sound/pci/ca0106/ca0106_mixer.c

   1 /*
   2  *  Copyright (c) 2004 James Courtier-Dutton <James@superbug.demon.co.uk>
   3  *  Driver CA0106 chips. e.g. Sound Blaster Audigy LS and Live 24bit
   4  *  Version: 0.0.17
   5  *
   6  *  FEATURES currently supported:
   7  *    See ca0106_main.c for features.
   8  *
   9  *  Changelog:
  10  *    Support interrupts per period.
  11  *    Removed noise from Center/LFE channel when in Analog mode.
  12  *    Rename and remove mixer controls.
  13  *  0.0.6
  14  *    Use separate card based DMA buffer for periods table list.
  15  *  0.0.7
  16  *    Change remove and rename ctrls into lists.
  17  *  0.0.8
  18  *    Try to fix capture sources.
  19  *  0.0.9
  20  *    Fix AC3 output.
  21  *    Enable S32_LE format support.
  22  *  0.0.10
  23  *    Enable playback 48000 and 96000 rates. (Rates other that these do not work, even with "plug:front".)
  24  *  0.0.11
  25  *    Add Model name recognition.
  26  *  0.0.12
  27  *    Correct interrupt timing. interrupt at end of period, instead of in the middle of a playback period.
  28  *    Remove redundent "voice" handling.
  29  *  0.0.13
  30  *    Single trigger call for multi channels.
  31  *  0.0.14
  32  *    Set limits based on what the sound card hardware can do.
  33  *    playback periods_min=2, periods_max=8
  34  *    capture hw constraints require period_size = n * 64 bytes.
  35  *    playback hw constraints require period_size = n * 64 bytes.
  36  *  0.0.15
  37  *    Separated ca0106.c into separate functional .c files.
  38  *  0.0.16
  39  *    Modified Copyright message.
  40  *  0.0.17
  41  *    Implement Mic and Line in Capture.
  42  *
  43  *  This code was initally based on code from ALSA's emu10k1x.c which is:
  44  *  Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
  45  *
  46  *   This program is free software; you can redistribute it and/or modify
  47  *   it under the terms of the GNU General Public License as published by
  48  *   the Free Software Foundation; either version 2 of the License, or
  49  *   (at your option) any later version.
  50  *
  51  *   This program is distributed in the hope that it will be useful,
  52  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  53  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  54  *   GNU General Public License for more details.
  55  *
  56  *   You should have received a copy of the GNU General Public License
  57  *   along with this program; if not, write to the Free Software
  58  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  59  *
  60  */
  61 #include <sound/driver.h>
  62 #include <linux/delay.h>
  63 #include <linux/init.h>
  64 #include <linux/interrupt.h>
  65 #include <linux/pci.h>
  66 #include <linux/slab.h>
  67 #include <linux/moduleparam.h>
  68 #include <sound/core.h>
  69 #include <sound/initval.h>
  70 #include <sound/pcm.h>
  71 #include <sound/ac97_codec.h>
  72 #include <sound/info.h>
  73
  74 #include "ca0106.h"
  75
  76 static int snd_ca0106_shared_spdif_info(struct snd_kcontrol *kcontrol,
  77                                         struct snd_ctl_elem_info *uinfo)
  78 {
  79         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
  80         uinfo->count = 1;
  81         uinfo->value.integer.min = 0;
  82         uinfo->value.integer.max = 1;
  83         return 0;
  84 }
  85
  86 static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol,
  87                                         struct snd_ctl_elem_value *ucontrol)
  88 {
  89         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
  90
  91         ucontrol->value.enumerated.item[0] = emu->spdif_enable;
  92         return 0;
  93 }
  94
  95 static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol,
  96                                         struct snd_ctl_elem_value *ucontrol)
  97 {
  98         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
  99         unsigned int val;
 100         int change = 0;
 101         u32 mask;
 102
 103         val = ucontrol->value.enumerated.item[0] ;
 104         change = (emu->spdif_enable != val);
 105         if (change) {
 106                 emu->spdif_enable = val;
 107                 if (val == 1) {
 108                         /* Digital */
 109                         snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
 110                         snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
 111                         snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
 112                                 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000);
 113                         mask = inl(emu->port + GPIO) & ~0x101;
 114                         outl(mask, emu->port + GPIO);
 115
 116                 } else {
 117                         /* Analog */
 118                         snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
 119                         snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
 120                         snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0,
 121                                 snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000);
 122                         mask = inl(emu->port + GPIO) | 0x101;
 123                         outl(mask, emu->port + GPIO);
 124                 }
 125         }
 126         return change;
 127 }
 128
 129 static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol,
 130                                           struct snd_ctl_elem_info *uinfo)
 131 {
 132         static char *texts[6] = {
 133                 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out"
 134         };
 135
 136         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 137         uinfo->count = 1;
 138         uinfo->value.enumerated.items = 6;
 139         if (uinfo->value.enumerated.item > 5)
 140                 uinfo->value.enumerated.item = 5;
 141         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 142         return 0;
 143 }
 144
 145 static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol,
 146                                         struct snd_ctl_elem_value *ucontrol)
 147 {
 148         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 149
 150         ucontrol->value.enumerated.item[0] = emu->capture_source;
 151         return 0;
 152 }
 153
 154 static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
 155                                         struct snd_ctl_elem_value *ucontrol)
 156 {
 157         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 158         unsigned int val;
 159         int change = 0;
 160         u32 mask;
 161         u32 source;
 162
 163         val = ucontrol->value.enumerated.item[0] ;
 164         change = (emu->capture_source != val);
 165         if (change) {
 166                 emu->capture_source = val;
 167                 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
 168                 mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
 169                 snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
 170         }
 171         return change;
 172 }
 173
 174 static int snd_ca0106_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
 175                                           struct snd_ctl_elem_info *uinfo)
 176 {
 177         static char *texts[6] = {
 178                 "Phone", "Mic", "Line in", "Aux"
 179         };
 180
 181         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 182         uinfo->count = 1;
 183         uinfo->value.enumerated.items = 4;
 184         if (uinfo->value.enumerated.item > 3)
 185                 uinfo->value.enumerated.item = 3;
 186         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 187         return 0;
 188 }
 189
 190 static int snd_ca0106_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
 191                                         struct snd_ctl_elem_value *ucontrol)
 192 {
 193         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 194
 195         ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
 196         return 0;
 197 }
 198
 199 static int snd_ca0106_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
 200                                         struct snd_ctl_elem_value *ucontrol)
 201 {
 202         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 203         unsigned int source_id;
 204         unsigned int ngain, ogain;
 205         int change = 0;
 206         u32 source;
 207         /* If the capture source has changed,
 208          * update the capture volume from the cached value
 209          * for the particular source.
 210          */
 211         source_id = ucontrol->value.enumerated.item[0] ;
 212         change = (emu->i2c_capture_source != source_id);
 213         if (change) {
 214                 snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
 215                 ngain = emu->i2c_capture_volume[source_id][0]; /* Left */
 216                 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
 217                 if (ngain != ogain)
 218                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff));
 219                 ngain = emu->i2c_capture_volume[source_id][1]; /* Left */
 220                 ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Left */
 221                 if (ngain != ogain)
 222                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
 223                 source = 1 << source_id;
 224                 snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
 225                 emu->i2c_capture_source = source_id;
 226         }
 227         return change;
 228 }
 229
 230 static int snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol *kcontrol,
 231                                                struct snd_ctl_elem_info *uinfo)
 232 {
 233         static char *texts[2] = { "Side out", "Line in" };
 234
 235         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 236         uinfo->count = 1;
 237         uinfo->value.enumerated.items = 2;
 238         if (uinfo->value.enumerated.item > 1)
 239                 uinfo->value.enumerated.item = 1;
 240         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 241         return 0;
 242 }
 243
 244 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
 245                                                struct snd_ctl_elem_info *uinfo)
 246 {
 247         static char *texts[2] = { "Line in", "Mic in" };
 248
 249         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 250         uinfo->count = 1;
 251         uinfo->value.enumerated.items = 2;
 252         if (uinfo->value.enumerated.item > 1)
 253                 uinfo->value.enumerated.item = 1;
 254         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 255         return 0;
 256 }
 257
 258 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
 259                                         struct snd_ctl_elem_value *ucontrol)
 260 {
 261         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 262
 263         ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
 264         return 0;
 265 }
 266
 267 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
 268                                         struct snd_ctl_elem_value *ucontrol)
 269 {
 270         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 271         unsigned int val;
 272         int change = 0;
 273         u32 tmp;
 274
 275         val = ucontrol->value.enumerated.item[0] ;
 276         change = (emu->capture_mic_line_in != val);
 277         if (change) {
 278                 emu->capture_mic_line_in = val;
 279                 if (val) {
 280                         //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
 281                         tmp = inl(emu->port+GPIO) & ~0x400;
 282                         tmp = tmp | 0x400;
 283                         outl(tmp, emu->port+GPIO);
 284                         //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
 285                 } else {
 286                         //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
 287                         tmp = inl(emu->port+GPIO) & ~0x400;
 288                         outl(tmp, emu->port+GPIO);
 289                         //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
 290                 }
 291         }
 292         return change;
 293 }
 294
 295 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata =
 296 {
 297         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 298         .name =         "Shared Mic/Line in Capture Switch",
 299         .info =         snd_ca0106_capture_mic_line_in_info,
 300         .get =          snd_ca0106_capture_mic_line_in_get,
 301         .put =          snd_ca0106_capture_mic_line_in_put
 302 };
 303
 304 static struct snd_kcontrol_new snd_ca0106_capture_line_in_side_out __devinitdata =
 305 {
 306         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 307         .name =         "Shared Line in/Side out Capture Switch",
 308         .info =         snd_ca0106_capture_line_in_side_out_info,
 309         .get =          snd_ca0106_capture_mic_line_in_get,
 310         .put =          snd_ca0106_capture_mic_line_in_put
 311 };
 312
 313
 314 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
 315                                  struct snd_ctl_elem_info *uinfo)
 316 {
 317         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 318         uinfo->count = 1;
 319         return 0;
 320 }
 321
 322 static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol,
 323                                  struct snd_ctl_elem_value *ucontrol)
 324 {
 325         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 326         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 327
 328         ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
 329         ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
 330         ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
 331         ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
 332         return 0;
 333 }
 334
 335 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
 336                                       struct snd_ctl_elem_value *ucontrol)
 337 {
 338         ucontrol->value.iec958.status[0] = 0xff;
 339         ucontrol->value.iec958.status[1] = 0xff;
 340         ucontrol->value.iec958.status[2] = 0xff;
 341         ucontrol->value.iec958.status[3] = 0xff;
 342         return 0;
 343 }
 344
 345 static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol,
 346                                  struct snd_ctl_elem_value *ucontrol)
 347 {
 348         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 349         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 350         int change;
 351         unsigned int val;
 352
 353         val = (ucontrol->value.iec958.status[0] << 0) |
 354               (ucontrol->value.iec958.status[1] << 8) |
 355               (ucontrol->value.iec958.status[2] << 16) |
 356               (ucontrol->value.iec958.status[3] << 24);
 357         change = val != emu->spdif_bits[idx];
 358         if (change) {
 359                 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, val);
 360                 emu->spdif_bits[idx] = val;
 361         }
 362         return change;
 363 }
 364
 365 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
 366                                   struct snd_ctl_elem_info *uinfo)
 367 {
 368         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 369         uinfo->count = 2;
 370         uinfo->value.integer.min = 0;
 371         uinfo->value.integer.max = 255;
 372         return 0;
 373 }
 374
 375 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
 376                                  struct snd_ctl_elem_value *ucontrol)
 377 {
 378         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 379         unsigned int value;
 380         int channel_id, reg;
 381
 382         channel_id = (kcontrol->private_value >> 8) & 0xff;
 383         reg = kcontrol->private_value & 0xff;
 384
 385         value = snd_ca0106_ptr_read(emu, reg, channel_id);
 386         ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
 387         ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
 388         return 0;
 389 }
 390
 391 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
 392                                  struct snd_ctl_elem_value *ucontrol)
 393 {
 394         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 395         unsigned int oval, nval;
 396         int channel_id, reg;
 397
 398         channel_id = (kcontrol->private_value >> 8) & 0xff;
 399         reg = kcontrol->private_value & 0xff;
 400
 401         oval = snd_ca0106_ptr_read(emu, reg, channel_id);
 402         nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
 403                 ((0xff - ucontrol->value.integer.value[1]) << 16);
 404         nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
 405                 ((0xff - ucontrol->value.integer.value[1]) );
 406         if (oval == nval)
 407                 return 0;
 408         snd_ca0106_ptr_write(emu, reg, channel_id, nval);
 409         return 1;
 410 }
 411
 412 static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
 413                                   struct snd_ctl_elem_info *uinfo)
 414 {
 415         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 416         uinfo->count = 2;
 417         uinfo->value.integer.min = 0;
 418         uinfo->value.integer.max = 255;
 419         return 0;
 420 }
 421
 422 static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
 423                                  struct snd_ctl_elem_value *ucontrol)
 424 {
 425         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 426         int source_id;
 427
 428         source_id = kcontrol->private_value;
 429
 430         ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
 431         ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
 432         return 0;
 433 }
 434
 435 static int snd_ca0106_i2c_volume_put(struct snd_kcontrol *kcontrol,
 436                                  struct snd_ctl_elem_value *ucontrol)
 437 {
 438         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 439         unsigned int ogain;
 440         unsigned int ngain;
 441         int source_id;
 442         int change = 0;
 443
 444         source_id = kcontrol->private_value;
 445         ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
 446         ngain = ucontrol->value.integer.value[0];
 447         if (ngain > 0xff)
 448                 return 0;
 449         if (ogain != ngain) {
 450                 if (emu->i2c_capture_source == source_id)
 451                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
 452                 emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
 453                 change = 1;
 454         }
 455         ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
 456         ngain = ucontrol->value.integer.value[1];
 457         if (ngain > 0xff)
 458                 return 0;
 459         if (ogain != ngain) {
 460                 if (emu->i2c_capture_source == source_id)
 461                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
 462                 emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
 463                 change = 1;
 464         }
 465
 466         return change;
 467 }
 468
 469 #define CA_VOLUME(xname,chid,reg) \
 470 {                                                               \
 471         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
 472         .info =  snd_ca0106_volume_info,                        \
 473         .get =   snd_ca0106_volume_get,                         \
 474         .put =   snd_ca0106_volume_put,                         \
 475         .private_value = ((chid) << 8) | (reg)                  \
 476 }
 477
 478 #define I2C_VOLUME(xname,chid) \
 479 {                                                               \
 480         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
 481         .info =  snd_ca0106_i2c_volume_info,                    \
 482         .get =   snd_ca0106_i2c_volume_get,                     \
 483         .put =   snd_ca0106_i2c_volume_put,                     \
 484         .private_value = chid                                   \
 485 }
 486
 487
 488 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
 489         CA_VOLUME("Analog Front Playback Volume",
 490                   CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
 491         CA_VOLUME("Analog Rear Playback Volume",
 492                   CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
 493         CA_VOLUME("Analog Center/LFE Playback Volume",
 494                   CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
 495         CA_VOLUME("Analog Side Playback Volume",
 496                   CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
 497
 498         CA_VOLUME("IEC958 Front Playback Volume",
 499                   CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
 500         CA_VOLUME("IEC958 Rear Playback Volume",
 501                   CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
 502         CA_VOLUME("IEC958 Center/LFE Playback Volume",
 503                   CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
 504         CA_VOLUME("IEC958 Unknown Playback Volume",
 505                   CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
 506
 507         CA_VOLUME("CAPTURE feedback Playback Volume",
 508                   1, CAPTURE_CONTROL),
 509
 510         I2C_VOLUME("Phone Capture Volume", 0),
 511         I2C_VOLUME("Mic Capture Volume", 1),
 512         I2C_VOLUME("Line in Capture Volume", 2),
 513         I2C_VOLUME("Aux Capture Volume", 3),
 514
 515         {
 516                 .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 517                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 518                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
 519                 .count =        4,
 520                 .info =         snd_ca0106_spdif_info,
 521                 .get =          snd_ca0106_spdif_get_mask
 522         },
 523         {
 524                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 525                 .name =         "IEC958 Playback Switch",
 526                 .info =         snd_ca0106_shared_spdif_info,
 527                 .get =          snd_ca0106_shared_spdif_get,
 528                 .put =          snd_ca0106_shared_spdif_put
 529         },
 530         {
 531                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 532                 .name =         "Digital Capture Source",
 533                 .info =         snd_ca0106_capture_source_info,
 534                 .get =          snd_ca0106_capture_source_get,
 535                 .put =          snd_ca0106_capture_source_put
 536         },
 537         {
 538                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 539                 .name =         "Capture Source",
 540                 .info =         snd_ca0106_i2c_capture_source_info,
 541                 .get =          snd_ca0106_i2c_capture_source_get,
 542                 .put =          snd_ca0106_i2c_capture_source_put
 543         },
 544         {
 545                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 546                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 547                 .count =        4,
 548                 .info =         snd_ca0106_spdif_info,
 549                 .get =          snd_ca0106_spdif_get,
 550                 .put =          snd_ca0106_spdif_put
 551         },
 552 };
 553
 554 static int __devinit remove_ctl(struct snd_card *card, const char *name)
 555 {
 556         struct snd_ctl_elem_id id;
 557         memset(&id, 0, sizeof(id));
 558         strcpy(id.name, name);
 559         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 560         return snd_ctl_remove_id(card, &id);
 561 }
 562
 563 static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name)
 564 {
 565         struct snd_ctl_elem_id sid;
 566         memset(&sid, 0, sizeof(sid));
 567         /* FIXME: strcpy is bad. */
 568         strcpy(sid.name, name);
 569         sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 570         return snd_ctl_find_id(card, &sid);
 571 }
 572
 573 static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst)
 574 {
 575         struct snd_kcontrol *kctl = ctl_find(card, src);
 576         if (kctl) {
 577                 strcpy(kctl->id.name, dst);
 578                 return 0;
 579         }
 580         return -ENOENT;
 581 }
 582
 583 int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
 584 {
 585         int i, err;
 586         struct snd_card *card = emu->card;
 587         char **c;
 588         static char *ca0106_remove_ctls[] = {
 589                 "Master Mono Playback Switch",
 590                 "Master Mono Playback Volume",
 591                 "3D Control - Switch",
 592                 "3D Control Sigmatel - Depth",
 593                 "PCM Playback Switch",
 594                 "PCM Playback Volume",
 595                 "CD Playback Switch",
 596                 "CD Playback Volume",
 597                 "Phone Playback Switch",
 598                 "Phone Playback Volume",
 599                 "Video Playback Switch",
 600                 "Video Playback Volume",
 601                 "PC Speaker Playback Switch",
 602                 "PC Speaker Playback Volume",
 603                 "Mono Output Select",
 604                 "Capture Source",
 605                 "Capture Switch",
 606                 "Capture Volume",
 607                 "External Amplifier",
 608                 "Sigmatel 4-Speaker Stereo Playback Switch",
 609                 "Sigmatel Surround Phase Inversion Playback ",
 610                 NULL
 611         };
 612         static char *ca0106_rename_ctls[] = {
 613                 "Master Playback Switch", "Capture Switch",
 614                 "Master Playback Volume", "Capture Volume",
 615                 "Line Playback Switch", "AC97 Line Capture Switch",
 616                 "Line Playback Volume", "AC97 Line Capture Volume",
 617                 "Aux Playback Switch", "AC97 Aux Capture Switch",
 618                 "Aux Playback Volume", "AC97 Aux Capture Volume",
 619                 "Mic Playback Switch", "AC97 Mic Capture Switch",
 620                 "Mic Playback Volume", "AC97 Mic Capture Volume",
 621                 "Mic Select", "AC97 Mic Select",
 622                 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
 623                 NULL
 624         };
 625 #if 1
 626         for (c = ca0106_remove_ctls; *c; c++)
 627                 remove_ctl(card, *c);
 628         for (c = ca0106_rename_ctls; *c; c += 2)
 629                 rename_ctl(card, c[0], c[1]);
 630 #endif
 631
 632         for (i = 0; i < ARRAY_SIZE(snd_ca0106_volume_ctls); i++) {
 633                 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_volume_ctls[i], emu));
 634                 if (err < 0)
 635                         return err;
 636         }
 637         if (emu->details->i2c_adc == 1) {
 638                 if (emu->details->gpio_type == 1)
 639                         err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
 640                 else  /* gpio_type == 2 */
 641                         err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_line_in_side_out, emu));
 642                 if (err < 0)
 643                         return err;
 644         }
 645         return 0;
 646 }
 647