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