1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * ALSA driver for ICEnsemble VT1724 (Envy24HT) 4 * 5 * Lowlevel functions for Terratec Aureon cards 6 * 7 * Copyright (c) 2003 Takashi Iwai <tiwai@suse.de> 8 * 9 * NOTES: 10 * 11 * - we reuse the struct snd_akm4xxx record for storing the wm8770 codec data. 12 * both wm and akm codecs are pretty similar, so we can integrate 13 * both controls in the future, once if wm codecs are reused in 14 * many boards. 15 * 16 * - DAC digital volumes are not implemented in the mixer. 17 * if they show better response than DAC analog volumes, we can use them 18 * instead. 19 * 20 * Lowlevel functions for AudioTrak Prodigy 7.1 (and possibly 192) cards 21 * Copyright (c) 2003 Dimitromanolakis Apostolos <apostol@cs.utoronto.ca> 22 * 23 * version 0.82: Stable / not all features work yet (no communication with AC97 secondary) 24 * added 64x/128x oversampling switch (should be 64x only for 96khz) 25 * fixed some recording labels (still need to check the rest) 26 * recording is working probably thanks to correct wm8770 initialization 27 * 28 * version 0.5: Initial release: 29 * working: analog output, mixer, headphone amplifier switch 30 * not working: prety much everything else, at least i could verify that 31 * we have no digital output, no capture, pretty bad clicks and poops 32 * on mixer switch and other coll stuff. 33 */ 34 35 #include <linux/delay.h> 36 #include <linux/interrupt.h> 37 #include <linux/init.h> 38 #include <linux/slab.h> 39 #include <linux/mutex.h> 40 41 #include <sound/core.h> 42 43 #include "ice1712.h" 44 #include "envy24ht.h" 45 #include "aureon.h" 46 #include <sound/tlv.h> 47 48 /* AC97 register cache for Aureon */ 49 struct aureon_spec { 50 unsigned short stac9744[64]; 51 unsigned int cs8415_mux; 52 unsigned short master[2]; 53 unsigned short vol[8]; 54 unsigned char pca9554_out; 55 }; 56 57 /* WM8770 registers */ 58 #define WM_DAC_ATTEN 0x00 /* DAC1-8 analog attenuation */ 59 #define WM_DAC_MASTER_ATTEN 0x08 /* DAC master analog attenuation */ 60 #define WM_DAC_DIG_ATTEN 0x09 /* DAC1-8 digital attenuation */ 61 #define WM_DAC_DIG_MASTER_ATTEN 0x11 /* DAC master digital attenuation */ 62 #define WM_PHASE_SWAP 0x12 /* DAC phase */ 63 #define WM_DAC_CTRL1 0x13 /* DAC control bits */ 64 #define WM_MUTE 0x14 /* mute controls */ 65 #define WM_DAC_CTRL2 0x15 /* de-emphasis and zefo-flag */ 66 #define WM_INT_CTRL 0x16 /* interface control */ 67 #define WM_MASTER 0x17 /* master clock and mode */ 68 #define WM_POWERDOWN 0x18 /* power-down controls */ 69 #define WM_ADC_GAIN 0x19 /* ADC gain L(19)/R(1a) */ 70 #define WM_ADC_MUX 0x1b /* input MUX */ 71 #define WM_OUT_MUX1 0x1c /* output MUX */ 72 #define WM_OUT_MUX2 0x1e /* output MUX */ 73 #define WM_RESET 0x1f /* software reset */ 74 75 /* CS8415A registers */ 76 #define CS8415_CTRL1 0x01 77 #define CS8415_CTRL2 0x02 78 #define CS8415_QSUB 0x14 79 #define CS8415_RATIO 0x1E 80 #define CS8415_C_BUFFER 0x20 81 #define CS8415_ID 0x7F 82 83 /* PCA9554 registers */ 84 #define PCA9554_DEV 0x40 /* I2C device address */ 85 #define PCA9554_IN 0x00 /* input port */ 86 #define PCA9554_OUT 0x01 /* output port */ 87 #define PCA9554_INVERT 0x02 /* input invert */ 88 #define PCA9554_DIR 0x03 /* port directions */ 89 90 /* 91 * Aureon Universe additional controls using PCA9554 92 */ 93 94 /* 95 * Send data to pca9554 96 */ 97 static void aureon_pca9554_write(struct snd_ice1712 *ice, unsigned char reg, 98 unsigned char data) 99 { 100 unsigned int tmp; 101 int i, j; 102 unsigned char dev = PCA9554_DEV; /* ID 0100000, write */ 103 unsigned char val = 0; 104 105 tmp = snd_ice1712_gpio_read(ice); 106 107 snd_ice1712_gpio_set_mask(ice, ~(AUREON_SPI_MOSI|AUREON_SPI_CLK| 108 AUREON_WM_RW|AUREON_WM_CS| 109 AUREON_CS8415_CS)); 110 tmp |= AUREON_WM_RW; 111 tmp |= AUREON_CS8415_CS | AUREON_WM_CS; /* disable SPI devices */ 112 113 tmp &= ~AUREON_SPI_MOSI; 114 tmp &= ~AUREON_SPI_CLK; 115 snd_ice1712_gpio_write(ice, tmp); 116 udelay(50); 117 118 /* 119 * send i2c stop condition and start condition 120 * to obtain sane state 121 */ 122 tmp |= AUREON_SPI_CLK; 123 snd_ice1712_gpio_write(ice, tmp); 124 udelay(50); 125 tmp |= AUREON_SPI_MOSI; 126 snd_ice1712_gpio_write(ice, tmp); 127 udelay(100); 128 tmp &= ~AUREON_SPI_MOSI; 129 snd_ice1712_gpio_write(ice, tmp); 130 udelay(50); 131 tmp &= ~AUREON_SPI_CLK; 132 snd_ice1712_gpio_write(ice, tmp); 133 udelay(100); 134 /* 135 * send device address, command and value, 136 * skipping ack cycles in between 137 */ 138 for (j = 0; j < 3; j++) { 139 switch (j) { 140 case 0: 141 val = dev; 142 break; 143 case 1: 144 val = reg; 145 break; 146 case 2: 147 val = data; 148 break; 149 } 150 for (i = 7; i >= 0; i--) { 151 tmp &= ~AUREON_SPI_CLK; 152 snd_ice1712_gpio_write(ice, tmp); 153 udelay(40); 154 if (val & (1 << i)) 155 tmp |= AUREON_SPI_MOSI; 156 else 157 tmp &= ~AUREON_SPI_MOSI; 158 snd_ice1712_gpio_write(ice, tmp); 159 udelay(40); 160 tmp |= AUREON_SPI_CLK; 161 snd_ice1712_gpio_write(ice, tmp); 162 udelay(40); 163 } 164 tmp &= ~AUREON_SPI_CLK; 165 snd_ice1712_gpio_write(ice, tmp); 166 udelay(40); 167 tmp |= AUREON_SPI_CLK; 168 snd_ice1712_gpio_write(ice, tmp); 169 udelay(40); 170 tmp &= ~AUREON_SPI_CLK; 171 snd_ice1712_gpio_write(ice, tmp); 172 udelay(40); 173 } 174 tmp &= ~AUREON_SPI_CLK; 175 snd_ice1712_gpio_write(ice, tmp); 176 udelay(40); 177 tmp &= ~AUREON_SPI_MOSI; 178 snd_ice1712_gpio_write(ice, tmp); 179 udelay(40); 180 tmp |= AUREON_SPI_CLK; 181 snd_ice1712_gpio_write(ice, tmp); 182 udelay(50); 183 tmp |= AUREON_SPI_MOSI; 184 snd_ice1712_gpio_write(ice, tmp); 185 udelay(100); 186 } 187 188 static int aureon_universe_inmux_info(struct snd_kcontrol *kcontrol, 189 struct snd_ctl_elem_info *uinfo) 190 { 191 static const char * const texts[3] = 192 {"Internal Aux", "Wavetable", "Rear Line-In"}; 193 194 return snd_ctl_enum_info(uinfo, 1, 3, texts); 195 } 196 197 static int aureon_universe_inmux_get(struct snd_kcontrol *kcontrol, 198 struct snd_ctl_elem_value *ucontrol) 199 { 200 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 201 struct aureon_spec *spec = ice->spec; 202 ucontrol->value.enumerated.item[0] = spec->pca9554_out; 203 return 0; 204 } 205 206 static int aureon_universe_inmux_put(struct snd_kcontrol *kcontrol, 207 struct snd_ctl_elem_value *ucontrol) 208 { 209 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 210 struct aureon_spec *spec = ice->spec; 211 unsigned char oval, nval; 212 int change; 213 214 nval = ucontrol->value.enumerated.item[0]; 215 if (nval >= 3) 216 return -EINVAL; 217 snd_ice1712_save_gpio_status(ice); 218 oval = spec->pca9554_out; 219 change = (oval != nval); 220 if (change) { 221 aureon_pca9554_write(ice, PCA9554_OUT, nval); 222 spec->pca9554_out = nval; 223 } 224 snd_ice1712_restore_gpio_status(ice); 225 return change; 226 } 227 228 229 static void aureon_ac97_write(struct snd_ice1712 *ice, unsigned short reg, 230 unsigned short val) 231 { 232 struct aureon_spec *spec = ice->spec; 233 unsigned int tmp; 234 235 /* Send address to XILINX chip */ 236 tmp = (snd_ice1712_gpio_read(ice) & ~0xFF) | (reg & 0x7F); 237 snd_ice1712_gpio_write(ice, tmp); 238 udelay(10); 239 tmp |= AUREON_AC97_ADDR; 240 snd_ice1712_gpio_write(ice, tmp); 241 udelay(10); 242 tmp &= ~AUREON_AC97_ADDR; 243 snd_ice1712_gpio_write(ice, tmp); 244 udelay(10); 245 246 /* Send low-order byte to XILINX chip */ 247 tmp &= ~AUREON_AC97_DATA_MASK; 248 tmp |= val & AUREON_AC97_DATA_MASK; 249 snd_ice1712_gpio_write(ice, tmp); 250 udelay(10); 251 tmp |= AUREON_AC97_DATA_LOW; 252 snd_ice1712_gpio_write(ice, tmp); 253 udelay(10); 254 tmp &= ~AUREON_AC97_DATA_LOW; 255 snd_ice1712_gpio_write(ice, tmp); 256 udelay(10); 257 258 /* Send high-order byte to XILINX chip */ 259 tmp &= ~AUREON_AC97_DATA_MASK; 260 tmp |= (val >> 8) & AUREON_AC97_DATA_MASK; 261 262 snd_ice1712_gpio_write(ice, tmp); 263 udelay(10); 264 tmp |= AUREON_AC97_DATA_HIGH; 265 snd_ice1712_gpio_write(ice, tmp); 266 udelay(10); 267 tmp &= ~AUREON_AC97_DATA_HIGH; 268 snd_ice1712_gpio_write(ice, tmp); 269 udelay(10); 270 271 /* Instruct XILINX chip to parse the data to the STAC9744 chip */ 272 tmp |= AUREON_AC97_COMMIT; 273 snd_ice1712_gpio_write(ice, tmp); 274 udelay(10); 275 tmp &= ~AUREON_AC97_COMMIT; 276 snd_ice1712_gpio_write(ice, tmp); 277 udelay(10); 278 279 /* Store the data in out private buffer */ 280 spec->stac9744[(reg & 0x7F) >> 1] = val; 281 } 282 283 static unsigned short aureon_ac97_read(struct snd_ice1712 *ice, unsigned short reg) 284 { 285 struct aureon_spec *spec = ice->spec; 286 return spec->stac9744[(reg & 0x7F) >> 1]; 287 } 288 289 /* 290 * Initialize STAC9744 chip 291 */ 292 static int aureon_ac97_init(struct snd_ice1712 *ice) 293 { 294 struct aureon_spec *spec = ice->spec; 295 int i; 296 static const unsigned short ac97_defaults[] = { 297 0x00, 0x9640, 298 0x02, 0x8000, 299 0x04, 0x8000, 300 0x06, 0x8000, 301 0x0C, 0x8008, 302 0x0E, 0x8008, 303 0x10, 0x8808, 304 0x12, 0x8808, 305 0x14, 0x8808, 306 0x16, 0x8808, 307 0x18, 0x8808, 308 0x1C, 0x8000, 309 0x26, 0x000F, 310 0x28, 0x0201, 311 0x2C, 0xBB80, 312 0x32, 0xBB80, 313 0x7C, 0x8384, 314 0x7E, 0x7644, 315 (unsigned short)-1 316 }; 317 unsigned int tmp; 318 319 /* Cold reset */ 320 tmp = (snd_ice1712_gpio_read(ice) | AUREON_AC97_RESET) & ~AUREON_AC97_DATA_MASK; 321 snd_ice1712_gpio_write(ice, tmp); 322 udelay(3); 323 324 tmp &= ~AUREON_AC97_RESET; 325 snd_ice1712_gpio_write(ice, tmp); 326 udelay(3); 327 328 tmp |= AUREON_AC97_RESET; 329 snd_ice1712_gpio_write(ice, tmp); 330 udelay(3); 331 332 memset(&spec->stac9744, 0, sizeof(spec->stac9744)); 333 for (i = 0; ac97_defaults[i] != (unsigned short)-1; i += 2) 334 spec->stac9744[(ac97_defaults[i]) >> 1] = ac97_defaults[i+1]; 335 336 /* Unmute AC'97 master volume permanently - muting is done by WM8770 */ 337 aureon_ac97_write(ice, AC97_MASTER, 0x0000); 338 339 return 0; 340 } 341 342 #define AUREON_AC97_STEREO 0x80 343 344 /* 345 * AC'97 volume controls 346 */ 347 static int aureon_ac97_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 348 { 349 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 350 uinfo->count = kcontrol->private_value & AUREON_AC97_STEREO ? 2 : 1; 351 uinfo->value.integer.min = 0; 352 uinfo->value.integer.max = 31; 353 return 0; 354 } 355 356 static int aureon_ac97_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 357 { 358 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 359 unsigned short vol; 360 361 mutex_lock(&ice->gpio_mutex); 362 363 vol = aureon_ac97_read(ice, kcontrol->private_value & 0x7F); 364 ucontrol->value.integer.value[0] = 0x1F - (vol & 0x1F); 365 if (kcontrol->private_value & AUREON_AC97_STEREO) 366 ucontrol->value.integer.value[1] = 0x1F - ((vol >> 8) & 0x1F); 367 368 mutex_unlock(&ice->gpio_mutex); 369 return 0; 370 } 371 372 static int aureon_ac97_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 373 { 374 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 375 unsigned short ovol, nvol; 376 int change; 377 378 snd_ice1712_save_gpio_status(ice); 379 380 ovol = aureon_ac97_read(ice, kcontrol->private_value & 0x7F); 381 nvol = (0x1F - ucontrol->value.integer.value[0]) & 0x001F; 382 if (kcontrol->private_value & AUREON_AC97_STEREO) 383 nvol |= ((0x1F - ucontrol->value.integer.value[1]) << 8) & 0x1F00; 384 nvol |= ovol & ~0x1F1F; 385 386 change = (ovol != nvol); 387 if (change) 388 aureon_ac97_write(ice, kcontrol->private_value & 0x7F, nvol); 389 390 snd_ice1712_restore_gpio_status(ice); 391 392 return change; 393 } 394 395 /* 396 * AC'97 mute controls 397 */ 398 #define aureon_ac97_mute_info snd_ctl_boolean_mono_info 399 400 static int aureon_ac97_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 401 { 402 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 403 404 mutex_lock(&ice->gpio_mutex); 405 406 ucontrol->value.integer.value[0] = aureon_ac97_read(ice, 407 kcontrol->private_value & 0x7F) & 0x8000 ? 0 : 1; 408 409 mutex_unlock(&ice->gpio_mutex); 410 return 0; 411 } 412 413 static int aureon_ac97_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 414 { 415 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 416 unsigned short ovol, nvol; 417 int change; 418 419 snd_ice1712_save_gpio_status(ice); 420 421 ovol = aureon_ac97_read(ice, kcontrol->private_value & 0x7F); 422 nvol = (ucontrol->value.integer.value[0] ? 0x0000 : 0x8000) | (ovol & ~0x8000); 423 424 change = (ovol != nvol); 425 if (change) 426 aureon_ac97_write(ice, kcontrol->private_value & 0x7F, nvol); 427 428 snd_ice1712_restore_gpio_status(ice); 429 430 return change; 431 } 432 433 /* 434 * AC'97 mute controls 435 */ 436 #define aureon_ac97_micboost_info snd_ctl_boolean_mono_info 437 438 static int aureon_ac97_micboost_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 439 { 440 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 441 442 mutex_lock(&ice->gpio_mutex); 443 444 ucontrol->value.integer.value[0] = aureon_ac97_read(ice, AC97_MIC) & 0x0020 ? 0 : 1; 445 446 mutex_unlock(&ice->gpio_mutex); 447 return 0; 448 } 449 450 static int aureon_ac97_micboost_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 451 { 452 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 453 unsigned short ovol, nvol; 454 int change; 455 456 snd_ice1712_save_gpio_status(ice); 457 458 ovol = aureon_ac97_read(ice, AC97_MIC); 459 nvol = (ucontrol->value.integer.value[0] ? 0x0000 : 0x0020) | (ovol & ~0x0020); 460 461 change = (ovol != nvol); 462 if (change) 463 aureon_ac97_write(ice, AC97_MIC, nvol); 464 465 snd_ice1712_restore_gpio_status(ice); 466 467 return change; 468 } 469 470 /* 471 * write data in the SPI mode 472 */ 473 static void aureon_spi_write(struct snd_ice1712 *ice, unsigned int cs, unsigned int data, int bits) 474 { 475 unsigned int tmp; 476 int i; 477 unsigned int mosi, clk; 478 479 tmp = snd_ice1712_gpio_read(ice); 480 481 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_PRODIGY71LT || 482 ice->eeprom.subvendor == VT1724_SUBDEVICE_PRODIGY71XT) { 483 snd_ice1712_gpio_set_mask(ice, ~(PRODIGY_SPI_MOSI|PRODIGY_SPI_CLK|PRODIGY_WM_CS)); 484 mosi = PRODIGY_SPI_MOSI; 485 clk = PRODIGY_SPI_CLK; 486 } else { 487 snd_ice1712_gpio_set_mask(ice, ~(AUREON_WM_RW|AUREON_SPI_MOSI|AUREON_SPI_CLK| 488 AUREON_WM_CS|AUREON_CS8415_CS)); 489 mosi = AUREON_SPI_MOSI; 490 clk = AUREON_SPI_CLK; 491 492 tmp |= AUREON_WM_RW; 493 } 494 495 tmp &= ~cs; 496 snd_ice1712_gpio_write(ice, tmp); 497 udelay(1); 498 499 for (i = bits - 1; i >= 0; i--) { 500 tmp &= ~clk; 501 snd_ice1712_gpio_write(ice, tmp); 502 udelay(1); 503 if (data & (1 << i)) 504 tmp |= mosi; 505 else 506 tmp &= ~mosi; 507 snd_ice1712_gpio_write(ice, tmp); 508 udelay(1); 509 tmp |= clk; 510 snd_ice1712_gpio_write(ice, tmp); 511 udelay(1); 512 } 513 514 tmp &= ~clk; 515 tmp |= cs; 516 snd_ice1712_gpio_write(ice, tmp); 517 udelay(1); 518 tmp |= clk; 519 snd_ice1712_gpio_write(ice, tmp); 520 udelay(1); 521 } 522 523 /* 524 * Read data in SPI mode 525 */ 526 static void aureon_spi_read(struct snd_ice1712 *ice, unsigned int cs, 527 unsigned int data, int bits, unsigned char *buffer, int size) 528 { 529 int i, j; 530 unsigned int tmp; 531 532 tmp = (snd_ice1712_gpio_read(ice) & ~AUREON_SPI_CLK) | AUREON_CS8415_CS|AUREON_WM_CS; 533 snd_ice1712_gpio_write(ice, tmp); 534 tmp &= ~cs; 535 snd_ice1712_gpio_write(ice, tmp); 536 udelay(1); 537 538 for (i = bits-1; i >= 0; i--) { 539 if (data & (1 << i)) 540 tmp |= AUREON_SPI_MOSI; 541 else 542 tmp &= ~AUREON_SPI_MOSI; 543 snd_ice1712_gpio_write(ice, tmp); 544 udelay(1); 545 546 tmp |= AUREON_SPI_CLK; 547 snd_ice1712_gpio_write(ice, tmp); 548 udelay(1); 549 550 tmp &= ~AUREON_SPI_CLK; 551 snd_ice1712_gpio_write(ice, tmp); 552 udelay(1); 553 } 554 555 for (j = 0; j < size; j++) { 556 unsigned char outdata = 0; 557 for (i = 7; i >= 0; i--) { 558 tmp = snd_ice1712_gpio_read(ice); 559 outdata <<= 1; 560 outdata |= (tmp & AUREON_SPI_MISO) ? 1 : 0; 561 udelay(1); 562 563 tmp |= AUREON_SPI_CLK; 564 snd_ice1712_gpio_write(ice, tmp); 565 udelay(1); 566 567 tmp &= ~AUREON_SPI_CLK; 568 snd_ice1712_gpio_write(ice, tmp); 569 udelay(1); 570 } 571 buffer[j] = outdata; 572 } 573 574 tmp |= cs; 575 snd_ice1712_gpio_write(ice, tmp); 576 } 577 578 static unsigned char aureon_cs8415_get(struct snd_ice1712 *ice, int reg) 579 { 580 unsigned char val; 581 aureon_spi_write(ice, AUREON_CS8415_CS, 0x2000 | reg, 16); 582 aureon_spi_read(ice, AUREON_CS8415_CS, 0x21, 8, &val, 1); 583 return val; 584 } 585 586 static void aureon_cs8415_read(struct snd_ice1712 *ice, int reg, 587 unsigned char *buffer, int size) 588 { 589 aureon_spi_write(ice, AUREON_CS8415_CS, 0x2000 | reg, 16); 590 aureon_spi_read(ice, AUREON_CS8415_CS, 0x21, 8, buffer, size); 591 } 592 593 static void aureon_cs8415_put(struct snd_ice1712 *ice, int reg, 594 unsigned char val) 595 { 596 aureon_spi_write(ice, AUREON_CS8415_CS, 0x200000 | (reg << 8) | val, 24); 597 } 598 599 /* 600 * get the current register value of WM codec 601 */ 602 static unsigned short wm_get(struct snd_ice1712 *ice, int reg) 603 { 604 reg <<= 1; 605 return ((unsigned short)ice->akm[0].images[reg] << 8) | 606 ice->akm[0].images[reg + 1]; 607 } 608 609 /* 610 * set the register value of WM codec 611 */ 612 static void wm_put_nocache(struct snd_ice1712 *ice, int reg, unsigned short val) 613 { 614 aureon_spi_write(ice, 615 ((ice->eeprom.subvendor == VT1724_SUBDEVICE_PRODIGY71LT || 616 ice->eeprom.subvendor == VT1724_SUBDEVICE_PRODIGY71XT) ? 617 PRODIGY_WM_CS : AUREON_WM_CS), 618 (reg << 9) | (val & 0x1ff), 16); 619 } 620 621 /* 622 * set the register value of WM codec and remember it 623 */ 624 static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val) 625 { 626 wm_put_nocache(ice, reg, val); 627 reg <<= 1; 628 ice->akm[0].images[reg] = val >> 8; 629 ice->akm[0].images[reg + 1] = val; 630 } 631 632 /* 633 */ 634 #define aureon_mono_bool_info snd_ctl_boolean_mono_info 635 636 /* 637 * AC'97 master playback mute controls (Mute on WM8770 chip) 638 */ 639 #define aureon_ac97_mmute_info snd_ctl_boolean_mono_info 640 641 static int aureon_ac97_mmute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 642 { 643 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 644 645 mutex_lock(&ice->gpio_mutex); 646 647 ucontrol->value.integer.value[0] = (wm_get(ice, WM_OUT_MUX1) >> 1) & 0x01; 648 649 mutex_unlock(&ice->gpio_mutex); 650 return 0; 651 } 652 653 static int aureon_ac97_mmute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 654 { 655 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 656 unsigned short ovol, nvol; 657 int change; 658 659 snd_ice1712_save_gpio_status(ice); 660 661 ovol = wm_get(ice, WM_OUT_MUX1); 662 nvol = (ovol & ~0x02) | (ucontrol->value.integer.value[0] ? 0x02 : 0x00); 663 change = (ovol != nvol); 664 if (change) 665 wm_put(ice, WM_OUT_MUX1, nvol); 666 667 snd_ice1712_restore_gpio_status(ice); 668 669 return change; 670 } 671 672 static const DECLARE_TLV_DB_SCALE(db_scale_wm_dac, -10000, 100, 1); 673 static const DECLARE_TLV_DB_SCALE(db_scale_wm_pcm, -6400, 50, 1); 674 static const DECLARE_TLV_DB_SCALE(db_scale_wm_adc, -1200, 100, 0); 675 static const DECLARE_TLV_DB_SCALE(db_scale_ac97_master, -4650, 150, 0); 676 static const DECLARE_TLV_DB_SCALE(db_scale_ac97_gain, -3450, 150, 0); 677 678 #define WM_VOL_MAX 100 679 #define WM_VOL_CNT 101 /* 0dB .. -100dB */ 680 #define WM_VOL_MUTE 0x8000 681 682 static void wm_set_vol(struct snd_ice1712 *ice, unsigned int index, unsigned short vol, unsigned short master) 683 { 684 unsigned char nvol; 685 686 if ((master & WM_VOL_MUTE) || (vol & WM_VOL_MUTE)) { 687 nvol = 0; 688 } else { 689 nvol = ((vol % WM_VOL_CNT) * (master % WM_VOL_CNT)) / 690 WM_VOL_MAX; 691 nvol += 0x1b; 692 } 693 694 wm_put(ice, index, nvol); 695 wm_put_nocache(ice, index, 0x180 | nvol); 696 } 697 698 /* 699 * DAC mute control 700 */ 701 #define wm_pcm_mute_info snd_ctl_boolean_mono_info 702 703 static int wm_pcm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 704 { 705 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 706 707 mutex_lock(&ice->gpio_mutex); 708 ucontrol->value.integer.value[0] = (wm_get(ice, WM_MUTE) & 0x10) ? 0 : 1; 709 mutex_unlock(&ice->gpio_mutex); 710 return 0; 711 } 712 713 static int wm_pcm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 714 { 715 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 716 unsigned short nval, oval; 717 int change; 718 719 snd_ice1712_save_gpio_status(ice); 720 oval = wm_get(ice, WM_MUTE); 721 nval = (oval & ~0x10) | (ucontrol->value.integer.value[0] ? 0 : 0x10); 722 change = (oval != nval); 723 if (change) 724 wm_put(ice, WM_MUTE, nval); 725 snd_ice1712_restore_gpio_status(ice); 726 727 return change; 728 } 729 730 /* 731 * Master volume attenuation mixer control 732 */ 733 static int wm_master_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 734 { 735 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 736 uinfo->count = 2; 737 uinfo->value.integer.min = 0; 738 uinfo->value.integer.max = WM_VOL_MAX; 739 return 0; 740 } 741 742 static int wm_master_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 743 { 744 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 745 struct aureon_spec *spec = ice->spec; 746 int i; 747 for (i = 0; i < 2; i++) 748 ucontrol->value.integer.value[i] = 749 spec->master[i] & ~WM_VOL_MUTE; 750 return 0; 751 } 752 753 static int wm_master_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 754 { 755 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 756 struct aureon_spec *spec = ice->spec; 757 int ch, change = 0; 758 759 snd_ice1712_save_gpio_status(ice); 760 for (ch = 0; ch < 2; ch++) { 761 unsigned int vol = ucontrol->value.integer.value[ch]; 762 if (vol > WM_VOL_MAX) 763 vol = WM_VOL_MAX; 764 vol |= spec->master[ch] & WM_VOL_MUTE; 765 if (vol != spec->master[ch]) { 766 int dac; 767 spec->master[ch] = vol; 768 for (dac = 0; dac < ice->num_total_dacs; dac += 2) 769 wm_set_vol(ice, WM_DAC_ATTEN + dac + ch, 770 spec->vol[dac + ch], 771 spec->master[ch]); 772 change = 1; 773 } 774 } 775 snd_ice1712_restore_gpio_status(ice); 776 return change; 777 } 778 779 /* 780 * DAC volume attenuation mixer control 781 */ 782 static int wm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 783 { 784 int voices = kcontrol->private_value >> 8; 785 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 786 uinfo->count = voices; 787 uinfo->value.integer.min = 0; /* mute (-101dB) */ 788 uinfo->value.integer.max = WM_VOL_MAX; /* 0dB */ 789 return 0; 790 } 791 792 static int wm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 793 { 794 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 795 struct aureon_spec *spec = ice->spec; 796 int i, ofs, voices; 797 798 voices = kcontrol->private_value >> 8; 799 ofs = kcontrol->private_value & 0xff; 800 for (i = 0; i < voices; i++) 801 ucontrol->value.integer.value[i] = 802 spec->vol[ofs+i] & ~WM_VOL_MUTE; 803 return 0; 804 } 805 806 static int wm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 807 { 808 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 809 struct aureon_spec *spec = ice->spec; 810 int i, idx, ofs, voices; 811 int change = 0; 812 813 voices = kcontrol->private_value >> 8; 814 ofs = kcontrol->private_value & 0xff; 815 snd_ice1712_save_gpio_status(ice); 816 for (i = 0; i < voices; i++) { 817 unsigned int vol = ucontrol->value.integer.value[i]; 818 if (vol > WM_VOL_MAX) 819 vol = WM_VOL_MAX; 820 vol |= spec->vol[ofs+i] & WM_VOL_MUTE; 821 if (vol != spec->vol[ofs+i]) { 822 spec->vol[ofs+i] = vol; 823 idx = WM_DAC_ATTEN + ofs + i; 824 wm_set_vol(ice, idx, spec->vol[ofs + i], 825 spec->master[i]); 826 change = 1; 827 } 828 } 829 snd_ice1712_restore_gpio_status(ice); 830 return change; 831 } 832 833 /* 834 * WM8770 mute control 835 */ 836 static int wm_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 837 { 838 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 839 uinfo->count = kcontrol->private_value >> 8; 840 uinfo->value.integer.min = 0; 841 uinfo->value.integer.max = 1; 842 return 0; 843 } 844 845 static int wm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 846 { 847 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 848 struct aureon_spec *spec = ice->spec; 849 int voices, ofs, i; 850 851 voices = kcontrol->private_value >> 8; 852 ofs = kcontrol->private_value & 0xFF; 853 854 for (i = 0; i < voices; i++) 855 ucontrol->value.integer.value[i] = 856 (spec->vol[ofs + i] & WM_VOL_MUTE) ? 0 : 1; 857 return 0; 858 } 859 860 static int wm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 861 { 862 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 863 struct aureon_spec *spec = ice->spec; 864 int change = 0, voices, ofs, i; 865 866 voices = kcontrol->private_value >> 8; 867 ofs = kcontrol->private_value & 0xFF; 868 869 snd_ice1712_save_gpio_status(ice); 870 for (i = 0; i < voices; i++) { 871 int val = (spec->vol[ofs + i] & WM_VOL_MUTE) ? 0 : 1; 872 if (ucontrol->value.integer.value[i] != val) { 873 spec->vol[ofs + i] &= ~WM_VOL_MUTE; 874 spec->vol[ofs + i] |= 875 ucontrol->value.integer.value[i] ? 0 : WM_VOL_MUTE; 876 wm_set_vol(ice, ofs + i, spec->vol[ofs + i], 877 spec->master[i]); 878 change = 1; 879 } 880 } 881 snd_ice1712_restore_gpio_status(ice); 882 883 return change; 884 } 885 886 /* 887 * WM8770 master mute control 888 */ 889 #define wm_master_mute_info snd_ctl_boolean_stereo_info 890 891 static int wm_master_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 892 { 893 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 894 struct aureon_spec *spec = ice->spec; 895 896 ucontrol->value.integer.value[0] = 897 (spec->master[0] & WM_VOL_MUTE) ? 0 : 1; 898 ucontrol->value.integer.value[1] = 899 (spec->master[1] & WM_VOL_MUTE) ? 0 : 1; 900 return 0; 901 } 902 903 static int wm_master_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 904 { 905 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 906 struct aureon_spec *spec = ice->spec; 907 int change = 0, i; 908 909 snd_ice1712_save_gpio_status(ice); 910 for (i = 0; i < 2; i++) { 911 int val = (spec->master[i] & WM_VOL_MUTE) ? 0 : 1; 912 if (ucontrol->value.integer.value[i] != val) { 913 int dac; 914 spec->master[i] &= ~WM_VOL_MUTE; 915 spec->master[i] |= 916 ucontrol->value.integer.value[i] ? 0 : WM_VOL_MUTE; 917 for (dac = 0; dac < ice->num_total_dacs; dac += 2) 918 wm_set_vol(ice, WM_DAC_ATTEN + dac + i, 919 spec->vol[dac + i], 920 spec->master[i]); 921 change = 1; 922 } 923 } 924 snd_ice1712_restore_gpio_status(ice); 925 926 return change; 927 } 928 929 /* digital master volume */ 930 #define PCM_0dB 0xff 931 #define PCM_RES 128 /* -64dB */ 932 #define PCM_MIN (PCM_0dB - PCM_RES) 933 static int wm_pcm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 934 { 935 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 936 uinfo->count = 1; 937 uinfo->value.integer.min = 0; /* mute (-64dB) */ 938 uinfo->value.integer.max = PCM_RES; /* 0dB */ 939 return 0; 940 } 941 942 static int wm_pcm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 943 { 944 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 945 unsigned short val; 946 947 mutex_lock(&ice->gpio_mutex); 948 val = wm_get(ice, WM_DAC_DIG_MASTER_ATTEN) & 0xff; 949 val = val > PCM_MIN ? (val - PCM_MIN) : 0; 950 ucontrol->value.integer.value[0] = val; 951 mutex_unlock(&ice->gpio_mutex); 952 return 0; 953 } 954 955 static int wm_pcm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 956 { 957 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 958 unsigned short ovol, nvol; 959 int change = 0; 960 961 nvol = ucontrol->value.integer.value[0]; 962 if (nvol > PCM_RES) 963 return -EINVAL; 964 snd_ice1712_save_gpio_status(ice); 965 nvol = (nvol ? (nvol + PCM_MIN) : 0) & 0xff; 966 ovol = wm_get(ice, WM_DAC_DIG_MASTER_ATTEN) & 0xff; 967 if (ovol != nvol) { 968 wm_put(ice, WM_DAC_DIG_MASTER_ATTEN, nvol); /* prelatch */ 969 wm_put_nocache(ice, WM_DAC_DIG_MASTER_ATTEN, nvol | 0x100); /* update */ 970 change = 1; 971 } 972 snd_ice1712_restore_gpio_status(ice); 973 return change; 974 } 975 976 /* 977 * ADC mute control 978 */ 979 #define wm_adc_mute_info snd_ctl_boolean_stereo_info 980 981 static int wm_adc_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 982 { 983 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 984 unsigned short val; 985 int i; 986 987 mutex_lock(&ice->gpio_mutex); 988 for (i = 0; i < 2; i++) { 989 val = wm_get(ice, WM_ADC_GAIN + i); 990 ucontrol->value.integer.value[i] = ~val>>5 & 0x1; 991 } 992 mutex_unlock(&ice->gpio_mutex); 993 return 0; 994 } 995 996 static int wm_adc_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 997 { 998 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 999 unsigned short new, old; 1000 int i, change = 0; 1001 1002 snd_ice1712_save_gpio_status(ice); 1003 for (i = 0; i < 2; i++) { 1004 old = wm_get(ice, WM_ADC_GAIN + i); 1005 new = (~ucontrol->value.integer.value[i]<<5&0x20) | (old&~0x20); 1006 if (new != old) { 1007 wm_put(ice, WM_ADC_GAIN + i, new); 1008 change = 1; 1009 } 1010 } 1011 snd_ice1712_restore_gpio_status(ice); 1012 1013 return change; 1014 } 1015 1016 /* 1017 * ADC gain mixer control 1018 */ 1019 static int wm_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1020 { 1021 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1022 uinfo->count = 2; 1023 uinfo->value.integer.min = 0; /* -12dB */ 1024 uinfo->value.integer.max = 0x1f; /* 19dB */ 1025 return 0; 1026 } 1027 1028 static int wm_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1029 { 1030 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1031 int i, idx; 1032 unsigned short vol; 1033 1034 mutex_lock(&ice->gpio_mutex); 1035 for (i = 0; i < 2; i++) { 1036 idx = WM_ADC_GAIN + i; 1037 vol = wm_get(ice, idx) & 0x1f; 1038 ucontrol->value.integer.value[i] = vol; 1039 } 1040 mutex_unlock(&ice->gpio_mutex); 1041 return 0; 1042 } 1043 1044 static int wm_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1045 { 1046 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1047 int i, idx; 1048 unsigned short ovol, nvol; 1049 int change = 0; 1050 1051 snd_ice1712_save_gpio_status(ice); 1052 for (i = 0; i < 2; i++) { 1053 idx = WM_ADC_GAIN + i; 1054 nvol = ucontrol->value.integer.value[i] & 0x1f; 1055 ovol = wm_get(ice, idx); 1056 if ((ovol & 0x1f) != nvol) { 1057 wm_put(ice, idx, nvol | (ovol & ~0x1f)); 1058 change = 1; 1059 } 1060 } 1061 snd_ice1712_restore_gpio_status(ice); 1062 return change; 1063 } 1064 1065 /* 1066 * ADC input mux mixer control 1067 */ 1068 static int wm_adc_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1069 { 1070 static const char * const texts[] = { 1071 "CD", /* AIN1 */ 1072 "Aux", /* AIN2 */ 1073 "Line", /* AIN3 */ 1074 "Mic", /* AIN4 */ 1075 "AC97" /* AIN5 */ 1076 }; 1077 static const char * const universe_texts[] = { 1078 "Aux1", /* AIN1 */ 1079 "CD", /* AIN2 */ 1080 "Phono", /* AIN3 */ 1081 "Line", /* AIN4 */ 1082 "Aux2", /* AIN5 */ 1083 "Mic", /* AIN6 */ 1084 "Aux3", /* AIN7 */ 1085 "AC97" /* AIN8 */ 1086 }; 1087 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1088 1089 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_AUREON71_UNIVERSE) 1090 return snd_ctl_enum_info(uinfo, 2, 8, universe_texts); 1091 else 1092 return snd_ctl_enum_info(uinfo, 2, 5, texts); 1093 } 1094 1095 static int wm_adc_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1096 { 1097 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1098 unsigned short val; 1099 1100 mutex_lock(&ice->gpio_mutex); 1101 val = wm_get(ice, WM_ADC_MUX); 1102 ucontrol->value.enumerated.item[0] = val & 7; 1103 ucontrol->value.enumerated.item[1] = (val >> 4) & 7; 1104 mutex_unlock(&ice->gpio_mutex); 1105 return 0; 1106 } 1107 1108 static int wm_adc_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1109 { 1110 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1111 unsigned short oval, nval; 1112 int change; 1113 1114 snd_ice1712_save_gpio_status(ice); 1115 oval = wm_get(ice, WM_ADC_MUX); 1116 nval = oval & ~0x77; 1117 nval |= ucontrol->value.enumerated.item[0] & 7; 1118 nval |= (ucontrol->value.enumerated.item[1] & 7) << 4; 1119 change = (oval != nval); 1120 if (change) 1121 wm_put(ice, WM_ADC_MUX, nval); 1122 snd_ice1712_restore_gpio_status(ice); 1123 return change; 1124 } 1125 1126 /* 1127 * CS8415 Input mux 1128 */ 1129 static int aureon_cs8415_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1130 { 1131 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1132 static const char * const aureon_texts[] = { 1133 "CD", /* RXP0 */ 1134 "Optical" /* RXP1 */ 1135 }; 1136 static const char * const prodigy_texts[] = { 1137 "CD", 1138 "Coax" 1139 }; 1140 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_PRODIGY71) 1141 return snd_ctl_enum_info(uinfo, 1, 2, prodigy_texts); 1142 else 1143 return snd_ctl_enum_info(uinfo, 1, 2, aureon_texts); 1144 } 1145 1146 static int aureon_cs8415_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1147 { 1148 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1149 struct aureon_spec *spec = ice->spec; 1150 1151 /* snd_ice1712_save_gpio_status(ice); */ 1152 /* val = aureon_cs8415_get(ice, CS8415_CTRL2); */ 1153 ucontrol->value.enumerated.item[0] = spec->cs8415_mux; 1154 /* snd_ice1712_restore_gpio_status(ice); */ 1155 return 0; 1156 } 1157 1158 static int aureon_cs8415_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1159 { 1160 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1161 struct aureon_spec *spec = ice->spec; 1162 unsigned short oval, nval; 1163 int change; 1164 1165 snd_ice1712_save_gpio_status(ice); 1166 oval = aureon_cs8415_get(ice, CS8415_CTRL2); 1167 nval = oval & ~0x07; 1168 nval |= ucontrol->value.enumerated.item[0] & 7; 1169 change = (oval != nval); 1170 if (change) 1171 aureon_cs8415_put(ice, CS8415_CTRL2, nval); 1172 snd_ice1712_restore_gpio_status(ice); 1173 spec->cs8415_mux = ucontrol->value.enumerated.item[0]; 1174 return change; 1175 } 1176 1177 static int aureon_cs8415_rate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1178 { 1179 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1180 uinfo->count = 1; 1181 uinfo->value.integer.min = 0; 1182 uinfo->value.integer.max = 192000; 1183 return 0; 1184 } 1185 1186 static int aureon_cs8415_rate_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1187 { 1188 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1189 unsigned char ratio; 1190 ratio = aureon_cs8415_get(ice, CS8415_RATIO); 1191 ucontrol->value.integer.value[0] = (int)((unsigned int)ratio * 750); 1192 return 0; 1193 } 1194 1195 /* 1196 * CS8415A Mute 1197 */ 1198 #define aureon_cs8415_mute_info snd_ctl_boolean_mono_info 1199 1200 static int aureon_cs8415_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1201 { 1202 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1203 snd_ice1712_save_gpio_status(ice); 1204 ucontrol->value.integer.value[0] = (aureon_cs8415_get(ice, CS8415_CTRL1) & 0x20) ? 0 : 1; 1205 snd_ice1712_restore_gpio_status(ice); 1206 return 0; 1207 } 1208 1209 static int aureon_cs8415_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1210 { 1211 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1212 unsigned char oval, nval; 1213 int change; 1214 snd_ice1712_save_gpio_status(ice); 1215 oval = aureon_cs8415_get(ice, CS8415_CTRL1); 1216 if (ucontrol->value.integer.value[0]) 1217 nval = oval & ~0x20; 1218 else 1219 nval = oval | 0x20; 1220 change = (oval != nval); 1221 if (change) 1222 aureon_cs8415_put(ice, CS8415_CTRL1, nval); 1223 snd_ice1712_restore_gpio_status(ice); 1224 return change; 1225 } 1226 1227 /* 1228 * CS8415A Q-Sub info 1229 */ 1230 static int aureon_cs8415_qsub_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1231 { 1232 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; 1233 uinfo->count = 10; 1234 return 0; 1235 } 1236 1237 static int aureon_cs8415_qsub_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1238 { 1239 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1240 1241 snd_ice1712_save_gpio_status(ice); 1242 aureon_cs8415_read(ice, CS8415_QSUB, ucontrol->value.bytes.data, 10); 1243 snd_ice1712_restore_gpio_status(ice); 1244 1245 return 0; 1246 } 1247 1248 static int aureon_cs8415_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1249 { 1250 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 1251 uinfo->count = 1; 1252 return 0; 1253 } 1254 1255 static int aureon_cs8415_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1256 { 1257 memset(ucontrol->value.iec958.status, 0xFF, 24); 1258 return 0; 1259 } 1260 1261 static int aureon_cs8415_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1262 { 1263 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1264 1265 snd_ice1712_save_gpio_status(ice); 1266 aureon_cs8415_read(ice, CS8415_C_BUFFER, ucontrol->value.iec958.status, 24); 1267 snd_ice1712_restore_gpio_status(ice); 1268 return 0; 1269 } 1270 1271 /* 1272 * Headphone Amplifier 1273 */ 1274 static int aureon_set_headphone_amp(struct snd_ice1712 *ice, int enable) 1275 { 1276 unsigned int tmp, tmp2; 1277 1278 tmp2 = tmp = snd_ice1712_gpio_read(ice); 1279 if (enable) 1280 if (ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71LT && 1281 ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71XT) 1282 tmp |= AUREON_HP_SEL; 1283 else 1284 tmp |= PRODIGY_HP_SEL; 1285 else 1286 if (ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71LT && 1287 ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71XT) 1288 tmp &= ~AUREON_HP_SEL; 1289 else 1290 tmp &= ~PRODIGY_HP_SEL; 1291 if (tmp != tmp2) { 1292 snd_ice1712_gpio_write(ice, tmp); 1293 return 1; 1294 } 1295 return 0; 1296 } 1297 1298 static int aureon_get_headphone_amp(struct snd_ice1712 *ice) 1299 { 1300 unsigned int tmp = snd_ice1712_gpio_read(ice); 1301 1302 return (tmp & AUREON_HP_SEL) != 0; 1303 } 1304 1305 #define aureon_hpamp_info snd_ctl_boolean_mono_info 1306 1307 static int aureon_hpamp_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1308 { 1309 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1310 1311 ucontrol->value.integer.value[0] = aureon_get_headphone_amp(ice); 1312 return 0; 1313 } 1314 1315 1316 static int aureon_hpamp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1317 { 1318 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1319 1320 return aureon_set_headphone_amp(ice, ucontrol->value.integer.value[0]); 1321 } 1322 1323 /* 1324 * Deemphasis 1325 */ 1326 1327 #define aureon_deemp_info snd_ctl_boolean_mono_info 1328 1329 static int aureon_deemp_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1330 { 1331 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1332 ucontrol->value.integer.value[0] = (wm_get(ice, WM_DAC_CTRL2) & 0xf) == 0xf; 1333 return 0; 1334 } 1335 1336 static int aureon_deemp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1337 { 1338 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1339 int temp, temp2; 1340 temp2 = temp = wm_get(ice, WM_DAC_CTRL2); 1341 if (ucontrol->value.integer.value[0]) 1342 temp |= 0xf; 1343 else 1344 temp &= ~0xf; 1345 if (temp != temp2) { 1346 wm_put(ice, WM_DAC_CTRL2, temp); 1347 return 1; 1348 } 1349 return 0; 1350 } 1351 1352 /* 1353 * ADC Oversampling 1354 */ 1355 static int aureon_oversampling_info(struct snd_kcontrol *k, struct snd_ctl_elem_info *uinfo) 1356 { 1357 static const char * const texts[2] = { "128x", "64x" }; 1358 1359 return snd_ctl_enum_info(uinfo, 1, 2, texts); 1360 } 1361 1362 static int aureon_oversampling_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1363 { 1364 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1365 ucontrol->value.enumerated.item[0] = (wm_get(ice, WM_MASTER) & 0x8) == 0x8; 1366 return 0; 1367 } 1368 1369 static int aureon_oversampling_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1370 { 1371 int temp, temp2; 1372 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 1373 1374 temp2 = temp = wm_get(ice, WM_MASTER); 1375 1376 if (ucontrol->value.enumerated.item[0]) 1377 temp |= 0x8; 1378 else 1379 temp &= ~0x8; 1380 1381 if (temp != temp2) { 1382 wm_put(ice, WM_MASTER, temp); 1383 return 1; 1384 } 1385 return 0; 1386 } 1387 1388 /* 1389 * mixers 1390 */ 1391 1392 static const struct snd_kcontrol_new aureon_dac_controls[] = { 1393 { 1394 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1395 .name = "Master Playback Switch", 1396 .info = wm_master_mute_info, 1397 .get = wm_master_mute_get, 1398 .put = wm_master_mute_put 1399 }, 1400 { 1401 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1402 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1403 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1404 .name = "Master Playback Volume", 1405 .info = wm_master_vol_info, 1406 .get = wm_master_vol_get, 1407 .put = wm_master_vol_put, 1408 .tlv = { .p = db_scale_wm_dac } 1409 }, 1410 { 1411 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1412 .name = "Front Playback Switch", 1413 .info = wm_mute_info, 1414 .get = wm_mute_get, 1415 .put = wm_mute_put, 1416 .private_value = (2 << 8) | 0 1417 }, 1418 { 1419 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1420 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1421 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1422 .name = "Front Playback Volume", 1423 .info = wm_vol_info, 1424 .get = wm_vol_get, 1425 .put = wm_vol_put, 1426 .private_value = (2 << 8) | 0, 1427 .tlv = { .p = db_scale_wm_dac } 1428 }, 1429 { 1430 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1431 .name = "Rear Playback Switch", 1432 .info = wm_mute_info, 1433 .get = wm_mute_get, 1434 .put = wm_mute_put, 1435 .private_value = (2 << 8) | 2 1436 }, 1437 { 1438 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1439 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1440 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1441 .name = "Rear Playback Volume", 1442 .info = wm_vol_info, 1443 .get = wm_vol_get, 1444 .put = wm_vol_put, 1445 .private_value = (2 << 8) | 2, 1446 .tlv = { .p = db_scale_wm_dac } 1447 }, 1448 { 1449 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1450 .name = "Center Playback Switch", 1451 .info = wm_mute_info, 1452 .get = wm_mute_get, 1453 .put = wm_mute_put, 1454 .private_value = (1 << 8) | 4 1455 }, 1456 { 1457 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1458 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1459 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1460 .name = "Center Playback Volume", 1461 .info = wm_vol_info, 1462 .get = wm_vol_get, 1463 .put = wm_vol_put, 1464 .private_value = (1 << 8) | 4, 1465 .tlv = { .p = db_scale_wm_dac } 1466 }, 1467 { 1468 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1469 .name = "LFE Playback Switch", 1470 .info = wm_mute_info, 1471 .get = wm_mute_get, 1472 .put = wm_mute_put, 1473 .private_value = (1 << 8) | 5 1474 }, 1475 { 1476 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1477 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1478 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1479 .name = "LFE Playback Volume", 1480 .info = wm_vol_info, 1481 .get = wm_vol_get, 1482 .put = wm_vol_put, 1483 .private_value = (1 << 8) | 5, 1484 .tlv = { .p = db_scale_wm_dac } 1485 }, 1486 { 1487 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1488 .name = "Side Playback Switch", 1489 .info = wm_mute_info, 1490 .get = wm_mute_get, 1491 .put = wm_mute_put, 1492 .private_value = (2 << 8) | 6 1493 }, 1494 { 1495 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1496 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1497 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1498 .name = "Side Playback Volume", 1499 .info = wm_vol_info, 1500 .get = wm_vol_get, 1501 .put = wm_vol_put, 1502 .private_value = (2 << 8) | 6, 1503 .tlv = { .p = db_scale_wm_dac } 1504 } 1505 }; 1506 1507 static const struct snd_kcontrol_new wm_controls[] = { 1508 { 1509 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1510 .name = "PCM Playback Switch", 1511 .info = wm_pcm_mute_info, 1512 .get = wm_pcm_mute_get, 1513 .put = wm_pcm_mute_put 1514 }, 1515 { 1516 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1517 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1518 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1519 .name = "PCM Playback Volume", 1520 .info = wm_pcm_vol_info, 1521 .get = wm_pcm_vol_get, 1522 .put = wm_pcm_vol_put, 1523 .tlv = { .p = db_scale_wm_pcm } 1524 }, 1525 { 1526 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1527 .name = "Capture Switch", 1528 .info = wm_adc_mute_info, 1529 .get = wm_adc_mute_get, 1530 .put = wm_adc_mute_put, 1531 }, 1532 { 1533 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1534 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1535 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1536 .name = "Capture Volume", 1537 .info = wm_adc_vol_info, 1538 .get = wm_adc_vol_get, 1539 .put = wm_adc_vol_put, 1540 .tlv = { .p = db_scale_wm_adc } 1541 }, 1542 { 1543 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1544 .name = "Capture Source", 1545 .info = wm_adc_mux_info, 1546 .get = wm_adc_mux_get, 1547 .put = wm_adc_mux_put, 1548 .private_value = 5 1549 }, 1550 { 1551 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1552 .name = "External Amplifier", 1553 .info = aureon_hpamp_info, 1554 .get = aureon_hpamp_get, 1555 .put = aureon_hpamp_put 1556 }, 1557 { 1558 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1559 .name = "DAC Deemphasis Switch", 1560 .info = aureon_deemp_info, 1561 .get = aureon_deemp_get, 1562 .put = aureon_deemp_put 1563 }, 1564 { 1565 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1566 .name = "ADC Oversampling", 1567 .info = aureon_oversampling_info, 1568 .get = aureon_oversampling_get, 1569 .put = aureon_oversampling_put 1570 } 1571 }; 1572 1573 static const struct snd_kcontrol_new ac97_controls[] = { 1574 { 1575 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1576 .name = "AC97 Playback Switch", 1577 .info = aureon_ac97_mmute_info, 1578 .get = aureon_ac97_mmute_get, 1579 .put = aureon_ac97_mmute_put, 1580 .private_value = AC97_MASTER 1581 }, 1582 { 1583 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1584 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1585 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1586 .name = "AC97 Playback Volume", 1587 .info = aureon_ac97_vol_info, 1588 .get = aureon_ac97_vol_get, 1589 .put = aureon_ac97_vol_put, 1590 .private_value = AC97_MASTER|AUREON_AC97_STEREO, 1591 .tlv = { .p = db_scale_ac97_master } 1592 }, 1593 { 1594 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1595 .name = "CD Playback Switch", 1596 .info = aureon_ac97_mute_info, 1597 .get = aureon_ac97_mute_get, 1598 .put = aureon_ac97_mute_put, 1599 .private_value = AC97_CD 1600 }, 1601 { 1602 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1603 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1604 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1605 .name = "CD Playback Volume", 1606 .info = aureon_ac97_vol_info, 1607 .get = aureon_ac97_vol_get, 1608 .put = aureon_ac97_vol_put, 1609 .private_value = AC97_CD|AUREON_AC97_STEREO, 1610 .tlv = { .p = db_scale_ac97_gain } 1611 }, 1612 { 1613 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1614 .name = "Aux Playback Switch", 1615 .info = aureon_ac97_mute_info, 1616 .get = aureon_ac97_mute_get, 1617 .put = aureon_ac97_mute_put, 1618 .private_value = AC97_AUX, 1619 }, 1620 { 1621 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1622 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1623 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1624 .name = "Aux Playback Volume", 1625 .info = aureon_ac97_vol_info, 1626 .get = aureon_ac97_vol_get, 1627 .put = aureon_ac97_vol_put, 1628 .private_value = AC97_AUX|AUREON_AC97_STEREO, 1629 .tlv = { .p = db_scale_ac97_gain } 1630 }, 1631 { 1632 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1633 .name = "Line Playback Switch", 1634 .info = aureon_ac97_mute_info, 1635 .get = aureon_ac97_mute_get, 1636 .put = aureon_ac97_mute_put, 1637 .private_value = AC97_LINE 1638 }, 1639 { 1640 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1641 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1642 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1643 .name = "Line Playback Volume", 1644 .info = aureon_ac97_vol_info, 1645 .get = aureon_ac97_vol_get, 1646 .put = aureon_ac97_vol_put, 1647 .private_value = AC97_LINE|AUREON_AC97_STEREO, 1648 .tlv = { .p = db_scale_ac97_gain } 1649 }, 1650 { 1651 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1652 .name = "Mic Playback Switch", 1653 .info = aureon_ac97_mute_info, 1654 .get = aureon_ac97_mute_get, 1655 .put = aureon_ac97_mute_put, 1656 .private_value = AC97_MIC 1657 }, 1658 { 1659 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1660 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1661 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1662 .name = "Mic Playback Volume", 1663 .info = aureon_ac97_vol_info, 1664 .get = aureon_ac97_vol_get, 1665 .put = aureon_ac97_vol_put, 1666 .private_value = AC97_MIC, 1667 .tlv = { .p = db_scale_ac97_gain } 1668 }, 1669 { 1670 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1671 .name = "Mic Boost (+20dB)", 1672 .info = aureon_ac97_micboost_info, 1673 .get = aureon_ac97_micboost_get, 1674 .put = aureon_ac97_micboost_put 1675 } 1676 }; 1677 1678 static const struct snd_kcontrol_new universe_ac97_controls[] = { 1679 { 1680 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1681 .name = "AC97 Playback Switch", 1682 .info = aureon_ac97_mmute_info, 1683 .get = aureon_ac97_mmute_get, 1684 .put = aureon_ac97_mmute_put, 1685 .private_value = AC97_MASTER 1686 }, 1687 { 1688 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1689 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1690 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1691 .name = "AC97 Playback Volume", 1692 .info = aureon_ac97_vol_info, 1693 .get = aureon_ac97_vol_get, 1694 .put = aureon_ac97_vol_put, 1695 .private_value = AC97_MASTER|AUREON_AC97_STEREO, 1696 .tlv = { .p = db_scale_ac97_master } 1697 }, 1698 { 1699 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1700 .name = "CD Playback Switch", 1701 .info = aureon_ac97_mute_info, 1702 .get = aureon_ac97_mute_get, 1703 .put = aureon_ac97_mute_put, 1704 .private_value = AC97_AUX 1705 }, 1706 { 1707 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1708 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1709 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1710 .name = "CD Playback Volume", 1711 .info = aureon_ac97_vol_info, 1712 .get = aureon_ac97_vol_get, 1713 .put = aureon_ac97_vol_put, 1714 .private_value = AC97_AUX|AUREON_AC97_STEREO, 1715 .tlv = { .p = db_scale_ac97_gain } 1716 }, 1717 { 1718 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1719 .name = "Phono Playback Switch", 1720 .info = aureon_ac97_mute_info, 1721 .get = aureon_ac97_mute_get, 1722 .put = aureon_ac97_mute_put, 1723 .private_value = AC97_CD 1724 }, 1725 { 1726 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1727 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1728 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1729 .name = "Phono Playback Volume", 1730 .info = aureon_ac97_vol_info, 1731 .get = aureon_ac97_vol_get, 1732 .put = aureon_ac97_vol_put, 1733 .private_value = AC97_CD|AUREON_AC97_STEREO, 1734 .tlv = { .p = db_scale_ac97_gain } 1735 }, 1736 { 1737 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1738 .name = "Line Playback Switch", 1739 .info = aureon_ac97_mute_info, 1740 .get = aureon_ac97_mute_get, 1741 .put = aureon_ac97_mute_put, 1742 .private_value = AC97_LINE 1743 }, 1744 { 1745 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1746 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1747 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1748 .name = "Line Playback Volume", 1749 .info = aureon_ac97_vol_info, 1750 .get = aureon_ac97_vol_get, 1751 .put = aureon_ac97_vol_put, 1752 .private_value = AC97_LINE|AUREON_AC97_STEREO, 1753 .tlv = { .p = db_scale_ac97_gain } 1754 }, 1755 { 1756 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1757 .name = "Mic Playback Switch", 1758 .info = aureon_ac97_mute_info, 1759 .get = aureon_ac97_mute_get, 1760 .put = aureon_ac97_mute_put, 1761 .private_value = AC97_MIC 1762 }, 1763 { 1764 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1765 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1766 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1767 .name = "Mic Playback Volume", 1768 .info = aureon_ac97_vol_info, 1769 .get = aureon_ac97_vol_get, 1770 .put = aureon_ac97_vol_put, 1771 .private_value = AC97_MIC, 1772 .tlv = { .p = db_scale_ac97_gain } 1773 }, 1774 { 1775 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1776 .name = "Mic Boost (+20dB)", 1777 .info = aureon_ac97_micboost_info, 1778 .get = aureon_ac97_micboost_get, 1779 .put = aureon_ac97_micboost_put 1780 }, 1781 { 1782 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1783 .name = "Aux Playback Switch", 1784 .info = aureon_ac97_mute_info, 1785 .get = aureon_ac97_mute_get, 1786 .put = aureon_ac97_mute_put, 1787 .private_value = AC97_VIDEO, 1788 }, 1789 { 1790 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1791 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1792 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 1793 .name = "Aux Playback Volume", 1794 .info = aureon_ac97_vol_info, 1795 .get = aureon_ac97_vol_get, 1796 .put = aureon_ac97_vol_put, 1797 .private_value = AC97_VIDEO|AUREON_AC97_STEREO, 1798 .tlv = { .p = db_scale_ac97_gain } 1799 }, 1800 { 1801 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1802 .name = "Aux Source", 1803 .info = aureon_universe_inmux_info, 1804 .get = aureon_universe_inmux_get, 1805 .put = aureon_universe_inmux_put 1806 } 1807 1808 }; 1809 1810 static const struct snd_kcontrol_new cs8415_controls[] = { 1811 { 1812 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1813 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH), 1814 .info = aureon_cs8415_mute_info, 1815 .get = aureon_cs8415_mute_get, 1816 .put = aureon_cs8415_mute_put 1817 }, 1818 { 1819 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1820 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, NONE) "Source", 1821 .info = aureon_cs8415_mux_info, 1822 .get = aureon_cs8415_mux_get, 1823 .put = aureon_cs8415_mux_put, 1824 }, 1825 { 1826 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1827 .name = SNDRV_CTL_NAME_IEC958("Q-subcode ", CAPTURE, DEFAULT), 1828 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 1829 .info = aureon_cs8415_qsub_info, 1830 .get = aureon_cs8415_qsub_get, 1831 }, 1832 { 1833 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1834 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK), 1835 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1836 .info = aureon_cs8415_spdif_info, 1837 .get = aureon_cs8415_mask_get 1838 }, 1839 { 1840 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1841 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT), 1842 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 1843 .info = aureon_cs8415_spdif_info, 1844 .get = aureon_cs8415_spdif_get 1845 }, 1846 { 1847 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1848 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, NONE) "Rate", 1849 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 1850 .info = aureon_cs8415_rate_info, 1851 .get = aureon_cs8415_rate_get 1852 } 1853 }; 1854 1855 static int aureon_add_controls(struct snd_ice1712 *ice) 1856 { 1857 unsigned int i, counts; 1858 int err; 1859 1860 counts = ARRAY_SIZE(aureon_dac_controls); 1861 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_AUREON51_SKY) 1862 counts -= 2; /* no side */ 1863 for (i = 0; i < counts; i++) { 1864 err = snd_ctl_add(ice->card, snd_ctl_new1(&aureon_dac_controls[i], ice)); 1865 if (err < 0) 1866 return err; 1867 } 1868 1869 for (i = 0; i < ARRAY_SIZE(wm_controls); i++) { 1870 err = snd_ctl_add(ice->card, snd_ctl_new1(&wm_controls[i], ice)); 1871 if (err < 0) 1872 return err; 1873 } 1874 1875 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_AUREON71_UNIVERSE) { 1876 for (i = 0; i < ARRAY_SIZE(universe_ac97_controls); i++) { 1877 err = snd_ctl_add(ice->card, snd_ctl_new1(&universe_ac97_controls[i], ice)); 1878 if (err < 0) 1879 return err; 1880 } 1881 } else if (ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71LT && 1882 ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71XT) { 1883 for (i = 0; i < ARRAY_SIZE(ac97_controls); i++) { 1884 err = snd_ctl_add(ice->card, snd_ctl_new1(&ac97_controls[i], ice)); 1885 if (err < 0) 1886 return err; 1887 } 1888 } 1889 1890 if (ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71LT && 1891 ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71XT) { 1892 unsigned char id; 1893 snd_ice1712_save_gpio_status(ice); 1894 id = aureon_cs8415_get(ice, CS8415_ID); 1895 snd_ice1712_restore_gpio_status(ice); 1896 if (id != 0x41) 1897 dev_info(ice->card->dev, 1898 "No CS8415 chip. Skipping CS8415 controls.\n"); 1899 else { 1900 for (i = 0; i < ARRAY_SIZE(cs8415_controls); i++) { 1901 struct snd_kcontrol *kctl; 1902 kctl = snd_ctl_new1(&cs8415_controls[i], ice); 1903 if (i > 1) 1904 kctl->id.device = ice->pcm->device; 1905 err = snd_ctl_add(ice->card, kctl); 1906 if (err < 0) 1907 return err; 1908 } 1909 } 1910 } 1911 1912 return 0; 1913 } 1914 1915 /* 1916 * reset the chip 1917 */ 1918 static int aureon_reset(struct snd_ice1712 *ice) 1919 { 1920 static const unsigned short wm_inits_aureon[] = { 1921 /* These come first to reduce init pop noise */ 1922 0x1b, 0x044, /* ADC Mux (AC'97 source) */ 1923 0x1c, 0x00B, /* Out Mux1 (VOUT1 = DAC+AUX, VOUT2 = DAC) */ 1924 0x1d, 0x009, /* Out Mux2 (VOUT2 = DAC, VOUT3 = DAC) */ 1925 1926 0x18, 0x000, /* All power-up */ 1927 1928 0x16, 0x122, /* I2S, normal polarity, 24bit */ 1929 0x17, 0x022, /* 256fs, slave mode */ 1930 0x00, 0, /* DAC1 analog mute */ 1931 0x01, 0, /* DAC2 analog mute */ 1932 0x02, 0, /* DAC3 analog mute */ 1933 0x03, 0, /* DAC4 analog mute */ 1934 0x04, 0, /* DAC5 analog mute */ 1935 0x05, 0, /* DAC6 analog mute */ 1936 0x06, 0, /* DAC7 analog mute */ 1937 0x07, 0, /* DAC8 analog mute */ 1938 0x08, 0x100, /* master analog mute */ 1939 0x09, 0xff, /* DAC1 digital full */ 1940 0x0a, 0xff, /* DAC2 digital full */ 1941 0x0b, 0xff, /* DAC3 digital full */ 1942 0x0c, 0xff, /* DAC4 digital full */ 1943 0x0d, 0xff, /* DAC5 digital full */ 1944 0x0e, 0xff, /* DAC6 digital full */ 1945 0x0f, 0xff, /* DAC7 digital full */ 1946 0x10, 0xff, /* DAC8 digital full */ 1947 0x11, 0x1ff, /* master digital full */ 1948 0x12, 0x000, /* phase normal */ 1949 0x13, 0x090, /* unmute DAC L/R */ 1950 0x14, 0x000, /* all unmute */ 1951 0x15, 0x000, /* no deemphasis, no ZFLG */ 1952 0x19, 0x000, /* -12dB ADC/L */ 1953 0x1a, 0x000, /* -12dB ADC/R */ 1954 (unsigned short)-1 1955 }; 1956 static const unsigned short wm_inits_prodigy[] = { 1957 1958 /* These come first to reduce init pop noise */ 1959 0x1b, 0x000, /* ADC Mux */ 1960 0x1c, 0x009, /* Out Mux1 */ 1961 0x1d, 0x009, /* Out Mux2 */ 1962 1963 0x18, 0x000, /* All power-up */ 1964 1965 0x16, 0x022, /* I2S, normal polarity, 24bit, high-pass on */ 1966 0x17, 0x006, /* 128fs, slave mode */ 1967 1968 0x00, 0, /* DAC1 analog mute */ 1969 0x01, 0, /* DAC2 analog mute */ 1970 0x02, 0, /* DAC3 analog mute */ 1971 0x03, 0, /* DAC4 analog mute */ 1972 0x04, 0, /* DAC5 analog mute */ 1973 0x05, 0, /* DAC6 analog mute */ 1974 0x06, 0, /* DAC7 analog mute */ 1975 0x07, 0, /* DAC8 analog mute */ 1976 0x08, 0x100, /* master analog mute */ 1977 1978 0x09, 0x7f, /* DAC1 digital full */ 1979 0x0a, 0x7f, /* DAC2 digital full */ 1980 0x0b, 0x7f, /* DAC3 digital full */ 1981 0x0c, 0x7f, /* DAC4 digital full */ 1982 0x0d, 0x7f, /* DAC5 digital full */ 1983 0x0e, 0x7f, /* DAC6 digital full */ 1984 0x0f, 0x7f, /* DAC7 digital full */ 1985 0x10, 0x7f, /* DAC8 digital full */ 1986 0x11, 0x1FF, /* master digital full */ 1987 1988 0x12, 0x000, /* phase normal */ 1989 0x13, 0x090, /* unmute DAC L/R */ 1990 0x14, 0x000, /* all unmute */ 1991 0x15, 0x000, /* no deemphasis, no ZFLG */ 1992 1993 0x19, 0x000, /* -12dB ADC/L */ 1994 0x1a, 0x000, /* -12dB ADC/R */ 1995 (unsigned short)-1 1996 1997 }; 1998 static const unsigned short cs_inits[] = { 1999 0x0441, /* RUN */ 2000 0x0180, /* no mute, OMCK output on RMCK pin */ 2001 0x0201, /* S/PDIF source on RXP1 */ 2002 0x0605, /* slave, 24bit, MSB on second OSCLK, SDOUT for right channel when OLRCK is high */ 2003 (unsigned short)-1 2004 }; 2005 unsigned int tmp; 2006 const unsigned short *p; 2007 int err; 2008 struct aureon_spec *spec = ice->spec; 2009 2010 err = aureon_ac97_init(ice); 2011 if (err != 0) 2012 return err; 2013 2014 snd_ice1712_gpio_set_dir(ice, 0x5fffff); /* fix this for the time being */ 2015 2016 /* reset the wm codec as the SPI mode */ 2017 snd_ice1712_save_gpio_status(ice); 2018 snd_ice1712_gpio_set_mask(ice, ~(AUREON_WM_RESET|AUREON_WM_CS|AUREON_CS8415_CS|AUREON_HP_SEL)); 2019 2020 tmp = snd_ice1712_gpio_read(ice); 2021 tmp &= ~AUREON_WM_RESET; 2022 snd_ice1712_gpio_write(ice, tmp); 2023 udelay(1); 2024 tmp |= AUREON_WM_CS | AUREON_CS8415_CS; 2025 snd_ice1712_gpio_write(ice, tmp); 2026 udelay(1); 2027 tmp |= AUREON_WM_RESET; 2028 snd_ice1712_gpio_write(ice, tmp); 2029 udelay(1); 2030 2031 /* initialize WM8770 codec */ 2032 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_PRODIGY71 || 2033 ice->eeprom.subvendor == VT1724_SUBDEVICE_PRODIGY71LT || 2034 ice->eeprom.subvendor == VT1724_SUBDEVICE_PRODIGY71XT) 2035 p = wm_inits_prodigy; 2036 else 2037 p = wm_inits_aureon; 2038 for (; *p != (unsigned short)-1; p += 2) 2039 wm_put(ice, p[0], p[1]); 2040 2041 /* initialize CS8415A codec */ 2042 if (ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71LT && 2043 ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71XT) { 2044 for (p = cs_inits; *p != (unsigned short)-1; p++) 2045 aureon_spi_write(ice, AUREON_CS8415_CS, *p | 0x200000, 24); 2046 spec->cs8415_mux = 1; 2047 2048 aureon_set_headphone_amp(ice, 1); 2049 } 2050 2051 snd_ice1712_restore_gpio_status(ice); 2052 2053 /* initialize PCA9554 pin directions & set default input */ 2054 aureon_pca9554_write(ice, PCA9554_DIR, 0x00); 2055 aureon_pca9554_write(ice, PCA9554_OUT, 0x00); /* internal AUX */ 2056 return 0; 2057 } 2058 2059 /* 2060 * suspend/resume 2061 */ 2062 #ifdef CONFIG_PM_SLEEP 2063 static int aureon_resume(struct snd_ice1712 *ice) 2064 { 2065 struct aureon_spec *spec = ice->spec; 2066 int err, i; 2067 2068 err = aureon_reset(ice); 2069 if (err != 0) 2070 return err; 2071 2072 /* workaround for poking volume with alsamixer after resume: 2073 * just set stored volume again */ 2074 for (i = 0; i < ice->num_total_dacs; i++) 2075 wm_set_vol(ice, i, spec->vol[i], spec->master[i % 2]); 2076 return 0; 2077 } 2078 #endif 2079 2080 /* 2081 * initialize the chip 2082 */ 2083 static int aureon_init(struct snd_ice1712 *ice) 2084 { 2085 struct aureon_spec *spec; 2086 int i, err; 2087 2088 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 2089 if (!spec) 2090 return -ENOMEM; 2091 ice->spec = spec; 2092 2093 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_AUREON51_SKY) { 2094 ice->num_total_dacs = 6; 2095 ice->num_total_adcs = 2; 2096 } else { 2097 /* aureon 7.1 and prodigy 7.1 */ 2098 ice->num_total_dacs = 8; 2099 ice->num_total_adcs = 2; 2100 } 2101 2102 /* to remember the register values of CS8415 */ 2103 ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); 2104 if (!ice->akm) 2105 return -ENOMEM; 2106 ice->akm_codecs = 1; 2107 2108 err = aureon_reset(ice); 2109 if (err != 0) 2110 return err; 2111 2112 spec->master[0] = WM_VOL_MUTE; 2113 spec->master[1] = WM_VOL_MUTE; 2114 for (i = 0; i < ice->num_total_dacs; i++) { 2115 spec->vol[i] = WM_VOL_MUTE; 2116 wm_set_vol(ice, i, spec->vol[i], spec->master[i % 2]); 2117 } 2118 2119 #ifdef CONFIG_PM_SLEEP 2120 ice->pm_resume = aureon_resume; 2121 ice->pm_suspend_enabled = 1; 2122 #endif 2123 2124 return 0; 2125 } 2126 2127 2128 /* 2129 * Aureon boards don't provide the EEPROM data except for the vendor IDs. 2130 * hence the driver needs to sets up it properly. 2131 */ 2132 2133 static const unsigned char aureon51_eeprom[] = { 2134 [ICE_EEP2_SYSCONF] = 0x0a, /* clock 512, spdif-in/ADC, 3DACs */ 2135 [ICE_EEP2_ACLINK] = 0x80, /* I2S */ 2136 [ICE_EEP2_I2S] = 0xfc, /* vol, 96k, 24bit, 192k */ 2137 [ICE_EEP2_SPDIF] = 0xc3, /* out-en, out-int, spdif-in */ 2138 [ICE_EEP2_GPIO_DIR] = 0xff, 2139 [ICE_EEP2_GPIO_DIR1] = 0xff, 2140 [ICE_EEP2_GPIO_DIR2] = 0x5f, 2141 [ICE_EEP2_GPIO_MASK] = 0x00, 2142 [ICE_EEP2_GPIO_MASK1] = 0x00, 2143 [ICE_EEP2_GPIO_MASK2] = 0x00, 2144 [ICE_EEP2_GPIO_STATE] = 0x00, 2145 [ICE_EEP2_GPIO_STATE1] = 0x00, 2146 [ICE_EEP2_GPIO_STATE2] = 0x00, 2147 }; 2148 2149 static const unsigned char aureon71_eeprom[] = { 2150 [ICE_EEP2_SYSCONF] = 0x0b, /* clock 512, spdif-in/ADC, 4DACs */ 2151 [ICE_EEP2_ACLINK] = 0x80, /* I2S */ 2152 [ICE_EEP2_I2S] = 0xfc, /* vol, 96k, 24bit, 192k */ 2153 [ICE_EEP2_SPDIF] = 0xc3, /* out-en, out-int, spdif-in */ 2154 [ICE_EEP2_GPIO_DIR] = 0xff, 2155 [ICE_EEP2_GPIO_DIR1] = 0xff, 2156 [ICE_EEP2_GPIO_DIR2] = 0x5f, 2157 [ICE_EEP2_GPIO_MASK] = 0x00, 2158 [ICE_EEP2_GPIO_MASK1] = 0x00, 2159 [ICE_EEP2_GPIO_MASK2] = 0x00, 2160 [ICE_EEP2_GPIO_STATE] = 0x00, 2161 [ICE_EEP2_GPIO_STATE1] = 0x00, 2162 [ICE_EEP2_GPIO_STATE2] = 0x00, 2163 }; 2164 #define prodigy71_eeprom aureon71_eeprom 2165 2166 static const unsigned char aureon71_universe_eeprom[] = { 2167 [ICE_EEP2_SYSCONF] = 0x2b, /* clock 512, mpu401, spdif-in/ADC, 2168 * 4DACs 2169 */ 2170 [ICE_EEP2_ACLINK] = 0x80, /* I2S */ 2171 [ICE_EEP2_I2S] = 0xfc, /* vol, 96k, 24bit, 192k */ 2172 [ICE_EEP2_SPDIF] = 0xc3, /* out-en, out-int, spdif-in */ 2173 [ICE_EEP2_GPIO_DIR] = 0xff, 2174 [ICE_EEP2_GPIO_DIR1] = 0xff, 2175 [ICE_EEP2_GPIO_DIR2] = 0x5f, 2176 [ICE_EEP2_GPIO_MASK] = 0x00, 2177 [ICE_EEP2_GPIO_MASK1] = 0x00, 2178 [ICE_EEP2_GPIO_MASK2] = 0x00, 2179 [ICE_EEP2_GPIO_STATE] = 0x00, 2180 [ICE_EEP2_GPIO_STATE1] = 0x00, 2181 [ICE_EEP2_GPIO_STATE2] = 0x00, 2182 }; 2183 2184 static const unsigned char prodigy71lt_eeprom[] = { 2185 [ICE_EEP2_SYSCONF] = 0x4b, /* clock 384, spdif-in/ADC, 4DACs */ 2186 [ICE_EEP2_ACLINK] = 0x80, /* I2S */ 2187 [ICE_EEP2_I2S] = 0xfc, /* vol, 96k, 24bit, 192k */ 2188 [ICE_EEP2_SPDIF] = 0xc3, /* out-en, out-int, spdif-in */ 2189 [ICE_EEP2_GPIO_DIR] = 0xff, 2190 [ICE_EEP2_GPIO_DIR1] = 0xff, 2191 [ICE_EEP2_GPIO_DIR2] = 0x5f, 2192 [ICE_EEP2_GPIO_MASK] = 0x00, 2193 [ICE_EEP2_GPIO_MASK1] = 0x00, 2194 [ICE_EEP2_GPIO_MASK2] = 0x00, 2195 [ICE_EEP2_GPIO_STATE] = 0x00, 2196 [ICE_EEP2_GPIO_STATE1] = 0x00, 2197 [ICE_EEP2_GPIO_STATE2] = 0x00, 2198 }; 2199 #define prodigy71xt_eeprom prodigy71lt_eeprom 2200 2201 /* entry point */ 2202 struct snd_ice1712_card_info snd_vt1724_aureon_cards[] = { 2203 { 2204 .subvendor = VT1724_SUBDEVICE_AUREON51_SKY, 2205 .name = "Terratec Aureon 5.1-Sky", 2206 .model = "aureon51", 2207 .chip_init = aureon_init, 2208 .build_controls = aureon_add_controls, 2209 .eeprom_size = sizeof(aureon51_eeprom), 2210 .eeprom_data = aureon51_eeprom, 2211 .driver = "Aureon51", 2212 }, 2213 { 2214 .subvendor = VT1724_SUBDEVICE_AUREON71_SPACE, 2215 .name = "Terratec Aureon 7.1-Space", 2216 .model = "aureon71", 2217 .chip_init = aureon_init, 2218 .build_controls = aureon_add_controls, 2219 .eeprom_size = sizeof(aureon71_eeprom), 2220 .eeprom_data = aureon71_eeprom, 2221 .driver = "Aureon71", 2222 }, 2223 { 2224 .subvendor = VT1724_SUBDEVICE_AUREON71_UNIVERSE, 2225 .name = "Terratec Aureon 7.1-Universe", 2226 .model = "universe", 2227 .chip_init = aureon_init, 2228 .build_controls = aureon_add_controls, 2229 .eeprom_size = sizeof(aureon71_universe_eeprom), 2230 .eeprom_data = aureon71_universe_eeprom, 2231 .driver = "Aureon71Univ", /* keep in 15 letters */ 2232 }, 2233 { 2234 .subvendor = VT1724_SUBDEVICE_PRODIGY71, 2235 .name = "Audiotrak Prodigy 7.1", 2236 .model = "prodigy71", 2237 .chip_init = aureon_init, 2238 .build_controls = aureon_add_controls, 2239 .eeprom_size = sizeof(prodigy71_eeprom), 2240 .eeprom_data = prodigy71_eeprom, 2241 .driver = "Prodigy71", /* should be identical with Aureon71 */ 2242 }, 2243 { 2244 .subvendor = VT1724_SUBDEVICE_PRODIGY71LT, 2245 .name = "Audiotrak Prodigy 7.1 LT", 2246 .model = "prodigy71lt", 2247 .chip_init = aureon_init, 2248 .build_controls = aureon_add_controls, 2249 .eeprom_size = sizeof(prodigy71lt_eeprom), 2250 .eeprom_data = prodigy71lt_eeprom, 2251 .driver = "Prodigy71LT", 2252 }, 2253 { 2254 .subvendor = VT1724_SUBDEVICE_PRODIGY71XT, 2255 .name = "Audiotrak Prodigy 7.1 XT", 2256 .model = "prodigy71xt", 2257 .chip_init = aureon_init, 2258 .build_controls = aureon_add_controls, 2259 .eeprom_size = sizeof(prodigy71xt_eeprom), 2260 .eeprom_data = prodigy71xt_eeprom, 2261 .driver = "Prodigy71LT", 2262 }, 2263 { } /* terminator */ 2264 }; 2265