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