git.oblomov.eu Git - linux-2.6/blob - sound/pci/emu10k1/emumixer.c

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