sound/pci/ac97/ac97_codec.c

   1 /*
   2  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
   3  *  Universal interface for Audio Codec '97
   4  *
   5  *  For more details look to AC '97 component specification revision 2.2
   6  *  by Intel Corporation (http://developer.intel.com).
   7  *
   8  *
   9  *   This program is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation; either version 2 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This program is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU General Public License
  20  *   along with this program; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  22  *
  23  */
  24
  25 #include <sound/driver.h>
  26 #include <linux/delay.h>
  27 #include <linux/init.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <linux/moduleparam.h>
  31 #include <sound/core.h>
  32 #include <sound/pcm.h>
  33 #include <sound/ac97_codec.h>
  34 #include <sound/asoundef.h>
  35 #include <sound/initval.h>
  36 #include "ac97_local.h"
  37 #include "ac97_id.h"
  38 #include "ac97_patch.h"
  39
  40 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
  41 MODULE_DESCRIPTION("Universal interface for Audio Codec '97");
  42 MODULE_LICENSE("GPL");
  43
  44 static int enable_loopback;
  45
  46 module_param(enable_loopback, bool, 0444);
  47 MODULE_PARM_DESC(enable_loopback, "Enable AC97 ADC/DAC Loopback Control");
  48 MODULE_PARM_SYNTAX(enable_loopback, SNDRV_BOOLEAN_FALSE_DESC);
  49
  50 #define chip_t ac97_t
  51
  52 /*
  53
  54  */
  55
  56 typedef struct {
  57         unsigned int id;
  58         unsigned int mask;
  59         const char *name;
  60         int (*patch)(ac97_t *ac97);
  61         int (*mpatch)(ac97_t *ac97);
  62 } ac97_codec_id_t;
  63
  64 static const ac97_codec_id_t snd_ac97_codec_id_vendors[] = {
  65 { 0x414b4d00, 0xffffff00, "Asahi Kasei",        NULL,   NULL },
  66 { 0x41445300, 0xffffff00, "Analog Devices",     NULL,   NULL },
  67 { 0x414c4300, 0xffffff00, "Realtek",            NULL,   NULL },
  68 { 0x414c4700, 0xffffff00, "Realtek",            NULL,   NULL },
  69 { 0x434d4900, 0xffffff00, "C-Media Electronics", NULL,  NULL },
  70 { 0x43525900, 0xffffff00, "Cirrus Logic",       NULL,   NULL },
  71 { 0x43585400, 0xffffff00, "Conexant",           NULL,   NULL },
  72 { 0x44543000, 0xffffff00, "Diamond Technology", NULL,   NULL },
  73 { 0x454d4300, 0xffffff00, "eMicro",             NULL,   NULL },
  74 { 0x45838300, 0xffffff00, "ESS Technology",     NULL,   NULL },
  75 { 0x48525300, 0xffffff00, "Intersil",           NULL,   NULL },
  76 { 0x49434500, 0xffffff00, "ICEnsemble",         NULL,   NULL },
  77 { 0x49544500, 0xffffff00, "ITE Tech.Inc",       NULL,   NULL },
  78 { 0x4e534300, 0xffffff00, "National Semiconductor", NULL, NULL },
  79 { 0x50534300, 0xffffff00, "Philips",            NULL,   NULL },
  80 { 0x53494c00, 0xffffff00, "Silicon Laboratory", NULL,   NULL },
  81 { 0x54524100, 0xffffff00, "TriTech",            NULL,   NULL },
  82 { 0x54584e00, 0xffffff00, "Texas Instruments",  NULL,   NULL },
  83 { 0x56494100, 0xffffff00, "VIA Technologies",   NULL,   NULL },
  84 { 0x57454300, 0xffffff00, "Winbond",            NULL,   NULL },
  85 { 0x574d4c00, 0xffffff00, "Wolfson",            NULL,   NULL },
  86 { 0x594d4800, 0xffffff00, "Yamaha",             NULL,   NULL },
  87 { 0x83847600, 0xffffff00, "SigmaTel",           NULL,   NULL },
  88 { 0,          0,          NULL,                 NULL,   NULL }
  89 };
  90
  91 static const ac97_codec_id_t snd_ac97_codec_ids[] = {
  92 { 0x414b4d00, 0xffffffff, "AK4540",             NULL,           NULL },
  93 { 0x414b4d01, 0xffffffff, "AK4542",             NULL,           NULL },
  94 { 0x414b4d02, 0xffffffff, "AK4543",             NULL,           NULL },
  95 { 0x414b4d06, 0xffffffff, "AK4544A",            NULL,           NULL },
  96 { 0x414b4d07, 0xffffffff, "AK4545",             NULL,           NULL },
  97 { 0x41445303, 0xffffffff, "AD1819",             patch_ad1819,   NULL },
  98 { 0x41445340, 0xffffffff, "AD1881",             patch_ad1881,   NULL },
  99 { 0x41445348, 0xffffffff, "AD1881A",            patch_ad1881,   NULL },
 100 { 0x41445360, 0xffffffff, "AD1885",             patch_ad1885,   NULL },
 101 { 0x41445361, 0xffffffff, "AD1886",             patch_ad1886,   NULL },
 102 { 0x41445362, 0xffffffff, "AD1887",             patch_ad1881,   NULL },
 103 { 0x41445363, 0xffffffff, "AD1886A",            patch_ad1881,   NULL },
 104 { 0x41445368, 0xffffffff, "AD1888",             patch_ad1888,   NULL },
 105 { 0x41445370, 0xffffffff, "AD1980",             patch_ad1980,   NULL },
 106 { 0x41445372, 0xffffffff, "AD1981A",            patch_ad1981a,  NULL },
 107 { 0x41445374, 0xffffffff, "AD1981B",            patch_ad1981b,  NULL },
 108 { 0x41445375, 0xffffffff, "AD1985",             patch_ad1985,   NULL },
 109 { 0x414c4300, 0xffffff00, "ALC100/100P",        NULL,           NULL },
 110 { 0x414c4710, 0xfffffff0, "ALC200/200P",        NULL,           NULL },
 111 { 0x414c4720, 0xfffffff0, "ALC650",             patch_alc650,   NULL },
 112 { 0x414c4721, 0xfffffff0, "ALC650D",            patch_alc650,   NULL },
 113 { 0x414c4722, 0xfffffff0, "ALC650E",            patch_alc650,   NULL },
 114 { 0x414c4723, 0xfffffff0, "ALC650F",            patch_alc650,   NULL },
 115 { 0x414c4760, 0xfffffff0, "ALC655",             patch_alc655,   NULL },
 116 { 0x414c4780, 0xfffffff0, "ALC658",             patch_alc655,   NULL },
 117 { 0x414c4730, 0xffffffff, "ALC101",             NULL,           NULL },
 118 { 0x414c4740, 0xfffffff0, "ALC202",             NULL,           NULL },
 119 { 0x414c4750, 0xfffffff0, "ALC250",             NULL,           NULL },
 120 { 0x414c4770, 0xfffffff0, "ALC203",             NULL,           NULL },
 121 { 0x434d4941, 0xffffffff, "CMI9738",            patch_cm9738,   NULL },
 122 { 0x434d4961, 0xffffffff, "CMI9739",            patch_cm9739,   NULL },
 123 { 0x43525900, 0xfffffff8, "CS4297",             NULL,           NULL },
 124 { 0x43525910, 0xfffffff8, "CS4297A",            patch_cirrus_spdif,     NULL },
 125 { 0x43525920, 0xfffffff8, "CS4294/4298",        NULL,           NULL },
 126 { 0x43525928, 0xfffffff8, "CS4294",             NULL,           NULL },
 127 { 0x43525930, 0xfffffff8, "CS4299",             patch_cirrus_cs4299,    NULL },
 128 { 0x43525948, 0xfffffff8, "CS4201",             NULL,           NULL },
 129 { 0x43525958, 0xfffffff8, "CS4205",             patch_cirrus_spdif,     NULL },
 130 { 0x43525960, 0xfffffff8, "CS4291",             NULL,           NULL },
 131 { 0x43525970, 0xfffffff8, "CS4202",             NULL,           NULL },
 132 { 0x43585421, 0xffffffff, "HSD11246",           NULL,           NULL }, // SmartMC II
 133 { 0x43585428, 0xfffffff8, "Cx20468",            patch_conexant, NULL }, // SmartAMC fixme: the mask might be different
 134 { 0x44543031, 0xfffffff0, "DT0398",             NULL,           NULL },
 135 { 0x454d4328, 0xffffffff, "28028",              NULL,           NULL },  // same as TR28028?
 136 { 0x45838308, 0xffffffff, "ESS1988",            NULL,           NULL },
 137 { 0x48525300, 0xffffff00, "HMP9701",            NULL,           NULL },
 138 { 0x49434501, 0xffffffff, "ICE1230",            NULL,           NULL },
 139 { 0x49434511, 0xffffffff, "ICE1232",            NULL,           NULL }, // alias VIA VT1611A?
 140 { 0x49434514, 0xffffffff, "ICE1232A",           NULL,           NULL },
 141 { 0x49434551, 0xffffffff, "VT1616",             patch_vt1616,   NULL },
 142 { 0x49434552, 0xffffffff, "VT1616i",            patch_vt1616,   NULL }, // VT1616 compatible (chipset integrated)
 143 { 0x49544520, 0xffffffff, "IT2226E",            NULL,           NULL },
 144 { 0x49544561, 0xffffffff, "IT2646E",            patch_it2646,   NULL },
 145 { 0x4e534300, 0xffffffff, "LM4540/43/45/46/48", NULL,           NULL }, // only guess --jk
 146 { 0x4e534331, 0xffffffff, "LM4549",             NULL,           NULL },
 147 { 0x4e534350, 0xffffffff, "LM4550",             NULL,           NULL },
 148 { 0x50534304, 0xffffffff, "UCB1400",            NULL,           NULL },
 149 { 0x53494c20, 0xffffffe0, "Si3036/8",           NULL,           mpatch_si3036 },
 150 { 0x54524102, 0xffffffff, "TR28022",            NULL,           NULL },
 151 { 0x54524106, 0xffffffff, "TR28026",            NULL,           NULL },
 152 { 0x54524108, 0xffffffff, "TR28028",            patch_tritech_tr28028,  NULL }, // added by xin jin [07/09/99]
 153 { 0x54524123, 0xffffffff, "TR28602",            NULL,           NULL }, // only guess --jk [TR28023 = eMicro EM28023 (new CT1297)]
 154 { 0x54584e20, 0xffffffff, "TLC320AD9xC",        NULL,           NULL },
 155 { 0x56494161, 0xffffffff, "VIA1612A",           NULL,           NULL }, // modified ICE1232 with S/PDIF
 156 { 0x57454301, 0xffffffff, "W83971D",            NULL,           NULL },
 157 { 0x574d4c00, 0xffffffff, "WM9701A",            NULL,           NULL },
 158 { 0x574d4C03, 0xffffffff, "WM9703/WM9707/WM9708/WM9717", patch_wolfson03, NULL},
 159 { 0x574d4C04, 0xffffffff, "WM9704M/WM9704Q",    patch_wolfson04, NULL},
 160 { 0x574d4C05, 0xffffffff, "WM9705/WM9710",      patch_wolfson05, NULL},
 161 { 0x574d4C09, 0xffffffff, "WM9709",             NULL,           NULL},
 162 { 0x574d4C12, 0xffffffff, "WM9711/WM9712",      patch_wolfson11, NULL},
 163 { 0x594d4800, 0xffffffff, "YMF743",             NULL,           NULL },
 164 { 0x594d4802, 0xffffffff, "YMF752",             NULL,           NULL },
 165 { 0x594d4803, 0xffffffff, "YMF753",             patch_yamaha_ymf753,    NULL },
 166 { 0x83847600, 0xffffffff, "STAC9700/83/84",     patch_sigmatel_stac9700,        NULL },
 167 { 0x83847604, 0xffffffff, "STAC9701/3/4/5",     NULL,           NULL },
 168 { 0x83847605, 0xffffffff, "STAC9704",           NULL,           NULL },
 169 { 0x83847608, 0xffffffff, "STAC9708/11",        patch_sigmatel_stac9708,        NULL },
 170 { 0x83847609, 0xffffffff, "STAC9721/23",        patch_sigmatel_stac9721,        NULL },
 171 { 0x83847644, 0xffffffff, "STAC9744",           patch_sigmatel_stac9744,        NULL },
 172 { 0x83847650, 0xffffffff, "STAC9750/51",        NULL,           NULL }, // patch?
 173 { 0x83847652, 0xffffffff, "STAC9752/53",        NULL,           NULL }, // patch?
 174 { 0x83847656, 0xffffffff, "STAC9756/57",        patch_sigmatel_stac9756,        NULL },
 175 { 0x83847658, 0xffffffff, "STAC9758/59",        patch_sigmatel_stac9758,        NULL },
 176 { 0x83847666, 0xffffffff, "STAC9766/67",        NULL,           NULL }, // patch?
 177 { 0,          0,          NULL,                 NULL,           NULL }
 178 };
 179
 180 const char *snd_ac97_stereo_enhancements[] =
 181 {
 182   /*   0 */ "No 3D Stereo Enhancement",
 183   /*   1 */ "Analog Devices Phat Stereo",
 184   /*   2 */ "Creative Stereo Enhancement",
 185   /*   3 */ "National Semi 3D Stereo Enhancement",
 186   /*   4 */ "YAMAHA Ymersion",
 187   /*   5 */ "BBE 3D Stereo Enhancement",
 188   /*   6 */ "Crystal Semi 3D Stereo Enhancement",
 189   /*   7 */ "Qsound QXpander",
 190   /*   8 */ "Spatializer 3D Stereo Enhancement",
 191   /*   9 */ "SRS 3D Stereo Enhancement",
 192   /*  10 */ "Platform Tech 3D Stereo Enhancement",
 193   /*  11 */ "AKM 3D Audio",
 194   /*  12 */ "Aureal Stereo Enhancement",
 195   /*  13 */ "Aztech 3D Enhancement",
 196   /*  14 */ "Binaura 3D Audio Enhancement",
 197   /*  15 */ "ESS Technology Stereo Enhancement",
 198   /*  16 */ "Harman International VMAx",
 199   /*  17 */ "Nvidea/IC Ensemble/KS Waves 3D Stereo Enhancement",
 200   /*  18 */ "Philips Incredible Sound",
 201   /*  19 */ "Texas Instruments 3D Stereo Enhancement",
 202   /*  20 */ "VLSI Technology 3D Stereo Enhancement",
 203   /*  21 */ "TriTech 3D Stereo Enhancement",
 204   /*  22 */ "Realtek 3D Stereo Enhancement",
 205   /*  23 */ "Samsung 3D Stereo Enhancement",
 206   /*  24 */ "Wolfson Microelectronics 3D Enhancement",
 207   /*  25 */ "Delta Integration 3D Enhancement",
 208   /*  26 */ "SigmaTel 3D Enhancement",
 209   /*  27 */ "IC Ensemble/KS Waves",
 210   /*  28 */ "Rockwell 3D Stereo Enhancement",
 211   /*  29 */ "Reserved 29",
 212   /*  30 */ "Reserved 30",
 213   /*  31 */ "Reserved 31"
 214 };
 215
 216 /*
 217  *  I/O routines
 218  */
 219
 220 static int snd_ac97_valid_reg(ac97_t *ac97, unsigned short reg)
 221 {
 222         if (ac97->limited_regs && ! test_bit(reg, ac97->reg_accessed))
 223                 return 0;
 224
 225         /* filter some registers for buggy codecs */
 226         switch (ac97->id) {
 227         case AC97_ID_AK4540:
 228         case AC97_ID_AK4542:
 229                 if (reg <= 0x1c || reg == 0x20 || reg == 0x26 || reg >= 0x7c)
 230                         return 1;
 231                 return 0;
 232         case AC97_ID_AD1819:    /* AD1819 */
 233         case AC97_ID_AD1881:    /* AD1881 */
 234         case AC97_ID_AD1881A:   /* AD1881A */
 235                 if (reg >= 0x3a && reg <= 0x6e) /* 0x59 */
 236                         return 0;
 237                 return 1;
 238         case AC97_ID_AD1885:    /* AD1885 */
 239         case AC97_ID_AD1886:    /* AD1886 */
 240         case AC97_ID_AD1886A:   /* AD1886A - !!verify!! --jk */
 241         case AC97_ID_AD1887:    /* AD1887 - !!verify!! --jk */
 242                 if (reg == 0x5a)
 243                         return 1;
 244                 if (reg >= 0x3c && reg <= 0x6e) /* 0x59 */
 245                         return 0;
 246                 return 1;
 247         case AC97_ID_STAC9700:
 248         case AC97_ID_STAC9704:
 249         case AC97_ID_STAC9705:
 250         case AC97_ID_STAC9708:
 251         case AC97_ID_STAC9721:
 252         case AC97_ID_STAC9744:
 253         case AC97_ID_STAC9756:
 254                 if (reg <= 0x3a || reg >= 0x5a)
 255                         return 1;
 256                 return 0;
 257         }
 258         return 1;
 259 }
 260
 261 /**
 262  * snd_ac97_write - write a value on the given register
 263  * @ac97: the ac97 instance
 264  * @reg: the register to change
 265  * @value: the value to set
 266  *
 267  * Writes a value on the given register.  This will invoke the write
 268  * callback directly after the register check.
 269  * This function doesn't change the register cache unlike
 270  * #snd_ca97_write_cache(), so use this only when you don't want to
 271  * reflect the change to the suspend/resume state.
 272  */
 273 void snd_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short value)
 274 {
 275         if (!snd_ac97_valid_reg(ac97, reg))
 276                 return;
 277         if ((ac97->id & 0xffffff00) == 0x414c4300) {
 278                 /* Fix H/W bug of ALC100/100P */
 279                 if (reg == AC97_MASTER || reg == AC97_HEADPHONE)
 280                         ac97->bus->write(ac97, AC97_RESET, 0);  /* reset audio codec */
 281         }
 282         ac97->bus->write(ac97, reg, value);
 283 }
 284
 285 /**
 286  * snd_ac97_read - read a value from the given register
 287  *
 288  * @ac97: the ac97 instance
 289  * @reg: the register to read
 290  *
 291  * Reads a value from the given register.  This will invoke the read
 292  * callback directly after the register check.
 293  *
 294  * Returns the read value.
 295  */
 296 unsigned short snd_ac97_read(ac97_t *ac97, unsigned short reg)
 297 {
 298         if (!snd_ac97_valid_reg(ac97, reg))
 299                 return 0;
 300         return ac97->bus->read(ac97, reg);
 301 }
 302
 303 /* read a register - return the cached value if already read */
 304 static inline unsigned short snd_ac97_read_cache(ac97_t *ac97, unsigned short reg)
 305 {
 306         if (! test_bit(reg, ac97->reg_accessed)) {
 307                 ac97->regs[reg] = ac97->bus->read(ac97, reg);
 308                 // set_bit(reg, ac97->reg_accessed);
 309         }
 310         return ac97->regs[reg];
 311 }
 312
 313 /**
 314  * snd_ac97_write_cache - write a value on the given register and update the cache
 315  * @ac97: the ac97 instance
 316  * @reg: the register to change
 317  * @value: the value to set
 318  *
 319  * Writes a value on the given register and updates the register
 320  * cache.  The cached values are used for the cached-read and the
 321  * suspend/resume.
 322  */
 323 void snd_ac97_write_cache(ac97_t *ac97, unsigned short reg, unsigned short value)
 324 {
 325         if (!snd_ac97_valid_reg(ac97, reg))
 326                 return;
 327         spin_lock(&ac97->reg_lock);
 328         ac97->regs[reg] = value;
 329         spin_unlock(&ac97->reg_lock);
 330         ac97->bus->write(ac97, reg, value);
 331         set_bit(reg, ac97->reg_accessed);
 332 }
 333
 334 /**
 335  * snd_ac97_update - update the value on the given register
 336  * @ac97: the ac97 instance
 337  * @reg: the register to change
 338  * @value: the value to set
 339  *
 340  * Compares the value with the register cache and updates the value
 341  * only when the value is changed.
 342  *
 343  * Returns 1 if the value is changed, 0 if no change, or a negative
 344  * code on failure.
 345  */
 346 int snd_ac97_update(ac97_t *ac97, unsigned short reg, unsigned short value)
 347 {
 348         int change;
 349
 350         if (!snd_ac97_valid_reg(ac97, reg))
 351                 return -EINVAL;
 352         spin_lock(&ac97->reg_lock);
 353         change = ac97->regs[reg] != value;
 354         if (change) {
 355                 ac97->regs[reg] = value;
 356                 spin_unlock(&ac97->reg_lock);
 357                 ac97->bus->write(ac97, reg, value);
 358         } else
 359                 spin_unlock(&ac97->reg_lock);
 360         return change;
 361 }
 362
 363 /**
 364  * snd_ac97_update_bits - update the bits on the given register
 365  * @ac97: the ac97 instance
 366  * @reg: the register to change
 367  * @mask: the bit-mask to change
 368  * @value: the value to set
 369  *
 370  * Updates the masked-bits on the given register only when the value
 371  * is changed.
 372  *
 373  * Returns 1 if the bits are changed, 0 if no change, or a negative
 374  * code on failure.
 375  */
 376 int snd_ac97_update_bits(ac97_t *ac97, unsigned short reg, unsigned short mask, unsigned short value)
 377 {
 378         int change;
 379         unsigned short old, new;
 380
 381         if (!snd_ac97_valid_reg(ac97, reg))
 382                 return -EINVAL;
 383         spin_lock(&ac97->reg_lock);
 384         old = snd_ac97_read_cache(ac97, reg);
 385         new = (old & ~mask) | value;
 386         change = old != new;
 387         if (change) {
 388                 ac97->regs[reg] = new;
 389                 spin_unlock(&ac97->reg_lock);
 390                 ac97->bus->write(ac97, reg, new);
 391         } else
 392                 spin_unlock(&ac97->reg_lock);
 393         return change;
 394 }
 395
 396 static int snd_ac97_ad18xx_update_pcm_bits(ac97_t *ac97, int codec, unsigned short mask, unsigned short value)
 397 {
 398         int change;
 399         unsigned short old, new, cfg;
 400
 401         down(&ac97->spec.ad18xx.mutex);
 402         spin_lock(&ac97->reg_lock);
 403         old = ac97->spec.ad18xx.pcmreg[codec];
 404         new = (old & ~mask) | value;
 405         cfg = snd_ac97_read_cache(ac97, AC97_AD_SERIAL_CFG);
 406         change = old != new;
 407         if (change) {
 408                 ac97->spec.ad18xx.pcmreg[codec] = new;
 409                 spin_unlock(&ac97->reg_lock);
 410                 /* select single codec */
 411                 ac97->bus->write(ac97, AC97_AD_SERIAL_CFG,
 412                                  (cfg & ~0x7000) |
 413                                  ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
 414                 /* update PCM bits */
 415                 ac97->bus->write(ac97, AC97_PCM, new);
 416                 /* select all codecs */
 417                 ac97->bus->write(ac97, AC97_AD_SERIAL_CFG,
 418                                  cfg | 0x7000);
 419         } else
 420                 spin_unlock(&ac97->reg_lock);
 421         up(&ac97->spec.ad18xx.mutex);
 422         return change;
 423 }
 424
 425 /*
 426  *
 427  */
 428
 429 static int snd_ac97_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 430 {
 431         static char *texts[8] = {
 432                 "Mic", "CD", "Video", "Aux", "Line",
 433                 "Mix", "Mix Mono", "Phone"
 434         };
 435
 436         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 437         uinfo->count = 2;
 438         uinfo->value.enumerated.items = 8;
 439         if (uinfo->value.enumerated.item > 7)
 440                 uinfo->value.enumerated.item = 7;
 441         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 442         return 0;
 443 }
 444
 445 static int snd_ac97_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 446 {
 447         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 448         unsigned short val;
 449
 450         val = snd_ac97_read_cache(ac97, AC97_REC_SEL);
 451         ucontrol->value.enumerated.item[0] = (val >> 8) & 7;
 452         ucontrol->value.enumerated.item[1] = (val >> 0) & 7;
 453         return 0;
 454 }
 455
 456 static int snd_ac97_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 457 {
 458         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 459         unsigned short val;
 460
 461         if (ucontrol->value.enumerated.item[0] > 7 ||
 462             ucontrol->value.enumerated.item[1] > 7)
 463                 return -EINVAL;
 464         val = (ucontrol->value.enumerated.item[0] << 8) |
 465               (ucontrol->value.enumerated.item[1] << 0);
 466         return snd_ac97_update(ac97, AC97_REC_SEL, val);
 467 }
 468
 469 #define AC97_ENUM_DOUBLE(xname, reg, shift, invert) \
 470 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_info_enum_double, \
 471   .get = snd_ac97_get_enum_double, .put = snd_ac97_put_enum_double, \
 472   .private_value = reg | (shift << 8) | (invert << 24) }
 473
 474 static int snd_ac97_info_enum_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 475 {
 476         static char *texts1[2] = { "pre 3D", "post 3D" };
 477         static char *texts2[2] = { "Mix", "Mic" };
 478         static char *texts3[2] = { "Mic1", "Mic2" };
 479         char **texts = NULL;
 480         int reg = kcontrol->private_value & 0xff;
 481         int shift = (kcontrol->private_value >> 8) & 0xff;
 482
 483         switch (reg) {
 484         case AC97_GENERAL_PURPOSE:
 485                 switch (shift) {
 486                 case 15: texts = texts1; break;
 487                 case 9: texts = texts2; break;
 488                 case 8: texts = texts3; break;
 489                 }
 490         }
 491         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 492         uinfo->count = 1;
 493         uinfo->value.enumerated.items = 2;
 494         if (uinfo->value.enumerated.item > 1)
 495                 uinfo->value.enumerated.item = 1;
 496         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 497         return 0;
 498 }
 499
 500 static int snd_ac97_get_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 501 {
 502         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 503         unsigned short val;
 504         int reg = kcontrol->private_value & 0xff;
 505         int shift = (kcontrol->private_value >> 8) & 0xff;
 506         int invert = (kcontrol->private_value >> 24) & 0xff;
 507
 508         val = (snd_ac97_read_cache(ac97, reg) >> shift) & 1;
 509         if (invert)
 510                 val ^= 1;
 511         ucontrol->value.enumerated.item[0] = val;
 512         return 0;
 513 }
 514
 515 static int snd_ac97_put_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 516 {
 517         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 518         unsigned short val;
 519         int reg = kcontrol->private_value & 0xff;
 520         int shift = (kcontrol->private_value >> 8) & 0xff;
 521         int invert = (kcontrol->private_value >> 24) & 0xff;
 522
 523         if (ucontrol->value.enumerated.item[0] > 1)
 524                 return -EINVAL;
 525         val = !!ucontrol->value.enumerated.item[0];
 526         if (invert)
 527                 val = !val;
 528         return snd_ac97_update_bits(ac97, reg, 1 << shift, val << shift);
 529 }
 530
 531 int snd_ac97_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 532 {
 533         int mask = (kcontrol->private_value >> 16) & 0xff;
 534
 535         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 536         uinfo->count = 1;
 537         uinfo->value.integer.min = 0;
 538         uinfo->value.integer.max = mask;
 539         return 0;
 540 }
 541
 542 int snd_ac97_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 543 {
 544         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 545         int reg = kcontrol->private_value & 0xff;
 546         int shift = (kcontrol->private_value >> 8) & 0xff;
 547         int mask = (kcontrol->private_value >> 16) & 0xff;
 548         int invert = (kcontrol->private_value >> 24) & 0xff;
 549
 550         ucontrol->value.integer.value[0] = (snd_ac97_read_cache(ac97, reg) >> shift) & mask;
 551         if (invert)
 552                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
 553         return 0;
 554 }
 555
 556 int snd_ac97_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 557 {
 558         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 559         int reg = kcontrol->private_value & 0xff;
 560         int shift = (kcontrol->private_value >> 8) & 0xff;
 561         int mask = (kcontrol->private_value >> 16) & 0xff;
 562         int invert = (kcontrol->private_value >> 24) & 0xff;
 563         unsigned short val;
 564
 565         val = (ucontrol->value.integer.value[0] & mask);
 566         if (invert)
 567                 val = mask - val;
 568         return snd_ac97_update_bits(ac97, reg, mask << shift, val << shift);
 569 }
 570
 571 #define AC97_DOUBLE(xname, reg, shift_left, shift_right, mask, invert) \
 572 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), .info = snd_ac97_info_double, \
 573   .get = snd_ac97_get_double, .put = snd_ac97_put_double, \
 574   .private_value = (reg) | ((shift_left) << 8) | ((shift_right) << 12) | ((mask) << 16) | ((invert) << 24) }
 575
 576 static int snd_ac97_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 577 {
 578         int mask = (kcontrol->private_value >> 16) & 0xff;
 579
 580         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 581         uinfo->count = 2;
 582         uinfo->value.integer.min = 0;
 583         uinfo->value.integer.max = mask;
 584         return 0;
 585 }
 586
 587 static int snd_ac97_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 588 {
 589         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 590         int reg = kcontrol->private_value & 0xff;
 591         int shift_left = (kcontrol->private_value >> 8) & 0x0f;
 592         int shift_right = (kcontrol->private_value >> 12) & 0x0f;
 593         int mask = (kcontrol->private_value >> 16) & 0xff;
 594         int invert = (kcontrol->private_value >> 24) & 0xff;
 595
 596         spin_lock(&ac97->reg_lock);
 597         ucontrol->value.integer.value[0] = (snd_ac97_read_cache(ac97, reg) >> shift_left) & mask;
 598         ucontrol->value.integer.value[1] = (snd_ac97_read_cache(ac97, reg) >> shift_right) & mask;
 599         spin_unlock(&ac97->reg_lock);
 600         if (invert) {
 601                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
 602                 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
 603         }
 604         return 0;
 605 }
 606
 607 static int snd_ac97_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 608 {
 609         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 610         int reg = kcontrol->private_value & 0xff;
 611         int shift_left = (kcontrol->private_value >> 8) & 0x0f;
 612         int shift_right = (kcontrol->private_value >> 12) & 0x0f;
 613         int mask = (kcontrol->private_value >> 16) & 0xff;
 614         int invert = (kcontrol->private_value >> 24) & 0xff;
 615         unsigned short val1, val2;
 616
 617         val1 = ucontrol->value.integer.value[0] & mask;
 618         val2 = ucontrol->value.integer.value[1] & mask;
 619         if (invert) {
 620                 val1 = mask - val1;
 621                 val2 = mask - val2;
 622         }
 623         return snd_ac97_update_bits(ac97, reg,
 624                                     (mask << shift_left) | (mask << shift_right),
 625                                     (val1 << shift_left) | (val2 << shift_right));
 626 }
 627
 628 static const snd_kcontrol_new_t snd_ac97_controls_master_mono[2] = {
 629 AC97_SINGLE("Master Mono Playback Switch", AC97_MASTER_MONO, 15, 1, 1),
 630 AC97_SINGLE("Master Mono Playback Volume", AC97_MASTER_MONO, 0, 31, 1)
 631 };
 632
 633 static const snd_kcontrol_new_t snd_ac97_controls_tone[2] = {
 634 AC97_SINGLE("Tone Control - Bass", AC97_MASTER_TONE, 8, 15, 1),
 635 AC97_SINGLE("Tone Control - Treble", AC97_MASTER_TONE, 0, 15, 1)
 636 };
 637
 638 static const snd_kcontrol_new_t snd_ac97_controls_pc_beep[2] = {
 639 AC97_SINGLE("PC Speaker Playback Switch", AC97_PC_BEEP, 15, 1, 1),
 640 AC97_SINGLE("PC Speaker Playback Volume", AC97_PC_BEEP, 1, 15, 1)
 641 };
 642
 643 static const snd_kcontrol_new_t snd_ac97_controls_phone[2] = {
 644 AC97_SINGLE("Phone Playback Switch", AC97_PHONE, 15, 1, 1),
 645 AC97_SINGLE("Phone Playback Volume", AC97_PHONE, 0, 15, 1)
 646 };
 647
 648 static const snd_kcontrol_new_t snd_ac97_controls_mic[3] = {
 649 AC97_SINGLE("Mic Playback Switch", AC97_MIC, 15, 1, 1),
 650 AC97_SINGLE("Mic Playback Volume", AC97_MIC, 0, 15, 1),
 651 AC97_SINGLE("Mic Boost (+20dB)", AC97_MIC, 6, 1, 0)
 652 };
 653
 654 static const snd_kcontrol_new_t snd_ac97_control_capture_src = {
 655         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 656         .name = "Capture Source",
 657         .info = snd_ac97_info_mux,
 658         .get = snd_ac97_get_mux,
 659         .put = snd_ac97_put_mux,
 660 };
 661
 662 static const snd_kcontrol_new_t snd_ac97_control_capture_vol =
 663 AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 15, 0);
 664
 665 static const snd_kcontrol_new_t snd_ac97_controls_mic_capture[2] = {
 666 AC97_SINGLE("Mic Capture Switch", AC97_REC_GAIN_MIC, 15, 1, 1),
 667 AC97_SINGLE("Mic Capture Volume", AC97_REC_GAIN_MIC, 0, 15, 0)
 668 };
 669
 670 typedef enum {
 671         AC97_GENERAL_PCM_OUT = 0,
 672         AC97_GENERAL_STEREO_ENHANCEMENT,
 673         AC97_GENERAL_3D,
 674         AC97_GENERAL_LOUDNESS,
 675         AC97_GENERAL_MONO,
 676         AC97_GENERAL_MIC,
 677         AC97_GENERAL_LOOPBACK
 678 } ac97_general_index_t;
 679
 680 static const snd_kcontrol_new_t snd_ac97_controls_general[7] = {
 681 AC97_ENUM_DOUBLE("PCM Out Path & Mute", AC97_GENERAL_PURPOSE, 15, 0),
 682 AC97_SINGLE("Simulated Stereo Enhancement", AC97_GENERAL_PURPOSE, 14, 1, 0),
 683 AC97_SINGLE("3D Control - Switch", AC97_GENERAL_PURPOSE, 13, 1, 0),
 684 AC97_SINGLE("Loudness (bass boost)", AC97_GENERAL_PURPOSE, 12, 1, 0),
 685 AC97_ENUM_DOUBLE("Mono Output Select", AC97_GENERAL_PURPOSE, 9, 0),
 686 AC97_ENUM_DOUBLE("Mic Select", AC97_GENERAL_PURPOSE, 8, 0),
 687 AC97_SINGLE("ADC/DAC Loopback", AC97_GENERAL_PURPOSE, 7, 1, 0)
 688 };
 689
 690 const snd_kcontrol_new_t snd_ac97_controls_3d[2] = {
 691 AC97_SINGLE("3D Control - Center", AC97_3D_CONTROL, 8, 15, 0),
 692 AC97_SINGLE("3D Control - Depth", AC97_3D_CONTROL, 0, 15, 0)
 693 };
 694
 695 static const snd_kcontrol_new_t snd_ac97_controls_center[2] = {
 696 AC97_SINGLE("Center Playback Switch", AC97_CENTER_LFE_MASTER, 7, 1, 1),
 697 AC97_SINGLE("Center Playback Volume", AC97_CENTER_LFE_MASTER, 0, 31, 1)
 698 };
 699
 700 static const snd_kcontrol_new_t snd_ac97_controls_lfe[2] = {
 701 AC97_SINGLE("LFE Playback Switch", AC97_CENTER_LFE_MASTER, 15, 1, 1),
 702 AC97_SINGLE("LFE Playback Volume", AC97_CENTER_LFE_MASTER, 8, 31, 1)
 703 };
 704
 705 static const snd_kcontrol_new_t snd_ac97_controls_surround[2] = {
 706 AC97_DOUBLE("Surround Playback Switch", AC97_SURROUND_MASTER, 15, 7, 1, 1),
 707 AC97_DOUBLE("Surround Playback Volume", AC97_SURROUND_MASTER, 8, 0, 31, 1),
 708 };
 709
 710 static const snd_kcontrol_new_t snd_ac97_control_eapd =
 711 AC97_SINGLE("External Amplifier", AC97_POWERDOWN, 15, 1, 1);
 712
 713 static int snd_ac97_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 714 {
 715         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 716         uinfo->count = 1;
 717         return 0;
 718 }
 719
 720 static int snd_ac97_spdif_cmask_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
 721 {
 722         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
 723                                            IEC958_AES0_NONAUDIO |
 724                                            IEC958_AES0_CON_EMPHASIS_5015 |
 725                                            IEC958_AES0_CON_NOT_COPYRIGHT;
 726         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
 727                                            IEC958_AES1_CON_ORIGINAL;
 728         ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
 729         return 0;
 730 }
 731
 732 static int snd_ac97_spdif_pmask_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
 733 {
 734         /* FIXME: AC'97 spec doesn't say which bits are used for what */
 735         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
 736                                            IEC958_AES0_NONAUDIO |
 737                                            IEC958_AES0_PRO_FS |
 738                                            IEC958_AES0_PRO_EMPHASIS_5015;
 739         return 0;
 740 }
 741
 742 static int snd_ac97_spdif_default_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
 743 {
 744         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 745
 746         spin_lock(&ac97->reg_lock);
 747         ucontrol->value.iec958.status[0] = ac97->spdif_status & 0xff;
 748         ucontrol->value.iec958.status[1] = (ac97->spdif_status >> 8) & 0xff;
 749         ucontrol->value.iec958.status[2] = (ac97->spdif_status >> 16) & 0xff;
 750         ucontrol->value.iec958.status[3] = (ac97->spdif_status >> 24) & 0xff;
 751         spin_unlock(&ac97->reg_lock);
 752         return 0;
 753 }
 754
 755 static int snd_ac97_spdif_default_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol)
 756 {
 757         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 758         unsigned int new = 0;
 759         unsigned short val = 0;
 760         int change;
 761
 762         spin_lock(&ac97->reg_lock);
 763         new = val = ucontrol->value.iec958.status[0] & (IEC958_AES0_PROFESSIONAL|IEC958_AES0_NONAUDIO);
 764         if (ucontrol->value.iec958.status[0] & IEC958_AES0_PROFESSIONAL) {
 765                 new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_PRO_FS|IEC958_AES0_PRO_EMPHASIS_5015);
 766                 switch (new & IEC958_AES0_PRO_FS) {
 767                 case IEC958_AES0_PRO_FS_44100: val |= 0<<12; break;
 768                 case IEC958_AES0_PRO_FS_48000: val |= 2<<12; break;
 769                 case IEC958_AES0_PRO_FS_32000: val |= 3<<12; break;
 770                 default:                       val |= 1<<12; break;
 771                 }
 772                 if ((new & IEC958_AES0_PRO_EMPHASIS) == IEC958_AES0_PRO_EMPHASIS_5015)
 773                         val |= 1<<3;
 774         } else {
 775                 new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT);
 776                 new |= ((ucontrol->value.iec958.status[1] & (IEC958_AES1_CON_CATEGORY|IEC958_AES1_CON_ORIGINAL)) << 8);
 777                 new |= ((ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) << 24);
 778                 if ((new & IEC958_AES0_CON_EMPHASIS) == IEC958_AES0_CON_EMPHASIS_5015)
 779                         val |= 1<<3;
 780                 if (!(new & IEC958_AES0_CON_NOT_COPYRIGHT))
 781                         val |= 1<<2;
 782                 val |= ((new >> 8) & 0xff) << 4;        // category + original
 783                 switch ((new >> 24) & 0xff) {
 784                 case IEC958_AES3_CON_FS_44100: val |= 0<<12; break;
 785                 case IEC958_AES3_CON_FS_48000: val |= 2<<12; break;
 786                 case IEC958_AES3_CON_FS_32000: val |= 3<<12; break;
 787                 default:                       val |= 1<<12; break;
 788                 }
 789         }
 790
 791         change = ac97->spdif_status != new;
 792         ac97->spdif_status = new;
 793         spin_unlock(&ac97->reg_lock);
 794
 795         if (ac97->flags & AC97_CS_SPDIF) {
 796                 int x = (val >> 12) & 0x03;
 797                 switch (x) {
 798                 case 0: x = 1; break;  // 44.1
 799                 case 2: x = 0; break;  // 48.0
 800                 default: x = 0; break; // illegal.
 801                 }
 802                 change |= snd_ac97_update_bits(ac97, AC97_CSR_SPDIF, 0x3fff, ((val & 0xcfff) | (x << 12)));
 803         } else if (ac97->flags & AC97_CX_SPDIF) {
 804                 int v;
 805                 v = new & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT) ? 0 : AC97_CXR_COPYRGT;
 806                 v |= new & IEC958_AES0_NONAUDIO ? AC97_CXR_SPDIF_AC3 : AC97_CXR_SPDIF_PCM;
 807                 change |= snd_ac97_update_bits(ac97, AC97_CXR_AUDIO_MISC,
 808                                                AC97_CXR_SPDIF_MASK | AC97_CXR_COPYRGT,
 809                                                v);
 810         } else {
 811                 unsigned short extst = snd_ac97_read_cache(ac97, AC97_EXTENDED_STATUS);
 812                 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); /* turn off */
 813
 814                 change |= snd_ac97_update_bits(ac97, AC97_SPDIF, 0x3fff, val);
 815                 if (extst & AC97_EA_SPDIF) {
 816                         snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
 817                 }
 818         }
 819
 820         return change;
 821 }
 822
 823 static int snd_ac97_put_spsa(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
 824 {
 825         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 826         int reg = kcontrol->private_value & 0xff;
 827         int shift = (kcontrol->private_value >> 8) & 0xff;
 828         int mask = (kcontrol->private_value >> 16) & 0xff;
 829         // int invert = (kcontrol->private_value >> 24) & 0xff;
 830         unsigned short value, old, new;
 831
 832         value = (ucontrol->value.integer.value[0] & mask);
 833
 834         mask <<= shift;
 835         value <<= shift;
 836         spin_lock(&ac97->reg_lock);
 837         old = snd_ac97_read_cache(ac97, reg);
 838         new = (old & ~mask) | value;
 839         spin_unlock(&ac97->reg_lock);
 840
 841         if (old != new) {
 842                 int change;
 843                 unsigned short extst = snd_ac97_read_cache(ac97, AC97_EXTENDED_STATUS);
 844                 snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); /* turn off */
 845                 change = snd_ac97_update_bits(ac97, reg, mask, value);
 846                 if (extst & AC97_EA_SPDIF)
 847                         snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
 848                 return change;
 849         }
 850         return 0;
 851 }
 852
 853 const snd_kcontrol_new_t snd_ac97_controls_spdif[5] = {
 854         {
 855                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
 856                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 857                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
 858                 .info = snd_ac97_spdif_mask_info,
 859                 .get = snd_ac97_spdif_cmask_get,
 860         },
 861         {
 862                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
 863                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 864                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
 865                 .info = snd_ac97_spdif_mask_info,
 866                 .get = snd_ac97_spdif_pmask_get,
 867         },
 868         {
 869                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 870                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 871                 .info = snd_ac97_spdif_mask_info,
 872                 .get = snd_ac97_spdif_default_get,
 873                 .put = snd_ac97_spdif_default_put,
 874         },
 875
 876         AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),AC97_EXTENDED_STATUS, 2, 1, 0),
 877         {
 878                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 879                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA",
 880                 .info = snd_ac97_info_single,
 881                 .get = snd_ac97_get_single,
 882                 .put = snd_ac97_put_spsa,
 883                 .private_value = AC97_SINGLE_VALUE(AC97_EXTENDED_STATUS, 4, 3, 0)
 884         },
 885 };
 886
 887 #define AD18XX_PCM_BITS(xname, codec, lshift, rshift, mask) \
 888 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_ad18xx_pcm_info_bits, \
 889   .get = snd_ac97_ad18xx_pcm_get_bits, .put = snd_ac97_ad18xx_pcm_put_bits, \
 890   .private_value = (codec) | ((lshift) << 8) | ((rshift) << 12) | ((mask) << 16) }
 891
 892 static int snd_ac97_ad18xx_pcm_info_bits(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 893 {
 894         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 895         int mask = (kcontrol->private_value >> 16) & 0x0f;
 896         int lshift = (kcontrol->private_value >> 8) & 0x0f;
 897         int rshift = (kcontrol->private_value >> 12) & 0x0f;
 898
 899         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 900         if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
 901                 uinfo->count = 2;
 902         else
 903                 uinfo->count = 1;
 904         uinfo->value.integer.min = 0;
 905         uinfo->value.integer.max = mask;
 906         return 0;
 907 }
 908
 909 static int snd_ac97_ad18xx_pcm_get_bits(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 910 {
 911         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 912         int codec = kcontrol->private_value & 3;
 913         int lshift = (kcontrol->private_value >> 8) & 0x0f;
 914         int rshift = (kcontrol->private_value >> 12) & 0x0f;
 915         int mask = (kcontrol->private_value >> 16) & 0xff;
 916
 917         ucontrol->value.integer.value[0] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> lshift) & mask);
 918         if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
 919                 ucontrol->value.integer.value[1] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> rshift) & mask);
 920         return 0;
 921 }
 922
 923 static int snd_ac97_ad18xx_pcm_put_bits(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 924 {
 925         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 926         int codec = kcontrol->private_value & 3;
 927         int lshift = (kcontrol->private_value >> 8) & 0x0f;
 928         int rshift = (kcontrol->private_value >> 12) & 0x0f;
 929         int mask = (kcontrol->private_value >> 16) & 0xff;
 930         unsigned short val, valmask;
 931
 932         val = (mask - (ucontrol->value.integer.value[0] & mask)) << lshift;
 933         valmask = mask << lshift;
 934         if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES)) {
 935                 val |= (mask - (ucontrol->value.integer.value[1] & mask)) << rshift;
 936                 valmask |= mask << rshift;
 937         }
 938         return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, valmask, val);
 939 }
 940
 941 #define AD18XX_PCM_VOLUME(xname, codec) \
 942 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_ad18xx_pcm_info_volume, \
 943   .get = snd_ac97_ad18xx_pcm_get_volume, .put = snd_ac97_ad18xx_pcm_put_volume, \
 944   .private_value = codec }
 945
 946 static int snd_ac97_ad18xx_pcm_info_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 947 {
 948         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 949         uinfo->count = 2;
 950         uinfo->value.integer.min = 0;
 951         uinfo->value.integer.max = 31;
 952         return 0;
 953 }
 954
 955 static int snd_ac97_ad18xx_pcm_get_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 956 {
 957         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 958         int codec = kcontrol->private_value & 3;
 959
 960         spin_lock(&ac97->reg_lock);
 961         ucontrol->value.integer.value[0] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 0) & 31);
 962         ucontrol->value.integer.value[1] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 8) & 31);
 963         spin_unlock(&ac97->reg_lock);
 964         return 0;
 965 }
 966
 967 static int snd_ac97_ad18xx_pcm_put_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 968 {
 969         ac97_t *ac97 = snd_kcontrol_chip(kcontrol);
 970         int codec = kcontrol->private_value & 3;
 971         unsigned short val1, val2;
 972
 973         val1 = 31 - (ucontrol->value.integer.value[0] & 31);
 974         val2 = 31 - (ucontrol->value.integer.value[1] & 31);
 975         return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, 0x1f1f, (val1 << 8) | val2);
 976 }
 977
 978 static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_pcm[2] = {
 979 AD18XX_PCM_BITS("PCM Playback Switch", 0, 15, 7, 1),
 980 AD18XX_PCM_VOLUME("PCM Playback Volume", 0)
 981 };
 982
 983 static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_surround[2] = {
 984 AD18XX_PCM_BITS("Surround Playback Switch", 1, 15, 7, 1),
 985 AD18XX_PCM_VOLUME("Surround Playback Volume", 1)
 986 };
 987
 988 static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_center[2] = {
 989 AD18XX_PCM_BITS("Center Playback Switch", 2, 15, 15, 1),
 990 AD18XX_PCM_BITS("Center Playback Volume", 2, 8, 8, 31)
 991 };
 992
 993 static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_lfe[2] = {
 994 AD18XX_PCM_BITS("LFE Playback Switch", 2, 7, 7, 1),
 995 AD18XX_PCM_BITS("LFE Playback Volume", 2, 0, 0, 31)
 996 };
 997
 998 /*
 999  *
1000  */
1001
1002 static void snd_ac97_powerdown(ac97_t *ac97);
1003
1004 static int snd_ac97_bus_free(ac97_bus_t *bus)
1005 {
1006         if (bus) {
1007                 snd_ac97_bus_proc_done(bus);
1008                 if (bus->pcms)
1009                         kfree(bus->pcms);
1010                 if (bus->private_free)
1011                         bus->private_free(bus);
1012                 snd_magic_kfree(bus);
1013         }
1014         return 0;
1015 }
1016
1017 static int snd_ac97_bus_dev_free(snd_device_t *device)
1018 {
1019         ac97_bus_t *bus = snd_magic_cast(ac97_bus_t, device->device_data, return -ENXIO);
1020         return snd_ac97_bus_free(bus);
1021 }
1022
1023 static int snd_ac97_free(ac97_t *ac97)
1024 {
1025         if (ac97) {
1026                 snd_ac97_proc_done(ac97);
1027                 if (ac97->bus)
1028                         ac97->bus->codec[ac97->num] = NULL;
1029                 if (ac97->private_free)
1030                         ac97->private_free(ac97);
1031                 snd_magic_kfree(ac97);
1032         }
1033         return 0;
1034 }
1035
1036 static int snd_ac97_dev_free(snd_device_t *device)
1037 {
1038         ac97_t *ac97 = snd_magic_cast(ac97_t, device->device_data, return -ENXIO);
1039         snd_ac97_powerdown(ac97); /* for avoiding click noises during shut down */
1040         return snd_ac97_free(ac97);
1041 }
1042
1043 static int snd_ac97_try_volume_mix(ac97_t * ac97, int reg)
1044 {
1045         unsigned short val, mask = 0x8000;
1046
1047         if (! snd_ac97_valid_reg(ac97, reg))
1048                 return 0;
1049
1050         switch (reg) {
1051         case AC97_MASTER_TONE:
1052                 return ac97->caps & 0x04 ? 1 : 0;
1053         case AC97_HEADPHONE:
1054                 return ac97->caps & 0x10 ? 1 : 0;
1055         case AC97_REC_GAIN_MIC:
1056                 return ac97->caps & 0x01 ? 1 : 0;
1057         case AC97_3D_CONTROL:
1058                 if (ac97->caps & 0x7c00) {
1059                         val = snd_ac97_read(ac97, reg);
1060                         /* if nonzero - fixed and we can't set it */
1061                         return val == 0;
1062                 }
1063                 return 0;
1064         case AC97_CENTER_LFE_MASTER:    /* center */
1065                 if ((ac97->ext_id & AC97_EI_CDAC) == 0)
1066                         return 0;
1067                 break;
1068         case AC97_CENTER_LFE_MASTER+1:  /* lfe */
1069                 if ((ac97->ext_id & AC97_EI_LDAC) == 0)
1070                         return 0;
1071                 reg = AC97_CENTER_LFE_MASTER;
1072                 mask = 0x0080;
1073                 break;
1074         case AC97_SURROUND_MASTER:
1075                 if ((ac97->ext_id & AC97_EI_SDAC) == 0)
1076                         return 0;
1077                 break;
1078         }
1079
1080         if (ac97->limited_regs && test_bit(reg, ac97->reg_accessed))
1081                 return 1; /* allow without check */
1082
1083         val = snd_ac97_read(ac97, reg);
1084         if (!(val & mask)) {
1085                 /* nothing seems to be here - mute flag is not set */
1086                 /* try another test */
1087                 snd_ac97_write_cache(ac97, reg, val | mask);
1088                 val = snd_ac97_read(ac97, reg);
1089                 if (!(val & mask))
1090                         return 0;       /* nothing here */
1091         }
1092         return 1;               /* success, useable */
1093 }
1094
1095 int snd_ac97_try_bit(ac97_t * ac97, int reg, int bit)
1096 {
1097         unsigned short mask, val, orig, res;
1098
1099         mask = 1 << bit;
1100         orig = snd_ac97_read(ac97, reg);
1101         val = orig ^ mask;
1102         snd_ac97_write(ac97, reg, val);
1103         res = snd_ac97_read(ac97, reg);
1104         snd_ac97_write_cache(ac97, reg, orig);
1105         return res == val;
1106 }
1107
1108 static void snd_ac97_change_volume_params1(ac97_t * ac97, int reg, unsigned char *max)
1109 {
1110         unsigned short val, val1;
1111
1112         *max = 63;
1113         val = 0x8000 | 0x0020;
1114         snd_ac97_write(ac97, reg, val);
1115         val1 = snd_ac97_read(ac97, reg);
1116         if (val != val1) {
1117                 *max = 31;
1118         }
1119         /* reset volume to zero */
1120         snd_ac97_write_cache(ac97, reg, 0x8000);
1121 }
1122
1123 static void snd_ac97_change_volume_params2(ac97_t * ac97, int reg, int shift, unsigned char *max)
1124 {
1125         unsigned short val, val1;
1126
1127         *max = 63;
1128         val = 0x8080 | (0x20 << shift);
1129         snd_ac97_write(ac97, reg, val);
1130         val1 = snd_ac97_read(ac97, reg);
1131         if (val != val1) {
1132                 *max = 31;
1133         }
1134         /* reset volume to zero */
1135         snd_ac97_write_cache(ac97, reg, 0x8080);
1136 }
1137
1138 static void snd_ac97_change_volume_params3(ac97_t * ac97, int reg, unsigned char *max)
1139 {
1140         unsigned short val, val1;
1141
1142         *max = 31;
1143         val = 0x8000 | 0x0010;
1144         snd_ac97_write(ac97, reg, val);
1145         val1 = snd_ac97_read(ac97, reg);
1146         if (val != val1) {
1147                 *max = 15;
1148         }
1149         /* reset volume to zero */
1150         snd_ac97_write_cache(ac97, reg, 0x8000);
1151 }
1152
1153 static inline int printable(unsigned int x)
1154 {
1155         x &= 0xff;
1156         if (x < ' ' || x >= 0x71) {
1157                 if (x <= 0x89)
1158                         return x - 0x71 + 'A';
1159                 return '?';
1160         }
1161         return x;
1162 }
1163
1164 snd_kcontrol_t *snd_ac97_cnew(const snd_kcontrol_new_t *_template, ac97_t * ac97)
1165 {
1166         snd_kcontrol_new_t template;
1167         memcpy(&template, _template, sizeof(template));
1168         snd_runtime_check(!template.index, return NULL);
1169         template.index = ac97->num;
1170         return snd_ctl_new1(&template, ac97);
1171 }
1172
1173 /*
1174  * create mute switch(es) for normal stereo controls
1175  */
1176 static int snd_ac97_cmute_new(snd_card_t *card, char *name, int reg, ac97_t *ac97)
1177 {
1178         snd_kcontrol_t *kctl;
1179         int stereo = 0;
1180
1181         if (ac97->flags & AC97_STEREO_MUTES) {
1182                 /* check whether both mute bits work */
1183                 unsigned short val, val1;
1184                 val = snd_ac97_read(ac97, reg);
1185                 val1 = val | 0x8080;
1186                 snd_ac97_write(ac97, reg, val1);
1187                 if (val1 == snd_ac97_read(ac97, reg))
1188                         stereo = 1;
1189                 snd_ac97_write(ac97, reg, val);
1190         }
1191         if (stereo) {
1192                 snd_kcontrol_new_t tmp = AC97_DOUBLE(name, reg, 15, 7, 1, 1);
1193                 tmp.index = ac97->num;
1194                 kctl = snd_ctl_new1(&tmp, ac97);
1195         } else {
1196                 snd_kcontrol_new_t tmp = AC97_SINGLE(name, reg, 15, 1, 1);
1197                 tmp.index = ac97->num;
1198                 kctl = snd_ctl_new1(&tmp, ac97);
1199         }
1200         return snd_ctl_add(card, kctl);
1201 }
1202
1203 /*
1204  * create volumes for normal stereo controls
1205  */
1206 static int snd_ac97_cvol_new(snd_card_t *card, char *name, int reg, unsigned int max, ac97_t *ac97)
1207 {
1208         int err;
1209         snd_kcontrol_new_t tmp = AC97_DOUBLE(name, reg, 8, 0, (unsigned int)max, 1);
1210         tmp.index = ac97->num;
1211         if ((err = snd_ctl_add(card, snd_ctl_new1(&tmp, ac97))) < 0)
1212                 return err;
1213         snd_ac97_write_cache(ac97, reg,
1214                              ((ac97->flags & AC97_STEREO_MUTES) ? 0x8080 : 0x8000) |
1215                              (unsigned short)max | ((unsigned short)max << 8));
1216         return 0;
1217 }
1218
1219 /*
1220  * create mute-switch and volumes for normal stereo controls
1221  */
1222 static int snd_ac97_cmix_new(snd_card_t *card, const char *pfx, int reg, int check_res, ac97_t *ac97)
1223 {
1224         int err;
1225         char name[44];
1226         unsigned char max;
1227
1228         sprintf(name, "%s Switch", pfx);
1229         if ((err = snd_ac97_cmute_new(card, name, reg, ac97)) < 0)
1230                 return err;
1231         sprintf(name, "%s Volume", pfx);
1232         if (check_res)
1233                 snd_ac97_change_volume_params1(ac97, reg, &max);
1234         else
1235                 max = 31; /* 5bit */
1236         if ((err = snd_ac97_cvol_new(card, name, reg, max, ac97)) < 0)
1237                 return err;
1238         return 0;
1239 }
1240
1241
1242 static int snd_ac97_mixer_build(ac97_t * ac97)
1243 {
1244         snd_card_t *card = ac97->bus->card;
1245         snd_kcontrol_t *kctl;
1246         int err;
1247         unsigned int idx;
1248         unsigned char max;
1249
1250         /* build master controls */
1251         /* AD claims to remove this control from AD1887, although spec v2.2 does not allow this */
1252         if (snd_ac97_try_volume_mix(ac97, AC97_MASTER)) {
1253                 if ((err = snd_ac97_cmix_new(card, "Master Playback", AC97_MASTER, 1, ac97)) < 0)
1254                         return err;
1255         }
1256
1257         ac97->regs[AC97_CENTER_LFE_MASTER] = 0x8080;
1258
1259         /* build center controls */
1260         if (snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER)) {
1261                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_center[0], ac97))) < 0)
1262                         return err;
1263                 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_center[1], ac97))) < 0)
1264                         return err;
1265                 snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 0, &max);
1266                 kctl->private_value &= ~(0xff << 16);
1267                 kctl->private_value |= (int)max << 16;
1268                 snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max);
1269         }
1270
1271         /* build LFE controls */
1272         if (snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1)) {
1273                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_lfe[0], ac97))) < 0)
1274                         return err;
1275                 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_lfe[1], ac97))) < 0)
1276                         return err;
1277                 snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 8, &max);
1278                 kctl->private_value &= ~(0xff << 16);
1279                 kctl->private_value |= (int)max << 16;
1280                 snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max << 8);
1281         }
1282
1283         /* build surround controls */
1284         if (snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER)) {
1285                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_surround[0], ac97))) < 0)
1286                         return err;
1287                 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_surround[1], ac97))) < 0)
1288                         return err;
1289                 snd_ac97_change_volume_params2(ac97, AC97_SURROUND_MASTER, 0, &max);
1290                 kctl->private_value &= ~(0xff << 16);
1291                 kctl->private_value |= (int)max << 16;
1292                 snd_ac97_write_cache(ac97, AC97_SURROUND_MASTER, 0x8080 | max | (max << 8));
1293         }
1294
1295         /* build headphone controls */
1296         if (snd_ac97_try_volume_mix(ac97, AC97_HEADPHONE) || ac97->id == AC97_ID_STAC9708) {
1297                 const char *name = ac97->id == AC97_ID_STAC9708 ?
1298                         "Sigmatel Surround Playback" :
1299                         "Headphone Playback";
1300                 if ((err = snd_ac97_cmix_new(card, name, AC97_HEADPHONE, 1, ac97)) < 0)
1301                         return err;
1302         }
1303
1304         /* build master mono controls */
1305         if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_MONO)) {
1306                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_master_mono[0], ac97))) < 0)
1307                         return err;
1308                 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_master_mono[1], ac97))) < 0)
1309                         return err;
1310                 snd_ac97_change_volume_params1(ac97, AC97_MASTER_MONO, &max);
1311                 kctl->private_value &= ~(0xff << 16);
1312                 kctl->private_value |= (int)max << 16;
1313                 snd_ac97_write_cache(ac97, AC97_MASTER_MONO, 0x8000 | max);
1314         }
1315
1316         /* build master tone controls */
1317         if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_TONE)) {
1318                 for (idx = 0; idx < 2; idx++) {
1319                         if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_tone[idx], ac97))) < 0)
1320                                 return err;
1321                         if (ac97->id == AC97_ID_YMF753) {
1322                                 kctl->private_value &= ~(0xff << 16);
1323                                 kctl->private_value |= 7 << 16;
1324                         }
1325                 }
1326                 snd_ac97_write_cache(ac97, AC97_MASTER_TONE, 0x0f0f);
1327         }
1328
1329         /* build PC Speaker controls */
1330         if ((ac97->flags & AC97_HAS_PC_BEEP) ||
1331             snd_ac97_try_volume_mix(ac97, AC97_PC_BEEP)) {
1332                 for (idx = 0; idx < 2; idx++)
1333                         if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_pc_beep[idx], ac97))) < 0)
1334                                 return err;
1335                 snd_ac97_write_cache(ac97, AC97_PC_BEEP, 0x801e);
1336         }
1337
1338         /* build Phone controls */
1339         if (snd_ac97_try_volume_mix(ac97, AC97_PHONE)) {
1340                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_phone[0], ac97))) < 0)
1341                         return err;
1342                 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_phone[1], ac97))) < 0)
1343                         return err;
1344                 snd_ac97_change_volume_params3(ac97, AC97_PHONE, &max);
1345                 kctl->private_value &= ~(0xff << 16);
1346                 kctl->private_value |= (int)max << 16;
1347                 snd_ac97_write_cache(ac97, AC97_PHONE, 0x8000 | max);
1348         }
1349
1350         /* build MIC controls */
1351         snd_ac97_change_volume_params3(ac97, AC97_MIC, &max);
1352         for (idx = 0; idx < 3; idx++) {
1353                 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_mic[idx], ac97))) < 0)
1354                         return err;
1355                 if (idx == 1) {         // volume
1356                         kctl->private_value &= ~(0xff << 16);
1357                         kctl->private_value |= (int)max << 16;
1358                 }
1359         }
1360         snd_ac97_write_cache(ac97, AC97_MIC, 0x8000 | max);
1361
1362         /* build Line controls */
1363         if ((err = snd_ac97_cmix_new(card, "Line Playback", AC97_LINE, 0, ac97)) < 0)
1364                 return err;
1365
1366         /* build CD controls */
1367         if ((err = snd_ac97_cmix_new(card, "CD Playback", AC97_CD, 0, ac97)) < 0)
1368                 return err;
1369
1370         /* build Video controls */
1371         if (snd_ac97_try_volume_mix(ac97, AC97_VIDEO)) {
1372                 if ((err = snd_ac97_cmix_new(card, "Video Playback", AC97_VIDEO, 0, ac97)) < 0)
1373                         return err;
1374         }
1375
1376         /* build Aux controls */
1377         if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
1378                 if ((err = snd_ac97_cmix_new(card, "Aux Playback", AC97_AUX, 0, ac97)) < 0)
1379                         return err;
1380         }
1381
1382         /* build PCM controls */
1383         if (ac97->flags & AC97_AD_MULTI) {
1384                 unsigned short init_val;
1385                 if (ac97->flags & AC97_STEREO_MUTES)
1386                         init_val = 0x9f9f;
1387                 else
1388                         init_val = 0x9f1f;
1389                 for (idx = 0; idx < 2; idx++)
1390                         if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_pcm[idx], ac97))) < 0)
1391                                 return err;
1392                 ac97->spec.ad18xx.pcmreg[0] = init_val;
1393                 if (ac97->scaps & AC97_SCAP_SURROUND_DAC) {
1394                         for (idx = 0; idx < 2; idx++)
1395                                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_surround[idx], ac97))) < 0)
1396                                         return err;
1397                         ac97->spec.ad18xx.pcmreg[1] = init_val;
1398                 }
1399                 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) {
1400                         for (idx = 0; idx < 2; idx++)
1401                                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_center[idx], ac97))) < 0)
1402                                         return err;
1403                         for (idx = 0; idx < 2; idx++)
1404                                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_lfe[idx], ac97))) < 0)
1405                                         return err;
1406                         ac97->spec.ad18xx.pcmreg[2] = init_val;
1407                 }
1408                 snd_ac97_write_cache(ac97, AC97_PCM, init_val);
1409         } else {
1410                 if ((err = snd_ac97_cmute_new(card, "PCM Playback Switch", AC97_PCM, ac97)) < 0)
1411                         return err;
1412                 /* FIXME: C-Media chips have no PCM volume!! */
1413                 if (/*ac97->id == 0x434d4941 ||*/
1414                     ac97->id == 0x434d4942 ||
1415                     ac97->id == 0x434d4961)
1416                         snd_ac97_write_cache(ac97, AC97_PCM, 0x9f1f);
1417                 else {
1418                         if ((err = snd_ac97_cvol_new(card, "PCM Playback Volume", AC97_PCM, 31, ac97)) < 0)
1419                                 return err;
1420                 }
1421         }
1422
1423         /* build Capture controls */
1424         if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_src, ac97))) < 0)
1425                 return err;
1426         if ((err = snd_ac97_cmute_new(card, "Capture Switch", AC97_REC_GAIN, ac97)) < 0)
1427                 return err;
1428         if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_vol, ac97))) < 0)
1429                 return err;
1430         snd_ac97_write_cache(ac97, AC97_REC_SEL, 0x0000);
1431         snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x0000);
1432
1433         /* build MIC Capture controls */
1434         if (snd_ac97_try_volume_mix(ac97, AC97_REC_GAIN_MIC)) {
1435                 for (idx = 0; idx < 2; idx++)
1436                         if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_capture[idx], ac97))) < 0)
1437                                 return err;
1438                 snd_ac97_write_cache(ac97, AC97_REC_GAIN_MIC, 0x0000);
1439         }
1440
1441         /* build PCM out path & mute control */
1442         if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 15)) {
1443                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_PCM_OUT], ac97))) < 0)
1444                         return err;
1445         }
1446
1447         /* build Simulated Stereo Enhancement control */
1448         if (ac97->caps & 0x0008) {
1449                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_STEREO_ENHANCEMENT], ac97))) < 0)
1450                         return err;
1451         }
1452
1453         /* build 3D Stereo Enhancement control */
1454         if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 13)) {
1455                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_3D], ac97))) < 0)
1456                         return err;
1457         }
1458
1459         /* build Loudness control */
1460         if (ac97->caps & 0x0020) {
1461                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOUDNESS], ac97))) < 0)
1462                         return err;
1463         }
1464
1465         /* build Mono output select control */
1466         if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 9)) {
1467                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MONO], ac97))) < 0)
1468                         return err;
1469         }
1470
1471         /* build Mic select control */
1472         if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 8)) {
1473                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MIC], ac97))) < 0)
1474                         return err;
1475         }
1476
1477         /* build ADC/DAC loopback control */
1478         if (enable_loopback && snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 7)) {
1479                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOOPBACK], ac97))) < 0)
1480                         return err;
1481         }
1482
1483         snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0x0000);
1484
1485         /* build 3D controls */
1486         if (ac97->build_ops && ac97->build_ops->build_3d) {
1487                 ac97->build_ops->build_3d(ac97);
1488         } else {
1489                 if (snd_ac97_try_volume_mix(ac97, AC97_3D_CONTROL)) {
1490                         unsigned short val;
1491                         val = 0x0707;
1492                         snd_ac97_write(ac97, AC97_3D_CONTROL, val);
1493                         val = snd_ac97_read(ac97, AC97_3D_CONTROL);
1494                         val = val == 0x0606;
1495                         if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
1496                                 return err;
1497                         if (val)
1498                                 kctl->private_value = AC97_3D_CONTROL | (9 << 8) | (7 << 16);
1499                         if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[1], ac97))) < 0)
1500                                 return err;
1501                         if (val)
1502                                 kctl->private_value = AC97_3D_CONTROL | (1 << 8) | (7 << 16);
1503                         snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
1504                 }
1505         }
1506
1507         /* build S/PDIF controls */
1508         if (ac97->ext_id & AC97_EI_SPDIF) {
1509                 if (ac97->build_ops && ac97->build_ops->build_spdif) {
1510                         if ((err = ac97->build_ops->build_spdif(ac97)) < 0)
1511                                 return err;
1512                 } else {
1513                         for (idx = 0; idx < 5; idx++)
1514                                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_spdif[idx], ac97))) < 0)
1515                                         return err;
1516                         if (ac97->build_ops && ac97->build_ops->build_post_spdif) {
1517                                 if ((err = ac97->build_ops->build_post_spdif(ac97)) < 0)
1518                                         return err;
1519                         }
1520                         /* set default PCM S/PDIF params */
1521                         /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
1522                         snd_ac97_write_cache(ac97, AC97_SPDIF, 0x2a20);
1523                 }
1524                 ac97->spdif_status = SNDRV_PCM_DEFAULT_CON_SPDIF;
1525         }
1526
1527         /* build chip specific controls */
1528         if (ac97->build_ops && ac97->build_ops->build_specific)
1529                 if ((err = ac97->build_ops->build_specific(ac97)) < 0)
1530                         return err;
1531
1532         if (snd_ac97_try_bit(ac97, AC97_POWERDOWN, 15)) {
1533                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_eapd, ac97))) < 0)
1534                         return err;
1535         }
1536
1537         return 0;
1538 }
1539
1540 static int snd_ac97_modem_build(snd_card_t * card, ac97_t * ac97)
1541 {
1542         /* TODO */
1543         //printk("AC97_GPIO_CFG = %x\n",snd_ac97_read(ac97,AC97_GPIO_CFG));
1544         snd_ac97_write(ac97, AC97_GPIO_CFG, 0xffff & ~(AC97_GPIO_LINE1_OH));
1545         snd_ac97_write(ac97, AC97_GPIO_POLARITY, 0xffff & ~(AC97_GPIO_LINE1_OH));
1546         snd_ac97_write(ac97, AC97_GPIO_STICKY, 0xffff);
1547         snd_ac97_write(ac97, AC97_GPIO_WAKEUP, 0x0);
1548         snd_ac97_write(ac97, AC97_MISC_AFE, 0x0);
1549         return 0;
1550 }
1551
1552 static int snd_ac97_test_rate(ac97_t *ac97, int reg, int shadow_reg, int rate)
1553 {
1554         unsigned short val;
1555         unsigned int tmp;
1556
1557         tmp = ((unsigned int)rate * ac97->bus->clock) / 48000;
1558         snd_ac97_write_cache(ac97, reg, tmp & 0xffff);
1559         if (shadow_reg)
1560                 snd_ac97_write_cache(ac97, shadow_reg, tmp & 0xffff);
1561         val = snd_ac97_read(ac97, reg);
1562         return val == (tmp & 0xffff);
1563 }
1564
1565 static void snd_ac97_determine_rates(ac97_t *ac97, int reg, int shadow_reg, unsigned int *r_result)
1566 {
1567         unsigned int result = 0;
1568
1569         /* test a non-standard rate */
1570         if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11000))
1571                 result |= SNDRV_PCM_RATE_CONTINUOUS;
1572         /* let's try to obtain standard rates */
1573         if (snd_ac97_test_rate(ac97, reg, shadow_reg, 8000))
1574                 result |= SNDRV_PCM_RATE_8000;
1575         if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11025))
1576                 result |= SNDRV_PCM_RATE_11025;
1577         if (snd_ac97_test_rate(ac97, reg, shadow_reg, 16000))
1578                 result |= SNDRV_PCM_RATE_16000;
1579         if (snd_ac97_test_rate(ac97, reg, shadow_reg, 22050))
1580                 result |= SNDRV_PCM_RATE_22050;
1581         if (snd_ac97_test_rate(ac97, reg, shadow_reg, 32000))
1582                 result |= SNDRV_PCM_RATE_32000;
1583         if (snd_ac97_test_rate(ac97, reg, shadow_reg, 44100))
1584                 result |= SNDRV_PCM_RATE_44100;
1585         if (snd_ac97_test_rate(ac97, reg, shadow_reg, 48000))
1586                 result |= SNDRV_PCM_RATE_48000;
1587         *r_result = result;
1588 }
1589
1590 /* check AC97_SPDIF register to accept which sample rates */
1591 static unsigned int snd_ac97_determine_spdif_rates(ac97_t *ac97)
1592 {
1593         unsigned int result = 0;
1594         int i;
1595         static unsigned short ctl_bits[] = {
1596                 AC97_SC_SPSR_44K, AC97_SC_SPSR_32K, AC97_SC_SPSR_48K
1597         };
1598         static unsigned int rate_bits[] = {
1599                 SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_32000, SNDRV_PCM_RATE_48000
1600         };
1601
1602         for (i = 0; i < (int)ARRAY_SIZE(ctl_bits); i++) {
1603                 snd_ac97_update_bits(ac97, AC97_SPDIF, AC97_SC_SPSR_MASK, ctl_bits[i]);
1604                 if ((snd_ac97_read(ac97, AC97_SPDIF) & AC97_SC_SPSR_MASK) == ctl_bits[i])
1605                         result |= rate_bits[i];
1606         }
1607         return result;
1608 }
1609
1610 void snd_ac97_get_name(ac97_t *ac97, unsigned int id, char *name, int modem)
1611 {
1612         const ac97_codec_id_t *pid;
1613
1614         sprintf(name, "0x%x %c%c%c", id,
1615                 printable(id >> 24),
1616                 printable(id >> 16),
1617                 printable(id >> 8));
1618         for (pid = snd_ac97_codec_id_vendors; pid->id; pid++)
1619                 if (pid->id == (id & pid->mask)) {
1620                         strcpy(name, pid->name);
1621                         if (ac97) {
1622                                 if (!modem && pid->patch)
1623                                         pid->patch(ac97);
1624                                 else if (modem && pid->mpatch)
1625                                         pid->mpatch(ac97);
1626                         }
1627                         goto __vendor_ok;
1628                 }
1629         return;
1630
1631       __vendor_ok:
1632         for (pid = snd_ac97_codec_ids; pid->id; pid++)
1633                 if (pid->id == (id & pid->mask)) {
1634                         strcat(name, " ");
1635                         strcat(name, pid->name);
1636                         if (pid->mask != 0xffffffff)
1637                                 sprintf(name + strlen(name), " rev %d", id & ~pid->mask);
1638                         if (ac97) {
1639                                 if (!modem && pid->patch)
1640                                         pid->patch(ac97);
1641                                 else if (modem && pid->mpatch)
1642                                         pid->mpatch(ac97);
1643                         }
1644                         return;
1645                 }
1646         sprintf(name + strlen(name), " id %x", id & 0xff);
1647 }
1648
1649
1650 /* wait for a while until registers are accessible after RESET
1651  * return 0 if ok, negative not ready
1652  */
1653 static int ac97_reset_wait(ac97_t *ac97, int timeout, int with_modem)
1654 {
1655         unsigned long end_time;
1656         end_time = jiffies + timeout;
1657         do {
1658                 unsigned short ext_mid;
1659
1660                 /* use preliminary reads to settle the communication */
1661                 snd_ac97_read(ac97, AC97_RESET);
1662                 snd_ac97_read(ac97, AC97_VENDOR_ID1);
1663                 snd_ac97_read(ac97, AC97_VENDOR_ID2);
1664                 /* modem? */
1665                 if (with_modem) {
1666                         ext_mid = snd_ac97_read(ac97, AC97_EXTENDED_MID);
1667                         if (ext_mid != 0xffff && (ext_mid & 1) != 0)
1668                                 return 0;
1669                 }
1670                 /* because the PCM or MASTER volume registers can be modified,
1671                  * the REC_GAIN register is used for tests
1672                  */
1673                 /* test if we can write to the record gain volume register */
1674                 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a05);
1675                 if (snd_ac97_read(ac97, AC97_REC_GAIN) == 0x8a05)
1676                         return 0;
1677                 set_current_state(TASK_UNINTERRUPTIBLE);
1678                 schedule_timeout(HZ/100);
1679         } while (time_after_eq(end_time, jiffies));
1680         return -ENODEV;
1681 }
1682
1683 /**
1684  * snd_ac97_bus - create an AC97 bus component
1685  * @card: the card instance
1686  * @_bus: the template of AC97 bus, callbacks and
1687  *         the private data.
1688  * @rbus: the pointer to store the new AC97 bus instance.
1689  *
1690  * Creates an AC97 bus component.  An ac97_bus_t instance is newly
1691  * allocated and initialized from the template (_bus).
1692  *
1693  * The template must include the valid callbacks (at least read and
1694  * write), the bus number (num), and the private data (private_data).
1695  * The other callbacks, wait and reset, are not mandatory.
1696  *
1697  * The clock is set to 48000.  If another clock is needed, set
1698  * bus->clock manually.
1699  *
1700  * The AC97 bus instance is registered as a low-level device, so you don't
1701  * have to release it manually.
1702  *
1703  * Returns zero if successful, or a negative error code on failure.
1704  */
1705 int snd_ac97_bus(snd_card_t * card, ac97_bus_t * _bus, ac97_bus_t ** rbus)
1706 {
1707         int err;
1708         ac97_bus_t *bus;
1709         static snd_device_ops_t ops = {
1710                 .dev_free =     snd_ac97_bus_dev_free,
1711         };
1712
1713         snd_assert(card != NULL, return -EINVAL);
1714         snd_assert(_bus != NULL && rbus != NULL, return -EINVAL);
1715         bus = snd_magic_kmalloc(ac97_bus_t, 0, GFP_KERNEL);
1716         if (bus == NULL)
1717                 return -ENOMEM;
1718         *bus = *_bus;
1719         bus->card = card;
1720         if (bus->clock == 0)
1721                 bus->clock = 48000;
1722         spin_lock_init(&bus->bus_lock);
1723         snd_ac97_bus_proc_init(bus);
1724         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, bus, &ops)) < 0) {
1725                 snd_ac97_bus_free(bus);
1726                 return err;
1727         }
1728         *rbus = bus;
1729         return 0;
1730 }
1731
1732 /**
1733  * snd_ac97_mixer - create an Codec97 component
1734  * @bus: the AC97 bus which codec is attached to
1735  * @_ac97: the template of ac97, including index, callbacks and
1736  *         the private data.
1737  * @rac97: the pointer to store the new ac97 instance.
1738  *
1739  * Creates an Codec97 component.  An ac97_t instance is newly
1740  * allocated and initialized from the template (_ac97).  The codec
1741  * is then initialized by the standard procedure.
1742  *
1743  * The template must include the valid callbacks (at least read and
1744  * write), the codec number (num) and address (addr), and the private
1745  * data (private_data).  The other callbacks, wait and reset, are not
1746  * mandatory.
1747  *
1748  * The ac97 instance is registered as a low-level device, so you don't
1749  * have to release it manually.
1750  *
1751  * Returns zero if successful, or a negative error code on failure.
1752  */
1753 int snd_ac97_mixer(ac97_bus_t * bus, ac97_t * _ac97, ac97_t ** rac97)
1754 {
1755         int err;
1756         ac97_t *ac97;
1757         snd_card_t *card;
1758         char name[64];
1759         unsigned long end_time;
1760         unsigned int reg;
1761         static snd_device_ops_t ops = {
1762                 .dev_free =     snd_ac97_dev_free,
1763         };
1764
1765         snd_assert(rac97 != NULL, return -EINVAL);
1766         *rac97 = NULL;
1767         snd_assert(bus != NULL && _ac97 != NULL, return -EINVAL);
1768         snd_assert(_ac97->num < 4 && bus->codec[_ac97->num] == NULL, return -EINVAL);
1769         card = bus->card;
1770         ac97 = snd_magic_kmalloc(ac97_t, 0, GFP_KERNEL);
1771         if (ac97 == NULL)
1772                 return -ENOMEM;
1773         *ac97 = *_ac97;
1774         ac97->bus = bus;
1775         bus->codec[ac97->num] = ac97;
1776         spin_lock_init(&ac97->reg_lock);
1777
1778         if (ac97->pci) {
1779                 pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_VENDOR_ID, &ac97->subsystem_vendor);
1780                 pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_ID, &ac97->subsystem_device);
1781         }
1782         if (bus->reset) {
1783                 bus->reset(ac97);
1784                 goto __access_ok;
1785         }
1786
1787         snd_ac97_write(ac97, AC97_RESET, 0);    /* reset to defaults */
1788         if (bus->wait)
1789                 bus->wait(ac97);
1790         else {
1791                 udelay(50);
1792                 if (ac97_reset_wait(ac97, HZ/2, 0) < 0 &&
1793                     ac97_reset_wait(ac97, HZ/2, 1) < 0) {
1794                         snd_printk(KERN_WARNING "AC'97 %d does not respond - RESET\n", ac97->num);
1795                         /* proceed anyway - it's often non-critical */
1796                 }
1797         }
1798       __access_ok:
1799         ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
1800         ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
1801         if (ac97->id == 0x00000000 || ac97->id == 0xffffffff) {
1802                 snd_printk(KERN_ERR "AC'97 %d access is not valid [0x%x], removing mixer.\n", ac97->num, ac97->id);
1803                 snd_ac97_free(ac97);
1804                 return -EIO;
1805         }
1806         /* AC97 audio codec chip revision detection. */
1807         /* Currently only Realtek ALC650 detection implemented. */
1808         switch(ac97->id & 0xfffffff0) {
1809         case 0x414c4720:        /* ALC650 */
1810                 reg = snd_ac97_read(ac97, AC97_ALC650_REVISION);
1811                 if (((reg & 0x3f) >= 0) && ((reg & 0x3f) < 3))
1812                         ac97->id = 0x414c4720;          /* Old version */
1813                 else if (((reg & 0x3f) >= 3) && ((reg & 0x3f) < 0x10))
1814                         ac97->id = 0x414c4721;          /* D version */
1815                 else if ((reg&0x30) == 0x10)
1816                         ac97->id = 0x414c4722;          /* E version */
1817                 else if ((reg&0x30) == 0x20)
1818                         ac97->id = 0x414c4723;          /* F version */
1819         }
1820
1821         /* test for AC'97 */
1822         if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO) && !(ac97->scaps & AC97_SCAP_AUDIO)) {
1823                 /* test if we can write to the record gain volume register */
1824                 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a06);
1825                 if ((err = snd_ac97_read(ac97, AC97_REC_GAIN)) == 0x8a06)
1826                         ac97->scaps |= AC97_SCAP_AUDIO;
1827         }
1828         if (ac97->scaps & AC97_SCAP_AUDIO) {
1829                 ac97->caps = snd_ac97_read(ac97, AC97_RESET);
1830                 ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID);
1831                 if (ac97->ext_id == 0xffff)     /* invalid combination */
1832                         ac97->ext_id = 0;
1833         }
1834
1835         /* test for MC'97 */
1836         if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM) && !(ac97->scaps & AC97_SCAP_MODEM)) {
1837                 ac97->ext_mid = snd_ac97_read(ac97, AC97_EXTENDED_MID);
1838                 if (ac97->ext_mid == 0xffff)    /* invalid combination */
1839                         ac97->ext_mid = 0;
1840                 if (ac97->ext_mid & 1)
1841                         ac97->scaps |= AC97_SCAP_MODEM;
1842         }
1843
1844         if (!ac97_is_audio(ac97) && !ac97_is_modem(ac97)) {
1845                 if (!(ac97->scaps & (AC97_SCAP_SKIP_AUDIO|AC97_SCAP_SKIP_MODEM)))
1846                         snd_printk(KERN_ERR "AC'97 %d access error (not audio or modem codec)\n", ac97->num);
1847                 snd_ac97_free(ac97);
1848                 return -EACCES;
1849         }
1850
1851         if (bus->reset) // FIXME: always skipping?
1852                 goto __ready_ok;
1853
1854         /* FIXME: add powerdown control */
1855         if (ac97_is_audio(ac97)) {
1856                 /* nothing should be in powerdown mode */
1857                 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
1858                 snd_ac97_write_cache(ac97, AC97_RESET, 0);              /* reset to defaults */
1859                 udelay(100);
1860                 /* nothing should be in powerdown mode */
1861                 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
1862                 snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0);
1863                 end_time = jiffies + (HZ / 10);
1864                 do {
1865                         if ((snd_ac97_read(ac97, AC97_POWERDOWN) & 0x0f) == 0x0f)
1866                                 goto __ready_ok;
1867                         set_current_state(TASK_UNINTERRUPTIBLE);
1868                         schedule_timeout(HZ/10);
1869                 } while (time_after_eq(end_time, jiffies));
1870                 snd_printk(KERN_ERR "AC'97 %d analog subsections not ready\n", ac97->num);
1871         }
1872
1873         /* FIXME: add powerdown control */
1874         if (ac97_is_modem(ac97)) {
1875                 unsigned char tmp;
1876
1877                 /* nothing should be in powerdown mode */
1878                 /* note: it's important to set the rate at first */
1879                 tmp = AC97_MEA_GPIO;
1880                 if (ac97->ext_mid & AC97_MEI_LINE1) {
1881                         snd_ac97_write_cache(ac97, AC97_LINE1_RATE, 12000);
1882                         tmp |= AC97_MEA_ADC1 | AC97_MEA_DAC1;
1883                 }
1884                 if (ac97->ext_mid & AC97_MEI_LINE2) {
1885                         snd_ac97_write_cache(ac97, AC97_LINE2_RATE, 12000);
1886                         tmp |= AC97_MEA_ADC2 | AC97_MEA_DAC2;
1887                 }
1888                 if (ac97->ext_mid & AC97_MEI_HANDSET) {
1889                         snd_ac97_write_cache(ac97, AC97_HANDSET_RATE, 12000);
1890                         tmp |= AC97_MEA_HADC | AC97_MEA_HDAC;
1891                 }
1892                 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0xff00 & ~(tmp << 8));
1893                 udelay(100);
1894                 /* nothing should be in powerdown mode */
1895                 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0xff00 & ~(tmp << 8));
1896                 end_time = jiffies + (HZ / 10);
1897                 do {
1898                         if ((snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS) & tmp) == tmp)
1899                                 goto __ready_ok;
1900                         set_current_state(TASK_UNINTERRUPTIBLE);
1901                         schedule_timeout(HZ/10);
1902                 } while (time_after_eq(end_time, jiffies));
1903                 snd_printk(KERN_ERR "MC'97 %d converters and GPIO not ready (0x%x)\n", ac97->num, snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS));
1904         }
1905
1906       __ready_ok:
1907         if (ac97_is_audio(ac97))
1908                 ac97->addr = (ac97->ext_id & AC97_EI_ADDR_MASK) >> AC97_EI_ADDR_SHIFT;
1909         else
1910                 ac97->addr = (ac97->ext_mid & AC97_MEI_ADDR_MASK) >> AC97_MEI_ADDR_SHIFT;
1911         if (ac97->ext_id & 0x0189)      /* L/R, MIC, SDAC, LDAC VRA support */
1912                 snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, ac97->ext_id & 0x0189);
1913         if (ac97->ext_id & AC97_EI_VRA) {       /* VRA support */
1914                 snd_ac97_determine_rates(ac97, AC97_PCM_FRONT_DAC_RATE, 0, &ac97->rates[AC97_RATES_FRONT_DAC]);
1915                 snd_ac97_determine_rates(ac97, AC97_PCM_LR_ADC_RATE, 0, &ac97->rates[AC97_RATES_ADC]);
1916         } else {
1917                 ac97->rates[AC97_RATES_FRONT_DAC] = SNDRV_PCM_RATE_48000;
1918                 ac97->rates[AC97_RATES_ADC] = SNDRV_PCM_RATE_48000;
1919         }
1920         if (ac97->ext_id & AC97_EI_SPDIF) {
1921                 /* codec specific code (patch) should override these values */
1922                 if (ac97->flags & AC97_CS_SPDIF)
1923                         ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100;
1924                 else if (ac97->id == AC97_ID_CM9739)
1925                         ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000;
1926                 else
1927                         ac97->rates[AC97_RATES_SPDIF] = snd_ac97_determine_spdif_rates(ac97);
1928         }
1929         if (ac97->ext_id & AC97_EI_VRM) {       /* MIC VRA support */
1930                 snd_ac97_determine_rates(ac97, AC97_PCM_MIC_ADC_RATE, 0, &ac97->rates[AC97_RATES_MIC_ADC]);
1931         } else {
1932                 ac97->rates[AC97_RATES_MIC_ADC] = SNDRV_PCM_RATE_48000;
1933         }
1934         if (ac97->ext_id & AC97_EI_SDAC) {      /* SDAC support */
1935                 snd_ac97_determine_rates(ac97, AC97_PCM_SURR_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_SURR_DAC]);
1936                 ac97->scaps |= AC97_SCAP_SURROUND_DAC;
1937         }
1938         if (ac97->ext_id & AC97_EI_LDAC) {      /* LDAC support */
1939                 snd_ac97_determine_rates(ac97, AC97_PCM_LFE_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_LFE_DAC]);
1940                 ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC;
1941         }
1942         /* additional initializations */
1943         if (bus->init)
1944                 bus->init(ac97);
1945         snd_ac97_get_name(ac97, ac97->id, name, 0);
1946         snd_ac97_get_name(NULL, ac97->id, name, 0);  // ac97->id might be changed in the special setup code
1947         if (ac97_is_audio(ac97)) {
1948                 if (card->mixername[0] == '\0') {
1949                         strcpy(card->mixername, name);
1950                 } else {
1951                         if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
1952                                 strcat(card->mixername, ",");
1953                                 strcat(card->mixername, name);
1954                         }
1955                 }
1956                 if ((err = snd_component_add(card, "AC97a")) < 0) {
1957                         snd_ac97_free(ac97);
1958                         return err;
1959                 }
1960                 if (snd_ac97_mixer_build(ac97) < 0) {
1961                         snd_ac97_free(ac97);
1962                         return -ENOMEM;
1963                 }
1964         }
1965         if (ac97_is_modem(ac97)) {
1966                 if (card->mixername[0] == '\0') {
1967                         strcpy(card->mixername, name);
1968                 } else {
1969                         if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
1970                                 strcat(card->mixername, ",");
1971                                 strcat(card->mixername, name);
1972                         }
1973                 }
1974                 if ((err = snd_component_add(card, "AC97m")) < 0) {
1975                         snd_ac97_free(ac97);
1976                         return err;
1977                 }
1978                 if (snd_ac97_modem_build(card, ac97) < 0) {
1979                         snd_ac97_free(ac97);
1980                         return -ENOMEM;
1981                 }
1982         }
1983         /* make sure the proper powerdown bits are cleared */
1984         if (ac97->scaps) {
1985                 reg = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
1986                 if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
1987                         reg &= ~AC97_EA_PRJ;
1988                 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
1989                         reg &= ~(AC97_EA_PRI | AC97_EA_PRK);
1990                 snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, reg);
1991         }
1992         snd_ac97_proc_init(ac97);
1993         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ac97, &ops)) < 0) {
1994                 snd_ac97_free(ac97);
1995                 return err;
1996         }
1997         *rac97 = ac97;
1998         return 0;
1999 }
2000
2001
2002 /*
2003  * Power down the chip.
2004  *
2005  * MASTER and HEADPHONE registers are muted but the register cache values
2006  * are not changed, so that the values can be restored in snd_ac97_resume().
2007  */
2008 static void snd_ac97_powerdown(ac97_t *ac97)
2009 {
2010         unsigned short power;
2011
2012         if (ac97_is_audio(ac97)) {
2013                 /* some codecs have stereo mute bits */
2014                 snd_ac97_write(ac97, AC97_MASTER, 0x9f9f);
2015                 snd_ac97_write(ac97, AC97_HEADPHONE, 0x9f9f);
2016         }
2017
2018         power = ac97->regs[AC97_POWERDOWN] | 0x8000;    /* EAPD */
2019         power |= 0x4000;        /* Headphone amplifier powerdown */
2020         power |= 0x0300;        /* ADC & DAC powerdown */
2021         snd_ac97_write(ac97, AC97_POWERDOWN, power);
2022         udelay(100);
2023         power |= 0x0400;        /* Analog Mixer powerdown (Vref on) */
2024         snd_ac97_write(ac97, AC97_POWERDOWN, power);
2025         udelay(100);
2026 #if 0
2027         /* FIXME: this causes click noises on some boards at resume */
2028         power |= 0x3800;        /* AC-link powerdown, internal Clk disable */
2029         snd_ac97_write(ac97, AC97_POWERDOWN, power);
2030 #endif
2031 }
2032
2033
2034 #ifdef CONFIG_PM
2035 /**
2036  * snd_ac97_suspend - General suspend function for AC97 codec
2037  * @ac97: the ac97 instance
2038  *
2039  * Suspends the codec, power down the chip.
2040  */
2041 void snd_ac97_suspend(ac97_t *ac97)
2042 {
2043         snd_ac97_powerdown(ac97);
2044 }
2045
2046 /**
2047  * snd_ac97_resume - General resume function for AC97 codec
2048  * @ac97: the ac97 instance
2049  *
2050  * Do the standard resume procedure, power up and restoring the
2051  * old register values.
2052  */
2053 void snd_ac97_resume(ac97_t *ac97)
2054 {
2055         int i, is_ad18xx, codec;
2056
2057         if (ac97->bus->reset) {
2058                 ac97->bus->reset(ac97);
2059                 goto  __reset_ready;
2060         }
2061
2062         snd_ac97_write(ac97, AC97_POWERDOWN, 0);
2063         snd_ac97_write(ac97, AC97_RESET, 0);
2064         udelay(100);
2065         snd_ac97_write(ac97, AC97_POWERDOWN, 0);
2066         snd_ac97_write(ac97, AC97_GENERAL_PURPOSE, 0);
2067
2068         snd_ac97_write(ac97, AC97_POWERDOWN, ac97->regs[AC97_POWERDOWN]);
2069         ac97->bus->write(ac97, AC97_MASTER, 0x8101);
2070         for (i = 0; i < 10; i++) {
2071                 if (snd_ac97_read(ac97, AC97_MASTER) == 0x8101)
2072                         break;
2073                 set_current_state(TASK_UNINTERRUPTIBLE);
2074                 schedule_timeout(1);
2075         }
2076         /* FIXME: extra delay */
2077         ac97->bus->write(ac97, AC97_MASTER, 0x8000);
2078         if (snd_ac97_read(ac97, AC97_MASTER) != 0x8000) {
2079                 set_current_state(TASK_UNINTERRUPTIBLE);
2080                 schedule_timeout(HZ/4);
2081         }
2082 __reset_ready:
2083
2084         if (ac97->bus->init)
2085                 ac97->bus->init(ac97);
2086
2087         is_ad18xx = (ac97->flags & AC97_AD_MULTI);
2088         if (is_ad18xx) {
2089                 /* restore the AD18xx codec configurations */
2090                 for (codec = 0; codec < 3; codec++) {
2091                         if (! ac97->spec.ad18xx.id[codec])
2092                                 continue;
2093                         /* select single codec */
2094                         snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
2095                                              ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
2096                         ac97->bus->write(ac97, AC97_AD_CODEC_CFG, ac97->spec.ad18xx.codec_cfg[codec]);
2097                 }
2098                 /* select all codecs */
2099                 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
2100         }
2101
2102         /* restore ac97 status */
2103         for (i = 2; i < 0x7c ; i += 2) {
2104                 if (i == AC97_POWERDOWN || i == AC97_EXTENDED_ID)
2105                         continue;
2106                 /* restore only accessible registers
2107                  * some chip (e.g. nm256) may hang up when unsupported registers
2108                  * are accessed..!
2109                  */
2110                 if (test_bit(i, ac97->reg_accessed)) {
2111                         if (is_ad18xx) {
2112                                 /* handle multi codecs for AD18xx */
2113                                 if (i == AC97_PCM) {
2114                                         for (codec = 0; codec < 3; codec++) {
2115                                                 if (! ac97->spec.ad18xx.id[codec])
2116                                                         continue;
2117                                                 /* select single codec */
2118                                                 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
2119                                                                      ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
2120                                                 /* update PCM bits */
2121                                                 ac97->bus->write(ac97, AC97_PCM, ac97->spec.ad18xx.pcmreg[codec]);
2122                                         }
2123                                         /* select all codecs */
2124                                         snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
2125                                         continue;
2126                                 } else if (i == AC97_AD_TEST ||
2127                                            i == AC97_AD_CODEC_CFG ||
2128                                            i == AC97_AD_SERIAL_CFG)
2129                                         continue; /* ignore */
2130                         }
2131                         snd_ac97_write(ac97, i, ac97->regs[i]);
2132                         snd_ac97_read(ac97, i);
2133                 }
2134         }
2135
2136         if (ac97->ext_id & AC97_EI_SPDIF) {
2137                 if (ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_SPDIF) {
2138                         /* reset spdif status */
2139                         snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
2140                         snd_ac97_write(ac97, AC97_EXTENDED_STATUS, ac97->regs[AC97_EXTENDED_STATUS]);
2141                         if (ac97->flags & AC97_CS_SPDIF)
2142                                 snd_ac97_write(ac97, AC97_CSR_SPDIF, ac97->regs[AC97_CSR_SPDIF]);
2143                         else
2144                                 snd_ac97_write(ac97, AC97_SPDIF, ac97->regs[AC97_SPDIF]);
2145                         snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
2146                 }
2147         }
2148 }
2149 #endif
2150
2151
2152 /*
2153  */
2154 int snd_ac97_remove_ctl(ac97_t *ac97, const char *name)
2155 {
2156         snd_ctl_elem_id_t id;
2157         memset(&id, 0, sizeof(id));
2158         strcpy(id.name, name);
2159         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2160         return snd_ctl_remove_id(ac97->bus->card, &id);
2161 }
2162
2163 static snd_kcontrol_t *ctl_find(ac97_t *ac97, const char *name)
2164 {
2165         snd_ctl_elem_id_t sid;
2166         memset(&sid, 0, sizeof(sid));
2167         strcpy(sid.name, name);
2168         sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2169         return snd_ctl_find_id(ac97->bus->card, &sid);
2170 }
2171
2172 int snd_ac97_rename_ctl(ac97_t *ac97, const char *src, const char *dst)
2173 {
2174         snd_kcontrol_t *kctl = ctl_find(ac97, src);
2175         if (kctl) {
2176                 strcpy(kctl->id.name, dst);
2177                 return 0;
2178         }
2179         return -ENOENT;
2180 }
2181
2182 int snd_ac97_swap_ctl(ac97_t *ac97, const char *s1, const char *s2)
2183 {
2184         snd_kcontrol_t *kctl1, *kctl2;
2185         kctl1 = ctl_find(ac97, s1);
2186         kctl2 = ctl_find(ac97, s2);
2187         if (kctl1 && kctl2) {
2188                 strcpy(kctl1->id.name, s2);
2189                 strcpy(kctl2->id.name, s1);
2190                 return 0;
2191         }
2192         return -ENOENT;
2193 }
2194
2195 static int swap_headphone(ac97_t *ac97, int remove_master)
2196 {
2197         /* FIXME: error checks.. */
2198         if (remove_master) {
2199                 if (ctl_find(ac97, "Headphone Playback Switch") == NULL)
2200                         return 0;
2201                 snd_ac97_remove_ctl(ac97, "Master Playback Switch");
2202                 snd_ac97_remove_ctl(ac97, "Master Playback Volume");
2203         } else {
2204                 snd_ac97_rename_ctl(ac97, "Master Playback Switch", "Line-Out Playback Switch");
2205                 snd_ac97_rename_ctl(ac97, "Master Playback Volume", "Line-Out Playback Volume");
2206         }
2207         snd_ac97_rename_ctl(ac97, "Headphone Playback Switch", "Master Playback Switch");
2208         snd_ac97_rename_ctl(ac97, "Headphone Playback Volume", "Master Playback Volume");
2209         return 0;
2210 }
2211
2212 static int swap_surround(ac97_t *ac97)
2213 {
2214         /* FIXME: error checks.. */
2215         snd_ac97_swap_ctl(ac97, "Master Playback Switch", "Surround Playback Switch");
2216         snd_ac97_swap_ctl(ac97, "Master Playback Volume", "Surround Playback Volume");
2217         return 0;
2218 }
2219
2220 static int tune_ad_sharing(ac97_t *ac97)
2221 {
2222         unsigned short scfg;
2223         if ((ac97->id & 0xffffff00) != 0x41445300) {
2224                 snd_printk(KERN_ERR "ac97_quirk AD_SHARING is only for AD codecs\n");
2225                 return -EINVAL;
2226         }
2227         /* Turn on OMS bit to route microphone to back panel */
2228         scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
2229         snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x0200);
2230         return 0;
2231 }
2232
2233 static const snd_kcontrol_new_t snd_ac97_alc_jack_detect =
2234 AC97_SINGLE("Jack Detect", AC97_ALC650_CLOCK, 5, 1, 0);
2235
2236 static int tune_alc_jack(ac97_t *ac97)
2237 {
2238         if ((ac97->id & 0xffffff00) != 0x414c4700) {
2239                 snd_printk(KERN_ERR "ac97_quirk ALC_JACK is only for Realtek codecs\n");
2240                 return -EINVAL;
2241         }
2242         snd_ac97_update_bits(ac97, 0x7a, 0x20, 0x20); /* select jack detect function */
2243         snd_ac97_update_bits(ac97, 0x7a, 0x01, 0x01); /* Line-out auto mute */
2244         return snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&snd_ac97_alc_jack_detect, ac97));
2245 }
2246
2247 static int apply_quirk(ac97_t *ac97, int quirk)
2248 {
2249         switch (quirk) {
2250         case AC97_TUNE_NONE:
2251                 return 0;
2252         case AC97_TUNE_HP_ONLY:
2253                 return swap_headphone(ac97, 1);
2254         case AC97_TUNE_SWAP_HP:
2255                 return swap_headphone(ac97, 0);
2256         case AC97_TUNE_SWAP_SURROUND:
2257                 return swap_surround(ac97);
2258         case AC97_TUNE_AD_SHARING:
2259                 return tune_ad_sharing(ac97);
2260         case AC97_TUNE_ALC_JACK:
2261                 return tune_alc_jack(ac97);
2262         }
2263         return -EINVAL;
2264 }
2265
2266 /**
2267  * snd_ac97_tune_hardware - tune up the hardware
2268  * @ac97: the ac97 instance
2269  * @quirk: quirk list
2270  * @override: explicit quirk value (overrides the list if not AC97_TUNE_DEFAULT)
2271  *
2272  * Do some workaround for each pci device, such as renaming of the
2273  * headphone (true line-out) control as "Master".
2274  * The quirk-list must be terminated with a zero-filled entry.
2275  *
2276  * Returns zero if successful, or a negative error code on failure.
2277  */
2278
2279 int snd_ac97_tune_hardware(ac97_t *ac97, struct ac97_quirk *quirk, int override)
2280 {
2281         int result;
2282
2283         snd_assert(quirk, return -EINVAL);
2284
2285         if (override != AC97_TUNE_DEFAULT) {
2286                 result = apply_quirk(ac97, override);
2287                 if (result < 0)
2288                         snd_printk(KERN_ERR "applying quirk type %d failed (%d)\n", override, result);
2289                 return result;
2290         }
2291
2292         for (; quirk->vendor; quirk++) {
2293                 if (quirk->vendor != ac97->subsystem_vendor)
2294                         continue;
2295                 if ((! quirk->mask && quirk->device == ac97->subsystem_device) ||
2296                     quirk->device == (quirk->mask & ac97->subsystem_device)) {
2297                         snd_printdd("ac97 quirk for %s (%04x:%04x)\n", quirk->name, ac97->subsystem_vendor, ac97->subsystem_device);
2298                         result = apply_quirk(ac97, quirk->type);
2299                         if (result < 0)
2300                                 snd_printk(KERN_ERR "applying quirk type %d for %s failed (%d)\n", quirk->type, quirk->name, result);
2301                         return result;
2302                 }
2303         }
2304         return 0;
2305 }
2306
2307
2308 /*
2309  *  Exported symbols
2310  */
2311
2312 EXPORT_SYMBOL(snd_ac97_write);
2313 EXPORT_SYMBOL(snd_ac97_read);
2314 EXPORT_SYMBOL(snd_ac97_write_cache);
2315 EXPORT_SYMBOL(snd_ac97_update);
2316 EXPORT_SYMBOL(snd_ac97_update_bits);
2317 EXPORT_SYMBOL(snd_ac97_bus);
2318 EXPORT_SYMBOL(snd_ac97_mixer);
2319 EXPORT_SYMBOL(snd_ac97_pcm_assign);
2320 EXPORT_SYMBOL(snd_ac97_pcm_open);
2321 EXPORT_SYMBOL(snd_ac97_pcm_close);
2322 EXPORT_SYMBOL(snd_ac97_tune_hardware);
2323 EXPORT_SYMBOL(snd_ac97_set_rate);
2324 #ifdef CONFIG_PM
2325 EXPORT_SYMBOL(snd_ac97_resume);
2326 EXPORT_SYMBOL(snd_ac97_suspend);
2327 #endif
2328
2329 /*
2330  *  INIT part
2331  */
2332
2333 static int __init alsa_ac97_init(void)
2334 {
2335         return 0;
2336 }
2337
2338 static void __exit alsa_ac97_exit(void)
2339 {
2340 }
2341
2342 module_init(alsa_ac97_init)
2343 module_exit(alsa_ac97_exit)