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
6 * FEATURES currently supported:
7 * See ca0106_main.c for features.
10 * Support interrupts per period.
11 * Removed noise from Center/LFE channel when in Analog mode.
12 * Rename and remove mixer controls.
14 * Use separate card based DMA buffer for periods table list.
16 * Change remove and rename ctrls into lists.
18 * Try to fix capture sources.
21 * Enable S32_LE format support.
23 * Enable playback 48000 and 96000 rates. (Rates other that these do not work, even with "plug:front".)
25 * Add Model name recognition.
27 * Correct interrupt timing. interrupt at end of period, instead of in the middle of a playback period.
28 * Remove redundent "voice" handling.
30 * Single trigger call for multi channels.
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.
37 * Separated ca0106.c into separate functional .c files.
39 * Modified Copyright message.
41 * Implement Mic and Line in Capture.
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>
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.
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.
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
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>
76 static int snd_ca0106_shared_spdif_info(struct snd_kcontrol *kcontrol,
77 struct snd_ctl_elem_info *uinfo)
79 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
81 uinfo->value.integer.min = 0;
82 uinfo->value.integer.max = 1;
86 static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol,
87 struct snd_ctl_elem_value *ucontrol)
89 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
91 ucontrol->value.enumerated.item[0] = emu->spdif_enable;
95 static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol,
96 struct snd_ctl_elem_value *ucontrol)
98 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
103 val = ucontrol->value.enumerated.item[0] ;
104 change = (emu->spdif_enable != val);
106 emu->spdif_enable = val;
109 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
110 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
111 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
112 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000);
113 mask = inl(emu->port + GPIO) & ~0x101;
114 outl(mask, emu->port + GPIO);
118 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
119 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
120 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
121 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000);
122 mask = inl(emu->port + GPIO) | 0x101;
123 outl(mask, emu->port + GPIO);
129 static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol,
130 struct snd_ctl_elem_info *uinfo)
132 static char *texts[6] = {
133 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out"
136 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
138 uinfo->value.enumerated.items = 6;
139 if (uinfo->value.enumerated.item > 5)
140 uinfo->value.enumerated.item = 5;
141 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
145 static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol,
146 struct snd_ctl_elem_value *ucontrol)
148 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
150 ucontrol->value.enumerated.item[0] = emu->capture_source;
154 static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
155 struct snd_ctl_elem_value *ucontrol)
157 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
163 val = ucontrol->value.enumerated.item[0] ;
164 change = (emu->capture_source != val);
166 emu->capture_source = val;
167 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
168 mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
169 snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
174 static int snd_ca0106_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
175 struct snd_ctl_elem_info *uinfo)
177 static char *texts[6] = {
178 "Phone", "Mic", "Line in", "Aux"
181 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
183 uinfo->value.enumerated.items = 4;
184 if (uinfo->value.enumerated.item > 3)
185 uinfo->value.enumerated.item = 3;
186 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
190 static int snd_ca0106_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
191 struct snd_ctl_elem_value *ucontrol)
193 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
195 ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
199 static int snd_ca0106_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
200 struct snd_ctl_elem_value *ucontrol)
202 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
203 unsigned int source_id;
204 unsigned int ngain, ogain;
207 /* If the capture source has changed,
208 * update the capture volume from the cached value
209 * for the particular source.
211 source_id = ucontrol->value.enumerated.item[0] ;
212 change = (emu->i2c_capture_source != source_id);
214 snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
215 ngain = emu->i2c_capture_volume[source_id][0]; /* Left */
216 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
218 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff));
219 ngain = emu->i2c_capture_volume[source_id][1]; /* Left */
220 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Left */
222 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
223 source = 1 << source_id;
224 snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
225 emu->i2c_capture_source = source_id;
230 static int snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol *kcontrol,
231 struct snd_ctl_elem_info *uinfo)
233 static char *texts[2] = { "Side out", "Line in" };
235 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
237 uinfo->value.enumerated.items = 2;
238 if (uinfo->value.enumerated.item > 1)
239 uinfo->value.enumerated.item = 1;
240 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
244 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
245 struct snd_ctl_elem_info *uinfo)
247 static char *texts[2] = { "Line in", "Mic in" };
249 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
251 uinfo->value.enumerated.items = 2;
252 if (uinfo->value.enumerated.item > 1)
253 uinfo->value.enumerated.item = 1;
254 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
258 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
259 struct snd_ctl_elem_value *ucontrol)
261 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
263 ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
267 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
268 struct snd_ctl_elem_value *ucontrol)
270 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
275 val = ucontrol->value.enumerated.item[0] ;
276 change = (emu->capture_mic_line_in != val);
278 emu->capture_mic_line_in = val;
280 //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
281 tmp = inl(emu->port+GPIO) & ~0x400;
283 outl(tmp, emu->port+GPIO);
284 //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
286 //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
287 tmp = inl(emu->port+GPIO) & ~0x400;
288 outl(tmp, emu->port+GPIO);
289 //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
295 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata =
297 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
298 .name = "Shared Mic/Line in Capture Switch",
299 .info = snd_ca0106_capture_mic_line_in_info,
300 .get = snd_ca0106_capture_mic_line_in_get,
301 .put = snd_ca0106_capture_mic_line_in_put
304 static struct snd_kcontrol_new snd_ca0106_capture_line_in_side_out __devinitdata =
306 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
307 .name = "Shared Line in/Side out Capture Switch",
308 .info = snd_ca0106_capture_line_in_side_out_info,
309 .get = snd_ca0106_capture_mic_line_in_get,
310 .put = snd_ca0106_capture_mic_line_in_put
314 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
315 struct snd_ctl_elem_info *uinfo)
317 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
322 static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol,
323 struct snd_ctl_elem_value *ucontrol)
325 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
326 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
328 ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
329 ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
330 ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
331 ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
335 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
336 struct snd_ctl_elem_value *ucontrol)
338 ucontrol->value.iec958.status[0] = 0xff;
339 ucontrol->value.iec958.status[1] = 0xff;
340 ucontrol->value.iec958.status[2] = 0xff;
341 ucontrol->value.iec958.status[3] = 0xff;
345 static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol,
346 struct snd_ctl_elem_value *ucontrol)
348 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
349 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
353 val = (ucontrol->value.iec958.status[0] << 0) |
354 (ucontrol->value.iec958.status[1] << 8) |
355 (ucontrol->value.iec958.status[2] << 16) |
356 (ucontrol->value.iec958.status[3] << 24);
357 change = val != emu->spdif_bits[idx];
359 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, val);
360 emu->spdif_bits[idx] = val;
365 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
366 struct snd_ctl_elem_info *uinfo)
368 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
370 uinfo->value.integer.min = 0;
371 uinfo->value.integer.max = 255;
375 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
376 struct snd_ctl_elem_value *ucontrol)
378 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
382 channel_id = (kcontrol->private_value >> 8) & 0xff;
383 reg = kcontrol->private_value & 0xff;
385 value = snd_ca0106_ptr_read(emu, reg, channel_id);
386 ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
387 ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
391 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
392 struct snd_ctl_elem_value *ucontrol)
394 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
395 unsigned int oval, nval;
398 channel_id = (kcontrol->private_value >> 8) & 0xff;
399 reg = kcontrol->private_value & 0xff;
401 oval = snd_ca0106_ptr_read(emu, reg, channel_id);
402 nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
403 ((0xff - ucontrol->value.integer.value[1]) << 16);
404 nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
405 ((0xff - ucontrol->value.integer.value[1]) );
408 snd_ca0106_ptr_write(emu, reg, channel_id, nval);
412 static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
413 struct snd_ctl_elem_info *uinfo)
415 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
417 uinfo->value.integer.min = 0;
418 uinfo->value.integer.max = 255;
422 static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
423 struct snd_ctl_elem_value *ucontrol)
425 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
428 source_id = kcontrol->private_value;
430 ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
431 ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
435 static int snd_ca0106_i2c_volume_put(struct snd_kcontrol *kcontrol,
436 struct snd_ctl_elem_value *ucontrol)
438 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
444 source_id = kcontrol->private_value;
445 ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
446 ngain = ucontrol->value.integer.value[0];
449 if (ogain != ngain) {
450 if (emu->i2c_capture_source == source_id)
451 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
452 emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
455 ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
456 ngain = ucontrol->value.integer.value[1];
459 if (ogain != ngain) {
460 if (emu->i2c_capture_source == source_id)
461 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
462 emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
469 #define CA_VOLUME(xname,chid,reg) \
471 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
472 .info = snd_ca0106_volume_info, \
473 .get = snd_ca0106_volume_get, \
474 .put = snd_ca0106_volume_put, \
475 .private_value = ((chid) << 8) | (reg) \
478 #define I2C_VOLUME(xname,chid) \
480 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
481 .info = snd_ca0106_i2c_volume_info, \
482 .get = snd_ca0106_i2c_volume_get, \
483 .put = snd_ca0106_i2c_volume_put, \
484 .private_value = chid \
488 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
489 CA_VOLUME("Analog Front Playback Volume",
490 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
491 CA_VOLUME("Analog Rear Playback Volume",
492 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
493 CA_VOLUME("Analog Center/LFE Playback Volume",
494 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
495 CA_VOLUME("Analog Side Playback Volume",
496 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
498 CA_VOLUME("IEC958 Front Playback Volume",
499 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
500 CA_VOLUME("IEC958 Rear Playback Volume",
501 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
502 CA_VOLUME("IEC958 Center/LFE Playback Volume",
503 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
504 CA_VOLUME("IEC958 Unknown Playback Volume",
505 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
507 CA_VOLUME("CAPTURE feedback Playback Volume",
510 I2C_VOLUME("Phone Capture Volume", 0),
511 I2C_VOLUME("Mic Capture Volume", 1),
512 I2C_VOLUME("Line in Capture Volume", 2),
513 I2C_VOLUME("Aux Capture Volume", 3),
516 .access = SNDRV_CTL_ELEM_ACCESS_READ,
517 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
518 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
520 .info = snd_ca0106_spdif_info,
521 .get = snd_ca0106_spdif_get_mask
524 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
525 .name = "IEC958 Playback Switch",
526 .info = snd_ca0106_shared_spdif_info,
527 .get = snd_ca0106_shared_spdif_get,
528 .put = snd_ca0106_shared_spdif_put
531 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
532 .name = "Digital Capture Source",
533 .info = snd_ca0106_capture_source_info,
534 .get = snd_ca0106_capture_source_get,
535 .put = snd_ca0106_capture_source_put
538 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
539 .name = "Capture Source",
540 .info = snd_ca0106_i2c_capture_source_info,
541 .get = snd_ca0106_i2c_capture_source_get,
542 .put = snd_ca0106_i2c_capture_source_put
545 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
546 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
548 .info = snd_ca0106_spdif_info,
549 .get = snd_ca0106_spdif_get,
550 .put = snd_ca0106_spdif_put
554 static int __devinit remove_ctl(struct snd_card *card, const char *name)
556 struct snd_ctl_elem_id id;
557 memset(&id, 0, sizeof(id));
558 strcpy(id.name, name);
559 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
560 return snd_ctl_remove_id(card, &id);
563 static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name)
565 struct snd_ctl_elem_id sid;
566 memset(&sid, 0, sizeof(sid));
567 /* FIXME: strcpy is bad. */
568 strcpy(sid.name, name);
569 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
570 return snd_ctl_find_id(card, &sid);
573 static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst)
575 struct snd_kcontrol *kctl = ctl_find(card, src);
577 strcpy(kctl->id.name, dst);
583 int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
586 struct snd_card *card = emu->card;
588 static char *ca0106_remove_ctls[] = {
589 "Master Mono Playback Switch",
590 "Master Mono Playback Volume",
591 "3D Control - Switch",
592 "3D Control Sigmatel - Depth",
593 "PCM Playback Switch",
594 "PCM Playback Volume",
595 "CD Playback Switch",
596 "CD Playback Volume",
597 "Phone Playback Switch",
598 "Phone Playback Volume",
599 "Video Playback Switch",
600 "Video Playback Volume",
601 "PC Speaker Playback Switch",
602 "PC Speaker Playback Volume",
603 "Mono Output Select",
607 "External Amplifier",
608 "Sigmatel 4-Speaker Stereo Playback Switch",
609 "Sigmatel Surround Phase Inversion Playback ",
612 static char *ca0106_rename_ctls[] = {
613 "Master Playback Switch", "Capture Switch",
614 "Master Playback Volume", "Capture Volume",
615 "Line Playback Switch", "AC97 Line Capture Switch",
616 "Line Playback Volume", "AC97 Line Capture Volume",
617 "Aux Playback Switch", "AC97 Aux Capture Switch",
618 "Aux Playback Volume", "AC97 Aux Capture Volume",
619 "Mic Playback Switch", "AC97 Mic Capture Switch",
620 "Mic Playback Volume", "AC97 Mic Capture Volume",
621 "Mic Select", "AC97 Mic Select",
622 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
626 for (c = ca0106_remove_ctls; *c; c++)
627 remove_ctl(card, *c);
628 for (c = ca0106_rename_ctls; *c; c += 2)
629 rename_ctl(card, c[0], c[1]);
632 for (i = 0; i < ARRAY_SIZE(snd_ca0106_volume_ctls); i++) {
633 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_volume_ctls[i], emu));
637 if (emu->details->i2c_adc == 1) {
638 if (emu->details->gpio_type == 1)
639 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
640 else /* gpio_type == 2 */
641 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_line_in_side_out, emu));