]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - sound/pci/ca0106/ca0106_mixer.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ALSA: cs5535 - Make OLPC-stuff depending on MGEODE_LX
[mirror_ubuntu-jammy-kernel.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.18
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 * 0.0.18
43 * Add support for mute control on SB Live 24bit (cards w/ SPI DAC)
44 *
45 * This code was initally based on code from ALSA's emu10k1x.c which is:
46 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
47 *
48 * This program is free software; you can redistribute it and/or modify
49 * it under the terms of the GNU General Public License as published by
50 * the Free Software Foundation; either version 2 of the License, or
51 * (at your option) any later version.
52 *
53 * This program is distributed in the hope that it will be useful,
54 * but WITHOUT ANY WARRANTY; without even the implied warranty of
55 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
56 * GNU General Public License for more details.
57 *
58 * You should have received a copy of the GNU General Public License
59 * along with this program; if not, write to the Free Software
60 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
61 *
62 */
63 #include <linux/delay.h>
64 #include <linux/init.h>
65 #include <linux/interrupt.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 #include <asm/io.h>
75
76 #include "ca0106.h"
77
78 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale1, -5175, 25, 1);
79 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale2, -10350, 50, 1);
80
81 #define snd_ca0106_shared_spdif_info snd_ctl_boolean_mono_info
82
83 static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol,
84 struct snd_ctl_elem_value *ucontrol)
85 {
86 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
87
88 ucontrol->value.integer.value[0] = emu->spdif_enable;
89 return 0;
90 }
91
92 static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol,
93 struct snd_ctl_elem_value *ucontrol)
94 {
95 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
96 unsigned int val;
97 int change = 0;
98 u32 mask;
99
100 val = !!ucontrol->value.integer.value[0];
101 change = (emu->spdif_enable != val);
102 if (change) {
103 emu->spdif_enable = val;
104 if (val) {
105 /* Digital */
106 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
107 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
108 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
109 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000);
110 mask = inl(emu->port + GPIO) & ~0x101;
111 outl(mask, emu->port + GPIO);
112
113 } else {
114 /* Analog */
115 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
116 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
117 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
118 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000);
119 mask = inl(emu->port + GPIO) | 0x101;
120 outl(mask, emu->port + GPIO);
121 }
122 }
123 return change;
124 }
125
126 static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol,
127 struct snd_ctl_elem_info *uinfo)
128 {
129 static char *texts[6] = {
130 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out"
131 };
132
133 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
134 uinfo->count = 1;
135 uinfo->value.enumerated.items = 6;
136 if (uinfo->value.enumerated.item > 5)
137 uinfo->value.enumerated.item = 5;
138 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
139 return 0;
140 }
141
142 static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol,
143 struct snd_ctl_elem_value *ucontrol)
144 {
145 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
146
147 ucontrol->value.enumerated.item[0] = emu->capture_source;
148 return 0;
149 }
150
151 static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
152 struct snd_ctl_elem_value *ucontrol)
153 {
154 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
155 unsigned int val;
156 int change = 0;
157 u32 mask;
158 u32 source;
159
160 val = ucontrol->value.enumerated.item[0] ;
161 if (val >= 6)
162 return -EINVAL;
163 change = (emu->capture_source != val);
164 if (change) {
165 emu->capture_source = val;
166 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
167 mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
168 snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
169 }
170 return change;
171 }
172
173 static int snd_ca0106_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
174 struct snd_ctl_elem_info *uinfo)
175 {
176 static char *texts[6] = {
177 "Phone", "Mic", "Line in", "Aux"
178 };
179
180 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
181 uinfo->count = 1;
182 uinfo->value.enumerated.items = 4;
183 if (uinfo->value.enumerated.item > 3)
184 uinfo->value.enumerated.item = 3;
185 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
186 return 0;
187 }
188
189 static int snd_ca0106_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
190 struct snd_ctl_elem_value *ucontrol)
191 {
192 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
193
194 ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
195 return 0;
196 }
197
198 static int snd_ca0106_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
199 struct snd_ctl_elem_value *ucontrol)
200 {
201 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
202 unsigned int source_id;
203 unsigned int ngain, ogain;
204 int change = 0;
205 u32 source;
206 /* If the capture source has changed,
207 * update the capture volume from the cached value
208 * for the particular source.
209 */
210 source_id = ucontrol->value.enumerated.item[0] ;
211 if (source_id >= 4)
212 return -EINVAL;
213 change = (emu->i2c_capture_source != source_id);
214 if (change) {
215 snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
216 ngain = emu->i2c_capture_volume[source_id][0]; /* Left */
217 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
218 if (ngain != ogain)
219 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff));
220 ngain = emu->i2c_capture_volume[source_id][1]; /* Left */
221 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Left */
222 if (ngain != ogain)
223 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
224 source = 1 << source_id;
225 snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
226 emu->i2c_capture_source = source_id;
227 }
228 return change;
229 }
230
231 static int snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol *kcontrol,
232 struct snd_ctl_elem_info *uinfo)
233 {
234 static char *texts[2] = { "Side out", "Line in" };
235
236 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
237 uinfo->count = 1;
238 uinfo->value.enumerated.items = 2;
239 if (uinfo->value.enumerated.item > 1)
240 uinfo->value.enumerated.item = 1;
241 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
242 return 0;
243 }
244
245 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
246 struct snd_ctl_elem_info *uinfo)
247 {
248 static char *texts[2] = { "Line in", "Mic in" };
249
250 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
251 uinfo->count = 1;
252 uinfo->value.enumerated.items = 2;
253 if (uinfo->value.enumerated.item > 1)
254 uinfo->value.enumerated.item = 1;
255 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
256 return 0;
257 }
258
259 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
260 struct snd_ctl_elem_value *ucontrol)
261 {
262 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
263
264 ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
265 return 0;
266 }
267
268 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
269 struct snd_ctl_elem_value *ucontrol)
270 {
271 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
272 unsigned int val;
273 int change = 0;
274 u32 tmp;
275
276 val = ucontrol->value.enumerated.item[0] ;
277 if (val > 1)
278 return -EINVAL;
279 change = (emu->capture_mic_line_in != val);
280 if (change) {
281 emu->capture_mic_line_in = val;
282 if (val) {
283 //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
284 tmp = inl(emu->port+GPIO) & ~0x400;
285 tmp = tmp | 0x400;
286 outl(tmp, emu->port+GPIO);
287 //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
288 } else {
289 //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
290 tmp = inl(emu->port+GPIO) & ~0x400;
291 outl(tmp, emu->port+GPIO);
292 //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
293 }
294 }
295 return change;
296 }
297
298 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata =
299 {
300 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
301 .name = "Shared Mic/Line in Capture Switch",
302 .info = snd_ca0106_capture_mic_line_in_info,
303 .get = snd_ca0106_capture_mic_line_in_get,
304 .put = snd_ca0106_capture_mic_line_in_put
305 };
306
307 static struct snd_kcontrol_new snd_ca0106_capture_line_in_side_out __devinitdata =
308 {
309 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
310 .name = "Shared Line in/Side out Capture Switch",
311 .info = snd_ca0106_capture_line_in_side_out_info,
312 .get = snd_ca0106_capture_mic_line_in_get,
313 .put = snd_ca0106_capture_mic_line_in_put
314 };
315
316
317 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
318 struct snd_ctl_elem_info *uinfo)
319 {
320 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
321 uinfo->count = 1;
322 return 0;
323 }
324
325 static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol,
326 struct snd_ctl_elem_value *ucontrol)
327 {
328 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
329 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
330
331 ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
332 ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
333 ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
334 ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
335 return 0;
336 }
337
338 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
339 struct snd_ctl_elem_value *ucontrol)
340 {
341 ucontrol->value.iec958.status[0] = 0xff;
342 ucontrol->value.iec958.status[1] = 0xff;
343 ucontrol->value.iec958.status[2] = 0xff;
344 ucontrol->value.iec958.status[3] = 0xff;
345 return 0;
346 }
347
348 static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol,
349 struct snd_ctl_elem_value *ucontrol)
350 {
351 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
352 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
353 int change;
354 unsigned int val;
355
356 val = (ucontrol->value.iec958.status[0] << 0) |
357 (ucontrol->value.iec958.status[1] << 8) |
358 (ucontrol->value.iec958.status[2] << 16) |
359 (ucontrol->value.iec958.status[3] << 24);
360 change = val != emu->spdif_bits[idx];
361 if (change) {
362 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, val);
363 emu->spdif_bits[idx] = val;
364 }
365 return change;
366 }
367
368 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
369 struct snd_ctl_elem_info *uinfo)
370 {
371 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
372 uinfo->count = 2;
373 uinfo->value.integer.min = 0;
374 uinfo->value.integer.max = 255;
375 return 0;
376 }
377
378 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
379 struct snd_ctl_elem_value *ucontrol)
380 {
381 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
382 unsigned int value;
383 int channel_id, reg;
384
385 channel_id = (kcontrol->private_value >> 8) & 0xff;
386 reg = kcontrol->private_value & 0xff;
387
388 value = snd_ca0106_ptr_read(emu, reg, channel_id);
389 ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
390 ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
391 return 0;
392 }
393
394 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
395 struct snd_ctl_elem_value *ucontrol)
396 {
397 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
398 unsigned int oval, nval;
399 int channel_id, reg;
400
401 channel_id = (kcontrol->private_value >> 8) & 0xff;
402 reg = kcontrol->private_value & 0xff;
403
404 oval = snd_ca0106_ptr_read(emu, reg, channel_id);
405 nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
406 ((0xff - ucontrol->value.integer.value[1]) << 16);
407 nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
408 ((0xff - ucontrol->value.integer.value[1]) );
409 if (oval == nval)
410 return 0;
411 snd_ca0106_ptr_write(emu, reg, channel_id, nval);
412 return 1;
413 }
414
415 static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
416 struct snd_ctl_elem_info *uinfo)
417 {
418 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
419 uinfo->count = 2;
420 uinfo->value.integer.min = 0;
421 uinfo->value.integer.max = 255;
422 return 0;
423 }
424
425 static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
426 struct snd_ctl_elem_value *ucontrol)
427 {
428 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
429 int source_id;
430
431 source_id = kcontrol->private_value;
432
433 ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
434 ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
435 return 0;
436 }
437
438 static int snd_ca0106_i2c_volume_put(struct snd_kcontrol *kcontrol,
439 struct snd_ctl_elem_value *ucontrol)
440 {
441 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
442 unsigned int ogain;
443 unsigned int ngain;
444 int source_id;
445 int change = 0;
446
447 source_id = kcontrol->private_value;
448 ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
449 ngain = ucontrol->value.integer.value[0];
450 if (ngain > 0xff)
451 return -EINVAL;
452 if (ogain != ngain) {
453 if (emu->i2c_capture_source == source_id)
454 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
455 emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
456 change = 1;
457 }
458 ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
459 ngain = ucontrol->value.integer.value[1];
460 if (ngain > 0xff)
461 return -EINVAL;
462 if (ogain != ngain) {
463 if (emu->i2c_capture_source == source_id)
464 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
465 emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
466 change = 1;
467 }
468
469 return change;
470 }
471
472 #define spi_mute_info snd_ctl_boolean_mono_info
473
474 static int spi_mute_get(struct snd_kcontrol *kcontrol,
475 struct snd_ctl_elem_value *ucontrol)
476 {
477 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
478 unsigned int reg = kcontrol->private_value >> SPI_REG_SHIFT;
479 unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
480
481 ucontrol->value.integer.value[0] = !(emu->spi_dac_reg[reg] & bit);
482 return 0;
483 }
484
485 static int spi_mute_put(struct snd_kcontrol *kcontrol,
486 struct snd_ctl_elem_value *ucontrol)
487 {
488 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
489 unsigned int reg = kcontrol->private_value >> SPI_REG_SHIFT;
490 unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
491 int ret;
492
493 ret = emu->spi_dac_reg[reg] & bit;
494 if (ucontrol->value.integer.value[0]) {
495 if (!ret) /* bit already cleared, do nothing */
496 return 0;
497 emu->spi_dac_reg[reg] &= ~bit;
498 } else {
499 if (ret) /* bit already set, do nothing */
500 return 0;
501 emu->spi_dac_reg[reg] |= bit;
502 }
503
504 ret = snd_ca0106_spi_write(emu, emu->spi_dac_reg[reg]);
505 return ret ? -EINVAL : 1;
506 }
507
508 #define CA_VOLUME(xname,chid,reg) \
509 { \
510 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
511 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
512 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
513 .info = snd_ca0106_volume_info, \
514 .get = snd_ca0106_volume_get, \
515 .put = snd_ca0106_volume_put, \
516 .tlv = { .p = snd_ca0106_db_scale1 }, \
517 .private_value = ((chid) << 8) | (reg) \
518 }
519
520 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
521 CA_VOLUME("Analog Front Playback Volume",
522 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
523 CA_VOLUME("Analog Rear Playback Volume",
524 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
525 CA_VOLUME("Analog Center/LFE Playback Volume",
526 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
527 CA_VOLUME("Analog Side Playback Volume",
528 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
529
530 CA_VOLUME("IEC958 Front Playback Volume",
531 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
532 CA_VOLUME("IEC958 Rear Playback Volume",
533 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
534 CA_VOLUME("IEC958 Center/LFE Playback Volume",
535 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
536 CA_VOLUME("IEC958 Unknown Playback Volume",
537 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
538
539 CA_VOLUME("CAPTURE feedback Playback Volume",
540 1, CAPTURE_CONTROL),
541
542 {
543 .access = SNDRV_CTL_ELEM_ACCESS_READ,
544 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
545 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
546 .count = 4,
547 .info = snd_ca0106_spdif_info,
548 .get = snd_ca0106_spdif_get_mask
549 },
550 {
551 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
552 .name = "IEC958 Playback Switch",
553 .info = snd_ca0106_shared_spdif_info,
554 .get = snd_ca0106_shared_spdif_get,
555 .put = snd_ca0106_shared_spdif_put
556 },
557 {
558 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
559 .name = "Digital Source Capture Enum",
560 .info = snd_ca0106_capture_source_info,
561 .get = snd_ca0106_capture_source_get,
562 .put = snd_ca0106_capture_source_put
563 },
564 {
565 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
566 .name = "Analog Source Capture Enum",
567 .info = snd_ca0106_i2c_capture_source_info,
568 .get = snd_ca0106_i2c_capture_source_get,
569 .put = snd_ca0106_i2c_capture_source_put
570 },
571 {
572 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
573 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
574 .count = 4,
575 .info = snd_ca0106_spdif_info,
576 .get = snd_ca0106_spdif_get,
577 .put = snd_ca0106_spdif_put
578 },
579 };
580
581 #define I2C_VOLUME(xname,chid) \
582 { \
583 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
584 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
585 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
586 .info = snd_ca0106_i2c_volume_info, \
587 .get = snd_ca0106_i2c_volume_get, \
588 .put = snd_ca0106_i2c_volume_put, \
589 .tlv = { .p = snd_ca0106_db_scale2 }, \
590 .private_value = chid \
591 }
592
593 static struct snd_kcontrol_new snd_ca0106_volume_i2c_adc_ctls[] __devinitdata = {
594 I2C_VOLUME("Phone Capture Volume", 0),
595 I2C_VOLUME("Mic Capture Volume", 1),
596 I2C_VOLUME("Line in Capture Volume", 2),
597 I2C_VOLUME("Aux Capture Volume", 3),
598 };
599
600 #define SPI_SWITCH(xname,reg,bit) \
601 { \
602 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
603 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
604 .info = spi_mute_info, \
605 .get = spi_mute_get, \
606 .put = spi_mute_put, \
607 .private_value = (reg<<SPI_REG_SHIFT) | (bit) \
608 }
609
610 static struct snd_kcontrol_new snd_ca0106_volume_spi_dac_ctls[]
611 __devinitdata = {
612 SPI_SWITCH("Analog Front Playback Switch",
613 SPI_DMUTE4_REG, SPI_DMUTE4_BIT),
614 SPI_SWITCH("Analog Rear Playback Switch",
615 SPI_DMUTE0_REG, SPI_DMUTE0_BIT),
616 SPI_SWITCH("Analog Center/LFE Playback Switch",
617 SPI_DMUTE2_REG, SPI_DMUTE2_BIT),
618 SPI_SWITCH("Analog Side Playback Switch",
619 SPI_DMUTE1_REG, SPI_DMUTE1_BIT),
620 };
621
622 static int __devinit remove_ctl(struct snd_card *card, const char *name)
623 {
624 struct snd_ctl_elem_id id;
625 memset(&id, 0, sizeof(id));
626 strcpy(id.name, name);
627 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
628 return snd_ctl_remove_id(card, &id);
629 }
630
631 static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name)
632 {
633 struct snd_ctl_elem_id sid;
634 memset(&sid, 0, sizeof(sid));
635 /* FIXME: strcpy is bad. */
636 strcpy(sid.name, name);
637 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
638 return snd_ctl_find_id(card, &sid);
639 }
640
641 static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst)
642 {
643 struct snd_kcontrol *kctl = ctl_find(card, src);
644 if (kctl) {
645 strcpy(kctl->id.name, dst);
646 return 0;
647 }
648 return -ENOENT;
649 }
650
651 #define ADD_CTLS(emu, ctls) \
652 do { \
653 int i, _err; \
654 for (i = 0; i < ARRAY_SIZE(ctls); i++) { \
655 _err = snd_ctl_add(card, snd_ctl_new1(&ctls[i], emu)); \
656 if (_err < 0) \
657 return _err; \
658 } \
659 } while (0)
660
661 static __devinitdata
662 DECLARE_TLV_DB_SCALE(snd_ca0106_master_db_scale, -6375, 50, 1);
663
664 static char *slave_vols[] __devinitdata = {
665 "Analog Front Playback Volume",
666 "Analog Rear Playback Volume",
667 "Analog Center/LFE Playback Volume",
668 "Analog Side Playback Volume",
669 "IEC958 Front Playback Volume",
670 "IEC958 Rear Playback Volume",
671 "IEC958 Center/LFE Playback Volume",
672 "IEC958 Unknown Playback Volume",
673 "CAPTURE feedback Playback Volume",
674 NULL
675 };
676
677 static char *slave_sws[] __devinitdata = {
678 "Analog Front Playback Switch",
679 "Analog Rear Playback Switch",
680 "Analog Center/LFE Playback Switch",
681 "Analog Side Playback Switch",
682 "IEC958 Playback Switch",
683 NULL
684 };
685
686 static void __devinit add_slaves(struct snd_card *card,
687 struct snd_kcontrol *master, char **list)
688 {
689 for (; *list; list++) {
690 struct snd_kcontrol *slave = ctl_find(card, *list);
691 if (slave)
692 snd_ctl_add_slave(master, slave);
693 }
694 }
695
696 int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
697 {
698 int err;
699 struct snd_card *card = emu->card;
700 char **c;
701 struct snd_kcontrol *vmaster;
702 static char *ca0106_remove_ctls[] = {
703 "Master Mono Playback Switch",
704 "Master Mono Playback Volume",
705 "3D Control - Switch",
706 "3D Control Sigmatel - Depth",
707 "PCM Playback Switch",
708 "PCM Playback Volume",
709 "CD Playback Switch",
710 "CD Playback Volume",
711 "Phone Playback Switch",
712 "Phone Playback Volume",
713 "Video Playback Switch",
714 "Video Playback Volume",
715 "PC Speaker Playback Switch",
716 "PC Speaker Playback Volume",
717 "Mono Output Select",
718 "Capture Source",
719 "Capture Switch",
720 "Capture Volume",
721 "External Amplifier",
722 "Sigmatel 4-Speaker Stereo Playback Switch",
723 "Sigmatel Surround Phase Inversion Playback ",
724 NULL
725 };
726 static char *ca0106_rename_ctls[] = {
727 "Master Playback Switch", "Capture Switch",
728 "Master Playback Volume", "Capture Volume",
729 "Line Playback Switch", "AC97 Line Capture Switch",
730 "Line Playback Volume", "AC97 Line Capture Volume",
731 "Aux Playback Switch", "AC97 Aux Capture Switch",
732 "Aux Playback Volume", "AC97 Aux Capture Volume",
733 "Mic Playback Switch", "AC97 Mic Capture Switch",
734 "Mic Playback Volume", "AC97 Mic Capture Volume",
735 "Mic Select", "AC97 Mic Select",
736 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
737 NULL
738 };
739 #if 1
740 for (c = ca0106_remove_ctls; *c; c++)
741 remove_ctl(card, *c);
742 for (c = ca0106_rename_ctls; *c; c += 2)
743 rename_ctl(card, c[0], c[1]);
744 #endif
745
746 ADD_CTLS(emu, snd_ca0106_volume_ctls);
747 if (emu->details->i2c_adc == 1) {
748 ADD_CTLS(emu, snd_ca0106_volume_i2c_adc_ctls);
749 if (emu->details->gpio_type == 1)
750 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
751 else /* gpio_type == 2 */
752 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_line_in_side_out, emu));
753 if (err < 0)
754 return err;
755 }
756 if (emu->details->spi_dac == 1)
757 ADD_CTLS(emu, snd_ca0106_volume_spi_dac_ctls);
758
759 /* Create virtual master controls */
760 vmaster = snd_ctl_make_virtual_master("Master Playback Volume",
761 snd_ca0106_master_db_scale);
762 if (!vmaster)
763 return -ENOMEM;
764 add_slaves(card, vmaster, slave_vols);
765
766 if (emu->details->spi_dac == 1) {
767 vmaster = snd_ctl_make_virtual_master("Master Playback Switch",
768 NULL);
769 if (!vmaster)
770 return -ENOMEM;
771 add_slaves(card, vmaster, slave_sws);
772 }
773 return 0;
774 }
775
Ubuntu Jammy Linux kernel mirror