1 /* 2 * C-Media CMI8788 driver - mixer code 3 * 4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de> 5 * 6 * 7 * This driver is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License, version 2. 9 * 10 * This driver is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this driver; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 */ 19 20 #include <linux/mutex.h> 21 #include <sound/ac97_codec.h> 22 #include <sound/asoundef.h> 23 #include <sound/control.h> 24 #include <sound/tlv.h> 25 #include "oxygen.h" 26 #include "cm9780.h" 27 28 static int dac_volume_info(struct snd_kcontrol *ctl, 29 struct snd_ctl_elem_info *info) 30 { 31 struct oxygen *chip = ctl->private_data; 32 33 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 34 info->count = chip->model.dac_channels_mixer; 35 info->value.integer.min = chip->model.dac_volume_min; 36 info->value.integer.max = chip->model.dac_volume_max; 37 return 0; 38 } 39 40 static int dac_volume_get(struct snd_kcontrol *ctl, 41 struct snd_ctl_elem_value *value) 42 { 43 struct oxygen *chip = ctl->private_data; 44 unsigned int i; 45 46 mutex_lock(&chip->mutex); 47 for (i = 0; i < chip->model.dac_channels_mixer; ++i) 48 value->value.integer.value[i] = chip->dac_volume[i]; 49 mutex_unlock(&chip->mutex); 50 return 0; 51 } 52 53 static int dac_volume_put(struct snd_kcontrol *ctl, 54 struct snd_ctl_elem_value *value) 55 { 56 struct oxygen *chip = ctl->private_data; 57 unsigned int i; 58 int changed; 59 60 changed = 0; 61 mutex_lock(&chip->mutex); 62 for (i = 0; i < chip->model.dac_channels_mixer; ++i) 63 if (value->value.integer.value[i] != chip->dac_volume[i]) { 64 chip->dac_volume[i] = value->value.integer.value[i]; 65 changed = 1; 66 } 67 if (changed) 68 chip->model.update_dac_volume(chip); 69 mutex_unlock(&chip->mutex); 70 return changed; 71 } 72 73 static int dac_mute_get(struct snd_kcontrol *ctl, 74 struct snd_ctl_elem_value *value) 75 { 76 struct oxygen *chip = ctl->private_data; 77 78 mutex_lock(&chip->mutex); 79 value->value.integer.value[0] = !chip->dac_mute; 80 mutex_unlock(&chip->mutex); 81 return 0; 82 } 83 84 static int dac_mute_put(struct snd_kcontrol *ctl, 85 struct snd_ctl_elem_value *value) 86 { 87 struct oxygen *chip = ctl->private_data; 88 int changed; 89 90 mutex_lock(&chip->mutex); 91 changed = !value->value.integer.value[0] != chip->dac_mute; 92 if (changed) { 93 chip->dac_mute = !value->value.integer.value[0]; 94 chip->model.update_dac_mute(chip); 95 } 96 mutex_unlock(&chip->mutex); 97 return changed; 98 } 99 100 static unsigned int upmix_item_count(struct oxygen *chip) 101 { 102 if (chip->model.dac_channels_pcm < 8) 103 return 2; 104 else if (chip->model.update_center_lfe_mix) 105 return 5; 106 else 107 return 3; 108 } 109 110 static int upmix_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info) 111 { 112 static const char *const names[5] = { 113 "Front", 114 "Front+Surround", 115 "Front+Surround+Back", 116 "Front+Surround+Center/LFE", 117 "Front+Surround+Center/LFE+Back", 118 }; 119 struct oxygen *chip = ctl->private_data; 120 unsigned int count = upmix_item_count(chip); 121 122 return snd_ctl_enum_info(info, 1, count, names); 123 } 124 125 static int upmix_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) 126 { 127 struct oxygen *chip = ctl->private_data; 128 129 mutex_lock(&chip->mutex); 130 value->value.enumerated.item[0] = chip->dac_routing; 131 mutex_unlock(&chip->mutex); 132 return 0; 133 } 134 135 void oxygen_update_dac_routing(struct oxygen *chip) 136 { 137 /* DAC 0: front, DAC 1: surround, DAC 2: center/LFE, DAC 3: back */ 138 static const unsigned int reg_values[5] = { 139 /* stereo -> front */ 140 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | 141 (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | 142 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | 143 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), 144 /* stereo -> front+surround */ 145 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | 146 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | 147 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | 148 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), 149 /* stereo -> front+surround+back */ 150 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | 151 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | 152 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | 153 (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), 154 /* stereo -> front+surround+center/LFE */ 155 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | 156 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | 157 (0 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | 158 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), 159 /* stereo -> front+surround+center/LFE+back */ 160 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | 161 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | 162 (0 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | 163 (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), 164 }; 165 u8 channels; 166 unsigned int reg_value; 167 168 channels = oxygen_read8(chip, OXYGEN_PLAY_CHANNELS) & 169 OXYGEN_PLAY_CHANNELS_MASK; 170 if (channels == OXYGEN_PLAY_CHANNELS_2) 171 reg_value = reg_values[chip->dac_routing]; 172 else if (channels == OXYGEN_PLAY_CHANNELS_8) 173 /* in 7.1 mode, "rear" channels go to the "back" jack */ 174 reg_value = (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | 175 (3 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | 176 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | 177 (1 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT); 178 else 179 reg_value = (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | 180 (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | 181 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | 182 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT); 183 if (chip->model.adjust_dac_routing) 184 reg_value = chip->model.adjust_dac_routing(chip, reg_value); 185 oxygen_write16_masked(chip, OXYGEN_PLAY_ROUTING, reg_value, 186 OXYGEN_PLAY_DAC0_SOURCE_MASK | 187 OXYGEN_PLAY_DAC1_SOURCE_MASK | 188 OXYGEN_PLAY_DAC2_SOURCE_MASK | 189 OXYGEN_PLAY_DAC3_SOURCE_MASK); 190 if (chip->model.update_center_lfe_mix) 191 chip->model.update_center_lfe_mix(chip, chip->dac_routing > 2); 192 } 193 194 static int upmix_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) 195 { 196 struct oxygen *chip = ctl->private_data; 197 unsigned int count = upmix_item_count(chip); 198 int changed; 199 200 if (value->value.enumerated.item[0] >= count) 201 return -EINVAL; 202 mutex_lock(&chip->mutex); 203 changed = value->value.enumerated.item[0] != chip->dac_routing; 204 if (changed) { 205 chip->dac_routing = value->value.enumerated.item[0]; 206 oxygen_update_dac_routing(chip); 207 } 208 mutex_unlock(&chip->mutex); 209 return changed; 210 } 211 212 static int spdif_switch_get(struct snd_kcontrol *ctl, 213 struct snd_ctl_elem_value *value) 214 { 215 struct oxygen *chip = ctl->private_data; 216 217 mutex_lock(&chip->mutex); 218 value->value.integer.value[0] = chip->spdif_playback_enable; 219 mutex_unlock(&chip->mutex); 220 return 0; 221 } 222 223 static unsigned int oxygen_spdif_rate(unsigned int oxygen_rate) 224 { 225 switch (oxygen_rate) { 226 case OXYGEN_RATE_32000: 227 return IEC958_AES3_CON_FS_32000 << OXYGEN_SPDIF_CS_RATE_SHIFT; 228 case OXYGEN_RATE_44100: 229 return IEC958_AES3_CON_FS_44100 << OXYGEN_SPDIF_CS_RATE_SHIFT; 230 default: /* OXYGEN_RATE_48000 */ 231 return IEC958_AES3_CON_FS_48000 << OXYGEN_SPDIF_CS_RATE_SHIFT; 232 case OXYGEN_RATE_64000: 233 return 0xb << OXYGEN_SPDIF_CS_RATE_SHIFT; 234 case OXYGEN_RATE_88200: 235 return IEC958_AES3_CON_FS_88200 << OXYGEN_SPDIF_CS_RATE_SHIFT; 236 case OXYGEN_RATE_96000: 237 return IEC958_AES3_CON_FS_96000 << OXYGEN_SPDIF_CS_RATE_SHIFT; 238 case OXYGEN_RATE_176400: 239 return IEC958_AES3_CON_FS_176400 << OXYGEN_SPDIF_CS_RATE_SHIFT; 240 case OXYGEN_RATE_192000: 241 return IEC958_AES3_CON_FS_192000 << OXYGEN_SPDIF_CS_RATE_SHIFT; 242 } 243 } 244 245 void oxygen_update_spdif_source(struct oxygen *chip) 246 { 247 u32 old_control, new_control; 248 u16 old_routing, new_routing; 249 unsigned int oxygen_rate; 250 251 old_control = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL); 252 old_routing = oxygen_read16(chip, OXYGEN_PLAY_ROUTING); 253 if (chip->pcm_active & (1 << PCM_SPDIF)) { 254 new_control = old_control | OXYGEN_SPDIF_OUT_ENABLE; 255 new_routing = (old_routing & ~OXYGEN_PLAY_SPDIF_MASK) 256 | OXYGEN_PLAY_SPDIF_SPDIF; 257 oxygen_rate = (old_control >> OXYGEN_SPDIF_OUT_RATE_SHIFT) 258 & OXYGEN_I2S_RATE_MASK; 259 /* S/PDIF rate was already set by the caller */ 260 } else if ((chip->pcm_active & (1 << PCM_MULTICH)) && 261 chip->spdif_playback_enable) { 262 new_routing = (old_routing & ~OXYGEN_PLAY_SPDIF_MASK) 263 | OXYGEN_PLAY_SPDIF_MULTICH_01; 264 oxygen_rate = oxygen_read16(chip, OXYGEN_I2S_MULTICH_FORMAT) 265 & OXYGEN_I2S_RATE_MASK; 266 new_control = (old_control & ~OXYGEN_SPDIF_OUT_RATE_MASK) | 267 (oxygen_rate << OXYGEN_SPDIF_OUT_RATE_SHIFT) | 268 OXYGEN_SPDIF_OUT_ENABLE; 269 } else { 270 new_control = old_control & ~OXYGEN_SPDIF_OUT_ENABLE; 271 new_routing = old_routing; 272 oxygen_rate = OXYGEN_RATE_44100; 273 } 274 if (old_routing != new_routing) { 275 oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, 276 new_control & ~OXYGEN_SPDIF_OUT_ENABLE); 277 oxygen_write16(chip, OXYGEN_PLAY_ROUTING, new_routing); 278 } 279 if (new_control & OXYGEN_SPDIF_OUT_ENABLE) 280 oxygen_write32(chip, OXYGEN_SPDIF_OUTPUT_BITS, 281 oxygen_spdif_rate(oxygen_rate) | 282 ((chip->pcm_active & (1 << PCM_SPDIF)) ? 283 chip->spdif_pcm_bits : chip->spdif_bits)); 284 oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, new_control); 285 } 286 287 static int spdif_switch_put(struct snd_kcontrol *ctl, 288 struct snd_ctl_elem_value *value) 289 { 290 struct oxygen *chip = ctl->private_data; 291 int changed; 292 293 mutex_lock(&chip->mutex); 294 changed = value->value.integer.value[0] != chip->spdif_playback_enable; 295 if (changed) { 296 chip->spdif_playback_enable = !!value->value.integer.value[0]; 297 spin_lock_irq(&chip->reg_lock); 298 oxygen_update_spdif_source(chip); 299 spin_unlock_irq(&chip->reg_lock); 300 } 301 mutex_unlock(&chip->mutex); 302 return changed; 303 } 304 305 static int spdif_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info) 306 { 307 info->type = SNDRV_CTL_ELEM_TYPE_IEC958; 308 info->count = 1; 309 return 0; 310 } 311 312 static void oxygen_to_iec958(u32 bits, struct snd_ctl_elem_value *value) 313 { 314 value->value.iec958.status[0] = 315 bits & (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C | 316 OXYGEN_SPDIF_PREEMPHASIS); 317 value->value.iec958.status[1] = /* category and original */ 318 bits >> OXYGEN_SPDIF_CATEGORY_SHIFT; 319 } 320 321 static u32 iec958_to_oxygen(struct snd_ctl_elem_value *value) 322 { 323 u32 bits; 324 325 bits = value->value.iec958.status[0] & 326 (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C | 327 OXYGEN_SPDIF_PREEMPHASIS); 328 bits |= value->value.iec958.status[1] << OXYGEN_SPDIF_CATEGORY_SHIFT; 329 if (bits & OXYGEN_SPDIF_NONAUDIO) 330 bits |= OXYGEN_SPDIF_V; 331 return bits; 332 } 333 334 static inline void write_spdif_bits(struct oxygen *chip, u32 bits) 335 { 336 oxygen_write32_masked(chip, OXYGEN_SPDIF_OUTPUT_BITS, bits, 337 OXYGEN_SPDIF_NONAUDIO | 338 OXYGEN_SPDIF_C | 339 OXYGEN_SPDIF_PREEMPHASIS | 340 OXYGEN_SPDIF_CATEGORY_MASK | 341 OXYGEN_SPDIF_ORIGINAL | 342 OXYGEN_SPDIF_V); 343 } 344 345 static int spdif_default_get(struct snd_kcontrol *ctl, 346 struct snd_ctl_elem_value *value) 347 { 348 struct oxygen *chip = ctl->private_data; 349 350 mutex_lock(&chip->mutex); 351 oxygen_to_iec958(chip->spdif_bits, value); 352 mutex_unlock(&chip->mutex); 353 return 0; 354 } 355 356 static int spdif_default_put(struct snd_kcontrol *ctl, 357 struct snd_ctl_elem_value *value) 358 { 359 struct oxygen *chip = ctl->private_data; 360 u32 new_bits; 361 int changed; 362 363 new_bits = iec958_to_oxygen(value); 364 mutex_lock(&chip->mutex); 365 changed = new_bits != chip->spdif_bits; 366 if (changed) { 367 chip->spdif_bits = new_bits; 368 if (!(chip->pcm_active & (1 << PCM_SPDIF))) 369 write_spdif_bits(chip, new_bits); 370 } 371 mutex_unlock(&chip->mutex); 372 return changed; 373 } 374 375 static int spdif_mask_get(struct snd_kcontrol *ctl, 376 struct snd_ctl_elem_value *value) 377 { 378 value->value.iec958.status[0] = IEC958_AES0_NONAUDIO | 379 IEC958_AES0_CON_NOT_COPYRIGHT | IEC958_AES0_CON_EMPHASIS; 380 value->value.iec958.status[1] = 381 IEC958_AES1_CON_CATEGORY | IEC958_AES1_CON_ORIGINAL; 382 return 0; 383 } 384 385 static int spdif_pcm_get(struct snd_kcontrol *ctl, 386 struct snd_ctl_elem_value *value) 387 { 388 struct oxygen *chip = ctl->private_data; 389 390 mutex_lock(&chip->mutex); 391 oxygen_to_iec958(chip->spdif_pcm_bits, value); 392 mutex_unlock(&chip->mutex); 393 return 0; 394 } 395 396 static int spdif_pcm_put(struct snd_kcontrol *ctl, 397 struct snd_ctl_elem_value *value) 398 { 399 struct oxygen *chip = ctl->private_data; 400 u32 new_bits; 401 int changed; 402 403 new_bits = iec958_to_oxygen(value); 404 mutex_lock(&chip->mutex); 405 changed = new_bits != chip->spdif_pcm_bits; 406 if (changed) { 407 chip->spdif_pcm_bits = new_bits; 408 if (chip->pcm_active & (1 << PCM_SPDIF)) 409 write_spdif_bits(chip, new_bits); 410 } 411 mutex_unlock(&chip->mutex); 412 return changed; 413 } 414 415 static int spdif_input_mask_get(struct snd_kcontrol *ctl, 416 struct snd_ctl_elem_value *value) 417 { 418 value->value.iec958.status[0] = 0xff; 419 value->value.iec958.status[1] = 0xff; 420 value->value.iec958.status[2] = 0xff; 421 value->value.iec958.status[3] = 0xff; 422 return 0; 423 } 424 425 static int spdif_input_default_get(struct snd_kcontrol *ctl, 426 struct snd_ctl_elem_value *value) 427 { 428 struct oxygen *chip = ctl->private_data; 429 u32 bits; 430 431 bits = oxygen_read32(chip, OXYGEN_SPDIF_INPUT_BITS); 432 value->value.iec958.status[0] = bits; 433 value->value.iec958.status[1] = bits >> 8; 434 value->value.iec958.status[2] = bits >> 16; 435 value->value.iec958.status[3] = bits >> 24; 436 return 0; 437 } 438 439 static int spdif_bit_switch_get(struct snd_kcontrol *ctl, 440 struct snd_ctl_elem_value *value) 441 { 442 struct oxygen *chip = ctl->private_data; 443 u32 bit = ctl->private_value; 444 445 value->value.integer.value[0] = 446 !!(oxygen_read32(chip, OXYGEN_SPDIF_CONTROL) & bit); 447 return 0; 448 } 449 450 static int spdif_bit_switch_put(struct snd_kcontrol *ctl, 451 struct snd_ctl_elem_value *value) 452 { 453 struct oxygen *chip = ctl->private_data; 454 u32 bit = ctl->private_value; 455 u32 oldreg, newreg; 456 int changed; 457 458 spin_lock_irq(&chip->reg_lock); 459 oldreg = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL); 460 if (value->value.integer.value[0]) 461 newreg = oldreg | bit; 462 else 463 newreg = oldreg & ~bit; 464 changed = newreg != oldreg; 465 if (changed) 466 oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, newreg); 467 spin_unlock_irq(&chip->reg_lock); 468 return changed; 469 } 470 471 static int monitor_volume_info(struct snd_kcontrol *ctl, 472 struct snd_ctl_elem_info *info) 473 { 474 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 475 info->count = 1; 476 info->value.integer.min = 0; 477 info->value.integer.max = 1; 478 return 0; 479 } 480 481 static int monitor_get(struct snd_kcontrol *ctl, 482 struct snd_ctl_elem_value *value) 483 { 484 struct oxygen *chip = ctl->private_data; 485 u8 bit = ctl->private_value; 486 int invert = ctl->private_value & (1 << 8); 487 488 value->value.integer.value[0] = 489 !!invert ^ !!(oxygen_read8(chip, OXYGEN_ADC_MONITOR) & bit); 490 return 0; 491 } 492 493 static int monitor_put(struct snd_kcontrol *ctl, 494 struct snd_ctl_elem_value *value) 495 { 496 struct oxygen *chip = ctl->private_data; 497 u8 bit = ctl->private_value; 498 int invert = ctl->private_value & (1 << 8); 499 u8 oldreg, newreg; 500 int changed; 501 502 spin_lock_irq(&chip->reg_lock); 503 oldreg = oxygen_read8(chip, OXYGEN_ADC_MONITOR); 504 if ((!!value->value.integer.value[0] ^ !!invert) != 0) 505 newreg = oldreg | bit; 506 else 507 newreg = oldreg & ~bit; 508 changed = newreg != oldreg; 509 if (changed) 510 oxygen_write8(chip, OXYGEN_ADC_MONITOR, newreg); 511 spin_unlock_irq(&chip->reg_lock); 512 return changed; 513 } 514 515 static int ac97_switch_get(struct snd_kcontrol *ctl, 516 struct snd_ctl_elem_value *value) 517 { 518 struct oxygen *chip = ctl->private_data; 519 unsigned int codec = (ctl->private_value >> 24) & 1; 520 unsigned int index = ctl->private_value & 0xff; 521 unsigned int bitnr = (ctl->private_value >> 8) & 0xff; 522 int invert = ctl->private_value & (1 << 16); 523 u16 reg; 524 525 mutex_lock(&chip->mutex); 526 reg = oxygen_read_ac97(chip, codec, index); 527 mutex_unlock(&chip->mutex); 528 if (!(reg & (1 << bitnr)) ^ !invert) 529 value->value.integer.value[0] = 1; 530 else 531 value->value.integer.value[0] = 0; 532 return 0; 533 } 534 535 static void mute_ac97_ctl(struct oxygen *chip, unsigned int control) 536 { 537 unsigned int priv_idx; 538 u16 value; 539 540 if (!chip->controls[control]) 541 return; 542 priv_idx = chip->controls[control]->private_value & 0xff; 543 value = oxygen_read_ac97(chip, 0, priv_idx); 544 if (!(value & 0x8000)) { 545 oxygen_write_ac97(chip, 0, priv_idx, value | 0x8000); 546 if (chip->model.ac97_switch) 547 chip->model.ac97_switch(chip, priv_idx, 0x8000); 548 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 549 &chip->controls[control]->id); 550 } 551 } 552 553 static int ac97_switch_put(struct snd_kcontrol *ctl, 554 struct snd_ctl_elem_value *value) 555 { 556 struct oxygen *chip = ctl->private_data; 557 unsigned int codec = (ctl->private_value >> 24) & 1; 558 unsigned int index = ctl->private_value & 0xff; 559 unsigned int bitnr = (ctl->private_value >> 8) & 0xff; 560 int invert = ctl->private_value & (1 << 16); 561 u16 oldreg, newreg; 562 int change; 563 564 mutex_lock(&chip->mutex); 565 oldreg = oxygen_read_ac97(chip, codec, index); 566 newreg = oldreg; 567 if (!value->value.integer.value[0] ^ !invert) 568 newreg |= 1 << bitnr; 569 else 570 newreg &= ~(1 << bitnr); 571 change = newreg != oldreg; 572 if (change) { 573 oxygen_write_ac97(chip, codec, index, newreg); 574 if (codec == 0 && chip->model.ac97_switch) 575 chip->model.ac97_switch(chip, index, newreg & 0x8000); 576 if (index == AC97_LINE) { 577 oxygen_write_ac97_masked(chip, 0, CM9780_GPIO_STATUS, 578 newreg & 0x8000 ? 579 CM9780_GPO0 : 0, CM9780_GPO0); 580 if (!(newreg & 0x8000)) { 581 mute_ac97_ctl(chip, CONTROL_MIC_CAPTURE_SWITCH); 582 mute_ac97_ctl(chip, CONTROL_CD_CAPTURE_SWITCH); 583 mute_ac97_ctl(chip, CONTROL_AUX_CAPTURE_SWITCH); 584 } 585 } else if ((index == AC97_MIC || index == AC97_CD || 586 index == AC97_VIDEO || index == AC97_AUX) && 587 bitnr == 15 && !(newreg & 0x8000)) { 588 mute_ac97_ctl(chip, CONTROL_LINE_CAPTURE_SWITCH); 589 oxygen_write_ac97_masked(chip, 0, CM9780_GPIO_STATUS, 590 CM9780_GPO0, CM9780_GPO0); 591 } 592 } 593 mutex_unlock(&chip->mutex); 594 return change; 595 } 596 597 static int ac97_volume_info(struct snd_kcontrol *ctl, 598 struct snd_ctl_elem_info *info) 599 { 600 int stereo = (ctl->private_value >> 16) & 1; 601 602 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 603 info->count = stereo ? 2 : 1; 604 info->value.integer.min = 0; 605 info->value.integer.max = 0x1f; 606 return 0; 607 } 608 609 static int ac97_volume_get(struct snd_kcontrol *ctl, 610 struct snd_ctl_elem_value *value) 611 { 612 struct oxygen *chip = ctl->private_data; 613 unsigned int codec = (ctl->private_value >> 24) & 1; 614 int stereo = (ctl->private_value >> 16) & 1; 615 unsigned int index = ctl->private_value & 0xff; 616 u16 reg; 617 618 mutex_lock(&chip->mutex); 619 reg = oxygen_read_ac97(chip, codec, index); 620 mutex_unlock(&chip->mutex); 621 value->value.integer.value[0] = 31 - (reg & 0x1f); 622 if (stereo) 623 value->value.integer.value[1] = 31 - ((reg >> 8) & 0x1f); 624 return 0; 625 } 626 627 static int ac97_volume_put(struct snd_kcontrol *ctl, 628 struct snd_ctl_elem_value *value) 629 { 630 struct oxygen *chip = ctl->private_data; 631 unsigned int codec = (ctl->private_value >> 24) & 1; 632 int stereo = (ctl->private_value >> 16) & 1; 633 unsigned int index = ctl->private_value & 0xff; 634 u16 oldreg, newreg; 635 int change; 636 637 mutex_lock(&chip->mutex); 638 oldreg = oxygen_read_ac97(chip, codec, index); 639 newreg = oldreg; 640 newreg = (newreg & ~0x1f) | 641 (31 - (value->value.integer.value[0] & 0x1f)); 642 if (stereo) 643 newreg = (newreg & ~0x1f00) | 644 ((31 - (value->value.integer.value[1] & 0x1f)) << 8); 645 else 646 newreg = (newreg & ~0x1f00) | ((newreg & 0x1f) << 8); 647 change = newreg != oldreg; 648 if (change) 649 oxygen_write_ac97(chip, codec, index, newreg); 650 mutex_unlock(&chip->mutex); 651 return change; 652 } 653 654 static int mic_fmic_source_info(struct snd_kcontrol *ctl, 655 struct snd_ctl_elem_info *info) 656 { 657 static const char *const names[] = { "Mic Jack", "Front Panel" }; 658 659 return snd_ctl_enum_info(info, 1, 2, names); 660 } 661 662 static int mic_fmic_source_get(struct snd_kcontrol *ctl, 663 struct snd_ctl_elem_value *value) 664 { 665 struct oxygen *chip = ctl->private_data; 666 667 mutex_lock(&chip->mutex); 668 value->value.enumerated.item[0] = 669 !!(oxygen_read_ac97(chip, 0, CM9780_JACK) & CM9780_FMIC2MIC); 670 mutex_unlock(&chip->mutex); 671 return 0; 672 } 673 674 static int mic_fmic_source_put(struct snd_kcontrol *ctl, 675 struct snd_ctl_elem_value *value) 676 { 677 struct oxygen *chip = ctl->private_data; 678 u16 oldreg, newreg; 679 int change; 680 681 mutex_lock(&chip->mutex); 682 oldreg = oxygen_read_ac97(chip, 0, CM9780_JACK); 683 if (value->value.enumerated.item[0]) 684 newreg = oldreg | CM9780_FMIC2MIC; 685 else 686 newreg = oldreg & ~CM9780_FMIC2MIC; 687 change = newreg != oldreg; 688 if (change) 689 oxygen_write_ac97(chip, 0, CM9780_JACK, newreg); 690 mutex_unlock(&chip->mutex); 691 return change; 692 } 693 694 static int ac97_fp_rec_volume_info(struct snd_kcontrol *ctl, 695 struct snd_ctl_elem_info *info) 696 { 697 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 698 info->count = 2; 699 info->value.integer.min = 0; 700 info->value.integer.max = 7; 701 return 0; 702 } 703 704 static int ac97_fp_rec_volume_get(struct snd_kcontrol *ctl, 705 struct snd_ctl_elem_value *value) 706 { 707 struct oxygen *chip = ctl->private_data; 708 u16 reg; 709 710 mutex_lock(&chip->mutex); 711 reg = oxygen_read_ac97(chip, 1, AC97_REC_GAIN); 712 mutex_unlock(&chip->mutex); 713 value->value.integer.value[0] = reg & 7; 714 value->value.integer.value[1] = (reg >> 8) & 7; 715 return 0; 716 } 717 718 static int ac97_fp_rec_volume_put(struct snd_kcontrol *ctl, 719 struct snd_ctl_elem_value *value) 720 { 721 struct oxygen *chip = ctl->private_data; 722 u16 oldreg, newreg; 723 int change; 724 725 mutex_lock(&chip->mutex); 726 oldreg = oxygen_read_ac97(chip, 1, AC97_REC_GAIN); 727 newreg = oldreg & ~0x0707; 728 newreg = newreg | (value->value.integer.value[0] & 7); 729 newreg = newreg | ((value->value.integer.value[0] & 7) << 8); 730 change = newreg != oldreg; 731 if (change) 732 oxygen_write_ac97(chip, 1, AC97_REC_GAIN, newreg); 733 mutex_unlock(&chip->mutex); 734 return change; 735 } 736 737 #define AC97_SWITCH(xname, codec, index, bitnr, invert) { \ 738 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 739 .name = xname, \ 740 .info = snd_ctl_boolean_mono_info, \ 741 .get = ac97_switch_get, \ 742 .put = ac97_switch_put, \ 743 .private_value = ((codec) << 24) | ((invert) << 16) | \ 744 ((bitnr) << 8) | (index), \ 745 } 746 #define AC97_VOLUME(xname, codec, index, stereo) { \ 747 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 748 .name = xname, \ 749 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 750 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \ 751 .info = ac97_volume_info, \ 752 .get = ac97_volume_get, \ 753 .put = ac97_volume_put, \ 754 .tlv = { .p = ac97_db_scale, }, \ 755 .private_value = ((codec) << 24) | ((stereo) << 16) | (index), \ 756 } 757 758 static DECLARE_TLV_DB_SCALE(monitor_db_scale, -600, 600, 0); 759 static DECLARE_TLV_DB_SCALE(ac97_db_scale, -3450, 150, 0); 760 static DECLARE_TLV_DB_SCALE(ac97_rec_db_scale, 0, 150, 0); 761 762 static const struct snd_kcontrol_new controls[] = { 763 { 764 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 765 .name = "Master Playback Volume", 766 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 767 .info = dac_volume_info, 768 .get = dac_volume_get, 769 .put = dac_volume_put, 770 }, 771 { 772 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 773 .name = "Master Playback Switch", 774 .info = snd_ctl_boolean_mono_info, 775 .get = dac_mute_get, 776 .put = dac_mute_put, 777 }, 778 { 779 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 780 .name = "Stereo Upmixing", 781 .info = upmix_info, 782 .get = upmix_get, 783 .put = upmix_put, 784 }, 785 { 786 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 787 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), 788 .info = snd_ctl_boolean_mono_info, 789 .get = spdif_switch_get, 790 .put = spdif_switch_put, 791 }, 792 { 793 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 794 .device = 1, 795 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), 796 .info = spdif_info, 797 .get = spdif_default_get, 798 .put = spdif_default_put, 799 }, 800 { 801 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 802 .device = 1, 803 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK), 804 .access = SNDRV_CTL_ELEM_ACCESS_READ, 805 .info = spdif_info, 806 .get = spdif_mask_get, 807 }, 808 { 809 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 810 .device = 1, 811 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM), 812 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 813 SNDRV_CTL_ELEM_ACCESS_INACTIVE, 814 .info = spdif_info, 815 .get = spdif_pcm_get, 816 .put = spdif_pcm_put, 817 }, 818 }; 819 820 static const struct snd_kcontrol_new spdif_input_controls[] = { 821 { 822 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 823 .device = 1, 824 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK), 825 .access = SNDRV_CTL_ELEM_ACCESS_READ, 826 .info = spdif_info, 827 .get = spdif_input_mask_get, 828 }, 829 { 830 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 831 .device = 1, 832 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT), 833 .access = SNDRV_CTL_ELEM_ACCESS_READ, 834 .info = spdif_info, 835 .get = spdif_input_default_get, 836 }, 837 { 838 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 839 .name = SNDRV_CTL_NAME_IEC958("Loopback ", NONE, SWITCH), 840 .info = snd_ctl_boolean_mono_info, 841 .get = spdif_bit_switch_get, 842 .put = spdif_bit_switch_put, 843 .private_value = OXYGEN_SPDIF_LOOPBACK, 844 }, 845 { 846 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 847 .name = SNDRV_CTL_NAME_IEC958("Validity Check ",CAPTURE,SWITCH), 848 .info = snd_ctl_boolean_mono_info, 849 .get = spdif_bit_switch_get, 850 .put = spdif_bit_switch_put, 851 .private_value = OXYGEN_SPDIF_SPDVALID, 852 }, 853 }; 854 855 static const struct { 856 unsigned int pcm_dev; 857 struct snd_kcontrol_new controls[2]; 858 } monitor_controls[] = { 859 { 860 .pcm_dev = CAPTURE_0_FROM_I2S_1, 861 .controls = { 862 { 863 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 864 .name = "Analog Input Monitor Playback Switch", 865 .info = snd_ctl_boolean_mono_info, 866 .get = monitor_get, 867 .put = monitor_put, 868 .private_value = OXYGEN_ADC_MONITOR_A, 869 }, 870 { 871 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 872 .name = "Analog Input Monitor Playback Volume", 873 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 874 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 875 .info = monitor_volume_info, 876 .get = monitor_get, 877 .put = monitor_put, 878 .private_value = OXYGEN_ADC_MONITOR_A_HALF_VOL 879 | (1 << 8), 880 .tlv = { .p = monitor_db_scale, }, 881 }, 882 }, 883 }, 884 { 885 .pcm_dev = CAPTURE_0_FROM_I2S_2, 886 .controls = { 887 { 888 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 889 .name = "Analog Input Monitor Playback Switch", 890 .info = snd_ctl_boolean_mono_info, 891 .get = monitor_get, 892 .put = monitor_put, 893 .private_value = OXYGEN_ADC_MONITOR_B, 894 }, 895 { 896 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 897 .name = "Analog Input Monitor Playback Volume", 898 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 899 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 900 .info = monitor_volume_info, 901 .get = monitor_get, 902 .put = monitor_put, 903 .private_value = OXYGEN_ADC_MONITOR_B_HALF_VOL 904 | (1 << 8), 905 .tlv = { .p = monitor_db_scale, }, 906 }, 907 }, 908 }, 909 { 910 .pcm_dev = CAPTURE_2_FROM_I2S_2, 911 .controls = { 912 { 913 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 914 .name = "Analog Input Monitor Playback Switch", 915 .index = 1, 916 .info = snd_ctl_boolean_mono_info, 917 .get = monitor_get, 918 .put = monitor_put, 919 .private_value = OXYGEN_ADC_MONITOR_B, 920 }, 921 { 922 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 923 .name = "Analog Input Monitor Playback Volume", 924 .index = 1, 925 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 926 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 927 .info = monitor_volume_info, 928 .get = monitor_get, 929 .put = monitor_put, 930 .private_value = OXYGEN_ADC_MONITOR_B_HALF_VOL 931 | (1 << 8), 932 .tlv = { .p = monitor_db_scale, }, 933 }, 934 }, 935 }, 936 { 937 .pcm_dev = CAPTURE_1_FROM_SPDIF, 938 .controls = { 939 { 940 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 941 .name = "Digital Input Monitor Playback Switch", 942 .info = snd_ctl_boolean_mono_info, 943 .get = monitor_get, 944 .put = monitor_put, 945 .private_value = OXYGEN_ADC_MONITOR_C, 946 }, 947 { 948 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 949 .name = "Digital Input Monitor Playback Volume", 950 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 951 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 952 .info = monitor_volume_info, 953 .get = monitor_get, 954 .put = monitor_put, 955 .private_value = OXYGEN_ADC_MONITOR_C_HALF_VOL 956 | (1 << 8), 957 .tlv = { .p = monitor_db_scale, }, 958 }, 959 }, 960 }, 961 }; 962 963 static const struct snd_kcontrol_new ac97_controls[] = { 964 AC97_VOLUME("Mic Capture Volume", 0, AC97_MIC, 0), 965 AC97_SWITCH("Mic Capture Switch", 0, AC97_MIC, 15, 1), 966 AC97_SWITCH("Mic Boost (+20dB)", 0, AC97_MIC, 6, 0), 967 { 968 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 969 .name = "Mic Source Capture Enum", 970 .info = mic_fmic_source_info, 971 .get = mic_fmic_source_get, 972 .put = mic_fmic_source_put, 973 }, 974 AC97_SWITCH("Line Capture Switch", 0, AC97_LINE, 15, 1), 975 AC97_VOLUME("CD Capture Volume", 0, AC97_CD, 1), 976 AC97_SWITCH("CD Capture Switch", 0, AC97_CD, 15, 1), 977 AC97_VOLUME("Aux Capture Volume", 0, AC97_AUX, 1), 978 AC97_SWITCH("Aux Capture Switch", 0, AC97_AUX, 15, 1), 979 }; 980 981 static const struct snd_kcontrol_new ac97_fp_controls[] = { 982 AC97_VOLUME("Front Panel Playback Volume", 1, AC97_HEADPHONE, 1), 983 AC97_SWITCH("Front Panel Playback Switch", 1, AC97_HEADPHONE, 15, 1), 984 { 985 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 986 .name = "Front Panel Capture Volume", 987 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 988 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 989 .info = ac97_fp_rec_volume_info, 990 .get = ac97_fp_rec_volume_get, 991 .put = ac97_fp_rec_volume_put, 992 .tlv = { .p = ac97_rec_db_scale, }, 993 }, 994 AC97_SWITCH("Front Panel Capture Switch", 1, AC97_REC_GAIN, 15, 1), 995 }; 996 997 static void oxygen_any_ctl_free(struct snd_kcontrol *ctl) 998 { 999 struct oxygen *chip = ctl->private_data; 1000 unsigned int i; 1001 1002 /* I'm too lazy to write a function for each control :-) */ 1003 for (i = 0; i < ARRAY_SIZE(chip->controls); ++i) 1004 chip->controls[i] = NULL; 1005 } 1006 1007 static int add_controls(struct oxygen *chip, 1008 const struct snd_kcontrol_new controls[], 1009 unsigned int count) 1010 { 1011 static const char *const known_ctl_names[CONTROL_COUNT] = { 1012 [CONTROL_SPDIF_PCM] = 1013 SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM), 1014 [CONTROL_SPDIF_INPUT_BITS] = 1015 SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT), 1016 [CONTROL_MIC_CAPTURE_SWITCH] = "Mic Capture Switch", 1017 [CONTROL_LINE_CAPTURE_SWITCH] = "Line Capture Switch", 1018 [CONTROL_CD_CAPTURE_SWITCH] = "CD Capture Switch", 1019 [CONTROL_AUX_CAPTURE_SWITCH] = "Aux Capture Switch", 1020 }; 1021 unsigned int i, j; 1022 struct snd_kcontrol_new template; 1023 struct snd_kcontrol *ctl; 1024 int err; 1025 1026 for (i = 0; i < count; ++i) { 1027 template = controls[i]; 1028 if (chip->model.control_filter) { 1029 err = chip->model.control_filter(&template); 1030 if (err < 0) 1031 return err; 1032 if (err == 1) 1033 continue; 1034 } 1035 if (!strcmp(template.name, "Stereo Upmixing") && 1036 chip->model.dac_channels_pcm == 2) 1037 continue; 1038 if (!strcmp(template.name, "Mic Source Capture Enum") && 1039 !(chip->model.device_config & AC97_FMIC_SWITCH)) 1040 continue; 1041 if (!strncmp(template.name, "CD Capture ", 11) && 1042 !(chip->model.device_config & AC97_CD_INPUT)) 1043 continue; 1044 if (!strcmp(template.name, "Master Playback Volume") && 1045 chip->model.dac_tlv) { 1046 template.tlv.p = chip->model.dac_tlv; 1047 template.access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; 1048 } 1049 ctl = snd_ctl_new1(&template, chip); 1050 if (!ctl) 1051 return -ENOMEM; 1052 err = snd_ctl_add(chip->card, ctl); 1053 if (err < 0) 1054 return err; 1055 for (j = 0; j < CONTROL_COUNT; ++j) 1056 if (!strcmp(ctl->id.name, known_ctl_names[j])) { 1057 chip->controls[j] = ctl; 1058 ctl->private_free = oxygen_any_ctl_free; 1059 } 1060 } 1061 return 0; 1062 } 1063 1064 int oxygen_mixer_init(struct oxygen *chip) 1065 { 1066 unsigned int i; 1067 int err; 1068 1069 err = add_controls(chip, controls, ARRAY_SIZE(controls)); 1070 if (err < 0) 1071 return err; 1072 if (chip->model.device_config & CAPTURE_1_FROM_SPDIF) { 1073 err = add_controls(chip, spdif_input_controls, 1074 ARRAY_SIZE(spdif_input_controls)); 1075 if (err < 0) 1076 return err; 1077 } 1078 for (i = 0; i < ARRAY_SIZE(monitor_controls); ++i) { 1079 if (!(chip->model.device_config & monitor_controls[i].pcm_dev)) 1080 continue; 1081 err = add_controls(chip, monitor_controls[i].controls, 1082 ARRAY_SIZE(monitor_controls[i].controls)); 1083 if (err < 0) 1084 return err; 1085 } 1086 if (chip->has_ac97_0) { 1087 err = add_controls(chip, ac97_controls, 1088 ARRAY_SIZE(ac97_controls)); 1089 if (err < 0) 1090 return err; 1091 } 1092 if (chip->has_ac97_1) { 1093 err = add_controls(chip, ac97_fp_controls, 1094 ARRAY_SIZE(ac97_fp_controls)); 1095 if (err < 0) 1096 return err; 1097 } 1098 return chip->model.mixer_init ? chip->model.mixer_init(chip) : 0; 1099 } 1100