1 /* 2 * card driver for models with WM8776/WM8766 DACs (Xonar DS/HDAV1.3 Slim) 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, see <http://www.gnu.org/licenses/>. 17 */ 18 19 /* 20 * Xonar DS 21 * -------- 22 * 23 * CMI8788: 24 * 25 * SPI 0 -> WM8766 (surround, center/LFE, back) 26 * SPI 1 -> WM8776 (front, input) 27 * 28 * GPIO 4 <- headphone detect, 0 = plugged 29 * GPIO 6 -> route input jack to mic-in (0) or line-in (1) 30 * GPIO 7 -> enable output to front L/R speaker channels 31 * GPIO 8 -> enable output to other speaker channels and front panel headphone 32 * 33 * WM8776: 34 * 35 * input 1 <- line 36 * input 2 <- mic 37 * input 3 <- front mic 38 * input 4 <- aux 39 */ 40 41 /* 42 * Xonar HDAV1.3 Slim 43 * ------------------ 44 * 45 * CMI8788: 46 * 47 * I²C <-> WM8776 (addr 0011010) 48 * 49 * GPIO 0 -> disable HDMI output 50 * GPIO 1 -> enable HP output 51 * GPIO 6 -> firmware EEPROM I²C clock 52 * GPIO 7 <-> firmware EEPROM I²C data 53 * 54 * UART <-> HDMI controller 55 * 56 * WM8776: 57 * 58 * input 1 <- mic 59 * input 2 <- aux 60 */ 61 62 #include <linux/pci.h> 63 #include <linux/delay.h> 64 #include <sound/control.h> 65 #include <sound/core.h> 66 #include <sound/info.h> 67 #include <sound/jack.h> 68 #include <sound/pcm.h> 69 #include <sound/pcm_params.h> 70 #include <sound/tlv.h> 71 #include "xonar.h" 72 #include "wm8776.h" 73 #include "wm8766.h" 74 75 #define GPIO_DS_HP_DETECT 0x0010 76 #define GPIO_DS_INPUT_ROUTE 0x0040 77 #define GPIO_DS_OUTPUT_FRONTLR 0x0080 78 #define GPIO_DS_OUTPUT_ENABLE 0x0100 79 80 #define GPIO_SLIM_HDMI_DISABLE 0x0001 81 #define GPIO_SLIM_OUTPUT_ENABLE 0x0002 82 #define GPIO_SLIM_FIRMWARE_CLK 0x0040 83 #define GPIO_SLIM_FIRMWARE_DATA 0x0080 84 85 #define I2C_DEVICE_WM8776 0x34 /* 001101, 0, /W=0 */ 86 87 #define LC_CONTROL_LIMITER 0x40000000 88 #define LC_CONTROL_ALC 0x20000000 89 90 struct xonar_wm87x6 { 91 struct xonar_generic generic; 92 u16 wm8776_regs[0x17]; 93 u16 wm8766_regs[0x10]; 94 struct snd_kcontrol *line_adcmux_control; 95 struct snd_kcontrol *mic_adcmux_control; 96 struct snd_kcontrol *lc_controls[13]; 97 struct snd_jack *hp_jack; 98 struct xonar_hdmi hdmi; 99 }; 100 101 static void wm8776_write_spi(struct oxygen *chip, 102 unsigned int reg, unsigned int value) 103 { 104 oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | 105 OXYGEN_SPI_DATA_LENGTH_2 | 106 OXYGEN_SPI_CLOCK_160 | 107 (1 << OXYGEN_SPI_CODEC_SHIFT) | 108 OXYGEN_SPI_CEN_LATCH_CLOCK_LO, 109 (reg << 9) | value); 110 } 111 112 static void wm8776_write_i2c(struct oxygen *chip, 113 unsigned int reg, unsigned int value) 114 { 115 oxygen_write_i2c(chip, I2C_DEVICE_WM8776, 116 (reg << 1) | (value >> 8), value); 117 } 118 119 static void wm8776_write(struct oxygen *chip, 120 unsigned int reg, unsigned int value) 121 { 122 struct xonar_wm87x6 *data = chip->model_data; 123 124 if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) == 125 OXYGEN_FUNCTION_SPI) 126 wm8776_write_spi(chip, reg, value); 127 else 128 wm8776_write_i2c(chip, reg, value); 129 if (reg < ARRAY_SIZE(data->wm8776_regs)) { 130 if (reg >= WM8776_HPLVOL && reg <= WM8776_DACMASTER) 131 value &= ~WM8776_UPDATE; 132 data->wm8776_regs[reg] = value; 133 } 134 } 135 136 static void wm8776_write_cached(struct oxygen *chip, 137 unsigned int reg, unsigned int value) 138 { 139 struct xonar_wm87x6 *data = chip->model_data; 140 141 if (reg >= ARRAY_SIZE(data->wm8776_regs) || 142 value != data->wm8776_regs[reg]) 143 wm8776_write(chip, reg, value); 144 } 145 146 static void wm8766_write(struct oxygen *chip, 147 unsigned int reg, unsigned int value) 148 { 149 struct xonar_wm87x6 *data = chip->model_data; 150 151 oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | 152 OXYGEN_SPI_DATA_LENGTH_2 | 153 OXYGEN_SPI_CLOCK_160 | 154 (0 << OXYGEN_SPI_CODEC_SHIFT) | 155 OXYGEN_SPI_CEN_LATCH_CLOCK_LO, 156 (reg << 9) | value); 157 if (reg < ARRAY_SIZE(data->wm8766_regs)) { 158 if ((reg >= WM8766_LDA1 && reg <= WM8766_RDA1) || 159 (reg >= WM8766_LDA2 && reg <= WM8766_MASTDA)) 160 value &= ~WM8766_UPDATE; 161 data->wm8766_regs[reg] = value; 162 } 163 } 164 165 static void wm8766_write_cached(struct oxygen *chip, 166 unsigned int reg, unsigned int value) 167 { 168 struct xonar_wm87x6 *data = chip->model_data; 169 170 if (reg >= ARRAY_SIZE(data->wm8766_regs) || 171 value != data->wm8766_regs[reg]) 172 wm8766_write(chip, reg, value); 173 } 174 175 static void wm8776_registers_init(struct oxygen *chip) 176 { 177 struct xonar_wm87x6 *data = chip->model_data; 178 179 wm8776_write(chip, WM8776_RESET, 0); 180 wm8776_write(chip, WM8776_PHASESWAP, WM8776_PH_MASK); 181 wm8776_write(chip, WM8776_DACCTRL1, WM8776_DZCEN | 182 WM8776_PL_LEFT_LEFT | WM8776_PL_RIGHT_RIGHT); 183 wm8776_write(chip, WM8776_DACMUTE, chip->dac_mute ? WM8776_DMUTE : 0); 184 wm8776_write(chip, WM8776_DACIFCTRL, 185 WM8776_DACFMT_LJUST | WM8776_DACWL_24); 186 wm8776_write(chip, WM8776_ADCIFCTRL, 187 data->wm8776_regs[WM8776_ADCIFCTRL]); 188 wm8776_write(chip, WM8776_MSTRCTRL, data->wm8776_regs[WM8776_MSTRCTRL]); 189 wm8776_write(chip, WM8776_PWRDOWN, data->wm8776_regs[WM8776_PWRDOWN]); 190 wm8776_write(chip, WM8776_HPLVOL, data->wm8776_regs[WM8776_HPLVOL]); 191 wm8776_write(chip, WM8776_HPRVOL, data->wm8776_regs[WM8776_HPRVOL] | 192 WM8776_UPDATE); 193 wm8776_write(chip, WM8776_ADCLVOL, data->wm8776_regs[WM8776_ADCLVOL]); 194 wm8776_write(chip, WM8776_ADCRVOL, data->wm8776_regs[WM8776_ADCRVOL]); 195 wm8776_write(chip, WM8776_ADCMUX, data->wm8776_regs[WM8776_ADCMUX]); 196 wm8776_write(chip, WM8776_DACLVOL, chip->dac_volume[0]); 197 wm8776_write(chip, WM8776_DACRVOL, chip->dac_volume[1] | WM8776_UPDATE); 198 } 199 200 static void wm8766_registers_init(struct oxygen *chip) 201 { 202 struct xonar_wm87x6 *data = chip->model_data; 203 204 wm8766_write(chip, WM8766_RESET, 0); 205 wm8766_write(chip, WM8766_DAC_CTRL, data->wm8766_regs[WM8766_DAC_CTRL]); 206 wm8766_write(chip, WM8766_INT_CTRL, WM8766_FMT_LJUST | WM8766_IWL_24); 207 wm8766_write(chip, WM8766_DAC_CTRL2, 208 WM8766_ZCD | (chip->dac_mute ? WM8766_DMUTE_MASK : 0)); 209 wm8766_write(chip, WM8766_LDA1, chip->dac_volume[2]); 210 wm8766_write(chip, WM8766_RDA1, chip->dac_volume[3]); 211 wm8766_write(chip, WM8766_LDA2, chip->dac_volume[4]); 212 wm8766_write(chip, WM8766_RDA2, chip->dac_volume[5]); 213 wm8766_write(chip, WM8766_LDA3, chip->dac_volume[6]); 214 wm8766_write(chip, WM8766_RDA3, chip->dac_volume[7] | WM8766_UPDATE); 215 } 216 217 static void wm8776_init(struct oxygen *chip) 218 { 219 struct xonar_wm87x6 *data = chip->model_data; 220 221 data->wm8776_regs[WM8776_HPLVOL] = (0x79 - 60) | WM8776_HPZCEN; 222 data->wm8776_regs[WM8776_HPRVOL] = (0x79 - 60) | WM8776_HPZCEN; 223 data->wm8776_regs[WM8776_ADCIFCTRL] = 224 WM8776_ADCFMT_LJUST | WM8776_ADCWL_24 | WM8776_ADCMCLK; 225 data->wm8776_regs[WM8776_MSTRCTRL] = 226 WM8776_ADCRATE_256 | WM8776_DACRATE_256; 227 data->wm8776_regs[WM8776_PWRDOWN] = WM8776_HPPD; 228 data->wm8776_regs[WM8776_ADCLVOL] = 0xa5 | WM8776_ZCA; 229 data->wm8776_regs[WM8776_ADCRVOL] = 0xa5 | WM8776_ZCA; 230 data->wm8776_regs[WM8776_ADCMUX] = 0x001; 231 wm8776_registers_init(chip); 232 } 233 234 static void wm8766_init(struct oxygen *chip) 235 { 236 struct xonar_wm87x6 *data = chip->model_data; 237 238 data->wm8766_regs[WM8766_DAC_CTRL] = 239 WM8766_PL_LEFT_LEFT | WM8766_PL_RIGHT_RIGHT; 240 wm8766_registers_init(chip); 241 } 242 243 static void xonar_ds_handle_hp_jack(struct oxygen *chip) 244 { 245 struct xonar_wm87x6 *data = chip->model_data; 246 bool hp_plugged; 247 unsigned int reg; 248 249 mutex_lock(&chip->mutex); 250 251 hp_plugged = !(oxygen_read16(chip, OXYGEN_GPIO_DATA) & 252 GPIO_DS_HP_DETECT); 253 254 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, 255 hp_plugged ? 0 : GPIO_DS_OUTPUT_FRONTLR, 256 GPIO_DS_OUTPUT_FRONTLR); 257 258 reg = data->wm8766_regs[WM8766_DAC_CTRL] & ~WM8766_MUTEALL; 259 if (hp_plugged) 260 reg |= WM8766_MUTEALL; 261 wm8766_write_cached(chip, WM8766_DAC_CTRL, reg); 262 263 snd_jack_report(data->hp_jack, hp_plugged ? SND_JACK_HEADPHONE : 0); 264 265 mutex_unlock(&chip->mutex); 266 } 267 268 static void xonar_ds_init(struct oxygen *chip) 269 { 270 struct xonar_wm87x6 *data = chip->model_data; 271 272 data->generic.anti_pop_delay = 300; 273 data->generic.output_enable_bit = GPIO_DS_OUTPUT_ENABLE; 274 275 wm8776_init(chip); 276 wm8766_init(chip); 277 278 oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, 279 GPIO_DS_INPUT_ROUTE | GPIO_DS_OUTPUT_FRONTLR); 280 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, 281 GPIO_DS_HP_DETECT); 282 oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DS_INPUT_ROUTE); 283 oxygen_set_bits16(chip, OXYGEN_GPIO_INTERRUPT_MASK, GPIO_DS_HP_DETECT); 284 chip->interrupt_mask |= OXYGEN_INT_GPIO; 285 286 xonar_enable_output(chip); 287 288 snd_jack_new(chip->card, "Headphone", 289 SND_JACK_HEADPHONE, &data->hp_jack); 290 xonar_ds_handle_hp_jack(chip); 291 292 snd_component_add(chip->card, "WM8776"); 293 snd_component_add(chip->card, "WM8766"); 294 } 295 296 static void xonar_hdav_slim_init(struct oxygen *chip) 297 { 298 struct xonar_wm87x6 *data = chip->model_data; 299 300 data->generic.anti_pop_delay = 300; 301 data->generic.output_enable_bit = GPIO_SLIM_OUTPUT_ENABLE; 302 303 wm8776_init(chip); 304 305 oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, 306 GPIO_SLIM_HDMI_DISABLE | 307 GPIO_SLIM_FIRMWARE_CLK | 308 GPIO_SLIM_FIRMWARE_DATA); 309 310 xonar_hdmi_init(chip, &data->hdmi); 311 xonar_enable_output(chip); 312 313 snd_component_add(chip->card, "WM8776"); 314 } 315 316 static void xonar_ds_cleanup(struct oxygen *chip) 317 { 318 xonar_disable_output(chip); 319 wm8776_write(chip, WM8776_RESET, 0); 320 } 321 322 static void xonar_hdav_slim_cleanup(struct oxygen *chip) 323 { 324 xonar_hdmi_cleanup(chip); 325 xonar_disable_output(chip); 326 wm8776_write(chip, WM8776_RESET, 0); 327 msleep(2); 328 } 329 330 static void xonar_ds_suspend(struct oxygen *chip) 331 { 332 xonar_ds_cleanup(chip); 333 } 334 335 static void xonar_hdav_slim_suspend(struct oxygen *chip) 336 { 337 xonar_hdav_slim_cleanup(chip); 338 } 339 340 static void xonar_ds_resume(struct oxygen *chip) 341 { 342 wm8776_registers_init(chip); 343 wm8766_registers_init(chip); 344 xonar_enable_output(chip); 345 xonar_ds_handle_hp_jack(chip); 346 } 347 348 static void xonar_hdav_slim_resume(struct oxygen *chip) 349 { 350 struct xonar_wm87x6 *data = chip->model_data; 351 352 wm8776_registers_init(chip); 353 xonar_hdmi_resume(chip, &data->hdmi); 354 xonar_enable_output(chip); 355 } 356 357 static void wm8776_adc_hardware_filter(unsigned int channel, 358 struct snd_pcm_hardware *hardware) 359 { 360 if (channel == PCM_A) { 361 hardware->rates = SNDRV_PCM_RATE_32000 | 362 SNDRV_PCM_RATE_44100 | 363 SNDRV_PCM_RATE_48000 | 364 SNDRV_PCM_RATE_64000 | 365 SNDRV_PCM_RATE_88200 | 366 SNDRV_PCM_RATE_96000; 367 hardware->rate_max = 96000; 368 } 369 } 370 371 static void xonar_hdav_slim_hardware_filter(unsigned int channel, 372 struct snd_pcm_hardware *hardware) 373 { 374 wm8776_adc_hardware_filter(channel, hardware); 375 xonar_hdmi_pcm_hardware_filter(channel, hardware); 376 } 377 378 static void set_wm87x6_dac_params(struct oxygen *chip, 379 struct snd_pcm_hw_params *params) 380 { 381 } 382 383 static void set_wm8776_adc_params(struct oxygen *chip, 384 struct snd_pcm_hw_params *params) 385 { 386 u16 reg; 387 388 reg = WM8776_ADCRATE_256 | WM8776_DACRATE_256; 389 if (params_rate(params) > 48000) 390 reg |= WM8776_ADCOSR; 391 wm8776_write_cached(chip, WM8776_MSTRCTRL, reg); 392 } 393 394 static void set_hdav_slim_dac_params(struct oxygen *chip, 395 struct snd_pcm_hw_params *params) 396 { 397 struct xonar_wm87x6 *data = chip->model_data; 398 399 xonar_set_hdmi_params(chip, &data->hdmi, params); 400 } 401 402 static void update_wm8776_volume(struct oxygen *chip) 403 { 404 struct xonar_wm87x6 *data = chip->model_data; 405 u8 to_change; 406 407 if (chip->dac_volume[0] == chip->dac_volume[1]) { 408 if (chip->dac_volume[0] != data->wm8776_regs[WM8776_DACLVOL] || 409 chip->dac_volume[1] != data->wm8776_regs[WM8776_DACRVOL]) { 410 wm8776_write(chip, WM8776_DACMASTER, 411 chip->dac_volume[0] | WM8776_UPDATE); 412 data->wm8776_regs[WM8776_DACLVOL] = chip->dac_volume[0]; 413 data->wm8776_regs[WM8776_DACRVOL] = chip->dac_volume[0]; 414 } 415 } else { 416 to_change = (chip->dac_volume[0] != 417 data->wm8776_regs[WM8776_DACLVOL]) << 0; 418 to_change |= (chip->dac_volume[1] != 419 data->wm8776_regs[WM8776_DACLVOL]) << 1; 420 if (to_change & 1) 421 wm8776_write(chip, WM8776_DACLVOL, chip->dac_volume[0] | 422 ((to_change & 2) ? 0 : WM8776_UPDATE)); 423 if (to_change & 2) 424 wm8776_write(chip, WM8776_DACRVOL, 425 chip->dac_volume[1] | WM8776_UPDATE); 426 } 427 } 428 429 static void update_wm87x6_volume(struct oxygen *chip) 430 { 431 static const u8 wm8766_regs[6] = { 432 WM8766_LDA1, WM8766_RDA1, 433 WM8766_LDA2, WM8766_RDA2, 434 WM8766_LDA3, WM8766_RDA3, 435 }; 436 struct xonar_wm87x6 *data = chip->model_data; 437 unsigned int i; 438 u8 to_change; 439 440 update_wm8776_volume(chip); 441 if (chip->dac_volume[2] == chip->dac_volume[3] && 442 chip->dac_volume[2] == chip->dac_volume[4] && 443 chip->dac_volume[2] == chip->dac_volume[5] && 444 chip->dac_volume[2] == chip->dac_volume[6] && 445 chip->dac_volume[2] == chip->dac_volume[7]) { 446 to_change = 0; 447 for (i = 0; i < 6; ++i) 448 if (chip->dac_volume[2] != 449 data->wm8766_regs[wm8766_regs[i]]) 450 to_change = 1; 451 if (to_change) { 452 wm8766_write(chip, WM8766_MASTDA, 453 chip->dac_volume[2] | WM8766_UPDATE); 454 for (i = 0; i < 6; ++i) 455 data->wm8766_regs[wm8766_regs[i]] = 456 chip->dac_volume[2]; 457 } 458 } else { 459 to_change = 0; 460 for (i = 0; i < 6; ++i) 461 to_change |= (chip->dac_volume[2 + i] != 462 data->wm8766_regs[wm8766_regs[i]]) << i; 463 for (i = 0; i < 6; ++i) 464 if (to_change & (1 << i)) 465 wm8766_write(chip, wm8766_regs[i], 466 chip->dac_volume[2 + i] | 467 ((to_change & (0x3e << i)) 468 ? 0 : WM8766_UPDATE)); 469 } 470 } 471 472 static void update_wm8776_mute(struct oxygen *chip) 473 { 474 wm8776_write_cached(chip, WM8776_DACMUTE, 475 chip->dac_mute ? WM8776_DMUTE : 0); 476 } 477 478 static void update_wm87x6_mute(struct oxygen *chip) 479 { 480 update_wm8776_mute(chip); 481 wm8766_write_cached(chip, WM8766_DAC_CTRL2, WM8766_ZCD | 482 (chip->dac_mute ? WM8766_DMUTE_MASK : 0)); 483 } 484 485 static void update_wm8766_center_lfe_mix(struct oxygen *chip, bool mixed) 486 { 487 struct xonar_wm87x6 *data = chip->model_data; 488 unsigned int reg; 489 490 /* 491 * The WM8766 can mix left and right channels, but this setting 492 * applies to all three stereo pairs. 493 */ 494 reg = data->wm8766_regs[WM8766_DAC_CTRL] & 495 ~(WM8766_PL_LEFT_MASK | WM8766_PL_RIGHT_MASK); 496 if (mixed) 497 reg |= WM8766_PL_LEFT_LRMIX | WM8766_PL_RIGHT_LRMIX; 498 else 499 reg |= WM8766_PL_LEFT_LEFT | WM8766_PL_RIGHT_RIGHT; 500 wm8766_write_cached(chip, WM8766_DAC_CTRL, reg); 501 } 502 503 static void xonar_ds_gpio_changed(struct oxygen *chip) 504 { 505 xonar_ds_handle_hp_jack(chip); 506 } 507 508 static int wm8776_bit_switch_get(struct snd_kcontrol *ctl, 509 struct snd_ctl_elem_value *value) 510 { 511 struct oxygen *chip = ctl->private_data; 512 struct xonar_wm87x6 *data = chip->model_data; 513 u16 bit = ctl->private_value & 0xffff; 514 unsigned int reg_index = (ctl->private_value >> 16) & 0xff; 515 bool invert = (ctl->private_value >> 24) & 1; 516 517 value->value.integer.value[0] = 518 ((data->wm8776_regs[reg_index] & bit) != 0) ^ invert; 519 return 0; 520 } 521 522 static int wm8776_bit_switch_put(struct snd_kcontrol *ctl, 523 struct snd_ctl_elem_value *value) 524 { 525 struct oxygen *chip = ctl->private_data; 526 struct xonar_wm87x6 *data = chip->model_data; 527 u16 bit = ctl->private_value & 0xffff; 528 u16 reg_value; 529 unsigned int reg_index = (ctl->private_value >> 16) & 0xff; 530 bool invert = (ctl->private_value >> 24) & 1; 531 int changed; 532 533 mutex_lock(&chip->mutex); 534 reg_value = data->wm8776_regs[reg_index] & ~bit; 535 if (value->value.integer.value[0] ^ invert) 536 reg_value |= bit; 537 changed = reg_value != data->wm8776_regs[reg_index]; 538 if (changed) 539 wm8776_write(chip, reg_index, reg_value); 540 mutex_unlock(&chip->mutex); 541 return changed; 542 } 543 544 static int wm8776_field_enum_info(struct snd_kcontrol *ctl, 545 struct snd_ctl_elem_info *info) 546 { 547 static const char *const hld[16] = { 548 "0 ms", "2.67 ms", "5.33 ms", "10.6 ms", 549 "21.3 ms", "42.7 ms", "85.3 ms", "171 ms", 550 "341 ms", "683 ms", "1.37 s", "2.73 s", 551 "5.46 s", "10.9 s", "21.8 s", "43.7 s", 552 }; 553 static const char *const atk_lim[11] = { 554 "0.25 ms", "0.5 ms", "1 ms", "2 ms", 555 "4 ms", "8 ms", "16 ms", "32 ms", 556 "64 ms", "128 ms", "256 ms", 557 }; 558 static const char *const atk_alc[11] = { 559 "8.40 ms", "16.8 ms", "33.6 ms", "67.2 ms", 560 "134 ms", "269 ms", "538 ms", "1.08 s", 561 "2.15 s", "4.3 s", "8.6 s", 562 }; 563 static const char *const dcy_lim[11] = { 564 "1.2 ms", "2.4 ms", "4.8 ms", "9.6 ms", 565 "19.2 ms", "38.4 ms", "76.8 ms", "154 ms", 566 "307 ms", "614 ms", "1.23 s", 567 }; 568 static const char *const dcy_alc[11] = { 569 "33.5 ms", "67.0 ms", "134 ms", "268 ms", 570 "536 ms", "1.07 s", "2.14 s", "4.29 s", 571 "8.58 s", "17.2 s", "34.3 s", 572 }; 573 static const char *const tranwin[8] = { 574 "0 us", "62.5 us", "125 us", "250 us", 575 "500 us", "1 ms", "2 ms", "4 ms", 576 }; 577 u8 max; 578 const char *const *names; 579 580 max = (ctl->private_value >> 12) & 0xf; 581 switch ((ctl->private_value >> 24) & 0x1f) { 582 case WM8776_ALCCTRL2: 583 names = hld; 584 break; 585 case WM8776_ALCCTRL3: 586 if (((ctl->private_value >> 20) & 0xf) == 0) { 587 if (ctl->private_value & LC_CONTROL_LIMITER) 588 names = atk_lim; 589 else 590 names = atk_alc; 591 } else { 592 if (ctl->private_value & LC_CONTROL_LIMITER) 593 names = dcy_lim; 594 else 595 names = dcy_alc; 596 } 597 break; 598 case WM8776_LIMITER: 599 names = tranwin; 600 break; 601 default: 602 return -ENXIO; 603 } 604 return snd_ctl_enum_info(info, 1, max + 1, names); 605 } 606 607 static int wm8776_field_volume_info(struct snd_kcontrol *ctl, 608 struct snd_ctl_elem_info *info) 609 { 610 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 611 info->count = 1; 612 info->value.integer.min = (ctl->private_value >> 8) & 0xf; 613 info->value.integer.max = (ctl->private_value >> 12) & 0xf; 614 return 0; 615 } 616 617 static void wm8776_field_set_from_ctl(struct snd_kcontrol *ctl) 618 { 619 struct oxygen *chip = ctl->private_data; 620 struct xonar_wm87x6 *data = chip->model_data; 621 unsigned int value, reg_index, mode; 622 u8 min, max, shift; 623 u16 mask, reg_value; 624 bool invert; 625 626 if ((data->wm8776_regs[WM8776_ALCCTRL1] & WM8776_LCSEL_MASK) == 627 WM8776_LCSEL_LIMITER) 628 mode = LC_CONTROL_LIMITER; 629 else 630 mode = LC_CONTROL_ALC; 631 if (!(ctl->private_value & mode)) 632 return; 633 634 value = ctl->private_value & 0xf; 635 min = (ctl->private_value >> 8) & 0xf; 636 max = (ctl->private_value >> 12) & 0xf; 637 mask = (ctl->private_value >> 16) & 0xf; 638 shift = (ctl->private_value >> 20) & 0xf; 639 reg_index = (ctl->private_value >> 24) & 0x1f; 640 invert = (ctl->private_value >> 29) & 0x1; 641 642 if (invert) 643 value = max - (value - min); 644 reg_value = data->wm8776_regs[reg_index]; 645 reg_value &= ~(mask << shift); 646 reg_value |= value << shift; 647 wm8776_write_cached(chip, reg_index, reg_value); 648 } 649 650 static int wm8776_field_set(struct snd_kcontrol *ctl, unsigned int value) 651 { 652 struct oxygen *chip = ctl->private_data; 653 u8 min, max; 654 int changed; 655 656 min = (ctl->private_value >> 8) & 0xf; 657 max = (ctl->private_value >> 12) & 0xf; 658 if (value < min || value > max) 659 return -EINVAL; 660 mutex_lock(&chip->mutex); 661 changed = value != (ctl->private_value & 0xf); 662 if (changed) { 663 ctl->private_value = (ctl->private_value & ~0xf) | value; 664 wm8776_field_set_from_ctl(ctl); 665 } 666 mutex_unlock(&chip->mutex); 667 return changed; 668 } 669 670 static int wm8776_field_enum_get(struct snd_kcontrol *ctl, 671 struct snd_ctl_elem_value *value) 672 { 673 value->value.enumerated.item[0] = ctl->private_value & 0xf; 674 return 0; 675 } 676 677 static int wm8776_field_volume_get(struct snd_kcontrol *ctl, 678 struct snd_ctl_elem_value *value) 679 { 680 value->value.integer.value[0] = ctl->private_value & 0xf; 681 return 0; 682 } 683 684 static int wm8776_field_enum_put(struct snd_kcontrol *ctl, 685 struct snd_ctl_elem_value *value) 686 { 687 return wm8776_field_set(ctl, value->value.enumerated.item[0]); 688 } 689 690 static int wm8776_field_volume_put(struct snd_kcontrol *ctl, 691 struct snd_ctl_elem_value *value) 692 { 693 return wm8776_field_set(ctl, value->value.integer.value[0]); 694 } 695 696 static int wm8776_hp_vol_info(struct snd_kcontrol *ctl, 697 struct snd_ctl_elem_info *info) 698 { 699 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 700 info->count = 2; 701 info->value.integer.min = 0x79 - 60; 702 info->value.integer.max = 0x7f; 703 return 0; 704 } 705 706 static int wm8776_hp_vol_get(struct snd_kcontrol *ctl, 707 struct snd_ctl_elem_value *value) 708 { 709 struct oxygen *chip = ctl->private_data; 710 struct xonar_wm87x6 *data = chip->model_data; 711 712 mutex_lock(&chip->mutex); 713 value->value.integer.value[0] = 714 data->wm8776_regs[WM8776_HPLVOL] & WM8776_HPATT_MASK; 715 value->value.integer.value[1] = 716 data->wm8776_regs[WM8776_HPRVOL] & WM8776_HPATT_MASK; 717 mutex_unlock(&chip->mutex); 718 return 0; 719 } 720 721 static int wm8776_hp_vol_put(struct snd_kcontrol *ctl, 722 struct snd_ctl_elem_value *value) 723 { 724 struct oxygen *chip = ctl->private_data; 725 struct xonar_wm87x6 *data = chip->model_data; 726 u8 to_update; 727 728 mutex_lock(&chip->mutex); 729 to_update = (value->value.integer.value[0] != 730 (data->wm8776_regs[WM8776_HPLVOL] & WM8776_HPATT_MASK)) 731 << 0; 732 to_update |= (value->value.integer.value[1] != 733 (data->wm8776_regs[WM8776_HPRVOL] & WM8776_HPATT_MASK)) 734 << 1; 735 if (value->value.integer.value[0] == value->value.integer.value[1]) { 736 if (to_update) { 737 wm8776_write(chip, WM8776_HPMASTER, 738 value->value.integer.value[0] | 739 WM8776_HPZCEN | WM8776_UPDATE); 740 data->wm8776_regs[WM8776_HPLVOL] = 741 value->value.integer.value[0] | WM8776_HPZCEN; 742 data->wm8776_regs[WM8776_HPRVOL] = 743 value->value.integer.value[0] | WM8776_HPZCEN; 744 } 745 } else { 746 if (to_update & 1) 747 wm8776_write(chip, WM8776_HPLVOL, 748 value->value.integer.value[0] | 749 WM8776_HPZCEN | 750 ((to_update & 2) ? 0 : WM8776_UPDATE)); 751 if (to_update & 2) 752 wm8776_write(chip, WM8776_HPRVOL, 753 value->value.integer.value[1] | 754 WM8776_HPZCEN | WM8776_UPDATE); 755 } 756 mutex_unlock(&chip->mutex); 757 return to_update != 0; 758 } 759 760 static int wm8776_input_mux_get(struct snd_kcontrol *ctl, 761 struct snd_ctl_elem_value *value) 762 { 763 struct oxygen *chip = ctl->private_data; 764 struct xonar_wm87x6 *data = chip->model_data; 765 unsigned int mux_bit = ctl->private_value; 766 767 value->value.integer.value[0] = 768 !!(data->wm8776_regs[WM8776_ADCMUX] & mux_bit); 769 return 0; 770 } 771 772 static int wm8776_input_mux_put(struct snd_kcontrol *ctl, 773 struct snd_ctl_elem_value *value) 774 { 775 struct oxygen *chip = ctl->private_data; 776 struct xonar_wm87x6 *data = chip->model_data; 777 struct snd_kcontrol *other_ctl; 778 unsigned int mux_bit = ctl->private_value; 779 u16 reg; 780 int changed; 781 782 mutex_lock(&chip->mutex); 783 reg = data->wm8776_regs[WM8776_ADCMUX]; 784 if (value->value.integer.value[0]) { 785 reg |= mux_bit; 786 /* line-in and mic-in are exclusive */ 787 mux_bit ^= 3; 788 if (reg & mux_bit) { 789 reg &= ~mux_bit; 790 if (mux_bit == 1) 791 other_ctl = data->line_adcmux_control; 792 else 793 other_ctl = data->mic_adcmux_control; 794 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 795 &other_ctl->id); 796 } 797 } else 798 reg &= ~mux_bit; 799 changed = reg != data->wm8776_regs[WM8776_ADCMUX]; 800 if (changed) { 801 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, 802 reg & 1 ? GPIO_DS_INPUT_ROUTE : 0, 803 GPIO_DS_INPUT_ROUTE); 804 wm8776_write(chip, WM8776_ADCMUX, reg); 805 } 806 mutex_unlock(&chip->mutex); 807 return changed; 808 } 809 810 static int wm8776_input_vol_info(struct snd_kcontrol *ctl, 811 struct snd_ctl_elem_info *info) 812 { 813 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 814 info->count = 2; 815 info->value.integer.min = 0xa5; 816 info->value.integer.max = 0xff; 817 return 0; 818 } 819 820 static int wm8776_input_vol_get(struct snd_kcontrol *ctl, 821 struct snd_ctl_elem_value *value) 822 { 823 struct oxygen *chip = ctl->private_data; 824 struct xonar_wm87x6 *data = chip->model_data; 825 826 mutex_lock(&chip->mutex); 827 value->value.integer.value[0] = 828 data->wm8776_regs[WM8776_ADCLVOL] & WM8776_AGMASK; 829 value->value.integer.value[1] = 830 data->wm8776_regs[WM8776_ADCRVOL] & WM8776_AGMASK; 831 mutex_unlock(&chip->mutex); 832 return 0; 833 } 834 835 static int wm8776_input_vol_put(struct snd_kcontrol *ctl, 836 struct snd_ctl_elem_value *value) 837 { 838 struct oxygen *chip = ctl->private_data; 839 struct xonar_wm87x6 *data = chip->model_data; 840 int changed = 0; 841 842 mutex_lock(&chip->mutex); 843 changed = (value->value.integer.value[0] != 844 (data->wm8776_regs[WM8776_ADCLVOL] & WM8776_AGMASK)) || 845 (value->value.integer.value[1] != 846 (data->wm8776_regs[WM8776_ADCRVOL] & WM8776_AGMASK)); 847 wm8776_write_cached(chip, WM8776_ADCLVOL, 848 value->value.integer.value[0] | WM8776_ZCA); 849 wm8776_write_cached(chip, WM8776_ADCRVOL, 850 value->value.integer.value[1] | WM8776_ZCA); 851 mutex_unlock(&chip->mutex); 852 return changed; 853 } 854 855 static int wm8776_level_control_info(struct snd_kcontrol *ctl, 856 struct snd_ctl_elem_info *info) 857 { 858 static const char *const names[3] = { 859 "None", "Peak Limiter", "Automatic Level Control" 860 }; 861 862 return snd_ctl_enum_info(info, 1, 3, names); 863 } 864 865 static int wm8776_level_control_get(struct snd_kcontrol *ctl, 866 struct snd_ctl_elem_value *value) 867 { 868 struct oxygen *chip = ctl->private_data; 869 struct xonar_wm87x6 *data = chip->model_data; 870 871 if (!(data->wm8776_regs[WM8776_ALCCTRL2] & WM8776_LCEN)) 872 value->value.enumerated.item[0] = 0; 873 else if ((data->wm8776_regs[WM8776_ALCCTRL1] & WM8776_LCSEL_MASK) == 874 WM8776_LCSEL_LIMITER) 875 value->value.enumerated.item[0] = 1; 876 else 877 value->value.enumerated.item[0] = 2; 878 return 0; 879 } 880 881 static void activate_control(struct oxygen *chip, 882 struct snd_kcontrol *ctl, unsigned int mode) 883 { 884 unsigned int access; 885 886 if (ctl->private_value & mode) 887 access = 0; 888 else 889 access = SNDRV_CTL_ELEM_ACCESS_INACTIVE; 890 if ((ctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_INACTIVE) != access) { 891 ctl->vd[0].access ^= SNDRV_CTL_ELEM_ACCESS_INACTIVE; 892 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_INFO, &ctl->id); 893 } 894 } 895 896 static int wm8776_level_control_put(struct snd_kcontrol *ctl, 897 struct snd_ctl_elem_value *value) 898 { 899 struct oxygen *chip = ctl->private_data; 900 struct xonar_wm87x6 *data = chip->model_data; 901 unsigned int mode = 0, i; 902 u16 ctrl1, ctrl2; 903 int changed; 904 905 if (value->value.enumerated.item[0] >= 3) 906 return -EINVAL; 907 mutex_lock(&chip->mutex); 908 changed = value->value.enumerated.item[0] != ctl->private_value; 909 if (changed) { 910 ctl->private_value = value->value.enumerated.item[0]; 911 ctrl1 = data->wm8776_regs[WM8776_ALCCTRL1]; 912 ctrl2 = data->wm8776_regs[WM8776_ALCCTRL2]; 913 switch (value->value.enumerated.item[0]) { 914 default: 915 wm8776_write_cached(chip, WM8776_ALCCTRL2, 916 ctrl2 & ~WM8776_LCEN); 917 break; 918 case 1: 919 wm8776_write_cached(chip, WM8776_ALCCTRL1, 920 (ctrl1 & ~WM8776_LCSEL_MASK) | 921 WM8776_LCSEL_LIMITER); 922 wm8776_write_cached(chip, WM8776_ALCCTRL2, 923 ctrl2 | WM8776_LCEN); 924 mode = LC_CONTROL_LIMITER; 925 break; 926 case 2: 927 wm8776_write_cached(chip, WM8776_ALCCTRL1, 928 (ctrl1 & ~WM8776_LCSEL_MASK) | 929 WM8776_LCSEL_ALC_STEREO); 930 wm8776_write_cached(chip, WM8776_ALCCTRL2, 931 ctrl2 | WM8776_LCEN); 932 mode = LC_CONTROL_ALC; 933 break; 934 } 935 for (i = 0; i < ARRAY_SIZE(data->lc_controls); ++i) 936 activate_control(chip, data->lc_controls[i], mode); 937 } 938 mutex_unlock(&chip->mutex); 939 return changed; 940 } 941 942 static int hpf_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info) 943 { 944 static const char *const names[2] = { 945 "None", "High-pass Filter" 946 }; 947 948 return snd_ctl_enum_info(info, 1, 2, names); 949 } 950 951 static int hpf_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) 952 { 953 struct oxygen *chip = ctl->private_data; 954 struct xonar_wm87x6 *data = chip->model_data; 955 956 value->value.enumerated.item[0] = 957 !(data->wm8776_regs[WM8776_ADCIFCTRL] & WM8776_ADCHPD); 958 return 0; 959 } 960 961 static int hpf_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) 962 { 963 struct oxygen *chip = ctl->private_data; 964 struct xonar_wm87x6 *data = chip->model_data; 965 unsigned int reg; 966 int changed; 967 968 mutex_lock(&chip->mutex); 969 reg = data->wm8776_regs[WM8776_ADCIFCTRL] & ~WM8776_ADCHPD; 970 if (!value->value.enumerated.item[0]) 971 reg |= WM8776_ADCHPD; 972 changed = reg != data->wm8776_regs[WM8776_ADCIFCTRL]; 973 if (changed) 974 wm8776_write(chip, WM8776_ADCIFCTRL, reg); 975 mutex_unlock(&chip->mutex); 976 return changed; 977 } 978 979 #define WM8776_BIT_SWITCH(xname, reg, bit, invert, flags) { \ 980 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 981 .name = xname, \ 982 .info = snd_ctl_boolean_mono_info, \ 983 .get = wm8776_bit_switch_get, \ 984 .put = wm8776_bit_switch_put, \ 985 .private_value = ((reg) << 16) | (bit) | ((invert) << 24) | (flags), \ 986 } 987 #define _WM8776_FIELD_CTL(xname, reg, shift, initval, min, max, mask, flags) \ 988 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 989 .name = xname, \ 990 .private_value = (initval) | ((min) << 8) | ((max) << 12) | \ 991 ((mask) << 16) | ((shift) << 20) | ((reg) << 24) | (flags) 992 #define WM8776_FIELD_CTL_ENUM(xname, reg, shift, init, min, max, mask, flags) {\ 993 _WM8776_FIELD_CTL(xname " Capture Enum", \ 994 reg, shift, init, min, max, mask, flags), \ 995 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 996 SNDRV_CTL_ELEM_ACCESS_INACTIVE, \ 997 .info = wm8776_field_enum_info, \ 998 .get = wm8776_field_enum_get, \ 999 .put = wm8776_field_enum_put, \ 1000 } 1001 #define WM8776_FIELD_CTL_VOLUME(a, b, c, d, e, f, g, h, tlv_p) { \ 1002 _WM8776_FIELD_CTL(a " Capture Volume", b, c, d, e, f, g, h), \ 1003 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 1004 SNDRV_CTL_ELEM_ACCESS_INACTIVE | \ 1005 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \ 1006 .info = wm8776_field_volume_info, \ 1007 .get = wm8776_field_volume_get, \ 1008 .put = wm8776_field_volume_put, \ 1009 .tlv = { .p = tlv_p }, \ 1010 } 1011 1012 static const DECLARE_TLV_DB_SCALE(wm87x6_dac_db_scale, -6000, 50, 0); 1013 static const DECLARE_TLV_DB_SCALE(wm8776_adc_db_scale, -2100, 50, 0); 1014 static const DECLARE_TLV_DB_SCALE(wm8776_hp_db_scale, -6000, 100, 0); 1015 static const DECLARE_TLV_DB_SCALE(wm8776_lct_db_scale, -1600, 100, 0); 1016 static const DECLARE_TLV_DB_SCALE(wm8776_maxgain_db_scale, 0, 400, 0); 1017 static const DECLARE_TLV_DB_SCALE(wm8776_ngth_db_scale, -7800, 600, 0); 1018 static const DECLARE_TLV_DB_SCALE(wm8776_maxatten_lim_db_scale, -1200, 100, 0); 1019 static const DECLARE_TLV_DB_SCALE(wm8776_maxatten_alc_db_scale, -2100, 400, 0); 1020 1021 static const struct snd_kcontrol_new ds_controls[] = { 1022 { 1023 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1024 .name = "Headphone Playback Volume", 1025 .info = wm8776_hp_vol_info, 1026 .get = wm8776_hp_vol_get, 1027 .put = wm8776_hp_vol_put, 1028 .tlv = { .p = wm8776_hp_db_scale }, 1029 }, 1030 WM8776_BIT_SWITCH("Headphone Playback Switch", 1031 WM8776_PWRDOWN, WM8776_HPPD, 1, 0), 1032 { 1033 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1034 .name = "Input Capture Volume", 1035 .info = wm8776_input_vol_info, 1036 .get = wm8776_input_vol_get, 1037 .put = wm8776_input_vol_put, 1038 .tlv = { .p = wm8776_adc_db_scale }, 1039 }, 1040 { 1041 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1042 .name = "Line Capture Switch", 1043 .info = snd_ctl_boolean_mono_info, 1044 .get = wm8776_input_mux_get, 1045 .put = wm8776_input_mux_put, 1046 .private_value = 1 << 0, 1047 }, 1048 { 1049 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1050 .name = "Mic Capture Switch", 1051 .info = snd_ctl_boolean_mono_info, 1052 .get = wm8776_input_mux_get, 1053 .put = wm8776_input_mux_put, 1054 .private_value = 1 << 1, 1055 }, 1056 WM8776_BIT_SWITCH("Front Mic Capture Switch", 1057 WM8776_ADCMUX, 1 << 2, 0, 0), 1058 WM8776_BIT_SWITCH("Aux Capture Switch", 1059 WM8776_ADCMUX, 1 << 3, 0, 0), 1060 { 1061 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1062 .name = "ADC Filter Capture Enum", 1063 .info = hpf_info, 1064 .get = hpf_get, 1065 .put = hpf_put, 1066 }, 1067 { 1068 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1069 .name = "Level Control Capture Enum", 1070 .info = wm8776_level_control_info, 1071 .get = wm8776_level_control_get, 1072 .put = wm8776_level_control_put, 1073 .private_value = 0, 1074 }, 1075 }; 1076 static const struct snd_kcontrol_new hdav_slim_controls[] = { 1077 { 1078 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1079 .name = "HDMI Playback Switch", 1080 .info = snd_ctl_boolean_mono_info, 1081 .get = xonar_gpio_bit_switch_get, 1082 .put = xonar_gpio_bit_switch_put, 1083 .private_value = GPIO_SLIM_HDMI_DISABLE | XONAR_GPIO_BIT_INVERT, 1084 }, 1085 { 1086 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1087 .name = "Headphone Playback Volume", 1088 .info = wm8776_hp_vol_info, 1089 .get = wm8776_hp_vol_get, 1090 .put = wm8776_hp_vol_put, 1091 .tlv = { .p = wm8776_hp_db_scale }, 1092 }, 1093 WM8776_BIT_SWITCH("Headphone Playback Switch", 1094 WM8776_PWRDOWN, WM8776_HPPD, 1, 0), 1095 { 1096 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1097 .name = "Input Capture Volume", 1098 .info = wm8776_input_vol_info, 1099 .get = wm8776_input_vol_get, 1100 .put = wm8776_input_vol_put, 1101 .tlv = { .p = wm8776_adc_db_scale }, 1102 }, 1103 WM8776_BIT_SWITCH("Mic Capture Switch", 1104 WM8776_ADCMUX, 1 << 0, 0, 0), 1105 WM8776_BIT_SWITCH("Aux Capture Switch", 1106 WM8776_ADCMUX, 1 << 1, 0, 0), 1107 { 1108 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1109 .name = "ADC Filter Capture Enum", 1110 .info = hpf_info, 1111 .get = hpf_get, 1112 .put = hpf_put, 1113 }, 1114 { 1115 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1116 .name = "Level Control Capture Enum", 1117 .info = wm8776_level_control_info, 1118 .get = wm8776_level_control_get, 1119 .put = wm8776_level_control_put, 1120 .private_value = 0, 1121 }, 1122 }; 1123 static const struct snd_kcontrol_new lc_controls[] = { 1124 WM8776_FIELD_CTL_VOLUME("Limiter Threshold", 1125 WM8776_ALCCTRL1, 0, 11, 0, 15, 0xf, 1126 LC_CONTROL_LIMITER, wm8776_lct_db_scale), 1127 WM8776_FIELD_CTL_ENUM("Limiter Attack Time", 1128 WM8776_ALCCTRL3, 0, 2, 0, 10, 0xf, 1129 LC_CONTROL_LIMITER), 1130 WM8776_FIELD_CTL_ENUM("Limiter Decay Time", 1131 WM8776_ALCCTRL3, 4, 3, 0, 10, 0xf, 1132 LC_CONTROL_LIMITER), 1133 WM8776_FIELD_CTL_ENUM("Limiter Transient Window", 1134 WM8776_LIMITER, 4, 2, 0, 7, 0x7, 1135 LC_CONTROL_LIMITER), 1136 WM8776_FIELD_CTL_VOLUME("Limiter Maximum Attenuation", 1137 WM8776_LIMITER, 0, 6, 3, 12, 0xf, 1138 LC_CONTROL_LIMITER, 1139 wm8776_maxatten_lim_db_scale), 1140 WM8776_FIELD_CTL_VOLUME("ALC Target Level", 1141 WM8776_ALCCTRL1, 0, 11, 0, 15, 0xf, 1142 LC_CONTROL_ALC, wm8776_lct_db_scale), 1143 WM8776_FIELD_CTL_ENUM("ALC Attack Time", 1144 WM8776_ALCCTRL3, 0, 2, 0, 10, 0xf, 1145 LC_CONTROL_ALC), 1146 WM8776_FIELD_CTL_ENUM("ALC Decay Time", 1147 WM8776_ALCCTRL3, 4, 3, 0, 10, 0xf, 1148 LC_CONTROL_ALC), 1149 WM8776_FIELD_CTL_VOLUME("ALC Maximum Gain", 1150 WM8776_ALCCTRL1, 4, 7, 1, 7, 0x7, 1151 LC_CONTROL_ALC, wm8776_maxgain_db_scale), 1152 WM8776_FIELD_CTL_VOLUME("ALC Maximum Attenuation", 1153 WM8776_LIMITER, 0, 10, 10, 15, 0xf, 1154 LC_CONTROL_ALC, wm8776_maxatten_alc_db_scale), 1155 WM8776_FIELD_CTL_ENUM("ALC Hold Time", 1156 WM8776_ALCCTRL2, 0, 0, 0, 15, 0xf, 1157 LC_CONTROL_ALC), 1158 WM8776_BIT_SWITCH("Noise Gate Capture Switch", 1159 WM8776_NOISEGATE, WM8776_NGAT, 0, 1160 LC_CONTROL_ALC), 1161 WM8776_FIELD_CTL_VOLUME("Noise Gate Threshold", 1162 WM8776_NOISEGATE, 2, 0, 0, 7, 0x7, 1163 LC_CONTROL_ALC, wm8776_ngth_db_scale), 1164 }; 1165 1166 static int add_lc_controls(struct oxygen *chip) 1167 { 1168 struct xonar_wm87x6 *data = chip->model_data; 1169 unsigned int i; 1170 struct snd_kcontrol *ctl; 1171 int err; 1172 1173 BUILD_BUG_ON(ARRAY_SIZE(lc_controls) != ARRAY_SIZE(data->lc_controls)); 1174 for (i = 0; i < ARRAY_SIZE(lc_controls); ++i) { 1175 ctl = snd_ctl_new1(&lc_controls[i], chip); 1176 if (!ctl) 1177 return -ENOMEM; 1178 err = snd_ctl_add(chip->card, ctl); 1179 if (err < 0) 1180 return err; 1181 data->lc_controls[i] = ctl; 1182 } 1183 return 0; 1184 } 1185 1186 static int xonar_ds_mixer_init(struct oxygen *chip) 1187 { 1188 struct xonar_wm87x6 *data = chip->model_data; 1189 unsigned int i; 1190 struct snd_kcontrol *ctl; 1191 int err; 1192 1193 for (i = 0; i < ARRAY_SIZE(ds_controls); ++i) { 1194 ctl = snd_ctl_new1(&ds_controls[i], chip); 1195 if (!ctl) 1196 return -ENOMEM; 1197 err = snd_ctl_add(chip->card, ctl); 1198 if (err < 0) 1199 return err; 1200 if (!strcmp(ctl->id.name, "Line Capture Switch")) 1201 data->line_adcmux_control = ctl; 1202 else if (!strcmp(ctl->id.name, "Mic Capture Switch")) 1203 data->mic_adcmux_control = ctl; 1204 } 1205 if (!data->line_adcmux_control || !data->mic_adcmux_control) 1206 return -ENXIO; 1207 1208 return add_lc_controls(chip); 1209 } 1210 1211 static int xonar_hdav_slim_mixer_init(struct oxygen *chip) 1212 { 1213 unsigned int i; 1214 struct snd_kcontrol *ctl; 1215 int err; 1216 1217 for (i = 0; i < ARRAY_SIZE(hdav_slim_controls); ++i) { 1218 ctl = snd_ctl_new1(&hdav_slim_controls[i], chip); 1219 if (!ctl) 1220 return -ENOMEM; 1221 err = snd_ctl_add(chip->card, ctl); 1222 if (err < 0) 1223 return err; 1224 } 1225 1226 return add_lc_controls(chip); 1227 } 1228 1229 static void dump_wm8776_registers(struct oxygen *chip, 1230 struct snd_info_buffer *buffer) 1231 { 1232 struct xonar_wm87x6 *data = chip->model_data; 1233 unsigned int i; 1234 1235 snd_iprintf(buffer, "\nWM8776:\n00:"); 1236 for (i = 0; i < 0x10; ++i) 1237 snd_iprintf(buffer, " %03x", data->wm8776_regs[i]); 1238 snd_iprintf(buffer, "\n10:"); 1239 for (i = 0x10; i < 0x17; ++i) 1240 snd_iprintf(buffer, " %03x", data->wm8776_regs[i]); 1241 snd_iprintf(buffer, "\n"); 1242 } 1243 1244 static void dump_wm87x6_registers(struct oxygen *chip, 1245 struct snd_info_buffer *buffer) 1246 { 1247 struct xonar_wm87x6 *data = chip->model_data; 1248 unsigned int i; 1249 1250 dump_wm8776_registers(chip, buffer); 1251 snd_iprintf(buffer, "\nWM8766:\n00:"); 1252 for (i = 0; i < 0x10; ++i) 1253 snd_iprintf(buffer, " %03x", data->wm8766_regs[i]); 1254 snd_iprintf(buffer, "\n"); 1255 } 1256 1257 static const struct oxygen_model model_xonar_ds = { 1258 .longname = "Asus Virtuoso 66", 1259 .chip = "AV200", 1260 .init = xonar_ds_init, 1261 .mixer_init = xonar_ds_mixer_init, 1262 .cleanup = xonar_ds_cleanup, 1263 .suspend = xonar_ds_suspend, 1264 .resume = xonar_ds_resume, 1265 .pcm_hardware_filter = wm8776_adc_hardware_filter, 1266 .set_dac_params = set_wm87x6_dac_params, 1267 .set_adc_params = set_wm8776_adc_params, 1268 .update_dac_volume = update_wm87x6_volume, 1269 .update_dac_mute = update_wm87x6_mute, 1270 .update_center_lfe_mix = update_wm8766_center_lfe_mix, 1271 .gpio_changed = xonar_ds_gpio_changed, 1272 .dump_registers = dump_wm87x6_registers, 1273 .dac_tlv = wm87x6_dac_db_scale, 1274 .model_data_size = sizeof(struct xonar_wm87x6), 1275 .device_config = PLAYBACK_0_TO_I2S | 1276 PLAYBACK_1_TO_SPDIF | 1277 CAPTURE_0_FROM_I2S_1 | 1278 CAPTURE_1_FROM_SPDIF, 1279 .dac_channels_pcm = 8, 1280 .dac_channels_mixer = 8, 1281 .dac_volume_min = 255 - 2*60, 1282 .dac_volume_max = 255, 1283 .function_flags = OXYGEN_FUNCTION_SPI, 1284 .dac_mclks = OXYGEN_MCLKS(256, 256, 128), 1285 .adc_mclks = OXYGEN_MCLKS(256, 256, 128), 1286 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, 1287 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, 1288 }; 1289 1290 static const struct oxygen_model model_xonar_hdav_slim = { 1291 .shortname = "Xonar HDAV1.3 Slim", 1292 .longname = "Asus Virtuoso 200", 1293 .chip = "AV200", 1294 .init = xonar_hdav_slim_init, 1295 .mixer_init = xonar_hdav_slim_mixer_init, 1296 .cleanup = xonar_hdav_slim_cleanup, 1297 .suspend = xonar_hdav_slim_suspend, 1298 .resume = xonar_hdav_slim_resume, 1299 .pcm_hardware_filter = xonar_hdav_slim_hardware_filter, 1300 .set_dac_params = set_hdav_slim_dac_params, 1301 .set_adc_params = set_wm8776_adc_params, 1302 .update_dac_volume = update_wm8776_volume, 1303 .update_dac_mute = update_wm8776_mute, 1304 .uart_input = xonar_hdmi_uart_input, 1305 .dump_registers = dump_wm8776_registers, 1306 .dac_tlv = wm87x6_dac_db_scale, 1307 .model_data_size = sizeof(struct xonar_wm87x6), 1308 .device_config = PLAYBACK_0_TO_I2S | 1309 PLAYBACK_1_TO_SPDIF | 1310 CAPTURE_0_FROM_I2S_1 | 1311 CAPTURE_1_FROM_SPDIF, 1312 .dac_channels_pcm = 8, 1313 .dac_channels_mixer = 2, 1314 .dac_volume_min = 255 - 2*60, 1315 .dac_volume_max = 255, 1316 .function_flags = OXYGEN_FUNCTION_2WIRE, 1317 .dac_mclks = OXYGEN_MCLKS(256, 256, 128), 1318 .adc_mclks = OXYGEN_MCLKS(256, 256, 128), 1319 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, 1320 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, 1321 }; 1322 1323 int get_xonar_wm87x6_model(struct oxygen *chip, 1324 const struct pci_device_id *id) 1325 { 1326 switch (id->subdevice) { 1327 case 0x838e: 1328 chip->model = model_xonar_ds; 1329 chip->model.shortname = "Xonar DS"; 1330 break; 1331 case 0x8522: 1332 chip->model = model_xonar_ds; 1333 chip->model.shortname = "Xonar DSX"; 1334 break; 1335 case 0x835e: 1336 chip->model = model_xonar_hdav_slim; 1337 break; 1338 default: 1339 return -EINVAL; 1340 } 1341 return 0; 1342 } 1343