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