?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net: dsa: mt7530: set CPU port to fallback mode
[linux/fpc-iii.git] / sound / pci / ca0106 / ca0106_mixer.c
blobb4d3415331f63c3008f283708f36e08c578c694f
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 initially 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/moduleparam.h>
67 #include <sound/core.h>
68 #include <sound/initval.h>
69 #include <sound/pcm.h>
70 #include <sound/ac97_codec.h>
71 #include <sound/info.h>
72 #include <sound/tlv.h>
73 #include <linux/io.h>
74
75 #include "ca0106.h"
76
77 static void ca0106_spdif_enable(struct snd_ca0106 *emu)
78 {
79 unsigned int val;
80
81 if (emu->spdif_enable) {
82 /* Digital */
83 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
84 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
85 val = snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000;
86 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, val);
87 val = inl(emu->port + GPIO) & ~0x101;
88 outl(val, emu->port + GPIO);
89
90 } else {
91 /* Analog */
92 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
93 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
94 val = snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000;
95 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, val);
96 val = inl(emu->port + GPIO) | 0x101;
97 outl(val, emu->port + GPIO);
98 }
99 }
100
101 static void ca0106_set_capture_source(struct snd_ca0106 *emu)
102 {
103 unsigned int val = emu->capture_source;
104 unsigned int source, mask;
105 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
106 mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
107 snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
108 }
109
110 static void ca0106_set_i2c_capture_source(struct snd_ca0106 *emu,
111 unsigned int val, int force)
112 {
113 unsigned int ngain, ogain;
114 u32 source;
115
116 snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
117 ngain = emu->i2c_capture_volume[val][0]; /* Left */
118 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
119 if (force || ngain != ogain)
120 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ngain & 0xff);
121 ngain = emu->i2c_capture_volume[val][1]; /* Right */
122 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Right */
123 if (force || ngain != ogain)
124 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ngain & 0xff);
125 source = 1 << val;
126 snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
127 emu->i2c_capture_source = val;
128 }
129
130 static void ca0106_set_capture_mic_line_in(struct snd_ca0106 *emu)
131 {
132 u32 tmp;
133
134 if (emu->capture_mic_line_in) {
135 /* snd_ca0106_i2c_write(emu, ADC_MUX, 0); */ /* Mute input */
136 tmp = inl(emu->port+GPIO) & ~0x400;
137 tmp = tmp | 0x400;
138 outl(tmp, emu->port+GPIO);
139 /* snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC); */
140 } else {
141 /* snd_ca0106_i2c_write(emu, ADC_MUX, 0); */ /* Mute input */
142 tmp = inl(emu->port+GPIO) & ~0x400;
143 outl(tmp, emu->port+GPIO);
144 /* snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN); */
145 }
146 }
147
148 static void ca0106_set_spdif_bits(struct snd_ca0106 *emu, int idx)
149 {
150 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, emu->spdif_str_bits[idx]);
151 }
152
153 /*
154 */
155 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale1, -5175, 25, 1);
156 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale2, -10350, 50, 1);
157
158 #define snd_ca0106_shared_spdif_info snd_ctl_boolean_mono_info
159
160 static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol,
161 struct snd_ctl_elem_value *ucontrol)
162 {
163 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
164
165 ucontrol->value.integer.value[0] = emu->spdif_enable;
166 return 0;
167 }
168
169 static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol,
170 struct snd_ctl_elem_value *ucontrol)
171 {
172 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
173 unsigned int val;
174 int change = 0;
175
176 val = !!ucontrol->value.integer.value[0];
177 change = (emu->spdif_enable != val);
178 if (change) {
179 emu->spdif_enable = val;
180 ca0106_spdif_enable(emu);
181 }
182 return change;
183 }
184
185 static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol,
186 struct snd_ctl_elem_info *uinfo)
187 {
188 static const char * const texts[6] = {
189 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out"
190 };
191
192 return snd_ctl_enum_info(uinfo, 1, 6, texts);
193 }
194
195 static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol,
196 struct snd_ctl_elem_value *ucontrol)
197 {
198 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
199
200 ucontrol->value.enumerated.item[0] = emu->capture_source;
201 return 0;
202 }
203
204 static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
205 struct snd_ctl_elem_value *ucontrol)
206 {
207 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
208 unsigned int val;
209 int change = 0;
210
211 val = ucontrol->value.enumerated.item[0] ;
212 if (val >= 6)
213 return -EINVAL;
214 change = (emu->capture_source != val);
215 if (change) {
216 emu->capture_source = val;
217 ca0106_set_capture_source(emu);
218 }
219 return change;
220 }
221
222 static int snd_ca0106_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
223 struct snd_ctl_elem_info *uinfo)
224 {
225 static const char * const texts[4] = {
226 "Phone", "Mic", "Line in", "Aux"
227 };
228
229 return snd_ctl_enum_info(uinfo, 1, 4, texts);
230 }
231
232 static int snd_ca0106_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
233 struct snd_ctl_elem_value *ucontrol)
234 {
235 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
236
237 ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
238 return 0;
239 }
240
241 static int snd_ca0106_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
242 struct snd_ctl_elem_value *ucontrol)
243 {
244 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
245 unsigned int source_id;
246 int change = 0;
247 /* If the capture source has changed,
248 * update the capture volume from the cached value
249 * for the particular source.
250 */
251 source_id = ucontrol->value.enumerated.item[0] ;
252 if (source_id >= 4)
253 return -EINVAL;
254 change = (emu->i2c_capture_source != source_id);
255 if (change) {
256 ca0106_set_i2c_capture_source(emu, source_id, 0);
257 }
258 return change;
259 }
260
261 static int snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol *kcontrol,
262 struct snd_ctl_elem_info *uinfo)
263 {
264 static const char * const texts[2] = { "Side out", "Line in" };
265
266 return snd_ctl_enum_info(uinfo, 1, 2, texts);
267 }
268
269 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
270 struct snd_ctl_elem_info *uinfo)
271 {
272 static const char * const texts[2] = { "Line in", "Mic in" };
273
274 return snd_ctl_enum_info(uinfo, 1, 2, texts);
275 }
276
277 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
278 struct snd_ctl_elem_value *ucontrol)
279 {
280 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
281
282 ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
283 return 0;
284 }
285
286 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
287 struct snd_ctl_elem_value *ucontrol)
288 {
289 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
290 unsigned int val;
291 int change = 0;
292
293 val = ucontrol->value.enumerated.item[0] ;
294 if (val > 1)
295 return -EINVAL;
296 change = (emu->capture_mic_line_in != val);
297 if (change) {
298 emu->capture_mic_line_in = val;
299 ca0106_set_capture_mic_line_in(emu);
300 }
301 return change;
302 }
303
304 static const struct snd_kcontrol_new snd_ca0106_capture_mic_line_in =
305 {
306 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
307 .name = "Shared Mic/Line in Capture Switch",
308 .info = snd_ca0106_capture_mic_line_in_info,
309 .get = snd_ca0106_capture_mic_line_in_get,
310 .put = snd_ca0106_capture_mic_line_in_put
311 };
312
313 static const struct snd_kcontrol_new snd_ca0106_capture_line_in_side_out =
314 {
315 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
316 .name = "Shared Line in/Side out Capture Switch",
317 .info = snd_ca0106_capture_line_in_side_out_info,
318 .get = snd_ca0106_capture_mic_line_in_get,
319 .put = snd_ca0106_capture_mic_line_in_put
320 };
321
322
323 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
324 struct snd_ctl_elem_info *uinfo)
325 {
326 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
327 uinfo->count = 1;
328 return 0;
329 }
330
331 static void decode_spdif_bits(unsigned char *status, unsigned int bits)
332 {
333 status[0] = (bits >> 0) & 0xff;
334 status[1] = (bits >> 8) & 0xff;
335 status[2] = (bits >> 16) & 0xff;
336 status[3] = (bits >> 24) & 0xff;
337 }
338
339 static int snd_ca0106_spdif_get_default(struct snd_kcontrol *kcontrol,
340 struct snd_ctl_elem_value *ucontrol)
341 {
342 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
343 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
344
345 decode_spdif_bits(ucontrol->value.iec958.status,
346 emu->spdif_bits[idx]);
347 return 0;
348 }
349
350 static int snd_ca0106_spdif_get_stream(struct snd_kcontrol *kcontrol,
351 struct snd_ctl_elem_value *ucontrol)
352 {
353 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
354 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
355
356 decode_spdif_bits(ucontrol->value.iec958.status,
357 emu->spdif_str_bits[idx]);
358 return 0;
359 }
360
361 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
362 struct snd_ctl_elem_value *ucontrol)
363 {
364 ucontrol->value.iec958.status[0] = 0xff;
365 ucontrol->value.iec958.status[1] = 0xff;
366 ucontrol->value.iec958.status[2] = 0xff;
367 ucontrol->value.iec958.status[3] = 0xff;
368 return 0;
369 }
370
371 static unsigned int encode_spdif_bits(unsigned char *status)
372 {
373 return ((unsigned int)status[0] << 0) |
374 ((unsigned int)status[1] << 8) |
375 ((unsigned int)status[2] << 16) |
376 ((unsigned int)status[3] << 24);
377 }
378
379 static int snd_ca0106_spdif_put_default(struct snd_kcontrol *kcontrol,
380 struct snd_ctl_elem_value *ucontrol)
381 {
382 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
383 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
384 unsigned int val;
385
386 val = encode_spdif_bits(ucontrol->value.iec958.status);
387 if (val != emu->spdif_bits[idx]) {
388 emu->spdif_bits[idx] = val;
389 /* FIXME: this isn't safe, but needed to keep the compatibility
390 * with older alsa-lib config
391 */
392 emu->spdif_str_bits[idx] = val;
393 ca0106_set_spdif_bits(emu, idx);
394 return 1;
395 }
396 return 0;
397 }
398
399 static int snd_ca0106_spdif_put_stream(struct snd_kcontrol *kcontrol,
400 struct snd_ctl_elem_value *ucontrol)
401 {
402 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
403 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
404 unsigned int val;
405
406 val = encode_spdif_bits(ucontrol->value.iec958.status);
407 if (val != emu->spdif_str_bits[idx]) {
408 emu->spdif_str_bits[idx] = val;
409 ca0106_set_spdif_bits(emu, idx);
410 return 1;
411 }
412 return 0;
413 }
414
415 static int snd_ca0106_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_volume_get(struct snd_kcontrol *kcontrol,
426 struct snd_ctl_elem_value *ucontrol)
427 {
428 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
429 unsigned int value;
430 int channel_id, reg;
431
432 channel_id = (kcontrol->private_value >> 8) & 0xff;
433 reg = kcontrol->private_value & 0xff;
434
435 value = snd_ca0106_ptr_read(emu, reg, channel_id);
436 ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
437 ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
438 return 0;
439 }
440
441 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
442 struct snd_ctl_elem_value *ucontrol)
443 {
444 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
445 unsigned int oval, nval;
446 int channel_id, reg;
447
448 channel_id = (kcontrol->private_value >> 8) & 0xff;
449 reg = kcontrol->private_value & 0xff;
450
451 oval = snd_ca0106_ptr_read(emu, reg, channel_id);
452 nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
453 ((0xff - ucontrol->value.integer.value[1]) << 16);
454 nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
455 ((0xff - ucontrol->value.integer.value[1]) );
456 if (oval == nval)
457 return 0;
458 snd_ca0106_ptr_write(emu, reg, channel_id, nval);
459 return 1;
460 }
461
462 static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
463 struct snd_ctl_elem_info *uinfo)
464 {
465 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
466 uinfo->count = 2;
467 uinfo->value.integer.min = 0;
468 uinfo->value.integer.max = 255;
469 return 0;
470 }
471
472 static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
473 struct snd_ctl_elem_value *ucontrol)
474 {
475 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
476 int source_id;
477
478 source_id = kcontrol->private_value;
479
480 ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
481 ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
482 return 0;
483 }
484
485 static int snd_ca0106_i2c_volume_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 ogain;
490 unsigned int ngain;
491 int source_id;
492 int change = 0;
493
494 source_id = kcontrol->private_value;
495 ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
496 ngain = ucontrol->value.integer.value[0];
497 if (ngain > 0xff)
498 return -EINVAL;
499 if (ogain != ngain) {
500 if (emu->i2c_capture_source == source_id)
501 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
502 emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
503 change = 1;
504 }
505 ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
506 ngain = ucontrol->value.integer.value[1];
507 if (ngain > 0xff)
508 return -EINVAL;
509 if (ogain != ngain) {
510 if (emu->i2c_capture_source == source_id)
511 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
512 emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
513 change = 1;
514 }
515
516 return change;
517 }
518
519 #define spi_mute_info snd_ctl_boolean_mono_info
520
521 static int spi_mute_get(struct snd_kcontrol *kcontrol,
522 struct snd_ctl_elem_value *ucontrol)
523 {
524 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
525 unsigned int reg = kcontrol->private_value >> SPI_REG_SHIFT;
526 unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
527
528 ucontrol->value.integer.value[0] = !(emu->spi_dac_reg[reg] & bit);
529 return 0;
530 }
531
532 static int spi_mute_put(struct snd_kcontrol *kcontrol,
533 struct snd_ctl_elem_value *ucontrol)
534 {
535 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
536 unsigned int reg = kcontrol->private_value >> SPI_REG_SHIFT;
537 unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
538 int ret;
539
540 ret = emu->spi_dac_reg[reg] & bit;
541 if (ucontrol->value.integer.value[0]) {
542 if (!ret) /* bit already cleared, do nothing */
543 return 0;
544 emu->spi_dac_reg[reg] &= ~bit;
545 } else {
546 if (ret) /* bit already set, do nothing */
547 return 0;
548 emu->spi_dac_reg[reg] |= bit;
549 }
550
551 ret = snd_ca0106_spi_write(emu, emu->spi_dac_reg[reg]);
552 return ret ? -EINVAL : 1;
553 }
554
555 #define CA_VOLUME(xname,chid,reg) \
556 { \
557 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
558 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
559 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
560 .info = snd_ca0106_volume_info, \
561 .get = snd_ca0106_volume_get, \
562 .put = snd_ca0106_volume_put, \
563 .tlv = { .p = snd_ca0106_db_scale1 }, \
564 .private_value = ((chid) << 8) | (reg) \
565 }
566
567 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] = {
568 CA_VOLUME("Analog Front Playback Volume",
569 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
570 CA_VOLUME("Analog Rear Playback Volume",
571 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
572 CA_VOLUME("Analog Center/LFE Playback Volume",
573 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
574 CA_VOLUME("Analog Side Playback Volume",
575 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
576
577 CA_VOLUME("IEC958 Front Playback Volume",
578 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
579 CA_VOLUME("IEC958 Rear Playback Volume",
580 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
581 CA_VOLUME("IEC958 Center/LFE Playback Volume",
582 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
583 CA_VOLUME("IEC958 Unknown Playback Volume",
584 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
585
586 CA_VOLUME("CAPTURE feedback Playback Volume",
587 1, CAPTURE_CONTROL),
588
589 {
590 .access = SNDRV_CTL_ELEM_ACCESS_READ,
591 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
592 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
593 .count = 4,
594 .info = snd_ca0106_spdif_info,
595 .get = snd_ca0106_spdif_get_mask
596 },
597 {
598 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
599 .name = "IEC958 Playback Switch",
600 .info = snd_ca0106_shared_spdif_info,
601 .get = snd_ca0106_shared_spdif_get,
602 .put = snd_ca0106_shared_spdif_put
603 },
604 {
605 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
606 .name = "Digital Source Capture Enum",
607 .info = snd_ca0106_capture_source_info,
608 .get = snd_ca0106_capture_source_get,
609 .put = snd_ca0106_capture_source_put
610 },
611 {
612 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
613 .name = "Analog Source Capture Enum",
614 .info = snd_ca0106_i2c_capture_source_info,
615 .get = snd_ca0106_i2c_capture_source_get,
616 .put = snd_ca0106_i2c_capture_source_put
617 },
618 {
619 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
620 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
621 .count = 4,
622 .info = snd_ca0106_spdif_info,
623 .get = snd_ca0106_spdif_get_default,
624 .put = snd_ca0106_spdif_put_default
625 },
626 {
627 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
628 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
629 .count = 4,
630 .info = snd_ca0106_spdif_info,
631 .get = snd_ca0106_spdif_get_stream,
632 .put = snd_ca0106_spdif_put_stream
633 },
634 };
635
636 #define I2C_VOLUME(xname,chid) \
637 { \
638 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
639 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
640 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
641 .info = snd_ca0106_i2c_volume_info, \
642 .get = snd_ca0106_i2c_volume_get, \
643 .put = snd_ca0106_i2c_volume_put, \
644 .tlv = { .p = snd_ca0106_db_scale2 }, \
645 .private_value = chid \
646 }
647
648 static struct snd_kcontrol_new snd_ca0106_volume_i2c_adc_ctls[] = {
649 I2C_VOLUME("Phone Capture Volume", 0),
650 I2C_VOLUME("Mic Capture Volume", 1),
651 I2C_VOLUME("Line in Capture Volume", 2),
652 I2C_VOLUME("Aux Capture Volume", 3),
653 };
654
655 static const int spi_dmute_reg[] = {
656 SPI_DMUTE0_REG,
657 SPI_DMUTE1_REG,
658 SPI_DMUTE2_REG,
659 0,
660 SPI_DMUTE4_REG,
661 };
662 static const int spi_dmute_bit[] = {
663 SPI_DMUTE0_BIT,
664 SPI_DMUTE1_BIT,
665 SPI_DMUTE2_BIT,
666 0,
667 SPI_DMUTE4_BIT,
668 };
669
670 static struct snd_kcontrol_new
671 snd_ca0106_volume_spi_dac_ctl(struct snd_ca0106_details *details,
672 int channel_id)
673 {
674 struct snd_kcontrol_new spi_switch = {0};
675 int reg, bit;
676 int dac_id;
677
678 spi_switch.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
679 spi_switch.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
680 spi_switch.info = spi_mute_info;
681 spi_switch.get = spi_mute_get;
682 spi_switch.put = spi_mute_put;
683
684 switch (channel_id) {
685 case PCM_FRONT_CHANNEL:
686 spi_switch.name = "Analog Front Playback Switch";
687 dac_id = (details->spi_dac & 0xf000) >> (4 * 3);
688 break;
689 case PCM_REAR_CHANNEL:
690 spi_switch.name = "Analog Rear Playback Switch";
691 dac_id = (details->spi_dac & 0x0f00) >> (4 * 2);
692 break;
693 case PCM_CENTER_LFE_CHANNEL:
694 spi_switch.name = "Analog Center/LFE Playback Switch";
695 dac_id = (details->spi_dac & 0x00f0) >> (4 * 1);
696 break;
697 case PCM_UNKNOWN_CHANNEL:
698 spi_switch.name = "Analog Side Playback Switch";
699 dac_id = (details->spi_dac & 0x000f) >> (4 * 0);
700 break;
701 default:
702 /* Unused channel */
703 spi_switch.name = NULL;
704 dac_id = 0;
705 }
706 reg = spi_dmute_reg[dac_id];
707 bit = spi_dmute_bit[dac_id];
708
709 spi_switch.private_value = (reg << SPI_REG_SHIFT) | bit;
710
711 return spi_switch;
712 }
713
714 static int remove_ctl(struct snd_card *card, const char *name)
715 {
716 struct snd_ctl_elem_id id;
717 memset(&id, 0, sizeof(id));
718 strcpy(id.name, name);
719 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
720 return snd_ctl_remove_id(card, &id);
721 }
722
723 static struct snd_kcontrol *ctl_find(struct snd_card *card, const char *name)
724 {
725 struct snd_ctl_elem_id sid;
726 memset(&sid, 0, sizeof(sid));
727 /* FIXME: strcpy is bad. */
728 strcpy(sid.name, name);
729 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
730 return snd_ctl_find_id(card, &sid);
731 }
732
733 static int rename_ctl(struct snd_card *card, const char *src, const char *dst)
734 {
735 struct snd_kcontrol *kctl = ctl_find(card, src);
736 if (kctl) {
737 strcpy(kctl->id.name, dst);
738 return 0;
739 }
740 return -ENOENT;
741 }
742
743 #define ADD_CTLS(emu, ctls) \
744 do { \
745 int i, _err; \
746 for (i = 0; i < ARRAY_SIZE(ctls); i++) { \
747 _err = snd_ctl_add(card, snd_ctl_new1(&ctls[i], emu)); \
748 if (_err < 0) \
749 return _err; \
750 } \
751 } while (0)
752
753 static
754 DECLARE_TLV_DB_SCALE(snd_ca0106_master_db_scale, -6375, 25, 1);
755
756 static char *slave_vols[] = {
757 "Analog Front Playback Volume",
758 "Analog Rear Playback Volume",
759 "Analog Center/LFE Playback Volume",
760 "Analog Side Playback Volume",
761 "IEC958 Front Playback Volume",
762 "IEC958 Rear Playback Volume",
763 "IEC958 Center/LFE Playback Volume",
764 "IEC958 Unknown Playback Volume",
765 "CAPTURE feedback Playback Volume",
766 NULL
767 };
768
769 static char *slave_sws[] = {
770 "Analog Front Playback Switch",
771 "Analog Rear Playback Switch",
772 "Analog Center/LFE Playback Switch",
773 "Analog Side Playback Switch",
774 "IEC958 Playback Switch",
775 NULL
776 };
777
778 static void add_slaves(struct snd_card *card,
779 struct snd_kcontrol *master, char **list)
780 {
781 for (; *list; list++) {
782 struct snd_kcontrol *slave = ctl_find(card, *list);
783 if (slave)
784 snd_ctl_add_slave(master, slave);
785 }
786 }
787
788 int snd_ca0106_mixer(struct snd_ca0106 *emu)
789 {
790 int err;
791 struct snd_card *card = emu->card;
792 char **c;
793 struct snd_kcontrol *vmaster;
794 static char *ca0106_remove_ctls[] = {
795 "Master Mono Playback Switch",
796 "Master Mono Playback Volume",
797 "3D Control - Switch",
798 "3D Control Sigmatel - Depth",
799 "PCM Playback Switch",
800 "PCM Playback Volume",
801 "CD Playback Switch",
802 "CD Playback Volume",
803 "Phone Playback Switch",
804 "Phone Playback Volume",
805 "Video Playback Switch",
806 "Video Playback Volume",
807 "Beep Playback Switch",
808 "Beep Playback Volume",
809 "Mono Output Select",
810 "Capture Source",
811 "Capture Switch",
812 "Capture Volume",
813 "External Amplifier",
814 "Sigmatel 4-Speaker Stereo Playback Switch",
815 "Surround Phase Inversion Playback Switch",
816 NULL
817 };
818 static char *ca0106_rename_ctls[] = {
819 "Master Playback Switch", "Capture Switch",
820 "Master Playback Volume", "Capture Volume",
821 "Line Playback Switch", "AC97 Line Capture Switch",
822 "Line Playback Volume", "AC97 Line Capture Volume",
823 "Aux Playback Switch", "AC97 Aux Capture Switch",
824 "Aux Playback Volume", "AC97 Aux Capture Volume",
825 "Mic Playback Switch", "AC97 Mic Capture Switch",
826 "Mic Playback Volume", "AC97 Mic Capture Volume",
827 "Mic Select", "AC97 Mic Select",
828 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
829 NULL
830 };
831 #if 1
832 for (c = ca0106_remove_ctls; *c; c++)
833 remove_ctl(card, *c);
834 for (c = ca0106_rename_ctls; *c; c += 2)
835 rename_ctl(card, c[0], c[1]);
836 #endif
837
838 ADD_CTLS(emu, snd_ca0106_volume_ctls);
839 if (emu->details->i2c_adc == 1) {
840 ADD_CTLS(emu, snd_ca0106_volume_i2c_adc_ctls);
841 if (emu->details->gpio_type == 1)
842 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
843 else /* gpio_type == 2 */
844 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_line_in_side_out, emu));
845 if (err < 0)
846 return err;
847 }
848 if (emu->details->spi_dac) {
849 int i;
850 for (i = 0;; i++) {
851 struct snd_kcontrol_new ctl;
852 ctl = snd_ca0106_volume_spi_dac_ctl(emu->details, i);
853 if (!ctl.name)
854 break;
855 err = snd_ctl_add(card, snd_ctl_new1(&ctl, emu));
856 if (err < 0)
857 return err;
858 }
859 }
860
861 /* Create virtual master controls */
862 vmaster = snd_ctl_make_virtual_master("Master Playback Volume",
863 snd_ca0106_master_db_scale);
864 if (!vmaster)
865 return -ENOMEM;
866 err = snd_ctl_add(card, vmaster);
867 if (err < 0)
868 return err;
869 add_slaves(card, vmaster, slave_vols);
870
871 if (emu->details->spi_dac) {
872 vmaster = snd_ctl_make_virtual_master("Master Playback Switch",
873 NULL);
874 if (!vmaster)
875 return -ENOMEM;
876 err = snd_ctl_add(card, vmaster);
877 if (err < 0)
878 return err;
879 add_slaves(card, vmaster, slave_sws);
880 }
881
882 strcpy(card->mixername, "CA0106");
883 return 0;
884 }
885
886 #ifdef CONFIG_PM_SLEEP
887 struct ca0106_vol_tbl {
888 unsigned int channel_id;
889 unsigned int reg;
890 };
891
892 static struct ca0106_vol_tbl saved_volumes[NUM_SAVED_VOLUMES] = {
893 { CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2 },
894 { CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2 },
895 { CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2 },
896 { CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2 },
897 { CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1 },
898 { CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1 },
899 { CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1 },
900 { CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1 },
901 { 1, CAPTURE_CONTROL },
902 };
903
904 void snd_ca0106_mixer_suspend(struct snd_ca0106 *chip)
905 {
906 int i;
907
908 /* save volumes */
909 for (i = 0; i < NUM_SAVED_VOLUMES; i++)
910 chip->saved_vol[i] =
911 snd_ca0106_ptr_read(chip, saved_volumes[i].reg,
912 saved_volumes[i].channel_id);
913 }
914
915 void snd_ca0106_mixer_resume(struct snd_ca0106 *chip)
916 {
917 int i;
918
919 for (i = 0; i < NUM_SAVED_VOLUMES; i++)
920 snd_ca0106_ptr_write(chip, saved_volumes[i].reg,
921 saved_volumes[i].channel_id,
922 chip->saved_vol[i]);
923
924 ca0106_spdif_enable(chip);
925 ca0106_set_capture_source(chip);
926 ca0106_set_i2c_capture_source(chip, chip->i2c_capture_source, 1);
927 for (i = 0; i < 4; i++)
928 ca0106_set_spdif_bits(chip, i);
929 if (chip->details->i2c_adc)
930 ca0106_set_capture_mic_line_in(chip);
931 }
932 #endif /* CONFIG_PM_SLEEP */
Linux with added FPC-III support