sound/pci/ice1712/aureon.c

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