projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-airlied' of git://people.freedesktop.org/~danvet/drm-intel into...
[deliverable/linux.git] / sound / pci / ice1712 / prodigy_hifi.c
1 /*
2 * ALSA driver for ICEnsemble VT1724 (Envy24HT)
3 *
4 * Lowlevel functions for Audiotrak Prodigy 7.1 Hifi
5 * based on pontis.c
6 *
7 * Copyright (c) 2007 Julian Scheel <julian@jusst.de>
8 * Copyright (c) 2007 allank
9 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26
27
28 #include <asm/io.h>
29 #include <linux/delay.h>
30 #include <linux/interrupt.h>
31 #include <linux/init.h>
32 #include <linux/slab.h>
33 #include <linux/mutex.h>
34
35 #include <sound/core.h>
36 #include <sound/info.h>
37 #include <sound/tlv.h>
38
39 #include "ice1712.h"
40 #include "envy24ht.h"
41 #include "prodigy_hifi.h"
42
43 struct prodigy_hifi_spec {
44 unsigned short master[2];
45 unsigned short vol[8];
46 };
47
48 /* I2C addresses */
49 #define WM_DEV 0x34
50
51 /* WM8776 registers */
52 #define WM_HP_ATTEN_L 0x00 /* headphone left attenuation */
53 #define WM_HP_ATTEN_R 0x01 /* headphone left attenuation */
54 #define WM_HP_MASTER 0x02 /* headphone master (both channels),
55 override LLR */
56 #define WM_DAC_ATTEN_L 0x03 /* digital left attenuation */
57 #define WM_DAC_ATTEN_R 0x04
58 #define WM_DAC_MASTER 0x05
59 #define WM_PHASE_SWAP 0x06 /* DAC phase swap */
60 #define WM_DAC_CTRL1 0x07
61 #define WM_DAC_MUTE 0x08
62 #define WM_DAC_CTRL2 0x09
63 #define WM_DAC_INT 0x0a
64 #define WM_ADC_INT 0x0b
65 #define WM_MASTER_CTRL 0x0c
66 #define WM_POWERDOWN 0x0d
67 #define WM_ADC_ATTEN_L 0x0e
68 #define WM_ADC_ATTEN_R 0x0f
69 #define WM_ALC_CTRL1 0x10
70 #define WM_ALC_CTRL2 0x11
71 #define WM_ALC_CTRL3 0x12
72 #define WM_NOISE_GATE 0x13
73 #define WM_LIMITER 0x14
74 #define WM_ADC_MUX 0x15
75 #define WM_OUT_MUX 0x16
76 #define WM_RESET 0x17
77
78 /* Analog Recording Source :- Mic, LineIn, CD/Video, */
79
80 /* implement capture source select control for WM8776 */
81
82 #define WM_AIN1 "AIN1"
83 #define WM_AIN2 "AIN2"
84 #define WM_AIN3 "AIN3"
85 #define WM_AIN4 "AIN4"
86 #define WM_AIN5 "AIN5"
87
88 /* GPIO pins of envy24ht connected to wm8766 */
89 #define WM8766_SPI_CLK (1<<17) /* CLK, Pin97 on ICE1724 */
90 #define WM8766_SPI_MD (1<<16) /* DATA VT1724 -> WM8766, Pin96 */
91 #define WM8766_SPI_ML (1<<18) /* Latch, Pin98 */
92
93 /* WM8766 registers */
94 #define WM8766_DAC_CTRL 0x02 /* DAC Control */
95 #define WM8766_INT_CTRL 0x03 /* Interface Control */
96 #define WM8766_DAC_CTRL2 0x09
97 #define WM8766_DAC_CTRL3 0x0a
98 #define WM8766_RESET 0x1f
99 #define WM8766_LDA1 0x00
100 #define WM8766_LDA2 0x04
101 #define WM8766_LDA3 0x06
102 #define WM8766_RDA1 0x01
103 #define WM8766_RDA2 0x05
104 #define WM8766_RDA3 0x07
105 #define WM8766_MUTE1 0x0C
106 #define WM8766_MUTE2 0x0F
107
108
109 /*
110 * Prodigy HD2
111 */
112 #define AK4396_ADDR 0x00
113 #define AK4396_CSN (1 << 8) /* CSN->GPIO8, pin 75 */
114 #define AK4396_CCLK (1 << 9) /* CCLK->GPIO9, pin 76 */
115 #define AK4396_CDTI (1 << 10) /* CDTI->GPIO10, pin 77 */
116
117 /* ak4396 registers */
118 #define AK4396_CTRL1 0x00
119 #define AK4396_CTRL2 0x01
120 #define AK4396_CTRL3 0x02
121 #define AK4396_LCH_ATT 0x03
122 #define AK4396_RCH_ATT 0x04
123
124
125 /*
126 * get the current register value of WM codec
127 */
128 static unsigned short wm_get(struct snd_ice1712 *ice, int reg)
129 {
130 reg <<= 1;
131 return ((unsigned short)ice->akm[0].images[reg] << 8) |
132 ice->akm[0].images[reg + 1];
133 }
134
135 /*
136 * set the register value of WM codec and remember it
137 */
138 static void wm_put_nocache(struct snd_ice1712 *ice, int reg, unsigned short val)
139 {
140 unsigned short cval;
141 cval = (reg << 9) | val;
142 snd_vt1724_write_i2c(ice, WM_DEV, cval >> 8, cval & 0xff);
143 }
144
145 static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val)
146 {
147 wm_put_nocache(ice, reg, val);
148 reg <<= 1;
149 ice->akm[0].images[reg] = val >> 8;
150 ice->akm[0].images[reg + 1] = val;
151 }
152
153 /*
154 * write data in the SPI mode
155 */
156
157 static void set_gpio_bit(struct snd_ice1712 *ice, unsigned int bit, int val)
158 {
159 unsigned int tmp = snd_ice1712_gpio_read(ice);
160 if (val)
161 tmp |= bit;
162 else
163 tmp &= ~bit;
164 snd_ice1712_gpio_write(ice, tmp);
165 }
166
167 /*
168 * SPI implementation for WM8766 codec - only writing supported, no readback
169 */
170
171 static void wm8766_spi_send_word(struct snd_ice1712 *ice, unsigned int data)
172 {
173 int i;
174 for (i = 0; i < 16; i++) {
175 set_gpio_bit(ice, WM8766_SPI_CLK, 0);
176 udelay(1);
177 set_gpio_bit(ice, WM8766_SPI_MD, data & 0x8000);
178 udelay(1);
179 set_gpio_bit(ice, WM8766_SPI_CLK, 1);
180 udelay(1);
181 data <<= 1;
182 }
183 }
184
185 static void wm8766_spi_write(struct snd_ice1712 *ice, unsigned int reg,
186 unsigned int data)
187 {
188 unsigned int block;
189
190 snd_ice1712_gpio_set_dir(ice, WM8766_SPI_MD|
191 WM8766_SPI_CLK|WM8766_SPI_ML);
192 snd_ice1712_gpio_set_mask(ice, ~(WM8766_SPI_MD|
193 WM8766_SPI_CLK|WM8766_SPI_ML));
194 /* latch must be low when writing */
195 set_gpio_bit(ice, WM8766_SPI_ML, 0);
196 block = (reg << 9) | (data & 0x1ff);
197 wm8766_spi_send_word(ice, block); /* REGISTER ADDRESS */
198 /* release latch */
199 set_gpio_bit(ice, WM8766_SPI_ML, 1);
200 udelay(1);
201 /* restore */
202 snd_ice1712_gpio_set_mask(ice, ice->gpio.write_mask);
203 snd_ice1712_gpio_set_dir(ice, ice->gpio.direction);
204 }
205
206
207 /*
208 * serial interface for ak4396 - only writing supported, no readback
209 */
210
211 static void ak4396_send_word(struct snd_ice1712 *ice, unsigned int data)
212 {
213 int i;
214 for (i = 0; i < 16; i++) {
215 set_gpio_bit(ice, AK4396_CCLK, 0);
216 udelay(1);
217 set_gpio_bit(ice, AK4396_CDTI, data & 0x8000);
218 udelay(1);
219 set_gpio_bit(ice, AK4396_CCLK, 1);
220 udelay(1);
221 data <<= 1;
222 }
223 }
224
225 static void ak4396_write(struct snd_ice1712 *ice, unsigned int reg,
226 unsigned int data)
227 {
228 unsigned int block;
229
230 snd_ice1712_gpio_set_dir(ice, AK4396_CSN|AK4396_CCLK|AK4396_CDTI);
231 snd_ice1712_gpio_set_mask(ice, ~(AK4396_CSN|AK4396_CCLK|AK4396_CDTI));
232 /* latch must be low when writing */
233 set_gpio_bit(ice, AK4396_CSN, 0);
234 block = ((AK4396_ADDR & 0x03) << 14) | (1 << 13) |
235 ((reg & 0x1f) << 8) | (data & 0xff);
236 ak4396_send_word(ice, block); /* REGISTER ADDRESS */
237 /* release latch */
238 set_gpio_bit(ice, AK4396_CSN, 1);
239 udelay(1);
240 /* restore */
241 snd_ice1712_gpio_set_mask(ice, ice->gpio.write_mask);
242 snd_ice1712_gpio_set_dir(ice, ice->gpio.direction);
243 }
244
245
246 /*
247 * ak4396 mixers
248 */
249
250
251
252 /*
253 * DAC volume attenuation mixer control (-64dB to 0dB)
254 */
255
256 static int ak4396_dac_vol_info(struct snd_kcontrol *kcontrol,
257 struct snd_ctl_elem_info *uinfo)
258 {
259 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
260 uinfo->count = 2;
261 uinfo->value.integer.min = 0; /* mute */
262 uinfo->value.integer.max = 0xFF; /* linear */
263 return 0;
264 }
265
266 static int ak4396_dac_vol_get(struct snd_kcontrol *kcontrol,
267 struct snd_ctl_elem_value *ucontrol)
268 {
269 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
270 struct prodigy_hifi_spec *spec = ice->spec;
271 int i;
272
273 for (i = 0; i < 2; i++)
274 ucontrol->value.integer.value[i] = spec->vol[i];
275
276 return 0;
277 }
278
279 static int ak4396_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
280 {
281 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
282 struct prodigy_hifi_spec *spec = ice->spec;
283 int i;
284 int change = 0;
285
286 mutex_lock(&ice->gpio_mutex);
287 for (i = 0; i < 2; i++) {
288 if (ucontrol->value.integer.value[i] != spec->vol[i]) {
289 spec->vol[i] = ucontrol->value.integer.value[i];
290 ak4396_write(ice, AK4396_LCH_ATT + i,
291 spec->vol[i] & 0xff);
292 change = 1;
293 }
294 }
295 mutex_unlock(&ice->gpio_mutex);
296 return change;
297 }
298
299 static const DECLARE_TLV_DB_SCALE(db_scale_wm_dac, -12700, 100, 1);
300 static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0);
301
302 static struct snd_kcontrol_new prodigy_hd2_controls[] __devinitdata = {
303 {
304 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
305 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
306 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
307 .name = "Front Playback Volume",
308 .info = ak4396_dac_vol_info,
309 .get = ak4396_dac_vol_get,
310 .put = ak4396_dac_vol_put,
311 .tlv = { .p = ak4396_db_scale },
312 },
313 };
314
315
316 /* --------------- */
317
318 /*
319 * Logarithmic volume values for WM87*6
320 * Computed as 20 * Log10(255 / x)
321 */
322 static const unsigned char wm_vol[256] = {
323 127, 48, 42, 39, 36, 34, 33, 31, 30, 29, 28, 27, 27, 26, 25, 25, 24, 24, 23,
324 23, 22, 22, 21, 21, 21, 20, 20, 20, 19, 19, 19, 18, 18, 18, 18, 17, 17, 17,
325 17, 16, 16, 16, 16, 15, 15, 15, 15, 15, 15, 14, 14, 14, 14, 14, 13, 13, 13,
326 13, 13, 13, 13, 12, 12, 12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11, 11, 11,
327 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8,
328 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6,
329 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
330 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3,
331 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
332 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
333 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
334 0, 0
335 };
336
337 #define WM_VOL_MAX (sizeof(wm_vol) - 1)
338 #define WM_VOL_MUTE 0x8000
339
340
341 #define DAC_0dB 0xff
342 #define DAC_RES 128
343 #define DAC_MIN (DAC_0dB - DAC_RES)
344
345
346 static void wm_set_vol(struct snd_ice1712 *ice, unsigned int index,
347 unsigned short vol, unsigned short master)
348 {
349 unsigned char nvol;
350
351 if ((master & WM_VOL_MUTE) || (vol & WM_VOL_MUTE))
352 nvol = 0;
353 else {
354 nvol = (((vol & ~WM_VOL_MUTE) * (master & ~WM_VOL_MUTE)) / 128)
355 & WM_VOL_MAX;
356 nvol = (nvol ? (nvol + DAC_MIN) : 0) & 0xff;
357 }
358
359 wm_put(ice, index, nvol);
360 wm_put_nocache(ice, index, 0x100 | nvol);
361 }
362
363 static void wm8766_set_vol(struct snd_ice1712 *ice, unsigned int index,
364 unsigned short vol, unsigned short master)
365 {
366 unsigned char nvol;
367
368 if ((master & WM_VOL_MUTE) || (vol & WM_VOL_MUTE))
369 nvol = 0;
370 else {
371 nvol = (((vol & ~WM_VOL_MUTE) * (master & ~WM_VOL_MUTE)) / 128)
372 & WM_VOL_MAX;
373 nvol = (nvol ? (nvol + DAC_MIN) : 0) & 0xff;
374 }
375
376 wm8766_spi_write(ice, index, (0x0100 | nvol));
377 }
378
379
380 /*
381 * DAC volume attenuation mixer control (-64dB to 0dB)
382 */
383
384 static int wm_dac_vol_info(struct snd_kcontrol *kcontrol,
385 struct snd_ctl_elem_info *uinfo)
386 {
387 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
388 uinfo->count = 2;
389 uinfo->value.integer.min = 0; /* mute */
390 uinfo->value.integer.max = DAC_RES; /* 0dB, 0.5dB step */
391 return 0;
392 }
393
394 static int wm_dac_vol_get(struct snd_kcontrol *kcontrol,
395 struct snd_ctl_elem_value *ucontrol)
396 {
397 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
398 struct prodigy_hifi_spec *spec = ice->spec;
399 int i;
400
401 for (i = 0; i < 2; i++)
402 ucontrol->value.integer.value[i] =
403 spec->vol[2 + i] & ~WM_VOL_MUTE;
404 return 0;
405 }
406
407 static int wm_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
408 {
409 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
410 struct prodigy_hifi_spec *spec = ice->spec;
411 int i, idx, change = 0;
412
413 mutex_lock(&ice->gpio_mutex);
414 for (i = 0; i < 2; i++) {
415 if (ucontrol->value.integer.value[i] != spec->vol[2 + i]) {
416 idx = WM_DAC_ATTEN_L + i;
417 spec->vol[2 + i] &= WM_VOL_MUTE;
418 spec->vol[2 + i] |= ucontrol->value.integer.value[i];
419 wm_set_vol(ice, idx, spec->vol[2 + i], spec->master[i]);
420 change = 1;
421 }
422 }
423 mutex_unlock(&ice->gpio_mutex);
424 return change;
425 }
426
427
428 /*
429 * WM8766 DAC volume attenuation mixer control
430 */
431 static int wm8766_vol_info(struct snd_kcontrol *kcontrol,
432 struct snd_ctl_elem_info *uinfo)
433 {
434 int voices = kcontrol->private_value >> 8;
435 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
436 uinfo->count = voices;
437 uinfo->value.integer.min = 0; /* mute */
438 uinfo->value.integer.max = DAC_RES; /* 0dB */
439 return 0;
440 }
441
442 static int wm8766_vol_get(struct snd_kcontrol *kcontrol,
443 struct snd_ctl_elem_value *ucontrol)
444 {
445 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
446 struct prodigy_hifi_spec *spec = ice->spec;
447 int i, ofs, voices;
448
449 voices = kcontrol->private_value >> 8;
450 ofs = kcontrol->private_value & 0xff;
451 for (i = 0; i < voices; i++)
452 ucontrol->value.integer.value[i] = spec->vol[ofs + i];
453 return 0;
454 }
455
456 static int wm8766_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
457 {
458 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
459 struct prodigy_hifi_spec *spec = ice->spec;
460 int i, idx, ofs, voices;
461 int change = 0;
462
463 voices = kcontrol->private_value >> 8;
464 ofs = kcontrol->private_value & 0xff;
465 mutex_lock(&ice->gpio_mutex);
466 for (i = 0; i < voices; i++) {
467 if (ucontrol->value.integer.value[i] != spec->vol[ofs + i]) {
468 idx = WM8766_LDA1 + ofs + i;
469 spec->vol[ofs + i] &= WM_VOL_MUTE;
470 spec->vol[ofs + i] |= ucontrol->value.integer.value[i];
471 wm8766_set_vol(ice, idx,
472 spec->vol[ofs + i], spec->master[i]);
473 change = 1;
474 }
475 }
476 mutex_unlock(&ice->gpio_mutex);
477 return change;
478 }
479
480 /*
481 * Master volume attenuation mixer control / applied to WM8776+WM8766
482 */
483 static int wm_master_vol_info(struct snd_kcontrol *kcontrol,
484 struct snd_ctl_elem_info *uinfo)
485 {
486 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
487 uinfo->count = 2;
488 uinfo->value.integer.min = 0;
489 uinfo->value.integer.max = DAC_RES;
490 return 0;
491 }
492
493 static int wm_master_vol_get(struct snd_kcontrol *kcontrol,
494 struct snd_ctl_elem_value *ucontrol)
495 {
496 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
497 struct prodigy_hifi_spec *spec = ice->spec;
498 int i;
499 for (i = 0; i < 2; i++)
500 ucontrol->value.integer.value[i] = spec->master[i];
501 return 0;
502 }
503
504 static int wm_master_vol_put(struct snd_kcontrol *kcontrol,
505 struct snd_ctl_elem_value *ucontrol)
506 {
507 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
508 struct prodigy_hifi_spec *spec = ice->spec;
509 int ch, change = 0;
510
511 mutex_lock(&ice->gpio_mutex);
512 for (ch = 0; ch < 2; ch++) {
513 if (ucontrol->value.integer.value[ch] != spec->master[ch]) {
514 spec->master[ch] = ucontrol->value.integer.value[ch];
515
516 /* Apply to front DAC */
517 wm_set_vol(ice, WM_DAC_ATTEN_L + ch,
518 spec->vol[2 + ch], spec->master[ch]);
519
520 wm8766_set_vol(ice, WM8766_LDA1 + ch,
521 spec->vol[0 + ch], spec->master[ch]);
522
523 wm8766_set_vol(ice, WM8766_LDA2 + ch,
524 spec->vol[4 + ch], spec->master[ch]);
525
526 wm8766_set_vol(ice, WM8766_LDA3 + ch,
527 spec->vol[6 + ch], spec->master[ch]);
528 change = 1;
529 }
530 }
531 mutex_unlock(&ice->gpio_mutex);
532 return change;
533 }
534
535
536 /* KONSTI */
537
538 static int wm_adc_mux_enum_info(struct snd_kcontrol *kcontrol,
539 struct snd_ctl_elem_info *uinfo)
540 {
541 static char* texts[32] = {
542 "NULL", WM_AIN1, WM_AIN2, WM_AIN1 "+" WM_AIN2,
543 WM_AIN3, WM_AIN1 "+" WM_AIN3, WM_AIN2 "+" WM_AIN3,
544 WM_AIN1 "+" WM_AIN2 "+" WM_AIN3,
545 WM_AIN4, WM_AIN1 "+" WM_AIN4, WM_AIN2 "+" WM_AIN4,
546 WM_AIN1 "+" WM_AIN2 "+" WM_AIN4,
547 WM_AIN3 "+" WM_AIN4, WM_AIN1 "+" WM_AIN3 "+" WM_AIN4,
548 WM_AIN2 "+" WM_AIN3 "+" WM_AIN4,
549 WM_AIN1 "+" WM_AIN2 "+" WM_AIN3 "+" WM_AIN4,
550 WM_AIN5, WM_AIN1 "+" WM_AIN5, WM_AIN2 "+" WM_AIN5,
551 WM_AIN1 "+" WM_AIN2 "+" WM_AIN5,
552 WM_AIN3 "+" WM_AIN5, WM_AIN1 "+" WM_AIN3 "+" WM_AIN5,
553 WM_AIN2 "+" WM_AIN3 "+" WM_AIN5,
554 WM_AIN1 "+" WM_AIN2 "+" WM_AIN3 "+" WM_AIN5,
555 WM_AIN4 "+" WM_AIN5, WM_AIN1 "+" WM_AIN4 "+" WM_AIN5,
556 WM_AIN2 "+" WM_AIN4 "+" WM_AIN5,
557 WM_AIN1 "+" WM_AIN2 "+" WM_AIN4 "+" WM_AIN5,
558 WM_AIN3 "+" WM_AIN4 "+" WM_AIN5,
559 WM_AIN1 "+" WM_AIN3 "+" WM_AIN4 "+" WM_AIN5,
560 WM_AIN2 "+" WM_AIN3 "+" WM_AIN4 "+" WM_AIN5,
561 WM_AIN1 "+" WM_AIN2 "+" WM_AIN3 "+" WM_AIN4 "+" WM_AIN5
562 };
563
564 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
565 uinfo->count = 1;
566 uinfo->value.enumerated.items = 32;
567 if (uinfo->value.enumerated.item > 31)
568 uinfo->value.enumerated.item = 31;
569 strcpy(uinfo->value.enumerated.name,
570 texts[uinfo->value.enumerated.item]);
571 return 0;
572 }
573
574 static int wm_adc_mux_enum_get(struct snd_kcontrol *kcontrol,
575 struct snd_ctl_elem_value *ucontrol)
576 {
577 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
578
579 mutex_lock(&ice->gpio_mutex);
580 ucontrol->value.integer.value[0] = wm_get(ice, WM_ADC_MUX) & 0x1f;
581 mutex_unlock(&ice->gpio_mutex);
582 return 0;
583 }
584
585 static int wm_adc_mux_enum_put(struct snd_kcontrol *kcontrol,
586 struct snd_ctl_elem_value *ucontrol)
587 {
588 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
589 unsigned short oval, nval;
590 int change = 0;
591
592 mutex_lock(&ice->gpio_mutex);
593 oval = wm_get(ice, WM_ADC_MUX);
594 nval = (oval & 0xe0) | ucontrol->value.integer.value[0];
595 if (nval != oval) {
596 wm_put(ice, WM_ADC_MUX, nval);
597 change = 1;
598 }
599 mutex_unlock(&ice->gpio_mutex);
600 return change;
601 }
602
603 /* KONSTI */
604
605 /*
606 * ADC gain mixer control (-64dB to 0dB)
607 */
608
609 #define ADC_0dB 0xcf
610 #define ADC_RES 128
611 #define ADC_MIN (ADC_0dB - ADC_RES)
612
613 static int wm_adc_vol_info(struct snd_kcontrol *kcontrol,
614 struct snd_ctl_elem_info *uinfo)
615 {
616 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
617 uinfo->count = 2;
618 uinfo->value.integer.min = 0; /* mute (-64dB) */
619 uinfo->value.integer.max = ADC_RES; /* 0dB, 0.5dB step */
620 return 0;
621 }
622
623 static int wm_adc_vol_get(struct snd_kcontrol *kcontrol,
624 struct snd_ctl_elem_value *ucontrol)
625 {
626 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
627 unsigned short val;
628 int i;
629
630 mutex_lock(&ice->gpio_mutex);
631 for (i = 0; i < 2; i++) {
632 val = wm_get(ice, WM_ADC_ATTEN_L + i) & 0xff;
633 val = val > ADC_MIN ? (val - ADC_MIN) : 0;
634 ucontrol->value.integer.value[i] = val;
635 }
636 mutex_unlock(&ice->gpio_mutex);
637 return 0;
638 }
639
640 static int wm_adc_vol_put(struct snd_kcontrol *kcontrol,
641 struct snd_ctl_elem_value *ucontrol)
642 {
643 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
644 unsigned short ovol, nvol;
645 int i, idx, change = 0;
646
647 mutex_lock(&ice->gpio_mutex);
648 for (i = 0; i < 2; i++) {
649 nvol = ucontrol->value.integer.value[i];
650 nvol = nvol ? (nvol + ADC_MIN) : 0;
651 idx = WM_ADC_ATTEN_L + i;
652 ovol = wm_get(ice, idx) & 0xff;
653 if (ovol != nvol) {
654 wm_put(ice, idx, nvol);
655 change = 1;
656 }
657 }
658 mutex_unlock(&ice->gpio_mutex);
659 return change;
660 }
661
662 /*
663 * ADC input mux mixer control
664 */
665 #define wm_adc_mux_info snd_ctl_boolean_mono_info
666
667 static int wm_adc_mux_get(struct snd_kcontrol *kcontrol,
668 struct snd_ctl_elem_value *ucontrol)
669 {
670 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
671 int bit = kcontrol->private_value;
672
673 mutex_lock(&ice->gpio_mutex);
674 ucontrol->value.integer.value[0] =
675 (wm_get(ice, WM_ADC_MUX) & (1 << bit)) ? 1 : 0;
676 mutex_unlock(&ice->gpio_mutex);
677 return 0;
678 }
679
680 static int wm_adc_mux_put(struct snd_kcontrol *kcontrol,
681 struct snd_ctl_elem_value *ucontrol)
682 {
683 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
684 int bit = kcontrol->private_value;
685 unsigned short oval, nval;
686 int change;
687
688 mutex_lock(&ice->gpio_mutex);
689 nval = oval = wm_get(ice, WM_ADC_MUX);
690 if (ucontrol->value.integer.value[0])
691 nval |= (1 << bit);
692 else
693 nval &= ~(1 << bit);
694 change = nval != oval;
695 if (change) {
696 wm_put(ice, WM_ADC_MUX, nval);
697 }
698 mutex_unlock(&ice->gpio_mutex);
699 return 0;
700 }
701
702 /*
703 * Analog bypass (In -> Out)
704 */
705 #define wm_bypass_info snd_ctl_boolean_mono_info
706
707 static int wm_bypass_get(struct snd_kcontrol *kcontrol,
708 struct snd_ctl_elem_value *ucontrol)
709 {
710 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
711
712 mutex_lock(&ice->gpio_mutex);
713 ucontrol->value.integer.value[0] =
714 (wm_get(ice, WM_OUT_MUX) & 0x04) ? 1 : 0;
715 mutex_unlock(&ice->gpio_mutex);
716 return 0;
717 }
718
719 static int wm_bypass_put(struct snd_kcontrol *kcontrol,
720 struct snd_ctl_elem_value *ucontrol)
721 {
722 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
723 unsigned short val, oval;
724 int change = 0;
725
726 mutex_lock(&ice->gpio_mutex);
727 val = oval = wm_get(ice, WM_OUT_MUX);
728 if (ucontrol->value.integer.value[0])
729 val |= 0x04;
730 else
731 val &= ~0x04;
732 if (val != oval) {
733 wm_put(ice, WM_OUT_MUX, val);
734 change = 1;
735 }
736 mutex_unlock(&ice->gpio_mutex);
737 return change;
738 }
739
740 /*
741 * Left/Right swap
742 */
743 #define wm_chswap_info snd_ctl_boolean_mono_info
744
745 static int wm_chswap_get(struct snd_kcontrol *kcontrol,
746 struct snd_ctl_elem_value *ucontrol)
747 {
748 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
749
750 mutex_lock(&ice->gpio_mutex);
751 ucontrol->value.integer.value[0] =
752 (wm_get(ice, WM_DAC_CTRL1) & 0xf0) != 0x90;
753 mutex_unlock(&ice->gpio_mutex);
754 return 0;
755 }
756
757 static int wm_chswap_put(struct snd_kcontrol *kcontrol,
758 struct snd_ctl_elem_value *ucontrol)
759 {
760 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
761 unsigned short val, oval;
762 int change = 0;
763
764 mutex_lock(&ice->gpio_mutex);
765 oval = wm_get(ice, WM_DAC_CTRL1);
766 val = oval & 0x0f;
767 if (ucontrol->value.integer.value[0])
768 val |= 0x60;
769 else
770 val |= 0x90;
771 if (val != oval) {
772 wm_put(ice, WM_DAC_CTRL1, val);
773 wm_put_nocache(ice, WM_DAC_CTRL1, val);
774 change = 1;
775 }
776 mutex_unlock(&ice->gpio_mutex);
777 return change;
778 }
779
780
781 /*
782 * mixers
783 */
784
785 static struct snd_kcontrol_new prodigy_hifi_controls[] __devinitdata = {
786 {
787 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
788 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
789 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
790 .name = "Master Playback Volume",
791 .info = wm_master_vol_info,
792 .get = wm_master_vol_get,
793 .put = wm_master_vol_put,
794 .tlv = { .p = db_scale_wm_dac }
795 },
796 {
797 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
798 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
799 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
800 .name = "Front Playback Volume",
801 .info = wm_dac_vol_info,
802 .get = wm_dac_vol_get,
803 .put = wm_dac_vol_put,
804 .tlv = { .p = db_scale_wm_dac },
805 },
806 {
807 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
808 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
809 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
810 .name = "Rear Playback Volume",
811 .info = wm8766_vol_info,
812 .get = wm8766_vol_get,
813 .put = wm8766_vol_put,
814 .private_value = (2 << 8) | 0,
815 .tlv = { .p = db_scale_wm_dac },
816 },
817 {
818 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
819 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
820 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
821 .name = "Center Playback Volume",
822 .info = wm8766_vol_info,
823 .get = wm8766_vol_get,
824 .put = wm8766_vol_put,
825 .private_value = (1 << 8) | 4,
826 .tlv = { .p = db_scale_wm_dac }
827 },
828 {
829 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
830 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
831 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
832 .name = "LFE Playback Volume",
833 .info = wm8766_vol_info,
834 .get = wm8766_vol_get,
835 .put = wm8766_vol_put,
836 .private_value = (1 << 8) | 5,
837 .tlv = { .p = db_scale_wm_dac }
838 },
839 {
840 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
841 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
842 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
843 .name = "Side Playback Volume",
844 .info = wm8766_vol_info,
845 .get = wm8766_vol_get,
846 .put = wm8766_vol_put,
847 .private_value = (2 << 8) | 6,
848 .tlv = { .p = db_scale_wm_dac },
849 },
850 {
851 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
852 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
853 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
854 .name = "Capture Volume",
855 .info = wm_adc_vol_info,
856 .get = wm_adc_vol_get,
857 .put = wm_adc_vol_put,
858 .tlv = { .p = db_scale_wm_dac },
859 },
860 {
861 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
862 .name = "CD Capture Switch",
863 .info = wm_adc_mux_info,
864 .get = wm_adc_mux_get,
865 .put = wm_adc_mux_put,
866 .private_value = 0,
867 },
868 {
869 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
870 .name = "Line Capture Switch",
871 .info = wm_adc_mux_info,
872 .get = wm_adc_mux_get,
873 .put = wm_adc_mux_put,
874 .private_value = 1,
875 },
876 {
877 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
878 .name = "Analog Bypass Switch",
879 .info = wm_bypass_info,
880 .get = wm_bypass_get,
881 .put = wm_bypass_put,
882 },
883 {
884 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
885 .name = "Swap Output Channels",
886 .info = wm_chswap_info,
887 .get = wm_chswap_get,
888 .put = wm_chswap_put,
889 },
890 {
891 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
892 .name = "Analog Capture Source",
893 .info = wm_adc_mux_enum_info,
894 .get = wm_adc_mux_enum_get,
895 .put = wm_adc_mux_enum_put,
896 },
897 };
898
899 /*
900 * WM codec registers
901 */
902 static void wm_proc_regs_write(struct snd_info_entry *entry,
903 struct snd_info_buffer *buffer)
904 {
905 struct snd_ice1712 *ice = entry->private_data;
906 char line[64];
907 unsigned int reg, val;
908 mutex_lock(&ice->gpio_mutex);
909 while (!snd_info_get_line(buffer, line, sizeof(line))) {
910 if (sscanf(line, "%x %x", &reg, &val) != 2)
911 continue;
912 if (reg <= 0x17 && val <= 0xffff)
913 wm_put(ice, reg, val);
914 }
915 mutex_unlock(&ice->gpio_mutex);
916 }
917
918 static void wm_proc_regs_read(struct snd_info_entry *entry,
919 struct snd_info_buffer *buffer)
920 {
921 struct snd_ice1712 *ice = entry->private_data;
922 int reg, val;
923
924 mutex_lock(&ice->gpio_mutex);
925 for (reg = 0; reg <= 0x17; reg++) {
926 val = wm_get(ice, reg);
927 snd_iprintf(buffer, "%02x = %04x\n", reg, val);
928 }
929 mutex_unlock(&ice->gpio_mutex);
930 }
931
932 static void wm_proc_init(struct snd_ice1712 *ice)
933 {
934 struct snd_info_entry *entry;
935 if (!snd_card_proc_new(ice->card, "wm_codec", &entry)) {
936 snd_info_set_text_ops(entry, ice, wm_proc_regs_read);
937 entry->mode |= S_IWUSR;
938 entry->c.text.write = wm_proc_regs_write;
939 }
940 }
941
942 static int __devinit prodigy_hifi_add_controls(struct snd_ice1712 *ice)
943 {
944 unsigned int i;
945 int err;
946
947 for (i = 0; i < ARRAY_SIZE(prodigy_hifi_controls); i++) {
948 err = snd_ctl_add(ice->card,
949 snd_ctl_new1(&prodigy_hifi_controls[i], ice));
950 if (err < 0)
951 return err;
952 }
953
954 wm_proc_init(ice);
955
956 return 0;
957 }
958
959 static int __devinit prodigy_hd2_add_controls(struct snd_ice1712 *ice)
960 {
961 unsigned int i;
962 int err;
963
964 for (i = 0; i < ARRAY_SIZE(prodigy_hd2_controls); i++) {
965 err = snd_ctl_add(ice->card,
966 snd_ctl_new1(&prodigy_hd2_controls[i], ice));
967 if (err < 0)
968 return err;
969 }
970
971 wm_proc_init(ice);
972
973 return 0;
974 }
975
976
977 /*
978 * initialize the chip
979 */
980 static int __devinit prodigy_hifi_init(struct snd_ice1712 *ice)
981 {
982 static unsigned short wm_inits[] = {
983 /* These come first to reduce init pop noise */
984 WM_ADC_MUX, 0x0003, /* ADC mute */
985 /* 0x00c0 replaced by 0x0003 */
986
987 WM_DAC_MUTE, 0x0001, /* DAC softmute */
988 WM_DAC_CTRL1, 0x0000, /* DAC mute */
989
990 WM_POWERDOWN, 0x0008, /* All power-up except HP */
991 WM_RESET, 0x0000, /* reset */
992 };
993 static unsigned short wm_inits2[] = {
994 WM_MASTER_CTRL, 0x0022, /* 256fs, slave mode */
995 WM_DAC_INT, 0x0022, /* I2S, normal polarity, 24bit */
996 WM_ADC_INT, 0x0022, /* I2S, normal polarity, 24bit */
997 WM_DAC_CTRL1, 0x0090, /* DAC L/R */
998 WM_OUT_MUX, 0x0001, /* OUT DAC */
999 WM_HP_ATTEN_L, 0x0179, /* HP 0dB */
1000 WM_HP_ATTEN_R, 0x0179, /* HP 0dB */
1001 WM_DAC_ATTEN_L, 0x0000, /* DAC 0dB */
1002 WM_DAC_ATTEN_L, 0x0100, /* DAC 0dB */
1003 WM_DAC_ATTEN_R, 0x0000, /* DAC 0dB */
1004 WM_DAC_ATTEN_R, 0x0100, /* DAC 0dB */
1005 WM_PHASE_SWAP, 0x0000, /* phase normal */
1006 #if 0
1007 WM_DAC_MASTER, 0x0100, /* DAC master muted */
1008 #endif
1009 WM_DAC_CTRL2, 0x0000, /* no deemphasis, no ZFLG */
1010 WM_ADC_ATTEN_L, 0x0000, /* ADC muted */
1011 WM_ADC_ATTEN_R, 0x0000, /* ADC muted */
1012 #if 1
1013 WM_ALC_CTRL1, 0x007b, /* */
1014 WM_ALC_CTRL2, 0x0000, /* */
1015 WM_ALC_CTRL3, 0x0000, /* */
1016 WM_NOISE_GATE, 0x0000, /* */
1017 #endif
1018 WM_DAC_MUTE, 0x0000, /* DAC unmute */
1019 WM_ADC_MUX, 0x0003, /* ADC unmute, both CD/Line On */
1020 };
1021 static unsigned short wm8766_inits[] = {
1022 WM8766_RESET, 0x0000,
1023 WM8766_DAC_CTRL, 0x0120,
1024 WM8766_INT_CTRL, 0x0022, /* I2S Normal Mode, 24 bit */
1025 WM8766_DAC_CTRL2, 0x0001,
1026 WM8766_DAC_CTRL3, 0x0080,
1027 WM8766_LDA1, 0x0100,
1028 WM8766_LDA2, 0x0100,
1029 WM8766_LDA3, 0x0100,
1030 WM8766_RDA1, 0x0100,
1031 WM8766_RDA2, 0x0100,
1032 WM8766_RDA3, 0x0100,
1033 WM8766_MUTE1, 0x0000,
1034 WM8766_MUTE2, 0x0000,
1035 };
1036
1037 struct prodigy_hifi_spec *spec;
1038 unsigned int i;
1039
1040 ice->vt1720 = 0;
1041 ice->vt1724 = 1;
1042
1043 ice->num_total_dacs = 8;
1044 ice->num_total_adcs = 1;
1045
1046 /* HACK - use this as the SPDIF source.
1047 * don't call snd_ice1712_gpio_get/put(), otherwise it's overwritten
1048 */
1049 ice->gpio.saved[0] = 0;
1050 /* to remember the register values */
1051
1052 ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
1053 if (! ice->akm)
1054 return -ENOMEM;
1055 ice->akm_codecs = 1;
1056
1057 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1058 if (!spec)
1059 return -ENOMEM;
1060 ice->spec = spec;
1061
1062 /* initialize WM8776 codec */
1063 for (i = 0; i < ARRAY_SIZE(wm_inits); i += 2)
1064 wm_put(ice, wm_inits[i], wm_inits[i+1]);
1065 schedule_timeout_uninterruptible(1);
1066 for (i = 0; i < ARRAY_SIZE(wm_inits2); i += 2)
1067 wm_put(ice, wm_inits2[i], wm_inits2[i+1]);
1068
1069 /* initialize WM8766 codec */
1070 for (i = 0; i < ARRAY_SIZE(wm8766_inits); i += 2)
1071 wm8766_spi_write(ice, wm8766_inits[i], wm8766_inits[i+1]);
1072
1073
1074 return 0;
1075 }
1076
1077
1078 /*
1079 * initialize the chip
1080 */
1081 static void ak4396_init(struct snd_ice1712 *ice)
1082 {
1083 static unsigned short ak4396_inits[] = {
1084 AK4396_CTRL1, 0x87, /* I2S Normal Mode, 24 bit */
1085 AK4396_CTRL2, 0x02,
1086 AK4396_CTRL3, 0x00,
1087 AK4396_LCH_ATT, 0x00,
1088 AK4396_RCH_ATT, 0x00,
1089 };
1090
1091 unsigned int i;
1092
1093 /* initialize ak4396 codec */
1094 /* reset codec */
1095 ak4396_write(ice, AK4396_CTRL1, 0x86);
1096 msleep(100);
1097 ak4396_write(ice, AK4396_CTRL1, 0x87);
1098
1099 for (i = 0; i < ARRAY_SIZE(ak4396_inits); i += 2)
1100 ak4396_write(ice, ak4396_inits[i], ak4396_inits[i+1]);
1101 }
1102
1103 #ifdef CONFIG_PM
1104 static int prodigy_hd2_resume(struct snd_ice1712 *ice)
1105 {
1106 /* initialize ak4396 codec and restore previous mixer volumes */
1107 struct prodigy_hifi_spec *spec = ice->spec;
1108 int i;
1109 mutex_lock(&ice->gpio_mutex);
1110 ak4396_init(ice);
1111 for (i = 0; i < 2; i++)
1112 ak4396_write(ice, AK4396_LCH_ATT + i, spec->vol[i] & 0xff);
1113 mutex_unlock(&ice->gpio_mutex);
1114 return 0;
1115 }
1116 #endif
1117
1118 static int __devinit prodigy_hd2_init(struct snd_ice1712 *ice)
1119 {
1120 struct prodigy_hifi_spec *spec;
1121
1122 ice->vt1720 = 0;
1123 ice->vt1724 = 1;
1124
1125 ice->num_total_dacs = 1;
1126 ice->num_total_adcs = 1;
1127
1128 /* HACK - use this as the SPDIF source.
1129 * don't call snd_ice1712_gpio_get/put(), otherwise it's overwritten
1130 */
1131 ice->gpio.saved[0] = 0;
1132 /* to remember the register values */
1133
1134 ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
1135 if (! ice->akm)
1136 return -ENOMEM;
1137 ice->akm_codecs = 1;
1138
1139 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1140 if (!spec)
1141 return -ENOMEM;
1142 ice->spec = spec;
1143
1144 #ifdef CONFIG_PM
1145 ice->pm_resume = &prodigy_hd2_resume;
1146 ice->pm_suspend_enabled = 1;
1147 #endif
1148
1149 ak4396_init(ice);
1150
1151 return 0;
1152 }
1153
1154
1155 static unsigned char prodigy71hifi_eeprom[] __devinitdata = {
1156 0x4b, /* SYSCONF: clock 512, spdif-in/ADC, 4DACs */
1157 0x80, /* ACLINK: I2S */
1158 0xfc, /* I2S: vol, 96k, 24bit, 192k */
1159 0xc3, /* SPDIF: out-en, out-int, spdif-in */
1160 0xff, /* GPIO_DIR */
1161 0xff, /* GPIO_DIR1 */
1162 0x5f, /* GPIO_DIR2 */
1163 0x00, /* GPIO_MASK */
1164 0x00, /* GPIO_MASK1 */
1165 0x00, /* GPIO_MASK2 */
1166 0x00, /* GPIO_STATE */
1167 0x00, /* GPIO_STATE1 */
1168 0x00, /* GPIO_STATE2 */
1169 };
1170
1171 static unsigned char prodigyhd2_eeprom[] __devinitdata = {
1172 0x4b, /* SYSCONF: clock 512, spdif-in/ADC, 4DACs */
1173 0x80, /* ACLINK: I2S */
1174 0xfc, /* I2S: vol, 96k, 24bit, 192k */
1175 0xc3, /* SPDIF: out-en, out-int, spdif-in */
1176 0xff, /* GPIO_DIR */
1177 0xff, /* GPIO_DIR1 */
1178 0x5f, /* GPIO_DIR2 */
1179 0x00, /* GPIO_MASK */
1180 0x00, /* GPIO_MASK1 */
1181 0x00, /* GPIO_MASK2 */
1182 0x00, /* GPIO_STATE */
1183 0x00, /* GPIO_STATE1 */
1184 0x00, /* GPIO_STATE2 */
1185 };
1186
1187 static unsigned char fortissimo4_eeprom[] __devinitdata = {
1188 0x43, /* SYSCONF: clock 512, ADC, 4DACs */
1189 0x80, /* ACLINK: I2S */
1190 0xfc, /* I2S: vol, 96k, 24bit, 192k */
1191 0xc1, /* SPDIF: out-en, out-int */
1192 0xff, /* GPIO_DIR */
1193 0xff, /* GPIO_DIR1 */
1194 0x5f, /* GPIO_DIR2 */
1195 0x00, /* GPIO_MASK */
1196 0x00, /* GPIO_MASK1 */
1197 0x00, /* GPIO_MASK2 */
1198 0x00, /* GPIO_STATE */
1199 0x00, /* GPIO_STATE1 */
1200 0x00, /* GPIO_STATE2 */
1201 };
1202
1203 /* entry point */
1204 struct snd_ice1712_card_info snd_vt1724_prodigy_hifi_cards[] __devinitdata = {
1205 {
1206 .subvendor = VT1724_SUBDEVICE_PRODIGY_HIFI,
1207 .name = "Audiotrak Prodigy 7.1 HiFi",
1208 .model = "prodigy71hifi",
1209 .chip_init = prodigy_hifi_init,
1210 .build_controls = prodigy_hifi_add_controls,
1211 .eeprom_size = sizeof(prodigy71hifi_eeprom),
1212 .eeprom_data = prodigy71hifi_eeprom,
1213 .driver = "Prodigy71HIFI",
1214 },
1215 {
1216 .subvendor = VT1724_SUBDEVICE_PRODIGY_HD2,
1217 .name = "Audiotrak Prodigy HD2",
1218 .model = "prodigyhd2",
1219 .chip_init = prodigy_hd2_init,
1220 .build_controls = prodigy_hd2_add_controls,
1221 .eeprom_size = sizeof(prodigyhd2_eeprom),
1222 .eeprom_data = prodigyhd2_eeprom,
1223 .driver = "Prodigy71HD2",
1224 },
1225 {
1226 .subvendor = VT1724_SUBDEVICE_FORTISSIMO4,
1227 .name = "Hercules Fortissimo IV",
1228 .model = "fortissimo4",
1229 .chip_init = prodigy_hifi_init,
1230 .build_controls = prodigy_hifi_add_controls,
1231 .eeprom_size = sizeof(fortissimo4_eeprom),
1232 .eeprom_data = fortissimo4_eeprom,
1233 .driver = "Fortissimo4",
1234 },
1235 { } /* terminator */
1236 };
1237
Linux kernel - Deliverables
This page took 0.058537 seconds and 5 git commands to generate.