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_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
 175                                                struct snd_ctl_elem_info *uinfo)
 176 {
 177         static char *texts[2] = { "Line in", "Mic in" };
 178
 179         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 180         uinfo->count = 1;
 181         uinfo->value.enumerated.items = 2;
 182         if (uinfo->value.enumerated.item > 1)
 183                 uinfo->value.enumerated.item = 1;
 184         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 185         return 0;
 186 }
 187
 188 static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol,
 189                                         struct snd_ctl_elem_value *ucontrol)
 190 {
 191         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 192
 193         ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in;
 194         return 0;
 195 }
 196
 197 static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
 198                                         struct snd_ctl_elem_value *ucontrol)
 199 {
 200         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 201         unsigned int val;
 202         int change = 0;
 203         u32 tmp;
 204
 205         val = ucontrol->value.enumerated.item[0] ;
 206         change = (emu->capture_mic_line_in != val);
 207         if (change) {
 208                 emu->capture_mic_line_in = val;
 209                 if (val) {
 210                         snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_PHONE); /* Mute input */
 211                         tmp = inl(emu->port+GPIO) & ~0x400;
 212                         tmp = tmp | 0x400;
 213                         outl(tmp, emu->port+GPIO);
 214                         snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
 215                 } else {
 216                         snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_PHONE); /* Mute input */
 217                         tmp = inl(emu->port+GPIO) & ~0x400;
 218                         outl(tmp, emu->port+GPIO);
 219                         snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
 220                 }
 221         }
 222         return change;
 223 }
 224
 225 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata =
 226 {
 227         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 228         .name =         "Mic/Line in Capture",
 229         .info =         snd_ca0106_capture_mic_line_in_info,
 230         .get =          snd_ca0106_capture_mic_line_in_get,
 231         .put =          snd_ca0106_capture_mic_line_in_put
 232 };
 233
 234 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
 235                                  struct snd_ctl_elem_info *uinfo)
 236 {
 237         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 238         uinfo->count = 1;
 239         return 0;
 240 }
 241
 242 static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol,
 243                                  struct snd_ctl_elem_value *ucontrol)
 244 {
 245         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 246         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 247
 248         ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
 249         ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
 250         ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
 251         ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
 252         return 0;
 253 }
 254
 255 static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol,
 256                                       struct snd_ctl_elem_value *ucontrol)
 257 {
 258         ucontrol->value.iec958.status[0] = 0xff;
 259         ucontrol->value.iec958.status[1] = 0xff;
 260         ucontrol->value.iec958.status[2] = 0xff;
 261         ucontrol->value.iec958.status[3] = 0xff;
 262         return 0;
 263 }
 264
 265 static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol,
 266                                  struct snd_ctl_elem_value *ucontrol)
 267 {
 268         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 269         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 270         int change;
 271         unsigned int val;
 272
 273         val = (ucontrol->value.iec958.status[0] << 0) |
 274               (ucontrol->value.iec958.status[1] << 8) |
 275               (ucontrol->value.iec958.status[2] << 16) |
 276               (ucontrol->value.iec958.status[3] << 24);
 277         change = val != emu->spdif_bits[idx];
 278         if (change) {
 279                 snd_ca0106_ptr_write(emu, SPCS0 + idx, 0, val);
 280                 emu->spdif_bits[idx] = val;
 281         }
 282         return change;
 283 }
 284
 285 static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol,
 286                                   struct snd_ctl_elem_info *uinfo)
 287 {
 288         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 289         uinfo->count = 2;
 290         uinfo->value.integer.min = 0;
 291         uinfo->value.integer.max = 255;
 292         return 0;
 293 }
 294
 295 static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol,
 296                                  struct snd_ctl_elem_value *ucontrol)
 297 {
 298         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 299         unsigned int value;
 300         int channel_id, reg;
 301
 302         channel_id = (kcontrol->private_value >> 8) & 0xff;
 303         reg = kcontrol->private_value & 0xff;
 304
 305         value = snd_ca0106_ptr_read(emu, reg, channel_id);
 306         ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
 307         ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
 308         return 0;
 309 }
 310
 311 static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
 312                                  struct snd_ctl_elem_value *ucontrol)
 313 {
 314         struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
 315         unsigned int oval, nval;
 316         int channel_id, reg;
 317
 318         channel_id = (kcontrol->private_value >> 8) & 0xff;
 319         reg = kcontrol->private_value & 0xff;
 320
 321         oval = snd_ca0106_ptr_read(emu, reg, channel_id);
 322         nval = ((0xff - ucontrol->value.integer.value[0]) << 24) |
 323                 ((0xff - ucontrol->value.integer.value[1]) << 16);
 324         nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
 325                 ((0xff - ucontrol->value.integer.value[1]) );
 326         if (oval == nval)
 327                 return 0;
 328         snd_ca0106_ptr_write(emu, reg, channel_id, nval);
 329         return 1;
 330 }
 331
 332 #define CA_VOLUME(xname,chid,reg) \
 333 {                                                               \
 334         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
 335         .info = snd_ca0106_volume_info,                         \
 336         .get =          snd_ca0106_volume_get,                  \
 337         .put =          snd_ca0106_volume_put,                  \
 338         .private_value = ((chid) << 8) | (reg)                  \
 339 }
 340
 341
 342 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
 343         CA_VOLUME("Analog Front Playback Volume",
 344                   CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2),
 345         CA_VOLUME("Analog Rear Playback Volume",
 346                   CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2),
 347         CA_VOLUME("Analog Center/LFE Playback Volume",
 348                   CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2),
 349         CA_VOLUME("Analog Side Playback Volume",
 350                   CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2),
 351
 352         CA_VOLUME("IEC958 Front Playback Volume",
 353                   CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1),
 354         CA_VOLUME("IEC958 Rear Playback Volume",
 355                   CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1),
 356         CA_VOLUME("IEC958 Center/LFE Playback Volume",
 357                   CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1),
 358         CA_VOLUME("IEC958 Unknown Playback Volume",
 359                   CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1),
 360
 361         CA_VOLUME("CAPTURE feedback Playback Volume",
 362                   1, CAPTURE_CONTROL),
 363
 364         {
 365                 .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 366                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 367                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
 368                 .count =        4,
 369                 .info =         snd_ca0106_spdif_info,
 370                 .get =          snd_ca0106_spdif_get_mask
 371         },
 372         {
 373                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 374                 .name =         "IEC958 Playback Switch",
 375                 .info =         snd_ca0106_shared_spdif_info,
 376                 .get =          snd_ca0106_shared_spdif_get,
 377                 .put =          snd_ca0106_shared_spdif_put
 378         },
 379         {
 380                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 381                 .name =         "Capture Source",
 382                 .info =         snd_ca0106_capture_source_info,
 383                 .get =          snd_ca0106_capture_source_get,
 384                 .put =          snd_ca0106_capture_source_put
 385         },
 386         {
 387                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 388                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 389                 .count =        4,
 390                 .info =         snd_ca0106_spdif_info,
 391                 .get =          snd_ca0106_spdif_get,
 392                 .put =          snd_ca0106_spdif_put
 393         },
 394 };
 395
 396 static int __devinit remove_ctl(struct snd_card *card, const char *name)
 397 {
 398         struct snd_ctl_elem_id id;
 399         memset(&id, 0, sizeof(id));
 400         strcpy(id.name, name);
 401         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 402         return snd_ctl_remove_id(card, &id);
 403 }
 404
 405 static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name)
 406 {
 407         struct snd_ctl_elem_id sid;
 408         memset(&sid, 0, sizeof(sid));
 409         /* FIXME: strcpy is bad. */
 410         strcpy(sid.name, name);
 411         sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 412         return snd_ctl_find_id(card, &sid);
 413 }
 414
 415 static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst)
 416 {
 417         struct snd_kcontrol *kctl = ctl_find(card, src);
 418         if (kctl) {
 419                 strcpy(kctl->id.name, dst);
 420                 return 0;
 421         }
 422         return -ENOENT;
 423 }
 424
 425 int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
 426 {
 427         int i, err;
 428         struct snd_card *card = emu->card;
 429         char **c;
 430         static char *ca0106_remove_ctls[] = {
 431                 "Master Mono Playback Switch",
 432                 "Master Mono Playback Volume",
 433                 "3D Control - Switch",
 434                 "3D Control Sigmatel - Depth",
 435                 "PCM Playback Switch",
 436                 "PCM Playback Volume",
 437                 "CD Playback Switch",
 438                 "CD Playback Volume",
 439                 "Phone Playback Switch",
 440                 "Phone Playback Volume",
 441                 "Video Playback Switch",
 442                 "Video Playback Volume",
 443                 "PC Speaker Playback Switch",
 444                 "PC Speaker Playback Volume",
 445                 "Mono Output Select",
 446                 "Capture Source",
 447                 "Capture Switch",
 448                 "Capture Volume",
 449                 "External Amplifier",
 450                 "Sigmatel 4-Speaker Stereo Playback Switch",
 451                 "Sigmatel Surround Phase Inversion Playback ",
 452                 NULL
 453         };
 454         static char *ca0106_rename_ctls[] = {
 455                 "Master Playback Switch", "Capture Switch",
 456                 "Master Playback Volume", "Capture Volume",
 457                 "Line Playback Switch", "AC97 Line Capture Switch",
 458                 "Line Playback Volume", "AC97 Line Capture Volume",
 459                 "Aux Playback Switch", "AC97 Aux Capture Switch",
 460                 "Aux Playback Volume", "AC97 Aux Capture Volume",
 461                 "Mic Playback Switch", "AC97 Mic Capture Switch",
 462                 "Mic Playback Volume", "AC97 Mic Capture Volume",
 463                 "Mic Select", "AC97 Mic Select",
 464                 "Mic Boost (+20dB)", "AC97 Mic Boost (+20dB)",
 465                 NULL
 466         };
 467 #if 1
 468         for (c = ca0106_remove_ctls; *c; c++)
 469                 remove_ctl(card, *c);
 470         for (c = ca0106_rename_ctls; *c; c += 2)
 471                 rename_ctl(card, c[0], c[1]);
 472 #endif
 473
 474         for (i = 0; i < ARRAY_SIZE(snd_ca0106_volume_ctls); i++) {
 475                 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_volume_ctls[i], emu));
 476                 if (err < 0)
 477                         return err;
 478         }
 479         if (emu->details->i2c_adc == 1) {
 480                 err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
 481                 if (err < 0)
 482                         return err;
 483         }
 484         return 0;
 485 }
 486