?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
close_port, kpacket_gen kmalloc oom, formard.c wake_sender/skb receive oom handling...
[cor_2_6_31.git] / sound / pci / ice1712 / prodigy192.c
blob2a8e5cd8f2d8093f18b3f2c12591ed503c483530
1 /*
2 * ALSA driver for ICEnsemble VT1724 (Envy24HT)
3 *
4 * Lowlevel functions for AudioTrak Prodigy 192 cards
5 * Supported IEC958 input from optional MI/ODI/O add-on card.
6 *
7 * Specifics (SW, HW):
8 * -------------------
9 * * 49.5MHz crystal
10 * * SPDIF-OUT on the card:
11 * - coax (through isolation transformer)/toslink supplied by
12 * 74HC04 gates - 3 in parallel
13 * - output switched between on-board CD drive dig-out connector
14 * and ice1724 SPDTX pin, using 74HC02 NOR gates, controlled
15 * by GPIO20 (0 = CD dig-out, 1 = SPDTX)
16 * * SPDTX goes straight to MI/ODI/O card's SPDIF-OUT coax
17 *
18 * * MI/ODI/O card: AK4114 based, used for iec958 input only
19 * - toslink input -> RX0
20 * - coax input -> RX1
21 * - 4wire protocol:
22 * AK4114 ICE1724
23 * ------------------------------
24 * CDTO (pin 32) -- GPIO11 pin 86
25 * CDTI (pin 33) -- GPIO10 pin 77
26 * CCLK (pin 34) -- GPIO9 pin 76
27 * CSN (pin 35) -- GPIO8 pin 75
28 * - output data Mode 7 (24bit, I2S, slave)
29 * - both MCKO1 and MCKO2 of ak4114 are fed to FPGA, which
30 * outputs master clock to SPMCLKIN of ice1724.
31 * Experimentally I found out that only a combination of
32 * OCKS0=1, OCKS1=1 (128fs, 64fs output) and ice1724 -
33 * VT1724_MT_I2S_MCLK_128X=0 (256fs input) yields correct
34 * sampling rate. That means the the FPGA doubles the
35 * MCK01 rate.
36 *
37 * Copyright (c) 2003 Takashi Iwai <tiwai@suse.de>
38 * Copyright (c) 2003 Dimitromanolakis Apostolos <apostol@cs.utoronto.ca>
39 * Copyright (c) 2004 Kouichi ONO <co2b@ceres.dti.ne.jp>
40 *
41 * This program is free software; you can redistribute it and/or modify
42 * it under the terms of the GNU General Public License as published by
43 * the Free Software Foundation; either version 2 of the License, or
44 * (at your option) any later version.
45 *
46 * This program is distributed in the hope that it will be useful,
47 * but WITHOUT ANY WARRANTY; without even the implied warranty of
48 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
49 * GNU General Public License for more details.
50 *
51 * You should have received a copy of the GNU General Public License
52 * along with this program; if not, write to the Free Software
53 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
54 *
55 */
56
57 #include <asm/io.h>
58 #include <linux/delay.h>
59 #include <linux/interrupt.h>
60 #include <linux/init.h>
61 #include <linux/slab.h>
62 #include <sound/core.h>
63
64 #include "ice1712.h"
65 #include "envy24ht.h"
66 #include "prodigy192.h"
67 #include "stac946x.h"
68 #include <sound/tlv.h>
69
70 struct prodigy192_spec {
71 struct ak4114 *ak4114;
72 /* rate change needs atomic mute/unmute of all dacs*/
73 struct mutex mute_mutex;
74 };
75
76 static inline void stac9460_put(struct snd_ice1712 *ice, int reg, unsigned char val)
77 {
78 snd_vt1724_write_i2c(ice, PRODIGY192_STAC9460_ADDR, reg, val);
79 }
80
81 static inline unsigned char stac9460_get(struct snd_ice1712 *ice, int reg)
82 {
83 return snd_vt1724_read_i2c(ice, PRODIGY192_STAC9460_ADDR, reg);
84 }
85
86 /*
87 * DAC mute control
88 */
89
90 /*
91 * idx = STAC9460 volume register number, mute: 0 = mute, 1 = unmute
92 */
93 static int stac9460_dac_mute(struct snd_ice1712 *ice, int idx,
94 unsigned char mute)
95 {
96 unsigned char new, old;
97 int change;
98 old = stac9460_get(ice, idx);
99 new = (~mute << 7 & 0x80) | (old & ~0x80);
100 change = (new != old);
101 if (change)
102 /*printk ("Volume register 0x%02x: 0x%02x\n", idx, new);*/
103 stac9460_put(ice, idx, new);
104 return change;
105 }
106
107 #define stac9460_dac_mute_info snd_ctl_boolean_mono_info
108
109 static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
110 {
111 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
112 unsigned char val;
113 int idx;
114
115 if (kcontrol->private_value)
116 idx = STAC946X_MASTER_VOLUME;
117 else
118 idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
119 val = stac9460_get(ice, idx);
120 ucontrol->value.integer.value[0] = (~val >> 7) & 0x1;
121 return 0;
122 }
123
124 static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
125 {
126 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
127 struct prodigy192_spec *spec = ice->spec;
128 int idx, change;
129
130 if (kcontrol->private_value)
131 idx = STAC946X_MASTER_VOLUME;
132 else
133 idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
134 /* due to possible conflicts with stac9460_set_rate_val, mutexing */
135 mutex_lock(&spec->mute_mutex);
136 /*
137 printk(KERN_DEBUG "Mute put: reg 0x%02x, ctrl value: 0x%02x\n", idx,
138 ucontrol->value.integer.value[0]);
139 */
140 change = stac9460_dac_mute(ice, idx, ucontrol->value.integer.value[0]);
141 mutex_unlock(&spec->mute_mutex);
142 return change;
143 }
144
145 /*
146 * DAC volume attenuation mixer control
147 */
148 static int stac9460_dac_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
149 {
150 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
151 uinfo->count = 1;
152 uinfo->value.integer.min = 0; /* mute */
153 uinfo->value.integer.max = 0x7f; /* 0dB */
154 return 0;
155 }
156
157 static int stac9460_dac_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
158 {
159 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
160 int idx;
161 unsigned char vol;
162
163 if (kcontrol->private_value)
164 idx = STAC946X_MASTER_VOLUME;
165 else
166 idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
167 vol = stac9460_get(ice, idx) & 0x7f;
168 ucontrol->value.integer.value[0] = 0x7f - vol;
169
170 return 0;
171 }
172
173 static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
174 {
175 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
176 int idx;
177 unsigned char tmp, ovol, nvol;
178 int change;
179
180 if (kcontrol->private_value)
181 idx = STAC946X_MASTER_VOLUME;
182 else
183 idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
184 nvol = ucontrol->value.integer.value[0];
185 tmp = stac9460_get(ice, idx);
186 ovol = 0x7f - (tmp & 0x7f);
187 change = (ovol != nvol);
188 if (change) {
189 ovol = (0x7f - nvol) | (tmp & 0x80);
190 /*
191 printk(KERN_DEBUG "DAC Volume: reg 0x%02x: 0x%02x\n",
192 idx, ovol);
193 */
194 stac9460_put(ice, idx, (0x7f - nvol) | (tmp & 0x80));
195 }
196 return change;
197 }
198
199 /*
200 * ADC mute control
201 */
202 #define stac9460_adc_mute_info snd_ctl_boolean_stereo_info
203
204 static int stac9460_adc_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
205 {
206 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
207 unsigned char val;
208 int i;
209
210 for (i = 0; i < 2; ++i) {
211 val = stac9460_get(ice, STAC946X_MIC_L_VOLUME + i);
212 ucontrol->value.integer.value[i] = ~val>>7 & 0x1;
213 }
214
215 return 0;
216 }
217
218 static int stac9460_adc_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
219 {
220 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
221 unsigned char new, old;
222 int i, reg;
223 int change;
224
225 for (i = 0; i < 2; ++i) {
226 reg = STAC946X_MIC_L_VOLUME + i;
227 old = stac9460_get(ice, reg);
228 new = (~ucontrol->value.integer.value[i]<<7&0x80) | (old&~0x80);
229 change = (new != old);
230 if (change)
231 stac9460_put(ice, reg, new);
232 }
233
234 return change;
235 }
236
237 /*
238 * ADC gain mixer control
239 */
240 static int stac9460_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
241 {
242 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
243 uinfo->count = 2;
244 uinfo->value.integer.min = 0; /* 0dB */
245 uinfo->value.integer.max = 0x0f; /* 22.5dB */
246 return 0;
247 }
248
249 static int stac9460_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
250 {
251 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
252 int i, reg;
253 unsigned char vol;
254
255 for (i = 0; i < 2; ++i) {
256 reg = STAC946X_MIC_L_VOLUME + i;
257 vol = stac9460_get(ice, reg) & 0x0f;
258 ucontrol->value.integer.value[i] = 0x0f - vol;
259 }
260
261 return 0;
262 }
263
264 static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
265 {
266 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
267 int i, reg;
268 unsigned char ovol, nvol;
269 int change;
270
271 for (i = 0; i < 2; ++i) {
272 reg = STAC946X_MIC_L_VOLUME + i;
273 nvol = ucontrol->value.integer.value[i] & 0x0f;
274 ovol = 0x0f - stac9460_get(ice, reg);
275 change = ((ovol & 0x0f) != nvol);
276 if (change)
277 stac9460_put(ice, reg, (0x0f - nvol) | (ovol & ~0x0f));
278 }
279
280 return change;
281 }
282
283 static int stac9460_mic_sw_info(struct snd_kcontrol *kcontrol,
284 struct snd_ctl_elem_info *uinfo)
285 {
286 static char *texts[2] = { "Line In", "Mic" };
287
288 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
289 uinfo->count = 1;
290 uinfo->value.enumerated.items = 2;
291
292 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
293 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
294 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
295
296 return 0;
297 }
298
299
300 static int stac9460_mic_sw_get(struct snd_kcontrol *kcontrol,
301 struct snd_ctl_elem_value *ucontrol)
302 {
303 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
304 unsigned char val;
305
306 val = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
307 ucontrol->value.enumerated.item[0] = (val >> 7) & 0x1;
308 return 0;
309 }
310
311 static int stac9460_mic_sw_put(struct snd_kcontrol *kcontrol,
312 struct snd_ctl_elem_value *ucontrol)
313 {
314 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
315 unsigned char new, old;
316 int change;
317 old = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
318 new = (ucontrol->value.enumerated.item[0] << 7 & 0x80) | (old & ~0x80);
319 change = (new != old);
320 if (change)
321 stac9460_put(ice, STAC946X_GENERAL_PURPOSE, new);
322 return change;
323 }
324 /*
325 * Handler for setting correct codec rate - called when rate change is detected
326 */
327 static void stac9460_set_rate_val(struct snd_ice1712 *ice, unsigned int rate)
328 {
329 unsigned char old, new;
330 int idx;
331 unsigned char changed[7];
332 struct prodigy192_spec *spec = ice->spec;
333
334 if (rate == 0) /* no hint - S/PDIF input is master, simply return */
335 return;
336 else if (rate <= 48000)
337 new = 0x08; /* 256x, base rate mode */
338 else if (rate <= 96000)
339 new = 0x11; /* 256x, mid rate mode */
340 else
341 new = 0x12; /* 128x, high rate mode */
342 old = stac9460_get(ice, STAC946X_MASTER_CLOCKING);
343 if (old == new)
344 return;
345 /* change detected, setting master clock, muting first */
346 /* due to possible conflicts with mute controls - mutexing */
347 mutex_lock(&spec->mute_mutex);
348 /* we have to remember current mute status for each DAC */
349 for (idx = 0; idx < 7 ; ++idx)
350 changed[idx] = stac9460_dac_mute(ice,
351 STAC946X_MASTER_VOLUME + idx, 0);
352 /*printk(KERN_DEBUG "Rate change: %d, new MC: 0x%02x\n", rate, new);*/
353 stac9460_put(ice, STAC946X_MASTER_CLOCKING, new);
354 udelay(10);
355 /* unmuting - only originally unmuted dacs -
356 * i.e. those changed when muting */
357 for (idx = 0; idx < 7 ; ++idx) {
358 if (changed[idx])
359 stac9460_dac_mute(ice, STAC946X_MASTER_VOLUME + idx, 1);
360 }
361 mutex_unlock(&spec->mute_mutex);
362 }
363
364
365 static const DECLARE_TLV_DB_SCALE(db_scale_dac, -19125, 75, 0);
366 static const DECLARE_TLV_DB_SCALE(db_scale_adc, 0, 150, 0);
367
368 /*
369 * mixers
370 */
371
372 static struct snd_kcontrol_new stac_controls[] __devinitdata = {
373 {
374 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
375 .name = "Master Playback Switch",
376 .info = stac9460_dac_mute_info,
377 .get = stac9460_dac_mute_get,
378 .put = stac9460_dac_mute_put,
379 .private_value = 1,
380 .tlv = { .p = db_scale_dac }
381 },
382 {
383 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
384 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
385 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
386 .name = "Master Playback Volume",
387 .info = stac9460_dac_vol_info,
388 .get = stac9460_dac_vol_get,
389 .put = stac9460_dac_vol_put,
390 .private_value = 1,
391 .tlv = { .p = db_scale_dac }
392 },
393 {
394 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
395 .name = "DAC Switch",
396 .count = 6,
397 .info = stac9460_dac_mute_info,
398 .get = stac9460_dac_mute_get,
399 .put = stac9460_dac_mute_put,
400 },
401 {
402 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
403 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
404 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
405 .name = "DAC Volume",
406 .count = 6,
407 .info = stac9460_dac_vol_info,
408 .get = stac9460_dac_vol_get,
409 .put = stac9460_dac_vol_put,
410 .tlv = { .p = db_scale_dac }
411 },
412 {
413 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
414 .name = "ADC Capture Switch",
415 .count = 1,
416 .info = stac9460_adc_mute_info,
417 .get = stac9460_adc_mute_get,
418 .put = stac9460_adc_mute_put,
419
420 },
421 {
422 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
423 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
424 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
425 .name = "ADC Capture Volume",
426 .count = 1,
427 .info = stac9460_adc_vol_info,
428 .get = stac9460_adc_vol_get,
429 .put = stac9460_adc_vol_put,
430 .tlv = { .p = db_scale_adc }
431 },
432 {
433 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
434 .name = "Analog Capture Input",
435 .info = stac9460_mic_sw_info,
436 .get = stac9460_mic_sw_get,
437 .put = stac9460_mic_sw_put,
438
439 },
440 };
441
442 /* AK4114 - ICE1724 connections on Prodigy192 + MI/ODI/O */
443 /* CDTO (pin 32) -- GPIO11 pin 86
444 * CDTI (pin 33) -- GPIO10 pin 77
445 * CCLK (pin 34) -- GPIO9 pin 76
446 * CSN (pin 35) -- GPIO8 pin 75
447 */
448 #define AK4114_ADDR 0x00 /* C1-C0: Chip Address
449 * (According to datasheet fixed to “00”)
450 */
451
452 /*
453 * 4wire ak4114 protocol - writing data
454 */
455 static void write_data(struct snd_ice1712 *ice, unsigned int gpio,
456 unsigned int data, int idx)
457 {
458 for (; idx >= 0; idx--) {
459 /* drop clock */
460 gpio &= ~VT1724_PRODIGY192_CCLK;
461 snd_ice1712_gpio_write(ice, gpio);
462 udelay(1);
463 /* set data */
464 if (data & (1 << idx))
465 gpio |= VT1724_PRODIGY192_CDOUT;
466 else
467 gpio &= ~VT1724_PRODIGY192_CDOUT;
468 snd_ice1712_gpio_write(ice, gpio);
469 udelay(1);
470 /* raise clock */
471 gpio |= VT1724_PRODIGY192_CCLK;
472 snd_ice1712_gpio_write(ice, gpio);
473 udelay(1);
474 }
475 }
476
477 /*
478 * 4wire ak4114 protocol - reading data
479 */
480 static unsigned char read_data(struct snd_ice1712 *ice, unsigned int gpio,
481 int idx)
482 {
483 unsigned char data = 0;
484
485 for (; idx >= 0; idx--) {
486 /* drop clock */
487 gpio &= ~VT1724_PRODIGY192_CCLK;
488 snd_ice1712_gpio_write(ice, gpio);
489 udelay(1);
490 /* read data */
491 if (snd_ice1712_gpio_read(ice) & VT1724_PRODIGY192_CDIN)
492 data |= (1 << idx);
493 udelay(1);
494 /* raise clock */
495 gpio |= VT1724_PRODIGY192_CCLK;
496 snd_ice1712_gpio_write(ice, gpio);
497 udelay(1);
498 }
499 return data;
500 }
501 /*
502 * 4wire ak4114 protocol - starting sequence
503 */
504 static unsigned int prodigy192_4wire_start(struct snd_ice1712 *ice)
505 {
506 unsigned int tmp;
507
508 snd_ice1712_save_gpio_status(ice);
509 tmp = snd_ice1712_gpio_read(ice);
510
511 tmp |= VT1724_PRODIGY192_CCLK; /* high at init */
512 tmp &= ~VT1724_PRODIGY192_CS; /* drop chip select */
513 snd_ice1712_gpio_write(ice, tmp);
514 udelay(1);
515 return tmp;
516 }
517
518 /*
519 * 4wire ak4114 protocol - final sequence
520 */
521 static void prodigy192_4wire_finish(struct snd_ice1712 *ice, unsigned int tmp)
522 {
523 tmp |= VT1724_PRODIGY192_CS; /* raise chip select */
524 snd_ice1712_gpio_write(ice, tmp);
525 udelay(1);
526 snd_ice1712_restore_gpio_status(ice);
527 }
528
529 /*
530 * Write data to addr register of ak4114
531 */
532 static void prodigy192_ak4114_write(void *private_data, unsigned char addr,
533 unsigned char data)
534 {
535 struct snd_ice1712 *ice = private_data;
536 unsigned int tmp, addrdata;
537 tmp = prodigy192_4wire_start(ice);
538 addrdata = (AK4114_ADDR << 6) | 0x20 | (addr & 0x1f);
539 addrdata = (addrdata << 8) | data;
540 write_data(ice, tmp, addrdata, 15);
541 prodigy192_4wire_finish(ice, tmp);
542 }
543
544 /*
545 * Read data from addr register of ak4114
546 */
547 static unsigned char prodigy192_ak4114_read(void *private_data,
548 unsigned char addr)
549 {
550 struct snd_ice1712 *ice = private_data;
551 unsigned int tmp;
552 unsigned char data;
553
554 tmp = prodigy192_4wire_start(ice);
555 write_data(ice, tmp, (AK4114_ADDR << 6) | (addr & 0x1f), 7);
556 data = read_data(ice, tmp, 7);
557 prodigy192_4wire_finish(ice, tmp);
558 return data;
559 }
560
561
562 static int ak4114_input_sw_info(struct snd_kcontrol *kcontrol,
563 struct snd_ctl_elem_info *uinfo)
564 {
565 static char *texts[2] = { "Toslink", "Coax" };
566
567 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
568 uinfo->count = 1;
569 uinfo->value.enumerated.items = 2;
570 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
571 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
572 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
573 return 0;
574 }
575
576
577 static int ak4114_input_sw_get(struct snd_kcontrol *kcontrol,
578 struct snd_ctl_elem_value *ucontrol)
579 {
580 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
581 unsigned char val;
582
583 val = prodigy192_ak4114_read(ice, AK4114_REG_IO1);
584 /* AK4114_IPS0 bit = 0 -> RX0 = Toslink
585 * AK4114_IPS0 bit = 1 -> RX1 = Coax
586 */
587 ucontrol->value.enumerated.item[0] = (val & AK4114_IPS0) ? 1 : 0;
588 return 0;
589 }
590
591 static int ak4114_input_sw_put(struct snd_kcontrol *kcontrol,
592 struct snd_ctl_elem_value *ucontrol)
593 {
594 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
595 unsigned char new, old, itemvalue;
596 int change;
597
598 old = prodigy192_ak4114_read(ice, AK4114_REG_IO1);
599 /* AK4114_IPS0 could be any bit */
600 itemvalue = (ucontrol->value.enumerated.item[0]) ? 0xff : 0x00;
601
602 new = (itemvalue & AK4114_IPS0) | (old & ~AK4114_IPS0);
603 change = (new != old);
604 if (change)
605 prodigy192_ak4114_write(ice, AK4114_REG_IO1, new);
606 return change;
607 }
608
609
610 static struct snd_kcontrol_new ak4114_controls[] __devinitdata = {
611 {
612 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
613 .name = "MIODIO IEC958 Capture Input",
614 .info = ak4114_input_sw_info,
615 .get = ak4114_input_sw_get,
616 .put = ak4114_input_sw_put,
617
618 }
619 };
620
621
622 static int prodigy192_ak4114_init(struct snd_ice1712 *ice)
623 {
624 static const unsigned char ak4114_init_vals[] = {
625 AK4114_RST | AK4114_PWN | AK4114_OCKS0 | AK4114_OCKS1,
626 /* ice1724 expects I2S and provides clock,
627 * DEM0 disables the deemphasis filter
628 */
629 AK4114_DIF_I24I2S | AK4114_DEM0 ,
630 AK4114_TX1E,
631 AK4114_EFH_1024 | AK4114_DIT, /* default input RX0 */
632 0,
633 0
634 };
635 static const unsigned char ak4114_init_txcsb[] = {
636 0x41, 0x02, 0x2c, 0x00, 0x00
637 };
638 struct prodigy192_spec *spec = ice->spec;
639 int err;
640
641 err = snd_ak4114_create(ice->card,
642 prodigy192_ak4114_read,
643 prodigy192_ak4114_write,
644 ak4114_init_vals, ak4114_init_txcsb,
645 ice, &spec->ak4114);
646 if (err < 0)
647 return err;
648 /* AK4114 in Prodigy192 cannot detect external rate correctly.
649 * No reason to stop capture stream due to incorrect checks */
650 spec->ak4114->check_flags = AK4114_CHECK_NO_RATE;
651 return 0;
652 }
653
654 static void stac9460_proc_regs_read(struct snd_info_entry *entry,
655 struct snd_info_buffer *buffer)
656 {
657 struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
658 int reg, val;
659 /* registers 0x0 - 0x14 */
660 for (reg = 0; reg <= 0x15; reg++) {
661 val = stac9460_get(ice, reg);
662 snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val);
663 }
664 }
665
666
667 static void stac9460_proc_init(struct snd_ice1712 *ice)
668 {
669 struct snd_info_entry *entry;
670 if (!snd_card_proc_new(ice->card, "stac9460_codec", &entry))
671 snd_info_set_text_ops(entry, ice, stac9460_proc_regs_read);
672 }
673
674
675 static int __devinit prodigy192_add_controls(struct snd_ice1712 *ice)
676 {
677 struct prodigy192_spec *spec = ice->spec;
678 unsigned int i;
679 int err;
680
681 for (i = 0; i < ARRAY_SIZE(stac_controls); i++) {
682 err = snd_ctl_add(ice->card,
683 snd_ctl_new1(&stac_controls[i], ice));
684 if (err < 0)
685 return err;
686 }
687 if (spec->ak4114) {
688 /* ak4114 is connected */
689 for (i = 0; i < ARRAY_SIZE(ak4114_controls); i++) {
690 err = snd_ctl_add(ice->card,
691 snd_ctl_new1(&ak4114_controls[i],
692 ice));
693 if (err < 0)
694 return err;
695 }
696 err = snd_ak4114_build(spec->ak4114,
697 NULL, /* ak4114 in MIO/DI/O handles no IEC958 output */
698 ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
699 if (err < 0)
700 return err;
701 }
702 stac9460_proc_init(ice);
703 return 0;
704 }
705
706 /*
707 * check for presence of MI/ODI/O add-on card with digital inputs
708 */
709 static int prodigy192_miodio_exists(struct snd_ice1712 *ice)
710 {
711
712 unsigned char orig_value;
713 const unsigned char test_data = 0xd1; /* random value */
714 unsigned char addr = AK4114_REG_INT0_MASK; /* random SAFE address */
715 int exists = 0;
716
717 orig_value = prodigy192_ak4114_read(ice, addr);
718 prodigy192_ak4114_write(ice, addr, test_data);
719 if (prodigy192_ak4114_read(ice, addr) == test_data) {
720 /* ak4114 seems to communicate, apparently exists */
721 /* writing back original value */
722 prodigy192_ak4114_write(ice, addr, orig_value);
723 exists = 1;
724 }
725 return exists;
726 }
727
728 /*
729 * initialize the chip
730 */
731 static int __devinit prodigy192_init(struct snd_ice1712 *ice)
732 {
733 static const unsigned short stac_inits_prodigy[] = {
734 STAC946X_RESET, 0,
735 STAC946X_MASTER_CLOCKING, 0x11,
736 /* STAC946X_MASTER_VOLUME, 0,
737 STAC946X_LF_VOLUME, 0,
738 STAC946X_RF_VOLUME, 0,
739 STAC946X_LR_VOLUME, 0,
740 STAC946X_RR_VOLUME, 0,
741 STAC946X_CENTER_VOLUME, 0,
742 STAC946X_LFE_VOLUME, 0,*/
743 (unsigned short)-1
744 };
745 const unsigned short *p;
746 int err = 0;
747 struct prodigy192_spec *spec;
748
749 /* prodigy 192 */
750 ice->num_total_dacs = 6;
751 ice->num_total_adcs = 2;
752 ice->vt1720 = 0; /* ice1724, e.g. 23 GPIOs */
753
754 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
755 if (!spec)
756 return -ENOMEM;
757 ice->spec = spec;
758 mutex_init(&spec->mute_mutex);
759
760 /* initialize codec */
761 p = stac_inits_prodigy;
762 for (; *p != (unsigned short)-1; p += 2)
763 stac9460_put(ice, p[0], p[1]);
764 ice->gpio.set_pro_rate = stac9460_set_rate_val;
765
766 /* MI/ODI/O add on card with AK4114 */
767 if (prodigy192_miodio_exists(ice)) {
768 err = prodigy192_ak4114_init(ice);
769 /* from this moment if err = 0 then
770 * spec->ak4114 should not be null
771 */
772 snd_printdd("AK4114 initialized with status %d\n", err);
773 } else
774 snd_printdd("AK4114 not found\n");
775 if (err < 0)
776 return err;
777
778 return 0;
779 }
780
781
782 /*
783 * Aureon boards don't provide the EEPROM data except for the vendor IDs.
784 * hence the driver needs to sets up it properly.
785 */
786
787 static unsigned char prodigy71_eeprom[] __devinitdata = {
788 [ICE_EEP2_SYSCONF] = 0x6a, /* 49MHz crystal, mpu401,
789 * spdif-in+ 1 stereo ADC,
790 * 3 stereo DACs
791 */
792 [ICE_EEP2_ACLINK] = 0x80, /* I2S */
793 [ICE_EEP2_I2S] = 0xf8, /* vol, 96k, 24bit, 192k */
794 [ICE_EEP2_SPDIF] = 0xc3, /* out-en, out-int, spdif-in */
795 [ICE_EEP2_GPIO_DIR] = 0xff,
796 [ICE_EEP2_GPIO_DIR1] = ~(VT1724_PRODIGY192_CDIN >> 8) ,
797 [ICE_EEP2_GPIO_DIR2] = 0xbf,
798 [ICE_EEP2_GPIO_MASK] = 0x00,
799 [ICE_EEP2_GPIO_MASK1] = 0x00,
800 [ICE_EEP2_GPIO_MASK2] = 0x00,
801 [ICE_EEP2_GPIO_STATE] = 0x00,
802 [ICE_EEP2_GPIO_STATE1] = 0x00,
803 [ICE_EEP2_GPIO_STATE2] = 0x10, /* GPIO20: 0 = CD drive dig. input
804 * passthrough,
805 * 1 = SPDIF-OUT from ice1724
806 */
807 };
808
809
810 /* entry point */
811 struct snd_ice1712_card_info snd_vt1724_prodigy192_cards[] __devinitdata = {
812 {
813 .subvendor = VT1724_SUBDEVICE_PRODIGY192VE,
814 .name = "Audiotrak Prodigy 192",
815 .model = "prodigy192",
816 .chip_init = prodigy192_init,
817 .build_controls = prodigy192_add_controls,
818 .eeprom_size = sizeof(prodigy71_eeprom),
819 .eeprom_data = prodigy71_eeprom,
820 },
821 { } /* terminator */
822 };
connection oriented routing - ARCHIVE NO UPDATES HERE