kernel/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.18
   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  *  0.0.18
  43  *    Add support for mute control on SB Live 24bit (cards w/ SPI DAC)
  44  *
  45  *  This code was initially based on code from ALSA's emu10k1x.c which is:
  46  *  Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
  47  *
  48  *   This program is free software; you can redistribute it and/or modify
  49  *   it under the terms of the GNU General Public License as published by
  50  *   the Free Software Foundation; either version 2 of the License, or
  51  *   (at your option) any later version.
  52  *
  53  *   This program is distributed in the hope that it will be useful,
  54  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  55  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  56  *   GNU General Public License for more details.
  57  *
  58  *   You should have received a copy of the GNU General Public License
  59  *   along with this program; if not, write to the Free Software
  60  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  61  *
  62  */
  63 #include <linux/delay.h>
  64 #include <linux/init.h>
  65 #include <linux/interrupt.h>
  66 #include <linux/moduleparam.h>
  67 #include <sound/core.h>
  68 #include <sound/initval.h>
  69 #include <sound/pcm.h>
  70 #include <sound/ac97_codec.h>
  71 #include <sound/info.h>
  72 #include <sound/tlv.h>
  73 #include <linux/io.h>
  74
  75 #include "ca0106.h"
  76
  77 static void ca0106_spdif_enable(struct snd_ca0106 *emu)
  78 {
  79         unsigned int val;
  80
  81         if (emu->spdif_enable) {
  82                 /* Digital */
  83                 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
  84                 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x0b000000);
  85                 val = snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) & ~0x1000;
  86                 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, val);
  87                 val = inl(emu->port + GPIO) & ~0x101;
  88                 outl(val, emu->port + GPIO);
  89
  90         } else {
  91                 /* Analog */
  92                 snd_ca0106_ptr_write(emu, SPDIF_SELECT1, 0, 0xf);
  93                 snd_ca0106_ptr_write(emu, SPDIF_SELECT2, 0, 0x000f0000);
  94                 val = snd_ca0106_ptr_read(emu, CAPTURE_CONTROL, 0) | 0x1000;
  95                 snd_ca0106_ptr_write(emu, CAPTURE_CONTROL, 0, val);
  96                 val = inl(emu->port + GPIO) | 0x101;
  97                 outl(val, emu->port + GPIO);
  98         }
  99 }
 100
 101 static void ca0106_set_capture_source(struct snd_ca0106 *emu)
 102 {
 103         unsigned int val = emu->capture_source;
 104         unsigned int source, mask;
 105         source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
 106         mask = snd_ca0106_ptr_read(emu, CAPTURE_SOURCE, 0) & 0xffff;
 107         snd_ca0106_ptr_write(emu, CAPTURE_SOURCE, 0, source | mask);
 108 }
 109
 110 static void ca0106_set_i2c_capture_source(struct snd_ca0106 *emu,
 111                                           unsigned int val, int force)
 112 {
 113         unsigned int ngain, ogain;
 114         u32 source;
 115
 116         snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
 117         ngain = emu->i2c_capture_volume[val][0]; /* Left */
 118         ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
 119         if (force || ngain != ogain)
 120                 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ngain & 0xff);
 121         ngain = emu->i2c_capture_volume[val][1]; /* Right */
 122         ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Right */
 123         if (force || ngain != ogain)
 124                 snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ngain & 0xff);
 125         source = 1 << val;
 126         snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
 127         emu->i2c_capture_source = val;
 128 }
 129
 130 static void ca0106_set_capture_mic_line_in(struct snd_ca0106 *emu)
 131 {
 132         u32 tmp;
 133
 134         if (emu->capture_mic_line_in) {
 135                 /* snd_ca0106_i2c_write(emu, ADC_MUX, 0); */ /* Mute input */
 136                 tmp = inl(emu->port+GPIO) & ~0x400;
 137                 tmp = tmp | 0x400;
 138                 outl(tmp, emu->port+GPIO);
 139                 /* snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC); */
 140         } else {
 141                 /* snd_ca0106_i2c_write(emu, ADC_MUX, 0); */ /* Mute input */
 142                 tmp = inl(emu->port+GPIO) & ~0x400;
 143                 outl(tmp, emu->port+GPIO);
 144                 /* snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN); */
 145         }
 146 }
 147
 148 static void ca0106_set_spdif_bits(struct snd_ca0106 *emu, int idx)
 149 {
 150         snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, emu->spdif_str_bits[idx]);
 151 }
 152
 153 /*
 154  */
 155 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale1, -5175, 25, 1);
 156 static const DECLARE_TLV_DB_SCALE(snd_ca0106_db_scale2, -10350, 50, 1);
 157
 158 #define snd_ca0106_shared_spdif_info    snd_ctl_boolean_mono_info
 159
 160 static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol,
 161                                         struct snd_ctl_elem_value *ucontrol)
 162 {
 163         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 164
 165         ucontrol->value.integer.value[0] = emu->spdif_enable;
 166         return 0;
 167 }
 168
 169 static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol,
 170                                         struct snd_ctl_elem_value *ucontrol)
 171 {
 172         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 173         unsigned int val;
 174         int change = 0;
 175
 176         val = !!ucontrol->value.integer.value[0];
 177         change = (emu->spdif_enable != val);
 178         if (change) {
 179                 emu->spdif_enable = val;
 180                 ca0106_spdif_enable(emu);
 181         }
 182         return change;
 183 }
 184
 185 static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol,
 186                                           struct snd_ctl_elem_info *uinfo)
 187 {
 188         static const char * const texts[6] = {
 189                 "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out"
 190         };
 191
 192         return snd_ctl_enum_info(uinfo, 1, 6, texts);
 193 }
 194
 195 static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol,
 196                                         struct snd_ctl_elem_value *ucontrol)
 197 {
 198         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 199
 200         ucontrol->value.enumerated.item[0] = emu->capture_source;
 201         return 0;
 202 }
 203
 204 static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
 205                                         struct snd_ctl_elem_value *ucontrol)
 206 {
 207         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 208         unsigned int val;
 209         int change = 0;
 210
 211         val = ucontrol->value.enumerated.item[0] ;
 212         if (val >= 6)
 213                 return -EINVAL;
 214         change = (emu->capture_source != val);
 215         if (change) {
 216                 emu->capture_source = val;
 217                 ca0106_set_capture_source(emu);
 218         }
 219         return change;
 220 }
 221
 222 static int snd_ca0106_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
 223                                           struct snd_ctl_elem_info *uinfo)
 224 {
 225         static const char * const texts[4] = {
 226                 "Phone", "Mic", "Line in", "Aux"
 227         };
 228
 229         return snd_ctl_enum_info(uinfo, 1, 4, texts);
 230 }
 231
 232 static int snd_ca0106_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
 233                                         struct snd_ctl_elem_value *ucontrol)
 234 {
 235         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 236
 237         ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
 238         return 0;
 239 }
 240
 241 static int snd_ca0106_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
 242                                         struct snd_ctl_elem_value *ucontrol)
 243 {
 244         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 245         unsigned int source_id;
 246         int change = 0;
 247         /* If the capture source has changed,
 248          * update the capture volume from the cached value
 249          * for the particular source.
 250          */
 251         source_id = ucontrol->value.enumerated.item[0] ;
 252         if (source_id >= 4)
 253                 return -EINVAL;
 254         change = (emu->i2c_capture_source != source_id);
 255         if (change) {
 256                 ca0106_set_i2c_capture_source(emu, source_id, 0);
 257         }
 258         return change;
 259 }
 260
 261 static int snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol *kcontrol,
 262                                                struct snd_ctl_elem_info *uinfo)
 263 {
 264         static const char * const texts[2] = { "Side out", "Line in" };
 265
 266         return snd_ctl_enum_info(uinfo, 1, 2, texts);
 267 }
 268
 269 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
 270                                                struct snd_ctl_elem_info *uinfo)
 271 {
 272         static const char * const texts[2] = { "Line in", "Mic in" };
 273
 274         return snd_ctl_enum_info(uinfo, 1, 2, texts);
 275 }
 276
 277 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
 278                                         struct snd_ctl_elem_value *ucontrol)
 279 {
 280         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 281
 282         ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
 283         return 0;
 284 }
 285
 286 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
 287                                         struct snd_ctl_elem_value *ucontrol)
 288 {
 289         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 290         unsigned int val;
 291         int change = 0;
 292
 293         val = ucontrol->value.enumerated.item[0] ;
 294         if (val > 1)
 295                 return -EINVAL;
 296         change = (emu->capture_mic_line_in != val);
 297         if (change) {
 298                 emu->capture_mic_line_in = val;
 299                 ca0106_set_capture_mic_line_in(emu);
 300         }
 301         return change;
 302 }
 303
 304 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in =
 305 {
 306         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 307         .name =         "Shared Mic/Line in Capture Switch",
 308         .info =         snd_ca0106_capture_mic_line_in_info,
 309         .get =          snd_ca0106_capture_mic_line_in_get,
 310         .put =          snd_ca0106_capture_mic_line_in_put
 311 };
 312
 313 static struct snd_kcontrol_new snd_ca0106_capture_line_in_side_out =
 314 {
 315         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 316         .name =         "Shared Line in/Side out Capture Switch",
 317         .info =         snd_ca0106_capture_line_in_side_out_info,
 318         .get =          snd_ca0106_capture_mic_line_in_get,
 319         .put =          snd_ca0106_capture_mic_line_in_put
 320 };
 321
 322
 323 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
 324                                  struct snd_ctl_elem_info *uinfo)
 325 {
 326         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 327         uinfo->count = 1;
 328         return 0;
 329 }
 330
 331 static void decode_spdif_bits(unsigned char *status, unsigned int bits)
 332 {
 333         status[0] = (bits >> 0) & 0xff;
 334         status[1] = (bits >> 8) & 0xff;
 335         status[2] = (bits >> 16) & 0xff;
 336         status[3] = (bits >> 24) & 0xff;
 337 }
 338
 339 static int snd_ca0106_spdif_get_default(struct snd_kcontrol *kcontrol,
 340                                  struct snd_ctl_elem_value *ucontrol)
 341 {
 342         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 343         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 344
 345         decode_spdif_bits(ucontrol->value.iec958.status,
 346                           emu->spdif_bits[idx]);
 347         return 0;
 348 }
 349
 350 static int snd_ca0106_spdif_get_stream(struct snd_kcontrol *kcontrol,
 351                                  struct snd_ctl_elem_value *ucontrol)
 352 {
 353         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 354         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 355
 356         decode_spdif_bits(ucontrol->value.iec958.status,
 357                           emu->spdif_str_bits[idx]);
 358         return 0;
 359 }
 360
 361 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
 362                                       struct snd_ctl_elem_value *ucontrol)
 363 {
 364         ucontrol->value.iec958.status[0] = 0xff;
 365         ucontrol->value.iec958.status[1] = 0xff;
 366         ucontrol->value.iec958.status[2] = 0xff;
 367         ucontrol->value.iec958.status[3] = 0xff;
 368         return 0;
 369 }
 370
 371 static unsigned int encode_spdif_bits(unsigned char *status)
 372 {
 373         return ((unsigned int)status[0] << 0) |
 374                 ((unsigned int)status[1] << 8) |
 375                 ((unsigned int)status[2] << 16) |
 376                 ((unsigned int)status[3] << 24);
 377 }
 378
 379 static int snd_ca0106_spdif_put_default(struct snd_kcontrol *kcontrol,
 380                                  struct snd_ctl_elem_value *ucontrol)
 381 {
 382         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 383         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 384         unsigned int val;
 385
 386         val = encode_spdif_bits(ucontrol->value.iec958.status);
 387         if (val != emu->spdif_bits[idx]) {
 388                 emu->spdif_bits[idx] = val;
 389                 /* FIXME: this isn't safe, but needed to keep the compatibility
 390                  * with older alsa-lib config
 391                  */
 392                 emu->spdif_str_bits[idx] = val;
 393                 ca0106_set_spdif_bits(emu, idx);
 394                 return 1;
 395         }
 396         return 0;
 397 }
 398
 399 static int snd_ca0106_spdif_put_stream(struct snd_kcontrol *kcontrol,
 400                                  struct snd_ctl_elem_value *ucontrol)
 401 {
 402         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 403         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 404         unsigned int val;
 405
 406         val = encode_spdif_bits(ucontrol->value.iec958.status);
 407         if (val != emu->spdif_str_bits[idx]) {
 408                 emu->spdif_str_bits[idx] = val;
 409                 ca0106_set_spdif_bits(emu, idx);
 410                 return 1;
 411         }
 412         return 0;
 413 }
 414
 415 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
 416                                   struct snd_ctl_elem_info *uinfo)
 417 {
 418         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 419         uinfo->count = 2;
 420         uinfo->value.integer.min = 0;
 421         uinfo->value.integer.max = 255;
 422         return 0;
 423 }
 424
 425 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
 426                                  struct snd_ctl_elem_value *ucontrol)
 427 {
 428         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 429         unsigned int value;
 430         int channel_id, reg;
 431
 432         channel_id = (kcontrol->private_value >> 8) & 0xff;
 433         reg = kcontrol->private_value & 0xff;
 434
 435         value = snd_ca0106_ptr_read(emu, reg, channel_id);
 436         ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
 437         ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
 438         return 0;
 439 }
 440
 441 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
 442                                  struct snd_ctl_elem_value *ucontrol)
 443 {
 444         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 445         unsigned int oval, nval;
 446         int channel_id, reg;
 447
 448         channel_id = (kcontrol->private_value >> 8) & 0xff;
 449         reg = kcontrol->private_value & 0xff;
 450
 451         oval = snd_ca0106_ptr_read(emu, reg, channel_id);
 452         nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
 453                 ((0xff - ucontrol->value.integer.value[1]) << 16);
 454         nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
 455                 ((0xff - ucontrol->value.integer.value[1]) );
 456         if (oval == nval)
 457                 return 0;
 458         snd_ca0106_ptr_write(emu, reg, channel_id, nval);
 459         return 1;
 460 }
 461
 462 static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
 463                                   struct snd_ctl_elem_info *uinfo)
 464 {
 465         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 466         uinfo->count = 2;
 467         uinfo->value.integer.min = 0;
 468         uinfo->value.integer.max = 255;
 469         return 0;
 470 }
 471
 472 static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
 473                                  struct snd_ctl_elem_value *ucontrol)
 474 {
 475         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 476         int source_id;
 477
 478         source_id = kcontrol->private_value;
 479
 480         ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
 481         ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
 482         return 0;
 483 }
 484
 485 static int snd_ca0106_i2c_volume_put(struct snd_kcontrol *kcontrol,
 486                                  struct snd_ctl_elem_value *ucontrol)
 487 {
 488         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 489         unsigned int ogain;
 490         unsigned int ngain;
 491         int source_id;
 492         int change = 0;
 493
 494         source_id = kcontrol->private_value;
 495         ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
 496         ngain = ucontrol->value.integer.value[0];
 497         if (ngain > 0xff)
 498                 return -EINVAL;
 499         if (ogain != ngain) {
 500                 if (emu->i2c_capture_source == source_id)
 501                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
 502                 emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
 503                 change = 1;
 504         }
 505         ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
 506         ngain = ucontrol->value.integer.value[1];
 507         if (ngain > 0xff)
 508                 return -EINVAL;
 509         if (ogain != ngain) {
 510                 if (emu->i2c_capture_source == source_id)
 511                         snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
 512                 emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
 513                 change = 1;
 514         }
 515
 516         return change;
 517 }
 518
 519 #define spi_mute_info   snd_ctl_boolean_mono_info
 520
 521 static int spi_mute_get(struct snd_kcontrol *kcontrol,
 522                         struct snd_ctl_elem_value *ucontrol)
 523 {
 524         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 525         unsigned int reg = kcontrol->private_value >> SPI_REG_SHIFT;
 526         unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
 527
 528         ucontrol->value.integer.value[0] = !(emu->spi_dac_reg[reg] & bit);
 529         return 0;
 530 }
 531
 532 static int spi_mute_put(struct snd_kcontrol *kcontrol,
 533                         struct snd_ctl_elem_value *ucontrol)
 534 {
 535         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 536         unsigned int reg = kcontrol->private_value >> SPI_REG_SHIFT;
 537         unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
 538         int ret;
 539
 540         ret = emu->spi_dac_reg[reg] & bit;
 541         if (ucontrol->value.integer.value[0]) {
 542                 if (!ret)       /* bit already cleared, do nothing */
 543                         return 0;
 544                 emu->spi_dac_reg[reg] &= ~bit;
 545         } else {
 546                 if (ret)        /* bit already set, do nothing */
 547                         return 0;
 548                 emu->spi_dac_reg[reg] |= bit;
 549         }
 550
 551         ret = snd_ca0106_spi_write(emu, emu->spi_dac_reg[reg]);
 552         return ret ? -EINVAL : 1;
 553 }
 554
 555 #define CA_VOLUME(xname,chid,reg) \
 556 {                                                               \
 557         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
 558         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |             \
 559                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,               \
 560         .info =  snd_ca0106_volume_info,                        \
 561         .get =   snd_ca0106_volume_get,                         \
 562         .put =   snd_ca0106_volume_put,                         \
 563         .tlv = { .p = snd_ca0106_db_scale1 },                   \
 564         .private_value = ((chid) << 8) | (reg)                  \
 565 }
 566
 567 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] = {
 568         CA_VOLUME("Analog Front Playback Volume",
 569                   CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
 570         CA_VOLUME("Analog Rear Playback Volume",
 571                   CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
 572         CA_VOLUME("Analog Center/LFE Playback Volume",
 573                   CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
 574         CA_VOLUME("Analog Side Playback Volume",
 575                   CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
 576
 577         CA_VOLUME("IEC958 Front Playback Volume",
 578                   CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
 579         CA_VOLUME("IEC958 Rear Playback Volume",
 580                   CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
 581         CA_VOLUME("IEC958 Center/LFE Playback Volume",
 582                   CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
 583         CA_VOLUME("IEC958 Unknown Playback Volume",
 584                   CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
 585
 586         CA_VOLUME("CAPTURE feedback Playback Volume",
 587                   1, CAPTURE_CONTROL),
 588
 589         {
 590                 .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 591                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 592                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
 593                 .count =        4,
 594                 .info =         snd_ca0106_spdif_info,
 595                 .get =          snd_ca0106_spdif_get_mask
 596         },
 597         {
 598                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 599                 .name =         "IEC958 Playback Switch",
 600                 .info =         snd_ca0106_shared_spdif_info,
 601                 .get =          snd_ca0106_shared_spdif_get,
 602                 .put =          snd_ca0106_shared_spdif_put
 603         },
 604         {
 605                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 606                 .name =         "Digital Source Capture Enum",
 607                 .info =         snd_ca0106_capture_source_info,
 608                 .get =          snd_ca0106_capture_source_get,
 609                 .put =          snd_ca0106_capture_source_put
 610         },
 611         {
 612                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 613                 .name =         "Analog Source Capture Enum",
 614                 .info =         snd_ca0106_i2c_capture_source_info,
 615                 .get =          snd_ca0106_i2c_capture_source_get,
 616                 .put =          snd_ca0106_i2c_capture_source_put
 617         },
 618         {
 619                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 620                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 621                 .count =        4,
 622                 .info =         snd_ca0106_spdif_info,
 623                 .get =          snd_ca0106_spdif_get_default,
 624                 .put =          snd_ca0106_spdif_put_default
 625         },
 626         {
 627                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 628                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
 629                 .count =        4,
 630                 .info =         snd_ca0106_spdif_info,
 631                 .get =          snd_ca0106_spdif_get_stream,
 632                 .put =          snd_ca0106_spdif_put_stream
 633         },
 634 };
 635
 636 #define I2C_VOLUME(xname,chid) \
 637 {                                                               \
 638         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
 639         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |             \
 640                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,               \
 641         .info =  snd_ca0106_i2c_volume_info,                    \
 642         .get =   snd_ca0106_i2c_volume_get,                     \
 643         .put =   snd_ca0106_i2c_volume_put,                     \
 644         .tlv = { .p = snd_ca0106_db_scale2 },                   \
 645         .private_value = chid                                   \
 646 }
 647
 648 static struct snd_kcontrol_new snd_ca0106_volume_i2c_adc_ctls[] = {
 649         I2C_VOLUME("Phone Capture Volume", 0),
 650         I2C_VOLUME("Mic Capture Volume", 1),
 651         I2C_VOLUME("Line in Capture Volume", 2),
 652         I2C_VOLUME("Aux Capture Volume", 3),
 653 };
 654
 655 static const int spi_dmute_reg[] = {
 656         SPI_DMUTE0_REG,
 657         SPI_DMUTE1_REG,
 658         SPI_DMUTE2_REG,
 659         0,
 660         SPI_DMUTE4_REG,
 661 };
 662 static const int spi_dmute_bit[] = {
 663         SPI_DMUTE0_BIT,
 664         SPI_DMUTE1_BIT,
 665         SPI_DMUTE2_BIT,
 666         0,
 667         SPI_DMUTE4_BIT,
 668 };
 669
 670 static struct snd_kcontrol_new
 671 snd_ca0106_volume_spi_dac_ctl(struct snd_ca0106_details *details,
 672                               int channel_id)
 673 {
 674         struct snd_kcontrol_new spi_switch = {0};
 675         int reg, bit;
 676         int dac_id;
 677
 678         spi_switch.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 679         spi_switch.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
 680         spi_switch.info = spi_mute_info;
 681         spi_switch.get = spi_mute_get;
 682         spi_switch.put = spi_mute_put;
 683
 684         switch (channel_id) {
 685         case PCM_FRONT_CHANNEL:
 686                 spi_switch.name = "Analog Front Playback Switch";
 687                 dac_id = (details->spi_dac & 0xf000) >> (4 * 3);
 688                 break;
 689         case PCM_REAR_CHANNEL:
 690                 spi_switch.name = "Analog Rear Playback Switch";
 691                 dac_id = (details->spi_dac & 0x0f00) >> (4 * 2);
 692                 break;
 693         case PCM_CENTER_LFE_CHANNEL:
 694                 spi_switch.name = "Analog Center/LFE Playback Switch";
 695                 dac_id = (details->spi_dac & 0x00f0) >> (4 * 1);
 696                 break;
 697         case PCM_UNKNOWN_CHANNEL:
 698                 spi_switch.name = "Analog Side Playback Switch";
 699                 dac_id = (details->spi_dac & 0x000f) >> (4 * 0);
 700                 break;
 701         default:
 702                 /* Unused channel */
 703                 spi_switch.name = NULL;
 704                 dac_id = 0;
 705         }
 706         reg = spi_dmute_reg[dac_id];
 707         bit = spi_dmute_bit[dac_id];
 708
 709         spi_switch.private_value = (reg << SPI_REG_SHIFT) | bit;
 710
 711         return spi_switch;
 712 }
 713
 714 static int remove_ctl(struct snd_card *card, const char *name)
 715 {
 716         struct snd_ctl_elem_id id;
 717         memset(&id, 0, sizeof(id));
 718         strcpy(id.name, name);
 719         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 720         return snd_ctl_remove_id(card, &id);
 721 }
 722
 723 static struct snd_kcontrol *ctl_find(struct snd_card *card, const char *name)
 724 {
 725         struct snd_ctl_elem_id sid;
 726         memset(&sid, 0, sizeof(sid));
 727         /* FIXME: strcpy is bad. */
 728         strcpy(sid.name, name);
 729         sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 730         return snd_ctl_find_id(card, &sid);
 731 }
 732
 733 static int rename_ctl(struct snd_card *card, const char *src, const char *dst)
 734 {
 735         struct snd_kcontrol *kctl = ctl_find(card, src);
 736         if (kctl) {
 737                 strcpy(kctl->id.name, dst);
 738                 return 0;
 739         }
 740         return -ENOENT;
 741 }
 742
 743 #define ADD_CTLS(emu, ctls)                                             \
 744         do {                                                            \
 745                 int i, _err;                                            \
 746                 for (i = 0; i < ARRAY_SIZE(ctls); i++) {                \
 747                         _err = snd_ctl_add(card, snd_ctl_new1(&ctls[i], emu)); \
 748                         if (_err < 0)                                   \
 749                                 return _err;                            \
 750                 }                                                       \
 751         } while (0)
 752
 753 static
 754 DECLARE_TLV_DB_SCALE(snd_ca0106_master_db_scale, -6375, 25, 1);
 755
 756 static char *slave_vols[] = {
 757         "Analog Front Playback Volume",
 758         "Analog Rear Playback Volume",
 759         "Analog Center/LFE Playback Volume",
 760         "Analog Side Playback Volume",
 761         "IEC958 Front Playback Volume",
 762         "IEC958 Rear Playback Volume",
 763         "IEC958 Center/LFE Playback Volume",
 764         "IEC958 Unknown Playback Volume",
 765         "CAPTURE feedback Playback Volume",
 766         NULL
 767 };
 768
 769 static char *slave_sws[] = {
 770         "Analog Front Playback Switch",
 771         "Analog Rear Playback Switch",
 772         "Analog Center/LFE Playback Switch",
 773         "Analog Side Playback Switch",
 774         "IEC958 Playback Switch",
 775         NULL
 776 };
 777
 778 static void add_slaves(struct snd_card *card,
 779                                  struct snd_kcontrol *master, char **list)
 780 {
 781         for (; *list; list++) {
 782                 struct snd_kcontrol *slave = ctl_find(card, *list);
 783                 if (slave)
 784                         snd_ctl_add_slave(master, slave);
 785         }
 786 }
 787
 788 int snd_ca0106_mixer(struct snd_ca0106 *emu)
 789 {
 790         int err;
 791         struct snd_card *card = emu->card;
 792         char **c;
 793         struct snd_kcontrol *vmaster;
 794         static char *ca0106_remove_ctls[] = {
 795                 "Master Mono Playback Switch",
 796                 "Master Mono Playback Volume",
 797                 "3D Control - Switch",
 798                 "3D Control Sigmatel - Depth",
 799                 "PCM Playback Switch",
 800                 "PCM Playback Volume",
 801                 "CD Playback Switch",
 802                 "CD Playback Volume",
 803                 "Phone Playback Switch",
 804                 "Phone Playback Volume",
 805                 "Video Playback Switch",
 806                 "Video Playback Volume",
 807                 "Beep Playback Switch",
 808                 "Beep Playback Volume",
 809                 "Mono Output Select",
 810                 "Capture Source",
 811                 "Capture Switch",
 812                 "Capture Volume",
 813                 "External Amplifier",
 814                 "Sigmatel 4-Speaker Stereo Playback Switch",
 815                 "Surround Phase Inversion Playback Switch",
 816                 NULL
 817         };
 818         static char *ca0106_rename_ctls[] = {
 819                 "Master Playback Switch", "Capture Switch",
 820                 "Master Playback Volume", "Capture Volume",
 821                 "Line Playback Switch", "AC97 Line Capture Switch",
 822                 "Line Playback Volume", "AC97 Line Capture Volume",
 823                 "Aux Playback Switch", "AC97 Aux Capture Switch",
 824                 "Aux Playback Volume", "AC97 Aux Capture Volume",
 825                 "Mic Playback Switch", "AC97 Mic Capture Switch",
 826                 "Mic Playback Volume", "AC97 Mic Capture Volume",
 827                 "Mic Select", "AC97 Mic Select",
 828                 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
 829                 NULL
 830         };
 831 #if 1
 832         for (c = ca0106_remove_ctls; *c; c++)
 833                 remove_ctl(card, *c);
 834         for (c = ca0106_rename_ctls; *c; c += 2)
 835                 rename_ctl(card, c[0], c[1]);
 836 #endif
 837
 838         ADD_CTLS(emu, snd_ca0106_volume_ctls);
 839         if (emu->details->i2c_adc == 1) {
 840                 ADD_CTLS(emu, snd_ca0106_volume_i2c_adc_ctls);
 841                 if (emu->details->gpio_type == 1)
 842                         err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
 843                 else  /* gpio_type == 2 */
 844                         err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_line_in_side_out, emu));
 845                 if (err < 0)
 846                         return err;
 847         }
 848         if (emu->details->spi_dac) {
 849                 int i;
 850                 for (i = 0;; i++) {
 851                         struct snd_kcontrol_new ctl;
 852                         ctl = snd_ca0106_volume_spi_dac_ctl(emu->details, i);
 853                         if (!ctl.name)
 854                                 break;
 855                         err = snd_ctl_add(card, snd_ctl_new1(&ctl, emu));
 856                         if (err < 0)
 857                                 return err;
 858                 }
 859         }
 860
 861         /* Create virtual master controls */
 862         vmaster = snd_ctl_make_virtual_master("Master Playback Volume",
 863                                               snd_ca0106_master_db_scale);
 864         if (!vmaster)
 865                 return -ENOMEM;
 866         err = snd_ctl_add(card, vmaster);
 867         if (err < 0)
 868                 return err;
 869         add_slaves(card, vmaster, slave_vols);
 870
 871         if (emu->details->spi_dac) {
 872                 vmaster = snd_ctl_make_virtual_master("Master Playback Switch",
 873                                                       NULL);
 874                 if (!vmaster)
 875                         return -ENOMEM;
 876                 err = snd_ctl_add(card, vmaster);
 877                 if (err < 0)
 878                         return err;
 879                 add_slaves(card, vmaster, slave_sws);
 880         }
 881
 882         strcpy(card->mixername, "CA0106");
 883         return 0;
 884 }
 885
 886 #ifdef CONFIG_PM_SLEEP
 887 struct ca0106_vol_tbl {
 888         unsigned int channel_id;
 889         unsigned int reg;
 890 };
 891
 892 static struct ca0106_vol_tbl saved_volumes[NUM_SAVED_VOLUMES] = {
 893         { CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2 },
 894         { CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2 },
 895         { CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2 },
 896         { CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2 },
 897         { CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1 },
 898         { CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1 },
 899         { CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1 },
 900         { CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1 },
 901         { 1, CAPTURE_CONTROL },
 902 };
 903
 904 void snd_ca0106_mixer_suspend(struct snd_ca0106 *chip)
 905 {
 906         int i;
 907
 908         /* save volumes */
 909         for (i = 0; i < NUM_SAVED_VOLUMES; i++)
 910                 chip->saved_vol[i] =
 911                         snd_ca0106_ptr_read(chip, saved_volumes[i].reg,
 912                                             saved_volumes[i].channel_id);
 913 }
 914
 915 void snd_ca0106_mixer_resume(struct snd_ca0106  *chip)
 916 {
 917         int i;
 918
 919         for (i = 0; i < NUM_SAVED_VOLUMES; i++)
 920                 snd_ca0106_ptr_write(chip, saved_volumes[i].reg,
 921                                      saved_volumes[i].channel_id,
 922                                      chip->saved_vol[i]);
 923
 924         ca0106_spdif_enable(chip);
 925         ca0106_set_capture_source(chip);
 926         ca0106_set_i2c_capture_source(chip, chip->i2c_capture_source, 1);
 927         for (i = 0; i < 4; i++)
 928                 ca0106_set_spdif_bits(chip, i);
 929         if (chip->details->i2c_adc)
 930                 ca0106_set_capture_mic_line_in(chip);
 931 }
 932 #endif /* CONFIG_PM_SLEEP */