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         if ((change = (tmp != reg)))
1123                 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, 0, tmp);
1124         spin_unlock_irqrestore(&emu->reg_lock, flags);
1125         return change;
1126 }
1127
1128 static const struct snd_kcontrol_new snd_audigy_spdif_output_rate =
1129 {
1130         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE,
1131         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
1132         .name =         "Audigy SPDIF Output Sample Rate",
1133         .count =        1,
1134         .info =         snd_audigy_spdif_output_rate_info,
1135         .get =          snd_audigy_spdif_output_rate_get,
1136         .put =          snd_audigy_spdif_output_rate_put
1137 };
1138 #endif
1139
1140 static int snd_emu10k1_spdif_put(struct snd_kcontrol *kcontrol,
1141                                  struct snd_ctl_elem_value *ucontrol)
1142 {
1143         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1144         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1145         int change;
1146         unsigned int val;
1147         unsigned long flags;
1148
1149         /* Limit: emu->spdif_bits */
1150         if (idx >= 3)
1151                 return -EINVAL;
1152         val = (ucontrol->value.iec958.status[0] << 0) |
1153               (ucontrol->value.iec958.status[1] << 8) |
1154               (ucontrol->value.iec958.status[2] << 16) |
1155               (ucontrol->value.iec958.status[3] << 24);
1156         spin_lock_irqsave(&emu->reg_lock, flags);
1157         change = val != emu->spdif_bits[idx];
1158         if (change) {
1159                 snd_emu10k1_ptr_write(emu, SPCS0 + idx, 0, val);
1160                 emu->spdif_bits[idx] = val;
1161         }
1162         spin_unlock_irqrestore(&emu->reg_lock, flags);
1163         return change;
1164 }
1165
1166 static const struct snd_kcontrol_new snd_emu10k1_spdif_mask_control =
1167 {
1168         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
1169         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1170         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
1171         .count =        3,
1172         .info =         snd_emu10k1_spdif_info,
1173         .get =          snd_emu10k1_spdif_get_mask
1174 };
1175
1176 static const struct snd_kcontrol_new snd_emu10k1_spdif_control =
1177 {
1178         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1179         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1180         .count =        3,
1181         .info =         snd_emu10k1_spdif_info,
1182         .get =          snd_emu10k1_spdif_get,
1183         .put =          snd_emu10k1_spdif_put
1184 };
1185
1186
1187 static void update_emu10k1_fxrt(struct snd_emu10k1 *emu, int voice, unsigned char *route)
1188 {
1189         if (emu->audigy) {
1190                 snd_emu10k1_ptr_write(emu, A_FXRT1, voice,
1191                                       snd_emu10k1_compose_audigy_fxrt1(route));
1192                 snd_emu10k1_ptr_write(emu, A_FXRT2, voice,
1193                                       snd_emu10k1_compose_audigy_fxrt2(route));
1194         } else {
1195                 snd_emu10k1_ptr_write(emu, FXRT, voice,
1196                                       snd_emu10k1_compose_send_routing(route));
1197         }
1198 }
1199
1200 static void update_emu10k1_send_volume(struct snd_emu10k1 *emu, int voice, unsigned char *volume)
1201 {
1202         snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_A, voice, volume[0]);
1203         snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_B, voice, volume[1]);
1204         snd_emu10k1_ptr_write(emu, PSST_FXSENDAMOUNT_C, voice, volume[2]);
1205         snd_emu10k1_ptr_write(emu, DSL_FXSENDAMOUNT_D, voice, volume[3]);
1206         if (emu->audigy) {
1207                 unsigned int val = ((unsigned int)volume[4] << 24) |
1208                         ((unsigned int)volume[5] << 16) |
1209                         ((unsigned int)volume[6] << 8) |
1210                         (unsigned int)volume[7];
1211                 snd_emu10k1_ptr_write(emu, A_SENDAMOUNTS, voice, val);
1212         }
1213 }
1214
1215 /* PCM stream controls */
1216
1217 static int snd_emu10k1_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1218 {
1219         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1220         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1221         uinfo->count = emu->audigy ? 3*8 : 3*4;
1222         uinfo->value.integer.min = 0;
1223         uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f;
1224         return 0;
1225 }
1226
1227 static int snd_emu10k1_send_routing_get(struct snd_kcontrol *kcontrol,
1228                                         struct snd_ctl_elem_value *ucontrol)
1229 {
1230         unsigned long flags;
1231         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1232         struct snd_emu10k1_pcm_mixer *mix =
1233                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1234         int voice, idx;
1235         int num_efx = emu->audigy ? 8 : 4;
1236         int mask = emu->audigy ? 0x3f : 0x0f;
1237
1238         spin_lock_irqsave(&emu->reg_lock, flags);
1239         for (voice = 0; voice < 3; voice++)
1240                 for (idx = 0; idx < num_efx; idx++)
1241                         ucontrol->value.integer.value[(voice * num_efx) + idx] =
1242                                 mix->send_routing[voice][idx] & mask;
1243         spin_unlock_irqrestore(&emu->reg_lock, flags);
1244         return 0;
1245 }
1246
1247 static int snd_emu10k1_send_routing_put(struct snd_kcontrol *kcontrol,
1248                                         struct snd_ctl_elem_value *ucontrol)
1249 {
1250         unsigned long flags;
1251         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1252         struct snd_emu10k1_pcm_mixer *mix =
1253                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1254         int change = 0, voice, idx, val;
1255         int num_efx = emu->audigy ? 8 : 4;
1256         int mask = emu->audigy ? 0x3f : 0x0f;
1257
1258         spin_lock_irqsave(&emu->reg_lock, flags);
1259         for (voice = 0; voice < 3; voice++)
1260                 for (idx = 0; idx < num_efx; idx++) {
1261                         val = ucontrol->value.integer.value[(voice * num_efx) + idx] & mask;
1262                         if (mix->send_routing[voice][idx] != val) {
1263                                 mix->send_routing[voice][idx] = val;
1264                                 change = 1;
1265                         }
1266                 }
1267         if (change && mix->epcm) {
1268                 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
1269                         update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number,
1270                                             &mix->send_routing[1][0]);
1271                         update_emu10k1_fxrt(emu, mix->epcm->voices[1]->number,
1272                                             &mix->send_routing[2][0]);
1273                 } else if (mix->epcm->voices[0]) {
1274                         update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number,
1275                                             &mix->send_routing[0][0]);
1276                 }
1277         }
1278         spin_unlock_irqrestore(&emu->reg_lock, flags);
1279         return change;
1280 }
1281
1282 static const struct snd_kcontrol_new snd_emu10k1_send_routing_control =
1283 {
1284         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1285         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1286         .name =         "EMU10K1 PCM Send Routing",
1287         .count =        32,
1288         .info =         snd_emu10k1_send_routing_info,
1289         .get =          snd_emu10k1_send_routing_get,
1290         .put =          snd_emu10k1_send_routing_put
1291 };
1292
1293 static int snd_emu10k1_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1294 {
1295         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1296         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1297         uinfo->count = emu->audigy ? 3*8 : 3*4;
1298         uinfo->value.integer.min = 0;
1299         uinfo->value.integer.max = 255;
1300         return 0;
1301 }
1302
1303 static int snd_emu10k1_send_volume_get(struct snd_kcontrol *kcontrol,
1304                                        struct snd_ctl_elem_value *ucontrol)
1305 {
1306         unsigned long flags;
1307         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1308         struct snd_emu10k1_pcm_mixer *mix =
1309                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1310         int idx;
1311         int num_efx = emu->audigy ? 8 : 4;
1312
1313         spin_lock_irqsave(&emu->reg_lock, flags);
1314         for (idx = 0; idx < 3*num_efx; idx++)
1315                 ucontrol->value.integer.value[idx] = mix->send_volume[idx/num_efx][idx%num_efx];
1316         spin_unlock_irqrestore(&emu->reg_lock, flags);
1317         return 0;
1318 }
1319
1320 static int snd_emu10k1_send_volume_put(struct snd_kcontrol *kcontrol,
1321                                        struct snd_ctl_elem_value *ucontrol)
1322 {
1323         unsigned long flags;
1324         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1325         struct snd_emu10k1_pcm_mixer *mix =
1326                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1327         int change = 0, idx, val;
1328         int num_efx = emu->audigy ? 8 : 4;
1329
1330         spin_lock_irqsave(&emu->reg_lock, flags);
1331         for (idx = 0; idx < 3*num_efx; idx++) {
1332                 val = ucontrol->value.integer.value[idx] & 255;
1333                 if (mix->send_volume[idx/num_efx][idx%num_efx] != val) {
1334                         mix->send_volume[idx/num_efx][idx%num_efx] = val;
1335                         change = 1;
1336                 }
1337         }
1338         if (change && mix->epcm) {
1339                 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
1340                         update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number,
1341                                                    &mix->send_volume[1][0]);
1342                         update_emu10k1_send_volume(emu, mix->epcm->voices[1]->number,
1343                                                    &mix->send_volume[2][0]);
1344                 } else if (mix->epcm->voices[0]) {
1345                         update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number,
1346                                                    &mix->send_volume[0][0]);
1347                 }
1348         }
1349         spin_unlock_irqrestore(&emu->reg_lock, flags);
1350         return change;
1351 }
1352
1353 static const struct snd_kcontrol_new snd_emu10k1_send_volume_control =
1354 {
1355         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1356         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1357         .name =         "EMU10K1 PCM Send Volume",
1358         .count =        32,
1359         .info =         snd_emu10k1_send_volume_info,
1360         .get =          snd_emu10k1_send_volume_get,
1361         .put =          snd_emu10k1_send_volume_put
1362 };
1363
1364 static int snd_emu10k1_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1365 {
1366         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1367         uinfo->count = 3;
1368         uinfo->value.integer.min = 0;
1369         uinfo->value.integer.max = 0xffff;
1370         return 0;
1371 }
1372
1373 static int snd_emu10k1_attn_get(struct snd_kcontrol *kcontrol,
1374                                 struct snd_ctl_elem_value *ucontrol)
1375 {
1376         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1377         struct snd_emu10k1_pcm_mixer *mix =
1378                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1379         unsigned long flags;
1380         int idx;
1381
1382         spin_lock_irqsave(&emu->reg_lock, flags);
1383         for (idx = 0; idx < 3; idx++)
1384                 ucontrol->value.integer.value[idx] = mix->attn[idx];
1385         spin_unlock_irqrestore(&emu->reg_lock, flags);
1386         return 0;
1387 }
1388
1389 static int snd_emu10k1_attn_put(struct snd_kcontrol *kcontrol,
1390                                 struct snd_ctl_elem_value *ucontrol)
1391 {
1392         unsigned long flags;
1393         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1394         struct snd_emu10k1_pcm_mixer *mix =
1395                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1396         int change = 0, idx, val;
1397
1398         spin_lock_irqsave(&emu->reg_lock, flags);
1399         for (idx = 0; idx < 3; idx++) {
1400                 val = ucontrol->value.integer.value[idx] & 0xffff;
1401                 if (mix->attn[idx] != val) {
1402                         mix->attn[idx] = val;
1403                         change = 1;
1404                 }
1405         }
1406         if (change && mix->epcm) {
1407                 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
1408                         snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[1]);
1409                         snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[1]->number, mix->attn[2]);
1410                 } else if (mix->epcm->voices[0]) {
1411                         snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[0]);
1412                 }
1413         }
1414         spin_unlock_irqrestore(&emu->reg_lock, flags);
1415         return change;
1416 }
1417
1418 static const struct snd_kcontrol_new snd_emu10k1_attn_control =
1419 {
1420         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1421         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1422         .name =         "EMU10K1 PCM Volume",
1423         .count =        32,
1424         .info =         snd_emu10k1_attn_info,
1425         .get =          snd_emu10k1_attn_get,
1426         .put =          snd_emu10k1_attn_put
1427 };
1428
1429 /* Mutichannel PCM stream controls */
1430
1431 static int snd_emu10k1_efx_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1432 {
1433         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1434         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1435         uinfo->count = emu->audigy ? 8 : 4;
1436         uinfo->value.integer.min = 0;
1437         uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f;
1438         return 0;
1439 }
1440
1441 static int snd_emu10k1_efx_send_routing_get(struct snd_kcontrol *kcontrol,
1442                                         struct snd_ctl_elem_value *ucontrol)
1443 {
1444         unsigned long flags;
1445         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1446         struct snd_emu10k1_pcm_mixer *mix =
1447                 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1448         int idx;
1449         int num_efx = emu->audigy ? 8 : 4;
1450         int mask = emu->audigy ? 0x3f : 0x0f;
1451
1452         spin_lock_irqsave(&emu->reg_lock, flags);
1453         for (idx = 0; idx < num_efx; idx++)
1454                 ucontrol->value.integer.value[idx] =
1455                         mix->send_routing[0][idx] & mask;
1456         spin_unlock_irqrestore(&emu->reg_lock, flags);
1457         return 0;
1458 }
1459
1460 static int snd_emu10k1_efx_send_routing_put(struct snd_kcontrol *kcontrol,
1461                                         struct snd_ctl_elem_value *ucontrol)
1462 {
1463         unsigned long flags;
1464         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1465         int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1466         struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1467         int change = 0, idx, val;
1468         int num_efx = emu->audigy ? 8 : 4;
1469         int mask = emu->audigy ? 0x3f : 0x0f;
1470
1471         spin_lock_irqsave(&emu->reg_lock, flags);
1472         for (idx = 0; idx < num_efx; idx++) {
1473                 val = ucontrol->value.integer.value[idx] & mask;
1474                 if (mix->send_routing[0][idx] != val) {
1475                         mix->send_routing[0][idx] = val;
1476                         change = 1;
1477                 }
1478         }
1479
1480         if (change && mix->epcm) {
1481                 if (mix->epcm->voices[ch]) {
1482                         update_emu10k1_fxrt(emu, mix->epcm->voices[ch]->number,
1483                                         &mix->send_routing[0][0]);
1484                 }
1485         }
1486         spin_unlock_irqrestore(&emu->reg_lock, flags);
1487         return change;
1488 }
1489
1490 static const struct snd_kcontrol_new snd_emu10k1_efx_send_routing_control =
1491 {
1492         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1493         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1494         .name =         "Multichannel PCM Send Routing",
1495         .count =        16,
1496         .info =         snd_emu10k1_efx_send_routing_info,
1497         .get =          snd_emu10k1_efx_send_routing_get,
1498         .put =          snd_emu10k1_efx_send_routing_put
1499 };
1500
1501 static int snd_emu10k1_efx_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1502 {
1503         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1504         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1505         uinfo->count = emu->audigy ? 8 : 4;
1506         uinfo->value.integer.min = 0;
1507         uinfo->value.integer.max = 255;
1508         return 0;
1509 }
1510
1511 static int snd_emu10k1_efx_send_volume_get(struct snd_kcontrol *kcontrol,
1512                                        struct snd_ctl_elem_value *ucontrol)
1513 {
1514         unsigned long flags;
1515         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1516         struct snd_emu10k1_pcm_mixer *mix =
1517                 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1518         int idx;
1519         int num_efx = emu->audigy ? 8 : 4;
1520
1521         spin_lock_irqsave(&emu->reg_lock, flags);
1522         for (idx = 0; idx < num_efx; idx++)
1523                 ucontrol->value.integer.value[idx] = mix->send_volume[0][idx];
1524         spin_unlock_irqrestore(&emu->reg_lock, flags);
1525         return 0;
1526 }
1527
1528 static int snd_emu10k1_efx_send_volume_put(struct snd_kcontrol *kcontrol,
1529                                        struct snd_ctl_elem_value *ucontrol)
1530 {
1531         unsigned long flags;
1532         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1533         int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1534         struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1535         int change = 0, idx, val;
1536         int num_efx = emu->audigy ? 8 : 4;
1537
1538         spin_lock_irqsave(&emu->reg_lock, flags);
1539         for (idx = 0; idx < num_efx; idx++) {
1540                 val = ucontrol->value.integer.value[idx] & 255;
1541                 if (mix->send_volume[0][idx] != val) {
1542                         mix->send_volume[0][idx] = val;
1543                         change = 1;
1544                 }
1545         }
1546         if (change && mix->epcm) {
1547                 if (mix->epcm->voices[ch]) {
1548                         update_emu10k1_send_volume(emu, mix->epcm->voices[ch]->number,
1549                                                    &mix->send_volume[0][0]);
1550                 }
1551         }
1552         spin_unlock_irqrestore(&emu->reg_lock, flags);
1553         return change;
1554 }
1555
1556
1557 static const struct snd_kcontrol_new snd_emu10k1_efx_send_volume_control =
1558 {
1559         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1560         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1561         .name =         "Multichannel PCM Send Volume",
1562         .count =        16,
1563         .info =         snd_emu10k1_efx_send_volume_info,
1564         .get =          snd_emu10k1_efx_send_volume_get,
1565         .put =          snd_emu10k1_efx_send_volume_put
1566 };
1567
1568 static int snd_emu10k1_efx_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1569 {
1570         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1571         uinfo->count = 1;
1572         uinfo->value.integer.min = 0;
1573         uinfo->value.integer.max = 0xffff;
1574         return 0;
1575 }
1576
1577 static int snd_emu10k1_efx_attn_get(struct snd_kcontrol *kcontrol,
1578                                 struct snd_ctl_elem_value *ucontrol)
1579 {
1580         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1581         struct snd_emu10k1_pcm_mixer *mix =
1582                 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
1583         unsigned long flags;
1584
1585         spin_lock_irqsave(&emu->reg_lock, flags);
1586         ucontrol->value.integer.value[0] = mix->attn[0];
1587         spin_unlock_irqrestore(&emu->reg_lock, flags);
1588         return 0;
1589 }
1590
1591 static int snd_emu10k1_efx_attn_put(struct snd_kcontrol *kcontrol,
1592                                 struct snd_ctl_elem_value *ucontrol)
1593 {
1594         unsigned long flags;
1595         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1596         int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1597         struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
1598         int change = 0, val;
1599
1600         spin_lock_irqsave(&emu->reg_lock, flags);
1601         val = ucontrol->value.integer.value[0] & 0xffff;
1602         if (mix->attn[0] != val) {
1603                 mix->attn[0] = val;
1604                 change = 1;
1605         }
1606         if (change && mix->epcm) {
1607                 if (mix->epcm->voices[ch]) {
1608                         snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[ch]->number, mix->attn[0]);
1609                 }
1610         }
1611         spin_unlock_irqrestore(&emu->reg_lock, flags);
1612         return change;
1613 }
1614
1615 static const struct snd_kcontrol_new snd_emu10k1_efx_attn_control =
1616 {
1617         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
1618         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1619         .name =         "Multichannel PCM Volume",
1620         .count =        16,
1621         .info =         snd_emu10k1_efx_attn_info,
1622         .get =          snd_emu10k1_efx_attn_get,
1623         .put =          snd_emu10k1_efx_attn_put
1624 };
1625
1626 #define snd_emu10k1_shared_spdif_info   snd_ctl_boolean_mono_info
1627
1628 static int snd_emu10k1_shared_spdif_get(struct snd_kcontrol *kcontrol,
1629                                         struct snd_ctl_elem_value *ucontrol)
1630 {
1631         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1632
1633         if (emu->audigy)
1634                 ucontrol->value.integer.value[0] = inl(emu->port + A_IOCFG) & A_IOCFG_GPOUT0 ? 1 : 0;
1635         else
1636                 ucontrol->value.integer.value[0] = inl(emu->port + HCFG) & HCFG_GPOUT0 ? 1 : 0;
1637         if (emu->card_capabilities->invert_shared_spdif)
1638                 ucontrol->value.integer.value[0] =
1639                         !ucontrol->value.integer.value[0];
1640
1641         return 0;
1642 }
1643
1644 static int snd_emu10k1_shared_spdif_put(struct snd_kcontrol *kcontrol,
1645                                         struct snd_ctl_elem_value *ucontrol)
1646 {
1647         unsigned long flags;
1648         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1649         unsigned int reg, val, sw;
1650         int change = 0;
1651
1652         sw = ucontrol->value.integer.value[0];
1653         if (emu->card_capabilities->invert_shared_spdif)
1654                 sw = !sw;
1655         spin_lock_irqsave(&emu->reg_lock, flags);
1656         if ( emu->card_capabilities->i2c_adc) {
1657                 /* Do nothing for Audigy 2 ZS Notebook */
1658         } else if (emu->audigy) {
1659                 reg = inl(emu->port + A_IOCFG);
1660                 val = sw ? A_IOCFG_GPOUT0 : 0;
1661                 change = (reg & A_IOCFG_GPOUT0) != val;
1662                 if (change) {
1663                         reg &= ~A_IOCFG_GPOUT0;
1664                         reg |= val;
1665                         outl(reg | val, emu->port + A_IOCFG);
1666                 }
1667         }
1668         reg = inl(emu->port + HCFG);
1669         val = sw ? HCFG_GPOUT0 : 0;
1670         change |= (reg & HCFG_GPOUT0) != val;
1671         if (change) {
1672                 reg &= ~HCFG_GPOUT0;
1673                 reg |= val;
1674                 outl(reg | val, emu->port + HCFG);
1675         }
1676         spin_unlock_irqrestore(&emu->reg_lock, flags);
1677         return change;
1678 }
1679
1680 static const struct snd_kcontrol_new snd_emu10k1_shared_spdif =
1681 {
1682         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
1683         .name =         "SB Live Analog/Digital Output Jack",
1684         .info =         snd_emu10k1_shared_spdif_info,
1685         .get =          snd_emu10k1_shared_spdif_get,
1686         .put =          snd_emu10k1_shared_spdif_put
1687 };
1688
1689 static const struct snd_kcontrol_new snd_audigy_shared_spdif =
1690 {
1691         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
1692         .name =         "Audigy Analog/Digital Output Jack",
1693         .info =         snd_emu10k1_shared_spdif_info,
1694         .get =          snd_emu10k1_shared_spdif_get,
1695         .put =          snd_emu10k1_shared_spdif_put
1696 };
1697
1698 /* workaround for too low volume on Audigy due to 16bit/24bit conversion */
1699
1700 #define snd_audigy_capture_boost_info   snd_ctl_boolean_mono_info
1701
1702 static int snd_audigy_capture_boost_get(struct snd_kcontrol *kcontrol,
1703                                         struct snd_ctl_elem_value *ucontrol)
1704 {
1705         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1706         unsigned int val;
1707
1708         /* FIXME: better to use a cached version */
1709         val = snd_ac97_read(emu->ac97, AC97_REC_GAIN);
1710         ucontrol->value.integer.value[0] = !!val;
1711         return 0;
1712 }
1713
1714 static int snd_audigy_capture_boost_put(struct snd_kcontrol *kcontrol,
1715                                         struct snd_ctl_elem_value *ucontrol)
1716 {
1717         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1718         unsigned int val;
1719
1720         if (ucontrol->value.integer.value[0])
1721                 val = 0x0f0f;
1722         else
1723                 val = 0;
1724         return snd_ac97_update(emu->ac97, AC97_REC_GAIN, val);
1725 }
1726
1727 static const struct snd_kcontrol_new snd_audigy_capture_boost =
1728 {
1729         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
1730         .name =         "Mic Extra Boost",
1731         .info =         snd_audigy_capture_boost_info,
1732         .get =          snd_audigy_capture_boost_get,
1733         .put =          snd_audigy_capture_boost_put
1734 };
1735
1736
1737 /*
1738  */
1739 static void snd_emu10k1_mixer_free_ac97(struct snd_ac97 *ac97)
1740 {
1741         struct snd_emu10k1 *emu = ac97->private_data;
1742         emu->ac97 = NULL;
1743 }
1744
1745 /*
1746  */
1747 static int remove_ctl(struct snd_card *card, const char *name)
1748 {
1749         struct snd_ctl_elem_id id;
1750         memset(&id, 0, sizeof(id));
1751         strcpy(id.name, name);
1752         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1753         return snd_ctl_remove_id(card, &id);
1754 }
1755
1756 static struct snd_kcontrol *ctl_find(struct snd_card *card, const char *name)
1757 {
1758         struct snd_ctl_elem_id sid;
1759         memset(&sid, 0, sizeof(sid));
1760         strcpy(sid.name, name);
1761         sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1762         return snd_ctl_find_id(card, &sid);
1763 }
1764
1765 static int rename_ctl(struct snd_card *card, const char *src, const char *dst)
1766 {
1767         struct snd_kcontrol *kctl = ctl_find(card, src);
1768         if (kctl) {
1769                 strcpy(kctl->id.name, dst);
1770                 return 0;
1771         }
1772         return -ENOENT;
1773 }
1774
1775 int snd_emu10k1_mixer(struct snd_emu10k1 *emu,
1776                       int pcm_device, int multi_device)
1777 {
1778         int err, pcm;
1779         struct snd_kcontrol *kctl;
1780         struct snd_card *card = emu->card;
1781         const char * const *c;
1782         static const char * const emu10k1_remove_ctls[] = {
1783                 /* no AC97 mono, surround, center/lfe */
1784                 "Master Mono Playback Switch",
1785                 "Master Mono Playback Volume",
1786                 "PCM Out Path & Mute",
1787                 "Mono Output Select",
1788                 "Surround Playback Switch",
1789                 "Surround Playback Volume",
1790                 "Center Playback Switch",
1791                 "Center Playback Volume",
1792                 "LFE Playback Switch",
1793                 "LFE Playback Volume",
1794                 NULL
1795         };
1796         static const char * const emu10k1_rename_ctls[] = {
1797                 "Surround Digital Playback Volume", "Surround Playback Volume",
1798                 "Center Digital Playback Volume", "Center Playback Volume",
1799                 "LFE Digital Playback Volume", "LFE Playback Volume",
1800                 NULL
1801         };
1802         static const char * const audigy_remove_ctls[] = {
1803                 /* Master/PCM controls on ac97 of Audigy has no effect */
1804                 /* On the Audigy2 the AC97 playback is piped into
1805                  * the Philips ADC for 24bit capture */
1806                 "PCM Playback Switch",
1807                 "PCM Playback Volume",
1808                 "Master Playback Switch",
1809                 "Master Playback Volume",
1810                 "PCM Out Path & Mute",
1811                 "Mono Output Select",
1812                 /* remove unused AC97 capture controls */
1813                 "Capture Source",
1814                 "Capture Switch",
1815                 "Capture Volume",
1816                 "Mic Select",
1817                 "Headphone Playback Switch",
1818                 "Headphone Playback Volume",
1819                 "3D Control - Center",
1820                 "3D Control - Depth",
1821                 "3D Control - Switch",
1822                 "Video Playback Switch",
1823                 "Video Playback Volume",
1824                 "Mic Playback Switch",
1825                 "Mic Playback Volume",
1826                 "External Amplifier",
1827                 NULL
1828         };
1829         static const char * const audigy_rename_ctls[] = {
1830                 /* use conventional names */
1831                 "Wave Playback Volume", "PCM Playback Volume",
1832                 /* "Wave Capture Volume", "PCM Capture Volume", */
1833                 "Wave Master Playback Volume", "Master Playback Volume",
1834                 "AMic Playback Volume", "Mic Playback Volume",
1835                 "Master Mono Playback Switch", "Phone Output Playback Switch",
1836                 "Master Mono Playback Volume", "Phone Output Playback Volume",
1837                 NULL
1838         };
1839         static const char * const audigy_rename_ctls_i2c_adc[] = {
1840                 //"Analog Mix Capture Volume","OLD Analog Mix Capture Volume",
1841                 "Line Capture Volume", "Analog Mix Capture Volume",
1842                 "Wave Playback Volume", "OLD PCM Playback Volume",
1843                 "Wave Master Playback Volume", "Master Playback Volume",
1844                 "AMic Playback Volume", "Old Mic Playback Volume",
1845                 "CD Capture Volume", "IEC958 Optical Capture Volume",
1846                 NULL
1847         };
1848         static const char * const audigy_remove_ctls_i2c_adc[] = {
1849                 /* On the Audigy2 ZS Notebook
1850                  * Capture via WM8775  */
1851                 "Mic Capture Volume",
1852                 "Analog Mix Capture Volume",
1853                 "Aux Capture Volume",
1854                 "IEC958 Optical Capture Volume",
1855                 NULL
1856         };
1857         static const char * const audigy_remove_ctls_1361t_adc[] = {
1858                 /* On the Audigy2 the AC97 playback is piped into
1859                  * the Philips ADC for 24bit capture */
1860                 "PCM Playback Switch",
1861                 "PCM Playback Volume",
1862                 "Capture Source",
1863                 "Capture Switch",
1864                 "Capture Volume",
1865                 "Mic Capture Volume",
1866                 "Headphone Playback Switch",
1867                 "Headphone Playback Volume",
1868                 "3D Control - Center",
1869                 "3D Control - Depth",
1870                 "3D Control - Switch",
1871                 "Line2 Playback Volume",
1872                 "Line2 Capture Volume",
1873                 NULL
1874         };
1875         static const char * const audigy_rename_ctls_1361t_adc[] = {
1876                 "Master Playback Switch", "Master Capture Switch",
1877                 "Master Playback Volume", "Master Capture Volume",
1878                 "Wave Master Playback Volume", "Master Playback Volume",
1879                 "Beep Playback Switch", "Beep Capture Switch",
1880                 "Beep Playback Volume", "Beep Capture Volume",
1881                 "Phone Playback Switch", "Phone Capture Switch",
1882                 "Phone Playback Volume", "Phone Capture Volume",
1883                 "Mic Playback Switch", "Mic Capture Switch",
1884                 "Mic Playback Volume", "Mic Capture Volume",
1885                 "Line Playback Switch", "Line Capture Switch",
1886                 "Line Playback Volume", "Line Capture Volume",
1887                 "CD Playback Switch", "CD Capture Switch",
1888                 "CD Playback Volume", "CD Capture Volume",
1889                 "Aux Playback Switch", "Aux Capture Switch",
1890                 "Aux Playback Volume", "Aux Capture Volume",
1891                 "Video Playback Switch", "Video Capture Switch",
1892                 "Video Playback Volume", "Video Capture Volume",
1893                 "Master Mono Playback Switch", "Phone Output Playback Switch",
1894                 "Master Mono Playback Volume", "Phone Output Playback Volume",
1895                 NULL
1896         };
1897
1898         if (emu->card_capabilities->ac97_chip) {
1899                 struct snd_ac97_bus *pbus;
1900                 struct snd_ac97_template ac97;
1901                 static const struct snd_ac97_bus_ops ops = {
1902                         .write = snd_emu10k1_ac97_write,
1903                         .read = snd_emu10k1_ac97_read,
1904                 };
1905
1906                 if ((err = snd_ac97_bus(emu->card, 0, &ops, NULL, &pbus)) < 0)
1907                         return err;
1908                 pbus->no_vra = 1; /* we don't need VRA */
1909
1910                 memset(&ac97, 0, sizeof(ac97));
1911                 ac97.private_data = emu;
1912                 ac97.private_free = snd_emu10k1_mixer_free_ac97;
1913                 ac97.scaps = AC97_SCAP_NO_SPDIF;
1914                 if ((err = snd_ac97_mixer(pbus, &ac97, &emu->ac97)) < 0) {
1915                         if (emu->card_capabilities->ac97_chip == 1)
1916                                 return err;
1917                         dev_info(emu->card->dev,
1918                                  "AC97 is optional on this board\n");
1919                         dev_info(emu->card->dev,
1920                                  "Proceeding without ac97 mixers...\n");
1921                         snd_device_free(emu->card, pbus);
1922                         goto no_ac97; /* FIXME: get rid of ugly gotos.. */
1923                 }
1924                 if (emu->audigy) {
1925                         /* set master volume to 0 dB */
1926                         snd_ac97_write_cache(emu->ac97, AC97_MASTER, 0x0000);
1927                         /* set capture source to mic */
1928                         snd_ac97_write_cache(emu->ac97, AC97_REC_SEL, 0x0000);
1929                         /* set mono output (TAD) to mic */
1930                         snd_ac97_update_bits(emu->ac97, AC97_GENERAL_PURPOSE,
1931                                 0x0200, 0x0200);
1932                         if (emu->card_capabilities->adc_1361t)
1933                                 c = audigy_remove_ctls_1361t_adc;
1934                         else
1935                                 c = audigy_remove_ctls;
1936                 } else {
1937                         /*
1938                          * Credits for cards based on STAC9758:
1939                          *   James Courtier-Dutton <James@superbug.demon.co.uk>
1940                          *   Voluspa <voluspa@comhem.se>
1941                          */
1942                         if (emu->ac97->id == AC97_ID_STAC9758) {
1943                                 emu->rear_ac97 = 1;
1944                                 snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_CNTR|AC97SLOT_LFE|AC97SLOT_REAR_LEFT|AC97SLOT_REAR_RIGHT);
1945                                 snd_ac97_write_cache(emu->ac97, AC97_HEADPHONE, 0x0202);
1946                                 remove_ctl(card,"Front Playback Volume");
1947                                 remove_ctl(card,"Front Playback Switch");
1948                         }
1949                         /* remove unused AC97 controls */
1950                         snd_ac97_write_cache(emu->ac97, AC97_SURROUND_MASTER, 0x0202);
1951                         snd_ac97_write_cache(emu->ac97, AC97_CENTER_LFE_MASTER, 0x0202);
1952                         c = emu10k1_remove_ctls;
1953                 }
1954                 for (; *c; c++)
1955                         remove_ctl(card, *c);
1956         } else if (emu->card_capabilities->i2c_adc) {
1957                 c = audigy_remove_ctls_i2c_adc;
1958                 for (; *c; c++)
1959                         remove_ctl(card, *c);
1960         } else {
1961         no_ac97:
1962                 if (emu->card_capabilities->ecard)
1963                         strcpy(emu->card->mixername, "EMU APS");
1964                 else if (emu->audigy)
1965                         strcpy(emu->card->mixername, "SB Audigy");
1966                 else
1967                         strcpy(emu->card->mixername, "Emu10k1");
1968         }
1969
1970         if (emu->audigy)
1971                 if (emu->card_capabilities->adc_1361t)
1972                         c = audigy_rename_ctls_1361t_adc;
1973                 else if (emu->card_capabilities->i2c_adc)
1974                         c = audigy_rename_ctls_i2c_adc;
1975                 else
1976                         c = audigy_rename_ctls;
1977         else
1978                 c = emu10k1_rename_ctls;
1979         for (; *c; c += 2)
1980                 rename_ctl(card, c[0], c[1]);
1981
1982         if (emu->card_capabilities->subsystem == 0x80401102) { /* SB Live! Platinum CT4760P */
1983                 remove_ctl(card, "Center Playback Volume");
1984                 remove_ctl(card, "LFE Playback Volume");
1985                 remove_ctl(card, "Wave Center Playback Volume");
1986                 remove_ctl(card, "Wave LFE Playback Volume");
1987         }
1988         if (emu->card_capabilities->subsystem == 0x20071102) {  /* Audigy 4 Pro */
1989                 rename_ctl(card, "Line2 Capture Volume", "Line1/Mic Capture Volume");
1990                 rename_ctl(card, "Analog Mix Capture Volume", "Line2 Capture Volume");
1991                 rename_ctl(card, "Aux2 Capture Volume", "Line3 Capture Volume");
1992                 rename_ctl(card, "Mic Capture Volume", "Unknown1 Capture Volume");
1993         }
1994         if ((kctl = emu->ctl_send_routing = snd_ctl_new1(&snd_emu10k1_send_routing_control, emu)) == NULL)
1995                 return -ENOMEM;
1996         kctl->id.device = pcm_device;
1997         if ((err = snd_ctl_add(card, kctl)))
1998                 return err;
1999         if ((kctl = emu->ctl_send_volume = snd_ctl_new1(&snd_emu10k1_send_volume_control, emu)) == NULL)
2000                 return -ENOMEM;
2001         kctl->id.device = pcm_device;
2002         if ((err = snd_ctl_add(card, kctl)))
2003                 return err;
2004         if ((kctl = emu->ctl_attn = snd_ctl_new1(&snd_emu10k1_attn_control, emu)) == NULL)
2005                 return -ENOMEM;
2006         kctl->id.device = pcm_device;
2007         if ((err = snd_ctl_add(card, kctl)))
2008                 return err;
2009
2010         if ((kctl = emu->ctl_efx_send_routing = snd_ctl_new1(&snd_emu10k1_efx_send_routing_control, emu)) == NULL)
2011                 return -ENOMEM;
2012         kctl->id.device = multi_device;
2013         if ((err = snd_ctl_add(card, kctl)))
2014                 return err;
2015
2016         if ((kctl = emu->ctl_efx_send_volume = snd_ctl_new1(&snd_emu10k1_efx_send_volume_control, emu)) == NULL)
2017                 return -ENOMEM;
2018         kctl->id.device = multi_device;
2019         if ((err = snd_ctl_add(card, kctl)))
2020                 return err;
2021
2022         if ((kctl = emu->ctl_efx_attn = snd_ctl_new1(&snd_emu10k1_efx_attn_control, emu)) == NULL)
2023                 return -ENOMEM;
2024         kctl->id.device = multi_device;
2025         if ((err = snd_ctl_add(card, kctl)))
2026                 return err;
2027
2028         /* initialize the routing and volume table for each pcm playback stream */
2029         for (pcm = 0; pcm < 32; pcm++) {
2030                 struct snd_emu10k1_pcm_mixer *mix;
2031                 int v;
2032
2033                 mix = &emu->pcm_mixer[pcm];
2034                 mix->epcm = NULL;
2035
2036                 for (v = 0; v < 4; v++)
2037                         mix->send_routing[0][v] =
2038                                 mix->send_routing[1][v] =
2039                                 mix->send_routing[2][v] = v;
2040
2041                 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
2042                 mix->send_volume[0][0] = mix->send_volume[0][1] =
2043                 mix->send_volume[1][0] = mix->send_volume[2][1] = 255;
2044
2045                 mix->attn[0] = mix->attn[1] = mix->attn[2] = 0xffff;
2046         }
2047
2048         /* initialize the routing and volume table for the multichannel playback stream */
2049         for (pcm = 0; pcm < NUM_EFX_PLAYBACK; pcm++) {
2050                 struct snd_emu10k1_pcm_mixer *mix;
2051                 int v;
2052
2053                 mix = &emu->efx_pcm_mixer[pcm];
2054                 mix->epcm = NULL;
2055
2056                 mix->send_routing[0][0] = pcm;
2057                 mix->send_routing[0][1] = (pcm == 0) ? 1 : 0;
2058                 for (v = 0; v < 2; v++)
2059                         mix->send_routing[0][2+v] = 13+v;
2060                 if (emu->audigy)
2061                         for (v = 0; v < 4; v++)
2062                                 mix->send_routing[0][4+v] = 60+v;
2063
2064                 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
2065                 mix->send_volume[0][0]  = 255;
2066
2067                 mix->attn[0] = 0xffff;
2068         }
2069
2070         if (! emu->card_capabilities->ecard) { /* FIXME: APS has these controls? */
2071                 /* sb live! and audigy */
2072                 if ((kctl = snd_ctl_new1(&snd_emu10k1_spdif_mask_control, emu)) == NULL)
2073                         return -ENOMEM;
2074                 if (!emu->audigy)
2075                         kctl->id.device = emu->pcm_efx->device;
2076                 if ((err = snd_ctl_add(card, kctl)))
2077                         return err;
2078                 if ((kctl = snd_ctl_new1(&snd_emu10k1_spdif_control, emu)) == NULL)
2079                         return -ENOMEM;
2080                 if (!emu->audigy)
2081                         kctl->id.device = emu->pcm_efx->device;
2082                 if ((err = snd_ctl_add(card, kctl)))
2083                         return err;
2084         }
2085
2086         if (emu->card_capabilities->emu_model) {
2087                 ;  /* Disable the snd_audigy_spdif_shared_spdif */
2088         } else if (emu->audigy) {
2089                 if ((kctl = snd_ctl_new1(&snd_audigy_shared_spdif, emu)) == NULL)
2090                         return -ENOMEM;
2091                 if ((err = snd_ctl_add(card, kctl)))
2092                         return err;
2093 #if 0
2094                 if ((kctl = snd_ctl_new1(&snd_audigy_spdif_output_rate, emu)) == NULL)
2095                         return -ENOMEM;
2096                 if ((err = snd_ctl_add(card, kctl)))
2097                         return err;
2098 #endif
2099         } else if (! emu->card_capabilities->ecard) {
2100                 /* sb live! */
2101                 if ((kctl = snd_ctl_new1(&snd_emu10k1_shared_spdif, emu)) == NULL)
2102                         return -ENOMEM;
2103                 if ((err = snd_ctl_add(card, kctl)))
2104                         return err;
2105         }
2106         if (emu->card_capabilities->ca0151_chip) { /* P16V */
2107                 if ((err = snd_p16v_mixer(emu)))
2108                         return err;
2109         }
2110
2111         if (emu->card_capabilities->emu_model == EMU_MODEL_EMU1616) {
2112                 /* 1616(m) cardbus */
2113                 int i;
2114
2115                 for (i = 0; i < ARRAY_SIZE(snd_emu1616_output_enum_ctls); i++) {
2116                         err = snd_ctl_add(card,
2117                                 snd_ctl_new1(&snd_emu1616_output_enum_ctls[i],
2118                                              emu));
2119                         if (err < 0)
2120                                 return err;
2121                 }
2122                 for (i = 0; i < ARRAY_SIZE(snd_emu1010_input_enum_ctls); i++) {
2123                         err = snd_ctl_add(card,
2124                                 snd_ctl_new1(&snd_emu1010_input_enum_ctls[i],
2125                                              emu));
2126                         if (err < 0)
2127                                 return err;
2128                 }
2129                 for (i = 0; i < ARRAY_SIZE(snd_emu1010_adc_pads) - 2; i++) {
2130                         err = snd_ctl_add(card,
2131                                 snd_ctl_new1(&snd_emu1010_adc_pads[i], emu));
2132                         if (err < 0)
2133                                 return err;
2134                 }
2135                 for (i = 0; i < ARRAY_SIZE(snd_emu1010_dac_pads) - 2; i++) {
2136                         err = snd_ctl_add(card,
2137                                 snd_ctl_new1(&snd_emu1010_dac_pads[i], emu));
2138                         if (err < 0)
2139                                 return err;
2140                 }
2141                 err = snd_ctl_add(card,
2142                         snd_ctl_new1(&snd_emu1010_internal_clock, emu));
2143                 if (err < 0)
2144                         return err;
2145                 err = snd_ctl_add(card,
2146                         snd_ctl_new1(&snd_emu1010_optical_out, emu));
2147                 if (err < 0)
2148                         return err;
2149                 err = snd_ctl_add(card,
2150                         snd_ctl_new1(&snd_emu1010_optical_in, emu));
2151                 if (err < 0)
2152                         return err;
2153
2154         } else if (emu->card_capabilities->emu_model) {
2155                 /* all other e-mu cards for now */
2156                 int i;
2157
2158                 for (i = 0; i < ARRAY_SIZE(snd_emu1010_output_enum_ctls); i++) {
2159                         err = snd_ctl_add(card,
2160                                 snd_ctl_new1(&snd_emu1010_output_enum_ctls[i],
2161                                              emu));
2162                         if (err < 0)
2163                                 return err;
2164                 }
2165                 for (i = 0; i < ARRAY_SIZE(snd_emu1010_input_enum_ctls); i++) {
2166                         err = snd_ctl_add(card,
2167                                 snd_ctl_new1(&snd_emu1010_input_enum_ctls[i],
2168                                              emu));
2169                         if (err < 0)
2170                                 return err;
2171                 }
2172                 for (i = 0; i < ARRAY_SIZE(snd_emu1010_adc_pads); i++) {
2173                         err = snd_ctl_add(card,
2174                                 snd_ctl_new1(&snd_emu1010_adc_pads[i], emu));
2175                         if (err < 0)
2176                                 return err;
2177                 }
2178                 for (i = 0; i < ARRAY_SIZE(snd_emu1010_dac_pads); i++) {
2179                         err = snd_ctl_add(card,
2180                                 snd_ctl_new1(&snd_emu1010_dac_pads[i], emu));
2181                         if (err < 0)
2182                                 return err;
2183                 }
2184                 err = snd_ctl_add(card,
2185                         snd_ctl_new1(&snd_emu1010_internal_clock, emu));
2186                 if (err < 0)
2187                         return err;
2188                 err = snd_ctl_add(card,
2189                         snd_ctl_new1(&snd_emu1010_optical_out, emu));
2190                 if (err < 0)
2191                         return err;
2192                 err = snd_ctl_add(card,
2193                         snd_ctl_new1(&snd_emu1010_optical_in, emu));
2194                 if (err < 0)
2195                         return err;
2196         }
2197
2198         if ( emu->card_capabilities->i2c_adc) {
2199                 int i;
2200
2201                 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_i2c_capture_source, emu));
2202                 if (err < 0)
2203                         return err;
2204
2205                 for (i = 0; i < ARRAY_SIZE(snd_audigy_i2c_volume_ctls); i++) {
2206                         err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_i2c_volume_ctls[i], emu));
2207                         if (err < 0)
2208                                 return err;
2209                 }
2210         }
2211
2212         if (emu->card_capabilities->ac97_chip && emu->audigy) {
2213                 err = snd_ctl_add(card, snd_ctl_new1(&snd_audigy_capture_boost,
2214                                                      emu));
2215                 if (err < 0)
2216                         return err;
2217         }
2218
2219         return 0;
2220 }