err.no Git - linux-2.6/blob - 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_mic_line_in_info(struct snd_kcontrol *kcontrol,
 231                                                struct snd_ctl_elem_info *uinfo)
 232 {
 233         static char *texts[2] = { "Line in", "Mic 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_get(struct snd_kcontrol *kcontrol,
 245                                         struct snd_ctl_elem_value *ucontrol)
 246 {
 247         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 248
 249         ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
 250         return 0;
 251 }
 252
 253 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
 254                                         struct snd_ctl_elem_value *ucontrol)
 255 {
 256         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 257         unsigned int val;
 258         int change = 0;
 259         u32 tmp;
 260
 261         val = ucontrol->value.enumerated.item[0] ;
 262         change = (emu->capture_mic_line_in != val);
 263         if (change) {
 264                 emu->capture_mic_line_in = val;
 265                 if (val) {
 266                         //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
 267                         tmp = inl(emu->port+GPIO) & ~0x400;
 268                         tmp = tmp | 0x400;
 269                         outl(tmp, emu->port+GPIO);
 270                         //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
 271                 } else {
 272                         //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
 273                         tmp = inl(emu->port+GPIO) & ~0x400;
 274                         outl(tmp, emu->port+GPIO);
 275                         //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
 276                 }
 277         }
 278         return change;
 279 }
 280
 281 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata =
 282 {
 283         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 284         .name =         "Shared Mic/Line in Capture Switch",
 285         .info =         snd_ca0106_capture_mic_line_in_info,
 286         .get =          snd_ca0106_capture_mic_line_in_get,
 287         .put =          snd_ca0106_capture_mic_line_in_put
 288 };
 289
 290 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
 291                                  struct snd_ctl_elem_info *uinfo)
 292 {
 293         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 294         uinfo->count = 1;
 295         return 0;
 296 }
 297
 298 static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol,
 299                                  struct snd_ctl_elem_value *ucontrol)
 300 {
 301         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 302         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 303
 304         ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
 305         ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
 306         ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
 307         ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
 308         return 0;
 309 }
 310
 311 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
 312                                       struct snd_ctl_elem_value *ucontrol)
 313 {
 314         ucontrol->value.iec958.status[0] = 0xff;
 315         ucontrol->value.iec958.status[1] = 0xff;
 316         ucontrol->value.iec958.status[2] = 0xff;
 317         ucontrol->value.iec958.status[3] = 0xff;
 318         return 0;
 319 }
 320
 321 static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol,
 322                                  struct snd_ctl_elem_value *ucontrol)
 323 {
 324         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 325         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 326         int change;
 327         unsigned int val;
 328
 329         val = (ucontrol->value.iec958.status[0] << 0) |
 330               (ucontrol->value.iec958.status[1] << 8) |
 331               (ucontrol->value.iec958.status[2] << 16) |
 332               (ucontrol->value.iec958.status[3] << 24);
 333         change = val != emu->spdif_bits[idx];
 334         if (change) {
 335                 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, val);
 336                 emu->spdif_bits[idx] = val;
 337         }
 338         return change;
 339 }
 340
 341 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
 342                                   struct snd_ctl_elem_info *uinfo)
 343 {
 344         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 345         uinfo->count = 2;
 346         uinfo->value.integer.min = 0;
 347         uinfo->value.integer.max = 255;
 348         return 0;
 349 }
 350
 351 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
 352                                  struct snd_ctl_elem_value *ucontrol)
 353 {
 354         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 355         unsigned int value;
 356         int channel_id, reg;
 357
 358         channel_id = (kcontrol->private_value >> 8) & 0xff;
 359         reg = kcontrol->private_value & 0xff;
 360
 361         value = snd_ca0106_ptr_read(emu, reg, channel_id);
 362         ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
 363         ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
 364         return 0;
 365 }
 366
 367 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
 368                                  struct snd_ctl_elem_value *ucontrol)
 369 {
 370         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 371         unsigned int oval, nval;
 372         int channel_id, reg;
 373
 374         channel_id = (kcontrol->private_value >> 8) & 0xff;
 375         reg = kcontrol->private_value & 0xff;
 376
 377         oval = snd_ca0106_ptr_read(emu, reg, channel_id);
 378         nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
 379                 ((0xff - ucontrol->value.integer.value[1]) << 16);
 380         nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
 381                 ((0xff - ucontrol->value.integer.value[1]) );
 382         if (oval == nval)
 383                 return 0;
 384         snd_ca0106_ptr_write(emu, reg, channel_id, nval);
 385         return 1;
 386 }
 387
 388 static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
 389                                   struct snd_ctl_elem_info *uinfo)
 390 {
 391         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 392         uinfo->count = 2;
 393         uinfo->value.integer.min = 0;
 394         uinfo->value.integer.max = 255;
 395         return 0;
 396 }
 397
 398 static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
 399                                  struct snd_ctl_elem_value *ucontrol)
 400 {
 401         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 402         int source_id;
 403
 404         source_id = kcontrol->private_value;
 405
 406         ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
 407         ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
 408         return 0;
 409 }
 410
 411 static int snd_ca0106_i2c_volume_put(struct snd_kcontrol *kcontrol,
 412                                  struct snd_ctl_elem_value *ucontrol)
 413 {
 414         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 415         unsigned int ogain;
 416         unsigned int ngain;
 417         int source_id;
 418         int change = 0;
 419
 420         source_id = kcontrol->private_value;
 421         ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
 422         ngain = ucontrol->value.integer.value[0];
 423         if (ngain > 0xff)
 424                 return 0;
 425         if (ogain != ngain) {
 426                 if (emu->i2c_capture_source == source_id)
 427                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
 428                 emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
 429                 change = 1;
 430         }
 431         ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
 432         ngain = ucontrol->value.integer.value[1];
 433         if (ngain > 0xff)
 434                 return 0;
 435         if (ogain != ngain) {
 436                 if (emu->i2c_capture_source == source_id)
 437                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
 438                 emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
 439                 change = 1;
 440         }
 441
 442         return change;
 443 }
 444
 445 #define CA_VOLUME(xname,chid,reg) \
 446 {                                                               \
 447         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
 448         .info =  snd_ca0106_volume_info,                        \
 449         .get =   snd_ca0106_volume_get,                         \
 450         .put =   snd_ca0106_volume_put,                         \
 451         .private_value = ((chid) << 8) | (reg)                  \
 452 }
 453
 454 #define I2C_VOLUME(xname,chid) \
 455 {                                                               \
 456         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
 457         .info =  snd_ca0106_i2c_volume_info,                    \
 458         .get =   snd_ca0106_i2c_volume_get,                     \
 459         .put =   snd_ca0106_i2c_volume_put,                     \
 460         .private_value = chid                                   \
 461 }
 462
 463
 464 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
 465         CA_VOLUME("Analog Front Playback Volume",
 466                   CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
 467         CA_VOLUME("Analog Rear Playback Volume",
 468                   CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
 469         CA_VOLUME("Analog Center/LFE Playback Volume",
 470                   CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
 471         CA_VOLUME("Analog Side Playback Volume",
 472                   CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
 473
 474         CA_VOLUME("IEC958 Front Playback Volume",
 475                   CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
 476         CA_VOLUME("IEC958 Rear Playback Volume",
 477                   CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
 478         CA_VOLUME("IEC958 Center/LFE Playback Volume",
 479                   CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
 480         CA_VOLUME("IEC958 Unknown Playback Volume",
 481                   CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
 482
 483         CA_VOLUME("CAPTURE feedback Playback Volume",
 484                   1, CAPTURE_CONTROL),
 485
 486         I2C_VOLUME("Phone Capture Volume", 0),
 487         I2C_VOLUME("Mic Capture Volume", 1),
 488         I2C_VOLUME("Line in Capture Volume", 2),
 489         I2C_VOLUME("Aux Capture Volume", 3),
 490
 491         {
 492                 .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 493                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 494                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
 495                 .count =        4,
 496                 .info =         snd_ca0106_spdif_info,
 497                 .get =          snd_ca0106_spdif_get_mask
 498         },
 499         {
 500                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 501                 .name =         "IEC958 Playback Switch",
 502                 .info =         snd_ca0106_shared_spdif_info,
 503                 .get =          snd_ca0106_shared_spdif_get,
 504                 .put =          snd_ca0106_shared_spdif_put
 505         },
 506         {
 507                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 508                 .name =         "Digital Capture Source",
 509                 .info =         snd_ca0106_capture_source_info,
 510                 .get =          snd_ca0106_capture_source_get,
 511                 .put =          snd_ca0106_capture_source_put
 512         },
 513         {
 514                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 515                 .name =         "Capture Source",
 516                 .info =         snd_ca0106_i2c_capture_source_info,
 517                 .get =          snd_ca0106_i2c_capture_source_get,
 518                 .put =          snd_ca0106_i2c_capture_source_put
 519         },
 520         {
 521                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 522                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 523                 .count =        4,
 524                 .info =         snd_ca0106_spdif_info,
 525                 .get =          snd_ca0106_spdif_get,
 526                 .put =          snd_ca0106_spdif_put
 527         },
 528 };
 529
 530 static int __devinit remove_ctl(struct snd_card *card, const char *name)
 531 {
 532         struct snd_ctl_elem_id id;
 533         memset(&id, 0, sizeof(id));
 534         strcpy(id.name, name);
 535         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 536         return snd_ctl_remove_id(card, &id);
 537 }
 538
 539 static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name)
 540 {
 541         struct snd_ctl_elem_id sid;
 542         memset(&sid, 0, sizeof(sid));
 543         /* FIXME: strcpy is bad. */
 544         strcpy(sid.name, name);
 545         sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 546         return snd_ctl_find_id(card, &sid);
 547 }
 548
 549 static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst)
 550 {
 551         struct snd_kcontrol *kctl = ctl_find(card, src);
 552         if (kctl) {
 553                 strcpy(kctl->id.name, dst);
 554                 return 0;
 555         }
 556         return -ENOENT;
 557 }
 558
 559 int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
 560 {
 561         int i, err;
 562         struct snd_card *card = emu->card;
 563         char **c;
 564         static char *ca0106_remove_ctls[] = {
 565                 "Master Mono Playback Switch",
 566                 "Master Mono Playback Volume",
 567                 "3D Control - Switch",
 568                 "3D Control Sigmatel - Depth",
 569                 "PCM Playback Switch",
 570                 "PCM Playback Volume",
 571                 "CD Playback Switch",
 572                 "CD Playback Volume",
 573                 "Phone Playback Switch",
 574                 "Phone Playback Volume",
 575                 "Video Playback Switch",
 576                 "Video Playback Volume",
 577                 "PC Speaker Playback Switch",
 578                 "PC Speaker Playback Volume",
 579                 "Mono Output Select",
 580                 "Capture Source",
 581                 "Capture Switch",
 582                 "Capture Volume",
 583                 "External Amplifier",
 584                 "Sigmatel 4-Speaker Stereo Playback Switch",
 585                 "Sigmatel Surround Phase Inversion Playback ",
 586                 NULL
 587         };
 588         static char *ca0106_rename_ctls[] = {
 589                 "Master Playback Switch", "Capture Switch",
 590                 "Master Playback Volume", "Capture Volume",
 591                 "Line Playback Switch", "AC97 Line Capture Switch",
 592                 "Line Playback Volume", "AC97 Line Capture Volume",
 593                 "Aux Playback Switch", "AC97 Aux Capture Switch",
 594                 "Aux Playback Volume", "AC97 Aux Capture Volume",
 595                 "Mic Playback Switch", "AC97 Mic Capture Switch",
 596                 "Mic Playback Volume", "AC97 Mic Capture Volume",
 597                 "Mic Select", "AC97 Mic Select",
 598                 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
 599                 NULL
 600         };
 601 #if 1
 602         for (c = ca0106_remove_ctls; *c; c++)
 603                 remove_ctl(card, *c);
 604         for (c = ca0106_rename_ctls; *c; c += 2)
 605                 rename_ctl(card, c[0], c[1]);
 606 #endif
 607
 608         for (i = 0; i < ARRAY_SIZE(snd_ca0106_volume_ctls); i++) {
 609                 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_volume_ctls[i], emu));
 610                 if (err < 0)
 611                         return err;
 612         }
 613         if (emu->details->i2c_adc == 1) {
 614                 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
 615                 if (err < 0)
 616                         return err;
 617         }
 618         return 0;
 619 }
 620