1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57#include <linux/delay.h>
58#include <linux/interrupt.h>
59#include <linux/init.h>
60#include <linux/slab.h>
61#include <sound/core.h>
62
63#include "ice1712.h"
64#include "envy24ht.h"
65#include "prodigy192.h"
66#include "stac946x.h"
67#include <sound/tlv.h>
68
69struct prodigy192_spec {
70 struct ak4114 *ak4114;
71
72 struct mutex mute_mutex;
73};
74
75static inline void stac9460_put(struct snd_ice1712 *ice, int reg, unsigned char val)
76{
77 snd_vt1724_write_i2c(ice, PRODIGY192_STAC9460_ADDR, reg, val);
78}
79
80static inline unsigned char stac9460_get(struct snd_ice1712 *ice, int reg)
81{
82 return snd_vt1724_read_i2c(ice, PRODIGY192_STAC9460_ADDR, reg);
83}
84
85
86
87
88
89
90
91
92static int stac9460_dac_mute(struct snd_ice1712 *ice, int idx,
93 unsigned char mute)
94{
95 unsigned char new, old;
96 int change;
97 old = stac9460_get(ice, idx);
98 new = (~mute << 7 & 0x80) | (old & ~0x80);
99 change = (new != old);
100 if (change)
101
102 stac9460_put(ice, idx, new);
103 return change;
104}
105
106#define stac9460_dac_mute_info snd_ctl_boolean_mono_info
107
108static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
109{
110 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
111 unsigned char val;
112 int idx;
113
114 if (kcontrol->private_value)
115 idx = STAC946X_MASTER_VOLUME;
116 else
117 idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
118 val = stac9460_get(ice, idx);
119 ucontrol->value.integer.value[0] = (~val >> 7) & 0x1;
120 return 0;
121}
122
123static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
124{
125 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
126 struct prodigy192_spec *spec = ice->spec;
127 int idx, change;
128
129 if (kcontrol->private_value)
130 idx = STAC946X_MASTER_VOLUME;
131 else
132 idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
133
134 mutex_lock(&spec->mute_mutex);
135
136
137
138
139 change = stac9460_dac_mute(ice, idx, ucontrol->value.integer.value[0]);
140 mutex_unlock(&spec->mute_mutex);
141 return change;
142}
143
144
145
146
147static int stac9460_dac_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
148{
149 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
150 uinfo->count = 1;
151 uinfo->value.integer.min = 0;
152 uinfo->value.integer.max = 0x7f;
153 return 0;
154}
155
156static int stac9460_dac_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
157{
158 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
159 int idx;
160 unsigned char vol;
161
162 if (kcontrol->private_value)
163 idx = STAC946X_MASTER_VOLUME;
164 else
165 idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
166 vol = stac9460_get(ice, idx) & 0x7f;
167 ucontrol->value.integer.value[0] = 0x7f - vol;
168
169 return 0;
170}
171
172static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
173{
174 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
175 int idx;
176 unsigned char tmp, ovol, nvol;
177 int change;
178
179 if (kcontrol->private_value)
180 idx = STAC946X_MASTER_VOLUME;
181 else
182 idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
183 nvol = ucontrol->value.integer.value[0];
184 tmp = stac9460_get(ice, idx);
185 ovol = 0x7f - (tmp & 0x7f);
186 change = (ovol != nvol);
187 if (change) {
188 ovol = (0x7f - nvol) | (tmp & 0x80);
189
190
191
192
193 stac9460_put(ice, idx, (0x7f - nvol) | (tmp & 0x80));
194 }
195 return change;
196}
197
198
199
200
201#define stac9460_adc_mute_info snd_ctl_boolean_stereo_info
202
203static int stac9460_adc_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
204{
205 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
206 unsigned char val;
207 int i;
208
209 for (i = 0; i < 2; ++i) {
210 val = stac9460_get(ice, STAC946X_MIC_L_VOLUME + i);
211 ucontrol->value.integer.value[i] = ~val>>7 & 0x1;
212 }
213
214 return 0;
215}
216
217static int stac9460_adc_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
218{
219 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
220 unsigned char new, old;
221 int i, reg;
222 int change;
223
224 for (i = 0; i < 2; ++i) {
225 reg = STAC946X_MIC_L_VOLUME + i;
226 old = stac9460_get(ice, reg);
227 new = (~ucontrol->value.integer.value[i]<<7&0x80) | (old&~0x80);
228 change = (new != old);
229 if (change)
230 stac9460_put(ice, reg, new);
231 }
232
233 return change;
234}
235
236
237
238
239static int stac9460_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
240{
241 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
242 uinfo->count = 2;
243 uinfo->value.integer.min = 0;
244 uinfo->value.integer.max = 0x0f;
245 return 0;
246}
247
248static int stac9460_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
249{
250 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
251 int i, reg;
252 unsigned char vol;
253
254 for (i = 0; i < 2; ++i) {
255 reg = STAC946X_MIC_L_VOLUME + i;
256 vol = stac9460_get(ice, reg) & 0x0f;
257 ucontrol->value.integer.value[i] = 0x0f - vol;
258 }
259
260 return 0;
261}
262
263static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
264{
265 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
266 int i, reg;
267 unsigned char ovol, nvol;
268 int change;
269
270 for (i = 0; i < 2; ++i) {
271 reg = STAC946X_MIC_L_VOLUME + i;
272 nvol = ucontrol->value.integer.value[i] & 0x0f;
273 ovol = 0x0f - stac9460_get(ice, reg);
274 change = ((ovol & 0x0f) != nvol);
275 if (change)
276 stac9460_put(ice, reg, (0x0f - nvol) | (ovol & ~0x0f));
277 }
278
279 return change;
280}
281
282static int stac9460_mic_sw_info(struct snd_kcontrol *kcontrol,
283 struct snd_ctl_elem_info *uinfo)
284{
285 static const char * const texts[2] = { "Line In", "Mic" };
286
287 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
288 uinfo->count = 1;
289 uinfo->value.enumerated.items = 2;
290
291 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
292 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
293 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
294
295 return 0;
296}
297
298
299static int stac9460_mic_sw_get(struct snd_kcontrol *kcontrol,
300 struct snd_ctl_elem_value *ucontrol)
301{
302 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
303 unsigned char val;
304
305 val = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
306 ucontrol->value.enumerated.item[0] = (val >> 7) & 0x1;
307 return 0;
308}
309
310static int stac9460_mic_sw_put(struct snd_kcontrol *kcontrol,
311 struct snd_ctl_elem_value *ucontrol)
312{
313 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
314 unsigned char new, old;
315 int change;
316 old = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
317 new = (ucontrol->value.enumerated.item[0] << 7 & 0x80) | (old & ~0x80);
318 change = (new != old);
319 if (change)
320 stac9460_put(ice, STAC946X_GENERAL_PURPOSE, new);
321 return change;
322}
323
324
325
326static void stac9460_set_rate_val(struct snd_ice1712 *ice, unsigned int rate)
327{
328 unsigned char old, new;
329 int idx;
330 unsigned char changed[7];
331 struct prodigy192_spec *spec = ice->spec;
332
333 if (rate == 0)
334 return;
335 else if (rate <= 48000)
336 new = 0x08;
337 else if (rate <= 96000)
338 new = 0x11;
339 else
340 new = 0x12;
341 old = stac9460_get(ice, STAC946X_MASTER_CLOCKING);
342 if (old == new)
343 return;
344
345
346 mutex_lock(&spec->mute_mutex);
347
348 for (idx = 0; idx < 7 ; ++idx)
349 changed[idx] = stac9460_dac_mute(ice,
350 STAC946X_MASTER_VOLUME + idx, 0);
351
352 stac9460_put(ice, STAC946X_MASTER_CLOCKING, new);
353 udelay(10);
354
355
356 for (idx = 0; idx < 7 ; ++idx) {
357 if (changed[idx])
358 stac9460_dac_mute(ice, STAC946X_MASTER_VOLUME + idx, 1);
359 }
360 mutex_unlock(&spec->mute_mutex);
361}
362
363
364static const DECLARE_TLV_DB_SCALE(db_scale_dac, -19125, 75, 0);
365static const DECLARE_TLV_DB_SCALE(db_scale_adc, 0, 150, 0);
366
367
368
369
370
371static struct snd_kcontrol_new stac_controls[] = {
372 {
373 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
374 .name = "Master Playback Switch",
375 .info = stac9460_dac_mute_info,
376 .get = stac9460_dac_mute_get,
377 .put = stac9460_dac_mute_put,
378 .private_value = 1,
379 .tlv = { .p = db_scale_dac }
380 },
381 {
382 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
383 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
384 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
385 .name = "Master Playback Volume",
386 .info = stac9460_dac_vol_info,
387 .get = stac9460_dac_vol_get,
388 .put = stac9460_dac_vol_put,
389 .private_value = 1,
390 .tlv = { .p = db_scale_dac }
391 },
392 {
393 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
394 .name = "DAC Switch",
395 .count = 6,
396 .info = stac9460_dac_mute_info,
397 .get = stac9460_dac_mute_get,
398 .put = stac9460_dac_mute_put,
399 },
400 {
401 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
402 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
403 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
404 .name = "DAC Volume",
405 .count = 6,
406 .info = stac9460_dac_vol_info,
407 .get = stac9460_dac_vol_get,
408 .put = stac9460_dac_vol_put,
409 .tlv = { .p = db_scale_dac }
410 },
411 {
412 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
413 .name = "ADC Capture Switch",
414 .count = 1,
415 .info = stac9460_adc_mute_info,
416 .get = stac9460_adc_mute_get,
417 .put = stac9460_adc_mute_put,
418
419 },
420 {
421 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
422 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
423 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
424 .name = "ADC Capture Volume",
425 .count = 1,
426 .info = stac9460_adc_vol_info,
427 .get = stac9460_adc_vol_get,
428 .put = stac9460_adc_vol_put,
429 .tlv = { .p = db_scale_adc }
430 },
431 {
432 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
433 .name = "Analog Capture Input",
434 .info = stac9460_mic_sw_info,
435 .get = stac9460_mic_sw_get,
436 .put = stac9460_mic_sw_put,
437
438 },
439};
440
441
442
443
444
445
446
447#define AK4114_ADDR 0x00
448
449
450
451
452
453
454static void write_data(struct snd_ice1712 *ice, unsigned int gpio,
455 unsigned int data, int idx)
456{
457 for (; idx >= 0; idx--) {
458
459 gpio &= ~VT1724_PRODIGY192_CCLK;
460 snd_ice1712_gpio_write(ice, gpio);
461 udelay(1);
462
463 if (data & (1 << idx))
464 gpio |= VT1724_PRODIGY192_CDOUT;
465 else
466 gpio &= ~VT1724_PRODIGY192_CDOUT;
467 snd_ice1712_gpio_write(ice, gpio);
468 udelay(1);
469
470 gpio |= VT1724_PRODIGY192_CCLK;
471 snd_ice1712_gpio_write(ice, gpio);
472 udelay(1);
473 }
474}
475
476
477
478
479static unsigned char read_data(struct snd_ice1712 *ice, unsigned int gpio,
480 int idx)
481{
482 unsigned char data = 0;
483
484 for (; idx >= 0; idx--) {
485
486 gpio &= ~VT1724_PRODIGY192_CCLK;
487 snd_ice1712_gpio_write(ice, gpio);
488 udelay(1);
489
490 if (snd_ice1712_gpio_read(ice) & VT1724_PRODIGY192_CDIN)
491 data |= (1 << idx);
492 udelay(1);
493
494 gpio |= VT1724_PRODIGY192_CCLK;
495 snd_ice1712_gpio_write(ice, gpio);
496 udelay(1);
497 }
498 return data;
499}
500
501
502
503static unsigned int prodigy192_4wire_start(struct snd_ice1712 *ice)
504{
505 unsigned int tmp;
506
507 snd_ice1712_save_gpio_status(ice);
508 tmp = snd_ice1712_gpio_read(ice);
509
510 tmp |= VT1724_PRODIGY192_CCLK;
511 tmp &= ~VT1724_PRODIGY192_CS;
512 snd_ice1712_gpio_write(ice, tmp);
513 udelay(1);
514 return tmp;
515}
516
517
518
519
520static void prodigy192_4wire_finish(struct snd_ice1712 *ice, unsigned int tmp)
521{
522 tmp |= VT1724_PRODIGY192_CS;
523 snd_ice1712_gpio_write(ice, tmp);
524 udelay(1);
525 snd_ice1712_restore_gpio_status(ice);
526}
527
528
529
530
531static void prodigy192_ak4114_write(void *private_data, unsigned char addr,
532 unsigned char data)
533{
534 struct snd_ice1712 *ice = private_data;
535 unsigned int tmp, addrdata;
536 tmp = prodigy192_4wire_start(ice);
537 addrdata = (AK4114_ADDR << 6) | 0x20 | (addr & 0x1f);
538 addrdata = (addrdata << 8) | data;
539 write_data(ice, tmp, addrdata, 15);
540 prodigy192_4wire_finish(ice, tmp);
541}
542
543
544
545
546static unsigned char prodigy192_ak4114_read(void *private_data,
547 unsigned char addr)
548{
549 struct snd_ice1712 *ice = private_data;
550 unsigned int tmp;
551 unsigned char data;
552
553 tmp = prodigy192_4wire_start(ice);
554 write_data(ice, tmp, (AK4114_ADDR << 6) | (addr & 0x1f), 7);
555 data = read_data(ice, tmp, 7);
556 prodigy192_4wire_finish(ice, tmp);
557 return data;
558}
559
560
561static int ak4114_input_sw_info(struct snd_kcontrol *kcontrol,
562 struct snd_ctl_elem_info *uinfo)
563{
564 static const char * const texts[2] = { "Toslink", "Coax" };
565
566 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
567 uinfo->count = 1;
568 uinfo->value.enumerated.items = 2;
569 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
570 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
571 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
572 return 0;
573}
574
575
576static int ak4114_input_sw_get(struct snd_kcontrol *kcontrol,
577 struct snd_ctl_elem_value *ucontrol)
578{
579 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
580 unsigned char val;
581
582 val = prodigy192_ak4114_read(ice, AK4114_REG_IO1);
583
584
585
586 ucontrol->value.enumerated.item[0] = (val & AK4114_IPS0) ? 1 : 0;
587 return 0;
588}
589
590static int ak4114_input_sw_put(struct snd_kcontrol *kcontrol,
591 struct snd_ctl_elem_value *ucontrol)
592{
593 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
594 unsigned char new, old, itemvalue;
595 int change;
596
597 old = prodigy192_ak4114_read(ice, AK4114_REG_IO1);
598
599 itemvalue = (ucontrol->value.enumerated.item[0]) ? 0xff : 0x00;
600
601 new = (itemvalue & AK4114_IPS0) | (old & ~AK4114_IPS0);
602 change = (new != old);
603 if (change)
604 prodigy192_ak4114_write(ice, AK4114_REG_IO1, new);
605 return change;
606}
607
608
609static struct snd_kcontrol_new ak4114_controls[] = {
610 {
611 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
612 .name = "MIODIO IEC958 Capture Input",
613 .info = ak4114_input_sw_info,
614 .get = ak4114_input_sw_get,
615 .put = ak4114_input_sw_put,
616
617 }
618};
619
620
621static int prodigy192_ak4114_init(struct snd_ice1712 *ice)
622{
623 static const unsigned char ak4114_init_vals[] = {
624 AK4114_RST | AK4114_PWN | AK4114_OCKS0 | AK4114_OCKS1,
625
626
627
628 AK4114_DIF_I24I2S | AK4114_DEM0 ,
629 AK4114_TX1E,
630 AK4114_EFH_1024 | AK4114_DIT,
631 0,
632 0
633 };
634 static const unsigned char ak4114_init_txcsb[] = {
635 0x41, 0x02, 0x2c, 0x00, 0x00
636 };
637 struct prodigy192_spec *spec = ice->spec;
638 int err;
639
640 err = snd_ak4114_create(ice->card,
641 prodigy192_ak4114_read,
642 prodigy192_ak4114_write,
643 ak4114_init_vals, ak4114_init_txcsb,
644 ice, &spec->ak4114);
645 if (err < 0)
646 return err;
647
648
649 spec->ak4114->check_flags = AK4114_CHECK_NO_RATE;
650 return 0;
651}
652
653static void stac9460_proc_regs_read(struct snd_info_entry *entry,
654 struct snd_info_buffer *buffer)
655{
656 struct snd_ice1712 *ice = entry->private_data;
657 int reg, val;
658
659 for (reg = 0; reg <= 0x15; reg++) {
660 val = stac9460_get(ice, reg);
661 snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val);
662 }
663}
664
665
666static void stac9460_proc_init(struct snd_ice1712 *ice)
667{
668 struct snd_info_entry *entry;
669 if (!snd_card_proc_new(ice->card, "stac9460_codec", &entry))
670 snd_info_set_text_ops(entry, ice, stac9460_proc_regs_read);
671}
672
673
674static int prodigy192_add_controls(struct snd_ice1712 *ice)
675{
676 struct prodigy192_spec *spec = ice->spec;
677 unsigned int i;
678 int err;
679
680 for (i = 0; i < ARRAY_SIZE(stac_controls); i++) {
681 err = snd_ctl_add(ice->card,
682 snd_ctl_new1(&stac_controls[i], ice));
683 if (err < 0)
684 return err;
685 }
686 if (spec->ak4114) {
687
688 for (i = 0; i < ARRAY_SIZE(ak4114_controls); i++) {
689 err = snd_ctl_add(ice->card,
690 snd_ctl_new1(&ak4114_controls[i],
691 ice));
692 if (err < 0)
693 return err;
694 }
695 err = snd_ak4114_build(spec->ak4114,
696 NULL,
697 ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
698 if (err < 0)
699 return err;
700 }
701 stac9460_proc_init(ice);
702 return 0;
703}
704
705
706
707
708static int prodigy192_miodio_exists(struct snd_ice1712 *ice)
709{
710
711 unsigned char orig_value;
712 const unsigned char test_data = 0xd1;
713 unsigned char addr = AK4114_REG_INT0_MASK;
714 int exists = 0;
715
716 orig_value = prodigy192_ak4114_read(ice, addr);
717 prodigy192_ak4114_write(ice, addr, test_data);
718 if (prodigy192_ak4114_read(ice, addr) == test_data) {
719
720
721 prodigy192_ak4114_write(ice, addr, orig_value);
722 exists = 1;
723 }
724 return exists;
725}
726
727
728
729
730static int prodigy192_init(struct snd_ice1712 *ice)
731{
732 static const unsigned short stac_inits_prodigy[] = {
733 STAC946X_RESET, 0,
734 STAC946X_MASTER_CLOCKING, 0x11,
735
736
737
738
739
740
741
742 (unsigned short)-1
743 };
744 const unsigned short *p;
745 int err = 0;
746 struct prodigy192_spec *spec;
747
748
749 ice->num_total_dacs = 6;
750 ice->num_total_adcs = 2;
751 ice->vt1720 = 0;
752
753 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
754 if (!spec)
755 return -ENOMEM;
756 ice->spec = spec;
757 mutex_init(&spec->mute_mutex);
758
759
760 p = stac_inits_prodigy;
761 for (; *p != (unsigned short)-1; p += 2)
762 stac9460_put(ice, p[0], p[1]);
763 ice->gpio.set_pro_rate = stac9460_set_rate_val;
764
765
766 if (prodigy192_miodio_exists(ice)) {
767 err = prodigy192_ak4114_init(ice);
768
769
770
771 snd_printdd("AK4114 initialized with status %d\n", err);
772 } else
773 snd_printdd("AK4114 not found\n");
774 if (err < 0)
775 return err;
776
777 return 0;
778}
779
780
781
782
783
784
785
786static unsigned char prodigy71_eeprom[] = {
787 [ICE_EEP2_SYSCONF] = 0x6a,
788
789
790
791 [ICE_EEP2_ACLINK] = 0x80,
792 [ICE_EEP2_I2S] = 0xf8,
793 [ICE_EEP2_SPDIF] = 0xc3,
794 [ICE_EEP2_GPIO_DIR] = 0xff,
795 [ICE_EEP2_GPIO_DIR1] = ~(VT1724_PRODIGY192_CDIN >> 8) ,
796 [ICE_EEP2_GPIO_DIR2] = 0xbf,
797 [ICE_EEP2_GPIO_MASK] = 0x00,
798 [ICE_EEP2_GPIO_MASK1] = 0x00,
799 [ICE_EEP2_GPIO_MASK2] = 0x00,
800 [ICE_EEP2_GPIO_STATE] = 0x00,
801 [ICE_EEP2_GPIO_STATE1] = 0x00,
802 [ICE_EEP2_GPIO_STATE2] = 0x10,
803
804
805
806};
807
808
809
810struct snd_ice1712_card_info snd_vt1724_prodigy192_cards[] = {
811 {
812 .subvendor = VT1724_SUBDEVICE_PRODIGY192VE,
813 .name = "Audiotrak Prodigy 192",
814 .model = "prodigy192",
815 .chip_init = prodigy192_init,
816 .build_controls = prodigy192_add_controls,
817 .eeprom_size = sizeof(prodigy71_eeprom),
818 .eeprom_data = prodigy71_eeprom,
819 },
820 { }
821};
822