?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
AT91: Added a generic way to setup AT91 serial ports in Kconfig
[linux-2.6/pdupreez.git] / sound / pci / emu10k1 / emumixer.c
blobf34bbfb705f5f7c870d50012aa17e7c7b57b93ee
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[] __devinitdata = {
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[] __devinitdata = {
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[] __devinitdata = {
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[] __devinitdata = {
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[] __devinitdata = {
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[] __devinitdata = {
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 __devinitdata =
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 __devinitdata =
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 /*
1643 */
1644 static void snd_emu10k1_mixer_free_ac97(struct snd_ac97 *ac97)
1645 {
1646 struct snd_emu10k1 *emu = ac97->private_data;
1647 emu->ac97 = NULL;
1648 }
1649
1650 /*
1651 */
1652 static int remove_ctl(struct snd_card *card, const char *name)
1653 {
1654 struct snd_ctl_elem_id id;
1655 memset(&id, 0, sizeof(id));
1656 strcpy(id.name, name);
1657 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1658 return snd_ctl_remove_id(card, &id);
1659 }
1660
1661 static struct snd_kcontrol *ctl_find(struct snd_card *card, const char *name)
1662 {
1663 struct snd_ctl_elem_id sid;
1664 memset(&sid, 0, sizeof(sid));
1665 strcpy(sid.name, name);
1666 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1667 return snd_ctl_find_id(card, &sid);
1668 }
1669
1670 static int rename_ctl(struct snd_card *card, const char *src, const char *dst)
1671 {
1672 struct snd_kcontrol *kctl = ctl_find(card, src);
1673 if (kctl) {
1674 strcpy(kctl->id.name, dst);
1675 return 0;
1676 }
1677 return -ENOENT;
1678 }
1679
1680 int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu,
1681 int pcm_device, int multi_device)
1682 {
1683 int err, pcm;
1684 struct snd_kcontrol *kctl;
1685 struct snd_card *card = emu->card;
1686 char **c;
1687 static char *emu10k1_remove_ctls[] = {
1688 /* no AC97 mono, surround, center/lfe */
1689 "Master Mono Playback Switch",
1690 "Master Mono Playback Volume",
1691 "PCM Out Path & Mute",
1692 "Mono Output Select",
1693 "Front Playback Switch",
1694 "Front Playback Volume",
1695 "Surround Playback Switch",
1696 "Surround Playback Volume",
1697 "Center Playback Switch",
1698 "Center Playback Volume",
1699 "LFE Playback Switch",
1700 "LFE Playback Volume",
1701 NULL
1702 };
1703 static char *emu10k1_rename_ctls[] = {
1704 "Surround Digital Playback Volume", "Surround Playback Volume",
1705 "Center Digital Playback Volume", "Center Playback Volume",
1706 "LFE Digital Playback Volume", "LFE Playback Volume",
1707 NULL
1708 };
1709 static char *audigy_remove_ctls[] = {
1710 /* Master/PCM controls on ac97 of Audigy has no effect */
1711 /* On the Audigy2 the AC97 playback is piped into
1712 * the Philips ADC for 24bit capture */
1713 "PCM Playback Switch",
1714 "PCM Playback Volume",
1715 "Master Mono Playback Switch",
1716 "Master Mono Playback Volume",
1717 "Master Playback Switch",
1718 "Master Playback Volume",
1719 "PCM Out Path & Mute",
1720 "Mono Output Select",
1721 /* remove unused AC97 capture controls */
1722 "Capture Source",
1723 "Capture Switch",
1724 "Capture Volume",
1725 "Mic Select",
1726 "Video Playback Switch",
1727 "Video Playback Volume",
1728 "Mic Playback Switch",
1729 "Mic Playback Volume",
1730 NULL
1731 };
1732 static char *audigy_rename_ctls[] = {
1733 /* use conventional names */
1734 "Wave Playback Volume", "PCM Playback Volume",
1735 /* "Wave Capture Volume", "PCM Capture Volume", */
1736 "Wave Master Playback Volume", "Master Playback Volume",
1737 "AMic Playback Volume", "Mic Playback Volume",
1738 NULL
1739 };
1740 static char *audigy_rename_ctls_i2c_adc[] = {
1741 //"Analog Mix Capture Volume","OLD Analog Mix Capture Volume",
1742 "Line Capture Volume", "Analog Mix Capture Volume",
1743 "Wave Playback Volume", "OLD PCM Playback Volume",
1744 "Wave Master Playback Volume", "Master Playback Volume",
1745 "AMic Playback Volume", "Old Mic Playback Volume",
1746 "CD Capture Volume", "IEC958 Optical Capture Volume",
1747 NULL
1748 };
1749 static char *audigy_remove_ctls_i2c_adc[] = {
1750 /* On the Audigy2 ZS Notebook
1751 * Capture via WM8775 */
1752 "Mic Capture Volume",
1753 "Analog Mix Capture Volume",
1754 "Aux Capture Volume",
1755 "IEC958 Optical Capture Volume",
1756 NULL
1757 };
1758 static char *audigy_remove_ctls_1361t_adc[] = {
1759 /* On the Audigy2 the AC97 playback is piped into
1760 * the Philips ADC for 24bit capture */
1761 "PCM Playback Switch",
1762 "PCM Playback Volume",
1763 "Master Mono Playback Switch",
1764 "Master Mono Playback Volume",
1765 "Capture Source",
1766 "Capture Switch",
1767 "Capture Volume",
1768 "Mic Capture Volume",
1769 "Headphone Playback Switch",
1770 "Headphone Playback Volume",
1771 "3D Control - Center",
1772 "3D Control - Depth",
1773 "3D Control - Switch",
1774 "Line2 Playback Volume",
1775 "Line2 Capture Volume",
1776 NULL
1777 };
1778 static char *audigy_rename_ctls_1361t_adc[] = {
1779 "Master Playback Switch", "Master Capture Switch",
1780 "Master Playback Volume", "Master Capture Volume",
1781 "Wave Master Playback Volume", "Master Playback Volume",
1782 "PC Speaker Playback Switch", "PC Speaker Capture Switch",
1783 "PC Speaker Playback Volume", "PC Speaker Capture Volume",
1784 "Phone Playback Switch", "Phone Capture Switch",
1785 "Phone Playback Volume", "Phone Capture Volume",
1786 "Mic Playback Switch", "Mic Capture Switch",
1787 "Mic Playback Volume", "Mic Capture Volume",
1788 "Line Playback Switch", "Line Capture Switch",
1789 "Line Playback Volume", "Line Capture Volume",
1790 "CD Playback Switch", "CD Capture Switch",
1791 "CD Playback Volume", "CD Capture Volume",
1792 "Aux Playback Switch", "Aux Capture Switch",
1793 "Aux Playback Volume", "Aux Capture Volume",
1794 "Video Playback Switch", "Video Capture Switch",
1795 "Video Playback Volume", "Video Capture Volume",
1796
1797 NULL
1798 };
1799
1800 if (emu->card_capabilities->ac97_chip) {
1801 struct snd_ac97_bus *pbus;
1802 struct snd_ac97_template ac97;
1803 static struct snd_ac97_bus_ops ops = {
1804 .write = snd_emu10k1_ac97_write,
1805 .read = snd_emu10k1_ac97_read,
1806 };
1807
1808 if ((err = snd_ac97_bus(emu->card, 0, &ops, NULL, &pbus)) < 0)
1809 return err;
1810 pbus->no_vra = 1; /* we don't need VRA */
1811
1812 memset(&ac97, 0, sizeof(ac97));
1813 ac97.private_data = emu;
1814 ac97.private_free = snd_emu10k1_mixer_free_ac97;
1815 ac97.scaps = AC97_SCAP_NO_SPDIF;
1816 if ((err = snd_ac97_mixer(pbus, &ac97, &emu->ac97)) < 0) {
1817 if (emu->card_capabilities->ac97_chip == 1)
1818 return err;
1819 snd_printd(KERN_INFO "emu10k1: AC97 is optional on this board\n");
1820 snd_printd(KERN_INFO" Proceeding without ac97 mixers...\n");
1821 snd_device_free(emu->card, pbus);
1822 goto no_ac97; /* FIXME: get rid of ugly gotos.. */
1823 }
1824 if (emu->audigy) {
1825 /* set master volume to 0 dB */
1826 snd_ac97_write_cache(emu->ac97, AC97_MASTER, 0x0000);
1827 /* set capture source to mic */
1828 snd_ac97_write_cache(emu->ac97, AC97_REC_SEL, 0x0000);
1829 if (emu->card_capabilities->adc_1361t)
1830 c = audigy_remove_ctls_1361t_adc;
1831 else
1832 c = audigy_remove_ctls;
1833 } else {
1834 /*
1835 * Credits for cards based on STAC9758:
1836 * James Courtier-Dutton <James@superbug.demon.co.uk>
1837 * Voluspa <voluspa@comhem.se>
1838 */
1839 if (emu->ac97->id == AC97_ID_STAC9758) {
1840 emu->rear_ac97 = 1;
1841 snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_CNTR|AC97SLOT_LFE|AC97SLOT_REAR_LEFT|AC97SLOT_REAR_RIGHT);
1842 snd_ac97_write_cache(emu->ac97, AC97_HEADPHONE, 0x0202);
1843 }
1844 /* remove unused AC97 controls */
1845 snd_ac97_write_cache(emu->ac97, AC97_SURROUND_MASTER, 0x0202);
1846 snd_ac97_write_cache(emu->ac97, AC97_CENTER_LFE_MASTER, 0x0202);
1847 c = emu10k1_remove_ctls;
1848 }
1849 for (; *c; c++)
1850 remove_ctl(card, *c);
1851 } else if (emu->card_capabilities->i2c_adc) {
1852 c = audigy_remove_ctls_i2c_adc;
1853 for (; *c; c++)
1854 remove_ctl(card, *c);
1855 } else {
1856 no_ac97:
1857 if (emu->card_capabilities->ecard)
1858 strcpy(emu->card->mixername, "EMU APS");
1859 else if (emu->audigy)
1860 strcpy(emu->card->mixername, "SB Audigy");
1861 else
1862 strcpy(emu->card->mixername, "Emu10k1");
1863 }
1864
1865 if (emu->audigy)
1866 if (emu->card_capabilities->adc_1361t)
1867 c = audigy_rename_ctls_1361t_adc;
1868 else if (emu->card_capabilities->i2c_adc)
1869 c = audigy_rename_ctls_i2c_adc;
1870 else
1871 c = audigy_rename_ctls;
1872 else
1873 c = emu10k1_rename_ctls;
1874 for (; *c; c += 2)
1875 rename_ctl(card, c[0], c[1]);
1876
1877 if (emu->card_capabilities->subsystem == 0x20071102) { /* Audigy 4 Pro */
1878 rename_ctl(card, "Line2 Capture Volume", "Line1/Mic Capture Volume");
1879 rename_ctl(card, "Analog Mix Capture Volume", "Line2 Capture Volume");
1880 rename_ctl(card, "Aux2 Capture Volume", "Line3 Capture Volume");
1881 rename_ctl(card, "Mic Capture Volume", "Unknown1 Capture Volume");
1882 remove_ctl(card, "Headphone Playback Switch");
1883 remove_ctl(card, "Headphone Playback Volume");
1884 remove_ctl(card, "3D Control - Center");
1885 remove_ctl(card, "3D Control - Depth");
1886 remove_ctl(card, "3D Control - Switch");
1887 }
1888 if ((kctl = emu->ctl_send_routing = snd_ctl_new1(&snd_emu10k1_send_routing_control, emu)) == NULL)
1889 return -ENOMEM;
1890 kctl->id.device = pcm_device;
1891 if ((err = snd_ctl_add(card, kctl)))
1892 return err;
1893 if ((kctl = emu->ctl_send_volume = snd_ctl_new1(&snd_emu10k1_send_volume_control, emu)) == NULL)
1894 return -ENOMEM;
1895 kctl->id.device = pcm_device;
1896 if ((err = snd_ctl_add(card, kctl)))
1897 return err;
1898 if ((kctl = emu->ctl_attn = snd_ctl_new1(&snd_emu10k1_attn_control, emu)) == NULL)
1899 return -ENOMEM;
1900 kctl->id.device = pcm_device;
1901 if ((err = snd_ctl_add(card, kctl)))
1902 return err;
1903
1904 if ((kctl = emu->ctl_efx_send_routing = snd_ctl_new1(&snd_emu10k1_efx_send_routing_control, emu)) == NULL)
1905 return -ENOMEM;
1906 kctl->id.device = multi_device;
1907 if ((err = snd_ctl_add(card, kctl)))
1908 return err;
1909
1910 if ((kctl = emu->ctl_efx_send_volume = snd_ctl_new1(&snd_emu10k1_efx_send_volume_control, emu)) == NULL)
1911 return -ENOMEM;
1912 kctl->id.device = multi_device;
1913 if ((err = snd_ctl_add(card, kctl)))
1914 return err;
1915
1916 if ((kctl = emu->ctl_efx_attn = snd_ctl_new1(&snd_emu10k1_efx_attn_control, emu)) == NULL)
1917 return -ENOMEM;
1918 kctl->id.device = multi_device;
1919 if ((err = snd_ctl_add(card, kctl)))
1920 return err;
1921
1922 /* initialize the routing and volume table for each pcm playback stream */
1923 for (pcm = 0; pcm < 32; pcm++) {
1924 struct snd_emu10k1_pcm_mixer *mix;
1925 int v;
1926
1927 mix = &emu->pcm_mixer[pcm];
1928 mix->epcm = NULL;
1929
1930 for (v = 0; v < 4; v++)
1931 mix->send_routing[0][v] =
1932 mix->send_routing[1][v] =
1933 mix->send_routing[2][v] = v;
1934
1935 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
1936 mix->send_volume[0][0] = mix->send_volume[0][1] =
1937 mix->send_volume[1][0] = mix->send_volume[2][1] = 255;
1938
1939 mix->attn[0] = mix->attn[1] = mix->attn[2] = 0xffff;
1940 }
1941
1942 /* initialize the routing and volume table for the multichannel playback stream */
1943 for (pcm = 0; pcm < NUM_EFX_PLAYBACK; pcm++) {
1944 struct snd_emu10k1_pcm_mixer *mix;
1945 int v;
1946
1947 mix = &emu->efx_pcm_mixer[pcm];
1948 mix->epcm = NULL;
1949
1950 mix->send_routing[0][0] = pcm;
1951 mix->send_routing[0][1] = (pcm == 0) ? 1 : 0;
1952 for (v = 0; v < 2; v++)
1953 mix->send_routing[0][2+v] = 13+v;
1954 if (emu->audigy)
1955 for (v = 0; v < 4; v++)
1956 mix->send_routing[0][4+v] = 60+v;
1957
1958 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
1959 mix->send_volume[0][0] = 255;
1960
1961 mix->attn[0] = 0xffff;
1962 }
1963
1964 if (! emu->card_capabilities->ecard) { /* FIXME: APS has these controls? */
1965 /* sb live! and audigy */
1966 if ((kctl = snd_ctl_new1(&snd_emu10k1_spdif_mask_control, emu)) == NULL)
1967 return -ENOMEM;
1968 if (!emu->audigy)
1969 kctl->id.device = emu->pcm_efx->device;
1970 if ((err = snd_ctl_add(card, kctl)))
1971 return err;
1972 if ((kctl = snd_ctl_new1(&snd_emu10k1_spdif_control, emu)) == NULL)
1973 return -ENOMEM;
1974 if (!emu->audigy)
1975 kctl->id.device = emu->pcm_efx->device;
1976 if ((err = snd_ctl_add(card, kctl)))
1977 return err;
1978 }
1979
1980 if (emu->card_capabilities->emu_model) {
1981 ; /* Disable the snd_audigy_spdif_shared_spdif */
1982 } else if (emu->audigy) {
1983 if ((kctl = snd_ctl_new1(&snd_audigy_shared_spdif, emu)) == NULL)
1984 return -ENOMEM;
1985 if ((err = snd_ctl_add(card, kctl)))
1986 return err;
1987 #if 0
1988 if ((kctl = snd_ctl_new1(&snd_audigy_spdif_output_rate, emu)) == NULL)
1989 return -ENOMEM;
1990 if ((err = snd_ctl_add(card, kctl)))
1991 return err;
1992 #endif
1993 } else if (! emu->card_capabilities->ecard) {
1994 /* sb live! */
1995 if ((kctl = snd_ctl_new1(&snd_emu10k1_shared_spdif, emu)) == NULL)
1996 return -ENOMEM;
1997 if ((err = snd_ctl_add(card, kctl)))
1998 return err;
1999 }
2000 if (emu->card_capabilities->ca0151_chip) { /* P16V */
2001 if ((err = snd_p16v_mixer(emu)))
2002 return err;
2003 }
2004
2005 if (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616) {
2006 /* 1616(m) cardbus */
2007 int i;
2008
2009 for (i = 0; i < ARRAY_SIZE(snd_emu1616_output_enum_ctls); i++) {
2010 err = snd_ctl_add(card,
2011 snd_ctl_new1(&snd_emu1616_output_enum_ctls[i],
2012 emu));
2013 if (err < 0)
2014 return err;
2015 }
2016 for (i = 0; i < ARRAY_SIZE(snd_emu1010_input_enum_ctls); i++) {
2017 err = snd_ctl_add(card,
2018 snd_ctl_new1(&snd_emu1010_input_enum_ctls[i],
2019 emu));
2020 if (err < 0)
2021 return err;
2022 }
2023 for (i = 0; i < ARRAY_SIZE(snd_emu1010_adc_pads) - 2; i++) {
2024 err = snd_ctl_add(card,
2025 snd_ctl_new1(&snd_emu1010_adc_pads[i], emu));
2026 if (err < 0)
2027 return err;
2028 }
2029 for (i = 0; i < ARRAY_SIZE(snd_emu1010_dac_pads) - 2; i++) {
2030 err = snd_ctl_add(card,
2031 snd_ctl_new1(&snd_emu1010_dac_pads[i], emu));
2032 if (err < 0)
2033 return err;
2034 }
2035 err = snd_ctl_add(card,
2036 snd_ctl_new1(&snd_emu1010_internal_clock, emu));
2037 if (err < 0)
2038 return err;
2039
2040 } else if (emu->card_capabilities->emu_model) {
2041 /* all other e-mu cards for now */
2042 int i;
2043
2044 for (i = 0; i < ARRAY_SIZE(snd_emu1010_output_enum_ctls); i++) {
2045 err = snd_ctl_add(card,
2046 snd_ctl_new1(&snd_emu1010_output_enum_ctls[i],
2047 emu));
2048 if (err < 0)
2049 return err;
2050 }
2051 for (i = 0; i < ARRAY_SIZE(snd_emu1010_input_enum_ctls); i++) {
2052 err = snd_ctl_add(card,
2053 snd_ctl_new1(&snd_emu1010_input_enum_ctls[i],
2054 emu));
2055 if (err < 0)
2056 return err;
2057 }
2058 for (i = 0; i < ARRAY_SIZE(snd_emu1010_adc_pads); i++) {
2059 err = snd_ctl_add(card,
2060 snd_ctl_new1(&snd_emu1010_adc_pads[i], emu));
2061 if (err < 0)
2062 return err;
2063 }
2064 for (i = 0; i < ARRAY_SIZE(snd_emu1010_dac_pads); i++) {
2065 err = snd_ctl_add(card,
2066 snd_ctl_new1(&snd_emu1010_dac_pads[i], emu));
2067 if (err < 0)
2068 return err;
2069 }
2070 err = snd_ctl_add(card,
2071 snd_ctl_new1(&snd_emu1010_internal_clock, emu));
2072 if (err < 0)
2073 return err;
2074 }
2075
2076 if ( emu->card_capabilities->i2c_adc) {
2077 int i;
2078
2079 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_i2c_capture_source, emu));
2080 if (err < 0)
2081 return err;
2082
2083 for (i = 0; i < ARRAY_SIZE(snd_audigy_i2c_volume_ctls); i++) {
2084 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_i2c_volume_ctls[i], emu));
2085 if (err < 0)
2086 return err;
2087 }
2088 }
2089
2090 return 0;
2091 }
Linux branches of Pieter du Preez