289f78a416080b92dab44414dd75572c562dba78
[linux-2.6.git] / sound / pci / ca0106 / ca0106_mixer.c
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/pci.h>
66 #include <linux/slab.h>
67 #include <linux/moduleparam.h>
68 #include <sound/core.h>
69 #include <sound/initval.h>
70 #include <sound/pcm.h>
71 #include <sound/ac97_codec.h>
72 #include <sound/info.h>
73 #include <sound/tlv.h>
74
75 #include "ca0106.h"
76
77 static DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale1, -5175, 25, 1);
78 static 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