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