1006 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Driver for Digigram VX soundcards4 *5 * Common mixer part6 *7 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>8 */9 10#include <sound/core.h>11#include <sound/control.h>12#include <sound/tlv.h>13#include <sound/vx_core.h>14#include "vx_cmd.h"15 16 17/*18 * write a codec data (24bit)19 */20static void vx_write_codec_reg(struct vx_core *chip, int codec, unsigned int data)21{22 if (snd_BUG_ON(!chip->ops->write_codec))23 return;24 25 if (chip->chip_status & VX_STAT_IS_STALE)26 return;27 28 mutex_lock(&chip->lock);29 chip->ops->write_codec(chip, codec, data);30 mutex_unlock(&chip->lock);31}32 33/*34 * Data type used to access the Codec35 */36union vx_codec_data {37 u32 l;38#ifdef SNDRV_BIG_ENDIAN39 struct w {40 u16 h;41 u16 l;42 } w;43 struct b {44 u8 hh;45 u8 mh;46 u8 ml;47 u8 ll;48 } b;49#else /* LITTLE_ENDIAN */50 struct w {51 u16 l;52 u16 h;53 } w;54 struct b {55 u8 ll;56 u8 ml;57 u8 mh;58 u8 hh;59 } b;60#endif61};62 63#define SET_CDC_DATA_SEL(di,s) ((di).b.mh = (u8) (s))64#define SET_CDC_DATA_REG(di,r) ((di).b.ml = (u8) (r))65#define SET_CDC_DATA_VAL(di,d) ((di).b.ll = (u8) (d))66#define SET_CDC_DATA_INIT(di) ((di).l = 0L, SET_CDC_DATA_SEL(di,XX_CODEC_SELECTOR))67 68/*69 * set up codec register and write the value70 * @codec: the codec id, 0 or 171 * @reg: register index72 * @val: data value73 */74static void vx_set_codec_reg(struct vx_core *chip, int codec, int reg, int val)75{76 union vx_codec_data data;77 /* DAC control register */78 SET_CDC_DATA_INIT(data);79 SET_CDC_DATA_REG(data, reg);80 SET_CDC_DATA_VAL(data, val);81 vx_write_codec_reg(chip, codec, data.l);82}83 84 85/*86 * vx_set_analog_output_level - set the output attenuation level87 * @codec: the output codec, 0 or 1. (1 for VXP440 only)88 * @left: left output level, 0 = mute89 * @right: right output level90 */91static void vx_set_analog_output_level(struct vx_core *chip, int codec, int left, int right)92{93 left = chip->hw->output_level_max - left;94 right = chip->hw->output_level_max - right;95 96 if (chip->ops->akm_write) {97 chip->ops->akm_write(chip, XX_CODEC_LEVEL_LEFT_REGISTER, left);98 chip->ops->akm_write(chip, XX_CODEC_LEVEL_RIGHT_REGISTER, right);99 } else {100 /* convert to attenuation level: 0 = 0dB (max), 0xe3 = -113.5 dB (min) */101 vx_set_codec_reg(chip, codec, XX_CODEC_LEVEL_LEFT_REGISTER, left);102 vx_set_codec_reg(chip, codec, XX_CODEC_LEVEL_RIGHT_REGISTER, right);103 }104}105 106 107/*108 * vx_toggle_dac_mute - mute/unmute DAC109 * @mute: 0 = unmute, 1 = mute110 */111 112#define DAC_ATTEN_MIN 0x08113#define DAC_ATTEN_MAX 0x38114 115void vx_toggle_dac_mute(struct vx_core *chip, int mute)116{117 unsigned int i;118 for (i = 0; i < chip->hw->num_codecs; i++) {119 if (chip->ops->akm_write)120 chip->ops->akm_write(chip, XX_CODEC_DAC_CONTROL_REGISTER, mute); /* XXX */121 else122 vx_set_codec_reg(chip, i, XX_CODEC_DAC_CONTROL_REGISTER,123 mute ? DAC_ATTEN_MAX : DAC_ATTEN_MIN);124 }125}126 127/*128 * vx_reset_codec - reset and initialize the codecs129 */130void vx_reset_codec(struct vx_core *chip, int cold_reset)131{132 unsigned int i;133 int port = chip->type >= VX_TYPE_VXPOCKET ? 0x75 : 0x65;134 135 chip->ops->reset_codec(chip);136 137 /* AKM codecs should be initialized in reset_codec callback */138 if (! chip->ops->akm_write) {139 /* initialize old codecs */140 for (i = 0; i < chip->hw->num_codecs; i++) {141 /* DAC control register (change level when zero crossing + mute) */142 vx_set_codec_reg(chip, i, XX_CODEC_DAC_CONTROL_REGISTER, DAC_ATTEN_MAX);143 /* ADC control register */144 vx_set_codec_reg(chip, i, XX_CODEC_ADC_CONTROL_REGISTER, 0x00);145 /* Port mode register */146 vx_set_codec_reg(chip, i, XX_CODEC_PORT_MODE_REGISTER, port);147 /* Clock control register */148 vx_set_codec_reg(chip, i, XX_CODEC_CLOCK_CONTROL_REGISTER, 0x00);149 }150 }151 152 /* mute analog output */153 for (i = 0; i < chip->hw->num_codecs; i++) {154 chip->output_level[i][0] = 0;155 chip->output_level[i][1] = 0;156 vx_set_analog_output_level(chip, i, 0, 0);157 }158}159 160/*161 * change the audio input source162 * @src: the target source (VX_AUDIO_SRC_XXX)163 */164static void vx_change_audio_source(struct vx_core *chip, int src)165{166 if (chip->chip_status & VX_STAT_IS_STALE)167 return;168 169 mutex_lock(&chip->lock);170 chip->ops->change_audio_source(chip, src);171 mutex_unlock(&chip->lock);172}173 174 175/*176 * change the audio source if necessary and possible177 * returns 1 if the source is actually changed.178 */179int vx_sync_audio_source(struct vx_core *chip)180{181 if (chip->audio_source_target == chip->audio_source ||182 chip->pcm_running)183 return 0;184 vx_change_audio_source(chip, chip->audio_source_target);185 chip->audio_source = chip->audio_source_target;186 return 1;187}188 189 190/*191 * audio level, mute, monitoring192 */193struct vx_audio_level {194 unsigned int has_level: 1;195 unsigned int has_monitor_level: 1;196 unsigned int has_mute: 1;197 unsigned int has_monitor_mute: 1;198 unsigned int mute;199 unsigned int monitor_mute;200 short level;201 short monitor_level;202};203 204static int vx_adjust_audio_level(struct vx_core *chip, int audio, int capture,205 struct vx_audio_level *info)206{207 struct vx_rmh rmh;208 209 if (chip->chip_status & VX_STAT_IS_STALE)210 return -EBUSY;211 212 vx_init_rmh(&rmh, CMD_AUDIO_LEVEL_ADJUST);213 if (capture)214 rmh.Cmd[0] |= COMMAND_RECORD_MASK;215 /* Add Audio IO mask */216 rmh.Cmd[1] = 1 << audio;217 rmh.Cmd[2] = 0;218 if (info->has_level) {219 rmh.Cmd[0] |= VALID_AUDIO_IO_DIGITAL_LEVEL;220 rmh.Cmd[2] |= info->level;221 }222 if (info->has_monitor_level) {223 rmh.Cmd[0] |= VALID_AUDIO_IO_MONITORING_LEVEL;224 rmh.Cmd[2] |= ((unsigned int)info->monitor_level << 10);225 }226 if (info->has_mute) { 227 rmh.Cmd[0] |= VALID_AUDIO_IO_MUTE_LEVEL;228 if (info->mute)229 rmh.Cmd[2] |= AUDIO_IO_HAS_MUTE_LEVEL;230 }231 if (info->has_monitor_mute) {232 /* validate flag for M2 at least to unmute it */ 233 rmh.Cmd[0] |= VALID_AUDIO_IO_MUTE_MONITORING_1 | VALID_AUDIO_IO_MUTE_MONITORING_2;234 if (info->monitor_mute)235 rmh.Cmd[2] |= AUDIO_IO_HAS_MUTE_MONITORING_1;236 }237 238 return vx_send_msg(chip, &rmh);239}240 241 242#if 0 // not used243static int vx_read_audio_level(struct vx_core *chip, int audio, int capture,244 struct vx_audio_level *info)245{246 int err;247 struct vx_rmh rmh;248 249 memset(info, 0, sizeof(*info));250 vx_init_rmh(&rmh, CMD_GET_AUDIO_LEVELS);251 if (capture)252 rmh.Cmd[0] |= COMMAND_RECORD_MASK;253 /* Add Audio IO mask */254 rmh.Cmd[1] = 1 << audio;255 err = vx_send_msg(chip, &rmh);256 if (err < 0)257 return err;258 info.level = rmh.Stat[0] & MASK_DSP_WORD_LEVEL;259 info.monitor_level = (rmh.Stat[0] >> 10) & MASK_DSP_WORD_LEVEL;260 info.mute = (rmh.Stat[i] & AUDIO_IO_HAS_MUTE_LEVEL) ? 1 : 0;261 info.monitor_mute = (rmh.Stat[i] & AUDIO_IO_HAS_MUTE_MONITORING_1) ? 1 : 0;262 return 0;263}264#endif // not used265 266/*267 * set the monitoring level and mute state of the given audio268 * no more static, because must be called from vx_pcm to demute monitoring269 */270int vx_set_monitor_level(struct vx_core *chip, int audio, int level, int active)271{272 struct vx_audio_level info;273 274 memset(&info, 0, sizeof(info));275 info.has_monitor_level = 1;276 info.monitor_level = level;277 info.has_monitor_mute = 1;278 info.monitor_mute = !active;279 chip->audio_monitor[audio] = level;280 chip->audio_monitor_active[audio] = active;281 return vx_adjust_audio_level(chip, audio, 0, &info); /* playback only */282}283 284 285/*286 * set the mute status of the given audio287 */288static int vx_set_audio_switch(struct vx_core *chip, int audio, int active)289{290 struct vx_audio_level info;291 292 memset(&info, 0, sizeof(info));293 info.has_mute = 1;294 info.mute = !active;295 chip->audio_active[audio] = active;296 return vx_adjust_audio_level(chip, audio, 0, &info); /* playback only */297}298 299/*300 * set the mute status of the given audio301 */302static int vx_set_audio_gain(struct vx_core *chip, int audio, int capture, int level)303{304 struct vx_audio_level info;305 306 memset(&info, 0, sizeof(info));307 info.has_level = 1;308 info.level = level;309 chip->audio_gain[capture][audio] = level;310 return vx_adjust_audio_level(chip, audio, capture, &info);311}312 313/*314 * reset all audio levels315 */316static void vx_reset_audio_levels(struct vx_core *chip)317{318 unsigned int i, c;319 struct vx_audio_level info;320 321 memset(chip->audio_gain, 0, sizeof(chip->audio_gain));322 memset(chip->audio_active, 0, sizeof(chip->audio_active));323 memset(chip->audio_monitor, 0, sizeof(chip->audio_monitor));324 memset(chip->audio_monitor_active, 0, sizeof(chip->audio_monitor_active));325 326 for (c = 0; c < 2; c++) {327 for (i = 0; i < chip->hw->num_ins * 2; i++) {328 memset(&info, 0, sizeof(info));329 if (c == 0) {330 info.has_monitor_level = 1;331 info.has_mute = 1;332 info.has_monitor_mute = 1;333 }334 info.has_level = 1;335 info.level = CVAL_0DB; /* default: 0dB */336 vx_adjust_audio_level(chip, i, c, &info);337 chip->audio_gain[c][i] = CVAL_0DB;338 chip->audio_monitor[i] = CVAL_0DB;339 }340 }341}342 343 344/*345 * VU, peak meter record346 */347 348#define VU_METER_CHANNELS 2349 350struct vx_vu_meter {351 int saturated;352 int vu_level;353 int peak_level;354};355 356/*357 * get the VU and peak meter values358 * @audio: the audio index359 * @capture: 0 = playback, 1 = capture operation360 * @info: the array of vx_vu_meter records (size = 2).361 */362static int vx_get_audio_vu_meter(struct vx_core *chip, int audio, int capture, struct vx_vu_meter *info)363{364 struct vx_rmh rmh;365 int i, err;366 367 if (chip->chip_status & VX_STAT_IS_STALE)368 return -EBUSY;369 370 vx_init_rmh(&rmh, CMD_AUDIO_VU_PIC_METER);371 rmh.LgStat += 2 * VU_METER_CHANNELS;372 if (capture)373 rmh.Cmd[0] |= COMMAND_RECORD_MASK;374 375 /* Add Audio IO mask */376 rmh.Cmd[1] = 0;377 for (i = 0; i < VU_METER_CHANNELS; i++)378 rmh.Cmd[1] |= 1 << (audio + i);379 err = vx_send_msg(chip, &rmh);380 if (err < 0)381 return err;382 /* Read response */383 for (i = 0; i < 2 * VU_METER_CHANNELS; i +=2) {384 info->saturated = (rmh.Stat[0] & (1 << (audio + i))) ? 1 : 0;385 info->vu_level = rmh.Stat[i + 1];386 info->peak_level = rmh.Stat[i + 2];387 info++;388 }389 return 0;390}391 392 393/*394 * control API entries395 */396 397/*398 * output level control399 */400static int vx_output_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)401{402 struct vx_core *chip = snd_kcontrol_chip(kcontrol);403 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;404 uinfo->count = 2;405 uinfo->value.integer.min = 0;406 uinfo->value.integer.max = chip->hw->output_level_max;407 return 0;408}409 410static int vx_output_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)411{412 struct vx_core *chip = snd_kcontrol_chip(kcontrol);413 int codec = kcontrol->id.index;414 mutex_lock(&chip->mixer_mutex);415 ucontrol->value.integer.value[0] = chip->output_level[codec][0];416 ucontrol->value.integer.value[1] = chip->output_level[codec][1];417 mutex_unlock(&chip->mixer_mutex);418 return 0;419}420 421static int vx_output_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)422{423 struct vx_core *chip = snd_kcontrol_chip(kcontrol);424 int codec = kcontrol->id.index;425 unsigned int val[2], vmax;426 427 vmax = chip->hw->output_level_max;428 val[0] = ucontrol->value.integer.value[0];429 val[1] = ucontrol->value.integer.value[1];430 if (val[0] > vmax || val[1] > vmax)431 return -EINVAL;432 mutex_lock(&chip->mixer_mutex);433 if (val[0] != chip->output_level[codec][0] ||434 val[1] != chip->output_level[codec][1]) {435 vx_set_analog_output_level(chip, codec, val[0], val[1]);436 chip->output_level[codec][0] = val[0];437 chip->output_level[codec][1] = val[1];438 mutex_unlock(&chip->mixer_mutex);439 return 1;440 }441 mutex_unlock(&chip->mixer_mutex);442 return 0;443}444 445static const struct snd_kcontrol_new vx_control_output_level = {446 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,447 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |448 SNDRV_CTL_ELEM_ACCESS_TLV_READ),449 .name = "Master Playback Volume",450 .info = vx_output_level_info,451 .get = vx_output_level_get,452 .put = vx_output_level_put,453 /* tlv will be filled later */454};455 456/*457 * audio source select458 */459static int vx_audio_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)460{461 static const char * const texts_mic[3] = {462 "Digital", "Line", "Mic"463 };464 static const char * const texts_vx2[2] = {465 "Digital", "Analog"466 };467 struct vx_core *chip = snd_kcontrol_chip(kcontrol);468 469 if (chip->type >= VX_TYPE_VXPOCKET)470 return snd_ctl_enum_info(uinfo, 1, 3, texts_mic);471 else472 return snd_ctl_enum_info(uinfo, 1, 2, texts_vx2);473}474 475static int vx_audio_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)476{477 struct vx_core *chip = snd_kcontrol_chip(kcontrol);478 ucontrol->value.enumerated.item[0] = chip->audio_source_target;479 return 0;480}481 482static int vx_audio_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)483{484 struct vx_core *chip = snd_kcontrol_chip(kcontrol);485 486 if (chip->type >= VX_TYPE_VXPOCKET) {487 if (ucontrol->value.enumerated.item[0] > 2)488 return -EINVAL;489 } else {490 if (ucontrol->value.enumerated.item[0] > 1)491 return -EINVAL;492 }493 mutex_lock(&chip->mixer_mutex);494 if (chip->audio_source_target != ucontrol->value.enumerated.item[0]) {495 chip->audio_source_target = ucontrol->value.enumerated.item[0];496 vx_sync_audio_source(chip);497 mutex_unlock(&chip->mixer_mutex);498 return 1;499 }500 mutex_unlock(&chip->mixer_mutex);501 return 0;502}503 504static const struct snd_kcontrol_new vx_control_audio_src = {505 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,506 .name = "Capture Source",507 .info = vx_audio_src_info,508 .get = vx_audio_src_get,509 .put = vx_audio_src_put,510};511 512/*513 * clock mode selection514 */515static int vx_clock_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)516{517 static const char * const texts[3] = {518 "Auto", "Internal", "External"519 };520 521 return snd_ctl_enum_info(uinfo, 1, 3, texts);522}523 524static int vx_clock_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)525{526 struct vx_core *chip = snd_kcontrol_chip(kcontrol);527 ucontrol->value.enumerated.item[0] = chip->clock_mode;528 return 0;529}530 531static int vx_clock_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)532{533 struct vx_core *chip = snd_kcontrol_chip(kcontrol);534 535 if (ucontrol->value.enumerated.item[0] > 2)536 return -EINVAL;537 mutex_lock(&chip->mixer_mutex);538 if (chip->clock_mode != ucontrol->value.enumerated.item[0]) {539 chip->clock_mode = ucontrol->value.enumerated.item[0];540 vx_set_clock(chip, chip->freq);541 mutex_unlock(&chip->mixer_mutex);542 return 1;543 }544 mutex_unlock(&chip->mixer_mutex);545 return 0;546}547 548static const struct snd_kcontrol_new vx_control_clock_mode = {549 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,550 .name = "Clock Mode",551 .info = vx_clock_mode_info,552 .get = vx_clock_mode_get,553 .put = vx_clock_mode_put,554};555 556/*557 * Audio Gain558 */559static int vx_audio_gain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)560{561 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;562 uinfo->count = 2;563 uinfo->value.integer.min = 0;564 uinfo->value.integer.max = CVAL_MAX;565 return 0;566}567 568static int vx_audio_gain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)569{570 struct vx_core *chip = snd_kcontrol_chip(kcontrol);571 int audio = kcontrol->private_value & 0xff;572 int capture = (kcontrol->private_value >> 8) & 1;573 574 mutex_lock(&chip->mixer_mutex);575 ucontrol->value.integer.value[0] = chip->audio_gain[capture][audio];576 ucontrol->value.integer.value[1] = chip->audio_gain[capture][audio+1];577 mutex_unlock(&chip->mixer_mutex);578 return 0;579}580 581static int vx_audio_gain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)582{583 struct vx_core *chip = snd_kcontrol_chip(kcontrol);584 int audio = kcontrol->private_value & 0xff;585 int capture = (kcontrol->private_value >> 8) & 1;586 unsigned int val[2];587 588 val[0] = ucontrol->value.integer.value[0];589 val[1] = ucontrol->value.integer.value[1];590 if (val[0] > CVAL_MAX || val[1] > CVAL_MAX)591 return -EINVAL;592 mutex_lock(&chip->mixer_mutex);593 if (val[0] != chip->audio_gain[capture][audio] ||594 val[1] != chip->audio_gain[capture][audio+1]) {595 vx_set_audio_gain(chip, audio, capture, val[0]);596 vx_set_audio_gain(chip, audio+1, capture, val[1]);597 mutex_unlock(&chip->mixer_mutex);598 return 1;599 }600 mutex_unlock(&chip->mixer_mutex);601 return 0;602}603 604static int vx_audio_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)605{606 struct vx_core *chip = snd_kcontrol_chip(kcontrol);607 int audio = kcontrol->private_value & 0xff;608 609 mutex_lock(&chip->mixer_mutex);610 ucontrol->value.integer.value[0] = chip->audio_monitor[audio];611 ucontrol->value.integer.value[1] = chip->audio_monitor[audio+1];612 mutex_unlock(&chip->mixer_mutex);613 return 0;614}615 616static int vx_audio_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)617{618 struct vx_core *chip = snd_kcontrol_chip(kcontrol);619 int audio = kcontrol->private_value & 0xff;620 unsigned int val[2];621 622 val[0] = ucontrol->value.integer.value[0];623 val[1] = ucontrol->value.integer.value[1];624 if (val[0] > CVAL_MAX || val[1] > CVAL_MAX)625 return -EINVAL;626 627 mutex_lock(&chip->mixer_mutex);628 if (val[0] != chip->audio_monitor[audio] ||629 val[1] != chip->audio_monitor[audio+1]) {630 vx_set_monitor_level(chip, audio, val[0],631 chip->audio_monitor_active[audio]);632 vx_set_monitor_level(chip, audio+1, val[1],633 chip->audio_monitor_active[audio+1]);634 mutex_unlock(&chip->mixer_mutex);635 return 1;636 }637 mutex_unlock(&chip->mixer_mutex);638 return 0;639}640 641#define vx_audio_sw_info snd_ctl_boolean_stereo_info642 643static int vx_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)644{645 struct vx_core *chip = snd_kcontrol_chip(kcontrol);646 int audio = kcontrol->private_value & 0xff;647 648 mutex_lock(&chip->mixer_mutex);649 ucontrol->value.integer.value[0] = chip->audio_active[audio];650 ucontrol->value.integer.value[1] = chip->audio_active[audio+1];651 mutex_unlock(&chip->mixer_mutex);652 return 0;653}654 655static int vx_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)656{657 struct vx_core *chip = snd_kcontrol_chip(kcontrol);658 int audio = kcontrol->private_value & 0xff;659 660 mutex_lock(&chip->mixer_mutex);661 if (ucontrol->value.integer.value[0] != chip->audio_active[audio] ||662 ucontrol->value.integer.value[1] != chip->audio_active[audio+1]) {663 vx_set_audio_switch(chip, audio,664 !!ucontrol->value.integer.value[0]);665 vx_set_audio_switch(chip, audio+1,666 !!ucontrol->value.integer.value[1]);667 mutex_unlock(&chip->mixer_mutex);668 return 1;669 }670 mutex_unlock(&chip->mixer_mutex);671 return 0;672}673 674static int vx_monitor_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)675{676 struct vx_core *chip = snd_kcontrol_chip(kcontrol);677 int audio = kcontrol->private_value & 0xff;678 679 mutex_lock(&chip->mixer_mutex);680 ucontrol->value.integer.value[0] = chip->audio_monitor_active[audio];681 ucontrol->value.integer.value[1] = chip->audio_monitor_active[audio+1];682 mutex_unlock(&chip->mixer_mutex);683 return 0;684}685 686static int vx_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)687{688 struct vx_core *chip = snd_kcontrol_chip(kcontrol);689 int audio = kcontrol->private_value & 0xff;690 691 mutex_lock(&chip->mixer_mutex);692 if (ucontrol->value.integer.value[0] != chip->audio_monitor_active[audio] ||693 ucontrol->value.integer.value[1] != chip->audio_monitor_active[audio+1]) {694 vx_set_monitor_level(chip, audio, chip->audio_monitor[audio],695 !!ucontrol->value.integer.value[0]);696 vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1],697 !!ucontrol->value.integer.value[1]);698 mutex_unlock(&chip->mixer_mutex);699 return 1;700 }701 mutex_unlock(&chip->mixer_mutex);702 return 0;703}704 705static const DECLARE_TLV_DB_SCALE(db_scale_audio_gain, -10975, 25, 0);706 707static const struct snd_kcontrol_new vx_control_audio_gain = {708 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,709 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |710 SNDRV_CTL_ELEM_ACCESS_TLV_READ),711 /* name will be filled later */712 .info = vx_audio_gain_info,713 .get = vx_audio_gain_get,714 .put = vx_audio_gain_put,715 .tlv = { .p = db_scale_audio_gain },716};717static const struct snd_kcontrol_new vx_control_output_switch = {718 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,719 .name = "PCM Playback Switch",720 .info = vx_audio_sw_info,721 .get = vx_audio_sw_get,722 .put = vx_audio_sw_put723};724static const struct snd_kcontrol_new vx_control_monitor_gain = {725 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,726 .name = "Monitoring Volume",727 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |728 SNDRV_CTL_ELEM_ACCESS_TLV_READ),729 .info = vx_audio_gain_info, /* shared */730 .get = vx_audio_monitor_get,731 .put = vx_audio_monitor_put,732 .tlv = { .p = db_scale_audio_gain },733};734static const struct snd_kcontrol_new vx_control_monitor_switch = {735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,736 .name = "Monitoring Switch",737 .info = vx_audio_sw_info, /* shared */738 .get = vx_monitor_sw_get,739 .put = vx_monitor_sw_put740};741 742 743/*744 * IEC958 status bits745 */746static int vx_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)747{748 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;749 uinfo->count = 1;750 return 0;751}752 753static int vx_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)754{755 struct vx_core *chip = snd_kcontrol_chip(kcontrol);756 757 mutex_lock(&chip->mixer_mutex);758 ucontrol->value.iec958.status[0] = (chip->uer_bits >> 0) & 0xff;759 ucontrol->value.iec958.status[1] = (chip->uer_bits >> 8) & 0xff;760 ucontrol->value.iec958.status[2] = (chip->uer_bits >> 16) & 0xff;761 ucontrol->value.iec958.status[3] = (chip->uer_bits >> 24) & 0xff;762 mutex_unlock(&chip->mixer_mutex);763 return 0;764}765 766static int vx_iec958_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)767{768 ucontrol->value.iec958.status[0] = 0xff;769 ucontrol->value.iec958.status[1] = 0xff;770 ucontrol->value.iec958.status[2] = 0xff;771 ucontrol->value.iec958.status[3] = 0xff;772 return 0;773}774 775static int vx_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)776{777 struct vx_core *chip = snd_kcontrol_chip(kcontrol);778 unsigned int val;779 780 val = (ucontrol->value.iec958.status[0] << 0) |781 (ucontrol->value.iec958.status[1] << 8) |782 (ucontrol->value.iec958.status[2] << 16) |783 (ucontrol->value.iec958.status[3] << 24);784 mutex_lock(&chip->mixer_mutex);785 if (chip->uer_bits != val) {786 chip->uer_bits = val;787 vx_set_iec958_status(chip, val);788 mutex_unlock(&chip->mixer_mutex);789 return 1;790 }791 mutex_unlock(&chip->mixer_mutex);792 return 0;793}794 795static const struct snd_kcontrol_new vx_control_iec958_mask = {796 .access = SNDRV_CTL_ELEM_ACCESS_READ,797 .iface = SNDRV_CTL_ELEM_IFACE_PCM,798 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),799 .info = vx_iec958_info, /* shared */800 .get = vx_iec958_mask_get,801};802 803static const struct snd_kcontrol_new vx_control_iec958 = {804 .iface = SNDRV_CTL_ELEM_IFACE_PCM,805 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),806 .info = vx_iec958_info,807 .get = vx_iec958_get,808 .put = vx_iec958_put809};810 811 812/*813 * VU meter814 */815 816#define METER_MAX 0xff817#define METER_SHIFT 16818 819static int vx_vu_meter_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)820{821 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;822 uinfo->count = 2;823 uinfo->value.integer.min = 0;824 uinfo->value.integer.max = METER_MAX;825 return 0;826}827 828static int vx_vu_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)829{830 struct vx_core *chip = snd_kcontrol_chip(kcontrol);831 struct vx_vu_meter meter[2];832 int audio = kcontrol->private_value & 0xff;833 int capture = (kcontrol->private_value >> 8) & 1;834 835 vx_get_audio_vu_meter(chip, audio, capture, meter);836 ucontrol->value.integer.value[0] = meter[0].vu_level >> METER_SHIFT;837 ucontrol->value.integer.value[1] = meter[1].vu_level >> METER_SHIFT;838 return 0;839}840 841static int vx_peak_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)842{843 struct vx_core *chip = snd_kcontrol_chip(kcontrol);844 struct vx_vu_meter meter[2];845 int audio = kcontrol->private_value & 0xff;846 int capture = (kcontrol->private_value >> 8) & 1;847 848 vx_get_audio_vu_meter(chip, audio, capture, meter);849 ucontrol->value.integer.value[0] = meter[0].peak_level >> METER_SHIFT;850 ucontrol->value.integer.value[1] = meter[1].peak_level >> METER_SHIFT;851 return 0;852}853 854#define vx_saturation_info snd_ctl_boolean_stereo_info855 856static int vx_saturation_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)857{858 struct vx_core *chip = snd_kcontrol_chip(kcontrol);859 struct vx_vu_meter meter[2];860 int audio = kcontrol->private_value & 0xff;861 862 vx_get_audio_vu_meter(chip, audio, 1, meter); /* capture only */863 ucontrol->value.integer.value[0] = meter[0].saturated;864 ucontrol->value.integer.value[1] = meter[1].saturated;865 return 0;866}867 868static const struct snd_kcontrol_new vx_control_vu_meter = {869 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,870 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,871 /* name will be filled later */872 .info = vx_vu_meter_info,873 .get = vx_vu_meter_get,874};875 876static const struct snd_kcontrol_new vx_control_peak_meter = {877 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,878 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,879 /* name will be filled later */880 .info = vx_vu_meter_info, /* shared */881 .get = vx_peak_meter_get,882};883 884static const struct snd_kcontrol_new vx_control_saturation = {885 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,886 .name = "Input Saturation",887 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,888 .info = vx_saturation_info,889 .get = vx_saturation_get,890};891 892 893 894/*895 *896 */897 898int snd_vx_mixer_new(struct vx_core *chip)899{900 unsigned int i, c;901 int err;902 struct snd_kcontrol_new temp;903 struct snd_card *card = chip->card;904 char name[32];905 906 strcpy(card->mixername, card->driver);907 908 /* output level controls */909 for (i = 0; i < chip->hw->num_outs; i++) {910 temp = vx_control_output_level;911 temp.index = i;912 temp.tlv.p = chip->hw->output_level_db_scale;913 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));914 if (err < 0)915 return err;916 }917 918 /* PCM volumes, switches, monitoring */919 for (i = 0; i < chip->hw->num_outs; i++) {920 int val = i * 2;921 temp = vx_control_audio_gain;922 temp.index = i;923 temp.name = "PCM Playback Volume";924 temp.private_value = val;925 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));926 if (err < 0)927 return err;928 temp = vx_control_output_switch;929 temp.index = i;930 temp.private_value = val;931 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));932 if (err < 0)933 return err;934 temp = vx_control_monitor_gain;935 temp.index = i;936 temp.private_value = val;937 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));938 if (err < 0)939 return err;940 temp = vx_control_monitor_switch;941 temp.index = i;942 temp.private_value = val;943 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));944 if (err < 0)945 return err;946 }947 for (i = 0; i < chip->hw->num_outs; i++) {948 temp = vx_control_audio_gain;949 temp.index = i;950 temp.name = "PCM Capture Volume";951 temp.private_value = (i * 2) | (1 << 8);952 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));953 if (err < 0)954 return err;955 }956 957 /* Audio source */958 err = snd_ctl_add(card, snd_ctl_new1(&vx_control_audio_src, chip));959 if (err < 0)960 return err;961 /* clock mode */962 err = snd_ctl_add(card, snd_ctl_new1(&vx_control_clock_mode, chip));963 if (err < 0)964 return err;965 /* IEC958 controls */966 err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958_mask, chip));967 if (err < 0)968 return err;969 err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958, chip));970 if (err < 0)971 return err;972 /* VU, peak, saturation meters */973 for (c = 0; c < 2; c++) {974 static const char * const dir[2] = { "Output", "Input" };975 for (i = 0; i < chip->hw->num_ins; i++) {976 int val = (i * 2) | (c << 8);977 if (c == 1) {978 temp = vx_control_saturation;979 temp.index = i;980 temp.private_value = val;981 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));982 if (err < 0)983 return err;984 }985 sprintf(name, "%s VU Meter", dir[c]);986 temp = vx_control_vu_meter;987 temp.index = i;988 temp.name = name;989 temp.private_value = val;990 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));991 if (err < 0)992 return err;993 sprintf(name, "%s Peak Meter", dir[c]);994 temp = vx_control_peak_meter;995 temp.index = i;996 temp.name = name;997 temp.private_value = val;998 err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));999 if (err < 0)1000 return err;1001 }1002 }1003 vx_reset_audio_levels(chip);1004 return 0;1005}1006