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