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