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