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