blob: 9c3a9c8d1dc2434944a4e58f857c78806ac11f33 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
James Courtier-Duttoned144f32005-05-27 23:28:27 +02004 * Version: 0.0.17
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
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.
James Courtier-Duttoned144f32005-05-27 23:28:27 +020040 * 0.0.17
41 * Implement Mic and Line in Capture.
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 *
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#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>
Jaroslav Kysela42750b02006-06-01 18:34:01 +020072#include <sound/tlv.h>
Jean Delvare6473d162007-03-06 02:45:12 -080073#include <asm/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75#include "ca0106.h"
76
Takashi Iwai0cb29ea2007-01-29 15:33:49 +010077static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale1, -5175, 25, 1);
78static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale2, -10350, 50, 1);
Jaroslav Kysela42750b02006-06-01 18:34:01 +020079
Takashi Iwaie4a3d142005-11-17 14:55:40 +010080static int snd_ca0106_shared_spdif_info(struct snd_kcontrol *kcontrol,
81 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082{
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
Takashi Iwaie4a3d142005-11-17 14:55:40 +010090static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol,
91 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
Takashi Iwaie4a3d142005-11-17 14:55:40 +010093 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95 ucontrol->value.enumerated.item[0] = emu->spdif_enable;
96 return 0;
97}
98
Takashi Iwaie4a3d142005-11-17 14:55:40 +010099static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol,
100 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100102 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 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);
James Courtier-Dutton1f829412005-05-21 16:23:37 +0200123 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100133static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol,
134 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
Takashi Iwai95a98262005-11-17 10:40:18 +0100136 static char *texts[6] = {
James Courtier-Dutton39596dc2005-12-16 21:59:59 +0100137 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out"
Takashi Iwai95a98262005-11-17 10:40:18 +0100138 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100149static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol,
150 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100152 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 ucontrol->value.enumerated.item[0] = emu->capture_source;
155 return 0;
156}
157
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100158static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
159 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100161 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 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
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100178static 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
194static 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
203static 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
James Courtier-Duttonbe0b7b02006-04-09 20:48:44 +0100234static 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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100248static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
249 struct snd_ctl_elem_info *uinfo)
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200250{
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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100262static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
263 struct snd_ctl_elem_value *ucontrol)
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200264{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100265 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200266
267 ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
268 return 0;
269}
270
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100271static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
272 struct snd_ctl_elem_value *ucontrol)
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200273{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100274 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200275 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) {
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100284 //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200285 tmp = inl(emu->port+GPIO) & ~0x400;
286 tmp = tmp | 0x400;
287 outl(tmp, emu->port+GPIO);
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100288 //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200289 } else {
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100290 //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200291 tmp = inl(emu->port+GPIO) & ~0x400;
292 outl(tmp, emu->port+GPIO);
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100293 //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200294 }
295 }
296 return change;
297}
298
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100299static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata =
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200300{
301 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100302 .name = "Shared Mic/Line in Capture Switch",
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200303 .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
James Courtier-Duttonbe0b7b02006-04-09 20:48:44 +0100308static 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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100318static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
319 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{
321 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
322 uinfo->count = 1;
323 return 0;
324}
325
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100326static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol,
327 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100329 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100339static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
340 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100349static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol,
350 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100352 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100369static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
370 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100379static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
380 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100382 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 unsigned int value;
Takashi Iwai95a98262005-11-17 10:40:18 +0100384 int channel_id, reg;
385
386 channel_id = (kcontrol->private_value >> 8) & 0xff;
387 reg = kcontrol->private_value & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100395static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
396 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100398 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
Takashi Iwai95a98262005-11-17 10:40:18 +0100399 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414}
415
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100416static 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
426static 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
439static 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
Takashi Iwai95a98262005-11-17 10:40:18 +0100473#define CA_VOLUME(xname,chid,reg) \
474{ \
475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
Jaroslav Kysela302e9c52006-07-05 17:39:49 +0200476 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
477 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100478 .info = snd_ca0106_volume_info, \
479 .get = snd_ca0106_volume_get, \
480 .put = snd_ca0106_volume_put, \
Takashi Iwai7cf0a952006-08-17 16:23:07 +0200481 .tlv = { .p = snd_ca0106_db_scale1 }, \
Takashi Iwai95a98262005-11-17 10:40:18 +0100482 .private_value = ((chid) << 8) | (reg) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483}
484
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100485static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
Takashi Iwai95a98262005-11-17 10:40:18 +0100486 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
James Courtier-Dutton39596dc2005-12-16 21:59:59 +0100495 CA_VOLUME("IEC958 Front Playback Volume",
Takashi Iwai95a98262005-11-17 10:40:18 +0100496 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
James Courtier-Dutton39596dc2005-12-16 21:59:59 +0100497 CA_VOLUME("IEC958 Rear Playback Volume",
Takashi Iwai95a98262005-11-17 10:40:18 +0100498 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
James Courtier-Dutton39596dc2005-12-16 21:59:59 +0100499 CA_VOLUME("IEC958 Center/LFE Playback Volume",
Takashi Iwai95a98262005-11-17 10:40:18 +0100500 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
James Courtier-Dutton39596dc2005-12-16 21:59:59 +0100501 CA_VOLUME("IEC958 Unknown Playback Volume",
Takashi Iwai95a98262005-11-17 10:40:18 +0100502 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,
James Courtier-Dutton39596dc2005-12-16 21:59:59 +0100517 .name = "IEC958 Playback Switch",
Takashi Iwai95a98262005-11-17 10:40:18 +0100518 .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,
James Courtier-Duttone6327cf2006-11-11 10:52:06 +0000524 .name = "Digital Source Capture Enum",
Takashi Iwai95a98262005-11-17 10:40:18 +0100525 .info = snd_ca0106_capture_source_info,
526 .get = snd_ca0106_capture_source_get,
527 .put = snd_ca0106_capture_source_put
528 },
529 {
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100530 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
James Courtier-Duttone6327cf2006-11-11 10:52:06 +0000531 .name = "Analog Source Capture Enum",
James Courtier-Dutton6129daa2006-04-09 13:01:34 +0100532 .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 {
Takashi Iwai95a98262005-11-17 10:40:18 +0100537 .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 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544};
545
James Courtier-Dutton7c157062006-12-10 00:00:38 +0000546#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
558static 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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100565static int __devinit remove_ctl(struct snd_card *card, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100567 struct snd_ctl_elem_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100574static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100576 struct snd_ctl_elem_id sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 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
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100584static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100586 struct snd_kcontrol *kctl = ctl_find(card, src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 if (kctl) {
588 strcpy(kctl->id.name, dst);
589 return 0;
590 }
591 return -ENOENT;
592}
593
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100594int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
Takashi Iwai95a98262005-11-17 10:40:18 +0100596 int i, err;
Takashi Iwaie4a3d142005-11-17 14:55:40 +0100597 struct snd_card *card = emu->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 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
Takashi Iwai95a98262005-11-17 10:40:18 +0100637 for (c = ca0106_remove_ctls; *c; c++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 remove_ctl(card, *c);
Takashi Iwai95a98262005-11-17 10:40:18 +0100639 for (c = ca0106_rename_ctls; *c; c += 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 rename_ctl(card, c[0], c[1]);
641#endif
642
Takashi Iwai95a98262005-11-17 10:40:18 +0100643 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)
James Courtier-Duttoned144f32005-05-27 23:28:27 +0200646 return err;
647 }
Takashi Iwai95a98262005-11-17 10:40:18 +0100648 if (emu->details->i2c_adc == 1) {
James Courtier-Dutton7c157062006-12-10 00:00:38 +0000649 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 }
James Courtier-Duttonbe0b7b02006-04-09 20:48:44 +0100654 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));
Takashi Iwai95a98262005-11-17 10:40:18 +0100658 if (err < 0)
659 return err;
660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 return 0;
662}
663