?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ppc: Clean up rtas_flash driver somewhat
[linux-2.6.git] / sound / pci / ice1712 / wtm.c
blobbcf30a387b87640f2f42202b1189af0fde49066e
1 /*
2 * ALSA driver for ICEnsemble VT1724 (Envy24HT)
3 *
4 * Lowlevel functions for Ego Sys Waveterminal 192M
5 *
6 * Copyright (c) 2006 Guedez Clement <klem.dev@gmail.com>
7 * Some functions are taken from the Prodigy192 driver
8 * source
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
25
26
27
28 #include <linux/delay.h>
29 #include <linux/interrupt.h>
30 #include <linux/init.h>
31 #include <sound/core.h>
32
33 #include "ice1712.h"
34 #include "envy24ht.h"
35 #include "wtm.h"
36 #include "stac946x.h"
37
38
39 /*
40 * 2*ADC 6*DAC no1 ringbuffer r/w on i2c bus
41 */
42 static inline void stac9460_put(struct snd_ice1712 *ice, int reg,
43 unsigned char val)
44 {
45 snd_vt1724_write_i2c(ice, STAC9460_I2C_ADDR, reg, val);
46 }
47
48 static inline unsigned char stac9460_get(struct snd_ice1712 *ice, int reg)
49 {
50 return snd_vt1724_read_i2c(ice, STAC9460_I2C_ADDR, reg);
51 }
52
53 /*
54 * 2*ADC 2*DAC no2 ringbuffer r/w on i2c bus
55 */
56 static inline void stac9460_2_put(struct snd_ice1712 *ice, int reg,
57 unsigned char val)
58 {
59 snd_vt1724_write_i2c(ice, STAC9460_2_I2C_ADDR, reg, val);
60 }
61
62 static inline unsigned char stac9460_2_get(struct snd_ice1712 *ice, int reg)
63 {
64 return snd_vt1724_read_i2c(ice, STAC9460_2_I2C_ADDR, reg);
65 }
66
67
68 /*
69 * DAC mute control
70 */
71 #define stac9460_dac_mute_info snd_ctl_boolean_mono_info
72
73 static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol,
74 struct snd_ctl_elem_value *ucontrol)
75 {
76 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
77 unsigned char val;
78 int idx, id;
79
80 if (kcontrol->private_value) {
81 idx = STAC946X_MASTER_VOLUME;
82 id = 0;
83 } else {
84 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
85 idx = id + STAC946X_LF_VOLUME;
86 }
87 if (id < 6)
88 val = stac9460_get(ice, idx);
89 else
90 val = stac9460_2_get(ice, idx - 6);
91 ucontrol->value.integer.value[0] = (~val >> 7) & 0x1;
92 return 0;
93 }
94
95 static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol,
96 struct snd_ctl_elem_value *ucontrol)
97 {
98 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
99 unsigned char new, old;
100 int id, idx;
101 int change;
102
103 if (kcontrol->private_value) {
104 idx = STAC946X_MASTER_VOLUME;
105 old = stac9460_get(ice, idx);
106 new = (~ucontrol->value.integer.value[0] << 7 & 0x80) |
107 (old & ~0x80);
108 change = (new != old);
109 if (change) {
110 stac9460_put(ice, idx, new);
111 stac9460_2_put(ice, idx, new);
112 }
113 } else {
114 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
115 idx = id + STAC946X_LF_VOLUME;
116 if (id < 6)
117 old = stac9460_get(ice, idx);
118 else
119 old = stac9460_2_get(ice, idx - 6);
120 new = (~ucontrol->value.integer.value[0] << 7 & 0x80) |
121 (old & ~0x80);
122 change = (new != old);
123 if (change) {
124 if (id < 6)
125 stac9460_put(ice, idx, new);
126 else
127 stac9460_2_put(ice, idx - 6, new);
128 }
129 }
130 return change;
131 }
132
133 /*
134 * DAC volume attenuation mixer control
135 */
136 static int stac9460_dac_vol_info(struct snd_kcontrol *kcontrol,
137 struct snd_ctl_elem_info *uinfo)
138 {
139 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
140 uinfo->count = 1;
141 uinfo->value.integer.min = 0; /* mute */
142 uinfo->value.integer.max = 0x7f; /* 0dB */
143 return 0;
144 }
145
146 static int stac9460_dac_vol_get(struct snd_kcontrol *kcontrol,
147 struct snd_ctl_elem_value *ucontrol)
148 {
149 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
150 int idx, id;
151 unsigned char vol;
152
153 if (kcontrol->private_value) {
154 idx = STAC946X_MASTER_VOLUME;
155 id = 0;
156 } else {
157 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
158 idx = id + STAC946X_LF_VOLUME;
159 }
160 if (id < 6)
161 vol = stac9460_get(ice, idx) & 0x7f;
162 else
163 vol = stac9460_2_get(ice, idx - 6) & 0x7f;
164 ucontrol->value.integer.value[0] = 0x7f - vol;
165 return 0;
166 }
167
168 static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol,
169 struct snd_ctl_elem_value *ucontrol)
170 {
171 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
172 int idx, id;
173 unsigned char tmp, ovol, nvol;
174 int change;
175
176 if (kcontrol->private_value) {
177 idx = STAC946X_MASTER_VOLUME;
178 nvol = ucontrol->value.integer.value[0] & 0x7f;
179 tmp = stac9460_get(ice, idx);
180 ovol = 0x7f - (tmp & 0x7f);
181 change = (ovol != nvol);
182 if (change) {
183 stac9460_put(ice, idx, (0x7f - nvol) | (tmp & 0x80));
184 stac9460_2_put(ice, idx, (0x7f - nvol) | (tmp & 0x80));
185 }
186 } else {
187 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
188 idx = id + STAC946X_LF_VOLUME;
189 nvol = ucontrol->value.integer.value[0] & 0x7f;
190 if (id < 6)
191 tmp = stac9460_get(ice, idx);
192 else
193 tmp = stac9460_2_get(ice, idx - 6);
194 ovol = 0x7f - (tmp & 0x7f);
195 change = (ovol != nvol);
196 if (change) {
197 if (id < 6)
198 stac9460_put(ice, idx, (0x7f - nvol) |
199 (tmp & 0x80));
200 else
201 stac9460_2_put(ice, idx-6, (0x7f - nvol) |
202 (tmp & 0x80));
203 }
204 }
205 return change;
206 }
207
208 /*
209 * ADC mute control
210 */
211 #define stac9460_adc_mute_info snd_ctl_boolean_stereo_info
212
213 static int stac9460_adc_mute_get(struct snd_kcontrol *kcontrol,
214 struct snd_ctl_elem_value *ucontrol)
215 {
216 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
217 unsigned char val;
218 int i, id;
219
220 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
221 if (id == 0) {
222 for (i = 0; i < 2; ++i) {
223 val = stac9460_get(ice, STAC946X_MIC_L_VOLUME + i);
224 ucontrol->value.integer.value[i] = ~val>>7 & 0x1;
225 }
226 } else {
227 for (i = 0; i < 2; ++i) {
228 val = stac9460_2_get(ice, STAC946X_MIC_L_VOLUME + i);
229 ucontrol->value.integer.value[i] = ~val>>7 & 0x1;
230 }
231 }
232 return 0;
233 }
234
235 static int stac9460_adc_mute_put(struct snd_kcontrol *kcontrol,
236 struct snd_ctl_elem_value *ucontrol)
237 {
238 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
239 unsigned char new, old;
240 int i, reg, id;
241 int change;
242
243 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
244 if (id == 0) {
245 for (i = 0; i < 2; ++i) {
246 reg = STAC946X_MIC_L_VOLUME + i;
247 old = stac9460_get(ice, reg);
248 new = (~ucontrol->value.integer.value[i]<<7&0x80) |
249 (old&~0x80);
250 change = (new != old);
251 if (change)
252 stac9460_put(ice, reg, new);
253 }
254 } else {
255 for (i = 0; i < 2; ++i) {
256 reg = STAC946X_MIC_L_VOLUME + i;
257 old = stac9460_2_get(ice, reg);
258 new = (~ucontrol->value.integer.value[i]<<7&0x80) |
259 (old&~0x80);
260 change = (new != old);
261 if (change)
262 stac9460_2_put(ice, reg, new);
263 }
264 }
265 return change;
266 }
267
268 /*
269 *ADC gain mixer control
270 */
271 static int stac9460_adc_vol_info(struct snd_kcontrol *kcontrol,
272 struct snd_ctl_elem_info *uinfo)
273 {
274 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
275 uinfo->count = 2;
276 uinfo->value.integer.min = 0; /* 0dB */
277 uinfo->value.integer.max = 0x0f; /* 22.5dB */
278 return 0;
279 }
280
281 static int stac9460_adc_vol_get(struct snd_kcontrol *kcontrol,
282 struct snd_ctl_elem_value *ucontrol)
283 {
284 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
285 int i, reg, id;
286 unsigned char vol;
287
288 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
289 if (id == 0) {
290 for (i = 0; i < 2; ++i) {
291 reg = STAC946X_MIC_L_VOLUME + i;
292 vol = stac9460_get(ice, reg) & 0x0f;
293 ucontrol->value.integer.value[i] = 0x0f - vol;
294 }
295 } else {
296 for (i = 0; i < 2; ++i) {
297 reg = STAC946X_MIC_L_VOLUME + i;
298 vol = stac9460_2_get(ice, reg) & 0x0f;
299 ucontrol->value.integer.value[i] = 0x0f - vol;
300 }
301 }
302 return 0;
303 }
304
305 static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol,
306 struct snd_ctl_elem_value *ucontrol)
307 {
308 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
309 int i, reg, id;
310 unsigned char ovol, nvol;
311 int change;
312
313 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
314 if (id == 0) {
315 for (i = 0; i < 2; ++i) {
316 reg = STAC946X_MIC_L_VOLUME + i;
317 nvol = ucontrol->value.integer.value[i] & 0x0f;
318 ovol = 0x0f - stac9460_get(ice, reg);
319 change = ((ovol & 0x0f) != nvol);
320 if (change)
321 stac9460_put(ice, reg, (0x0f - nvol) |
322 (ovol & ~0x0f));
323 }
324 } else {
325 for (i = 0; i < 2; ++i) {
326 reg = STAC946X_MIC_L_VOLUME + i;
327 nvol = ucontrol->value.integer.value[i] & 0x0f;
328 ovol = 0x0f - stac9460_2_get(ice, reg);
329 change = ((ovol & 0x0f) != nvol);
330 if (change)
331 stac9460_2_put(ice, reg, (0x0f - nvol) |
332 (ovol & ~0x0f));
333 }
334 }
335 return change;
336 }
337
338 /*
339 * MIC / LINE switch fonction
340 */
341
342 #define stac9460_mic_sw_info snd_ctl_boolean_mono_info
343
344 static int stac9460_mic_sw_get(struct snd_kcontrol *kcontrol,
345 struct snd_ctl_elem_value *ucontrol)
346 {
347 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
348 unsigned char val;
349 int id;
350
351 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
352 if (id == 0)
353 val = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
354 else
355 val = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE);
356 ucontrol->value.integer.value[0] = ~val>>7 & 0x1;
357 return 0;
358 }
359
360 static int stac9460_mic_sw_put(struct snd_kcontrol *kcontrol,
361 struct snd_ctl_elem_value *ucontrol)
362 {
363 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
364 unsigned char new, old;
365 int change, id;
366
367 id = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
368 if (id == 0)
369 old = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
370 else
371 old = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE);
372 new = (~ucontrol->value.integer.value[0] << 7 & 0x80) | (old & ~0x80);
373 change = (new != old);
374 if (change) {
375 if (id == 0)
376 stac9460_put(ice, STAC946X_GENERAL_PURPOSE, new);
377 else
378 stac9460_2_put(ice, STAC946X_GENERAL_PURPOSE, new);
379 }
380 return change;
381 }
382
383 /*
384 * Control tabs
385 */
386 static struct snd_kcontrol_new stac9640_controls[] = {
387 {
388 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
389 .name = "Master Playback Switch",
390 .info = stac9460_dac_mute_info,
391 .get = stac9460_dac_mute_get,
392 .put = stac9460_dac_mute_put,
393 .private_value = 1
394 },
395 {
396 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
397 .name = "Master Playback Volume",
398 .info = stac9460_dac_vol_info,
399 .get = stac9460_dac_vol_get,
400 .put = stac9460_dac_vol_put,
401 .private_value = 1,
402 },
403 {
404 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
405 .name = "MIC/Line switch",
406 .count = 2,
407 .info = stac9460_mic_sw_info,
408 .get = stac9460_mic_sw_get,
409 .put = stac9460_mic_sw_put,
410
411 },
412 {
413 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
414 .name = "DAC Switch",
415 .count = 8,
416 .info = stac9460_dac_mute_info,
417 .get = stac9460_dac_mute_get,
418 .put = stac9460_dac_mute_put,
419 },
420 {
421 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
422 .name = "DAC Volume",
423 .count = 8,
424 .info = stac9460_dac_vol_info,
425 .get = stac9460_dac_vol_get,
426 .put = stac9460_dac_vol_put,
427 },
428 {
429 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
430 .name = "ADC Switch",
431 .count = 2,
432 .info = stac9460_adc_mute_info,
433 .get = stac9460_adc_mute_get,
434 .put = stac9460_adc_mute_put,
435 },
436 {
437 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
438 .name = "ADC Volume",
439 .count = 2,
440 .info = stac9460_adc_vol_info,
441 .get = stac9460_adc_vol_get,
442 .put = stac9460_adc_vol_put,
443
444 }
445 };
446
447
448
449 /*INIT*/
450 static int wtm_add_controls(struct snd_ice1712 *ice)
451 {
452 unsigned int i;
453 int err;
454
455 for (i = 0; i < ARRAY_SIZE(stac9640_controls); i++) {
456 err = snd_ctl_add(ice->card,
457 snd_ctl_new1(&stac9640_controls[i], ice));
458 if (err < 0)
459 return err;
460 }
461 return 0;
462 }
463
464 static int wtm_init(struct snd_ice1712 *ice)
465 {
466 static unsigned short stac_inits_prodigy[] = {
467 STAC946X_RESET, 0,
468 (unsigned short)-1
469 };
470 unsigned short *p;
471
472 /*WTM 192M*/
473 ice->num_total_dacs = 8;
474 ice->num_total_adcs = 4;
475 ice->force_rdma1 = 1;
476
477 /*initialize codec*/
478 p = stac_inits_prodigy;
479 for (; *p != (unsigned short)-1; p += 2) {
480 stac9460_put(ice, p[0], p[1]);
481 stac9460_2_put(ice, p[0], p[1]);
482 }
483 return 0;
484 }
485
486
487 static unsigned char wtm_eeprom[] = {
488 0x47, /*SYSCONF: clock 192KHz, 4ADC, 8DAC */
489 0x80, /* ACLINK : I2S */
490 0xf8, /* I2S: vol; 96k, 24bit, 192k */
491 0xc1 /*SPDIF: out-en, spidf ext out*/,
492 0x9f, /* GPIO_DIR */
493 0xff, /* GPIO_DIR1 */
494 0x7f, /* GPIO_DIR2 */
495 0x9f, /* GPIO_MASK */
496 0xff, /* GPIO_MASK1 */
497 0x7f, /* GPIO_MASK2 */
498 0x16, /* GPIO_STATE */
499 0x80, /* GPIO_STATE1 */
500 0x00, /* GPIO_STATE2 */
501 };
502
503
504 /*entry point*/
505 struct snd_ice1712_card_info snd_vt1724_wtm_cards[] = {
506 {
507 .subvendor = VT1724_SUBDEVICE_WTM,
508 .name = "ESI Waveterminal 192M",
509 .model = "WT192M",
510 .chip_init = wtm_init,
511 .build_controls = wtm_add_controls,
512 .eeprom_size = sizeof(wtm_eeprom),
513 .eeprom_data = wtm_eeprom,
514 },
515 {} /*terminator*/
516 };
Linus' kernel tree