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 return snd_ctl_enum_info(uinfo, 1, 2, texts);
288}
289
290
291static int stac9460_mic_sw_get(struct snd_kcontrol *kcontrol,
292 struct snd_ctl_elem_value *ucontrol)
293{
294 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
295 unsigned char val;
296
297 val = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
298 ucontrol->value.enumerated.item[0] = (val >> 7) & 0x1;
299 return 0;
300}
301
302static int stac9460_mic_sw_put(struct snd_kcontrol *kcontrol,
303 struct snd_ctl_elem_value *ucontrol)
304{
305 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
306 unsigned char new, old;
307 int change;
308 old = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
309 new = (ucontrol->value.enumerated.item[0] << 7 & 0x80) | (old & ~0x80);
310 change = (new != old);
311 if (change)
312 stac9460_put(ice, STAC946X_GENERAL_PURPOSE, new);
313 return change;
314}
315
316
317
318static void stac9460_set_rate_val(struct snd_ice1712 *ice, unsigned int rate)
319{
320 unsigned char old, new;
321 int idx;
322 unsigned char changed[7];
323 struct prodigy192_spec *spec = ice->spec;
324
325 if (rate == 0)
326 return;
327 else if (rate <= 48000)
328 new = 0x08;
329 else if (rate <= 96000)
330 new = 0x11;
331 else
332 new = 0x12;
333 old = stac9460_get(ice, STAC946X_MASTER_CLOCKING);
334 if (old == new)
335 return;
336
337
338 mutex_lock(&spec->mute_mutex);
339
340 for (idx = 0; idx < 7 ; ++idx)
341 changed[idx] = stac9460_dac_mute(ice,
342 STAC946X_MASTER_VOLUME + idx, 0);
343
344 stac9460_put(ice, STAC946X_MASTER_CLOCKING, new);
345 udelay(10);
346
347
348 for (idx = 0; idx < 7 ; ++idx) {
349 if (changed[idx])
350 stac9460_dac_mute(ice, STAC946X_MASTER_VOLUME + idx, 1);
351 }
352 mutex_unlock(&spec->mute_mutex);
353}
354
355
356static const DECLARE_TLV_DB_SCALE(db_scale_dac, -19125, 75, 0);
357static const DECLARE_TLV_DB_SCALE(db_scale_adc, 0, 150, 0);
358
359
360
361
362
363static struct snd_kcontrol_new stac_controls[] = {
364 {
365 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
366 .name = "Master Playback Switch",
367 .info = stac9460_dac_mute_info,
368 .get = stac9460_dac_mute_get,
369 .put = stac9460_dac_mute_put,
370 .private_value = 1,
371 .tlv = { .p = db_scale_dac }
372 },
373 {
374 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
375 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
376 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
377 .name = "Master Playback Volume",
378 .info = stac9460_dac_vol_info,
379 .get = stac9460_dac_vol_get,
380 .put = stac9460_dac_vol_put,
381 .private_value = 1,
382 .tlv = { .p = db_scale_dac }
383 },
384 {
385 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
386 .name = "DAC Switch",
387 .count = 6,
388 .info = stac9460_dac_mute_info,
389 .get = stac9460_dac_mute_get,
390 .put = stac9460_dac_mute_put,
391 },
392 {
393 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
394 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
395 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
396 .name = "DAC Volume",
397 .count = 6,
398 .info = stac9460_dac_vol_info,
399 .get = stac9460_dac_vol_get,
400 .put = stac9460_dac_vol_put,
401 .tlv = { .p = db_scale_dac }
402 },
403 {
404 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
405 .name = "ADC Capture Switch",
406 .count = 1,
407 .info = stac9460_adc_mute_info,
408 .get = stac9460_adc_mute_get,
409 .put = stac9460_adc_mute_put,
410
411 },
412 {
413 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
414 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
415 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
416 .name = "ADC Capture Volume",
417 .count = 1,
418 .info = stac9460_adc_vol_info,
419 .get = stac9460_adc_vol_get,
420 .put = stac9460_adc_vol_put,
421 .tlv = { .p = db_scale_adc }
422 },
423 {
424 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
425 .name = "Analog Capture Input",
426 .info = stac9460_mic_sw_info,
427 .get = stac9460_mic_sw_get,
428 .put = stac9460_mic_sw_put,
429
430 },
431};
432
433
434
435
436
437
438
439#define AK4114_ADDR 0x00
440
441
442
443
444
445
446static void write_data(struct snd_ice1712 *ice, unsigned int gpio,
447 unsigned int data, int idx)
448{
449 for (; idx >= 0; idx--) {
450
451 gpio &= ~VT1724_PRODIGY192_CCLK;
452 snd_ice1712_gpio_write(ice, gpio);
453 udelay(1);
454
455 if (data & (1 << idx))
456 gpio |= VT1724_PRODIGY192_CDOUT;
457 else
458 gpio &= ~VT1724_PRODIGY192_CDOUT;
459 snd_ice1712_gpio_write(ice, gpio);
460 udelay(1);
461
462 gpio |= VT1724_PRODIGY192_CCLK;
463 snd_ice1712_gpio_write(ice, gpio);
464 udelay(1);
465 }
466}
467
468
469
470
471static unsigned char read_data(struct snd_ice1712 *ice, unsigned int gpio,
472 int idx)
473{
474 unsigned char data = 0;
475
476 for (; idx >= 0; idx--) {
477
478 gpio &= ~VT1724_PRODIGY192_CCLK;
479 snd_ice1712_gpio_write(ice, gpio);
480 udelay(1);
481
482 if (snd_ice1712_gpio_read(ice) & VT1724_PRODIGY192_CDIN)
483 data |= (1 << idx);
484 udelay(1);
485
486 gpio |= VT1724_PRODIGY192_CCLK;
487 snd_ice1712_gpio_write(ice, gpio);
488 udelay(1);
489 }
490 return data;
491}
492
493
494
495static unsigned int prodigy192_4wire_start(struct snd_ice1712 *ice)
496{
497 unsigned int tmp;
498
499 snd_ice1712_save_gpio_status(ice);
500 tmp = snd_ice1712_gpio_read(ice);
501
502 tmp |= VT1724_PRODIGY192_CCLK;
503 tmp &= ~VT1724_PRODIGY192_CS;
504 snd_ice1712_gpio_write(ice, tmp);
505 udelay(1);
506 return tmp;
507}
508
509
510
511
512static void prodigy192_4wire_finish(struct snd_ice1712 *ice, unsigned int tmp)
513{
514 tmp |= VT1724_PRODIGY192_CS;
515 snd_ice1712_gpio_write(ice, tmp);
516 udelay(1);
517 snd_ice1712_restore_gpio_status(ice);
518}
519
520
521
522
523static void prodigy192_ak4114_write(void *private_data, unsigned char addr,
524 unsigned char data)
525{
526 struct snd_ice1712 *ice = private_data;
527 unsigned int tmp, addrdata;
528 tmp = prodigy192_4wire_start(ice);
529 addrdata = (AK4114_ADDR << 6) | 0x20 | (addr & 0x1f);
530 addrdata = (addrdata << 8) | data;
531 write_data(ice, tmp, addrdata, 15);
532 prodigy192_4wire_finish(ice, tmp);
533}
534
535
536
537
538static unsigned char prodigy192_ak4114_read(void *private_data,
539 unsigned char addr)
540{
541 struct snd_ice1712 *ice = private_data;
542 unsigned int tmp;
543 unsigned char data;
544
545 tmp = prodigy192_4wire_start(ice);
546 write_data(ice, tmp, (AK4114_ADDR << 6) | (addr & 0x1f), 7);
547 data = read_data(ice, tmp, 7);
548 prodigy192_4wire_finish(ice, tmp);
549 return data;
550}
551
552
553static int ak4114_input_sw_info(struct snd_kcontrol *kcontrol,
554 struct snd_ctl_elem_info *uinfo)
555{
556 static const char * const texts[2] = { "Toslink", "Coax" };
557
558 return snd_ctl_enum_info(uinfo, 1, 2, texts);
559}
560
561
562static int ak4114_input_sw_get(struct snd_kcontrol *kcontrol,
563 struct snd_ctl_elem_value *ucontrol)
564{
565 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
566 unsigned char val;
567
568 val = prodigy192_ak4114_read(ice, AK4114_REG_IO1);
569
570
571
572 ucontrol->value.enumerated.item[0] = (val & AK4114_IPS0) ? 1 : 0;
573 return 0;
574}
575
576static int ak4114_input_sw_put(struct snd_kcontrol *kcontrol,
577 struct snd_ctl_elem_value *ucontrol)
578{
579 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
580 unsigned char new, old, itemvalue;
581 int change;
582
583 old = prodigy192_ak4114_read(ice, AK4114_REG_IO1);
584
585 itemvalue = (ucontrol->value.enumerated.item[0]) ? 0xff : 0x00;
586
587 new = (itemvalue & AK4114_IPS0) | (old & ~AK4114_IPS0);
588 change = (new != old);
589 if (change)
590 prodigy192_ak4114_write(ice, AK4114_REG_IO1, new);
591 return change;
592}
593
594
595static struct snd_kcontrol_new ak4114_controls[] = {
596 {
597 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
598 .name = "MIODIO IEC958 Capture Input",
599 .info = ak4114_input_sw_info,
600 .get = ak4114_input_sw_get,
601 .put = ak4114_input_sw_put,
602
603 }
604};
605
606
607static int prodigy192_ak4114_init(struct snd_ice1712 *ice)
608{
609 static const unsigned char ak4114_init_vals[] = {
610 AK4114_RST | AK4114_PWN | AK4114_OCKS0 | AK4114_OCKS1,
611
612
613
614 AK4114_DIF_I24I2S | AK4114_DEM0 ,
615 AK4114_TX1E,
616 AK4114_EFH_1024 | AK4114_DIT,
617 0,
618 0
619 };
620 static const unsigned char ak4114_init_txcsb[] = {
621 0x41, 0x02, 0x2c, 0x00, 0x00
622 };
623 struct prodigy192_spec *spec = ice->spec;
624 int err;
625
626 err = snd_ak4114_create(ice->card,
627 prodigy192_ak4114_read,
628 prodigy192_ak4114_write,
629 ak4114_init_vals, ak4114_init_txcsb,
630 ice, &spec->ak4114);
631 if (err < 0)
632 return err;
633
634
635 spec->ak4114->check_flags = AK4114_CHECK_NO_RATE;
636 return 0;
637}
638
639static void stac9460_proc_regs_read(struct snd_info_entry *entry,
640 struct snd_info_buffer *buffer)
641{
642 struct snd_ice1712 *ice = entry->private_data;
643 int reg, val;
644
645 for (reg = 0; reg <= 0x15; reg++) {
646 val = stac9460_get(ice, reg);
647 snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val);
648 }
649}
650
651
652static void stac9460_proc_init(struct snd_ice1712 *ice)
653{
654 struct snd_info_entry *entry;
655 if (!snd_card_proc_new(ice->card, "stac9460_codec", &entry))
656 snd_info_set_text_ops(entry, ice, stac9460_proc_regs_read);
657}
658
659
660static int prodigy192_add_controls(struct snd_ice1712 *ice)
661{
662 struct prodigy192_spec *spec = ice->spec;
663 unsigned int i;
664 int err;
665
666 for (i = 0; i < ARRAY_SIZE(stac_controls); i++) {
667 err = snd_ctl_add(ice->card,
668 snd_ctl_new1(&stac_controls[i], ice));
669 if (err < 0)
670 return err;
671 }
672 if (spec->ak4114) {
673
674 for (i = 0; i < ARRAY_SIZE(ak4114_controls); i++) {
675 err = snd_ctl_add(ice->card,
676 snd_ctl_new1(&ak4114_controls[i],
677 ice));
678 if (err < 0)
679 return err;
680 }
681 err = snd_ak4114_build(spec->ak4114,
682 NULL,
683 ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
684 if (err < 0)
685 return err;
686 }
687 stac9460_proc_init(ice);
688 return 0;
689}
690
691
692
693
694static int prodigy192_miodio_exists(struct snd_ice1712 *ice)
695{
696
697 unsigned char orig_value;
698 const unsigned char test_data = 0xd1;
699 unsigned char addr = AK4114_REG_INT0_MASK;
700 int exists = 0;
701
702 orig_value = prodigy192_ak4114_read(ice, addr);
703 prodigy192_ak4114_write(ice, addr, test_data);
704 if (prodigy192_ak4114_read(ice, addr) == test_data) {
705
706
707 prodigy192_ak4114_write(ice, addr, orig_value);
708 exists = 1;
709 }
710 return exists;
711}
712
713
714
715
716static int prodigy192_init(struct snd_ice1712 *ice)
717{
718 static const unsigned short stac_inits_prodigy[] = {
719 STAC946X_RESET, 0,
720 STAC946X_MASTER_CLOCKING, 0x11,
721
722
723
724
725
726
727
728 (unsigned short)-1
729 };
730 const unsigned short *p;
731 int err = 0;
732 struct prodigy192_spec *spec;
733
734
735 ice->num_total_dacs = 6;
736 ice->num_total_adcs = 2;
737 ice->vt1720 = 0;
738
739 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
740 if (!spec)
741 return -ENOMEM;
742 ice->spec = spec;
743 mutex_init(&spec->mute_mutex);
744
745
746 p = stac_inits_prodigy;
747 for (; *p != (unsigned short)-1; p += 2)
748 stac9460_put(ice, p[0], p[1]);
749 ice->gpio.set_pro_rate = stac9460_set_rate_val;
750
751
752 if (prodigy192_miodio_exists(ice)) {
753 err = prodigy192_ak4114_init(ice);
754
755
756
757 dev_dbg(ice->card->dev,
758 "AK4114 initialized with status %d\n", err);
759 } else
760 dev_dbg(ice->card->dev, "AK4114 not found\n");
761
762 return err;
763}
764
765
766
767
768
769
770
771static unsigned char prodigy71_eeprom[] = {
772 [ICE_EEP2_SYSCONF] = 0x6a,
773
774
775
776 [ICE_EEP2_ACLINK] = 0x80,
777 [ICE_EEP2_I2S] = 0xf8,
778 [ICE_EEP2_SPDIF] = 0xc3,
779 [ICE_EEP2_GPIO_DIR] = 0xff,
780 [ICE_EEP2_GPIO_DIR1] = ~(VT1724_PRODIGY192_CDIN >> 8) ,
781 [ICE_EEP2_GPIO_DIR2] = 0xbf,
782 [ICE_EEP2_GPIO_MASK] = 0x00,
783 [ICE_EEP2_GPIO_MASK1] = 0x00,
784 [ICE_EEP2_GPIO_MASK2] = 0x00,
785 [ICE_EEP2_GPIO_STATE] = 0x00,
786 [ICE_EEP2_GPIO_STATE1] = 0x00,
787 [ICE_EEP2_GPIO_STATE2] = 0x10,
788
789
790
791};
792
793
794
795struct snd_ice1712_card_info snd_vt1724_prodigy192_cards[] = {
796 {
797 .subvendor = VT1724_SUBDEVICE_PRODIGY192VE,
798 .name = "Audiotrak Prodigy 192",
799 .model = "prodigy192",
800 .chip_init = prodigy192_init,
801 .build_controls = prodigy192_add_controls,
802 .eeprom_size = sizeof(prodigy71_eeprom),
803 .eeprom_data = prodigy71_eeprom,
804 },
805 { }
806};
807