source: GPL/trunk/alsa-kernel/pci/emu10k1/emumixer.c

Last change on this file was 777, checked in by David Azarewicz, 7 months ago

Merge from uniaud32-exp branch
File size: 72.0 KB
Line 
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
24static const DECLARE_TLV_DB_SCALE(snd_audigy_db_scale2, -10350, 50, 1); /* WM8775 gain scale */
25
26
27static 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
44static 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
51static 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
67static 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
153static const char * const emu1010_src_texts[] = {
154 EMU1010_COMMON_TEXTS,
155 DSP_TEXTS,
156};
157
158static 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
184static const char * const emu1010b_src_texts[] = {
185 EMU1010b_COMMON_TEXTS,
186 DSP_TEXTS,
187};
188
189static 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
213static const char * const emu1616_src_texts[] = {
214 EMU1616_COMMON_TEXTS,
215 DSP_TEXTS,
216};
217
218static 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
236static const char * const emu0404_src_texts[] = {
237 EMU0404_COMMON_TEXTS,
238 DSP_TEXTS,
239};
240
241static 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
259static 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
272static 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
285static 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
301static 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
313static 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
325static 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
340static 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
350static 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
360static 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
373static 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
379static 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
385static 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
397static 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
424static 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
451static 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
481static 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
500struct 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
513static 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
576static unsigned emu1010_idx(struct snd_emu10k1 *emu)
577{
578 return emu->card_capabilities->emu_model - 1;
579}
580
581static 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
591static 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
601static 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
614static 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
623static 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
633static 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
647static 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_fpga_lock(emu);
665 snd_emu1010_output_source_apply(emu, channel, val);
666 snd_emu1010_fpga_unlock(emu);
667 }
668 return change;
669}
670
671static const struct snd_kcontrol_new emu1010_output_source_ctl = {
672 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
673 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
674 .info = snd_emu1010_input_output_source_info,
675 .get = snd_emu1010_output_source_get,
676 .put = snd_emu1010_output_source_put
677};
678
679static int snd_emu1010_input_source_get(struct snd_kcontrol *kcontrol,
680 struct snd_ctl_elem_value *ucontrol)
681{
682 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
683 const struct snd_emu1010_routing_info *emu_ri =
684 &emu1010_routing_info[emu1010_idx(emu)];
685 unsigned channel = kcontrol->private_value;
686
687 if (channel >= emu_ri->n_ins)
688 return -EINVAL;
689 ucontrol->value.enumerated.item[0] = emu->emu1010.input_source[channel];
690 return 0;
691}
692
693static int snd_emu1010_input_source_put(struct snd_kcontrol *kcontrol,
694 struct snd_ctl_elem_value *ucontrol)
695{
696 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
697 const struct snd_emu1010_routing_info *emu_ri =
698 &emu1010_routing_info[emu1010_idx(emu)];
699 unsigned val = ucontrol->value.enumerated.item[0];
700 unsigned channel = kcontrol->private_value;
701 int change;
702
703 if (val >= emu_ri->n_srcs)
704 return -EINVAL;
705 if (channel >= emu_ri->n_ins)
706 return -EINVAL;
707 change = (emu->emu1010.input_source[channel] != val);
708 if (change) {
709 emu->emu1010.input_source[channel] = val;
710 snd_emu1010_fpga_lock(emu);
711 snd_emu1010_input_source_apply(emu, channel, val);
712 snd_emu1010_fpga_unlock(emu);
713 }
714 return change;
715}
716
717static const struct snd_kcontrol_new emu1010_input_source_ctl = {
718 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
719 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
720 .info = snd_emu1010_input_output_source_info,
721 .get = snd_emu1010_input_source_get,
722 .put = snd_emu1010_input_source_put
723};
724
725static int add_emu1010_source_mixers(struct snd_emu10k1 *emu)
726{
727 const struct snd_emu1010_routing_info *emu_ri =
728 &emu1010_routing_info[emu1010_idx(emu)];
729 int err;
730
731 err = add_ctls(emu, &emu1010_output_source_ctl,
732 emu_ri->out_texts, emu_ri->n_outs);
733 if (err < 0)
734 return err;
735 err = add_ctls(emu, &emu1010_input_source_ctl,
736 emu1010_input_texts, emu_ri->n_ins);
737 return err;
738}
739
740
741static const char * const snd_emu1010_adc_pads[] = {
742 "ADC1 14dB PAD 0202 Capture Switch",
743 "ADC1 14dB PAD Audio Dock Capture Switch",
744 "ADC2 14dB PAD Audio Dock Capture Switch",
745 "ADC3 14dB PAD Audio Dock Capture Switch",
746};
747
748static const unsigned short snd_emu1010_adc_pad_regs[] = {
749 EMU_HANA_0202_ADC_PAD1,
750 EMU_HANA_DOCK_ADC_PAD1,
751 EMU_HANA_DOCK_ADC_PAD2,
752 EMU_HANA_DOCK_ADC_PAD3,
753};
754
755#define snd_emu1010_adc_pads_info snd_ctl_boolean_mono_info
756
757static int snd_emu1010_adc_pads_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
758{
759 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
760 unsigned int mask = snd_emu1010_adc_pad_regs[kcontrol->private_value];
761
762 ucontrol->value.integer.value[0] = (emu->emu1010.adc_pads & mask) ? 1 : 0;
763 return 0;
764}
765
766static int snd_emu1010_adc_pads_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
767{
768 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
769 unsigned int mask = snd_emu1010_adc_pad_regs[kcontrol->private_value];
770 unsigned int val, cache;
771 int change;
772
773 val = ucontrol->value.integer.value[0];
774 cache = emu->emu1010.adc_pads;
775 if (val == 1)
776 cache = cache | mask;
777 else
778 cache = cache & ~mask;
779 change = (cache != emu->emu1010.adc_pads);
780 if (change) {
781 snd_emu1010_fpga_write_lock(emu, EMU_HANA_ADC_PADS, cache );
782 emu->emu1010.adc_pads = cache;
783 }
784
785 return change;
786}
787
788static const struct snd_kcontrol_new emu1010_adc_pads_ctl = {
789 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
790 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
791 .info = snd_emu1010_adc_pads_info,
792 .get = snd_emu1010_adc_pads_get,
793 .put = snd_emu1010_adc_pads_put
794};
795
796
797static const char * const snd_emu1010_dac_pads[] = {
798 "DAC1 0202 14dB PAD Playback Switch",
799 "DAC1 Audio Dock 14dB PAD Playback Switch",
800 "DAC2 Audio Dock 14dB PAD Playback Switch",
801 "DAC3 Audio Dock 14dB PAD Playback Switch",
802 "DAC4 Audio Dock 14dB PAD Playback Switch",
803};
804
805static const unsigned short snd_emu1010_dac_regs[] = {
806 EMU_HANA_0202_DAC_PAD1,
807 EMU_HANA_DOCK_DAC_PAD1,
808 EMU_HANA_DOCK_DAC_PAD2,
809 EMU_HANA_DOCK_DAC_PAD3,
810 EMU_HANA_DOCK_DAC_PAD4,
811};
812
813#define snd_emu1010_dac_pads_info snd_ctl_boolean_mono_info
814
815static int snd_emu1010_dac_pads_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
816{
817 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
818 unsigned int mask = snd_emu1010_dac_regs[kcontrol->private_value];
819
820 ucontrol->value.integer.value[0] = (emu->emu1010.dac_pads & mask) ? 1 : 0;
821 return 0;
822}
823
824static int snd_emu1010_dac_pads_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
825{
826 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
827 unsigned int mask = snd_emu1010_dac_regs[kcontrol->private_value];
828 unsigned int val, cache;
829 int change;
830
831 val = ucontrol->value.integer.value[0];
832 cache = emu->emu1010.dac_pads;
833 if (val == 1)
834 cache = cache | mask;
835 else
836 cache = cache & ~mask;
837 change = (cache != emu->emu1010.dac_pads);
838 if (change) {
839 snd_emu1010_fpga_write_lock(emu, EMU_HANA_DAC_PADS, cache );
840 emu->emu1010.dac_pads = cache;
841 }
842
843 return change;
844}
845
846static const struct snd_kcontrol_new emu1010_dac_pads_ctl = {
847 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
848 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
849 .info = snd_emu1010_dac_pads_info,
850 .get = snd_emu1010_dac_pads_get,
851 .put = snd_emu1010_dac_pads_put
852};
853
854
855struct snd_emu1010_pads_info {
856 const char * const *adc_ctls, * const *dac_ctls;
857 unsigned n_adc_ctls, n_dac_ctls;
858};
859
860static const struct snd_emu1010_pads_info emu1010_pads_info[] = {
861 {
862 /* rev1 1010 */
863 .adc_ctls = snd_emu1010_adc_pads,
864 .n_adc_ctls = ARRAY_SIZE(snd_emu1010_adc_pads),
865 .dac_ctls = snd_emu1010_dac_pads,
866 .n_dac_ctls = ARRAY_SIZE(snd_emu1010_dac_pads),
867 },
868 {
869 /* rev2 1010 */
870 .adc_ctls = snd_emu1010_adc_pads,
871 .n_adc_ctls = ARRAY_SIZE(snd_emu1010_adc_pads) - 1,
872 .dac_ctls = snd_emu1010_dac_pads,
873 .n_dac_ctls = ARRAY_SIZE(snd_emu1010_dac_pads) - 1,
874 },
875 {
876 /* 1616(m) cardbus */
877 .adc_ctls = snd_emu1010_adc_pads + 1,
878 .n_adc_ctls = ARRAY_SIZE(snd_emu1010_adc_pads) - 2,
879 .dac_ctls = snd_emu1010_dac_pads + 1,
880 .n_dac_ctls = ARRAY_SIZE(snd_emu1010_dac_pads) - 2,
881 },
882 {
883 /* 0404 */
884 .adc_ctls = NULL,
885 .n_adc_ctls = 0,
886 .dac_ctls = NULL,
887 .n_dac_ctls = 0,
888 },
889};
890
891static const char * const emu1010_clock_texts[] = {
892 "44100", "48000", "SPDIF", "ADAT", "Dock", "BNC"
893};
894
895static const u8 emu1010_clock_vals[] = {
896 EMU_HANA_WCLOCK_INT_44_1K,
897 EMU_HANA_WCLOCK_INT_48K,
898 EMU_HANA_WCLOCK_HANA_SPDIF_IN,
899 EMU_HANA_WCLOCK_HANA_ADAT_IN,
900 EMU_HANA_WCLOCK_2ND_HANA,
901 EMU_HANA_WCLOCK_SYNC_BNC,
902};
903
904static const char * const emu0404_clock_texts[] = {
905 "44100", "48000", "SPDIF", "BNC"
906};
907
908static const u8 emu0404_clock_vals[] = {
909 EMU_HANA_WCLOCK_INT_44_1K,
910 EMU_HANA_WCLOCK_INT_48K,
911 EMU_HANA_WCLOCK_HANA_SPDIF_IN,
912 EMU_HANA_WCLOCK_SYNC_BNC,
913};
914
915struct snd_emu1010_clock_info {
916 const char * const *texts;
917 const u8 *vals;
918 unsigned num;
919};
920
921static const struct snd_emu1010_clock_info emu1010_clock_info[] = {
922 {
923 // rev1 1010
924 .texts = emu1010_clock_texts,
925 .vals = emu1010_clock_vals,
926 .num = ARRAY_SIZE(emu1010_clock_vals),
927 },
928 {
929 // rev2 1010
930 .texts = emu1010_clock_texts,
931 .vals = emu1010_clock_vals,
932 .num = ARRAY_SIZE(emu1010_clock_vals) - 1,
933 },
934 {
935 // 1616(m) CardBus
936 .texts = emu1010_clock_texts,
937 // TODO: determine what is actually available.
938 // Pedantically, *every* source comes from the 2nd FPGA, as the
939 // card itself has no own (digital) audio ports. The user manual
940 // claims that ADAT and S/PDIF clock sources are separate, which
941 // can mean two things: either E-MU mapped the dock's sources to
942 // the primary ones, or they determine the meaning of the "Dock"
943 // source depending on how the ports are actually configured
944 // (which the 2nd FPGA must be doing anyway).
945 .vals = emu1010_clock_vals,
946 .num = ARRAY_SIZE(emu1010_clock_vals),
947 },
948 {
949 // 0404
950 .texts = emu0404_clock_texts,
951 .vals = emu0404_clock_vals,
952 .num = ARRAY_SIZE(emu0404_clock_vals),
953 },
954};
955
956static int snd_emu1010_clock_source_info(struct snd_kcontrol *kcontrol,
957 struct snd_ctl_elem_info *uinfo)
958{
959 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
960 const struct snd_emu1010_clock_info *emu_ci =
961 &emu1010_clock_info[emu1010_idx(emu)];
962
963 return snd_ctl_enum_info(uinfo, 1, emu_ci->num, emu_ci->texts);
964}
965
966static int snd_emu1010_clock_source_get(struct snd_kcontrol *kcontrol,
967 struct snd_ctl_elem_value *ucontrol)
968{
969 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
970
971 ucontrol->value.enumerated.item[0] = emu->emu1010.clock_source;
972 return 0;
973}
974
975static int snd_emu1010_clock_source_put(struct snd_kcontrol *kcontrol,
976 struct snd_ctl_elem_value *ucontrol)
977{
978 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
979 const struct snd_emu1010_clock_info *emu_ci =
980 &emu1010_clock_info[emu1010_idx(emu)];
981 unsigned int val;
982 int change = 0;
983
984 val = ucontrol->value.enumerated.item[0] ;
985 if (val >= emu_ci->num)
986 return -EINVAL;
987 snd_emu1010_fpga_lock(emu);
988 spin_lock_irq(&emu->reg_lock);
989 change = (emu->emu1010.clock_source != val);
990 if (change) {
991 emu->emu1010.clock_source = val;
992 emu->emu1010.wclock = emu_ci->vals[val];
993 snd_emu1010_update_clock(emu);
994
995 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_MUTE);
996 snd_emu1010_fpga_write(emu, EMU_HANA_WCLOCK, emu->emu1010.wclock);
997 spin_unlock_irq(&emu->reg_lock);
998
999 msleep(10); // Allow DLL to settle
1000 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE);
1001 } else {
1002 spin_unlock_irq(&emu->reg_lock);
1003 }
1004 snd_emu1010_fpga_unlock(emu);
1005 return change;
1006}
1007
1008static const struct snd_kcontrol_new snd_emu1010_clock_source =
1009{
1010 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1011 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1012 .name = "Clock Source",
1013 .count = 1,
1014 .info = snd_emu1010_clock_source_info,
1015 .get = snd_emu1010_clock_source_get,
1016 .put = snd_emu1010_clock_source_put
1017};
1018
1019static int snd_emu1010_clock_fallback_info(struct snd_kcontrol *kcontrol,
1020 struct snd_ctl_elem_info *uinfo)
1021{
1022 static const char * const texts[2] = {
1023 "44100", "48000"
1024 };
1025
1026 return snd_ctl_enum_info(uinfo, 1, 2, texts);
1027}
1028
1029static int snd_emu1010_clock_fallback_get(struct snd_kcontrol *kcontrol,
1030 struct snd_ctl_elem_value *ucontrol)
1031{
1032 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1033
1034 ucontrol->value.enumerated.item[0] = emu->emu1010.clock_fallback;
1035 return 0;
1036}
1037
1038static int snd_emu1010_clock_fallback_put(struct snd_kcontrol *kcontrol,
1039 struct snd_ctl_elem_value *ucontrol)
1040{
1041 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1042 unsigned int val = ucontrol->value.enumerated.item[0];
1043 int change;
1044
1045 if (val >= 2)
1046 return -EINVAL;
1047 change = (emu->emu1010.clock_fallback != val);
1048 if (change) {
1049 emu->emu1010.clock_fallback = val;
1050 snd_emu1010_fpga_write_lock(emu, EMU_HANA_DEFCLOCK, 1 - val);
1051 }
1052 return change;
1053}
1054
1055static const struct snd_kcontrol_new snd_emu1010_clock_fallback =
1056{
1057 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1058 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1059 .name = "Clock Fallback",
1060 .count = 1,
1061 .info = snd_emu1010_clock_fallback_info,
1062 .get = snd_emu1010_clock_fallback_get,
1063 .put = snd_emu1010_clock_fallback_put
1064};
1065
1066static int snd_emu1010_optical_out_info(struct snd_kcontrol *kcontrol,
1067 struct snd_ctl_elem_info *uinfo)
1068{
1069 static const char * const texts[2] = {
1070 "SPDIF", "ADAT"
1071 };
1072
1073 return snd_ctl_enum_info(uinfo, 1, 2, texts);
1074}
1075
1076static int snd_emu1010_optical_out_get(struct snd_kcontrol *kcontrol,
1077 struct snd_ctl_elem_value *ucontrol)
1078{
1079 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1080
1081 ucontrol->value.enumerated.item[0] = emu->emu1010.optical_out;
1082 return 0;
1083}
1084
1085static int snd_emu1010_optical_out_put(struct snd_kcontrol *kcontrol,
1086 struct snd_ctl_elem_value *ucontrol)
1087{
1088 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1089 unsigned int val;
1090 u32 tmp;
1091 int change = 0;
1092
1093 val = ucontrol->value.enumerated.item[0];
1094 /* Limit: uinfo->value.enumerated.items = 2; */
1095 if (val >= 2)
1096 return -EINVAL;
1097 change = (emu->emu1010.optical_out != val);
1098 if (change) {
1099 emu->emu1010.optical_out = val;
1100 tmp = (emu->emu1010.optical_in ? EMU_HANA_OPTICAL_IN_ADAT : EMU_HANA_OPTICAL_IN_SPDIF) |
1101 (emu->emu1010.optical_out ? EMU_HANA_OPTICAL_OUT_ADAT : EMU_HANA_OPTICAL_OUT_SPDIF);
1102 snd_emu1010_fpga_write_lock(emu, EMU_HANA_OPTICAL_TYPE, tmp);
1103 }
1104 return change;
1105}
1106
1107static const struct snd_kcontrol_new snd_emu1010_optical_out = {
1108 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1109 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1110 .name = "Optical Output Mode",
1111 .count = 1,
1112 .info = snd_emu1010_optical_out_info,
1113 .get = snd_emu1010_optical_out_get,
1114 .put = snd_emu1010_optical_out_put
1115};
1116
1117static int snd_emu1010_optical_in_info(struct snd_kcontrol *kcontrol,
1118 struct snd_ctl_elem_info *uinfo)
1119{
1120 static const char * const texts[2] = {
1121 "SPDIF", "ADAT"
1122 };
1123
1124 return snd_ctl_enum_info(uinfo, 1, 2, texts);
1125}
1126
1127static int snd_emu1010_optical_in_get(struct snd_kcontrol *kcontrol,
1128 struct snd_ctl_elem_value *ucontrol)
1129{
1130 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1131
1132 ucontrol->value.enumerated.item[0] = emu->emu1010.optical_in;
1133 return 0;
1134}
1135
1136static int snd_emu1010_optical_in_put(struct snd_kcontrol *kcontrol,
1137 struct snd_ctl_elem_value *ucontrol)
1138{
1139 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1140 unsigned int val;
1141 u32 tmp;
1142 int change = 0;
1143
1144 val = ucontrol->value.enumerated.item[0];
1145 /* Limit: uinfo->value.enumerated.items = 2; */
1146 if (val >= 2)
1147 return -EINVAL;
1148 change = (emu->emu1010.optical_in != val);
1149 if (change) {
1150 emu->emu1010.optical_in = val;
1151 tmp = (emu->emu1010.optical_in ? EMU_HANA_OPTICAL_IN_ADAT : EMU_HANA_OPTICAL_IN_SPDIF) |
1152 (emu->emu1010.optical_out ? EMU_HANA_OPTICAL_OUT_ADAT : EMU_HANA_OPTICAL_OUT_SPDIF);
1153 snd_emu1010_fpga_write_lock(emu, EMU_HANA_OPTICAL_TYPE, tmp);
1154 }
1155 return change;
1156}
1157
1158static const struct snd_kcontrol_new snd_emu1010_optical_in = {
1159 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1160 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1161 .name = "Optical Input Mode",
1162 .count = 1,
1163 .info = snd_emu1010_optical_in_info,
1164 .get = snd_emu1010_optical_in_get,
1165 .put = snd_emu1010_optical_in_put
1166};
1167
1168static int snd_audigy_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
1169 struct snd_ctl_elem_info *uinfo)
1170{
1171#if 0
1172 static const char * const texts[4] = {
1173 "Unknown1", "Unknown2", "Mic", "Line"
1174 };
1175#endif
1176 static const char * const texts[2] = {
1177 "Mic", "Line"
1178 };
1179
1180 return snd_ctl_enum_info(uinfo, 1, 2, texts);
1181}
1182
1183static int snd_audigy_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
1184 struct snd_ctl_elem_value *ucontrol)
1185{
1186 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1187
1188 ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
1189 return 0;
1190}
1191
1192static int snd_audigy_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
1193 struct snd_ctl_elem_value *ucontrol)
1194{
1195 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1196 unsigned int source_id;
1197 unsigned int ngain, ogain;
1198 u16 gpio;
1199 int change = 0;
1200 u32 source;
1201 /* If the capture source has changed,
1202 * update the capture volume from the cached value
1203 * for the particular source.
1204 */
1205 source_id = ucontrol->value.enumerated.item[0];
1206 /* Limit: uinfo->value.enumerated.items = 2; */
1207 /* emu->i2c_capture_volume */
1208 if (source_id >= 2)
1209 return -EINVAL;
1210 change = (emu->i2c_capture_source != source_id);
1211 if (change) {
1212 snd_emu10k1_i2c_write(emu, ADC_MUX, 0); /* Mute input */
1213 spin_lock_irq(&emu->emu_lock);
1214 gpio = inw(emu->port + A_IOCFG);
1215 if (source_id==0)
1216 outw(gpio | 0x4, emu->port + A_IOCFG);
1217 else
1218 outw(gpio & ~0x4, emu->port + A_IOCFG);
1219 spin_unlock_irq(&emu->emu_lock);
1220
1221 ngain = emu->i2c_capture_volume[source_id][0]; /* Left */
1222 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
1223 if (ngain != ogain)
1224 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff));
1225 ngain = emu->i2c_capture_volume[source_id][1]; /* Right */
1226 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Right */
1227 if (ngain != ogain)
1228 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
1229
1230 source = 1 << (source_id + 2);
1231 snd_emu10k1_i2c_write(emu, ADC_MUX, source); /* Set source */
1232 emu->i2c_capture_source = source_id;
1233 }
1234 return change;
1235}
1236
1237static const struct snd_kcontrol_new snd_audigy_i2c_capture_source =
1238{
1239 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1240 .name = "Capture Source",
1241 .info = snd_audigy_i2c_capture_source_info,
1242 .get = snd_audigy_i2c_capture_source_get,
1243 .put = snd_audigy_i2c_capture_source_put
1244};
1245
1246static int snd_audigy_i2c_volume_info(struct snd_kcontrol *kcontrol,
1247 struct snd_ctl_elem_info *uinfo)
1248{
1249 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1250 uinfo->count = 2;
1251 uinfo->value.integer.min = 0;
1252 uinfo->value.integer.max = 255;
1253 return 0;
1254}
1255
1256static int snd_audigy_i2c_volume_get(struct snd_kcontrol *kcontrol,
1257 struct snd_ctl_elem_value *ucontrol)
1258{
1259 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1260 unsigned int source_id;
1261
1262 source_id = kcontrol->private_value;
1263 /* Limit: emu->i2c_capture_volume */
1264 /* capture_source: uinfo->value.enumerated.items = 2 */
1265 if (source_id >= 2)
1266 return -EINVAL;
1267
1268 ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
1269 ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
1270 return 0;
1271}
1272
1273static int snd_audigy_i2c_volume_put(struct snd_kcontrol *kcontrol,
1274 struct snd_ctl_elem_value *ucontrol)
1275{
1276 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1277 unsigned int ogain;
1278 unsigned int ngain0, ngain1;
1279 unsigned int source_id;
1280 int change = 0;
1281
1282 source_id = kcontrol->private_value;
1283 /* Limit: emu->i2c_capture_volume */
1284 /* capture_source: uinfo->value.enumerated.items = 2 */
1285 if (source_id >= 2)
1286 return -EINVAL;
1287 ngain0 = ucontrol->value.integer.value[0];
1288 ngain1 = ucontrol->value.integer.value[1];
1289 if (ngain0 > 0xff)
1290 return -EINVAL;
1291 if (ngain1 > 0xff)
1292 return -EINVAL;
1293 ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
1294 if (ogain != ngain0) {
1295 if (emu->i2c_capture_source == source_id)
1296 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCL, ngain0);
1297 emu->i2c_capture_volume[source_id][0] = ngain0;
1298 change = 1;
1299 }
1300 ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
1301 if (ogain != ngain1) {
1302 if (emu->i2c_capture_source == source_id)
1303 snd_emu10k1_i2c_write(emu, ADC_ATTEN_ADCR, ngain1);
1304 emu->i2c_capture_volume[source_id][1] = ngain1;
1305 change = 1;
1306 }
1307
1308 return change;
1309}
1310
1311static const struct snd_kcontrol_new i2c_volume_ctl = {
1312 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1313 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1314 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1315 .info = snd_audigy_i2c_volume_info,
1316 .get = snd_audigy_i2c_volume_get,
1317 .put = snd_audigy_i2c_volume_put,
1318 .tlv = { .p = snd_audigy_db_scale2 }
1319};
1320
1321static const char * const snd_audigy_i2c_volume_ctls[] = {
1322 "Mic Capture Volume",
1323 "Line Capture Volume",
1324};
1325
1326#if 0
1327static int snd_audigy_spdif_output_rate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1328{
1329 static const char * const texts[] = {"44100", "48000", "96000"};
1330
1331 return snd_ctl_enum_info(uinfo, 1, 3, texts);
1332}
1333
1334static int snd_audigy_spdif_output_rate_get(struct snd_kcontrol *kcontrol,
1335 struct snd_ctl_elem_value *ucontrol)
1336{
1337 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1338 unsigned int tmp;
1339
1340 tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0);
1341 switch (tmp & A_SPDIF_RATE_MASK) {
1342 case A_SPDIF_44100:
1343 ucontrol->value.enumerated.item[0] = 0;
1344 break;
1345 case A_SPDIF_48000:
1346 ucontrol->value.enumerated.item[0] = 1;
1347 break;
1348 case A_SPDIF_96000:
1349 ucontrol->value.enumerated.item[0] = 2;
1350 break;
1351 default:
1352 ucontrol->value.enumerated.item[0] = 1;
1353 }
1354 return 0;
1355}
1356
1357static int snd_audigy_spdif_output_rate_put(struct snd_kcontrol *kcontrol,
1358 struct snd_ctl_elem_value *ucontrol)
1359{
1360 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1361 int change;
1362 unsigned int reg, val, tmp;
1363
1364 switch(ucontrol->value.enumerated.item[0]) {
1365 case 0:
1366 val = A_SPDIF_44100;
1367 break;
1368 case 1:
1369 val = A_SPDIF_48000;
1370 break;
1371 case 2:
1372 val = A_SPDIF_96000;
1373 break;
1374 default:
1375 val = A_SPDIF_48000;
1376 break;
1377 }
1378
1379
1380 spin_lock_irq(&emu->reg_lock);
1381 reg = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0);
1382 tmp = reg & ~A_SPDIF_RATE_MASK;
1383 tmp |= val;
1384 change = (tmp != reg);
1385 if (change)
1386 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, 0, tmp);
1387 spin_unlock_irq(&emu->reg_lock);
1388 return change;
1389}
1390
1391static const struct snd_kcontrol_new snd_audigy_spdif_output_rate =
1392{
1393 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1394 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1395 .name = "Audigy SPDIF Output Sample Rate",
1396 .count = 1,
1397 .info = snd_audigy_spdif_output_rate_info,
1398 .get = snd_audigy_spdif_output_rate_get,
1399 .put = snd_audigy_spdif_output_rate_put
1400};
1401#endif
1402
1403static int snd_emu10k1_spdif_put(struct snd_kcontrol *kcontrol,
1404 struct snd_ctl_elem_value *ucontrol)
1405{
1406 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1407 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1408 int change;
1409 unsigned int val;
1410
1411 /* Limit: emu->spdif_bits */
1412 if (idx >= 3)
1413 return -EINVAL;
1414 val = (ucontrol->value.iec958.status[0] << 0) |
1415 (ucontrol->value.iec958.status[1] << 8) |
1416 (ucontrol->value.iec958.status[2] << 16) |
1417 (ucontrol->value.iec958.status[3] << 24);
1418 change = val != emu->spdif_bits[idx];
1419 if (change) {
1420 snd_emu10k1_ptr_write(emu, SPCS0 + idx, 0, val);
1421 emu->spdif_bits[idx] = val;
1422 }
1423 return change;
1424}
1425
1426static const struct snd_kcontrol_new snd_emu10k1_spdif_mask_control =
1427{
1428 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1429 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1430 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
1431 .count = 3,
1432 .info = snd_emu10k1_spdif_info,
1433 .get = snd_emu10k1_spdif_get_mask
1434};
1435
1436static const struct snd_kcontrol_new snd_emu10k1_spdif_control =
1437{
1438 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1439 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1440 .count = 3,
1441 .info = snd_emu10k1_spdif_info,
1442 .get = snd_emu10k1_spdif_get,
1443 .put = snd_emu10k1_spdif_put
1444};
1445
1446
1447static void update_emu10k1_fxrt(struct snd_emu10k1 *emu, int voice, unsigned char *route)
1448{
1449 if (emu->audigy) {
1450 snd_emu10k1_ptr_write_multiple(emu, voice,
1451 A_FXRT1, snd_emu10k1_compose_audigy_fxrt1(route),
1452 A_FXRT2, snd_emu10k1_compose_audigy_fxrt2(route),
1453 REGLIST_END);
1454 } else {
1455 snd_emu10k1_ptr_write(emu, FXRT, voice,
1456 snd_emu10k1_compose_send_routing(route));
1457 }
1458}
1459
1460static void update_emu10k1_send_volume(struct snd_emu10k1 *emu, int voice, unsigned char *volume)
1461{
1462 snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_A, voice, volume[0]);
1463 snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_B, voice, volume[1]);
1464 snd_emu10k1_ptr_write(emu, PSST_FXSENDAMOUNT_C, voice, volume[2]);
1465 snd_emu10k1_ptr_write(emu, DSL_FXSENDAMOUNT_D, voice, volume[3]);
1466 if (emu->audigy) {
1467 snd_emu10k1_ptr_write(emu, A_SENDAMOUNTS, voice,
1468 snd_emu10k1_compose_audigy_sendamounts(volume));
1469 }
1470}
1471
1472/* PCM stream controls */
1473
1474static int snd_emu10k1_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1475{
1476 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1477 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1478 uinfo->count = emu->audigy ? 3*8 : 3*4;
1479 uinfo->value.integer.min = 0;
1480 uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f;
1481 return 0;
1482}
1483
1484static int snd_emu10k1_send_routing_get(struct snd_kcontrol *kcontrol,
1485 struct snd_ctl_elem_value *ucontrol)
1486{
1487 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1488 struct snd_emu10k1_pcm_mixer *mix =
1489 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1490 int voice, idx;
1491 int num_efx = emu->audigy ? 8 : 4;
1492 int mask = emu->audigy ? 0x3f : 0x0f;
1493
1494 for (voice = 0; voice < 3; voice++)
1495 for (idx = 0; idx < num_efx; idx++)
1496 ucontrol->value.integer.value[(voice * num_efx) + idx] =
1497 mix->send_routing[voice][idx] & mask;
1498 return 0;
1499}
1500
1501static int snd_emu10k1_send_routing_put(struct snd_kcontrol *kcontrol,
1502 struct snd_ctl_elem_value *ucontrol)
1503{
1504 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1505 struct snd_emu10k1_pcm_mixer *mix =
1506 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1507 int change = 0, voice, idx, val;
1508 int num_efx = emu->audigy ? 8 : 4;
1509 int mask = emu->audigy ? 0x3f : 0x0f;
1510
1511 spin_lock_irq(&emu->reg_lock);
1512 for (voice = 0; voice < 3; voice++)
1513 for (idx = 0; idx < num_efx; idx++) {
1514 val = ucontrol->value.integer.value[(voice * num_efx) + idx] & mask;
1515 if (mix->send_routing[voice][idx] != val) {
1516 mix->send_routing[voice][idx] = val;
1517 change = 1;
1518 }
1519 }
1520 if (change && mix->epcm && mix->epcm->voices[0]) {
1521 if (!mix->epcm->voices[0]->last) {
1522 update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number,
1523 &mix->send_routing[1][0]);
1524 update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number + 1,
1525 &mix->send_routing[2][0]);
1526 } else {
1527 update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number,
1528 &mix->send_routing[0][0]);
1529 }
1530 }
1531 spin_unlock_irq(&emu->reg_lock);
1532 return change;
1533}
1534
1535static const struct snd_kcontrol_new snd_emu10k1_send_routing_control =
1536{
1537 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1538 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1539 .name = "EMU10K1 PCM Send Routing",
1540 .count = 32,
1541 .info = snd_emu10k1_send_routing_info,
1542 .get = snd_emu10k1_send_routing_get,
1543 .put = snd_emu10k1_send_routing_put
1544};
1545
1546static int snd_emu10k1_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1547{
1548 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1549 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1550 uinfo->count = emu->audigy ? 3*8 : 3*4;
1551 uinfo->value.integer.min = 0;
1552 uinfo->value.integer.max = 255;
1553 return 0;
1554}
1555
1556static int snd_emu10k1_send_volume_get(struct snd_kcontrol *kcontrol,
1557 struct snd_ctl_elem_value *ucontrol)
1558{
1559 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1560 struct snd_emu10k1_pcm_mixer *mix =
1561 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1562 int idx;
1563 int num_efx = emu->audigy ? 8 : 4;
1564
1565 for (idx = 0; idx < 3*num_efx; idx++)
1566 ucontrol->value.integer.value[idx] = mix->send_volume[idx/num_efx][idx%num_efx];
1567 return 0;
1568}
1569
1570static int snd_emu10k1_send_volume_put(struct snd_kcontrol *kcontrol,
1571 struct snd_ctl_elem_value *ucontrol)
1572{
1573 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1574 struct snd_emu10k1_pcm_mixer *mix =
1575 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1576 int change = 0, idx, val;
1577 int num_efx = emu->audigy ? 8 : 4;
1578
1579 spin_lock_irq(&emu->reg_lock);
1580 for (idx = 0; idx < 3*num_efx; idx++) {
1581 val = ucontrol->value.integer.value[idx] & 255;
1582 if (mix->send_volume[idx/num_efx][idx%num_efx] != val) {
1583 mix->send_volume[idx/num_efx][idx%num_efx] = val;
1584 change = 1;
1585 }
1586 }
1587 if (change && mix->epcm && mix->epcm->voices[0]) {
1588 if (!mix->epcm->voices[0]->last) {
1589 update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number,
1590 &mix->send_volume[1][0]);
1591 update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number + 1,
1592 &mix->send_volume[2][0]);
1593 } else {
1594 update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number,
1595 &mix->send_volume[0][0]);
1596 }
1597 }
1598 spin_unlock_irq(&emu->reg_lock);
1599 return change;
1600}
1601
1602static const struct snd_kcontrol_new snd_emu10k1_send_volume_control =
1603{
1604 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1605 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1606 .name = "EMU10K1 PCM Send Volume",
1607 .count = 32,
1608 .info = snd_emu10k1_send_volume_info,
1609 .get = snd_emu10k1_send_volume_get,
1610 .put = snd_emu10k1_send_volume_put
1611};
1612
1613static int snd_emu10k1_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1614{
1615 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1616 uinfo->count = 3;
1617 uinfo->value.integer.min = 0;
1618 uinfo->value.integer.max = 0x1fffd;
1619 return 0;
1620}
1621
1622static int snd_emu10k1_attn_get(struct snd_kcontrol *kcontrol,
1623 struct snd_ctl_elem_value *ucontrol)
1624{
1625 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1626 struct snd_emu10k1_pcm_mixer *mix =
1627 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1628 int idx;
1629
1630 for (idx = 0; idx < 3; idx++)
1631 ucontrol->value.integer.value[idx] = mix->attn[idx] * 0xffffU / 0x8000U;
1632 return 0;
1633}
1634
1635static int snd_emu10k1_attn_put(struct snd_kcontrol *kcontrol,
1636 struct snd_ctl_elem_value *ucontrol)
1637{
1638 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1639 struct snd_emu10k1_pcm_mixer *mix =
1640 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1641 int change = 0, idx, val;
1642
1643 spin_lock_irq(&emu->reg_lock);
1644 for (idx = 0; idx < 3; idx++) {
1645 unsigned uval = ucontrol->value.integer.value[idx] & 0x1ffff;
1646 val = uval * 0x8000U / 0xffffU;
1647 if (mix->attn[idx] != val) {
1648 mix->attn[idx] = val;
1649 change = 1;
1650 }
1651 }
1652 if (change && mix->epcm && mix->epcm->voices[0]) {
1653 if (!mix->epcm->voices[0]->last) {
1654 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[1]);
1655 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number + 1, mix->attn[2]);
1656 } else {
1657 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[0]);
1658 }
1659 }
1660 spin_unlock_irq(&emu->reg_lock);
1661 return change;
1662}
1663
1664static const struct snd_kcontrol_new snd_emu10k1_attn_control =
1665{
1666 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1667 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1668 .name = "EMU10K1 PCM Volume",
1669 .count = 32,
1670 .info = snd_emu10k1_attn_info,
1671 .get = snd_emu10k1_attn_get,
1672 .put = snd_emu10k1_attn_put
1673};
1674
1675/* Mutichannel PCM stream controls */
1676
1677static int snd_emu10k1_efx_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1678{
1679 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1680 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1681 uinfo->count = emu->audigy ? 8 : 4;
1682 uinfo->value.integer.min = 0;
1683 uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f;
1684 return 0;
1685}
1686
1687static int snd_emu10k1_efx_send_routing_get(struct snd_kcontrol *kcontrol,
1688 struct snd_ctl_elem_value *ucontrol)
1689{
1690 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1691 struct snd_emu10k1_pcm_mixer *mix =
1692 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1693 int idx;
1694 int num_efx = emu->audigy ? 8 : 4;
1695 int mask = emu->audigy ? 0x3f : 0x0f;
1696
1697 for (idx = 0; idx < num_efx; idx++)
1698 ucontrol->value.integer.value[idx] =
1699 mix->send_routing[0][idx] & mask;
1700 return 0;
1701}
1702
1703static int snd_emu10k1_efx_send_routing_put(struct snd_kcontrol *kcontrol,
1704 struct snd_ctl_elem_value *ucontrol)
1705{
1706 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1707 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1708 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1709 int change = 0, idx, val;
1710 int num_efx = emu->audigy ? 8 : 4;
1711 int mask = emu->audigy ? 0x3f : 0x0f;
1712
1713 spin_lock_irq(&emu->reg_lock);
1714 for (idx = 0; idx < num_efx; idx++) {
1715 val = ucontrol->value.integer.value[idx] & mask;
1716 if (mix->send_routing[0][idx] != val) {
1717 mix->send_routing[0][idx] = val;
1718 change = 1;
1719 }
1720 }
1721
1722 if (change && mix->epcm) {
1723 if (mix->epcm->voices[ch]) {
1724 update_emu10k1_fxrt(emu, mix->epcm->voices[ch]->number,
1725 &mix->send_routing[0][0]);
1726 }
1727 }
1728 spin_unlock_irq(&emu->reg_lock);
1729 return change;
1730}
1731
1732static const struct snd_kcontrol_new snd_emu10k1_efx_send_routing_control =
1733{
1734 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1735 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1736 .name = "Multichannel PCM Send Routing",
1737 .count = 16,
1738 .info = snd_emu10k1_efx_send_routing_info,
1739 .get = snd_emu10k1_efx_send_routing_get,
1740 .put = snd_emu10k1_efx_send_routing_put
1741};
1742
1743static int snd_emu10k1_efx_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1744{
1745 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1746 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1747 uinfo->count = emu->audigy ? 8 : 4;
1748 uinfo->value.integer.min = 0;
1749 uinfo->value.integer.max = 255;
1750 return 0;
1751}
1752
1753static int snd_emu10k1_efx_send_volume_get(struct snd_kcontrol *kcontrol,
1754 struct snd_ctl_elem_value *ucontrol)
1755{
1756 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1757 struct snd_emu10k1_pcm_mixer *mix =
1758 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1759 int idx;
1760 int num_efx = emu->audigy ? 8 : 4;
1761
1762 for (idx = 0; idx < num_efx; idx++)
1763 ucontrol->value.integer.value[idx] = mix->send_volume[0][idx];
1764 return 0;
1765}
1766
1767static int snd_emu10k1_efx_send_volume_put(struct snd_kcontrol *kcontrol,
1768 struct snd_ctl_elem_value *ucontrol)
1769{
1770 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1771 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1772 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1773 int change = 0, idx, val;
1774 int num_efx = emu->audigy ? 8 : 4;
1775
1776 spin_lock_irq(&emu->reg_lock);
1777 for (idx = 0; idx < num_efx; idx++) {
1778 val = ucontrol->value.integer.value[idx] & 255;
1779 if (mix->send_volume[0][idx] != val) {
1780 mix->send_volume[0][idx] = val;
1781 change = 1;
1782 }
1783 }
1784 if (change && mix->epcm) {
1785 if (mix->epcm->voices[ch]) {
1786 update_emu10k1_send_volume(emu, mix->epcm->voices[ch]->number,
1787 &mix->send_volume[0][0]);
1788 }
1789 }
1790 spin_unlock_irq(&emu->reg_lock);
1791 return change;
1792}
1793
1794
1795static const struct snd_kcontrol_new snd_emu10k1_efx_send_volume_control =
1796{
1797 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1798 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1799 .name = "Multichannel PCM Send Volume",
1800 .count = 16,
1801 .info = snd_emu10k1_efx_send_volume_info,
1802 .get = snd_emu10k1_efx_send_volume_get,
1803 .put = snd_emu10k1_efx_send_volume_put
1804};
1805
1806static int snd_emu10k1_efx_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1807{
1808 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1809 uinfo->count = 1;
1810 uinfo->value.integer.min = 0;
1811 uinfo->value.integer.max = 0x1fffd;
1812 return 0;
1813}
1814
1815static int snd_emu10k1_efx_attn_get(struct snd_kcontrol *kcontrol,
1816 struct snd_ctl_elem_value *ucontrol)
1817{
1818 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1819 struct snd_emu10k1_pcm_mixer *mix =
1820 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1821
1822 ucontrol->value.integer.value[0] = mix->attn[0] * 0xffffU / 0x8000U;
1823 return 0;
1824}
1825
1826static int snd_emu10k1_efx_attn_put(struct snd_kcontrol *kcontrol,
1827 struct snd_ctl_elem_value *ucontrol)
1828{
1829 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1830 int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1831 struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1832 int change = 0, val;
1833 unsigned uval;
1834
1835 spin_lock_irq(&emu->reg_lock);
1836 uval = ucontrol->value.integer.value[0] & 0x1ffff;
1837 val = uval * 0x8000U / 0xffffU;
1838 if (mix->attn[0] != val) {
1839 mix->attn[0] = val;
1840 change = 1;
1841 }
1842 if (change && mix->epcm) {
1843 if (mix->epcm->voices[ch]) {
1844 snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[ch]->number, mix->attn[0]);
1845 }
1846 }
1847 spin_unlock_irq(&emu->reg_lock);
1848 return change;
1849}
1850
1851static const struct snd_kcontrol_new snd_emu10k1_efx_attn_control =
1852{
1853 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1854 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1855 .name = "Multichannel PCM Volume",
1856 .count = 16,
1857 .info = snd_emu10k1_efx_attn_info,
1858 .get = snd_emu10k1_efx_attn_get,
1859 .put = snd_emu10k1_efx_attn_put
1860};
1861
1862#define snd_emu10k1_shared_spdif_info snd_ctl_boolean_mono_info
1863
1864static int snd_emu10k1_shared_spdif_get(struct snd_kcontrol *kcontrol,
1865 struct snd_ctl_elem_value *ucontrol)
1866{
1867 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1868
1869 if (emu->audigy)
1870 ucontrol->value.integer.value[0] = inw(emu->port + A_IOCFG) & A_IOCFG_GPOUT0 ? 1 : 0;
1871 else
1872 ucontrol->value.integer.value[0] = inl(emu->port + HCFG) & HCFG_GPOUT0 ? 1 : 0;
1873 if (emu->card_capabilities->invert_shared_spdif)
1874 ucontrol->value.integer.value[0] =
1875 !ucontrol->value.integer.value[0];
1876
1877 return 0;
1878}
1879
1880static int snd_emu10k1_shared_spdif_put(struct snd_kcontrol *kcontrol,
1881 struct snd_ctl_elem_value *ucontrol)
1882{
1883 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1884 unsigned int reg, val, sw;
1885 int change = 0;
1886
1887 sw = ucontrol->value.integer.value[0];
1888 if (emu->card_capabilities->invert_shared_spdif)
1889 sw = !sw;
1890 spin_lock_irq(&emu->emu_lock);
1891 if ( emu->card_capabilities->i2c_adc) {
1892 /* Do nothing for Audigy 2 ZS Notebook */
1893 } else if (emu->audigy) {
1894 reg = inw(emu->port + A_IOCFG);
1895 val = sw ? A_IOCFG_GPOUT0 : 0;
1896 change = (reg & A_IOCFG_GPOUT0) != val;
1897 if (change) {
1898 reg &= ~A_IOCFG_GPOUT0;
1899 reg |= val;
1900 outw(reg | val, emu->port + A_IOCFG);
1901 }
1902 }
1903 reg = inl(emu->port + HCFG);
1904 val = sw ? HCFG_GPOUT0 : 0;
1905 change |= (reg & HCFG_GPOUT0) != val;
1906 if (change) {
1907 reg &= ~HCFG_GPOUT0;
1908 reg |= val;
1909 outl(reg | val, emu->port + HCFG);
1910 }
1911 spin_unlock_irq(&emu->emu_lock);
1912 return change;
1913}
1914
1915static const struct snd_kcontrol_new snd_emu10k1_shared_spdif =
1916{
1917 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1918 .name = "SB Live Analog/Digital Output Jack",
1919 .info = snd_emu10k1_shared_spdif_info,
1920 .get = snd_emu10k1_shared_spdif_get,
1921 .put = snd_emu10k1_shared_spdif_put
1922};
1923
1924static const struct snd_kcontrol_new snd_audigy_shared_spdif =
1925{
1926 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1927 .name = "Audigy Analog/Digital Output Jack",
1928 .info = snd_emu10k1_shared_spdif_info,
1929 .get = snd_emu10k1_shared_spdif_get,
1930 .put = snd_emu10k1_shared_spdif_put
1931};
1932
1933/* workaround for too low volume on Audigy due to 16bit/24bit conversion */
1934
1935#define snd_audigy_capture_boost_info snd_ctl_boolean_mono_info
1936
1937static int snd_audigy_capture_boost_get(struct snd_kcontrol *kcontrol,
1938 struct snd_ctl_elem_value *ucontrol)
1939{
1940 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1941 unsigned int val;
1942
1943 /* FIXME: better to use a cached version */
1944 val = snd_ac97_read(emu->ac97, AC97_REC_GAIN);
1945 ucontrol->value.integer.value[0] = !!val;
1946 return 0;
1947}
1948
1949static int snd_audigy_capture_boost_put(struct snd_kcontrol *kcontrol,
1950 struct snd_ctl_elem_value *ucontrol)
1951{
1952 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1953 unsigned int val;
1954
1955 if (ucontrol->value.integer.value[0])
1956 val = 0x0f0f;
1957 else
1958 val = 0;
1959 return snd_ac97_update(emu->ac97, AC97_REC_GAIN, val);
1960}
1961
1962static const struct snd_kcontrol_new snd_audigy_capture_boost =
1963{
1964 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1965 .name = "Mic Extra Boost",
1966 .info = snd_audigy_capture_boost_info,
1967 .get = snd_audigy_capture_boost_get,
1968 .put = snd_audigy_capture_boost_put
1969};
1970
1971
1972/*
1973 */
1974static void snd_emu10k1_mixer_free_ac97(struct snd_ac97 *ac97)
1975{
1976 struct snd_emu10k1 *emu = ac97->private_data;
1977 emu->ac97 = NULL;
1978}
1979
1980/*
1981 */
1982static int remove_ctl(struct snd_card *card, const char *name)
1983{
1984 struct snd_ctl_elem_id id;
1985 memset(&id, 0, sizeof(id));
1986 strcpy(id.name, name);
1987 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1988 return snd_ctl_remove_id(card, &id);
1989}
1990
1991static int rename_ctl(struct snd_card *card, const char *src, const char *dst)
1992{
1993 struct snd_kcontrol *kctl = snd_ctl_find_id_mixer(card, src);
1994 if (kctl) {
1995 snd_ctl_rename(card, kctl, dst);
1996 return 0;
1997 }
1998 return -ENOENT;
1999}
2000
2001int snd_emu10k1_mixer(struct snd_emu10k1 *emu,
2002 int pcm_device, int multi_device)
2003{
2004 int err;
2005 struct snd_kcontrol *kctl;
2006 struct snd_card *card = emu->card;
2007 const char * const *c;
2008 static const char * const emu10k1_remove_ctls[] = {
2009 /* no AC97 mono, surround, center/lfe */
2010 "Master Mono Playback Switch",
2011 "Master Mono Playback Volume",
2012 "PCM Out Path & Mute",
2013 "Mono Output Select",
2014 "Surround Playback Switch",
2015 "Surround Playback Volume",
2016 "Center Playback Switch",
2017 "Center Playback Volume",
2018 "LFE Playback Switch",
2019 "LFE Playback Volume",
2020 NULL
2021 };
2022 static const char * const emu10k1_rename_ctls[] = {
2023 "Surround Digital Playback Volume", "Surround Playback Volume",
2024 "Center Digital Playback Volume", "Center Playback Volume",
2025 "LFE Digital Playback Volume", "LFE Playback Volume",
2026 NULL
2027 };
2028 static const char * const audigy_remove_ctls[] = {
2029 /* Master/PCM controls on ac97 of Audigy has no effect */
2030 /* On the Audigy2 the AC97 playback is piped into
2031 * the Philips ADC for 24bit capture */
2032 "PCM Playback Switch",
2033 "PCM Playback Volume",
2034 "Master Playback Switch",
2035 "Master Playback Volume",
2036 "PCM Out Path & Mute",
2037 "Mono Output Select",
2038 /* remove unused AC97 capture controls */
2039 "Capture Source",
2040 "Capture Switch",
2041 "Capture Volume",
2042 "Mic Select",
2043 "Headphone Playback Switch",
2044 "Headphone Playback Volume",
2045 "3D Control - Center",
2046 "3D Control - Depth",
2047 "3D Control - Switch",
2048 "Video Playback Switch",
2049 "Video Playback Volume",
2050 "Mic Playback Switch",
2051 "Mic Playback Volume",
2052 "External Amplifier",
2053 NULL
2054 };
2055 static const char * const audigy_rename_ctls[] = {
2056 /* use conventional names */
2057 "Wave Playback Volume", "PCM Playback Volume",
2058 /* "Wave Capture Volume", "PCM Capture Volume", */
2059 "Wave Master Playback Volume", "Master Playback Volume",
2060 "AMic Playback Volume", "Mic Playback Volume",
2061 "Master Mono Playback Switch", "Phone Output Playback Switch",
2062 "Master Mono Playback Volume", "Phone Output Playback Volume",
2063 NULL
2064 };
2065 static const char * const audigy_rename_ctls_i2c_adc[] = {
2066 //"Analog Mix Capture Volume","OLD Analog Mix Capture Volume",
2067 "Line Capture Volume", "Analog Mix Capture Volume",
2068 "Wave Playback Volume", "OLD PCM Playback Volume",
2069 "Wave Master Playback Volume", "Master Playback Volume",
2070 "AMic Playback Volume", "Old Mic Playback Volume",
2071 "CD Capture Volume", "IEC958 Optical Capture Volume",
2072 NULL
2073 };
2074 static const char * const audigy_remove_ctls_i2c_adc[] = {
2075 /* On the Audigy2 ZS Notebook
2076 * Capture via WM8775 */
2077 "Mic Capture Volume",
2078 "Analog Mix Capture Volume",
2079 "Aux Capture Volume",
2080 "IEC958 Optical Capture Volume",
2081 NULL
2082 };
2083 static const char * const audigy_remove_ctls_1361t_adc[] = {
2084 /* On the Audigy2 the AC97 playback is piped into
2085 * the Philips ADC for 24bit capture */
2086 "PCM Playback Switch",
2087 "PCM Playback Volume",
2088 "Capture Source",
2089 "Capture Switch",
2090 "Capture Volume",
2091 "Mic Capture Volume",
2092 "Headphone Playback Switch",
2093 "Headphone Playback Volume",
2094 "3D Control - Center",
2095 "3D Control - Depth",
2096 "3D Control - Switch",
2097 "Line2 Playback Volume",
2098 "Line2 Capture Volume",
2099 NULL
2100 };
2101 static const char * const audigy_rename_ctls_1361t_adc[] = {
2102 "Master Playback Switch", "Master Capture Switch",
2103 "Master Playback Volume", "Master Capture Volume",
2104 "Wave Master Playback Volume", "Master Playback Volume",
2105 "Beep Playback Switch", "Beep Capture Switch",
2106 "Beep Playback Volume", "Beep Capture Volume",
2107 "Phone Playback Switch", "Phone Capture Switch",
2108 "Phone Playback Volume", "Phone Capture Volume",
2109 "Mic Playback Switch", "Mic Capture Switch",
2110 "Mic Playback Volume", "Mic Capture Volume",
2111 "Line Playback Switch", "Line Capture Switch",
2112 "Line Playback Volume", "Line Capture Volume",
2113 "CD Playback Switch", "CD Capture Switch",
2114 "CD Playback Volume", "CD Capture Volume",
2115 "Aux Playback Switch", "Aux Capture Switch",
2116 "Aux Playback Volume", "Aux Capture Volume",
2117 "Video Playback Switch", "Video Capture Switch",
2118 "Video Playback Volume", "Video Capture Volume",
2119 "Master Mono Playback Switch", "Phone Output Playback Switch",
2120 "Master Mono Playback Volume", "Phone Output Playback Volume",
2121 NULL
2122 };
2123
2124 if (emu->card_capabilities->ac97_chip) {
2125 struct snd_ac97_bus *pbus;
2126 struct snd_ac97_template ac97;
2127 static const struct snd_ac97_bus_ops ops = {
2128 .write = snd_emu10k1_ac97_write,
2129 .read = snd_emu10k1_ac97_read,
2130 };
2131
2132 err = snd_ac97_bus(emu->card, 0, &ops, NULL, &pbus);
2133 if (err < 0)
2134 return err;
2135 pbus->no_vra = 1; /* we don't need VRA */
2136
2137 memset(&ac97, 0, sizeof(ac97));
2138 ac97.private_data = emu;
2139 ac97.private_free = snd_emu10k1_mixer_free_ac97;
2140 ac97.scaps = AC97_SCAP_NO_SPDIF;
2141 err = snd_ac97_mixer(pbus, &ac97, &emu->ac97);
2142 if (err < 0) {
2143 if (emu->card_capabilities->ac97_chip == 1)
2144 return err;
2145 dev_info(emu->card->dev,
2146 "AC97 is optional on this board\n");
2147 dev_info(emu->card->dev,
2148 "Proceeding without ac97 mixers...\n");
2149 snd_device_free(emu->card, pbus);
2150 goto no_ac97; /* FIXME: get rid of ugly gotos.. */
2151 }
2152 if (emu->audigy) {
2153 /* set master volume to 0 dB */
2154 snd_ac97_write_cache(emu->ac97, AC97_MASTER, 0x0000);
2155 /* set capture source to mic */
2156 snd_ac97_write_cache(emu->ac97, AC97_REC_SEL, 0x0000);
2157 /* set mono output (TAD) to mic */
2158 snd_ac97_update_bits(emu->ac97, AC97_GENERAL_PURPOSE,
2159 0x0200, 0x0200);
2160 if (emu->card_capabilities->adc_1361t)
2161 c = audigy_remove_ctls_1361t_adc;
2162 else
2163 c = audigy_remove_ctls;
2164 } else {
2165 /*
2166 * Credits for cards based on STAC9758:
2167 * James Courtier-Dutton <James@superbug.demon.co.uk>
2168 * Voluspa <voluspa@comhem.se>
2169 */
2170 if (emu->ac97->id == AC97_ID_STAC9758) {
2171 emu->rear_ac97 = 1;
2172 snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_CNTR|AC97SLOT_LFE|AC97SLOT_REAR_LEFT|AC97SLOT_REAR_RIGHT);
2173 snd_ac97_write_cache(emu->ac97, AC97_HEADPHONE, 0x0202);
2174 remove_ctl(card,"Front Playback Volume");
2175 remove_ctl(card,"Front Playback Switch");
2176 }
2177 /* remove unused AC97 controls */
2178 snd_ac97_write_cache(emu->ac97, AC97_SURROUND_MASTER, 0x0202);
2179 snd_ac97_write_cache(emu->ac97, AC97_CENTER_LFE_MASTER, 0x0202);
2180 c = emu10k1_remove_ctls;
2181 }
2182 for (; *c; c++)
2183 remove_ctl(card, *c);
2184 } else if (emu->card_capabilities->i2c_adc) {
2185 c = audigy_remove_ctls_i2c_adc;
2186 for (; *c; c++)
2187 remove_ctl(card, *c);
2188 } else {
2189 no_ac97:
2190 if (emu->card_capabilities->ecard)
2191 strcpy(emu->card->mixername, "EMU APS");
2192 else if (emu->audigy)
2193 strcpy(emu->card->mixername, "SB Audigy");
2194 else
2195 strcpy(emu->card->mixername, "Emu10k1");
2196 }
2197
2198 if (emu->audigy)
2199 if (emu->card_capabilities->adc_1361t)
2200 c = audigy_rename_ctls_1361t_adc;
2201 else if (emu->card_capabilities->i2c_adc)
2202 c = audigy_rename_ctls_i2c_adc;
2203 else
2204 c = audigy_rename_ctls;
2205 else
2206 c = emu10k1_rename_ctls;
2207 for (; *c; c += 2)
2208 rename_ctl(card, c[0], c[1]);
2209
2210 if (emu->card_capabilities->subsystem == 0x80401102) { /* SB Live! Platinum CT4760P */
2211 remove_ctl(card, "Center Playback Volume");
2212 remove_ctl(card, "LFE Playback Volume");
2213 remove_ctl(card, "Wave Center Playback Volume");
2214 remove_ctl(card, "Wave LFE Playback Volume");
2215 }
2216 if (emu->card_capabilities->subsystem == 0x20071102) { /* Audigy 4 Pro */
2217 rename_ctl(card, "Line2 Capture Volume", "Line1/Mic Capture Volume");
2218 rename_ctl(card, "Analog Mix Capture Volume", "Line2 Capture Volume");
2219 rename_ctl(card, "Aux2 Capture Volume", "Line3 Capture Volume");
2220 rename_ctl(card, "Mic Capture Volume", "Unknown1 Capture Volume");
2221 }
2222 kctl = emu->ctl_send_routing = snd_ctl_new1(&snd_emu10k1_send_routing_control, emu);
2223 if (!kctl)
2224 return -ENOMEM;
2225 kctl->id.device = pcm_device;
2226 err = snd_ctl_add(card, kctl);
2227 if (err)
2228 return err;
2229 kctl = emu->ctl_send_volume = snd_ctl_new1(&snd_emu10k1_send_volume_control, emu);
2230 if (!kctl)
2231 return -ENOMEM;
2232 kctl->id.device = pcm_device;
2233 err = snd_ctl_add(card, kctl);
2234 if (err)
2235 return err;
2236 kctl = emu->ctl_attn = snd_ctl_new1(&snd_emu10k1_attn_control, emu);
2237 if (!kctl)
2238 return -ENOMEM;
2239 kctl->id.device = pcm_device;
2240 err = snd_ctl_add(card, kctl);
2241 if (err)
2242 return err;
2243
2244 kctl = emu->ctl_efx_send_routing = snd_ctl_new1(&snd_emu10k1_efx_send_routing_control, emu);
2245 if (!kctl)
2246 return -ENOMEM;
2247 kctl->id.device = multi_device;
2248 err = snd_ctl_add(card, kctl);
2249 if (err)
2250 return err;
2251
2252 kctl = emu->ctl_efx_send_volume = snd_ctl_new1(&snd_emu10k1_efx_send_volume_control, emu);
2253 if (!kctl)
2254 return -ENOMEM;
2255 kctl->id.device = multi_device;
2256 err = snd_ctl_add(card, kctl);
2257 if (err)
2258 return err;
2259
2260 kctl = emu->ctl_efx_attn = snd_ctl_new1(&snd_emu10k1_efx_attn_control, emu);
2261 if (!kctl)
2262 return -ENOMEM;
2263 kctl->id.device = multi_device;
2264 err = snd_ctl_add(card, kctl);
2265 if (err)
2266 return err;
2267
2268 if (!emu->card_capabilities->ecard && !emu->card_capabilities->emu_model) {
2269 /* sb live! and audigy */
2270 kctl = snd_ctl_new1(&snd_emu10k1_spdif_mask_control, emu);
2271 if (!kctl)
2272 return -ENOMEM;
2273 if (!emu->audigy)
2274 kctl->id.device = emu->pcm_efx->device;
2275 err = snd_ctl_add(card, kctl);
2276 if (err)
2277 return err;
2278 kctl = snd_ctl_new1(&snd_emu10k1_spdif_control, emu);
2279 if (!kctl)
2280 return -ENOMEM;
2281 if (!emu->audigy)
2282 kctl->id.device = emu->pcm_efx->device;
2283 err = snd_ctl_add(card, kctl);
2284 if (err)
2285 return err;
2286 }
2287
2288 if (emu->card_capabilities->emu_model) {
2289 ; /* Disable the snd_audigy_spdif_shared_spdif */
2290 } else if (emu->audigy) {
2291 kctl = snd_ctl_new1(&snd_audigy_shared_spdif, emu);
2292 if (!kctl)
2293 return -ENOMEM;
2294 err = snd_ctl_add(card, kctl);
2295 if (err)
2296 return err;
2297#if 0
2298 kctl = snd_ctl_new1(&snd_audigy_spdif_output_rate, emu);
2299 if (!kctl)
2300 return -ENOMEM;
2301 err = snd_ctl_add(card, kctl);
2302 if (err)
2303 return err;
2304#endif
2305 } else if (! emu->card_capabilities->ecard) {
2306 /* sb live! */
2307 kctl = snd_ctl_new1(&snd_emu10k1_shared_spdif, emu);
2308 if (!kctl)
2309 return -ENOMEM;
2310 err = snd_ctl_add(card, kctl);
2311 if (err)
2312 return err;
2313 }
2314 if (emu->card_capabilities->ca0151_chip) { /* P16V */
2315 err = snd_p16v_mixer(emu);
2316 if (err)
2317 return err;
2318 }
2319
2320 if (emu->card_capabilities->emu_model) {
2321 unsigned i, emu_idx = emu1010_idx(emu);
2322 const struct snd_emu1010_routing_info *emu_ri =
2323 &emu1010_routing_info[emu_idx];
2324 const struct snd_emu1010_pads_info *emu_pi = &emu1010_pads_info[emu_idx];
2325
2326 for (i = 0; i < emu_ri->n_ins; i++)
2327 emu->emu1010.input_source[i] =
2328 emu1010_map_source(emu_ri, emu_ri->in_dflts[i]);
2329 for (i = 0; i < emu_ri->n_outs; i++)
2330 emu->emu1010.output_source[i] =
2331 emu1010_map_source(emu_ri, emu_ri->out_dflts[i]);
2332 snd_emu1010_fpga_lock(emu);
2333 snd_emu1010_apply_sources(emu);
2334 snd_emu1010_fpga_unlock(emu);
2335
2336 kctl = emu->ctl_clock_source = snd_ctl_new1(&snd_emu1010_clock_source, emu);
2337 err = snd_ctl_add(card, kctl);
2338 if (err < 0)
2339 return err;
2340 err = snd_ctl_add(card,
2341 snd_ctl_new1(&snd_emu1010_clock_fallback, emu));
2342 if (err < 0)
2343 return err;
2344
2345 err = add_ctls(emu, &emu1010_adc_pads_ctl,
2346 emu_pi->adc_ctls, emu_pi->n_adc_ctls);
2347 if (err < 0)
2348 return err;
2349 err = add_ctls(emu, &emu1010_dac_pads_ctl,
2350 emu_pi->dac_ctls, emu_pi->n_dac_ctls);
2351 if (err < 0)
2352 return err;
2353
2354 if (!emu->card_capabilities->no_adat) {
2355 err = snd_ctl_add(card,
2356 snd_ctl_new1(&snd_emu1010_optical_out, emu));
2357 if (err < 0)
2358 return err;
2359 err = snd_ctl_add(card,
2360 snd_ctl_new1(&snd_emu1010_optical_in, emu));
2361 if (err < 0)
2362 return err;
2363 }
2364
2365 err = add_emu1010_source_mixers(emu);
2366 if (err < 0)
2367 return err;
2368 }
2369
2370 if ( emu->card_capabilities->i2c_adc) {
2371 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_i2c_capture_source, emu));
2372 if (err < 0)
2373 return err;
2374
2375 err = add_ctls(emu, &i2c_volume_ctl,
2376 snd_audigy_i2c_volume_ctls,
2377 ARRAY_SIZE(snd_audigy_i2c_volume_ctls));
2378 if (err < 0)
2379 return err;
2380 }
2381
2382 if (emu->card_capabilities->ac97_chip && emu->audigy) {
2383 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_capture_boost,
2384 emu));
2385 if (err < 0)
2386 return err;
2387 }
2388
2389 return 0;
2390}
Note: See TracBrowser for help on using the repository browser.