sound/pci/emu10k1/emumixer.c

   1 /*
   2  *  Copyright (c) by Jaroslav Kysela <perex@suse.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  *  BUGS:
   9  *    --
  10  *
  11  *  TODO:
  12  *    --
  13  *
  14  *   This program is free software; you can redistribute it and/or modify
  15  *   it under the terms of the GNU General Public License as published by
  16  *   the Free Software Foundation; either version 2 of the License, or
  17  *   (at your option) any later version.
  18  *
  19  *   This program is distributed in the hope that it will be useful,
  20  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *   GNU General Public License for more details.
  23  *
  24  *   You should have received a copy of the GNU General Public License
  25  *   along with this program; if not, write to the Free Software
  26  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  27  *
  28  */
  29
  30 #include <sound/driver.h>
  31 #include <linux/time.h>
  32 #include <linux/init.h>
  33 #include <sound/core.h>
  34 #include <sound/emu10k1.h>
  35
  36 #define AC97_ID_STAC9758        0x83847658
  37
  38 static int snd_emu10k1_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  39 {
  40         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
  41         uinfo->count = 1;
  42         return 0;
  43 }
  44
  45 static int snd_emu10k1_spdif_get(struct snd_kcontrol *kcontrol,
  46                                  struct snd_ctl_elem_value *ucontrol)
  47 {
  48         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
  49         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
  50         unsigned long flags;
  51
  52         spin_lock_irqsave(&emu->reg_lock, flags);
  53         ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
  54         ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
  55         ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
  56         ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
  57         spin_unlock_irqrestore(&emu->reg_lock, flags);
  58         return 0;
  59 }
  60
  61 static int snd_emu10k1_spdif_get_mask(struct snd_kcontrol *kcontrol,
  62                                       struct snd_ctl_elem_value *ucontrol)
  63 {
  64         ucontrol->value.iec958.status[0] = 0xff;
  65         ucontrol->value.iec958.status[1] = 0xff;
  66         ucontrol->value.iec958.status[2] = 0xff;
  67         ucontrol->value.iec958.status[3] = 0xff;
  68         return 0;
  69 }
  70
  71 #if 0
  72 static int snd_audigy_spdif_output_rate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  73 {
  74         static char *texts[] = {"44100", "48000", "96000"};
  75
  76         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  77         uinfo->count = 1;
  78         uinfo->value.enumerated.items = 3;
  79         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
  80                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
  81         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
  82         return 0;
  83 }
  84
  85 static int snd_audigy_spdif_output_rate_get(struct snd_kcontrol *kcontrol,
  86                                  struct snd_ctl_elem_value *ucontrol)
  87 {
  88         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
  89         unsigned int tmp;
  90         unsigned long flags;
  91
  92
  93         spin_lock_irqsave(&emu->reg_lock, flags);
  94         tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0);
  95         switch (tmp & A_SPDIF_RATE_MASK) {
  96         case A_SPDIF_44100:
  97                 ucontrol->value.enumerated.item[0] = 0;
  98                 break;
  99         case A_SPDIF_48000:
 100                 ucontrol->value.enumerated.item[0] = 1;
 101                 break;
 102         case A_SPDIF_96000:
 103                 ucontrol->value.enumerated.item[0] = 2;
 104                 break;
 105         default:
 106                 ucontrol->value.enumerated.item[0] = 1;
 107         }
 108         spin_unlock_irqrestore(&emu->reg_lock, flags);
 109         return 0;
 110 }
 111
 112 static int snd_audigy_spdif_output_rate_put(struct snd_kcontrol *kcontrol,
 113                                  struct snd_ctl_elem_value *ucontrol)
 114 {
 115         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 116         int change;
 117         unsigned int reg, val, tmp;
 118         unsigned long flags;
 119
 120         switch(ucontrol->value.enumerated.item[0]) {
 121         case 0:
 122                 val = A_SPDIF_44100;
 123                 break;
 124         case 1:
 125                 val = A_SPDIF_48000;
 126                 break;
 127         case 2:
 128                 val = A_SPDIF_96000;
 129                 break;
 130         default:
 131                 val = A_SPDIF_48000;
 132                 break;
 133         }
 134
 135
 136         spin_lock_irqsave(&emu->reg_lock, flags);
 137         reg = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0);
 138         tmp = reg & ~A_SPDIF_RATE_MASK;
 139         tmp |= val;
 140         if ((change = (tmp != reg)))
 141                 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, 0, tmp);
 142         spin_unlock_irqrestore(&emu->reg_lock, flags);
 143         return change;
 144 }
 145
 146 static struct snd_kcontrol_new snd_audigy_spdif_output_rate =
 147 {
 148         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE,
 149         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 150         .name =         "Audigy SPDIF Output Sample Rate",
 151         .count =        1,
 152         .info =         snd_audigy_spdif_output_rate_info,
 153         .get =          snd_audigy_spdif_output_rate_get,
 154         .put =          snd_audigy_spdif_output_rate_put
 155 };
 156 #endif
 157
 158 static int snd_emu10k1_spdif_put(struct snd_kcontrol *kcontrol,
 159                                  struct snd_ctl_elem_value *ucontrol)
 160 {
 161         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 162         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 163         int change;
 164         unsigned int val;
 165         unsigned long flags;
 166
 167         val = (ucontrol->value.iec958.status[0] << 0) |
 168               (ucontrol->value.iec958.status[1] << 8) |
 169               (ucontrol->value.iec958.status[2] << 16) |
 170               (ucontrol->value.iec958.status[3] << 24);
 171         spin_lock_irqsave(&emu->reg_lock, flags);
 172         change = val != emu->spdif_bits[idx];
 173         if (change) {
 174                 snd_emu10k1_ptr_write(emu, SPCS0 + idx, 0, val);
 175                 emu->spdif_bits[idx] = val;
 176         }
 177         spin_unlock_irqrestore(&emu->reg_lock, flags);
 178         return change;
 179 }
 180
 181 static struct snd_kcontrol_new snd_emu10k1_spdif_mask_control =
 182 {
 183         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 184         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 185         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
 186         .count =        4,
 187         .info =         snd_emu10k1_spdif_info,
 188         .get =          snd_emu10k1_spdif_get_mask
 189 };
 190
 191 static struct snd_kcontrol_new snd_emu10k1_spdif_control =
 192 {
 193         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 194         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 195         .count =        4,
 196         .info =         snd_emu10k1_spdif_info,
 197         .get =          snd_emu10k1_spdif_get,
 198         .put =          snd_emu10k1_spdif_put
 199 };
 200
 201
 202 static void update_emu10k1_fxrt(struct snd_emu10k1 *emu, int voice, unsigned char *route)
 203 {
 204         if (emu->audigy) {
 205                 snd_emu10k1_ptr_write(emu, A_FXRT1, voice,
 206                                       snd_emu10k1_compose_audigy_fxrt1(route));
 207                 snd_emu10k1_ptr_write(emu, A_FXRT2, voice,
 208                                       snd_emu10k1_compose_audigy_fxrt2(route));
 209         } else {
 210                 snd_emu10k1_ptr_write(emu, FXRT, voice,
 211                                       snd_emu10k1_compose_send_routing(route));
 212         }
 213 }
 214
 215 static void update_emu10k1_send_volume(struct snd_emu10k1 *emu, int voice, unsigned char *volume)
 216 {
 217         snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_A, voice, volume[0]);
 218         snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_B, voice, volume[1]);
 219         snd_emu10k1_ptr_write(emu, PSST_FXSENDAMOUNT_C, voice, volume[2]);
 220         snd_emu10k1_ptr_write(emu, DSL_FXSENDAMOUNT_D, voice, volume[3]);
 221         if (emu->audigy) {
 222                 unsigned int val = ((unsigned int)volume[4] << 24) |
 223                         ((unsigned int)volume[5] << 16) |
 224                         ((unsigned int)volume[6] << 8) |
 225                         (unsigned int)volume[7];
 226                 snd_emu10k1_ptr_write(emu, A_SENDAMOUNTS, voice, val);
 227         }
 228 }
 229
 230 /* PCM stream controls */
 231
 232 static int snd_emu10k1_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 233 {
 234         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 235         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 236         uinfo->count = emu->audigy ? 3*8 : 3*4;
 237         uinfo->value.integer.min = 0;
 238         uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f;
 239         return 0;
 240 }
 241
 242 static int snd_emu10k1_send_routing_get(struct snd_kcontrol *kcontrol,
 243                                         struct snd_ctl_elem_value *ucontrol)
 244 {
 245         unsigned long flags;
 246         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 247         struct snd_emu10k1_pcm_mixer *mix =
 248                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 249         int voice, idx;
 250         int num_efx = emu->audigy ? 8 : 4;
 251         int mask = emu->audigy ? 0x3f : 0x0f;
 252
 253         spin_lock_irqsave(&emu->reg_lock, flags);
 254         for (voice = 0; voice < 3; voice++)
 255                 for (idx = 0; idx < num_efx; idx++)
 256                         ucontrol->value.integer.value[(voice * num_efx) + idx] =
 257                                 mix->send_routing[voice][idx] & mask;
 258         spin_unlock_irqrestore(&emu->reg_lock, flags);
 259         return 0;
 260 }
 261
 262 static int snd_emu10k1_send_routing_put(struct snd_kcontrol *kcontrol,
 263                                         struct snd_ctl_elem_value *ucontrol)
 264 {
 265         unsigned long flags;
 266         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 267         struct snd_emu10k1_pcm_mixer *mix =
 268                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 269         int change = 0, voice, idx, val;
 270         int num_efx = emu->audigy ? 8 : 4;
 271         int mask = emu->audigy ? 0x3f : 0x0f;
 272
 273         spin_lock_irqsave(&emu->reg_lock, flags);
 274         for (voice = 0; voice < 3; voice++)
 275                 for (idx = 0; idx < num_efx; idx++) {
 276                         val = ucontrol->value.integer.value[(voice * num_efx) + idx] & mask;
 277                         if (mix->send_routing[voice][idx] != val) {
 278                                 mix->send_routing[voice][idx] = val;
 279                                 change = 1;
 280                         }
 281                 }
 282         if (change && mix->epcm) {
 283                 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
 284                         update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number,
 285                                             &mix->send_routing[1][0]);
 286                         update_emu10k1_fxrt(emu, mix->epcm->voices[1]->number,
 287                                             &mix->send_routing[2][0]);
 288                 } else if (mix->epcm->voices[0]) {
 289                         update_emu10k1_fxrt(emu, mix->epcm->voices[0]->number,
 290                                             &mix->send_routing[0][0]);
 291                 }
 292         }
 293         spin_unlock_irqrestore(&emu->reg_lock, flags);
 294         return change;
 295 }
 296
 297 static struct snd_kcontrol_new snd_emu10k1_send_routing_control =
 298 {
 299         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
 300         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 301         .name =         "EMU10K1 PCM Send Routing",
 302         .count =        32,
 303         .info =         snd_emu10k1_send_routing_info,
 304         .get =          snd_emu10k1_send_routing_get,
 305         .put =          snd_emu10k1_send_routing_put
 306 };
 307
 308 static int snd_emu10k1_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 309 {
 310         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 311         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 312         uinfo->count = emu->audigy ? 3*8 : 3*4;
 313         uinfo->value.integer.min = 0;
 314         uinfo->value.integer.max = 255;
 315         return 0;
 316 }
 317
 318 static int snd_emu10k1_send_volume_get(struct snd_kcontrol *kcontrol,
 319                                        struct snd_ctl_elem_value *ucontrol)
 320 {
 321         unsigned long flags;
 322         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 323         struct snd_emu10k1_pcm_mixer *mix =
 324                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 325         int idx;
 326         int num_efx = emu->audigy ? 8 : 4;
 327
 328         spin_lock_irqsave(&emu->reg_lock, flags);
 329         for (idx = 0; idx < 3*num_efx; idx++)
 330                 ucontrol->value.integer.value[idx] = mix->send_volume[idx/num_efx][idx%num_efx];
 331         spin_unlock_irqrestore(&emu->reg_lock, flags);
 332         return 0;
 333 }
 334
 335 static int snd_emu10k1_send_volume_put(struct snd_kcontrol *kcontrol,
 336                                        struct snd_ctl_elem_value *ucontrol)
 337 {
 338         unsigned long flags;
 339         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 340         struct snd_emu10k1_pcm_mixer *mix =
 341                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 342         int change = 0, idx, val;
 343         int num_efx = emu->audigy ? 8 : 4;
 344
 345         spin_lock_irqsave(&emu->reg_lock, flags);
 346         for (idx = 0; idx < 3*num_efx; idx++) {
 347                 val = ucontrol->value.integer.value[idx] & 255;
 348                 if (mix->send_volume[idx/num_efx][idx%num_efx] != val) {
 349                         mix->send_volume[idx/num_efx][idx%num_efx] = val;
 350                         change = 1;
 351                 }
 352         }
 353         if (change && mix->epcm) {
 354                 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
 355                         update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number,
 356                                                    &mix->send_volume[1][0]);
 357                         update_emu10k1_send_volume(emu, mix->epcm->voices[1]->number,
 358                                                    &mix->send_volume[2][0]);
 359                 } else if (mix->epcm->voices[0]) {
 360                         update_emu10k1_send_volume(emu, mix->epcm->voices[0]->number,
 361                                                    &mix->send_volume[0][0]);
 362                 }
 363         }
 364         spin_unlock_irqrestore(&emu->reg_lock, flags);
 365         return change;
 366 }
 367
 368 static struct snd_kcontrol_new snd_emu10k1_send_volume_control =
 369 {
 370         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
 371         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 372         .name =         "EMU10K1 PCM Send Volume",
 373         .count =        32,
 374         .info =         snd_emu10k1_send_volume_info,
 375         .get =          snd_emu10k1_send_volume_get,
 376         .put =          snd_emu10k1_send_volume_put
 377 };
 378
 379 static int snd_emu10k1_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 380 {
 381         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 382         uinfo->count = 3;
 383         uinfo->value.integer.min = 0;
 384         uinfo->value.integer.max = 0xffff;
 385         return 0;
 386 }
 387
 388 static int snd_emu10k1_attn_get(struct snd_kcontrol *kcontrol,
 389                                 struct snd_ctl_elem_value *ucontrol)
 390 {
 391         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 392         struct snd_emu10k1_pcm_mixer *mix =
 393                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 394         unsigned long flags;
 395         int idx;
 396
 397         spin_lock_irqsave(&emu->reg_lock, flags);
 398         for (idx = 0; idx < 3; idx++)
 399                 ucontrol->value.integer.value[idx] = mix->attn[idx];
 400         spin_unlock_irqrestore(&emu->reg_lock, flags);
 401         return 0;
 402 }
 403
 404 static int snd_emu10k1_attn_put(struct snd_kcontrol *kcontrol,
 405                                 struct snd_ctl_elem_value *ucontrol)
 406 {
 407         unsigned long flags;
 408         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 409         struct snd_emu10k1_pcm_mixer *mix =
 410                 &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 411         int change = 0, idx, val;
 412
 413         spin_lock_irqsave(&emu->reg_lock, flags);
 414         for (idx = 0; idx < 3; idx++) {
 415                 val = ucontrol->value.integer.value[idx] & 0xffff;
 416                 if (mix->attn[idx] != val) {
 417                         mix->attn[idx] = val;
 418                         change = 1;
 419                 }
 420         }
 421         if (change && mix->epcm) {
 422                 if (mix->epcm->voices[0] && mix->epcm->voices[1]) {
 423                         snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[1]);
 424                         snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[1]->number, mix->attn[2]);
 425                 } else if (mix->epcm->voices[0]) {
 426                         snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[0]->number, mix->attn[0]);
 427                 }
 428         }
 429         spin_unlock_irqrestore(&emu->reg_lock, flags);
 430         return change;
 431 }
 432
 433 static struct snd_kcontrol_new snd_emu10k1_attn_control =
 434 {
 435         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
 436         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 437         .name =         "EMU10K1 PCM Volume",
 438         .count =        32,
 439         .info =         snd_emu10k1_attn_info,
 440         .get =          snd_emu10k1_attn_get,
 441         .put =          snd_emu10k1_attn_put
 442 };
 443
 444 /* Mutichannel PCM stream controls */
 445
 446 static int snd_emu10k1_efx_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 447 {
 448         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 449         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 450         uinfo->count = emu->audigy ? 8 : 4;
 451         uinfo->value.integer.min = 0;
 452         uinfo->value.integer.max = emu->audigy ? 0x3f : 0x0f;
 453         return 0;
 454 }
 455
 456 static int snd_emu10k1_efx_send_routing_get(struct snd_kcontrol *kcontrol,
 457                                         struct snd_ctl_elem_value *ucontrol)
 458 {
 459         unsigned long flags;
 460         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 461         struct snd_emu10k1_pcm_mixer *mix =
 462                 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 463         int idx;
 464         int num_efx = emu->audigy ? 8 : 4;
 465         int mask = emu->audigy ? 0x3f : 0x0f;
 466
 467         spin_lock_irqsave(&emu->reg_lock, flags);
 468         for (idx = 0; idx < num_efx; idx++)
 469                 ucontrol->value.integer.value[idx] =
 470                         mix->send_routing[0][idx] & mask;
 471         spin_unlock_irqrestore(&emu->reg_lock, flags);
 472         return 0;
 473 }
 474
 475 static int snd_emu10k1_efx_send_routing_put(struct snd_kcontrol *kcontrol,
 476                                         struct snd_ctl_elem_value *ucontrol)
 477 {
 478         unsigned long flags;
 479         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 480         int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 481         struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
 482         int change = 0, idx, val;
 483         int num_efx = emu->audigy ? 8 : 4;
 484         int mask = emu->audigy ? 0x3f : 0x0f;
 485
 486         spin_lock_irqsave(&emu->reg_lock, flags);
 487         for (idx = 0; idx < num_efx; idx++) {
 488                 val = ucontrol->value.integer.value[idx] & mask;
 489                 if (mix->send_routing[0][idx] != val) {
 490                         mix->send_routing[0][idx] = val;
 491                         change = 1;
 492                 }
 493         }
 494
 495         if (change && mix->epcm) {
 496                 if (mix->epcm->voices[ch]) {
 497                         update_emu10k1_fxrt(emu, mix->epcm->voices[ch]->number,
 498                                         &mix->send_routing[0][0]);
 499                 }
 500         }
 501         spin_unlock_irqrestore(&emu->reg_lock, flags);
 502         return change;
 503 }
 504
 505 static struct snd_kcontrol_new snd_emu10k1_efx_send_routing_control =
 506 {
 507         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
 508         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 509         .name =         "Multichannel PCM Send Routing",
 510         .count =        16,
 511         .info =         snd_emu10k1_efx_send_routing_info,
 512         .get =          snd_emu10k1_efx_send_routing_get,
 513         .put =          snd_emu10k1_efx_send_routing_put
 514 };
 515
 516 static int snd_emu10k1_efx_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 517 {
 518         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 519         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 520         uinfo->count = emu->audigy ? 8 : 4;
 521         uinfo->value.integer.min = 0;
 522         uinfo->value.integer.max = 255;
 523         return 0;
 524 }
 525
 526 static int snd_emu10k1_efx_send_volume_get(struct snd_kcontrol *kcontrol,
 527                                        struct snd_ctl_elem_value *ucontrol)
 528 {
 529         unsigned long flags;
 530         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 531         struct snd_emu10k1_pcm_mixer *mix =
 532                 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 533         int idx;
 534         int num_efx = emu->audigy ? 8 : 4;
 535
 536         spin_lock_irqsave(&emu->reg_lock, flags);
 537         for (idx = 0; idx < num_efx; idx++)
 538                 ucontrol->value.integer.value[idx] = mix->send_volume[0][idx];
 539         spin_unlock_irqrestore(&emu->reg_lock, flags);
 540         return 0;
 541 }
 542
 543 static int snd_emu10k1_efx_send_volume_put(struct snd_kcontrol *kcontrol,
 544                                        struct snd_ctl_elem_value *ucontrol)
 545 {
 546         unsigned long flags;
 547         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 548         int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 549         struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
 550         int change = 0, idx, val;
 551         int num_efx = emu->audigy ? 8 : 4;
 552
 553         spin_lock_irqsave(&emu->reg_lock, flags);
 554         for (idx = 0; idx < num_efx; idx++) {
 555                 val = ucontrol->value.integer.value[idx] & 255;
 556                 if (mix->send_volume[0][idx] != val) {
 557                         mix->send_volume[0][idx] = val;
 558                         change = 1;
 559                 }
 560         }
 561         if (change && mix->epcm) {
 562                 if (mix->epcm->voices[ch]) {
 563                         update_emu10k1_send_volume(emu, mix->epcm->voices[ch]->number,
 564                                                    &mix->send_volume[0][0]);
 565                 }
 566         }
 567         spin_unlock_irqrestore(&emu->reg_lock, flags);
 568         return change;
 569 }
 570
 571
 572 static struct snd_kcontrol_new snd_emu10k1_efx_send_volume_control =
 573 {
 574         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
 575         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 576         .name =         "Multichannel PCM Send Volume",
 577         .count =        16,
 578         .info =         snd_emu10k1_efx_send_volume_info,
 579         .get =          snd_emu10k1_efx_send_volume_get,
 580         .put =          snd_emu10k1_efx_send_volume_put
 581 };
 582
 583 static int snd_emu10k1_efx_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 584 {
 585         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 586         uinfo->count = 1;
 587         uinfo->value.integer.min = 0;
 588         uinfo->value.integer.max = 0xffff;
 589         return 0;
 590 }
 591
 592 static int snd_emu10k1_efx_attn_get(struct snd_kcontrol *kcontrol,
 593                                 struct snd_ctl_elem_value *ucontrol)
 594 {
 595         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 596         struct snd_emu10k1_pcm_mixer *mix =
 597                 &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)];
 598         unsigned long flags;
 599
 600         spin_lock_irqsave(&emu->reg_lock, flags);
 601         ucontrol->value.integer.value[0] = mix->attn[0];
 602         spin_unlock_irqrestore(&emu->reg_lock, flags);
 603         return 0;
 604 }
 605
 606 static int snd_emu10k1_efx_attn_put(struct snd_kcontrol *kcontrol,
 607                                 struct snd_ctl_elem_value *ucontrol)
 608 {
 609         unsigned long flags;
 610         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 611         int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 612         struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch];
 613         int change = 0, val;
 614
 615         spin_lock_irqsave(&emu->reg_lock, flags);
 616         val = ucontrol->value.integer.value[0] & 0xffff;
 617         if (mix->attn[0] != val) {
 618                 mix->attn[0] = val;
 619                 change = 1;
 620         }
 621         if (change && mix->epcm) {
 622                 if (mix->epcm->voices[ch]) {
 623                         snd_emu10k1_ptr_write(emu, VTFT_VOLUMETARGET, mix->epcm->voices[ch]->number, mix->attn[0]);
 624                 }
 625         }
 626         spin_unlock_irqrestore(&emu->reg_lock, flags);
 627         return change;
 628 }
 629
 630 static struct snd_kcontrol_new snd_emu10k1_efx_attn_control =
 631 {
 632         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
 633         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 634         .name =         "Multichannel PCM Volume",
 635         .count =        16,
 636         .info =         snd_emu10k1_efx_attn_info,
 637         .get =          snd_emu10k1_efx_attn_get,
 638         .put =          snd_emu10k1_efx_attn_put
 639 };
 640
 641 static int snd_emu10k1_shared_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 642 {
 643         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 644         uinfo->count = 1;
 645         uinfo->value.integer.min = 0;
 646         uinfo->value.integer.max = 1;
 647         return 0;
 648 }
 649
 650 static int snd_emu10k1_shared_spdif_get(struct snd_kcontrol *kcontrol,
 651                                         struct snd_ctl_elem_value *ucontrol)
 652 {
 653         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 654
 655         if (emu->audigy)
 656                 ucontrol->value.integer.value[0] = inl(emu->port + A_IOCFG) & A_IOCFG_GPOUT0 ? 1 : 0;
 657         else
 658                 ucontrol->value.integer.value[0] = inl(emu->port + HCFG) & HCFG_GPOUT0 ? 1 : 0;
 659         return 0;
 660 }
 661
 662 static int snd_emu10k1_shared_spdif_put(struct snd_kcontrol *kcontrol,
 663                                         struct snd_ctl_elem_value *ucontrol)
 664 {
 665         unsigned long flags;
 666         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 667         unsigned int reg, val;
 668         int change = 0;
 669
 670         spin_lock_irqsave(&emu->reg_lock, flags);
 671         if (emu->audigy) {
 672                 reg = inl(emu->port + A_IOCFG);
 673                 val = ucontrol->value.integer.value[0] ? A_IOCFG_GPOUT0 : 0;
 674                 change = (reg & A_IOCFG_GPOUT0) != val;
 675                 if (change) {
 676                         reg &= ~A_IOCFG_GPOUT0;
 677                         reg |= val;
 678                         outl(reg | val, emu->port + A_IOCFG);
 679                 }
 680         }
 681         reg = inl(emu->port + HCFG);
 682         val = ucontrol->value.integer.value[0] ? HCFG_GPOUT0 : 0;
 683         change |= (reg & HCFG_GPOUT0) != val;
 684         if (change) {
 685                 reg &= ~HCFG_GPOUT0;
 686                 reg |= val;
 687                 outl(reg | val, emu->port + HCFG);
 688         }
 689         spin_unlock_irqrestore(&emu->reg_lock, flags);
 690         return change;
 691 }
 692
 693 static struct snd_kcontrol_new snd_emu10k1_shared_spdif __devinitdata =
 694 {
 695         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 696         .name =         "SB Live Analog/Digital Output Jack",
 697         .info =         snd_emu10k1_shared_spdif_info,
 698         .get =          snd_emu10k1_shared_spdif_get,
 699         .put =          snd_emu10k1_shared_spdif_put
 700 };
 701
 702 static struct snd_kcontrol_new snd_audigy_shared_spdif __devinitdata =
 703 {
 704         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 705         .name =         "Audigy Analog/Digital Output Jack",
 706         .info =         snd_emu10k1_shared_spdif_info,
 707         .get =          snd_emu10k1_shared_spdif_get,
 708         .put =          snd_emu10k1_shared_spdif_put
 709 };
 710
 711 /*
 712  */
 713 static void snd_emu10k1_mixer_free_ac97(struct snd_ac97 *ac97)
 714 {
 715         struct snd_emu10k1 *emu = ac97->private_data;
 716         emu->ac97 = NULL;
 717 }
 718
 719 /*
 720  */
 721 static int remove_ctl(struct snd_card *card, const char *name)
 722 {
 723         struct snd_ctl_elem_id id;
 724         memset(&id, 0, sizeof(id));
 725         strcpy(id.name, name);
 726         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 727         return snd_ctl_remove_id(card, &id);
 728 }
 729
 730 static struct snd_kcontrol *ctl_find(struct snd_card *card, const char *name)
 731 {
 732         struct snd_ctl_elem_id sid;
 733         memset(&sid, 0, sizeof(sid));
 734         strcpy(sid.name, name);
 735         sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 736         return snd_ctl_find_id(card, &sid);
 737 }
 738
 739 static int rename_ctl(struct snd_card *card, const char *src, const char *dst)
 740 {
 741         struct snd_kcontrol *kctl = ctl_find(card, src);
 742         if (kctl) {
 743                 strcpy(kctl->id.name, dst);
 744                 return 0;
 745         }
 746         return -ENOENT;
 747 }
 748
 749 int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu,
 750                                 int pcm_device, int multi_device)
 751 {
 752         int err, pcm;
 753         struct snd_kcontrol *kctl;
 754         struct snd_card *card = emu->card;
 755         char **c;
 756         static char *emu10k1_remove_ctls[] = {
 757                 /* no AC97 mono, surround, center/lfe */
 758                 "Master Mono Playback Switch",
 759                 "Master Mono Playback Volume",
 760                 "PCM Out Path & Mute",
 761                 "Mono Output Select",
 762                 "Front Playback Switch",
 763                 "Front Playback Volume",
 764                 "Surround Playback Switch",
 765                 "Surround Playback Volume",
 766                 "Center Playback Switch",
 767                 "Center Playback Volume",
 768                 "LFE Playback Switch",
 769                 "LFE Playback Volume",
 770                 NULL
 771         };
 772         static char *emu10k1_rename_ctls[] = {
 773                 "Surround Digital Playback Volume", "Surround Playback Volume",
 774                 "Center Digital Playback Volume", "Center Playback Volume",
 775                 "LFE Digital Playback Volume", "LFE Playback Volume",
 776                 NULL
 777         };
 778         static char *audigy_remove_ctls[] = {
 779                 /* Master/PCM controls on ac97 of Audigy has no effect */
 780                 /* On the Audigy2 the AC97 playback is piped into
 781                  * the Philips ADC for 24bit capture */
 782                 "PCM Playback Switch",
 783                 "PCM Playback Volume",
 784                 "Master Mono Playback Switch",
 785                 "Master Mono Playback Volume",
 786                 "Master Playback Switch",
 787                 "Master Playback Volume",
 788                 "PCM Out Path & Mute",
 789                 "Mono Output Select",
 790                 /* remove unused AC97 capture controls */
 791                 "Capture Source",
 792                 "Capture Switch",
 793                 "Capture Volume",
 794                 "Mic Select",
 795                 "Video Playback Switch",
 796                 "Video Playback Volume",
 797                 "Mic Playback Switch",
 798                 "Mic Playback Volume",
 799                 NULL
 800         };
 801         static char *audigy_rename_ctls[] = {
 802                 /* use conventional names */
 803                 "Wave Playback Volume", "PCM Playback Volume",
 804                 /* "Wave Capture Volume", "PCM Capture Volume", */
 805                 "Wave Master Playback Volume", "Master Playback Volume",
 806                 "AMic Playback Volume", "Mic Playback Volume",
 807                 NULL
 808         };
 809         static char *audigy_remove_ctls_1361t_adc[] = {
 810                 /* On the Audigy2 the AC97 playback is piped into
 811                  * the Philips ADC for 24bit capture */
 812                 "PCM Playback Switch",
 813                 "PCM Playback Volume",
 814                 "Master Mono Playback Switch",
 815                 "Master Mono Playback Volume",
 816                 "Capture Source",
 817                 "Capture Switch",
 818                 "Capture Volume",
 819                 "Mic Capture Volume",
 820                 "Headphone Playback Switch",
 821                 "Headphone Playback Volume",
 822                 "3D Control - Center",
 823                 "3D Control - Depth",
 824                 "3D Control - Switch",
 825                 "Line2 Playback Volume",
 826                 "Line2 Capture Volume",
 827                 NULL
 828         };
 829         static char *audigy_rename_ctls_1361t_adc[] = {
 830                 "Master Playback Switch", "Master Capture Switch",
 831                 "Master Playback Volume", "Master Capture Volume",
 832                 "Wave Master Playback Volume", "Master Playback Volume",
 833                 "PC Speaker Playback Switch", "PC Speaker Capture Switch",
 834                 "PC Speaker Playback Volume", "PC Speaker Capture Volume",
 835                 "Phone Playback Switch", "Phone Capture Switch",
 836                 "Phone Playback Volume", "Phone Capture Volume",
 837                 "Mic Playback Switch", "Mic Capture Switch",
 838                 "Mic Playback Volume", "Mic Capture Volume",
 839                 "Line Playback Switch", "Line Capture Switch",
 840                 "Line Playback Volume", "Line Capture Volume",
 841                 "CD Playback Switch", "CD Capture Switch",
 842                 "CD Playback Volume", "CD Capture Volume",
 843                 "Aux Playback Switch", "Aux Capture Switch",
 844                 "Aux Playback Volume", "Aux Capture Volume",
 845                 "Video Playback Switch", "Video Capture Switch",
 846                 "Video Playback Volume", "Video Capture Volume",
 847
 848                 NULL
 849         };
 850
 851         if (emu->card_capabilities->ac97_chip) {
 852                 struct snd_ac97_bus *pbus;
 853                 struct snd_ac97_template ac97;
 854                 static struct snd_ac97_bus_ops ops = {
 855                         .write = snd_emu10k1_ac97_write,
 856                         .read = snd_emu10k1_ac97_read,
 857                 };
 858
 859                 if ((err = snd_ac97_bus(emu->card, 0, &ops, NULL, &pbus)) < 0)
 860                         return err;
 861                 pbus->no_vra = 1; /* we don't need VRA */
 862
 863                 memset(&ac97, 0, sizeof(ac97));
 864                 ac97.private_data = emu;
 865                 ac97.private_free = snd_emu10k1_mixer_free_ac97;
 866                 ac97.scaps = AC97_SCAP_NO_SPDIF;
 867                 if ((err = snd_ac97_mixer(pbus, &ac97, &emu->ac97)) < 0) {
 868                         if (emu->card_capabilities->ac97_chip == 1)
 869                                 return err;
 870                         snd_printd(KERN_INFO "emu10k1: AC97 is optional on this board\n");
 871                         snd_printd(KERN_INFO"          Proceeding without ac97 mixers...\n");
 872                         snd_device_free(emu->card, pbus);
 873                         goto no_ac97; /* FIXME: get rid of ugly gotos.. */
 874                 }
 875                 if (emu->audigy) {
 876                         /* set master volume to 0 dB */
 877                         snd_ac97_write_cache(emu->ac97, AC97_MASTER, 0x0000);
 878                         /* set capture source to mic */
 879                         snd_ac97_write_cache(emu->ac97, AC97_REC_SEL, 0x0000);
 880                         if (emu->card_capabilities->adc_1361t)
 881                                 c = audigy_remove_ctls_1361t_adc;
 882                         else
 883                                 c = audigy_remove_ctls;
 884                 } else {
 885                         /*
 886                          * Credits for cards based on STAC9758:
 887                          *   James Courtier-Dutton <James@superbug.demon.co.uk>
 888                          *   Voluspa <voluspa@comhem.se>
 889                          */
 890                         if (emu->ac97->id == AC97_ID_STAC9758) {
 891                                 emu->rear_ac97 = 1;
 892                                 snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_CNTR|AC97SLOT_LFE|AC97SLOT_REAR_LEFT|AC97SLOT_REAR_RIGHT);
 893                         }
 894                         /* remove unused AC97 controls */
 895                         snd_ac97_write_cache(emu->ac97, AC97_SURROUND_MASTER, 0x0202);
 896                         snd_ac97_write_cache(emu->ac97, AC97_CENTER_LFE_MASTER, 0x0202);
 897                         c = emu10k1_remove_ctls;
 898                 }
 899                 for (; *c; c++)
 900                         remove_ctl(card, *c);
 901         } else {
 902         no_ac97:
 903                 if (emu->card_capabilities->ecard)
 904                         strcpy(emu->card->mixername, "EMU APS");
 905                 else if (emu->audigy)
 906                         strcpy(emu->card->mixername, "SB Audigy");
 907                 else
 908                         strcpy(emu->card->mixername, "Emu10k1");
 909         }
 910
 911         if (emu->audigy)
 912                 if (emu->card_capabilities->adc_1361t)
 913                         c = audigy_rename_ctls_1361t_adc;
 914                 else
 915                         c = audigy_rename_ctls;
 916         else
 917                 c = emu10k1_rename_ctls;
 918         for (; *c; c += 2)
 919                 rename_ctl(card, c[0], c[1]);
 920
 921         if (emu->card_capabilities->subsystem == 0x20071102) {  /* Audigy 4 Pro */
 922                 rename_ctl(card, "Line2 Capture Volume", "Line1/Mic Capture Volume");
 923                 rename_ctl(card, "Analog Mix Capture Volume", "Line2 Capture Volume");
 924                 rename_ctl(card, "Aux2 Capture Volume", "Line3 Capture Volume");
 925                 rename_ctl(card, "Mic Capture Volume", "Unknown1 Capture Volume");
 926                 remove_ctl(card, "Headphone Playback Switch");
 927                 remove_ctl(card, "Headphone Playback Volume");
 928                 remove_ctl(card, "3D Control - Center");
 929                 remove_ctl(card, "3D Control - Depth");
 930                 remove_ctl(card, "3D Control - Switch");
 931         }
 932         if ((kctl = emu->ctl_send_routing = snd_ctl_new1(&snd_emu10k1_send_routing_control, emu)) == NULL)
 933                 return -ENOMEM;
 934         kctl->id.device = pcm_device;
 935         if ((err = snd_ctl_add(card, kctl)))
 936                 return err;
 937         if ((kctl = emu->ctl_send_volume = snd_ctl_new1(&snd_emu10k1_send_volume_control, emu)) == NULL)
 938                 return -ENOMEM;
 939         kctl->id.device = pcm_device;
 940         if ((err = snd_ctl_add(card, kctl)))
 941                 return err;
 942         if ((kctl = emu->ctl_attn = snd_ctl_new1(&snd_emu10k1_attn_control, emu)) == NULL)
 943                 return -ENOMEM;
 944         kctl->id.device = pcm_device;
 945         if ((err = snd_ctl_add(card, kctl)))
 946                 return err;
 947
 948         if ((kctl = emu->ctl_efx_send_routing = snd_ctl_new1(&snd_emu10k1_efx_send_routing_control, emu)) == NULL)
 949                 return -ENOMEM;
 950         kctl->id.device = multi_device;
 951         if ((err = snd_ctl_add(card, kctl)))
 952                 return err;
 953
 954         if ((kctl = emu->ctl_efx_send_volume = snd_ctl_new1(&snd_emu10k1_efx_send_volume_control, emu)) == NULL)
 955                 return -ENOMEM;
 956         kctl->id.device = multi_device;
 957         if ((err = snd_ctl_add(card, kctl)))
 958                 return err;
 959
 960         if ((kctl = emu->ctl_efx_attn = snd_ctl_new1(&snd_emu10k1_efx_attn_control, emu)) == NULL)
 961                 return -ENOMEM;
 962         kctl->id.device = multi_device;
 963         if ((err = snd_ctl_add(card, kctl)))
 964                 return err;
 965
 966         /* initialize the routing and volume table for each pcm playback stream */
 967         for (pcm = 0; pcm < 32; pcm++) {
 968                 struct snd_emu10k1_pcm_mixer *mix;
 969                 int v;
 970
 971                 mix = &emu->pcm_mixer[pcm];
 972                 mix->epcm = NULL;
 973
 974                 for (v = 0; v < 4; v++)
 975                         mix->send_routing[0][v] =
 976                                 mix->send_routing[1][v] =
 977                                 mix->send_routing[2][v] = v;
 978
 979                 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
 980                 mix->send_volume[0][0] = mix->send_volume[0][1] =
 981                 mix->send_volume[1][0] = mix->send_volume[2][1] = 255;
 982
 983                 mix->attn[0] = mix->attn[1] = mix->attn[2] = 0xffff;
 984         }
 985
 986         /* initialize the routing and volume table for the multichannel playback stream */
 987         for (pcm = 0; pcm < NUM_EFX_PLAYBACK; pcm++) {
 988                 struct snd_emu10k1_pcm_mixer *mix;
 989                 int v;
 990
 991                 mix = &emu->efx_pcm_mixer[pcm];
 992                 mix->epcm = NULL;
 993
 994                 mix->send_routing[0][0] = pcm;
 995                 mix->send_routing[0][1] = (pcm == 0) ? 1 : 0;
 996                 for (v = 0; v < 2; v++)
 997                         mix->send_routing[0][2+v] = 13+v;
 998                 if (emu->audigy)
 999                         for (v = 0; v < 4; v++)
1000                                 mix->send_routing[0][4+v] = 60+v;
1001
1002                 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
1003                 mix->send_volume[0][0]  = 255;
1004
1005                 mix->attn[0] = 0xffff;
1006         }
1007
1008         if (! emu->card_capabilities->ecard) { /* FIXME: APS has these controls? */
1009                 /* sb live! and audigy */
1010                 if ((kctl = snd_ctl_new1(&snd_emu10k1_spdif_mask_control, emu)) == NULL)
1011                         return -ENOMEM;
1012                 if (!emu->audigy)
1013                         kctl->id.device = emu->pcm_efx->device;
1014                 if ((err = snd_ctl_add(card, kctl)))
1015                         return err;
1016                 if ((kctl = snd_ctl_new1(&snd_emu10k1_spdif_control, emu)) == NULL)
1017                         return -ENOMEM;
1018                 if (!emu->audigy)
1019                         kctl->id.device = emu->pcm_efx->device;
1020                 if ((err = snd_ctl_add(card, kctl)))
1021                         return err;
1022         }
1023
1024         if ( emu->card_capabilities->emu1212m) {
1025                 ;  /* Disable the snd_audigy_spdif_shared_spdif */
1026         } else if (emu->audigy) {
1027                 if ((kctl = snd_ctl_new1(&snd_audigy_shared_spdif, emu)) == NULL)
1028                         return -ENOMEM;
1029                 if ((err = snd_ctl_add(card, kctl)))
1030                         return err;
1031 #if 0
1032                 if ((kctl = snd_ctl_new1(&snd_audigy_spdif_output_rate, emu)) == NULL)
1033                         return -ENOMEM;
1034                 if ((err = snd_ctl_add(card, kctl)))
1035                         return err;
1036 #endif
1037         } else if (! emu->card_capabilities->ecard) {
1038                 /* sb live! */
1039                 if ((kctl = snd_ctl_new1(&snd_emu10k1_shared_spdif, emu)) == NULL)
1040                         return -ENOMEM;
1041                 if ((err = snd_ctl_add(card, kctl)))
1042                         return err;
1043         }
1044         if (emu->card_capabilities->ca0151_chip) { /* P16V */
1045                 if ((err = snd_p16v_mixer(emu)))
1046                         return err;
1047         }
1048
1049         return 0;
1050 }