linux/sound/pci/emu10k1/emumixer.c
<<
>>
Prefs
   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
  30static const DECLARE_TLV_DB_SCALE(snd_audigy_db_scale2, -10350, 50, 1); /* WM8775 gain scale */
  31
  32static 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
  39static 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
  58static 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 */
  72static 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
 130static 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 */
 186static 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 */
 243static 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 */
 299static 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 */
 327static 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 */
 353static 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
 378static 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
 389static 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
 405static 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
 435static 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
 449static 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
 487static 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 */
 516static 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
 548static 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
 577static 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
 585static 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
 616static 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
 625static 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
 633static 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
 664static 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
 673static 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
 683static 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
 692static 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
 784static 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
 795static 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
 805static 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
 814static 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
 836static 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
 846static 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
 856static 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
 865static 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
 887static 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
 897static 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
 912static 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
 921static 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
 967static 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
 976static 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
 986static 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
1003static 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
1054static 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
1060static 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
1067static 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
1094static 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
1128static 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
1140static 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
1166static 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
1176static 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
1187static 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
1200static 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
1217static 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
1227static 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
1247static 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
1282static 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
1293static 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
1303static 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
1320static 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
1353static 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
1364static 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
1373static 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
1389static 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
1418static 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
1431static 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
1441static 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
1460static 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
1490static 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
1501static 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
1511static 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
1528static 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
1557static 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
1568static 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
1577static 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
1591static 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
1615static 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
1628static 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
1644static 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
1680static 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
1689static 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
1702static 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
1714static 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
1727static 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 */
1739static 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 */
1747static 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
1756static 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
1765static 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
1775int 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}
2221