?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC66 3.0.0.4.374.130 core
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / sound / pci / ca0106 / ca0106_mixer.c
blob9c3a9c8d1dc2434944a4e58f857c78806ac11f33
1 /*
2 * Copyright (c) 2004 James Courtier-Dutton <James@superbug.demon.co.uk>
3 * Driver CA0106 chips. e.g. Sound Blaster Audigy LS and Live 24bit
4 * Version: 0.0.17
5 *
6 * FEATURES currently supported:
7 * See ca0106_main.c for features.
8 *
9 * Changelog:
10 * Support interrupts per period.
11 * Removed noise from Center/LFE channel when in Analog mode.
12 * Rename and remove mixer controls.
13 * 0.0.6
14 * Use separate card based DMA buffer for periods table list.
15 * 0.0.7
16 * Change remove and rename ctrls into lists.
17 * 0.0.8
18 * Try to fix capture sources.
19 * 0.0.9
20 * Fix AC3 output.
21 * Enable S32_LE format support.
22 * 0.0.10
23 * Enable playback 48000 and 96000 rates. (Rates other that these do not work, even with "plug:front".)
24 * 0.0.11
25 * Add Model name recognition.
26 * 0.0.12
27 * Correct interrupt timing. interrupt at end of period, instead of in the middle of a playback period.
28 * Remove redundent "voice" handling.
29 * 0.0.13
30 * Single trigger call for multi channels.
31 * 0.0.14
32 * Set limits based on what the sound card hardware can do.
33 * playback periods_min=2, periods_max=8
34 * capture hw constraints require period_size = n * 64 bytes.
35 * playback hw constraints require period_size = n * 64 bytes.
36 * 0.0.15
37 * Separated ca0106.c into separate functional .c files.
38 * 0.0.16
39 * Modified Copyright message.
40 * 0.0.17
41 * Implement Mic and Line in Capture.
42 *
43 * This code was initally based on code from ALSA's emu10k1x.c which is:
44 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
45 *
46 * This program is free software; you can redistribute it and/or modify
47 * it under the terms of the GNU General Public License as published by
48 * the Free Software Foundation; either version 2 of the License, or
49 * (at your option) any later version.
50 *
51 * This program is distributed in the hope that it will be useful,
52 * but WITHOUT ANY WARRANTY; without even the implied warranty of
53 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
54 * GNU General Public License for more details.
55 *
56 * You should have received a copy of the GNU General Public License
57 * along with this program; if not, write to the Free Software
58 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
59 *
60 */
61 #include <sound/driver.h>
62 #include <linux/delay.h>
63 #include <linux/init.h>
64 #include <linux/interrupt.h>
65 #include <linux/slab.h>
66 #include <linux/moduleparam.h>
67 #include <sound/core.h>
68 #include <sound/initval.h>
69 #include <sound/pcm.h>
70 #include <sound/ac97_codec.h>
71 #include <sound/info.h>
72 #include <sound/tlv.h>
73 #include <asm/io.h>
74
75 #include "ca0106.h"
76
77 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale1, -5175, 25, 1);
78 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale2, -10350, 50, 1);
79
80 static int snd_ca0106_shared_spdif_info(struct snd_kcontrol *kcontrol,
81 struct snd_ctl_elem_info *uinfo)
82 {
83 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
84 uinfo->count = 1;
85 uinfo->value.integer.min = 0;
86 uinfo->value.integer.max = 1;
87 return 0;
88 }
89
90 static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol,
91 struct snd_ctl_elem_value *ucontrol)
92 {
93 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
94
95 ucontrol->value.enumerated.item[0] = emu->spdif_enable;
96 return 0;
97 }
98
99 static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol,
100 struct snd_ctl_elem_value *ucontrol)
101 {
102 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
103 unsigned int val;
104 int change = 0;
105 u32 mask;
106
107 val = ucontrol->value.enumerated.item[0] ;
108 change = (emu->spdif_enable != val);
109 if (change) {
110 emu->spdif_enable = val;
111 if (val == 1) {
112 /* Digital */
113 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
114 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
115 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
116 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000);
117 mask = inl(emu->port + GPIO) & ~0x101;
118 outl(mask, emu->port + GPIO);
119
120 } else {
121 /* Analog */
122 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
123 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
124 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
125 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000);
126 mask = inl(emu->port + GPIO) | 0x101;
127 outl(mask, emu->port + GPIO);
128 }
129 }
130 return change;
131 }
132
133 static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol,
134 struct snd_ctl_elem_info *uinfo)
135 {
136 static char *texts[6] = {
137 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out"
138 };
139
140 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
141 uinfo->count = 1;
142 uinfo->value.enumerated.items = 6;
143 if (uinfo->value.enumerated.item > 5)
144 uinfo->value.enumerated.item = 5;
145 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
146 return 0;
147 }
148
149 static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol,
150 struct snd_ctl_elem_value *ucontrol)
151 {
152 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
153
154 ucontrol->value.enumerated.item[0] = emu->capture_source;
155 return 0;
156 }
157
158 static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
159 struct snd_ctl_elem_value *ucontrol)
160 {
161 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
162 unsigned int val;
163 int change = 0;
164 u32 mask;
165 u32 source;
166
167 val = ucontrol->value.enumerated.item[0] ;
168 change = (emu->capture_source != val);
169 if (change) {
170 emu->capture_source = val;
171 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
172 mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
173 snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
174 }
175 return change;
176 }
177
178 static int snd_ca0106_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
179 struct snd_ctl_elem_info *uinfo)
180 {
181 static char *texts[6] = {
182 "Phone", "Mic", "Line in", "Aux"
183 };
184
185 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
186 uinfo->count = 1;
187 uinfo->value.enumerated.items = 4;
188 if (uinfo->value.enumerated.item > 3)
189 uinfo->value.enumerated.item = 3;
190 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
191 return 0;
192 }
193
194 static int snd_ca0106_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
195 struct snd_ctl_elem_value *ucontrol)
196 {
197 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
198
199 ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
200 return 0;
201 }
202
203 static int snd_ca0106_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
204 struct snd_ctl_elem_value *ucontrol)
205 {
206 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
207 unsigned int source_id;
208 unsigned int ngain, ogain;
209 int change = 0;
210 u32 source;
211 /* If the capture source has changed,
212 * update the capture volume from the cached value
213 * for the particular source.
214 */
215 source_id = ucontrol->value.enumerated.item[0] ;
216 change = (emu->i2c_capture_source != source_id);
217 if (change) {
218 snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
219 ngain = emu->i2c_capture_volume[source_id][0]; /* Left */
220 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
221 if (ngain != ogain)
222 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff));
223 ngain = emu->i2c_capture_volume[source_id][1]; /* Left */
224 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Left */
225 if (ngain != ogain)
226 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
227 source = 1 << source_id;
228 snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
229 emu->i2c_capture_source = source_id;
230 }
231 return change;
232 }
233
234 static int snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol *kcontrol,
235 struct snd_ctl_elem_info *uinfo)
236 {
237 static char *texts[2] = { "Side out", "Line in" };
238
239 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
240 uinfo->count = 1;
241 uinfo->value.enumerated.items = 2;
242 if (uinfo->value.enumerated.item > 1)
243 uinfo->value.enumerated.item = 1;
244 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
245 return 0;
246 }
247
248 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
249 struct snd_ctl_elem_info *uinfo)
250 {
251 static char *texts[2] = { "Line in", "Mic in" };
252
253 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
254 uinfo->count = 1;
255 uinfo->value.enumerated.items = 2;
256 if (uinfo->value.enumerated.item > 1)
257 uinfo->value.enumerated.item = 1;
258 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
259 return 0;
260 }
261
262 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
263 struct snd_ctl_elem_value *ucontrol)
264 {
265 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
266
267 ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
268 return 0;
269 }
270
271 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
272 struct snd_ctl_elem_value *ucontrol)
273 {
274 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
275 unsigned int val;
276 int change = 0;
277 u32 tmp;
278
279 val = ucontrol->value.enumerated.item[0] ;
280 change = (emu->capture_mic_line_in != val);
281 if (change) {
282 emu->capture_mic_line_in = val;
283 if (val) {
284 //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
285 tmp = inl(emu->port+GPIO) & ~0x400;
286 tmp = tmp | 0x400;
287 outl(tmp, emu->port+GPIO);
288 //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
289 } else {
290 //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
291 tmp = inl(emu->port+GPIO) & ~0x400;
292 outl(tmp, emu->port+GPIO);
293 //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
294 }
295 }
296 return change;
297 }
298
299 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata =
300 {
301 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
302 .name = "Shared Mic/Line in Capture Switch",
303 .info = snd_ca0106_capture_mic_line_in_info,
304 .get = snd_ca0106_capture_mic_line_in_get,
305 .put = snd_ca0106_capture_mic_line_in_put
306 };
307
308 static struct snd_kcontrol_new snd_ca0106_capture_line_in_side_out __devinitdata =
309 {
310 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
311 .name = "Shared Line in/Side out Capture Switch",
312 .info = snd_ca0106_capture_line_in_side_out_info,
313 .get = snd_ca0106_capture_mic_line_in_get,
314 .put = snd_ca0106_capture_mic_line_in_put
315 };
316
317
318 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
319 struct snd_ctl_elem_info *uinfo)
320 {
321 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
322 uinfo->count = 1;
323 return 0;
324 }
325
326 static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol,
327 struct snd_ctl_elem_value *ucontrol)
328 {
329 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
330 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
331
332 ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
333 ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
334 ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
335 ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
336 return 0;
337 }
338
339 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
340 struct snd_ctl_elem_value *ucontrol)
341 {
342 ucontrol->value.iec958.status[0] = 0xff;
343 ucontrol->value.iec958.status[1] = 0xff;
344 ucontrol->value.iec958.status[2] = 0xff;
345 ucontrol->value.iec958.status[3] = 0xff;
346 return 0;
347 }
348
349 static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol,
350 struct snd_ctl_elem_value *ucontrol)
351 {
352 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
353 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
354 int change;
355 unsigned int val;
356
357 val = (ucontrol->value.iec958.status[0] << 0) |
358 (ucontrol->value.iec958.status[1] << 8) |
359 (ucontrol->value.iec958.status[2] << 16) |
360 (ucontrol->value.iec958.status[3] << 24);
361 change = val != emu->spdif_bits[idx];
362 if (change) {
363 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, val);
364 emu->spdif_bits[idx] = val;
365 }
366 return change;
367 }
368
369 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
370 struct snd_ctl_elem_info *uinfo)
371 {
372 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
373 uinfo->count = 2;
374 uinfo->value.integer.min = 0;
375 uinfo->value.integer.max = 255;
376 return 0;
377 }
378
379 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
380 struct snd_ctl_elem_value *ucontrol)
381 {
382 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
383 unsigned int value;
384 int channel_id, reg;
385
386 channel_id = (kcontrol->private_value >> 8) & 0xff;
387 reg = kcontrol->private_value & 0xff;
388
389 value = snd_ca0106_ptr_read(emu, reg, channel_id);
390 ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
391 ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
392 return 0;
393 }
394
395 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
396 struct snd_ctl_elem_value *ucontrol)
397 {
398 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
399 unsigned int oval, nval;
400 int channel_id, reg;
401
402 channel_id = (kcontrol->private_value >> 8) & 0xff;
403 reg = kcontrol->private_value & 0xff;
404
405 oval = snd_ca0106_ptr_read(emu, reg, channel_id);
406 nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
407 ((0xff - ucontrol->value.integer.value[1]) << 16);
408 nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
409 ((0xff - ucontrol->value.integer.value[1]) );
410 if (oval == nval)
411 return 0;
412 snd_ca0106_ptr_write(emu, reg, channel_id, nval);
413 return 1;
414 }
415
416 static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
417 struct snd_ctl_elem_info *uinfo)
418 {
419 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
420 uinfo->count = 2;
421 uinfo->value.integer.min = 0;
422 uinfo->value.integer.max = 255;
423 return 0;
424 }
425
426 static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
427 struct snd_ctl_elem_value *ucontrol)
428 {
429 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
430 int source_id;
431
432 source_id = kcontrol->private_value;
433
434 ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
435 ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
436 return 0;
437 }
438
439 static int snd_ca0106_i2c_volume_put(struct snd_kcontrol *kcontrol,
440 struct snd_ctl_elem_value *ucontrol)
441 {
442 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
443 unsigned int ogain;
444 unsigned int ngain;
445 int source_id;
446 int change = 0;
447
448 source_id = kcontrol->private_value;
449 ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
450 ngain = ucontrol->value.integer.value[0];
451 if (ngain > 0xff)
452 return 0;
453 if (ogain != ngain) {
454 if (emu->i2c_capture_source == source_id)
455 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
456 emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
457 change = 1;
458 }
459 ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
460 ngain = ucontrol->value.integer.value[1];
461 if (ngain > 0xff)
462 return 0;
463 if (ogain != ngain) {
464 if (emu->i2c_capture_source == source_id)
465 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
466 emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
467 change = 1;
468 }
469
470 return change;
471 }
472
473 #define CA_VOLUME(xname,chid,reg) \
474 { \
475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
476 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
477 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
478 .info = snd_ca0106_volume_info, \
479 .get = snd_ca0106_volume_get, \
480 .put = snd_ca0106_volume_put, \
481 .tlv = { .p = snd_ca0106_db_scale1 }, \
482 .private_value = ((chid) << 8) | (reg) \
483 }
484
485 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
486 CA_VOLUME("Analog Front Playback Volume",
487 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
488 CA_VOLUME("Analog Rear Playback Volume",
489 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
490 CA_VOLUME("Analog Center/LFE Playback Volume",
491 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
492 CA_VOLUME("Analog Side Playback Volume",
493 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
494
495 CA_VOLUME("IEC958 Front Playback Volume",
496 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
497 CA_VOLUME("IEC958 Rear Playback Volume",
498 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
499 CA_VOLUME("IEC958 Center/LFE Playback Volume",
500 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
501 CA_VOLUME("IEC958 Unknown Playback Volume",
502 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
503
504 CA_VOLUME("CAPTURE feedback Playback Volume",
505 1, CAPTURE_CONTROL),
506
507 {
508 .access = SNDRV_CTL_ELEM_ACCESS_READ,
509 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
510 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
511 .count = 4,
512 .info = snd_ca0106_spdif_info,
513 .get = snd_ca0106_spdif_get_mask
514 },
515 {
516 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
517 .name = "IEC958 Playback Switch",
518 .info = snd_ca0106_shared_spdif_info,
519 .get = snd_ca0106_shared_spdif_get,
520 .put = snd_ca0106_shared_spdif_put
521 },
522 {
523 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
524 .name = "Digital Source Capture Enum",
525 .info = snd_ca0106_capture_source_info,
526 .get = snd_ca0106_capture_source_get,
527 .put = snd_ca0106_capture_source_put
528 },
529 {
530 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
531 .name = "Analog Source Capture Enum",
532 .info = snd_ca0106_i2c_capture_source_info,
533 .get = snd_ca0106_i2c_capture_source_get,
534 .put = snd_ca0106_i2c_capture_source_put
535 },
536 {
537 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
538 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
539 .count = 4,
540 .info = snd_ca0106_spdif_info,
541 .get = snd_ca0106_spdif_get,
542 .put = snd_ca0106_spdif_put
543 },
544 };
545
546 #define I2C_VOLUME(xname,chid) \
547 { \
548 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
549 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
550 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
551 .info = snd_ca0106_i2c_volume_info, \
552 .get = snd_ca0106_i2c_volume_get, \
553 .put = snd_ca0106_i2c_volume_put, \
554 .tlv = { .p = snd_ca0106_db_scale2 }, \
555 .private_value = chid \
556 }
557
558 static struct snd_kcontrol_new snd_ca0106_volume_i2c_adc_ctls[] __devinitdata = {
559 I2C_VOLUME("Phone Capture Volume", 0),
560 I2C_VOLUME("Mic Capture Volume", 1),
561 I2C_VOLUME("Line in Capture Volume", 2),
562 I2C_VOLUME("Aux Capture Volume", 3),
563 };
564
565 static int __devinit remove_ctl(struct snd_card *card, const char *name)
566 {
567 struct snd_ctl_elem_id id;
568 memset(&id, 0, sizeof(id));
569 strcpy(id.name, name);
570 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
571 return snd_ctl_remove_id(card, &id);
572 }
573
574 static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name)
575 {
576 struct snd_ctl_elem_id sid;
577 memset(&sid, 0, sizeof(sid));
578 /* FIXME: strcpy is bad. */
579 strcpy(sid.name, name);
580 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
581 return snd_ctl_find_id(card, &sid);
582 }
583
584 static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst)
585 {
586 struct snd_kcontrol *kctl = ctl_find(card, src);
587 if (kctl) {
588 strcpy(kctl->id.name, dst);
589 return 0;
590 }
591 return -ENOENT;
592 }
593
594 int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
595 {
596 int i, err;
597 struct snd_card *card = emu->card;
598 char **c;
599 static char *ca0106_remove_ctls[] = {
600 "Master Mono Playback Switch",
601 "Master Mono Playback Volume",
602 "3D Control - Switch",
603 "3D Control Sigmatel - Depth",
604 "PCM Playback Switch",
605 "PCM Playback Volume",
606 "CD Playback Switch",
607 "CD Playback Volume",
608 "Phone Playback Switch",
609 "Phone Playback Volume",
610 "Video Playback Switch",
611 "Video Playback Volume",
612 "PC Speaker Playback Switch",
613 "PC Speaker Playback Volume",
614 "Mono Output Select",
615 "Capture Source",
616 "Capture Switch",
617 "Capture Volume",
618 "External Amplifier",
619 "Sigmatel 4-Speaker Stereo Playback Switch",
620 "Sigmatel Surround Phase Inversion Playback ",
621 NULL
622 };
623 static char *ca0106_rename_ctls[] = {
624 "Master Playback Switch", "Capture Switch",
625 "Master Playback Volume", "Capture Volume",
626 "Line Playback Switch", "AC97 Line Capture Switch",
627 "Line Playback Volume", "AC97 Line Capture Volume",
628 "Aux Playback Switch", "AC97 Aux Capture Switch",
629 "Aux Playback Volume", "AC97 Aux Capture Volume",
630 "Mic Playback Switch", "AC97 Mic Capture Switch",
631 "Mic Playback Volume", "AC97 Mic Capture Volume",
632 "Mic Select", "AC97 Mic Select",
633 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
634 NULL
635 };
636 #if 1
637 for (c = ca0106_remove_ctls; *c; c++)
638 remove_ctl(card, *c);
639 for (c = ca0106_rename_ctls; *c; c += 2)
640 rename_ctl(card, c[0], c[1]);
641 #endif
642
643 for (i = 0; i < ARRAY_SIZE(snd_ca0106_volume_ctls); i++) {
644 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_volume_ctls[i], emu));
645 if (err < 0)
646 return err;
647 }
648 if (emu->details->i2c_adc == 1) {
649 for (i = 0; i < ARRAY_SIZE(snd_ca0106_volume_i2c_adc_ctls); i++) {
650 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_volume_i2c_adc_ctls[i], emu));
651 if (err < 0)
652 return err;
653 }
654 if (emu->details->gpio_type == 1)
655 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
656 else /* gpio_type == 2 */
657 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_line_in_side_out, emu));
658 if (err < 0)
659 return err;
660 }
661 return 0;
662 }
663
Tomato firmware and modifications.