1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (c) 2004 James Courtier-Dutton <James@superbug.demon.co.uk>
4 * Driver CA0106 chips. e.g. Sound Blaster Audigy LS and Live 24bit
5 * Version: 0.0.18
6 *
7 * FEATURES currently supported:
8 * See ca0106_main.c for features.
9 *
10 * Changelog:
11 * Support interrupts per period.
12 * Removed noise from Center/LFE channel when in Analog mode.
13 * Rename and remove mixer controls.
14 * 0.0.6
15 * Use separate card based DMA buffer for periods table list.
16 * 0.0.7
17 * Change remove and rename ctrls into lists.
18 * 0.0.8
19 * Try to fix capture sources.
20 * 0.0.9
21 * Fix AC3 output.
22 * Enable S32_LE format support.
23 * 0.0.10
24 * Enable playback 48000 and 96000 rates. (Rates other that these do not work, even with "plug:front".)
25 * 0.0.11
26 * Add Model name recognition.
27 * 0.0.12
28 * Correct interrupt timing. interrupt at end of period, instead of in the middle of a playback period.
29 * Remove redundent "voice" handling.
30 * 0.0.13
31 * Single trigger call for multi channels.
32 * 0.0.14
33 * Set limits based on what the sound card hardware can do.
34 * playback periods_min=2, periods_max=8
35 * capture hw constraints require period_size = n * 64 bytes.
36 * playback hw constraints require period_size = n * 64 bytes.
37 * 0.0.15
38 * Separated ca0106.c into separate functional .c files.
39 * 0.0.16
40 * Modified Copyright message.
41 * 0.0.17
42 * Implement Mic and Line in Capture.
43 * 0.0.18
44 * Add support for mute control on SB Live 24bit (cards w/ SPI DAC)
45 *
46 * This code was initially based on code from ALSA's emu10k1x.c which is:
47 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
48 */
49 #include <linux/delay.h>
50 #include <linux/init.h>
51 #include <linux/interrupt.h>
52 #include <linux/moduleparam.h>
53 #include <sound/core.h>
54 #include <sound/initval.h>
55 #include <sound/pcm.h>
56 #include <sound/ac97_codec.h>
57 #include <sound/info.h>
58 #include <sound/tlv.h>
59 #include <linux/io.h>
60
61 #include "ca0106.h"
62
ca0106_spdif_enable(struct snd_ca0106 * emu)63 static void ca0106_spdif_enable(struct snd_ca0106 *emu)
64 {
65 unsigned int val;
66
67 if (emu->spdif_enable) {
68 /* Digital */
69 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
70 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
71 val = snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000;
72 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, val);
73 val = inl(emu->port + CA0106_GPIO) & ~0x101;
74 outl(val, emu->port + CA0106_GPIO);
75
76 } else {
77 /* Analog */
78 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
79 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
80 val = snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000;
81 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, val);
82 val = inl(emu->port + CA0106_GPIO) | 0x101;
83 outl(val, emu->port + CA0106_GPIO);
84 }
85 }
86
ca0106_set_capture_source(struct snd_ca0106 * emu)87 static void ca0106_set_capture_source(struct snd_ca0106 *emu)
88 {
89 unsigned int val = emu->capture_source;
90 unsigned int source, mask;
91 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
92 mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
93 snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
94 }
95
ca0106_set_i2c_capture_source(struct snd_ca0106 * emu,unsigned int val,int force)96 static void ca0106_set_i2c_capture_source(struct snd_ca0106 *emu,
97 unsigned int val, int force)
98 {
99 unsigned int ngain, ogain;
100 u32 source;
101
102 snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
103 ngain = emu->i2c_capture_volume[val][0]; /* Left */
104 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
105 if (force || ngain != ogain)
106 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ngain & 0xff);
107 ngain = emu->i2c_capture_volume[val][1]; /* Right */
108 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Right */
109 if (force || ngain != ogain)
110 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ngain & 0xff);
111 source = 1 << val;
112 snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
113 emu->i2c_capture_source = val;
114 }
115
ca0106_set_capture_mic_line_in(struct snd_ca0106 * emu)116 static void ca0106_set_capture_mic_line_in(struct snd_ca0106 *emu)
117 {
118 u32 tmp;
119
120 if (emu->capture_mic_line_in) {
121 /* snd_ca0106_i2c_write(emu, ADC_MUX, 0); */ /* Mute input */
122 tmp = inl(emu->port + CA0106_GPIO) & ~0x400;
123 tmp = tmp | 0x400;
124 outl(tmp, emu->port + CA0106_GPIO);
125 /* snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC); */
126 } else {
127 /* snd_ca0106_i2c_write(emu, ADC_MUX, 0); */ /* Mute input */
128 tmp = inl(emu->port + CA0106_GPIO) & ~0x400;
129 outl(tmp, emu->port + CA0106_GPIO);
130 /* snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN); */
131 }
132 }
133
ca0106_set_spdif_bits(struct snd_ca0106 * emu,int idx)134 static void ca0106_set_spdif_bits(struct snd_ca0106 *emu, int idx)
135 {
136 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, emu->spdif_str_bits[idx]);
137 }
138
139 /*
140 */
141 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale1, -5175, 25, 1);
142 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale2, -10350, 50, 1);
143
144 #define snd_ca0106_shared_spdif_info snd_ctl_boolean_mono_info
145
snd_ca0106_shared_spdif_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)146 static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol,
147 struct snd_ctl_elem_value *ucontrol)
148 {
149 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
150
151 ucontrol->value.integer.value[0] = emu->spdif_enable;
152 return 0;
153 }
154
snd_ca0106_shared_spdif_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)155 static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol,
156 struct snd_ctl_elem_value *ucontrol)
157 {
158 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
159 unsigned int val;
160 int change = 0;
161
162 val = !!ucontrol->value.integer.value[0];
163 change = (emu->spdif_enable != val);
164 if (change) {
165 emu->spdif_enable = val;
166 ca0106_spdif_enable(emu);
167 }
168 return change;
169 }
170
snd_ca0106_capture_source_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)171 static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol,
172 struct snd_ctl_elem_info *uinfo)
173 {
174 static const char * const texts[6] = {
175 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out"
176 };
177
178 return snd_ctl_enum_info(uinfo, 1, 6, texts);
179 }
180
snd_ca0106_capture_source_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)181 static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol,
182 struct snd_ctl_elem_value *ucontrol)
183 {
184 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
185
186 ucontrol->value.enumerated.item[0] = emu->capture_source;
187 return 0;
188 }
189
snd_ca0106_capture_source_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)190 static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
191 struct snd_ctl_elem_value *ucontrol)
192 {
193 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
194 unsigned int val;
195 int change = 0;
196
197 val = ucontrol->value.enumerated.item[0] ;
198 if (val >= 6)
199 return -EINVAL;
200 change = (emu->capture_source != val);
201 if (change) {
202 emu->capture_source = val;
203 ca0106_set_capture_source(emu);
204 }
205 return change;
206 }
207
snd_ca0106_i2c_capture_source_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)208 static int snd_ca0106_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
209 struct snd_ctl_elem_info *uinfo)
210 {
211 static const char * const texts[4] = {
212 "Phone", "Mic", "Line in", "Aux"
213 };
214
215 return snd_ctl_enum_info(uinfo, 1, 4, texts);
216 }
217
snd_ca0106_i2c_capture_source_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)218 static int snd_ca0106_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
219 struct snd_ctl_elem_value *ucontrol)
220 {
221 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
222
223 ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
224 return 0;
225 }
226
snd_ca0106_i2c_capture_source_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)227 static int snd_ca0106_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
228 struct snd_ctl_elem_value *ucontrol)
229 {
230 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
231 unsigned int source_id;
232 int change = 0;
233 /* If the capture source has changed,
234 * update the capture volume from the cached value
235 * for the particular source.
236 */
237 source_id = ucontrol->value.enumerated.item[0] ;
238 if (source_id >= 4)
239 return -EINVAL;
240 change = (emu->i2c_capture_source != source_id);
241 if (change) {
242 ca0106_set_i2c_capture_source(emu, source_id, 0);
243 }
244 return change;
245 }
246
snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)247 static int snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol *kcontrol,
248 struct snd_ctl_elem_info *uinfo)
249 {
250 static const char * const texts[2] = { "Side out", "Line in" };
251
252 return snd_ctl_enum_info(uinfo, 1, 2, texts);
253 }
254
snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)255 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
256 struct snd_ctl_elem_info *uinfo)
257 {
258 static const char * const texts[2] = { "Line in", "Mic in" };
259
260 return snd_ctl_enum_info(uinfo, 1, 2, texts);
261 }
262
snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)263 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
264 struct snd_ctl_elem_value *ucontrol)
265 {
266 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
267
268 ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
269 return 0;
270 }
271
snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)272 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
273 struct snd_ctl_elem_value *ucontrol)
274 {
275 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
276 unsigned int val;
277 int change = 0;
278
279 val = ucontrol->value.enumerated.item[0] ;
280 if (val > 1)
281 return -EINVAL;
282 change = (emu->capture_mic_line_in != val);
283 if (change) {
284 emu->capture_mic_line_in = val;
285 ca0106_set_capture_mic_line_in(emu);
286 }
287 return change;
288 }
289
290 static const struct snd_kcontrol_new snd_ca0106_capture_mic_line_in =
291 {
292 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
293 .name = "Shared Mic/Line in Capture Switch",
294 .info = snd_ca0106_capture_mic_line_in_info,
295 .get = snd_ca0106_capture_mic_line_in_get,
296 .put = snd_ca0106_capture_mic_line_in_put
297 };
298
299 static const struct snd_kcontrol_new snd_ca0106_capture_line_in_side_out =
300 {
301 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
302 .name = "Shared Line in/Side out Capture Switch",
303 .info = snd_ca0106_capture_line_in_side_out_info,
304 .get = snd_ca0106_capture_mic_line_in_get,
305 .put = snd_ca0106_capture_mic_line_in_put
306 };
307
308
snd_ca0106_spdif_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)309 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
310 struct snd_ctl_elem_info *uinfo)
311 {
312 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
313 uinfo->count = 1;
314 return 0;
315 }
316
decode_spdif_bits(unsigned char * status,unsigned int bits)317 static void decode_spdif_bits(unsigned char *status, unsigned int bits)
318 {
319 status[0] = (bits >> 0) & 0xff;
320 status[1] = (bits >> 8) & 0xff;
321 status[2] = (bits >> 16) & 0xff;
322 status[3] = (bits >> 24) & 0xff;
323 }
324
snd_ca0106_spdif_get_default(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)325 static int snd_ca0106_spdif_get_default(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 decode_spdif_bits(ucontrol->value.iec958.status,
332 emu->spdif_bits[idx]);
333 return 0;
334 }
335
snd_ca0106_spdif_get_stream(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)336 static int snd_ca0106_spdif_get_stream(struct snd_kcontrol *kcontrol,
337 struct snd_ctl_elem_value *ucontrol)
338 {
339 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
340 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
341
342 decode_spdif_bits(ucontrol->value.iec958.status,
343 emu->spdif_str_bits[idx]);
344 return 0;
345 }
346
snd_ca0106_spdif_get_mask(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)347 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
348 struct snd_ctl_elem_value *ucontrol)
349 {
350 ucontrol->value.iec958.status[0] = 0xff;
351 ucontrol->value.iec958.status[1] = 0xff;
352 ucontrol->value.iec958.status[2] = 0xff;
353 ucontrol->value.iec958.status[3] = 0xff;
354 return 0;
355 }
356
encode_spdif_bits(unsigned char * status)357 static unsigned int encode_spdif_bits(unsigned char *status)
358 {
359 return ((unsigned int)status[0] << 0) |
360 ((unsigned int)status[1] << 8) |
361 ((unsigned int)status[2] << 16) |
362 ((unsigned int)status[3] << 24);
363 }
364
snd_ca0106_spdif_put_default(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)365 static int snd_ca0106_spdif_put_default(struct snd_kcontrol *kcontrol,
366 struct snd_ctl_elem_value *ucontrol)
367 {
368 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
369 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
370 unsigned int val;
371
372 val = encode_spdif_bits(ucontrol->value.iec958.status);
373 if (val != emu->spdif_bits[idx]) {
374 emu->spdif_bits[idx] = val;
375 /* FIXME: this isn't safe, but needed to keep the compatibility
376 * with older alsa-lib config
377 */
378 emu->spdif_str_bits[idx] = val;
379 ca0106_set_spdif_bits(emu, idx);
380 return 1;
381 }
382 return 0;
383 }
384
snd_ca0106_spdif_put_stream(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)385 static int snd_ca0106_spdif_put_stream(struct snd_kcontrol *kcontrol,
386 struct snd_ctl_elem_value *ucontrol)
387 {
388 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
389 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
390 unsigned int val;
391
392 val = encode_spdif_bits(ucontrol->value.iec958.status);
393 if (val != emu->spdif_str_bits[idx]) {
394 emu->spdif_str_bits[idx] = val;
395 ca0106_set_spdif_bits(emu, idx);
396 return 1;
397 }
398 return 0;
399 }
400
snd_ca0106_volume_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)401 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
402 struct snd_ctl_elem_info *uinfo)
403 {
404 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
405 uinfo->count = 2;
406 uinfo->value.integer.min = 0;
407 uinfo->value.integer.max = 255;
408 return 0;
409 }
410
snd_ca0106_volume_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)411 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
412 struct snd_ctl_elem_value *ucontrol)
413 {
414 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
415 unsigned int value;
416 int channel_id, reg;
417
418 channel_id = (kcontrol->private_value >> 8) & 0xff;
419 reg = kcontrol->private_value & 0xff;
420
421 value = snd_ca0106_ptr_read(emu, reg, channel_id);
422 ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
423 ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
424 return 0;
425 }
426
snd_ca0106_volume_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)427 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
428 struct snd_ctl_elem_value *ucontrol)
429 {
430 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
431 unsigned int oval, nval;
432 int channel_id, reg;
433
434 channel_id = (kcontrol->private_value >> 8) & 0xff;
435 reg = kcontrol->private_value & 0xff;
436
437 oval = snd_ca0106_ptr_read(emu, reg, channel_id);
438 nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
439 ((0xff - ucontrol->value.integer.value[1]) << 16);
440 nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
441 ((0xff - ucontrol->value.integer.value[1]) );
442 if (oval == nval)
443 return 0;
444 snd_ca0106_ptr_write(emu, reg, channel_id, nval);
445 return 1;
446 }
447
snd_ca0106_i2c_volume_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)448 static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
449 struct snd_ctl_elem_info *uinfo)
450 {
451 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
452 uinfo->count = 2;
453 uinfo->value.integer.min = 0;
454 uinfo->value.integer.max = 255;
455 return 0;
456 }
457
snd_ca0106_i2c_volume_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)458 static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
459 struct snd_ctl_elem_value *ucontrol)
460 {
461 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
462 int source_id;
463
464 source_id = kcontrol->private_value;
465
466 ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
467 ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
468 return 0;
469 }
470
snd_ca0106_i2c_volume_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)471 static int snd_ca0106_i2c_volume_put(struct snd_kcontrol *kcontrol,
472 struct snd_ctl_elem_value *ucontrol)
473 {
474 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
475 unsigned int ogain;
476 unsigned int ngain;
477 int source_id;
478 int change = 0;
479
480 source_id = kcontrol->private_value;
481 ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
482 ngain = ucontrol->value.integer.value[0];
483 if (ngain > 0xff)
484 return -EINVAL;
485 if (ogain != ngain) {
486 if (emu->i2c_capture_source == source_id)
487 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
488 emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
489 change = 1;
490 }
491 ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
492 ngain = ucontrol->value.integer.value[1];
493 if (ngain > 0xff)
494 return -EINVAL;
495 if (ogain != ngain) {
496 if (emu->i2c_capture_source == source_id)
497 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
498 emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
499 change = 1;
500 }
501
502 return change;
503 }
504
505 #define spi_mute_info snd_ctl_boolean_mono_info
506
spi_mute_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)507 static int spi_mute_get(struct snd_kcontrol *kcontrol,
508 struct snd_ctl_elem_value *ucontrol)
509 {
510 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
511 unsigned int reg = kcontrol->private_value >> SPI_REG_SHIFT;
512 unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
513
514 ucontrol->value.integer.value[0] = !(emu->spi_dac_reg[reg] & bit);
515 return 0;
516 }
517
spi_mute_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)518 static int spi_mute_put(struct snd_kcontrol *kcontrol,
519 struct snd_ctl_elem_value *ucontrol)
520 {
521 struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
522 unsigned int reg = kcontrol->private_value >> SPI_REG_SHIFT;
523 unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
524 int ret;
525
526 ret = emu->spi_dac_reg[reg] & bit;
527 if (ucontrol->value.integer.value[0]) {
528 if (!ret) /* bit already cleared, do nothing */
529 return 0;
530 emu->spi_dac_reg[reg] &= ~bit;
531 } else {
532 if (ret) /* bit already set, do nothing */
533 return 0;
534 emu->spi_dac_reg[reg] |= bit;
535 }
536
537 ret = snd_ca0106_spi_write(emu, emu->spi_dac_reg[reg]);
538 return ret ? -EINVAL : 1;
539 }
540
541 #define CA_VOLUME(xname,chid,reg) \
542 { \
543 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
544 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
545 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
546 .info = snd_ca0106_volume_info, \
547 .get = snd_ca0106_volume_get, \
548 .put = snd_ca0106_volume_put, \
549 .tlv = { .p = snd_ca0106_db_scale1 }, \
550 .private_value = ((chid) << 8) | (reg) \
551 }
552
553 static const struct snd_kcontrol_new snd_ca0106_volume_ctls[] = {
554 CA_VOLUME("Analog Front Playback Volume",
555 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
556 CA_VOLUME("Analog Rear Playback Volume",
557 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
558 CA_VOLUME("Analog Center/LFE Playback Volume",
559 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
560 CA_VOLUME("Analog Side Playback Volume",
561 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
562
563 CA_VOLUME("IEC958 Front Playback Volume",
564 CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
565 CA_VOLUME("IEC958 Rear Playback Volume",
566 CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
567 CA_VOLUME("IEC958 Center/LFE Playback Volume",
568 CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
569 CA_VOLUME("IEC958 Unknown Playback Volume",
570 CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
571
572 CA_VOLUME("CAPTURE feedback Playback Volume",
573 1, CAPTURE_CONTROL),
574
575 {
576 .access = SNDRV_CTL_ELEM_ACCESS_READ,
577 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
578 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
579 .count = 4,
580 .info = snd_ca0106_spdif_info,
581 .get = snd_ca0106_spdif_get_mask
582 },
583 {
584 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
585 .name = "IEC958 Playback Switch",
586 .info = snd_ca0106_shared_spdif_info,
587 .get = snd_ca0106_shared_spdif_get,
588 .put = snd_ca0106_shared_spdif_put
589 },
590 {
591 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
592 .name = "Digital Source Capture Enum",
593 .info = snd_ca0106_capture_source_info,
594 .get = snd_ca0106_capture_source_get,
595 .put = snd_ca0106_capture_source_put
596 },
597 {
598 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
599 .name = "Analog Source Capture Enum",
600 .info = snd_ca0106_i2c_capture_source_info,
601 .get = snd_ca0106_i2c_capture_source_get,
602 .put = snd_ca0106_i2c_capture_source_put
603 },
604 {
605 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
606 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
607 .count = 4,
608 .info = snd_ca0106_spdif_info,
609 .get = snd_ca0106_spdif_get_default,
610 .put = snd_ca0106_spdif_put_default
611 },
612 {
613 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
614 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
615 .count = 4,
616 .info = snd_ca0106_spdif_info,
617 .get = snd_ca0106_spdif_get_stream,
618 .put = snd_ca0106_spdif_put_stream
619 },
620 };
621
622 #define I2C_VOLUME(xname,chid) \
623 { \
624 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
625 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
626 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
627 .info = snd_ca0106_i2c_volume_info, \
628 .get = snd_ca0106_i2c_volume_get, \
629 .put = snd_ca0106_i2c_volume_put, \
630 .tlv = { .p = snd_ca0106_db_scale2 }, \
631 .private_value = chid \
632 }
633
634 static const struct snd_kcontrol_new snd_ca0106_volume_i2c_adc_ctls[] = {
635 I2C_VOLUME("Phone Capture Volume", 0),
636 I2C_VOLUME("Mic Capture Volume", 1),
637 I2C_VOLUME("Line in Capture Volume", 2),
638 I2C_VOLUME("Aux Capture Volume", 3),
639 };
640
641 static const int spi_dmute_reg[] = {
642 SPI_DMUTE0_REG,
643 SPI_DMUTE1_REG,
644 SPI_DMUTE2_REG,
645 0,
646 SPI_DMUTE4_REG,
647 };
648 static const int spi_dmute_bit[] = {
649 SPI_DMUTE0_BIT,
650 SPI_DMUTE1_BIT,
651 SPI_DMUTE2_BIT,
652 0,
653 SPI_DMUTE4_BIT,
654 };
655
656 static struct snd_kcontrol_new
snd_ca0106_volume_spi_dac_ctl(const struct snd_ca0106_details * details,int channel_id)657 snd_ca0106_volume_spi_dac_ctl(const struct snd_ca0106_details *details,
658 int channel_id)
659 {
660 struct snd_kcontrol_new spi_switch = {0};
661 int reg, bit;
662 int dac_id;
663
664 spi_switch.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
665 spi_switch.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
666 spi_switch.info = spi_mute_info;
667 spi_switch.get = spi_mute_get;
668 spi_switch.put = spi_mute_put;
669
670 switch (channel_id) {
671 case PCM_FRONT_CHANNEL:
672 spi_switch.name = "Analog Front Playback Switch";
673 dac_id = (details->spi_dac & 0xf000) >> (4 * 3);
674 break;
675 case PCM_REAR_CHANNEL:
676 spi_switch.name = "Analog Rear Playback Switch";
677 dac_id = (details->spi_dac & 0x0f00) >> (4 * 2);
678 break;
679 case PCM_CENTER_LFE_CHANNEL:
680 spi_switch.name = "Analog Center/LFE Playback Switch";
681 dac_id = (details->spi_dac & 0x00f0) >> (4 * 1);
682 break;
683 case PCM_UNKNOWN_CHANNEL:
684 spi_switch.name = "Analog Side Playback Switch";
685 dac_id = (details->spi_dac & 0x000f) >> (4 * 0);
686 break;
687 default:
688 /* Unused channel */
689 spi_switch.name = NULL;
690 dac_id = 0;
691 }
692 reg = spi_dmute_reg[dac_id];
693 bit = spi_dmute_bit[dac_id];
694
695 spi_switch.private_value = (reg << SPI_REG_SHIFT) | bit;
696
697 return spi_switch;
698 }
699
remove_ctl(struct snd_card * card,const char * name)700 static int remove_ctl(struct snd_card *card, const char *name)
701 {
702 struct snd_ctl_elem_id id;
703 memset(&id, 0, sizeof(id));
704 strcpy(id.name, name);
705 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
706 return snd_ctl_remove_id(card, &id);
707 }
708
rename_ctl(struct snd_card * card,const char * src,const char * dst)709 static int rename_ctl(struct snd_card *card, const char *src, const char *dst)
710 {
711 struct snd_kcontrol *kctl = snd_ctl_find_id_mixer(card, src);
712 if (kctl) {
713 snd_ctl_rename(card, kctl, dst);
714 return 0;
715 }
716 return -ENOENT;
717 }
718
719 #define ADD_CTLS(emu, ctls) \
720 do { \
721 int i, _err; \
722 for (i = 0; i < ARRAY_SIZE(ctls); i++) { \
723 _err = snd_ctl_add(card, snd_ctl_new1(&ctls[i], emu)); \
724 if (_err < 0) \
725 return _err; \
726 } \
727 } while (0)
728
729 static
730 DECLARE_TLV_DB_SCALE(snd_ca0106_master_db_scale, -6375, 25, 1);
731
732 static const char * const follower_vols[] = {
733 "Analog Front Playback Volume",
734 "Analog Rear Playback Volume",
735 "Analog Center/LFE Playback Volume",
736 "Analog Side Playback Volume",
737 "IEC958 Front Playback Volume",
738 "IEC958 Rear Playback Volume",
739 "IEC958 Center/LFE Playback Volume",
740 "IEC958 Unknown Playback Volume",
741 "CAPTURE feedback Playback Volume",
742 NULL
743 };
744
745 static const char * const follower_sws[] = {
746 "Analog Front Playback Switch",
747 "Analog Rear Playback Switch",
748 "Analog Center/LFE Playback Switch",
749 "Analog Side Playback Switch",
750 "IEC958 Playback Switch",
751 NULL
752 };
753
snd_ca0106_mixer(struct snd_ca0106 * emu)754 int snd_ca0106_mixer(struct snd_ca0106 *emu)
755 {
756 int err;
757 struct snd_card *card = emu->card;
758 const char * const *c;
759 struct snd_kcontrol *vmaster;
760 static const char * const ca0106_remove_ctls[] = {
761 "Master Mono Playback Switch",
762 "Master Mono Playback Volume",
763 "3D Control - Switch",
764 "3D Control Sigmatel - Depth",
765 "PCM Playback Switch",
766 "PCM Playback Volume",
767 "CD Playback Switch",
768 "CD Playback Volume",
769 "Phone Playback Switch",
770 "Phone Playback Volume",
771 "Video Playback Switch",
772 "Video Playback Volume",
773 "Beep Playback Switch",
774 "Beep Playback Volume",
775 "Mono Output Select",
776 "Capture Source",
777 "Capture Switch",
778 "Capture Volume",
779 "External Amplifier",
780 "Sigmatel 4-Speaker Stereo Playback Switch",
781 "Surround Phase Inversion Playback Switch",
782 NULL
783 };
784 static const char * const ca0106_rename_ctls[] = {
785 "Master Playback Switch", "Capture Switch",
786 "Master Playback Volume", "Capture Volume",
787 "Line Playback Switch", "AC97 Line Capture Switch",
788 "Line Playback Volume", "AC97 Line Capture Volume",
789 "Aux Playback Switch", "AC97 Aux Capture Switch",
790 "Aux Playback Volume", "AC97 Aux Capture Volume",
791 "Mic Playback Switch", "AC97 Mic Capture Switch",
792 "Mic Playback Volume", "AC97 Mic Capture Volume",
793 "Mic Select", "AC97 Mic Select",
794 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
795 NULL
796 };
797 #if 1
798 for (c = ca0106_remove_ctls; *c; c++)
799 remove_ctl(card, *c);
800 for (c = ca0106_rename_ctls; *c; c += 2)
801 rename_ctl(card, c[0], c[1]);
802 #endif
803
804 ADD_CTLS(emu, snd_ca0106_volume_ctls);
805 if (emu->details->i2c_adc == 1) {
806 ADD_CTLS(emu, snd_ca0106_volume_i2c_adc_ctls);
807 if (emu->details->gpio_type == 1)
808 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
809 else /* gpio_type == 2 */
810 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_line_in_side_out, emu));
811 if (err < 0)
812 return err;
813 }
814 if (emu->details->spi_dac) {
815 int i;
816 for (i = 0;; i++) {
817 struct snd_kcontrol_new ctl;
818 ctl = snd_ca0106_volume_spi_dac_ctl(emu->details, i);
819 if (!ctl.name)
820 break;
821 err = snd_ctl_add(card, snd_ctl_new1(&ctl, emu));
822 if (err < 0)
823 return err;
824 }
825 }
826
827 /* Create virtual master controls */
828 vmaster = snd_ctl_make_virtual_master("Master Playback Volume",
829 snd_ca0106_master_db_scale);
830 if (!vmaster)
831 return -ENOMEM;
832 err = snd_ctl_add(card, vmaster);
833 if (err < 0)
834 return err;
835 err = snd_ctl_add_followers(card, vmaster, follower_vols);
836 if (err < 0)
837 return err;
838
839 if (emu->details->spi_dac) {
840 vmaster = snd_ctl_make_virtual_master("Master Playback Switch",
841 NULL);
842 if (!vmaster)
843 return -ENOMEM;
844 err = snd_ctl_add(card, vmaster);
845 if (err < 0)
846 return err;
847 err = snd_ctl_add_followers(card, vmaster, follower_sws);
848 if (err < 0)
849 return err;
850 }
851
852 strcpy(card->mixername, "CA0106");
853 return 0;
854 }
855
856 #ifdef CONFIG_PM_SLEEP
857 struct ca0106_vol_tbl {
858 unsigned int channel_id;
859 unsigned int reg;
860 };
861
862 static const struct ca0106_vol_tbl saved_volumes[NUM_SAVED_VOLUMES] = {
863 { CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2 },
864 { CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2 },
865 { CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2 },
866 { CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2 },
867 { CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1 },
868 { CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1 },
869 { CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1 },
870 { CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1 },
871 { 1, CAPTURE_CONTROL },
872 };
873
snd_ca0106_mixer_suspend(struct snd_ca0106 * chip)874 void snd_ca0106_mixer_suspend(struct snd_ca0106 *chip)
875 {
876 int i;
877
878 /* save volumes */
879 for (i = 0; i < NUM_SAVED_VOLUMES; i++)
880 chip->saved_vol[i] =
881 snd_ca0106_ptr_read(chip, saved_volumes[i].reg,
882 saved_volumes[i].channel_id);
883 }
884
snd_ca0106_mixer_resume(struct snd_ca0106 * chip)885 void snd_ca0106_mixer_resume(struct snd_ca0106 *chip)
886 {
887 int i;
888
889 for (i = 0; i < NUM_SAVED_VOLUMES; i++)
890 snd_ca0106_ptr_write(chip, saved_volumes[i].reg,
891 saved_volumes[i].channel_id,
892 chip->saved_vol[i]);
893
894 ca0106_spdif_enable(chip);
895 ca0106_set_capture_source(chip);
896 ca0106_set_i2c_capture_source(chip, chip->i2c_capture_source, 1);
897 for (i = 0; i < 4; i++)
898 ca0106_set_spdif_bits(chip, i);
899 if (chip->details->i2c_adc)
900 ca0106_set_capture_mic_line_in(chip);
901 }
902 #endif /* CONFIG_PM_SLEEP */
903
