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