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