~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/emu10k1/emumixer.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp