xref: /openbmc/linux/sound/pci/emu10k1/emumixer.c (revision aa9e9180)
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