sound/pci/emu10k1/emumixer.c

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