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