?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'locks-v3.16-2' of git://git.samba.org/jlayton/linux
[linux/fpc-iii.git] / sound / pci / emu10k1 / emumixer.c
blobc5ae2a24d8a53f9f31775b2c4ae51fff0db569cf
1 /*
2 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
3 * Takashi Iwai <tiwai@suse.de>
4 * Creative Labs, Inc.
5 * Routines for control of EMU10K1 chips / mixer routines
6 * Multichannel PCM support Copyright (c) Lee Revell <rlrevell@joe-job.com>
7 *
8 * Copyright (c) by James Courtier-Dutton <James@superbug.co.uk>
9 * Added EMU 1010 support.
10 *
11 * BUGS:
12 * --
13 *
14 * TODO:
15 * --
16 *
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 *
31 */
32
33 #include <linux/time.h>
34 #include <linux/init.h>
35 #include <sound/core.h>
36 #include <sound/emu10k1.h>
37 #include <linux/delay.h>
38 #include <sound/tlv.h>
39
40 #include "p17v.h"
41
42 #define AC97_ID_STAC9758 0x83847658
43
44 static const DECLARE_TLV_DB_SCALE(snd_audigy_db_scale2, -10350, 50, 1); /* WM8775 gain scale */
45
46 static int snd_emu10k1_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
47 {
48 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
49 uinfo->count = 1;
50 return 0;
51 }
52
53 static int snd_emu10k1_spdif_get(struct snd_kcontrol *kcontrol,
54 struct snd_ctl_elem_value *ucontrol)
55 {
56 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
57 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
58 unsigned long flags;
59
60 /* Limit: emu->spdif_bits */
61 if (idx >= 3)
62 return -EINVAL;
63 spin_lock_irqsave(&emu->reg_lock, flags);
64 ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
65 ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
66 ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
67 ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
68 spin_unlock_irqrestore(&emu->reg_lock, flags);
69 return 0;
70 }
71
72 static int snd_emu10k1_spdif_get_mask(struct snd_kcontrol *kcontrol,
73 struct snd_ctl_elem_value *ucontrol)
74 {
75 ucontrol->value.iec958.status[0] = 0xff;
76 ucontrol->value.iec958.status[1] = 0xff;
77 ucontrol->value.iec958.status[2] = 0xff;
78 ucontrol->value.iec958.status[3] = 0xff;
79 return 0;
80 }
81
82 /*
83 * Items labels in enum mixer controls assigning source data to
84 * each destination
85 */
86 static char *emu1010_src_texts[] = {
87 "Silence",
88 "Dock Mic A",
89 "Dock Mic B",
90 "Dock ADC1 Left",
91 "Dock ADC1 Right",
92 "Dock ADC2 Left",
93 "Dock ADC2 Right",
94 "Dock ADC3 Left",
95 "Dock ADC3 Right",
96 "0202 ADC Left",
97 "0202 ADC Right",
98 "0202 SPDIF Left",
99 "0202 SPDIF Right",
100 "ADAT 0",
101 "ADAT 1",
102 "ADAT 2",
103 "ADAT 3",
104 "ADAT 4",
105 "ADAT 5",
106 "ADAT 6",
107 "ADAT 7",
108 "DSP 0",
109 "DSP 1",
110 "DSP 2",
111 "DSP 3",
112 "DSP 4",
113 "DSP 5",
114 "DSP 6",
115 "DSP 7",
116 "DSP 8",
117 "DSP 9",
118 "DSP 10",
119 "DSP 11",
120 "DSP 12",
121 "DSP 13",
122 "DSP 14",
123 "DSP 15",
124 "DSP 16",
125 "DSP 17",
126 "DSP 18",
127 "DSP 19",
128 "DSP 20",
129 "DSP 21",
130 "DSP 22",
131 "DSP 23",
132 "DSP 24",
133 "DSP 25",
134 "DSP 26",
135 "DSP 27",
136 "DSP 28",
137 "DSP 29",
138 "DSP 30",
139 "DSP 31",
140 };
141
142 /* 1616(m) cardbus */
143
144 static char *emu1616_src_texts[] = {
145 "Silence",
146 "Dock Mic A",
147 "Dock Mic B",
148 "Dock ADC1 Left",
149 "Dock ADC1 Right",
150 "Dock ADC2 Left",
151 "Dock ADC2 Right",
152 "Dock SPDIF Left",
153 "Dock SPDIF Right",
154 "ADAT 0",
155 "ADAT 1",
156 "ADAT 2",
157 "ADAT 3",
158 "ADAT 4",
159 "ADAT 5",
160 "ADAT 6",
161 "ADAT 7",
162 "DSP 0",
163 "DSP 1",
164 "DSP 2",
165 "DSP 3",
166 "DSP 4",
167 "DSP 5",
168 "DSP 6",
169 "DSP 7",
170 "DSP 8",
171 "DSP 9",
172 "DSP 10",
173 "DSP 11",
174 "DSP 12",
175 "DSP 13",
176 "DSP 14",
177 "DSP 15",
178 "DSP 16",
179 "DSP 17",
180 "DSP 18",
181 "DSP 19",
182 "DSP 20",
183 "DSP 21",
184 "DSP 22",
185 "DSP 23",
186 "DSP 24",
187 "DSP 25",
188 "DSP 26",
189 "DSP 27",
190 "DSP 28",
191 "DSP 29",
192 "DSP 30",
193 "DSP 31",
194 };
195
196
197 /*
198 * List of data sources available for each destination
199 */
200 static unsigned int emu1010_src_regs[] = {
201 EMU_SRC_SILENCE,/* 0 */
202 EMU_SRC_DOCK_MIC_A1, /* 1 */
203 EMU_SRC_DOCK_MIC_B1, /* 2 */
204 EMU_SRC_DOCK_ADC1_LEFT1, /* 3 */
205 EMU_SRC_DOCK_ADC1_RIGHT1, /* 4 */
206 EMU_SRC_DOCK_ADC2_LEFT1, /* 5 */
207 EMU_SRC_DOCK_ADC2_RIGHT1, /* 6 */
208 EMU_SRC_DOCK_ADC3_LEFT1, /* 7 */
209 EMU_SRC_DOCK_ADC3_RIGHT1, /* 8 */
210 EMU_SRC_HAMOA_ADC_LEFT1, /* 9 */
211 EMU_SRC_HAMOA_ADC_RIGHT1, /* 10 */
212 EMU_SRC_HANA_SPDIF_LEFT1, /* 11 */
213 EMU_SRC_HANA_SPDIF_RIGHT1, /* 12 */
214 EMU_SRC_HANA_ADAT, /* 13 */
215 EMU_SRC_HANA_ADAT+1, /* 14 */
216 EMU_SRC_HANA_ADAT+2, /* 15 */
217 EMU_SRC_HANA_ADAT+3, /* 16 */
218 EMU_SRC_HANA_ADAT+4, /* 17 */
219 EMU_SRC_HANA_ADAT+5, /* 18 */
220 EMU_SRC_HANA_ADAT+6, /* 19 */
221 EMU_SRC_HANA_ADAT+7, /* 20 */
222 EMU_SRC_ALICE_EMU32A, /* 21 */
223 EMU_SRC_ALICE_EMU32A+1, /* 22 */
224 EMU_SRC_ALICE_EMU32A+2, /* 23 */
225 EMU_SRC_ALICE_EMU32A+3, /* 24 */
226 EMU_SRC_ALICE_EMU32A+4, /* 25 */
227 EMU_SRC_ALICE_EMU32A+5, /* 26 */
228 EMU_SRC_ALICE_EMU32A+6, /* 27 */
229 EMU_SRC_ALICE_EMU32A+7, /* 28 */
230 EMU_SRC_ALICE_EMU32A+8, /* 29 */
231 EMU_SRC_ALICE_EMU32A+9, /* 30 */
232 EMU_SRC_ALICE_EMU32A+0xa, /* 31 */
233 EMU_SRC_ALICE_EMU32A+0xb, /* 32 */
234 EMU_SRC_ALICE_EMU32A+0xc, /* 33 */
235 EMU_SRC_ALICE_EMU32A+0xd, /* 34 */
236 EMU_SRC_ALICE_EMU32A+0xe, /* 35 */
237 EMU_SRC_ALICE_EMU32A+0xf, /* 36 */
238 EMU_SRC_ALICE_EMU32B, /* 37 */
239 EMU_SRC_ALICE_EMU32B+1, /* 38 */
240 EMU_SRC_ALICE_EMU32B+2, /* 39 */
241 EMU_SRC_ALICE_EMU32B+3, /* 40 */
242 EMU_SRC_ALICE_EMU32B+4, /* 41 */
243 EMU_SRC_ALICE_EMU32B+5, /* 42 */
244 EMU_SRC_ALICE_EMU32B+6, /* 43 */
245 EMU_SRC_ALICE_EMU32B+7, /* 44 */
246 EMU_SRC_ALICE_EMU32B+8, /* 45 */
247 EMU_SRC_ALICE_EMU32B+9, /* 46 */
248 EMU_SRC_ALICE_EMU32B+0xa, /* 47 */
249 EMU_SRC_ALICE_EMU32B+0xb, /* 48 */
250 EMU_SRC_ALICE_EMU32B+0xc, /* 49 */
251 EMU_SRC_ALICE_EMU32B+0xd, /* 50 */
252 EMU_SRC_ALICE_EMU32B+0xe, /* 51 */
253 EMU_SRC_ALICE_EMU32B+0xf, /* 52 */
254 };
255
256 /* 1616(m) cardbus */
257 static unsigned int emu1616_src_regs[] = {
258 EMU_SRC_SILENCE,
259 EMU_SRC_DOCK_MIC_A1,
260 EMU_SRC_DOCK_MIC_B1,
261 EMU_SRC_DOCK_ADC1_LEFT1,
262 EMU_SRC_DOCK_ADC1_RIGHT1,
263 EMU_SRC_DOCK_ADC2_LEFT1,
264 EMU_SRC_DOCK_ADC2_RIGHT1,
265 EMU_SRC_MDOCK_SPDIF_LEFT1,
266 EMU_SRC_MDOCK_SPDIF_RIGHT1,
267 EMU_SRC_MDOCK_ADAT,
268 EMU_SRC_MDOCK_ADAT+1,
269 EMU_SRC_MDOCK_ADAT+2,
270 EMU_SRC_MDOCK_ADAT+3,
271 EMU_SRC_MDOCK_ADAT+4,
272 EMU_SRC_MDOCK_ADAT+5,
273 EMU_SRC_MDOCK_ADAT+6,
274 EMU_SRC_MDOCK_ADAT+7,
275 EMU_SRC_ALICE_EMU32A,
276 EMU_SRC_ALICE_EMU32A+1,
277 EMU_SRC_ALICE_EMU32A+2,
278 EMU_SRC_ALICE_EMU32A+3,
279 EMU_SRC_ALICE_EMU32A+4,
280 EMU_SRC_ALICE_EMU32A+5,
281 EMU_SRC_ALICE_EMU32A+6,
282 EMU_SRC_ALICE_EMU32A+7,
283 EMU_SRC_ALICE_EMU32A+8,
284 EMU_SRC_ALICE_EMU32A+9,
285 EMU_SRC_ALICE_EMU32A+0xa,
286 EMU_SRC_ALICE_EMU32A+0xb,
287 EMU_SRC_ALICE_EMU32A+0xc,
288 EMU_SRC_ALICE_EMU32A+0xd,
289 EMU_SRC_ALICE_EMU32A+0xe,
290 EMU_SRC_ALICE_EMU32A+0xf,
291 EMU_SRC_ALICE_EMU32B,
292 EMU_SRC_ALICE_EMU32B+1,
293 EMU_SRC_ALICE_EMU32B+2,
294 EMU_SRC_ALICE_EMU32B+3,
295 EMU_SRC_ALICE_EMU32B+4,
296 EMU_SRC_ALICE_EMU32B+5,
297 EMU_SRC_ALICE_EMU32B+6,
298 EMU_SRC_ALICE_EMU32B+7,
299 EMU_SRC_ALICE_EMU32B+8,
300 EMU_SRC_ALICE_EMU32B+9,
301 EMU_SRC_ALICE_EMU32B+0xa,
302 EMU_SRC_ALICE_EMU32B+0xb,
303 EMU_SRC_ALICE_EMU32B+0xc,
304 EMU_SRC_ALICE_EMU32B+0xd,
305 EMU_SRC_ALICE_EMU32B+0xe,
306 EMU_SRC_ALICE_EMU32B+0xf,
307 };
308
309 /*
310 * Data destinations - physical EMU outputs.
311 * Each destination has an enum mixer control to choose a data source
312 */
313 static unsigned int emu1010_output_dst[] = {
314 EMU_DST_DOCK_DAC1_LEFT1, /* 0 */
315 EMU_DST_DOCK_DAC1_RIGHT1, /* 1 */
316 EMU_DST_DOCK_DAC2_LEFT1, /* 2 */
317 EMU_DST_DOCK_DAC2_RIGHT1, /* 3 */
318 EMU_DST_DOCK_DAC3_LEFT1, /* 4 */
319 EMU_DST_DOCK_DAC3_RIGHT1, /* 5 */
320 EMU_DST_DOCK_DAC4_LEFT1, /* 6 */
321 EMU_DST_DOCK_DAC4_RIGHT1, /* 7 */
322 EMU_DST_DOCK_PHONES_LEFT1, /* 8 */
323 EMU_DST_DOCK_PHONES_RIGHT1, /* 9 */
324 EMU_DST_DOCK_SPDIF_LEFT1, /* 10 */
325 EMU_DST_DOCK_SPDIF_RIGHT1, /* 11 */
326 EMU_DST_HANA_SPDIF_LEFT1, /* 12 */
327 EMU_DST_HANA_SPDIF_RIGHT1, /* 13 */
328 EMU_DST_HAMOA_DAC_LEFT1, /* 14 */
329 EMU_DST_HAMOA_DAC_RIGHT1, /* 15 */
330 EMU_DST_HANA_ADAT, /* 16 */
331 EMU_DST_HANA_ADAT+1, /* 17 */
332 EMU_DST_HANA_ADAT+2, /* 18 */
333 EMU_DST_HANA_ADAT+3, /* 19 */
334 EMU_DST_HANA_ADAT+4, /* 20 */
335 EMU_DST_HANA_ADAT+5, /* 21 */
336 EMU_DST_HANA_ADAT+6, /* 22 */
337 EMU_DST_HANA_ADAT+7, /* 23 */
338 };
339
340 /* 1616(m) cardbus */
341 static unsigned int emu1616_output_dst[] = {
342 EMU_DST_DOCK_DAC1_LEFT1,
343 EMU_DST_DOCK_DAC1_RIGHT1,
344 EMU_DST_DOCK_DAC2_LEFT1,
345 EMU_DST_DOCK_DAC2_RIGHT1,
346 EMU_DST_DOCK_DAC3_LEFT1,
347 EMU_DST_DOCK_DAC3_RIGHT1,
348 EMU_DST_MDOCK_SPDIF_LEFT1,
349 EMU_DST_MDOCK_SPDIF_RIGHT1,
350 EMU_DST_MDOCK_ADAT,
351 EMU_DST_MDOCK_ADAT+1,
352 EMU_DST_MDOCK_ADAT+2,
353 EMU_DST_MDOCK_ADAT+3,
354 EMU_DST_MDOCK_ADAT+4,
355 EMU_DST_MDOCK_ADAT+5,
356 EMU_DST_MDOCK_ADAT+6,
357 EMU_DST_MDOCK_ADAT+7,
358 EMU_DST_MANA_DAC_LEFT,
359 EMU_DST_MANA_DAC_RIGHT,
360 };
361
362 /*
363 * Data destinations - HANA outputs going to Alice2 (audigy) for
364 * capture (EMU32 + I2S links)
365 * Each destination has an enum mixer control to choose a data source
366 */
367 static unsigned int emu1010_input_dst[] = {
368 EMU_DST_ALICE2_EMU32_0,
369 EMU_DST_ALICE2_EMU32_1,
370 EMU_DST_ALICE2_EMU32_2,
371 EMU_DST_ALICE2_EMU32_3,
372 EMU_DST_ALICE2_EMU32_4,
373 EMU_DST_ALICE2_EMU32_5,
374 EMU_DST_ALICE2_EMU32_6,
375 EMU_DST_ALICE2_EMU32_7,
376 EMU_DST_ALICE2_EMU32_8,
377 EMU_DST_ALICE2_EMU32_9,
378 EMU_DST_ALICE2_EMU32_A,
379 EMU_DST_ALICE2_EMU32_B,
380 EMU_DST_ALICE2_EMU32_C,
381 EMU_DST_ALICE2_EMU32_D,
382 EMU_DST_ALICE2_EMU32_E,
383 EMU_DST_ALICE2_EMU32_F,
384 EMU_DST_ALICE_I2S0_LEFT,
385 EMU_DST_ALICE_I2S0_RIGHT,
386 EMU_DST_ALICE_I2S1_LEFT,
387 EMU_DST_ALICE_I2S1_RIGHT,
388 EMU_DST_ALICE_I2S2_LEFT,
389 EMU_DST_ALICE_I2S2_RIGHT,
390 };
391
392 static int snd_emu1010_input_output_source_info(struct snd_kcontrol *kcontrol,
393 struct snd_ctl_elem_info *uinfo)
394 {
395 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
396 char **items;
397
398 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
399 uinfo->count = 1;
400 if (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616) {
401 uinfo->value.enumerated.items = 49;
402 items = emu1616_src_texts;
403 } else {
404 uinfo->value.enumerated.items = 53;
405 items = emu1010_src_texts;
406 }
407 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
408 uinfo->value.enumerated.item =
409 uinfo->value.enumerated.items - 1;
410 strcpy(uinfo->value.enumerated.name,
411 items[uinfo->value.enumerated.item]);
412 return 0;
413 }
414
415 static int snd_emu1010_output_source_get(struct snd_kcontrol *kcontrol,
416 struct snd_ctl_elem_value *ucontrol)
417 {
418 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
419 unsigned int channel;
420
421 channel = (kcontrol->private_value) & 0xff;
422 /* Limit: emu1010_output_dst, emu->emu1010.output_source */
423 if (channel >= 24 ||
424 (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616 &&
425 channel >= 18))
426 return -EINVAL;
427 ucontrol->value.enumerated.item[0] = emu->emu1010.output_source[channel];
428 return 0;
429 }
430
431 static int snd_emu1010_output_source_put(struct snd_kcontrol *kcontrol,
432 struct snd_ctl_elem_value *ucontrol)
433 {
434 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
435 unsigned int val;
436 unsigned int channel;
437
438 val = ucontrol->value.enumerated.item[0];
439 if (val >= 53 ||
440 (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616 &&
441 val >= 49))
442 return -EINVAL;
443 channel = (kcontrol->private_value) & 0xff;
444 /* Limit: emu1010_output_dst, emu->emu1010.output_source */
445 if (channel >= 24 ||
446 (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616 &&
447 channel >= 18))
448 return -EINVAL;
449 if (emu->emu1010.output_source[channel] == val)
450 return 0;
451 emu->emu1010.output_source[channel] = val;
452 if (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616)
453 snd_emu1010_fpga_link_dst_src_write(emu,
454 emu1616_output_dst[channel], emu1616_src_regs[val]);
455 else
456 snd_emu1010_fpga_link_dst_src_write(emu,
457 emu1010_output_dst[channel], emu1010_src_regs[val]);
458 return 1;
459 }
460
461 static int snd_emu1010_input_source_get(struct snd_kcontrol *kcontrol,
462 struct snd_ctl_elem_value *ucontrol)
463 {
464 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
465 unsigned int channel;
466
467 channel = (kcontrol->private_value) & 0xff;
468 /* Limit: emu1010_input_dst, emu->emu1010.input_source */
469 if (channel >= 22)
470 return -EINVAL;
471 ucontrol->value.enumerated.item[0] = emu->emu1010.input_source[channel];
472 return 0;
473 }
474
475 static int snd_emu1010_input_source_put(struct snd_kcontrol *kcontrol,
476 struct snd_ctl_elem_value *ucontrol)
477 {
478 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
479 unsigned int val;
480 unsigned int channel;
481
482 val = ucontrol->value.enumerated.item[0];
483 if (val >= 53 ||
484 (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616 &&
485 val >= 49))
486 return -EINVAL;
487 channel = (kcontrol->private_value) & 0xff;
488 /* Limit: emu1010_input_dst, emu->emu1010.input_source */
489 if (channel >= 22)
490 return -EINVAL;
491 if (emu->emu1010.input_source[channel] == val)
492 return 0;
493 emu->emu1010.input_source[channel] = val;
494 if (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616)
495 snd_emu1010_fpga_link_dst_src_write(emu,
496 emu1010_input_dst[channel], emu1616_src_regs[val]);
497 else
498 snd_emu1010_fpga_link_dst_src_write(emu,
499 emu1010_input_dst[channel], emu1010_src_regs[val]);
500 return 1;
501 }
502
503 #define EMU1010_SOURCE_OUTPUT(xname,chid) \
504 { \
505 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
506 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
507 .info = snd_emu1010_input_output_source_info, \
508 .get = snd_emu1010_output_source_get, \
509 .put = snd_emu1010_output_source_put, \
510 .private_value = chid \
511 }
512
513 static struct snd_kcontrol_new snd_emu1010_output_enum_ctls[] = {
514 EMU1010_SOURCE_OUTPUT("Dock DAC1 Left Playback Enum", 0),
515 EMU1010_SOURCE_OUTPUT("Dock DAC1 Right Playback Enum", 1),
516 EMU1010_SOURCE_OUTPUT("Dock DAC2 Left Playback Enum", 2),
517 EMU1010_SOURCE_OUTPUT("Dock DAC2 Right Playback Enum", 3),
518 EMU1010_SOURCE_OUTPUT("Dock DAC3 Left Playback Enum", 4),
519 EMU1010_SOURCE_OUTPUT("Dock DAC3 Right Playback Enum", 5),
520 EMU1010_SOURCE_OUTPUT("Dock DAC4 Left Playback Enum", 6),
521 EMU1010_SOURCE_OUTPUT("Dock DAC4 Right Playback Enum", 7),
522 EMU1010_SOURCE_OUTPUT("Dock Phones Left Playback Enum", 8),
523 EMU1010_SOURCE_OUTPUT("Dock Phones Right Playback Enum", 9),
524 EMU1010_SOURCE_OUTPUT("Dock SPDIF Left Playback Enum", 0xa),
525 EMU1010_SOURCE_OUTPUT("Dock SPDIF Right Playback Enum", 0xb),
526 EMU1010_SOURCE_OUTPUT("1010 SPDIF Left Playback Enum", 0xc),
527 EMU1010_SOURCE_OUTPUT("1010 SPDIF Right Playback Enum", 0xd),
528 EMU1010_SOURCE_OUTPUT("0202 DAC Left Playback Enum", 0xe),
529 EMU1010_SOURCE_OUTPUT("0202 DAC Right Playback Enum", 0xf),
530 EMU1010_SOURCE_OUTPUT("1010 ADAT 0 Playback Enum", 0x10),
531 EMU1010_SOURCE_OUTPUT("1010 ADAT 1 Playback Enum", 0x11),
532 EMU1010_SOURCE_OUTPUT("1010 ADAT 2 Playback Enum", 0x12),
533 EMU1010_SOURCE_OUTPUT("1010 ADAT 3 Playback Enum", 0x13),
534 EMU1010_SOURCE_OUTPUT("1010 ADAT 4 Playback Enum", 0x14),
535 EMU1010_SOURCE_OUTPUT("1010 ADAT 5 Playback Enum", 0x15),
536 EMU1010_SOURCE_OUTPUT("1010 ADAT 6 Playback Enum", 0x16),
537 EMU1010_SOURCE_OUTPUT("1010 ADAT 7 Playback Enum", 0x17),
538 };
539
540
541 /* 1616(m) cardbus */
542 static struct snd_kcontrol_new snd_emu1616_output_enum_ctls[] = {
543 EMU1010_SOURCE_OUTPUT("Dock DAC1 Left Playback Enum", 0),
544 EMU1010_SOURCE_OUTPUT("Dock DAC1 Right Playback Enum", 1),
545 EMU1010_SOURCE_OUTPUT("Dock DAC2 Left Playback Enum", 2),
546 EMU1010_SOURCE_OUTPUT("Dock DAC2 Right Playback Enum", 3),
547 EMU1010_SOURCE_OUTPUT("Dock DAC3 Left Playback Enum", 4),
548 EMU1010_SOURCE_OUTPUT("Dock DAC3 Right Playback Enum", 5),
549 EMU1010_SOURCE_OUTPUT("Dock SPDIF Left Playback Enum", 6),
550 EMU1010_SOURCE_OUTPUT("Dock SPDIF Right Playback Enum", 7),
551 EMU1010_SOURCE_OUTPUT("Dock ADAT 0 Playback Enum", 8),
552 EMU1010_SOURCE_OUTPUT("Dock ADAT 1 Playback Enum", 9),
553 EMU1010_SOURCE_OUTPUT("Dock ADAT 2 Playback Enum", 0xa),
554 EMU1010_SOURCE_OUTPUT("Dock ADAT 3 Playback Enum", 0xb),
555 EMU1010_SOURCE_OUTPUT("Dock ADAT 4 Playback Enum", 0xc),
556 EMU1010_SOURCE_OUTPUT("Dock ADAT 5 Playback Enum", 0xd),
557 EMU1010_SOURCE_OUTPUT("Dock ADAT 6 Playback Enum", 0xe),
558 EMU1010_SOURCE_OUTPUT("Dock ADAT 7 Playback Enum", 0xf),
559 EMU1010_SOURCE_OUTPUT("Mana DAC Left Playback Enum", 0x10),
560 EMU1010_SOURCE_OUTPUT("Mana DAC Right Playback Enum", 0x11),
561 };
562
563
564 #define EMU1010_SOURCE_INPUT(xname,chid) \
565 { \
566 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
567 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
568 .info = snd_emu1010_input_output_source_info, \
569 .get = snd_emu1010_input_source_get, \
570 .put = snd_emu1010_input_source_put, \
571 .private_value = chid \
572 }
573
574 static struct snd_kcontrol_new snd_emu1010_input_enum_ctls[] = {
575 EMU1010_SOURCE_INPUT("DSP 0 Capture Enum", 0),
576 EMU1010_SOURCE_INPUT("DSP 1 Capture Enum", 1),
577 EMU1010_SOURCE_INPUT("DSP 2 Capture Enum", 2),
578 EMU1010_SOURCE_INPUT("DSP 3 Capture Enum", 3),
579 EMU1010_SOURCE_INPUT("DSP 4 Capture Enum", 4),
580 EMU1010_SOURCE_INPUT("DSP 5 Capture Enum", 5),
581 EMU1010_SOURCE_INPUT("DSP 6 Capture Enum", 6),
582 EMU1010_SOURCE_INPUT("DSP 7 Capture Enum", 7),
583 EMU1010_SOURCE_INPUT("DSP 8 Capture Enum", 8),
584 EMU1010_SOURCE_INPUT("DSP 9 Capture Enum", 9),
585 EMU1010_SOURCE_INPUT("DSP A Capture Enum", 0xa),
586 EMU1010_SOURCE_INPUT("DSP B Capture Enum", 0xb),
587 EMU1010_SOURCE_INPUT("DSP C Capture Enum", 0xc),
588 EMU1010_SOURCE_INPUT("DSP D Capture Enum", 0xd),
589 EMU1010_SOURCE_INPUT("DSP E Capture Enum", 0xe),
590 EMU1010_SOURCE_INPUT("DSP F Capture Enum", 0xf),
591 EMU1010_SOURCE_INPUT("DSP 10 Capture Enum", 0x10),
592 EMU1010_SOURCE_INPUT("DSP 11 Capture Enum", 0x11),
593 EMU1010_SOURCE_INPUT("DSP 12 Capture Enum", 0x12),
594 EMU1010_SOURCE_INPUT("DSP 13 Capture Enum", 0x13),
595 EMU1010_SOURCE_INPUT("DSP 14 Capture Enum", 0x14),
596 EMU1010_SOURCE_INPUT("DSP 15 Capture Enum", 0x15),
597 };
598
599
600
601 #define snd_emu1010_adc_pads_info snd_ctl_boolean_mono_info
602
603 static int snd_emu1010_adc_pads_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
604 {
605 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
606 unsigned int mask = kcontrol->private_value & 0xff;
607 ucontrol->value.integer.value[0] = (emu->emu1010.adc_pads & mask) ? 1 : 0;
608 return 0;
609 }
610
611 static int snd_emu1010_adc_pads_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
612 {
613 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
614 unsigned int mask = kcontrol->private_value & 0xff;
615 unsigned int val, cache;
616 val = ucontrol->value.integer.value[0];
617 cache = emu->emu1010.adc_pads;
618 if (val == 1)
619 cache = cache | mask;
620 else
621 cache = cache & ~mask;
622 if (cache != emu->emu1010.adc_pads) {
623 snd_emu1010_fpga_write(emu, EMU_HANA_ADC_PADS, cache );
624 emu->emu1010.adc_pads = cache;
625 }
626
627 return 0;
628 }
629
630
631
632 #define EMU1010_ADC_PADS(xname,chid) \
633 { \
634 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
635 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
636 .info = snd_emu1010_adc_pads_info, \
637 .get = snd_emu1010_adc_pads_get, \
638 .put = snd_emu1010_adc_pads_put, \
639 .private_value = chid \
640 }
641
642 static struct snd_kcontrol_new snd_emu1010_adc_pads[] = {
643 EMU1010_ADC_PADS("ADC1 14dB PAD Audio Dock Capture Switch", EMU_HANA_DOCK_ADC_PAD1),
644 EMU1010_ADC_PADS("ADC2 14dB PAD Audio Dock Capture Switch", EMU_HANA_DOCK_ADC_PAD2),
645 EMU1010_ADC_PADS("ADC3 14dB PAD Audio Dock Capture Switch", EMU_HANA_DOCK_ADC_PAD3),
646 EMU1010_ADC_PADS("ADC1 14dB PAD 0202 Capture Switch", EMU_HANA_0202_ADC_PAD1),
647 };
648
649 #define snd_emu1010_dac_pads_info snd_ctl_boolean_mono_info
650
651 static int snd_emu1010_dac_pads_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
652 {
653 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
654 unsigned int mask = kcontrol->private_value & 0xff;
655 ucontrol->value.integer.value[0] = (emu->emu1010.dac_pads & mask) ? 1 : 0;
656 return 0;
657 }
658
659 static int snd_emu1010_dac_pads_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
660 {
661 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
662 unsigned int mask = kcontrol->private_value & 0xff;
663 unsigned int val, cache;
664 val = ucontrol->value.integer.value[0];
665 cache = emu->emu1010.dac_pads;
666 if (val == 1)
667 cache = cache | mask;
668 else
669 cache = cache & ~mask;
670 if (cache != emu->emu1010.dac_pads) {
671 snd_emu1010_fpga_write(emu, EMU_HANA_DAC_PADS, cache );
672 emu->emu1010.dac_pads = cache;
673 }
674
675 return 0;
676 }
677
678
679
680 #define EMU1010_DAC_PADS(xname,chid) \
681 { \
682 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
683 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
684 .info = snd_emu1010_dac_pads_info, \
685 .get = snd_emu1010_dac_pads_get, \
686 .put = snd_emu1010_dac_pads_put, \
687 .private_value = chid \
688 }
689
690 static struct snd_kcontrol_new snd_emu1010_dac_pads[] = {
691 EMU1010_DAC_PADS("DAC1 Audio Dock 14dB PAD Playback Switch", EMU_HANA_DOCK_DAC_PAD1),
692 EMU1010_DAC_PADS("DAC2 Audio Dock 14dB PAD Playback Switch", EMU_HANA_DOCK_DAC_PAD2),
693 EMU1010_DAC_PADS("DAC3 Audio Dock 14dB PAD Playback Switch", EMU_HANA_DOCK_DAC_PAD3),
694 EMU1010_DAC_PADS("DAC4 Audio Dock 14dB PAD Playback Switch", EMU_HANA_DOCK_DAC_PAD4),
695 EMU1010_DAC_PADS("DAC1 0202 14dB PAD Playback Switch", EMU_HANA_0202_DAC_PAD1),
696 };
697
698
699 static int snd_emu1010_internal_clock_info(struct snd_kcontrol *kcontrol,
700 struct snd_ctl_elem_info *uinfo)
701 {
702 static char *texts[4] = {
703 "44100", "48000", "SPDIF", "ADAT"
704 };
705
706 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
707 uinfo->count = 1;
708 uinfo->value.enumerated.items = 4;
709 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
710 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
711 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
712 return 0;
713
714
715 }
716
717 static int snd_emu1010_internal_clock_get(struct snd_kcontrol *kcontrol,
718 struct snd_ctl_elem_value *ucontrol)
719 {
720 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
721
722 ucontrol->value.enumerated.item[0] = emu->emu1010.internal_clock;
723 return 0;
724 }
725
726 static int snd_emu1010_internal_clock_put(struct snd_kcontrol *kcontrol,
727 struct snd_ctl_elem_value *ucontrol)
728 {
729 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
730 unsigned int val;
731 int change = 0;
732
733 val = ucontrol->value.enumerated.item[0] ;
734 /* Limit: uinfo->value.enumerated.items = 4; */
735 if (val >= 4)
736 return -EINVAL;
737 change = (emu->emu1010.internal_clock != val);
738 if (change) {
739 emu->emu1010.internal_clock = val;
740 switch (val) {
741 case 0:
742 /* 44100 */
743 /* Mute all */
744 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE );
745 /* Default fallback clock 48kHz */
746 snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, EMU_HANA_DEFCLOCK_44_1K );
747 /* Word Clock source, Internal 44.1kHz x1 */
748 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK,
749 EMU_HANA_WCLOCK_INT_44_1K | EMU_HANA_WCLOCK_1X );
750 /* Set LEDs on Audio Dock */
751 snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_LEDS_2,
752 EMU_HANA_DOCK_LEDS_2_44K | EMU_HANA_DOCK_LEDS_2_LOCK );
753 /* Allow DLL to settle */
754 msleep(10);
755 /* Unmute all */
756 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE );
757 break;
758 case 1:
759 /* 48000 */
760 /* Mute all */
761 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE );
762 /* Default fallback clock 48kHz */
763 snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, EMU_HANA_DEFCLOCK_48K );
764 /* Word Clock source, Internal 48kHz x1 */
765 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK,
766 EMU_HANA_WCLOCK_INT_48K | EMU_HANA_WCLOCK_1X );
767 /* Set LEDs on Audio Dock */
768 snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_LEDS_2,
769 EMU_HANA_DOCK_LEDS_2_48K | EMU_HANA_DOCK_LEDS_2_LOCK );
770 /* Allow DLL to settle */
771 msleep(10);
772 /* Unmute all */
773 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE );
774 break;
775
776 case 2: /* Take clock from S/PDIF IN */
777 /* Mute all */
778 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE );
779 /* Default fallback clock 48kHz */
780 snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, EMU_HANA_DEFCLOCK_48K );
781 /* Word Clock source, sync to S/PDIF input */
782 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK,
783 EMU_HANA_WCLOCK_HANA_SPDIF_IN | EMU_HANA_WCLOCK_1X );
784 /* Set LEDs on Audio Dock */
785 snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_LEDS_2,
786 EMU_HANA_DOCK_LEDS_2_EXT | EMU_HANA_DOCK_LEDS_2_LOCK );
787 /* FIXME: We should set EMU_HANA_DOCK_LEDS_2_LOCK only when clock signal is present and valid */
788 /* Allow DLL to settle */
789 msleep(10);
790 /* Unmute all */
791 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE );
792 break;
793
794 case 3:
795 /* Take clock from ADAT IN */
796 /* Mute all */
797 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE );
798 /* Default fallback clock 48kHz */
799 snd_emu1010_fpga_write(emu, EMU_HANA_DEFCLOCK, EMU_HANA_DEFCLOCK_48K );
800 /* Word Clock source, sync to ADAT input */
801 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK,
802 EMU_HANA_WCLOCK_HANA_ADAT_IN | EMU_HANA_WCLOCK_1X );
803 /* Set LEDs on Audio Dock */
804 snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_LEDS_2, EMU_HANA_DOCK_LEDS_2_EXT | EMU_HANA_DOCK_LEDS_2_LOCK );
805 /* FIXME: We should set EMU_HANA_DOCK_LEDS_2_LOCK only when clock signal is present and valid */
806 /* Allow DLL to settle */
807 msleep(10);
808 /* Unmute all */
809 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE );
810
811
812 break;
813 }
814 }
815 return change;
816 }
817
818 static struct snd_kcontrol_new snd_emu1010_internal_clock =
819 {
820 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
821 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
822 .name = "Clock Internal Rate",
823 .count = 1,
824 .info = snd_emu1010_internal_clock_info,
825 .get = snd_emu1010_internal_clock_get,
826 .put = snd_emu1010_internal_clock_put
827 };
828
829 static int snd_audigy_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
830 struct snd_ctl_elem_info *uinfo)
831 {
832 #if 0
833 static char *texts[4] = {
834 "Unknown1", "Unknown2", "Mic", "Line"
835 };
836 #endif
837 static char *texts[2] = {
838 "Mic", "Line"
839 };
840
841 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
842 uinfo->count = 1;
843 uinfo->value.enumerated.items = 2;
844 if (uinfo->value.enumerated.item > 1)
845 uinfo->value.enumerated.item = 1;
846 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
847 return 0;
848 }
849
850 static int snd_audigy_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
851 struct snd_ctl_elem_value *ucontrol)
852 {
853 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
854
855 ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
856 return 0;
857 }
858
859 static int snd_audigy_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
860 struct snd_ctl_elem_value *ucontrol)
861 {
862 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
863 unsigned int source_id;
864 unsigned int ngain, ogain;
865 u32 gpio;
866 int change = 0;
867 unsigned long flags;
868 u32 source;
869 /* If the capture source has changed,
870 * update the capture volume from the cached value
871 * for the particular source.
872 */
873 source_id = ucontrol->value.enumerated.item[0];
874 /* Limit: uinfo->value.enumerated.items = 2; */
875 /* emu->i2c_capture_volume */
876 if (source_id >= 2)
877 return -EINVAL;
878 change = (emu->i2c_capture_source != source_id);
879 if (change) {
880 snd_emu10k1_i2c_write(emu, ADC_MUX, 0); /* Mute input */
881 spin_lock_irqsave(&emu->emu_lock, flags);
882 gpio = inl(emu->port + A_IOCFG);
883 if (source_id==0)
884 outl(gpio | 0x4, emu->port + A_IOCFG);
885 else
886 outl(gpio & ~0x4, emu->port + A_IOCFG);
887 spin_unlock_irqrestore(&emu->emu_lock, flags);
888
889 ngain = emu->i2c_capture_volume[source_id][0]; /* Left */
890 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
891 if (ngain != ogain)
892 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff));
893 ngain = emu->i2c_capture_volume[source_id][1]; /* Right */
894 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Right */
895 if (ngain != ogain)
896 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
897
898 source = 1 << (source_id + 2);
899 snd_emu10k1_i2c_write(emu, ADC_MUX, source); /* Set source */
900 emu->i2c_capture_source = source_id;
901 }
902 return change;
903 }
904
905 static struct snd_kcontrol_new snd_audigy_i2c_capture_source =
906 {
907 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
908 .name = "Capture Source",
909 .info = snd_audigy_i2c_capture_source_info,
910 .get = snd_audigy_i2c_capture_source_get,
911 .put = snd_audigy_i2c_capture_source_put
912 };
913
914 static int snd_audigy_i2c_volume_info(struct snd_kcontrol *kcontrol,
915 struct snd_ctl_elem_info *uinfo)
916 {
917 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
918 uinfo->count = 2;
919 uinfo->value.integer.min = 0;
920 uinfo->value.integer.max = 255;
921 return 0;
922 }
923
924 static int snd_audigy_i2c_volume_get(struct snd_kcontrol *kcontrol,
925 struct snd_ctl_elem_value *ucontrol)
926 {
927 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
928 unsigned int source_id;
929
930 source_id = kcontrol->private_value;
931 /* Limit: emu->i2c_capture_volume */
932 /* capture_source: uinfo->value.enumerated.items = 2 */
933 if (source_id >= 2)
934 return -EINVAL;
935
936 ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
937 ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
938 return 0;
939 }
940
941 static int snd_audigy_i2c_volume_put(struct snd_kcontrol *kcontrol,
942 struct snd_ctl_elem_value *ucontrol)
943 {
944 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
945 unsigned int ogain;
946 unsigned int ngain;
947 unsigned int source_id;
948 int change = 0;
949
950 source_id = kcontrol->private_value;
951 /* Limit: emu->i2c_capture_volume */
952 /* capture_source: uinfo->value.enumerated.items = 2 */
953 if (source_id >= 2)
954 return -EINVAL;
955 ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
956 ngain = ucontrol->value.integer.value[0];
957 if (ngain > 0xff)
958 return 0;
959 if (ogain != ngain) {
960 if (emu->i2c_capture_source == source_id)
961 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
962 emu->i2c_capture_volume[source_id][0] = ngain;
963 change = 1;
964 }
965 ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
966 ngain = ucontrol->value.integer.value[1];
967 if (ngain > 0xff)
968 return 0;
969 if (ogain != ngain) {
970 if (emu->i2c_capture_source == source_id)
971 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
972 emu->i2c_capture_volume[source_id][1] = ngain;
973 change = 1;
974 }
975
976 return change;
977 }
978
979 #define I2C_VOLUME(xname,chid) \
980 { \
981 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
982 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
983 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
984 .info = snd_audigy_i2c_volume_info, \
985 .get = snd_audigy_i2c_volume_get, \
986 .put = snd_audigy_i2c_volume_put, \
987 .tlv = { .p = snd_audigy_db_scale2 }, \
988 .private_value = chid \
989 }
990
991
992 static struct snd_kcontrol_new snd_audigy_i2c_volume_ctls[] = {
993 I2C_VOLUME("Mic Capture Volume", 0),
994 I2C_VOLUME("Line Capture Volume", 0)
995 };
996
997 #if 0
998 static int snd_audigy_spdif_output_rate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
999 {
1000 static char *texts[] = {"44100", "48000", "96000"};
1001
1002 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1003 uinfo->count = 1;
1004 uinfo->value.enumerated.items = 3;
1005 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1006 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1007 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1008 return 0;
1009 }
1010
1011 static int snd_audigy_spdif_output_rate_get(struct snd_kcontrol *kcontrol,
1012 struct snd_ctl_elem_value *ucontrol)
1013 {
1014 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1015 unsigned int tmp;
1016 unsigned long flags;
1017
1018
1019 spin_lock_irqsave(&emu->reg_lock, flags);
1020 tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0);
1021 switch (tmp & A_SPDIF_RATE_MASK) {
1022 case A_SPDIF_44100:
1023 ucontrol->value.enumerated.item[0] = 0;
1024 break;
1025 case A_SPDIF_48000:
1026 ucontrol->value.enumerated.item[0] = 1;
1027 break;
1028 case A_SPDIF_96000:
1029 ucontrol->value.enumerated.item[0] = 2;
1030 break;
1031 default:
1032 ucontrol->value.enumerated.item[0] = 1;
1033 }
1034 spin_unlock_irqrestore(&emu->reg_lock, flags);
1035 return 0;
1036 }
1037
1038 static int snd_audigy_spdif_output_rate_put(struct snd_kcontrol *kcontrol,
1039 struct snd_ctl_elem_value *ucontrol)
1040 {
1041 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1042 int change;
1043 unsigned int reg, val, tmp;
1044 unsigned long flags;
1045
1046 switch(ucontrol->value.enumerated.item[0]) {
1047 case 0:
1048 val = A_SPDIF_44100;
1049 break;
1050 case 1:
1051 val = A_SPDIF_48000;
1052 break;
1053 case 2:
1054 val = A_SPDIF_96000;
1055 break;
1056 default:
1057 val = A_SPDIF_48000;
1058 break;
1059 }
1060
1061
1062 spin_lock_irqsave(&emu->reg_lock, flags);
1063 reg = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0);
1064 tmp = reg & ~A_SPDIF_RATE_MASK;
1065 tmp |= val;
1066 if ((change = (tmp != reg)))
1067 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, 0, tmp);
1068 spin_unlock_irqrestore(&emu->reg_lock, flags);
1069 return change;
1070 }
1071
1072 static struct snd_kcontrol_new snd_audigy_spdif_output_rate =
1073 {
1074 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1075 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1076 .name = "Audigy SPDIF Output Sample Rate",
1077 .count = 1,
1078 .info = snd_audigy_spdif_output_rate_info,
1079 .get = snd_audigy_spdif_output_rate_get,
1080 .put = snd_audigy_spdif_output_rate_put
1081 };
1082 #endif
1083
1084 static int snd_emu10k1_spdif_put(struct snd_kcontrol *kcontrol,
1085 struct snd_ctl_elem_value *ucontrol)
1086 {
1087 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1088 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1089 int change;
1090 unsigned int val;
1091 unsigned long flags;
1092
1093 /* Limit: emu->spdif_bits */
1094 if (idx >= 3)
1095 return -EINVAL;
1096 val = (ucontrol->value.iec958.status[0] << 0) |
1097 (ucontrol->value.iec958.status[1] << 8) |
1098 (ucontrol->value.iec958.status[2] << 16) |
1099 (ucontrol->value.iec958.status[3] << 24);
1100 spin_lock_irqsave(&emu->reg_lock, flags);
1101 change = val != emu->spdif_bits[idx];
1102 if (change) {
1103 snd_emu10k1_ptr_write(emu, SPCS0 + idx, 0, val);
1104 emu->spdif_bits[idx] = val;
1105 }
1106 spin_unlock_irqrestore(&emu->reg_lock, flags);
1107 return change;
1108 }
1109
1110 static struct snd_kcontrol_new snd_emu10k1_spdif_mask_control =
1111 {
1112 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1113 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1114 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
1115 .count = 3,
1116 .info = snd_emu10k1_spdif_info,
1117 .get = snd_emu10k1_spdif_get_mask
1118 };
1119
1120 static struct snd_kcontrol_new snd_emu10k1_spdif_control =
1121 {
1122 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1123 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1124 .count = 3,
1125 .info = snd_emu10k1_spdif_info,
1126 .get = snd_emu10k1_spdif_get,
1127 .put = snd_emu10k1_spdif_put
1128 };
1129
1130
1131 static void update_emu10k1_fxrt(struct snd_emu10k1 *emu, int voice, unsigned char *route)
1132 {
1133 if (emu->audigy) {
1134 snd_emu10k1_ptr_write(emu, A_FXRT1, voice,
1135 snd_emu10k1_compose_audigy_fxrt1(route));
1136 snd_emu10k1_ptr_write(emu, A_FXRT2, voice,
1137 snd_emu10k1_compose_audigy_fxrt2(route));
1138 } else {
1139 snd_emu10k1_ptr_write(emu, FXRT, voice,
1140 snd_emu10k1_compose_send_routing(route));
1141 }
1142 }
1143
1144 static void update_emu10k1_send_volume(struct snd_emu10k1 *emu, int voice, unsigned char *volume)
1145 {
1146 snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_A, voice, volume[0]);
1147 snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_B, voice, volume[1]);
1148 snd_emu10k1_ptr_write(emu, PSST_FXSENDAMOUNT_C, voice, volume[2]);
1149 snd_emu10k1_ptr_write(emu, DSL_FXSENDAMOUNT_D, voice, volume[3]);
1150 if (emu->audigy) {
1151 unsigned int val = ((unsigned int)volume[4] << 24) |
1152 ((unsigned int)volume[5] << 16) |
1153 ((unsigned int)volume[6] << 8) |
1154 (unsigned int)volume[7];
1155 snd_emu10k1_ptr_write(emu, A_SENDAMOUNTS, voice, val);
1156 }
1157 }
1158
1159 /* PCM stream controls */
1160
1161 static int snd_emu10k1_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1162 {
1163 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1164 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1165 uinfo->count = emu->audigy ? 3*8 : 3*4;
1166 uinfo->value.integer.min = 0;
1167 uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f;
1168 return 0;
1169 }
1170
1171 static int snd_emu10k1_send_routing_get(struct snd_kcontrol *kcontrol,
1172 struct snd_ctl_elem_value *ucontrol)
1173 {
1174 unsigned long flags;
1175 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1176 struct snd_emu10k1_pcm_mixer *mix =
1177 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1178 int voice, idx;
1179 int num_efx = emu->audigy ? 8 : 4;
1180 int mask = emu->audigy ? 0x3f : 0x0f;
1181
1182 spin_lock_irqsave(&emu->reg_lock, flags);
1183 for (voice = 0; voice < 3; voice++)
1184 for (idx = 0; idx < num_efx; idx++)
1185 ucontrol->value.integer.value[(voice * num_efx) + idx] =
1186 mix->send_routing[voice][idx] & mask;
1187 spin_unlock_irqrestore(&emu->reg_lock, flags);
1188 return 0;
1189 }
1190
1191 static int snd_emu10k1_send_routing_put(struct snd_kcontrol *kcontrol,
1192 struct snd_ctl_elem_value *ucontrol)
1193 {
1194 unsigned long flags;
1195 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1196 struct snd_emu10k1_pcm_mixer *mix =
1197 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1198 int change = 0, voice, idx, val;
1199 int num_efx = emu->audigy ? 8 : 4;
1200 int mask = emu->audigy ? 0x3f : 0x0f;
1201
1202 spin_lock_irqsave(&emu->reg_lock, flags);
1203 for (voice = 0; voice < 3; voice++)
1204 for (idx = 0; idx < num_efx; idx++) {
1205 val = ucontrol->value.integer.value[(voice * num_efx) + idx] & mask;
1206 if (mix->send_routing[voice][idx] != val) {
1207 mix->send_routing[voice][idx] = val;
1208 change = 1;
1209 }
1210 }
1211 if (change && mix->epcm) {
1212 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
1213 update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number,
1214 &mix->send_routing[1][0]);
1215 update_emu10k1_fxrt(emu, mix->epcm->voices[1]->number,
1216 &mix->send_routing[2][0]);
1217 } else if (mix->epcm->voices[0]) {
1218 update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number,
1219 &mix->send_routing[0][0]);
1220 }
1221 }
1222 spin_unlock_irqrestore(&emu->reg_lock, flags);
1223 return change;
1224 }
1225
1226 static struct snd_kcontrol_new snd_emu10k1_send_routing_control =
1227 {
1228 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1229 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1230 .name = "EMU10K1 PCM Send Routing",
1231 .count = 32,
1232 .info = snd_emu10k1_send_routing_info,
1233 .get = snd_emu10k1_send_routing_get,
1234 .put = snd_emu10k1_send_routing_put
1235 };
1236
1237 static int snd_emu10k1_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1238 {
1239 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1240 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1241 uinfo->count = emu->audigy ? 3*8 : 3*4;
1242 uinfo->value.integer.min = 0;
1243 uinfo->value.integer.max = 255;
1244 return 0;
1245 }
1246
1247 static int snd_emu10k1_send_volume_get(struct snd_kcontrol *kcontrol,
1248 struct snd_ctl_elem_value *ucontrol)
1249 {
1250 unsigned long flags;
1251 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1252 struct snd_emu10k1_pcm_mixer *mix =
1253 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1254 int idx;
1255 int num_efx = emu->audigy ? 8 : 4;
1256
1257 spin_lock_irqsave(&emu->reg_lock, flags);
1258 for (idx = 0; idx < 3*num_efx; idx++)
1259 ucontrol->value.integer.value[idx] = mix->send_volume[idx/num_efx][idx%num_efx];
1260 spin_unlock_irqrestore(&emu->reg_lock, flags);
1261 return 0;
1262 }
1263
1264 static int snd_emu10k1_send_volume_put(struct snd_kcontrol *kcontrol,
1265 struct snd_ctl_elem_value *ucontrol)
1266 {
1267 unsigned long flags;
1268 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1269 struct snd_emu10k1_pcm_mixer *mix =
1270 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1271 int change = 0, idx, val;
1272 int num_efx = emu->audigy ? 8 : 4;
1273
1274 spin_lock_irqsave(&emu->reg_lock, flags);
1275 for (idx = 0; idx < 3*num_efx; idx++) {
1276 val = ucontrol->value.integer.value[idx] & 255;
1277 if (mix->send_volume[idx/num_efx][idx%num_efx] != val) {
1278 mix->send_volume[idx/num_efx][idx%num_efx] = val;
1279 change = 1;
1280 }
1281 }
1282 if (change && mix->epcm) {
1283 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
1284 update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number,
1285 &mix->send_volume[1][0]);
1286 update_emu10k1_send_volume(emu, mix->epcm->voices[1]->number,
1287 &mix->send_volume[2][0]);
1288 } else if (mix->epcm->voices[0]) {
1289 update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number,
1290 &mix->send_volume[0][0]);
1291 }
1292 }
1293 spin_unlock_irqrestore(&emu->reg_lock, flags);
1294 return change;
1295 }
1296
1297 static struct snd_kcontrol_new snd_emu10k1_send_volume_control =
1298 {
1299 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1300 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1301 .name = "EMU10K1 PCM Send Volume",
1302 .count = 32,
1303 .info = snd_emu10k1_send_volume_info,
1304 .get = snd_emu10k1_send_volume_get,
1305 .put = snd_emu10k1_send_volume_put
1306 };
1307
1308 static int snd_emu10k1_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1309 {
1310 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1311 uinfo->count = 3;
1312 uinfo->value.integer.min = 0;
1313 uinfo->value.integer.max = 0xffff;
1314 return 0;
1315 }
1316
1317 static int snd_emu10k1_attn_get(struct snd_kcontrol *kcontrol,
1318 struct snd_ctl_elem_value *ucontrol)
1319 {
1320 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1321 struct snd_emu10k1_pcm_mixer *mix =
1322 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1323 unsigned long flags;
1324 int idx;
1325
1326 spin_lock_irqsave(&emu->reg_lock, flags);
1327 for (idx = 0; idx < 3; idx++)
1328 ucontrol->value.integer.value[idx] = mix->attn[idx];
1329 spin_unlock_irqrestore(&emu->reg_lock, flags);
1330 return 0;
1331 }
1332
1333 static int snd_emu10k1_attn_put(struct snd_kcontrol *kcontrol,
1334 struct snd_ctl_elem_value *ucontrol)
1335 {
1336 unsigned long flags;
1337 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1338 struct snd_emu10k1_pcm_mixer *mix =
1339 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1340 int change = 0, idx, val;
1341
1342 spin_lock_irqsave(&emu->reg_lock, flags);
1343 for (idx = 0; idx < 3; idx++) {
1344 val = ucontrol->value.integer.value[idx] & 0xffff;
1345 if (mix->attn[idx] != val) {
1346 mix->attn[idx] = val;
1347 change = 1;
1348 }
1349 }
1350 if (change && mix->epcm) {
1351 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
1352 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[1]);
1353 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[1]->number, mix->attn[2]);
1354 } else if (mix->epcm->voices[0]) {
1355 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[0]);
1356 }
1357 }
1358 spin_unlock_irqrestore(&emu->reg_lock, flags);
1359 return change;
1360 }
1361
1362 static struct snd_kcontrol_new snd_emu10k1_attn_control =
1363 {
1364 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1365 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1366 .name = "EMU10K1 PCM Volume",
1367 .count = 32,
1368 .info = snd_emu10k1_attn_info,
1369 .get = snd_emu10k1_attn_get,
1370 .put = snd_emu10k1_attn_put
1371 };
1372
1373 /* Mutichannel PCM stream controls */
1374
1375 static int snd_emu10k1_efx_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1376 {
1377 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1378 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1379 uinfo->count = emu->audigy ? 8 : 4;
1380 uinfo->value.integer.min = 0;
1381 uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f;
1382 return 0;
1383 }
1384
1385 static int snd_emu10k1_efx_send_routing_get(struct snd_kcontrol *kcontrol,
1386 struct snd_ctl_elem_value *ucontrol)
1387 {
1388 unsigned long flags;
1389 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1390 struct snd_emu10k1_pcm_mixer *mix =
1391 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1392 int idx;
1393 int num_efx = emu->audigy ? 8 : 4;
1394 int mask = emu->audigy ? 0x3f : 0x0f;
1395
1396 spin_lock_irqsave(&emu->reg_lock, flags);
1397 for (idx = 0; idx < num_efx; idx++)
1398 ucontrol->value.integer.value[idx] =
1399 mix->send_routing[0][idx] & mask;
1400 spin_unlock_irqrestore(&emu->reg_lock, flags);
1401 return 0;
1402 }
1403
1404 static int snd_emu10k1_efx_send_routing_put(struct snd_kcontrol *kcontrol,
1405 struct snd_ctl_elem_value *ucontrol)
1406 {
1407 unsigned long flags;
1408 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1409 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1410 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1411 int change = 0, idx, val;
1412 int num_efx = emu->audigy ? 8 : 4;
1413 int mask = emu->audigy ? 0x3f : 0x0f;
1414
1415 spin_lock_irqsave(&emu->reg_lock, flags);
1416 for (idx = 0; idx < num_efx; idx++) {
1417 val = ucontrol->value.integer.value[idx] & mask;
1418 if (mix->send_routing[0][idx] != val) {
1419 mix->send_routing[0][idx] = val;
1420 change = 1;
1421 }
1422 }
1423
1424 if (change && mix->epcm) {
1425 if (mix->epcm->voices[ch]) {
1426 update_emu10k1_fxrt(emu, mix->epcm->voices[ch]->number,
1427 &mix->send_routing[0][0]);
1428 }
1429 }
1430 spin_unlock_irqrestore(&emu->reg_lock, flags);
1431 return change;
1432 }
1433
1434 static struct snd_kcontrol_new snd_emu10k1_efx_send_routing_control =
1435 {
1436 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1437 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1438 .name = "Multichannel PCM Send Routing",
1439 .count = 16,
1440 .info = snd_emu10k1_efx_send_routing_info,
1441 .get = snd_emu10k1_efx_send_routing_get,
1442 .put = snd_emu10k1_efx_send_routing_put
1443 };
1444
1445 static int snd_emu10k1_efx_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1446 {
1447 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1448 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1449 uinfo->count = emu->audigy ? 8 : 4;
1450 uinfo->value.integer.min = 0;
1451 uinfo->value.integer.max = 255;
1452 return 0;
1453 }
1454
1455 static int snd_emu10k1_efx_send_volume_get(struct snd_kcontrol *kcontrol,
1456 struct snd_ctl_elem_value *ucontrol)
1457 {
1458 unsigned long flags;
1459 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1460 struct snd_emu10k1_pcm_mixer *mix =
1461 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1462 int idx;
1463 int num_efx = emu->audigy ? 8 : 4;
1464
1465 spin_lock_irqsave(&emu->reg_lock, flags);
1466 for (idx = 0; idx < num_efx; idx++)
1467 ucontrol->value.integer.value[idx] = mix->send_volume[0][idx];
1468 spin_unlock_irqrestore(&emu->reg_lock, flags);
1469 return 0;
1470 }
1471
1472 static int snd_emu10k1_efx_send_volume_put(struct snd_kcontrol *kcontrol,
1473 struct snd_ctl_elem_value *ucontrol)
1474 {
1475 unsigned long flags;
1476 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1477 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1478 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1479 int change = 0, idx, val;
1480 int num_efx = emu->audigy ? 8 : 4;
1481
1482 spin_lock_irqsave(&emu->reg_lock, flags);
1483 for (idx = 0; idx < num_efx; idx++) {
1484 val = ucontrol->value.integer.value[idx] & 255;
1485 if (mix->send_volume[0][idx] != val) {
1486 mix->send_volume[0][idx] = val;
1487 change = 1;
1488 }
1489 }
1490 if (change && mix->epcm) {
1491 if (mix->epcm->voices[ch]) {
1492 update_emu10k1_send_volume(emu, mix->epcm->voices[ch]->number,
1493 &mix->send_volume[0][0]);
1494 }
1495 }
1496 spin_unlock_irqrestore(&emu->reg_lock, flags);
1497 return change;
1498 }
1499
1500
1501 static struct snd_kcontrol_new snd_emu10k1_efx_send_volume_control =
1502 {
1503 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1504 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1505 .name = "Multichannel PCM Send Volume",
1506 .count = 16,
1507 .info = snd_emu10k1_efx_send_volume_info,
1508 .get = snd_emu10k1_efx_send_volume_get,
1509 .put = snd_emu10k1_efx_send_volume_put
1510 };
1511
1512 static int snd_emu10k1_efx_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1513 {
1514 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1515 uinfo->count = 1;
1516 uinfo->value.integer.min = 0;
1517 uinfo->value.integer.max = 0xffff;
1518 return 0;
1519 }
1520
1521 static int snd_emu10k1_efx_attn_get(struct snd_kcontrol *kcontrol,
1522 struct snd_ctl_elem_value *ucontrol)
1523 {
1524 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1525 struct snd_emu10k1_pcm_mixer *mix =
1526 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1527 unsigned long flags;
1528
1529 spin_lock_irqsave(&emu->reg_lock, flags);
1530 ucontrol->value.integer.value[0] = mix->attn[0];
1531 spin_unlock_irqrestore(&emu->reg_lock, flags);
1532 return 0;
1533 }
1534
1535 static int snd_emu10k1_efx_attn_put(struct snd_kcontrol *kcontrol,
1536 struct snd_ctl_elem_value *ucontrol)
1537 {
1538 unsigned long flags;
1539 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1540 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1541 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1542 int change = 0, val;
1543
1544 spin_lock_irqsave(&emu->reg_lock, flags);
1545 val = ucontrol->value.integer.value[0] & 0xffff;
1546 if (mix->attn[0] != val) {
1547 mix->attn[0] = val;
1548 change = 1;
1549 }
1550 if (change && mix->epcm) {
1551 if (mix->epcm->voices[ch]) {
1552 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[ch]->number, mix->attn[0]);
1553 }
1554 }
1555 spin_unlock_irqrestore(&emu->reg_lock, flags);
1556 return change;
1557 }
1558
1559 static struct snd_kcontrol_new snd_emu10k1_efx_attn_control =
1560 {
1561 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1562 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1563 .name = "Multichannel PCM Volume",
1564 .count = 16,
1565 .info = snd_emu10k1_efx_attn_info,
1566 .get = snd_emu10k1_efx_attn_get,
1567 .put = snd_emu10k1_efx_attn_put
1568 };
1569
1570 #define snd_emu10k1_shared_spdif_info snd_ctl_boolean_mono_info
1571
1572 static int snd_emu10k1_shared_spdif_get(struct snd_kcontrol *kcontrol,
1573 struct snd_ctl_elem_value *ucontrol)
1574 {
1575 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1576
1577 if (emu->audigy)
1578 ucontrol->value.integer.value[0] = inl(emu->port + A_IOCFG) & A_IOCFG_GPOUT0 ? 1 : 0;
1579 else
1580 ucontrol->value.integer.value[0] = inl(emu->port + HCFG) & HCFG_GPOUT0 ? 1 : 0;
1581 if (emu->card_capabilities->invert_shared_spdif)
1582 ucontrol->value.integer.value[0] =
1583 !ucontrol->value.integer.value[0];
1584
1585 return 0;
1586 }
1587
1588 static int snd_emu10k1_shared_spdif_put(struct snd_kcontrol *kcontrol,
1589 struct snd_ctl_elem_value *ucontrol)
1590 {
1591 unsigned long flags;
1592 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1593 unsigned int reg, val, sw;
1594 int change = 0;
1595
1596 sw = ucontrol->value.integer.value[0];
1597 if (emu->card_capabilities->invert_shared_spdif)
1598 sw = !sw;
1599 spin_lock_irqsave(&emu->reg_lock, flags);
1600 if ( emu->card_capabilities->i2c_adc) {
1601 /* Do nothing for Audigy 2 ZS Notebook */
1602 } else if (emu->audigy) {
1603 reg = inl(emu->port + A_IOCFG);
1604 val = sw ? A_IOCFG_GPOUT0 : 0;
1605 change = (reg & A_IOCFG_GPOUT0) != val;
1606 if (change) {
1607 reg &= ~A_IOCFG_GPOUT0;
1608 reg |= val;
1609 outl(reg | val, emu->port + A_IOCFG);
1610 }
1611 }
1612 reg = inl(emu->port + HCFG);
1613 val = sw ? HCFG_GPOUT0 : 0;
1614 change |= (reg & HCFG_GPOUT0) != val;
1615 if (change) {
1616 reg &= ~HCFG_GPOUT0;
1617 reg |= val;
1618 outl(reg | val, emu->port + HCFG);
1619 }
1620 spin_unlock_irqrestore(&emu->reg_lock, flags);
1621 return change;
1622 }
1623
1624 static struct snd_kcontrol_new snd_emu10k1_shared_spdif =
1625 {
1626 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1627 .name = "SB Live Analog/Digital Output Jack",
1628 .info = snd_emu10k1_shared_spdif_info,
1629 .get = snd_emu10k1_shared_spdif_get,
1630 .put = snd_emu10k1_shared_spdif_put
1631 };
1632
1633 static struct snd_kcontrol_new snd_audigy_shared_spdif =
1634 {
1635 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1636 .name = "Audigy Analog/Digital Output Jack",
1637 .info = snd_emu10k1_shared_spdif_info,
1638 .get = snd_emu10k1_shared_spdif_get,
1639 .put = snd_emu10k1_shared_spdif_put
1640 };
1641
1642 /* workaround for too low volume on Audigy due to 16bit/24bit conversion */
1643
1644 #define snd_audigy_capture_boost_info snd_ctl_boolean_mono_info
1645
1646 static int snd_audigy_capture_boost_get(struct snd_kcontrol *kcontrol,
1647 struct snd_ctl_elem_value *ucontrol)
1648 {
1649 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1650 unsigned int val;
1651
1652 /* FIXME: better to use a cached version */
1653 val = snd_ac97_read(emu->ac97, AC97_REC_GAIN);
1654 ucontrol->value.integer.value[0] = !!val;
1655 return 0;
1656 }
1657
1658 static int snd_audigy_capture_boost_put(struct snd_kcontrol *kcontrol,
1659 struct snd_ctl_elem_value *ucontrol)
1660 {
1661 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1662 unsigned int val;
1663
1664 if (ucontrol->value.integer.value[0])
1665 val = 0x0f0f;
1666 else
1667 val = 0;
1668 return snd_ac97_update(emu->ac97, AC97_REC_GAIN, val);
1669 }
1670
1671 static struct snd_kcontrol_new snd_audigy_capture_boost =
1672 {
1673 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1674 .name = "Analog Capture Boost",
1675 .info = snd_audigy_capture_boost_info,
1676 .get = snd_audigy_capture_boost_get,
1677 .put = snd_audigy_capture_boost_put
1678 };
1679
1680
1681 /*
1682 */
1683 static void snd_emu10k1_mixer_free_ac97(struct snd_ac97 *ac97)
1684 {
1685 struct snd_emu10k1 *emu = ac97->private_data;
1686 emu->ac97 = NULL;
1687 }
1688
1689 /*
1690 */
1691 static int remove_ctl(struct snd_card *card, const char *name)
1692 {
1693 struct snd_ctl_elem_id id;
1694 memset(&id, 0, sizeof(id));
1695 strcpy(id.name, name);
1696 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1697 return snd_ctl_remove_id(card, &id);
1698 }
1699
1700 static struct snd_kcontrol *ctl_find(struct snd_card *card, const char *name)
1701 {
1702 struct snd_ctl_elem_id sid;
1703 memset(&sid, 0, sizeof(sid));
1704 strcpy(sid.name, name);
1705 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1706 return snd_ctl_find_id(card, &sid);
1707 }
1708
1709 static int rename_ctl(struct snd_card *card, const char *src, const char *dst)
1710 {
1711 struct snd_kcontrol *kctl = ctl_find(card, src);
1712 if (kctl) {
1713 strcpy(kctl->id.name, dst);
1714 return 0;
1715 }
1716 return -ENOENT;
1717 }
1718
1719 int snd_emu10k1_mixer(struct snd_emu10k1 *emu,
1720 int pcm_device, int multi_device)
1721 {
1722 int err, pcm;
1723 struct snd_kcontrol *kctl;
1724 struct snd_card *card = emu->card;
1725 char **c;
1726 static char *emu10k1_remove_ctls[] = {
1727 /* no AC97 mono, surround, center/lfe */
1728 "Master Mono Playback Switch",
1729 "Master Mono Playback Volume",
1730 "PCM Out Path & Mute",
1731 "Mono Output Select",
1732 "Surround Playback Switch",
1733 "Surround Playback Volume",
1734 "Center Playback Switch",
1735 "Center Playback Volume",
1736 "LFE Playback Switch",
1737 "LFE Playback Volume",
1738 NULL
1739 };
1740 static char *emu10k1_rename_ctls[] = {
1741 "Surround Digital Playback Volume", "Surround Playback Volume",
1742 "Center Digital Playback Volume", "Center Playback Volume",
1743 "LFE Digital Playback Volume", "LFE Playback Volume",
1744 NULL
1745 };
1746 static char *audigy_remove_ctls[] = {
1747 /* Master/PCM controls on ac97 of Audigy has no effect */
1748 /* On the Audigy2 the AC97 playback is piped into
1749 * the Philips ADC for 24bit capture */
1750 "PCM Playback Switch",
1751 "PCM Playback Volume",
1752 "Master Mono Playback Switch",
1753 "Master Mono Playback Volume",
1754 "Master Playback Switch",
1755 "Master Playback Volume",
1756 "PCM Out Path & Mute",
1757 "Mono Output Select",
1758 /* remove unused AC97 capture controls */
1759 "Capture Source",
1760 "Capture Switch",
1761 "Capture Volume",
1762 "Mic Select",
1763 "Video Playback Switch",
1764 "Video Playback Volume",
1765 "Mic Playback Switch",
1766 "Mic Playback Volume",
1767 NULL
1768 };
1769 static char *audigy_rename_ctls[] = {
1770 /* use conventional names */
1771 "Wave Playback Volume", "PCM Playback Volume",
1772 /* "Wave Capture Volume", "PCM Capture Volume", */
1773 "Wave Master Playback Volume", "Master Playback Volume",
1774 "AMic Playback Volume", "Mic Playback Volume",
1775 NULL
1776 };
1777 static char *audigy_rename_ctls_i2c_adc[] = {
1778 //"Analog Mix Capture Volume","OLD Analog Mix Capture Volume",
1779 "Line Capture Volume", "Analog Mix Capture Volume",
1780 "Wave Playback Volume", "OLD PCM Playback Volume",
1781 "Wave Master Playback Volume", "Master Playback Volume",
1782 "AMic Playback Volume", "Old Mic Playback Volume",
1783 "CD Capture Volume", "IEC958 Optical Capture Volume",
1784 NULL
1785 };
1786 static char *audigy_remove_ctls_i2c_adc[] = {
1787 /* On the Audigy2 ZS Notebook
1788 * Capture via WM8775 */
1789 "Mic Capture Volume",
1790 "Analog Mix Capture Volume",
1791 "Aux Capture Volume",
1792 "IEC958 Optical Capture Volume",
1793 NULL
1794 };
1795 static char *audigy_remove_ctls_1361t_adc[] = {
1796 /* On the Audigy2 the AC97 playback is piped into
1797 * the Philips ADC for 24bit capture */
1798 "PCM Playback Switch",
1799 "PCM Playback Volume",
1800 "Master Mono Playback Switch",
1801 "Master Mono Playback Volume",
1802 "Capture Source",
1803 "Capture Switch",
1804 "Capture Volume",
1805 "Mic Capture Volume",
1806 "Headphone Playback Switch",
1807 "Headphone Playback Volume",
1808 "3D Control - Center",
1809 "3D Control - Depth",
1810 "3D Control - Switch",
1811 "Line2 Playback Volume",
1812 "Line2 Capture Volume",
1813 NULL
1814 };
1815 static char *audigy_rename_ctls_1361t_adc[] = {
1816 "Master Playback Switch", "Master Capture Switch",
1817 "Master Playback Volume", "Master Capture Volume",
1818 "Wave Master Playback Volume", "Master Playback Volume",
1819 "Beep Playback Switch", "Beep Capture Switch",
1820 "Beep Playback Volume", "Beep Capture Volume",
1821 "Phone Playback Switch", "Phone Capture Switch",
1822 "Phone Playback Volume", "Phone Capture Volume",
1823 "Mic Playback Switch", "Mic Capture Switch",
1824 "Mic Playback Volume", "Mic Capture Volume",
1825 "Line Playback Switch", "Line Capture Switch",
1826 "Line Playback Volume", "Line Capture Volume",
1827 "CD Playback Switch", "CD Capture Switch",
1828 "CD Playback Volume", "CD Capture Volume",
1829 "Aux Playback Switch", "Aux Capture Switch",
1830 "Aux Playback Volume", "Aux Capture Volume",
1831 "Video Playback Switch", "Video Capture Switch",
1832 "Video Playback Volume", "Video Capture Volume",
1833
1834 NULL
1835 };
1836
1837 if (emu->card_capabilities->ac97_chip) {
1838 struct snd_ac97_bus *pbus;
1839 struct snd_ac97_template ac97;
1840 static struct snd_ac97_bus_ops ops = {
1841 .write = snd_emu10k1_ac97_write,
1842 .read = snd_emu10k1_ac97_read,
1843 };
1844
1845 if ((err = snd_ac97_bus(emu->card, 0, &ops, NULL, &pbus)) < 0)
1846 return err;
1847 pbus->no_vra = 1; /* we don't need VRA */
1848
1849 memset(&ac97, 0, sizeof(ac97));
1850 ac97.private_data = emu;
1851 ac97.private_free = snd_emu10k1_mixer_free_ac97;
1852 ac97.scaps = AC97_SCAP_NO_SPDIF;
1853 if ((err = snd_ac97_mixer(pbus, &ac97, &emu->ac97)) < 0) {
1854 if (emu->card_capabilities->ac97_chip == 1)
1855 return err;
1856 dev_info(emu->card->dev,
1857 "AC97 is optional on this board\n");
1858 dev_info(emu->card->dev,
1859 "Proceeding without ac97 mixers...\n");
1860 snd_device_free(emu->card, pbus);
1861 goto no_ac97; /* FIXME: get rid of ugly gotos.. */
1862 }
1863 if (emu->audigy) {
1864 /* set master volume to 0 dB */
1865 snd_ac97_write_cache(emu->ac97, AC97_MASTER, 0x0000);
1866 /* set capture source to mic */
1867 snd_ac97_write_cache(emu->ac97, AC97_REC_SEL, 0x0000);
1868 if (emu->card_capabilities->adc_1361t)
1869 c = audigy_remove_ctls_1361t_adc;
1870 else
1871 c = audigy_remove_ctls;
1872 } else {
1873 /*
1874 * Credits for cards based on STAC9758:
1875 * James Courtier-Dutton <James@superbug.demon.co.uk>
1876 * Voluspa <voluspa@comhem.se>
1877 */
1878 if (emu->ac97->id == AC97_ID_STAC9758) {
1879 emu->rear_ac97 = 1;
1880 snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_CNTR|AC97SLOT_LFE|AC97SLOT_REAR_LEFT|AC97SLOT_REAR_RIGHT);
1881 snd_ac97_write_cache(emu->ac97, AC97_HEADPHONE, 0x0202);
1882 remove_ctl(card,"Front Playback Volume");
1883 remove_ctl(card,"Front Playback Switch");
1884 }
1885 /* remove unused AC97 controls */
1886 snd_ac97_write_cache(emu->ac97, AC97_SURROUND_MASTER, 0x0202);
1887 snd_ac97_write_cache(emu->ac97, AC97_CENTER_LFE_MASTER, 0x0202);
1888 c = emu10k1_remove_ctls;
1889 }
1890 for (; *c; c++)
1891 remove_ctl(card, *c);
1892 } else if (emu->card_capabilities->i2c_adc) {
1893 c = audigy_remove_ctls_i2c_adc;
1894 for (; *c; c++)
1895 remove_ctl(card, *c);
1896 } else {
1897 no_ac97:
1898 if (emu->card_capabilities->ecard)
1899 strcpy(emu->card->mixername, "EMU APS");
1900 else if (emu->audigy)
1901 strcpy(emu->card->mixername, "SB Audigy");
1902 else
1903 strcpy(emu->card->mixername, "Emu10k1");
1904 }
1905
1906 if (emu->audigy)
1907 if (emu->card_capabilities->adc_1361t)
1908 c = audigy_rename_ctls_1361t_adc;
1909 else if (emu->card_capabilities->i2c_adc)
1910 c = audigy_rename_ctls_i2c_adc;
1911 else
1912 c = audigy_rename_ctls;
1913 else
1914 c = emu10k1_rename_ctls;
1915 for (; *c; c += 2)
1916 rename_ctl(card, c[0], c[1]);
1917
1918 if (emu->card_capabilities->subsystem == 0x80401102) { /* SB Live! Platinum CT4760P */
1919 remove_ctl(card, "Center Playback Volume");
1920 remove_ctl(card, "LFE Playback Volume");
1921 remove_ctl(card, "Wave Center Playback Volume");
1922 remove_ctl(card, "Wave LFE Playback Volume");
1923 }
1924 if (emu->card_capabilities->subsystem == 0x20071102) { /* Audigy 4 Pro */
1925 rename_ctl(card, "Line2 Capture Volume", "Line1/Mic Capture Volume");
1926 rename_ctl(card, "Analog Mix Capture Volume", "Line2 Capture Volume");
1927 rename_ctl(card, "Aux2 Capture Volume", "Line3 Capture Volume");
1928 rename_ctl(card, "Mic Capture Volume", "Unknown1 Capture Volume");
1929 remove_ctl(card, "Headphone Playback Switch");
1930 remove_ctl(card, "Headphone Playback Volume");
1931 remove_ctl(card, "3D Control - Center");
1932 remove_ctl(card, "3D Control - Depth");
1933 remove_ctl(card, "3D Control - Switch");
1934 }
1935 if ((kctl = emu->ctl_send_routing = snd_ctl_new1(&snd_emu10k1_send_routing_control, emu)) == NULL)
1936 return -ENOMEM;
1937 kctl->id.device = pcm_device;
1938 if ((err = snd_ctl_add(card, kctl)))
1939 return err;
1940 if ((kctl = emu->ctl_send_volume = snd_ctl_new1(&snd_emu10k1_send_volume_control, emu)) == NULL)
1941 return -ENOMEM;
1942 kctl->id.device = pcm_device;
1943 if ((err = snd_ctl_add(card, kctl)))
1944 return err;
1945 if ((kctl = emu->ctl_attn = snd_ctl_new1(&snd_emu10k1_attn_control, emu)) == NULL)
1946 return -ENOMEM;
1947 kctl->id.device = pcm_device;
1948 if ((err = snd_ctl_add(card, kctl)))
1949 return err;
1950
1951 if ((kctl = emu->ctl_efx_send_routing = snd_ctl_new1(&snd_emu10k1_efx_send_routing_control, emu)) == NULL)
1952 return -ENOMEM;
1953 kctl->id.device = multi_device;
1954 if ((err = snd_ctl_add(card, kctl)))
1955 return err;
1956
1957 if ((kctl = emu->ctl_efx_send_volume = snd_ctl_new1(&snd_emu10k1_efx_send_volume_control, emu)) == NULL)
1958 return -ENOMEM;
1959 kctl->id.device = multi_device;
1960 if ((err = snd_ctl_add(card, kctl)))
1961 return err;
1962
1963 if ((kctl = emu->ctl_efx_attn = snd_ctl_new1(&snd_emu10k1_efx_attn_control, emu)) == NULL)
1964 return -ENOMEM;
1965 kctl->id.device = multi_device;
1966 if ((err = snd_ctl_add(card, kctl)))
1967 return err;
1968
1969 /* initialize the routing and volume table for each pcm playback stream */
1970 for (pcm = 0; pcm < 32; pcm++) {
1971 struct snd_emu10k1_pcm_mixer *mix;
1972 int v;
1973
1974 mix = &emu->pcm_mixer[pcm];
1975 mix->epcm = NULL;
1976
1977 for (v = 0; v < 4; v++)
1978 mix->send_routing[0][v] =
1979 mix->send_routing[1][v] =
1980 mix->send_routing[2][v] = v;
1981
1982 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
1983 mix->send_volume[0][0] = mix->send_volume[0][1] =
1984 mix->send_volume[1][0] = mix->send_volume[2][1] = 255;
1985
1986 mix->attn[0] = mix->attn[1] = mix->attn[2] = 0xffff;
1987 }
1988
1989 /* initialize the routing and volume table for the multichannel playback stream */
1990 for (pcm = 0; pcm < NUM_EFX_PLAYBACK; pcm++) {
1991 struct snd_emu10k1_pcm_mixer *mix;
1992 int v;
1993
1994 mix = &emu->efx_pcm_mixer[pcm];
1995 mix->epcm = NULL;
1996
1997 mix->send_routing[0][0] = pcm;
1998 mix->send_routing[0][1] = (pcm == 0) ? 1 : 0;
1999 for (v = 0; v < 2; v++)
2000 mix->send_routing[0][2+v] = 13+v;
2001 if (emu->audigy)
2002 for (v = 0; v < 4; v++)
2003 mix->send_routing[0][4+v] = 60+v;
2004
2005 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
2006 mix->send_volume[0][0] = 255;
2007
2008 mix->attn[0] = 0xffff;
2009 }
2010
2011 if (! emu->card_capabilities->ecard) { /* FIXME: APS has these controls? */
2012 /* sb live! and audigy */
2013 if ((kctl = snd_ctl_new1(&snd_emu10k1_spdif_mask_control, emu)) == NULL)
2014 return -ENOMEM;
2015 if (!emu->audigy)
2016 kctl->id.device = emu->pcm_efx->device;
2017 if ((err = snd_ctl_add(card, kctl)))
2018 return err;
2019 if ((kctl = snd_ctl_new1(&snd_emu10k1_spdif_control, emu)) == NULL)
2020 return -ENOMEM;
2021 if (!emu->audigy)
2022 kctl->id.device = emu->pcm_efx->device;
2023 if ((err = snd_ctl_add(card, kctl)))
2024 return err;
2025 }
2026
2027 if (emu->card_capabilities->emu_model) {
2028 ; /* Disable the snd_audigy_spdif_shared_spdif */
2029 } else if (emu->audigy) {
2030 if ((kctl = snd_ctl_new1(&snd_audigy_shared_spdif, emu)) == NULL)
2031 return -ENOMEM;
2032 if ((err = snd_ctl_add(card, kctl)))
2033 return err;
2034 #if 0
2035 if ((kctl = snd_ctl_new1(&snd_audigy_spdif_output_rate, emu)) == NULL)
2036 return -ENOMEM;
2037 if ((err = snd_ctl_add(card, kctl)))
2038 return err;
2039 #endif
2040 } else if (! emu->card_capabilities->ecard) {
2041 /* sb live! */
2042 if ((kctl = snd_ctl_new1(&snd_emu10k1_shared_spdif, emu)) == NULL)
2043 return -ENOMEM;
2044 if ((err = snd_ctl_add(card, kctl)))
2045 return err;
2046 }
2047 if (emu->card_capabilities->ca0151_chip) { /* P16V */
2048 if ((err = snd_p16v_mixer(emu)))
2049 return err;
2050 }
2051
2052 if (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616) {
2053 /* 1616(m) cardbus */
2054 int i;
2055
2056 for (i = 0; i < ARRAY_SIZE(snd_emu1616_output_enum_ctls); i++) {
2057 err = snd_ctl_add(card,
2058 snd_ctl_new1(&snd_emu1616_output_enum_ctls[i],
2059 emu));
2060 if (err < 0)
2061 return err;
2062 }
2063 for (i = 0; i < ARRAY_SIZE(snd_emu1010_input_enum_ctls); i++) {
2064 err = snd_ctl_add(card,
2065 snd_ctl_new1(&snd_emu1010_input_enum_ctls[i],
2066 emu));
2067 if (err < 0)
2068 return err;
2069 }
2070 for (i = 0; i < ARRAY_SIZE(snd_emu1010_adc_pads) - 2; i++) {
2071 err = snd_ctl_add(card,
2072 snd_ctl_new1(&snd_emu1010_adc_pads[i], emu));
2073 if (err < 0)
2074 return err;
2075 }
2076 for (i = 0; i < ARRAY_SIZE(snd_emu1010_dac_pads) - 2; i++) {
2077 err = snd_ctl_add(card,
2078 snd_ctl_new1(&snd_emu1010_dac_pads[i], emu));
2079 if (err < 0)
2080 return err;
2081 }
2082 err = snd_ctl_add(card,
2083 snd_ctl_new1(&snd_emu1010_internal_clock, emu));
2084 if (err < 0)
2085 return err;
2086
2087 } else if (emu->card_capabilities->emu_model) {
2088 /* all other e-mu cards for now */
2089 int i;
2090
2091 for (i = 0; i < ARRAY_SIZE(snd_emu1010_output_enum_ctls); i++) {
2092 err = snd_ctl_add(card,
2093 snd_ctl_new1(&snd_emu1010_output_enum_ctls[i],
2094 emu));
2095 if (err < 0)
2096 return err;
2097 }
2098 for (i = 0; i < ARRAY_SIZE(snd_emu1010_input_enum_ctls); i++) {
2099 err = snd_ctl_add(card,
2100 snd_ctl_new1(&snd_emu1010_input_enum_ctls[i],
2101 emu));
2102 if (err < 0)
2103 return err;
2104 }
2105 for (i = 0; i < ARRAY_SIZE(snd_emu1010_adc_pads); i++) {
2106 err = snd_ctl_add(card,
2107 snd_ctl_new1(&snd_emu1010_adc_pads[i], emu));
2108 if (err < 0)
2109 return err;
2110 }
2111 for (i = 0; i < ARRAY_SIZE(snd_emu1010_dac_pads); i++) {
2112 err = snd_ctl_add(card,
2113 snd_ctl_new1(&snd_emu1010_dac_pads[i], emu));
2114 if (err < 0)
2115 return err;
2116 }
2117 err = snd_ctl_add(card,
2118 snd_ctl_new1(&snd_emu1010_internal_clock, emu));
2119 if (err < 0)
2120 return err;
2121 }
2122
2123 if ( emu->card_capabilities->i2c_adc) {
2124 int i;
2125
2126 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_i2c_capture_source, emu));
2127 if (err < 0)
2128 return err;
2129
2130 for (i = 0; i < ARRAY_SIZE(snd_audigy_i2c_volume_ctls); i++) {
2131 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_i2c_volume_ctls[i], emu));
2132 if (err < 0)
2133 return err;
2134 }
2135 }
2136
2137 if (emu->card_capabilities->ac97_chip && emu->audigy) {
2138 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_capture_boost,
2139 emu));
2140 if (err < 0)
2141 return err;
2142 }
2143
2144 return 0;
2145 }
Linux with added FPC-III support