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