linux/sound/pci/ac97/ac97_codec.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4 *  Universal interface for Audio Codec '97
   5 *
   6 *  For more details look to AC '97 component specification revision 2.2
   7 *  by Intel Corporation (http://developer.intel.com).
   8 */
   9
  10#include <linux/delay.h>
  11#include <linux/init.h>
  12#include <linux/slab.h>
  13#include <linux/pci.h>
  14#include <linux/module.h>
  15#include <linux/mutex.h>
  16#include <sound/core.h>
  17#include <sound/pcm.h>
  18#include <sound/tlv.h>
  19#include <sound/ac97_codec.h>
  20#include <sound/asoundef.h>
  21#include <sound/initval.h>
  22#include "ac97_id.h"
  23
  24#include "ac97_patch.c"
  25
  26MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  27MODULE_DESCRIPTION("Universal interface for Audio Codec '97");
  28MODULE_LICENSE("GPL");
  29
  30static bool enable_loopback;
  31
  32module_param(enable_loopback, bool, 0444);
  33MODULE_PARM_DESC(enable_loopback, "Enable AC97 ADC/DAC Loopback Control");
  34
  35#ifdef CONFIG_SND_AC97_POWER_SAVE
  36static int power_save = CONFIG_SND_AC97_POWER_SAVE_DEFAULT;
  37module_param(power_save, int, 0644);
  38MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
  39                 "(in second, 0 = disable).");
  40#endif
  41/*
  42
  43 */
  44
  45struct ac97_codec_id {
  46        unsigned int id;
  47        unsigned int mask;
  48        const char *name;
  49        int (*patch)(struct snd_ac97 *ac97);
  50        int (*mpatch)(struct snd_ac97 *ac97);
  51        unsigned int flags;
  52};
  53
  54static const struct ac97_codec_id snd_ac97_codec_id_vendors[] = {
  55{ 0x41445300, 0xffffff00, "Analog Devices",     NULL,   NULL },
  56{ 0x414b4d00, 0xffffff00, "Asahi Kasei",        NULL,   NULL },
  57{ 0x414c4300, 0xffffff00, "Realtek",            NULL,   NULL },
  58{ 0x414c4700, 0xffffff00, "Realtek",            NULL,   NULL },
  59/*
  60 * This is an _inofficial_ Aztech Labs entry
  61 * (value might differ from unknown official Aztech ID),
  62 * currently used by the AC97 emulation of the almost-AC97 PCI168 card.
  63 */
  64{ 0x415a5400, 0xffffff00, "Aztech Labs (emulated)",     NULL,   NULL },
  65{ 0x434d4900, 0xffffff00, "C-Media Electronics", NULL,  NULL },
  66{ 0x43525900, 0xffffff00, "Cirrus Logic",       NULL,   NULL },
  67{ 0x43585400, 0xffffff00, "Conexant",           NULL,   NULL },
  68{ 0x44543000, 0xffffff00, "Diamond Technology", NULL,   NULL },
  69{ 0x454d4300, 0xffffff00, "eMicro",             NULL,   NULL },
  70{ 0x45838300, 0xffffff00, "ESS Technology",     NULL,   NULL },
  71{ 0x48525300, 0xffffff00, "Intersil",           NULL,   NULL },
  72{ 0x49434500, 0xffffff00, "ICEnsemble",         NULL,   NULL },
  73{ 0x49544500, 0xffffff00, "ITE Tech.Inc",       NULL,   NULL },
  74{ 0x4e534300, 0xffffff00, "National Semiconductor", NULL, NULL },
  75{ 0x50534300, 0xffffff00, "Philips",            NULL,   NULL },
  76{ 0x53494c00, 0xffffff00, "Silicon Laboratory", NULL,   NULL },
  77{ 0x53544d00, 0xffffff00, "STMicroelectronics", NULL,   NULL },
  78{ 0x54524100, 0xffffff00, "TriTech",            NULL,   NULL },
  79{ 0x54584e00, 0xffffff00, "Texas Instruments",  NULL,   NULL },
  80{ 0x56494100, 0xffffff00, "VIA Technologies",   NULL,   NULL },
  81{ 0x57454300, 0xffffff00, "Winbond",            NULL,   NULL },
  82{ 0x574d4c00, 0xffffff00, "Wolfson",            NULL,   NULL },
  83{ 0x594d4800, 0xffffff00, "Yamaha",             NULL,   NULL },
  84{ 0x83847600, 0xffffff00, "SigmaTel",           NULL,   NULL },
  85{ 0,          0,          NULL,                 NULL,   NULL }
  86};
  87
  88static const struct ac97_codec_id snd_ac97_codec_ids[] = {
  89{ 0x41445303, 0xffffffff, "AD1819",             patch_ad1819,   NULL },
  90{ 0x41445340, 0xffffffff, "AD1881",             patch_ad1881,   NULL },
  91{ 0x41445348, 0xffffffff, "AD1881A",            patch_ad1881,   NULL },
  92{ 0x41445360, 0xffffffff, "AD1885",             patch_ad1885,   NULL },
  93{ 0x41445361, 0xffffffff, "AD1886",             patch_ad1886,   NULL },
  94{ 0x41445362, 0xffffffff, "AD1887",             patch_ad1881,   NULL },
  95{ 0x41445363, 0xffffffff, "AD1886A",            patch_ad1881,   NULL },
  96{ 0x41445368, 0xffffffff, "AD1888",             patch_ad1888,   NULL },
  97{ 0x41445370, 0xffffffff, "AD1980",             patch_ad1980,   NULL },
  98{ 0x41445372, 0xffffffff, "AD1981A",            patch_ad1981a,  NULL },
  99{ 0x41445374, 0xffffffff, "AD1981B",            patch_ad1981b,  NULL },
 100{ 0x41445375, 0xffffffff, "AD1985",             patch_ad1985,   NULL },
 101{ 0x41445378, 0xffffffff, "AD1986",             patch_ad1986,   NULL },
 102{ 0x414b4d00, 0xffffffff, "AK4540",             NULL,           NULL },
 103{ 0x414b4d01, 0xffffffff, "AK4542",             NULL,           NULL },
 104{ 0x414b4d02, 0xffffffff, "AK4543",             NULL,           NULL },
 105{ 0x414b4d06, 0xffffffff, "AK4544A",            NULL,           NULL },
 106{ 0x414b4d07, 0xffffffff, "AK4545",             NULL,           NULL },
 107{ 0x414c4300, 0xffffff00, "ALC100,100P",        NULL,           NULL },
 108{ 0x414c4710, 0xfffffff0, "ALC200,200P",        NULL,           NULL },
 109{ 0x414c4721, 0xffffffff, "ALC650D",            NULL,   NULL }, /* already patched */
 110{ 0x414c4722, 0xffffffff, "ALC650E",            NULL,   NULL }, /* already patched */
 111{ 0x414c4723, 0xffffffff, "ALC650F",            NULL,   NULL }, /* already patched */
 112{ 0x414c4720, 0xfffffff0, "ALC650",             patch_alc650,   NULL },
 113{ 0x414c4730, 0xffffffff, "ALC101",             NULL,           NULL },
 114{ 0x414c4740, 0xfffffff0, "ALC202",             NULL,           NULL },
 115{ 0x414c4750, 0xfffffff0, "ALC250",             NULL,           NULL },
 116{ 0x414c4760, 0xfffffff0, "ALC655",             patch_alc655,   NULL },
 117{ 0x414c4770, 0xfffffff0, "ALC203",             patch_alc203,   NULL },
 118{ 0x414c4781, 0xffffffff, "ALC658D",            NULL,   NULL }, /* already patched */
 119{ 0x414c4780, 0xfffffff0, "ALC658",             patch_alc655,   NULL },
 120{ 0x414c4790, 0xfffffff0, "ALC850",             patch_alc850,   NULL },
 121{ 0x415a5401, 0xffffffff, "AZF3328",            patch_aztech_azf3328,   NULL },
 122{ 0x434d4941, 0xffffffff, "CMI9738",            patch_cm9738,   NULL },
 123{ 0x434d4961, 0xffffffff, "CMI9739",            patch_cm9739,   NULL },
 124{ 0x434d4969, 0xffffffff, "CMI9780",            patch_cm9780,   NULL },
 125{ 0x434d4978, 0xffffffff, "CMI9761A",           patch_cm9761,   NULL },
 126{ 0x434d4982, 0xffffffff, "CMI9761B",           patch_cm9761,   NULL },
 127{ 0x434d4983, 0xffffffff, "CMI9761A+",          patch_cm9761,   NULL },
 128{ 0x43525900, 0xfffffff8, "CS4297",             NULL,           NULL },
 129{ 0x43525910, 0xfffffff8, "CS4297A",            patch_cirrus_spdif,     NULL },
 130{ 0x43525920, 0xfffffff8, "CS4298",             patch_cirrus_spdif,             NULL },
 131{ 0x43525928, 0xfffffff8, "CS4294",             NULL,           NULL },
 132{ 0x43525930, 0xfffffff8, "CS4299",             patch_cirrus_cs4299,    NULL },
 133{ 0x43525948, 0xfffffff8, "CS4201",             NULL,           NULL },
 134{ 0x43525958, 0xfffffff8, "CS4205",             patch_cirrus_spdif,     NULL },
 135{ 0x43525960, 0xfffffff8, "CS4291",             NULL,           NULL },
 136{ 0x43525970, 0xfffffff8, "CS4202",             NULL,           NULL },
 137{ 0x43585421, 0xffffffff, "HSD11246",           NULL,           NULL }, // SmartMC II
 138{ 0x43585428, 0xfffffff8, "Cx20468",            patch_conexant, NULL }, // SmartAMC fixme: the mask might be different
 139{ 0x43585430, 0xffffffff, "Cx20468-31",         patch_conexant, NULL },
 140{ 0x43585431, 0xffffffff, "Cx20551",           patch_cx20551,  NULL },
 141{ 0x44543031, 0xfffffff0, "DT0398",             NULL,           NULL },
 142{ 0x454d4328, 0xffffffff, "EM28028",            NULL,           NULL },  // same as TR28028?
 143{ 0x45838308, 0xffffffff, "ESS1988",            NULL,           NULL },
 144{ 0x48525300, 0xffffff00, "HMP9701",            NULL,           NULL },
 145{ 0x49434501, 0xffffffff, "ICE1230",            NULL,           NULL },
 146{ 0x49434511, 0xffffffff, "ICE1232",            NULL,           NULL }, // alias VIA VT1611A?
 147{ 0x49434514, 0xffffffff, "ICE1232A",           NULL,           NULL },
 148{ 0x49434551, 0xffffffff, "VT1616",             patch_vt1616,   NULL }, 
 149{ 0x49434552, 0xffffffff, "VT1616i",            patch_vt1616,   NULL }, // VT1616 compatible (chipset integrated)
 150{ 0x49544520, 0xffffffff, "IT2226E",            NULL,           NULL },
 151{ 0x49544561, 0xffffffff, "IT2646E",            patch_it2646,   NULL },
 152{ 0x4e534300, 0xffffffff, "LM4540,43,45,46,48", NULL,           NULL }, // only guess --jk
 153{ 0x4e534331, 0xffffffff, "LM4549",             NULL,           NULL },
 154{ 0x4e534350, 0xffffffff, "LM4550",             patch_lm4550,   NULL }, // volume wrap fix 
 155{ 0x50534304, 0xffffffff, "UCB1400",            patch_ucb1400,  NULL },
 156{ 0x53494c20, 0xffffffe0, "Si3036,8",           mpatch_si3036,  mpatch_si3036, AC97_MODEM_PATCH },
 157{ 0x53544d02, 0xffffffff, "ST7597",             NULL,           NULL },
 158{ 0x54524102, 0xffffffff, "TR28022",            NULL,           NULL },
 159{ 0x54524103, 0xffffffff, "TR28023",            NULL,           NULL },
 160{ 0x54524106, 0xffffffff, "TR28026",            NULL,           NULL },
 161{ 0x54524108, 0xffffffff, "TR28028",            patch_tritech_tr28028,  NULL }, // added by xin jin [07/09/99]
 162{ 0x54524123, 0xffffffff, "TR28602",            NULL,           NULL }, // only guess --jk [TR28023 = eMicro EM28023 (new CT1297)]
 163{ 0x54584e03, 0xffffffff, "TLV320AIC27",        NULL,           NULL },
 164{ 0x54584e20, 0xffffffff, "TLC320AD9xC",        NULL,           NULL },
 165{ 0x56494120, 0xfffffff0, "VIA1613",            patch_vt1613,   NULL },
 166{ 0x56494161, 0xffffffff, "VIA1612A",           NULL,           NULL }, // modified ICE1232 with S/PDIF
 167{ 0x56494170, 0xffffffff, "VIA1617A",           patch_vt1617a,  NULL }, // modified VT1616 with S/PDIF
 168{ 0x56494182, 0xffffffff, "VIA1618",            patch_vt1618,   NULL },
 169{ 0x57454301, 0xffffffff, "W83971D",            NULL,           NULL },
 170{ 0x574d4c00, 0xffffffff, "WM9701,WM9701A",     NULL,           NULL },
 171{ 0x574d4C03, 0xffffffff, "WM9703,WM9707,WM9708,WM9717", patch_wolfson03, NULL},
 172{ 0x574d4C04, 0xffffffff, "WM9704M,WM9704Q",    patch_wolfson04, NULL},
 173{ 0x574d4C05, 0xffffffff, "WM9705,WM9710",      patch_wolfson05, NULL},
 174{ 0x574d4C09, 0xffffffff, "WM9709",             NULL,           NULL},
 175{ 0x574d4C12, 0xffffffff, "WM9711,WM9712,WM9715",       patch_wolfson11, NULL},
 176{ 0x574d4c13, 0xffffffff, "WM9713,WM9714",      patch_wolfson13, NULL, AC97_DEFAULT_POWER_OFF},
 177{ 0x594d4800, 0xffffffff, "YMF743",             patch_yamaha_ymf743,    NULL },
 178{ 0x594d4802, 0xffffffff, "YMF752",             NULL,           NULL },
 179{ 0x594d4803, 0xffffffff, "YMF753",             patch_yamaha_ymf753,    NULL },
 180{ 0x83847600, 0xffffffff, "STAC9700,83,84",     patch_sigmatel_stac9700,        NULL },
 181{ 0x83847604, 0xffffffff, "STAC9701,3,4,5",     NULL,           NULL },
 182{ 0x83847605, 0xffffffff, "STAC9704",           NULL,           NULL },
 183{ 0x83847608, 0xffffffff, "STAC9708,11",        patch_sigmatel_stac9708,        NULL },
 184{ 0x83847609, 0xffffffff, "STAC9721,23",        patch_sigmatel_stac9721,        NULL },
 185{ 0x83847644, 0xffffffff, "STAC9744",           patch_sigmatel_stac9744,        NULL },
 186{ 0x83847650, 0xffffffff, "STAC9750,51",        NULL,           NULL }, // patch?
 187{ 0x83847652, 0xffffffff, "STAC9752,53",        NULL,           NULL }, // patch?
 188{ 0x83847656, 0xffffffff, "STAC9756,57",        patch_sigmatel_stac9756,        NULL },
 189{ 0x83847658, 0xffffffff, "STAC9758,59",        patch_sigmatel_stac9758,        NULL },
 190{ 0x83847666, 0xffffffff, "STAC9766,67",        NULL,           NULL }, // patch?
 191{ 0,          0,          NULL,                 NULL,           NULL }
 192};
 193
 194
 195static void update_power_regs(struct snd_ac97 *ac97);
 196#ifdef CONFIG_SND_AC97_POWER_SAVE
 197#define ac97_is_power_save_mode(ac97) \
 198        ((ac97->scaps & AC97_SCAP_POWER_SAVE) && power_save)
 199#else
 200#define ac97_is_power_save_mode(ac97) 0
 201#endif
 202
 203#define ac97_err(ac97, fmt, args...)    \
 204        dev_err((ac97)->bus->card->dev, fmt, ##args)
 205#define ac97_warn(ac97, fmt, args...)   \
 206        dev_warn((ac97)->bus->card->dev, fmt, ##args)
 207#define ac97_dbg(ac97, fmt, args...)    \
 208        dev_dbg((ac97)->bus->card->dev, fmt, ##args)
 209
 210/*
 211 *  I/O routines
 212 */
 213
 214static int snd_ac97_valid_reg(struct snd_ac97 *ac97, unsigned short reg)
 215{
 216        /* filter some registers for buggy codecs */
 217        switch (ac97->id) {
 218        case AC97_ID_ST_AC97_ID4:
 219                if (reg == 0x08)
 220                        return 0;
 221                fallthrough;
 222        case AC97_ID_ST7597:
 223                if (reg == 0x22 || reg == 0x7a)
 224                        return 1;
 225                fallthrough;
 226        case AC97_ID_AK4540:
 227        case AC97_ID_AK4542:
 228                if (reg <= 0x1c || reg == 0x20 || reg == 0x26 || reg >= 0x7c)
 229                        return 1;
 230                return 0;
 231        case AC97_ID_AD1819:    /* AD1819 */
 232        case AC97_ID_AD1881:    /* AD1881 */
 233        case AC97_ID_AD1881A:   /* AD1881A */
 234                if (reg >= 0x3a && reg <= 0x6e) /* 0x59 */
 235                        return 0;
 236                return 1;
 237        case AC97_ID_AD1885:    /* AD1885 */
 238        case AC97_ID_AD1886:    /* AD1886 */
 239        case AC97_ID_AD1886A:   /* AD1886A - !!verify!! --jk */
 240        case AC97_ID_AD1887:    /* AD1887 - !!verify!! --jk */
 241                if (reg == 0x5a)
 242                        return 1;
 243                if (reg >= 0x3c && reg <= 0x6e) /* 0x59 */
 244                        return 0;
 245                return 1;
 246        case AC97_ID_STAC9700:
 247        case AC97_ID_STAC9704:
 248        case AC97_ID_STAC9705:
 249        case AC97_ID_STAC9708:
 250        case AC97_ID_STAC9721:
 251        case AC97_ID_STAC9744:
 252        case AC97_ID_STAC9756:
 253                if (reg <= 0x3a || reg >= 0x5a)
 254                        return 1;
 255                return 0;
 256        }
 257        return 1;
 258}
 259
 260/**
 261 * snd_ac97_write - write a value on the given register
 262 * @ac97: the ac97 instance
 263 * @reg: the register to change
 264 * @value: the value to set
 265 *
 266 * Writes a value on the given register.  This will invoke the write
 267 * callback directly after the register check.
 268 * This function doesn't change the register cache unlike
 269 * #snd_ca97_write_cache(), so use this only when you don't want to
 270 * reflect the change to the suspend/resume state.
 271 */
 272void snd_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)
 273{
 274        if (!snd_ac97_valid_reg(ac97, reg))
 275                return;
 276        if ((ac97->id & 0xffffff00) == AC97_ID_ALC100) {
 277                /* Fix H/W bug of ALC100/100P */
 278                if (reg == AC97_MASTER || reg == AC97_HEADPHONE)
 279                        ac97->bus->ops->write(ac97, AC97_RESET, 0);     /* reset audio codec */
 280        }
 281        ac97->bus->ops->write(ac97, reg, value);
 282}
 283
 284EXPORT_SYMBOL(snd_ac97_write);
 285
 286/**
 287 * snd_ac97_read - read a value from the given register
 288 * 
 289 * @ac97: the ac97 instance
 290 * @reg: the register to read
 291 *
 292 * Reads a value from the given register.  This will invoke the read
 293 * callback directly after the register check.
 294 *
 295 * Return: The read value.
 296 */
 297unsigned short snd_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
 298{
 299        if (!snd_ac97_valid_reg(ac97, reg))
 300                return 0;
 301        return ac97->bus->ops->read(ac97, reg);
 302}
 303
 304/* read a register - return the cached value if already read */
 305static inline unsigned short snd_ac97_read_cache(struct snd_ac97 *ac97, unsigned short reg)
 306{
 307        if (! test_bit(reg, ac97->reg_accessed)) {
 308                ac97->regs[reg] = ac97->bus->ops->read(ac97, reg);
 309                // set_bit(reg, ac97->reg_accessed);
 310        }
 311        return ac97->regs[reg];
 312}
 313
 314EXPORT_SYMBOL(snd_ac97_read);
 315
 316/**
 317 * snd_ac97_write_cache - write a value on the given register and update the cache
 318 * @ac97: the ac97 instance
 319 * @reg: the register to change
 320 * @value: the value to set
 321 *
 322 * Writes a value on the given register and updates the register
 323 * cache.  The cached values are used for the cached-read and the
 324 * suspend/resume.
 325 */
 326void snd_ac97_write_cache(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)
 327{
 328        if (!snd_ac97_valid_reg(ac97, reg))
 329                return;
 330        mutex_lock(&ac97->reg_mutex);
 331        ac97->regs[reg] = value;
 332        ac97->bus->ops->write(ac97, reg, value);
 333        set_bit(reg, ac97->reg_accessed);
 334        mutex_unlock(&ac97->reg_mutex);
 335}
 336
 337EXPORT_SYMBOL(snd_ac97_write_cache);
 338
 339/**
 340 * snd_ac97_update - update the value on the given register
 341 * @ac97: the ac97 instance
 342 * @reg: the register to change
 343 * @value: the value to set
 344 *
 345 * Compares the value with the register cache and updates the value
 346 * only when the value is changed.
 347 *
 348 * Return: 1 if the value is changed, 0 if no change, or a negative
 349 * code on failure.
 350 */
 351int snd_ac97_update(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)
 352{
 353        int change;
 354
 355        if (!snd_ac97_valid_reg(ac97, reg))
 356                return -EINVAL;
 357        mutex_lock(&ac97->reg_mutex);
 358        change = ac97->regs[reg] != value;
 359        if (change) {
 360                ac97->regs[reg] = value;
 361                ac97->bus->ops->write(ac97, reg, value);
 362        }
 363        set_bit(reg, ac97->reg_accessed);
 364        mutex_unlock(&ac97->reg_mutex);
 365        return change;
 366}
 367
 368EXPORT_SYMBOL(snd_ac97_update);
 369
 370/**
 371 * snd_ac97_update_bits - update the bits on the given register
 372 * @ac97: the ac97 instance
 373 * @reg: the register to change
 374 * @mask: the bit-mask to change
 375 * @value: the value to set
 376 *
 377 * Updates the masked-bits on the given register only when the value
 378 * is changed.
 379 *
 380 * Return: 1 if the bits are changed, 0 if no change, or a negative
 381 * code on failure.
 382 */
 383int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned short mask, unsigned short value)
 384{
 385        int change;
 386
 387        if (!snd_ac97_valid_reg(ac97, reg))
 388                return -EINVAL;
 389        mutex_lock(&ac97->reg_mutex);
 390        change = snd_ac97_update_bits_nolock(ac97, reg, mask, value);
 391        mutex_unlock(&ac97->reg_mutex);
 392        return change;
 393}
 394
 395EXPORT_SYMBOL(snd_ac97_update_bits);
 396
 397/* no lock version - see snd_ac97_update_bits() */
 398int snd_ac97_update_bits_nolock(struct snd_ac97 *ac97, unsigned short reg,
 399                                unsigned short mask, unsigned short value)
 400{
 401        int change;
 402        unsigned short old, new;
 403
 404        old = snd_ac97_read_cache(ac97, reg);
 405        new = (old & ~mask) | (value & mask);
 406        change = old != new;
 407        if (change) {
 408                ac97->regs[reg] = new;
 409                ac97->bus->ops->write(ac97, reg, new);
 410        }
 411        set_bit(reg, ac97->reg_accessed);
 412        return change;
 413}
 414
 415static int snd_ac97_ad18xx_update_pcm_bits(struct snd_ac97 *ac97, int codec, unsigned short mask, unsigned short value)
 416{
 417        int change;
 418        unsigned short old, new, cfg;
 419
 420        mutex_lock(&ac97->page_mutex);
 421        old = ac97->spec.ad18xx.pcmreg[codec];
 422        new = (old & ~mask) | (value & mask);
 423        change = old != new;
 424        if (change) {
 425                mutex_lock(&ac97->reg_mutex);
 426                cfg = snd_ac97_read_cache(ac97, AC97_AD_SERIAL_CFG);
 427                ac97->spec.ad18xx.pcmreg[codec] = new;
 428                /* select single codec */
 429                ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
 430                                 (cfg & ~0x7000) |
 431                                 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
 432                /* update PCM bits */
 433                ac97->bus->ops->write(ac97, AC97_PCM, new);
 434                /* select all codecs */
 435                ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
 436                                 cfg | 0x7000);
 437                mutex_unlock(&ac97->reg_mutex);
 438        }
 439        mutex_unlock(&ac97->page_mutex);
 440        return change;
 441}
 442
 443/*
 444 * Controls
 445 */
 446
 447static int snd_ac97_info_enum_double(struct snd_kcontrol *kcontrol,
 448                                     struct snd_ctl_elem_info *uinfo)
 449{
 450        struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
 451        
 452        return snd_ctl_enum_info(uinfo, e->shift_l == e->shift_r ? 1 : 2,
 453                                 e->mask, e->texts);
 454}
 455
 456static int snd_ac97_get_enum_double(struct snd_kcontrol *kcontrol,
 457                                    struct snd_ctl_elem_value *ucontrol)
 458{
 459        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 460        struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
 461        unsigned short val, bitmask;
 462        
 463        for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
 464                ;
 465        val = snd_ac97_read_cache(ac97, e->reg);
 466        ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
 467        if (e->shift_l != e->shift_r)
 468                ucontrol->value.enumerated.item[1] = (val >> e->shift_r) & (bitmask - 1);
 469
 470        return 0;
 471}
 472
 473static int snd_ac97_put_enum_double(struct snd_kcontrol *kcontrol,
 474                                    struct snd_ctl_elem_value *ucontrol)
 475{
 476        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 477        struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
 478        unsigned short val;
 479        unsigned short mask, bitmask;
 480        
 481        for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
 482                ;
 483        if (ucontrol->value.enumerated.item[0] > e->mask - 1)
 484                return -EINVAL;
 485        val = ucontrol->value.enumerated.item[0] << e->shift_l;
 486        mask = (bitmask - 1) << e->shift_l;
 487        if (e->shift_l != e->shift_r) {
 488                if (ucontrol->value.enumerated.item[1] > e->mask - 1)
 489                        return -EINVAL;
 490                val |= ucontrol->value.enumerated.item[1] << e->shift_r;
 491                mask |= (bitmask - 1) << e->shift_r;
 492        }
 493        return snd_ac97_update_bits(ac97, e->reg, mask, val);
 494}
 495
 496/* save/restore ac97 v2.3 paging */
 497static int snd_ac97_page_save(struct snd_ac97 *ac97, int reg, struct snd_kcontrol *kcontrol)
 498{
 499        int page_save = -1;
 500        if ((kcontrol->private_value & (1<<25)) &&
 501            (ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23 &&
 502            (reg >= 0x60 && reg < 0x70)) {
 503                unsigned short page = (kcontrol->private_value >> 26) & 0x0f;
 504                mutex_lock(&ac97->page_mutex); /* lock paging */
 505                page_save = snd_ac97_read(ac97, AC97_INT_PAGING) & AC97_PAGE_MASK;
 506                snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page);
 507        }
 508        return page_save;
 509}
 510
 511static void snd_ac97_page_restore(struct snd_ac97 *ac97, int page_save)
 512{
 513        if (page_save >= 0) {
 514                snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save);
 515                mutex_unlock(&ac97->page_mutex); /* unlock paging */
 516        }
 517}
 518
 519/* volume and switch controls */
 520static int snd_ac97_info_volsw(struct snd_kcontrol *kcontrol,
 521                               struct snd_ctl_elem_info *uinfo)
 522{
 523        int mask = (kcontrol->private_value >> 16) & 0xff;
 524        int shift = (kcontrol->private_value >> 8) & 0x0f;
 525        int rshift = (kcontrol->private_value >> 12) & 0x0f;
 526
 527        uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 528        uinfo->count = shift == rshift ? 1 : 2;
 529        uinfo->value.integer.min = 0;
 530        uinfo->value.integer.max = mask;
 531        return 0;
 532}
 533
 534static int snd_ac97_get_volsw(struct snd_kcontrol *kcontrol,
 535                              struct snd_ctl_elem_value *ucontrol)
 536{
 537        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 538        int reg = kcontrol->private_value & 0xff;
 539        int shift = (kcontrol->private_value >> 8) & 0x0f;
 540        int rshift = (kcontrol->private_value >> 12) & 0x0f;
 541        int mask = (kcontrol->private_value >> 16) & 0xff;
 542        int invert = (kcontrol->private_value >> 24) & 0x01;
 543        int page_save;
 544
 545        page_save = snd_ac97_page_save(ac97, reg, kcontrol);
 546        ucontrol->value.integer.value[0] = (snd_ac97_read_cache(ac97, reg) >> shift) & mask;
 547        if (shift != rshift)
 548                ucontrol->value.integer.value[1] = (snd_ac97_read_cache(ac97, reg) >> rshift) & mask;
 549        if (invert) {
 550                ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
 551                if (shift != rshift)
 552                        ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
 553        }
 554        snd_ac97_page_restore(ac97, page_save);
 555        return 0;
 556}
 557
 558static int snd_ac97_put_volsw(struct snd_kcontrol *kcontrol,
 559                              struct snd_ctl_elem_value *ucontrol)
 560{
 561        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 562        int reg = kcontrol->private_value & 0xff;
 563        int shift = (kcontrol->private_value >> 8) & 0x0f;
 564        int rshift = (kcontrol->private_value >> 12) & 0x0f;
 565        int mask = (kcontrol->private_value >> 16) & 0xff;
 566        int invert = (kcontrol->private_value >> 24) & 0x01;
 567        int err, page_save;
 568        unsigned short val, val2, val_mask;
 569        
 570        page_save = snd_ac97_page_save(ac97, reg, kcontrol);
 571        val = (ucontrol->value.integer.value[0] & mask);
 572        if (invert)
 573                val = mask - val;
 574        val_mask = mask << shift;
 575        val = val << shift;
 576        if (shift != rshift) {
 577                val2 = (ucontrol->value.integer.value[1] & mask);
 578                if (invert)
 579                        val2 = mask - val2;
 580                val_mask |= mask << rshift;
 581                val |= val2 << rshift;
 582        }
 583        err = snd_ac97_update_bits(ac97, reg, val_mask, val);
 584        snd_ac97_page_restore(ac97, page_save);
 585#ifdef CONFIG_SND_AC97_POWER_SAVE
 586        /* check analog mixer power-down */
 587        if ((val_mask & AC97_PD_EAPD) &&
 588            (kcontrol->private_value & (1<<30))) {
 589                if (val & AC97_PD_EAPD)
 590                        ac97->power_up &= ~(1 << (reg>>1));
 591                else
 592                        ac97->power_up |= 1 << (reg>>1);
 593                update_power_regs(ac97);
 594        }
 595#endif
 596        return err;
 597}
 598
 599static const struct snd_kcontrol_new snd_ac97_controls_tone[2] = {
 600AC97_SINGLE("Tone Control - Bass", AC97_MASTER_TONE, 8, 15, 1),
 601AC97_SINGLE("Tone Control - Treble", AC97_MASTER_TONE, 0, 15, 1)
 602};
 603
 604static const struct snd_kcontrol_new snd_ac97_controls_pc_beep[2] = {
 605AC97_SINGLE("Beep Playback Switch", AC97_PC_BEEP, 15, 1, 1),
 606AC97_SINGLE("Beep Playback Volume", AC97_PC_BEEP, 1, 15, 1)
 607};
 608
 609static const struct snd_kcontrol_new snd_ac97_controls_mic_boost =
 610        AC97_SINGLE("Mic Boost (+20dB)", AC97_MIC, 6, 1, 0);
 611
 612
 613static const char* std_rec_sel[] = {"Mic", "CD", "Video", "Aux", "Line", "Mix", "Mix Mono", "Phone"};
 614static const char* std_3d_path[] = {"pre 3D", "post 3D"};
 615static const char* std_mix[] = {"Mix", "Mic"};
 616static const char* std_mic[] = {"Mic1", "Mic2"};
 617
 618static const struct ac97_enum std_enum[] = {
 619AC97_ENUM_DOUBLE(AC97_REC_SEL, 8, 0, 8, std_rec_sel),
 620AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 15, 2, std_3d_path),
 621AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 9, 2, std_mix),
 622AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 8, 2, std_mic),
 623};
 624
 625static const struct snd_kcontrol_new snd_ac97_control_capture_src = 
 626AC97_ENUM("Capture Source", std_enum[0]); 
 627
 628static const struct snd_kcontrol_new snd_ac97_control_capture_vol =
 629AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 15, 0);
 630
 631static const struct snd_kcontrol_new snd_ac97_controls_mic_capture[2] = {
 632AC97_SINGLE("Mic Capture Switch", AC97_REC_GAIN_MIC, 15, 1, 1),
 633AC97_SINGLE("Mic Capture Volume", AC97_REC_GAIN_MIC, 0, 15, 0)
 634};
 635
 636enum {
 637        AC97_GENERAL_PCM_OUT = 0,
 638        AC97_GENERAL_STEREO_ENHANCEMENT,
 639        AC97_GENERAL_3D,
 640        AC97_GENERAL_LOUDNESS,
 641        AC97_GENERAL_MONO,
 642        AC97_GENERAL_MIC,
 643        AC97_GENERAL_LOOPBACK
 644};
 645
 646static const struct snd_kcontrol_new snd_ac97_controls_general[7] = {
 647AC97_ENUM("PCM Out Path & Mute", std_enum[1]),
 648AC97_SINGLE("Simulated Stereo Enhancement", AC97_GENERAL_PURPOSE, 14, 1, 0),
 649AC97_SINGLE("3D Control - Switch", AC97_GENERAL_PURPOSE, 13, 1, 0),
 650AC97_SINGLE("Loudness (bass boost)", AC97_GENERAL_PURPOSE, 12, 1, 0),
 651AC97_ENUM("Mono Output Select", std_enum[2]),
 652AC97_ENUM("Mic Select", std_enum[3]),
 653AC97_SINGLE("ADC/DAC Loopback", AC97_GENERAL_PURPOSE, 7, 1, 0)
 654};
 655
 656static const struct snd_kcontrol_new snd_ac97_controls_3d[2] = {
 657AC97_SINGLE("3D Control - Center", AC97_3D_CONTROL, 8, 15, 0),
 658AC97_SINGLE("3D Control - Depth", AC97_3D_CONTROL, 0, 15, 0)
 659};
 660
 661static const struct snd_kcontrol_new snd_ac97_controls_center[2] = {
 662AC97_SINGLE("Center Playback Switch", AC97_CENTER_LFE_MASTER, 7, 1, 1),
 663AC97_SINGLE("Center Playback Volume", AC97_CENTER_LFE_MASTER, 0, 31, 1)
 664};
 665
 666static const struct snd_kcontrol_new snd_ac97_controls_lfe[2] = {
 667AC97_SINGLE("LFE Playback Switch", AC97_CENTER_LFE_MASTER, 15, 1, 1),
 668AC97_SINGLE("LFE Playback Volume", AC97_CENTER_LFE_MASTER, 8, 31, 1)
 669};
 670
 671static const struct snd_kcontrol_new snd_ac97_control_eapd =
 672AC97_SINGLE("External Amplifier", AC97_POWERDOWN, 15, 1, 1);
 673
 674static const struct snd_kcontrol_new snd_ac97_controls_modem_switches[2] = {
 675AC97_SINGLE("Off-hook Switch", AC97_GPIO_STATUS, 0, 1, 0),
 676AC97_SINGLE("Caller ID Switch", AC97_GPIO_STATUS, 2, 1, 0)
 677};
 678
 679/* change the existing EAPD control as inverted */
 680static void set_inv_eapd(struct snd_ac97 *ac97, struct snd_kcontrol *kctl)
 681{
 682        kctl->private_value = AC97_SINGLE_VALUE(AC97_POWERDOWN, 15, 1, 0);
 683        snd_ac97_update_bits(ac97, AC97_POWERDOWN, (1<<15), (1<<15)); /* EAPD up */
 684        ac97->scaps |= AC97_SCAP_INV_EAPD;
 685}
 686
 687static int snd_ac97_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 688{
 689        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 690        uinfo->count = 1;
 691        return 0;
 692}
 693                        
 694static int snd_ac97_spdif_cmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 695{
 696        ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
 697                                           IEC958_AES0_NONAUDIO |
 698                                           IEC958_AES0_CON_EMPHASIS_5015 |
 699                                           IEC958_AES0_CON_NOT_COPYRIGHT;
 700        ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
 701                                           IEC958_AES1_CON_ORIGINAL;
 702        ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
 703        return 0;
 704}
 705                        
 706static int snd_ac97_spdif_pmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 707{
 708        /* FIXME: AC'97 spec doesn't say which bits are used for what */
 709        ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
 710                                           IEC958_AES0_NONAUDIO |
 711                                           IEC958_AES0_PRO_FS |
 712                                           IEC958_AES0_PRO_EMPHASIS_5015;
 713        return 0;
 714}
 715
 716static int snd_ac97_spdif_default_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 717{
 718        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 719
 720        mutex_lock(&ac97->reg_mutex);
 721        ucontrol->value.iec958.status[0] = ac97->spdif_status & 0xff;
 722        ucontrol->value.iec958.status[1] = (ac97->spdif_status >> 8) & 0xff;
 723        ucontrol->value.iec958.status[2] = (ac97->spdif_status >> 16) & 0xff;
 724        ucontrol->value.iec958.status[3] = (ac97->spdif_status >> 24) & 0xff;
 725        mutex_unlock(&ac97->reg_mutex);
 726        return 0;
 727}
 728                        
 729static int snd_ac97_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 730{
 731        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 732        unsigned int new = 0;
 733        unsigned short val = 0;
 734        int change;
 735
 736        new = val = ucontrol->value.iec958.status[0] & (IEC958_AES0_PROFESSIONAL|IEC958_AES0_NONAUDIO);
 737        if (ucontrol->value.iec958.status[0] & IEC958_AES0_PROFESSIONAL) {
 738                new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_PRO_FS|IEC958_AES0_PRO_EMPHASIS_5015);
 739                switch (new & IEC958_AES0_PRO_FS) {
 740                case IEC958_AES0_PRO_FS_44100: val |= 0<<12; break;
 741                case IEC958_AES0_PRO_FS_48000: val |= 2<<12; break;
 742                case IEC958_AES0_PRO_FS_32000: val |= 3<<12; break;
 743                default:                       val |= 1<<12; break;
 744                }
 745                if ((new & IEC958_AES0_PRO_EMPHASIS) == IEC958_AES0_PRO_EMPHASIS_5015)
 746                        val |= 1<<3;
 747        } else {
 748                new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT);
 749                new |= ((ucontrol->value.iec958.status[1] & (IEC958_AES1_CON_CATEGORY|IEC958_AES1_CON_ORIGINAL)) << 8);
 750                new |= ((ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) << 24);
 751                if ((new & IEC958_AES0_CON_EMPHASIS) == IEC958_AES0_CON_EMPHASIS_5015)
 752                        val |= 1<<3;
 753                if (!(new & IEC958_AES0_CON_NOT_COPYRIGHT))
 754                        val |= 1<<2;
 755                val |= ((new >> 8) & 0xff) << 4;        // category + original
 756                switch ((new >> 24) & 0xff) {
 757                case IEC958_AES3_CON_FS_44100: val |= 0<<12; break;
 758                case IEC958_AES3_CON_FS_48000: val |= 2<<12; break;
 759                case IEC958_AES3_CON_FS_32000: val |= 3<<12; break;
 760                default:                       val |= 1<<12; break;
 761                }
 762        }
 763
 764        mutex_lock(&ac97->reg_mutex);
 765        change = ac97->spdif_status != new;
 766        ac97->spdif_status = new;
 767
 768        if (ac97->flags & AC97_CS_SPDIF) {
 769                int x = (val >> 12) & 0x03;
 770                switch (x) {
 771                case 0: x = 1; break;  // 44.1
 772                case 2: x = 0; break;  // 48.0
 773                default: x = 0; break; // illegal.
 774                }
 775                change |= snd_ac97_update_bits_nolock(ac97, AC97_CSR_SPDIF, 0x3fff, ((val & 0xcfff) | (x << 12)));
 776        } else if (ac97->flags & AC97_CX_SPDIF) {
 777                int v;
 778                v = new & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT) ? 0 : AC97_CXR_COPYRGT;
 779                v |= new & IEC958_AES0_NONAUDIO ? AC97_CXR_SPDIF_AC3 : AC97_CXR_SPDIF_PCM;
 780                change |= snd_ac97_update_bits_nolock(ac97, AC97_CXR_AUDIO_MISC, 
 781                                                      AC97_CXR_SPDIF_MASK | AC97_CXR_COPYRGT,
 782                                                      v);
 783        } else if (ac97->id == AC97_ID_YMF743) {
 784                change |= snd_ac97_update_bits_nolock(ac97,
 785                                                      AC97_YMF7X3_DIT_CTRL,
 786                                                      0xff38,
 787                                                      ((val << 4) & 0xff00) |
 788                                                      ((val << 2) & 0x0038));
 789        } else {
 790                unsigned short extst = snd_ac97_read_cache(ac97, AC97_EXTENDED_STATUS);
 791                snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); /* turn off */
 792
 793                change |= snd_ac97_update_bits_nolock(ac97, AC97_SPDIF, 0x3fff, val);
 794                if (extst & AC97_EA_SPDIF) {
 795                        snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
 796                }
 797        }
 798        mutex_unlock(&ac97->reg_mutex);
 799
 800        return change;
 801}
 802
 803static int snd_ac97_put_spsa(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 804{
 805        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 806        int reg = kcontrol->private_value & 0xff;
 807        int shift = (kcontrol->private_value >> 8) & 0x0f;
 808        int mask = (kcontrol->private_value >> 16) & 0xff;
 809        // int invert = (kcontrol->private_value >> 24) & 0xff;
 810        unsigned short value, old, new;
 811        int change;
 812
 813        value = (ucontrol->value.integer.value[0] & mask);
 814
 815        mutex_lock(&ac97->reg_mutex);
 816        mask <<= shift;
 817        value <<= shift;
 818        old = snd_ac97_read_cache(ac97, reg);
 819        new = (old & ~mask) | value;
 820        change = old != new;
 821
 822        if (change) {
 823                unsigned short extst = snd_ac97_read_cache(ac97, AC97_EXTENDED_STATUS);
 824                snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); /* turn off */
 825                change = snd_ac97_update_bits_nolock(ac97, reg, mask, value);
 826                if (extst & AC97_EA_SPDIF)
 827                        snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
 828        }
 829        mutex_unlock(&ac97->reg_mutex);
 830        return change;
 831}
 832
 833static const struct snd_kcontrol_new snd_ac97_controls_spdif[5] = {
 834        {
 835                .access = SNDRV_CTL_ELEM_ACCESS_READ,
 836                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 837                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
 838                .info = snd_ac97_spdif_mask_info,
 839                .get = snd_ac97_spdif_cmask_get,
 840        },
 841        {
 842                .access = SNDRV_CTL_ELEM_ACCESS_READ,
 843                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 844                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
 845                .info = snd_ac97_spdif_mask_info,
 846                .get = snd_ac97_spdif_pmask_get,
 847        },
 848        {
 849                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 850                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 851                .info = snd_ac97_spdif_mask_info,
 852                .get = snd_ac97_spdif_default_get,
 853                .put = snd_ac97_spdif_default_put,
 854        },
 855
 856        AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),AC97_EXTENDED_STATUS, 2, 1, 0),
 857        {
 858                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 859                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA",
 860                .info = snd_ac97_info_volsw,
 861                .get = snd_ac97_get_volsw,
 862                .put = snd_ac97_put_spsa,
 863                .private_value = AC97_SINGLE_VALUE(AC97_EXTENDED_STATUS, 4, 3, 0)
 864        },
 865};
 866
 867#define AD18XX_PCM_BITS(xname, codec, lshift, rshift, mask) \
 868{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_ad18xx_pcm_info_bits, \
 869  .get = snd_ac97_ad18xx_pcm_get_bits, .put = snd_ac97_ad18xx_pcm_put_bits, \
 870  .private_value = (codec) | ((lshift) << 8) | ((rshift) << 12) | ((mask) << 16) }
 871
 872static int snd_ac97_ad18xx_pcm_info_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 873{
 874        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 875        int mask = (kcontrol->private_value >> 16) & 0x0f;
 876        int lshift = (kcontrol->private_value >> 8) & 0x0f;
 877        int rshift = (kcontrol->private_value >> 12) & 0x0f;
 878
 879        uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
 880        if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
 881                uinfo->count = 2;
 882        else
 883                uinfo->count = 1;
 884        uinfo->value.integer.min = 0;
 885        uinfo->value.integer.max = mask;
 886        return 0;
 887}
 888
 889static int snd_ac97_ad18xx_pcm_get_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 890{
 891        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 892        int codec = kcontrol->private_value & 3;
 893        int lshift = (kcontrol->private_value >> 8) & 0x0f;
 894        int rshift = (kcontrol->private_value >> 12) & 0x0f;
 895        int mask = (kcontrol->private_value >> 16) & 0xff;
 896        
 897        ucontrol->value.integer.value[0] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> lshift) & mask);
 898        if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
 899                ucontrol->value.integer.value[1] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> rshift) & mask);
 900        return 0;
 901}
 902
 903static int snd_ac97_ad18xx_pcm_put_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 904{
 905        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 906        int codec = kcontrol->private_value & 3;
 907        int lshift = (kcontrol->private_value >> 8) & 0x0f;
 908        int rshift = (kcontrol->private_value >> 12) & 0x0f;
 909        int mask = (kcontrol->private_value >> 16) & 0xff;
 910        unsigned short val, valmask;
 911        
 912        val = (mask - (ucontrol->value.integer.value[0] & mask)) << lshift;
 913        valmask = mask << lshift;
 914        if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES)) {
 915                val |= (mask - (ucontrol->value.integer.value[1] & mask)) << rshift;
 916                valmask |= mask << rshift;
 917        }
 918        return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, valmask, val);
 919}
 920
 921#define AD18XX_PCM_VOLUME(xname, codec) \
 922{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_ad18xx_pcm_info_volume, \
 923  .get = snd_ac97_ad18xx_pcm_get_volume, .put = snd_ac97_ad18xx_pcm_put_volume, \
 924  .private_value = codec }
 925
 926static int snd_ac97_ad18xx_pcm_info_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 927{
 928        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 929        uinfo->count = 2;
 930        uinfo->value.integer.min = 0;
 931        uinfo->value.integer.max = 31;
 932        return 0;
 933}
 934
 935static int snd_ac97_ad18xx_pcm_get_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 936{
 937        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 938        int codec = kcontrol->private_value & 3;
 939        
 940        mutex_lock(&ac97->page_mutex);
 941        ucontrol->value.integer.value[0] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 0) & 31);
 942        ucontrol->value.integer.value[1] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 8) & 31);
 943        mutex_unlock(&ac97->page_mutex);
 944        return 0;
 945}
 946
 947static int snd_ac97_ad18xx_pcm_put_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 948{
 949        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
 950        int codec = kcontrol->private_value & 3;
 951        unsigned short val1, val2;
 952        
 953        val1 = 31 - (ucontrol->value.integer.value[0] & 31);
 954        val2 = 31 - (ucontrol->value.integer.value[1] & 31);
 955        return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, 0x1f1f, (val1 << 8) | val2);
 956}
 957
 958static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_pcm[2] = {
 959AD18XX_PCM_BITS("PCM Playback Switch", 0, 15, 7, 1),
 960AD18XX_PCM_VOLUME("PCM Playback Volume", 0)
 961};
 962
 963static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_surround[2] = {
 964AD18XX_PCM_BITS("Surround Playback Switch", 1, 15, 7, 1),
 965AD18XX_PCM_VOLUME("Surround Playback Volume", 1)
 966};
 967
 968static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_center[2] = {
 969AD18XX_PCM_BITS("Center Playback Switch", 2, 15, 15, 1),
 970AD18XX_PCM_BITS("Center Playback Volume", 2, 8, 8, 31)
 971};
 972
 973static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_lfe[2] = {
 974AD18XX_PCM_BITS("LFE Playback Switch", 2, 7, 7, 1),
 975AD18XX_PCM_BITS("LFE Playback Volume", 2, 0, 0, 31)
 976};
 977
 978/*
 979 *
 980 */
 981
 982static void snd_ac97_powerdown(struct snd_ac97 *ac97);
 983
 984static int snd_ac97_bus_free(struct snd_ac97_bus *bus)
 985{
 986        if (bus) {
 987                snd_ac97_bus_proc_done(bus);
 988                kfree(bus->pcms);
 989                if (bus->private_free)
 990                        bus->private_free(bus);
 991                kfree(bus);
 992        }
 993        return 0;
 994}
 995
 996static int snd_ac97_bus_dev_free(struct snd_device *device)
 997{
 998        struct snd_ac97_bus *bus = device->device_data;
 999        return snd_ac97_bus_free(bus);
1000}
1001
1002static int snd_ac97_free(struct snd_ac97 *ac97)
1003{
1004        if (ac97) {
1005#ifdef CONFIG_SND_AC97_POWER_SAVE
1006                cancel_delayed_work_sync(&ac97->power_work);
1007#endif
1008                snd_ac97_proc_done(ac97);
1009                if (ac97->bus)
1010                        ac97->bus->codec[ac97->num] = NULL;
1011                if (ac97->private_free)
1012                        ac97->private_free(ac97);
1013                kfree(ac97);
1014        }
1015        return 0;
1016}
1017
1018static int snd_ac97_dev_free(struct snd_device *device)
1019{
1020        struct snd_ac97 *ac97 = device->device_data;
1021        snd_ac97_powerdown(ac97); /* for avoiding click noises during shut down */
1022        return snd_ac97_free(ac97);
1023}
1024
1025static int snd_ac97_try_volume_mix(struct snd_ac97 * ac97, int reg)
1026{
1027        unsigned short val, mask = AC97_MUTE_MASK_MONO;
1028
1029        if (! snd_ac97_valid_reg(ac97, reg))
1030                return 0;
1031
1032        switch (reg) {
1033        case AC97_MASTER_TONE:
1034                return ac97->caps & AC97_BC_BASS_TREBLE ? 1 : 0;
1035        case AC97_HEADPHONE:
1036                return ac97->caps & AC97_BC_HEADPHONE ? 1 : 0;
1037        case AC97_REC_GAIN_MIC:
1038                return ac97->caps & AC97_BC_DEDICATED_MIC ? 1 : 0;
1039        case AC97_3D_CONTROL:
1040                if (ac97->caps & AC97_BC_3D_TECH_ID_MASK) {
1041                        val = snd_ac97_read(ac97, reg);
1042                        /* if nonzero - fixed and we can't set it */
1043                        return val == 0;
1044                }
1045                return 0;
1046        case AC97_CENTER_LFE_MASTER:    /* center */
1047                if ((ac97->ext_id & AC97_EI_CDAC) == 0)
1048                        return 0;
1049                break;
1050        case AC97_CENTER_LFE_MASTER+1:  /* lfe */
1051                if ((ac97->ext_id & AC97_EI_LDAC) == 0)
1052                        return 0;
1053                reg = AC97_CENTER_LFE_MASTER;
1054                mask = 0x0080;
1055                break;
1056        case AC97_SURROUND_MASTER:
1057                if ((ac97->ext_id & AC97_EI_SDAC) == 0)
1058                        return 0;
1059                break;
1060        }
1061
1062        val = snd_ac97_read(ac97, reg);
1063        if (!(val & mask)) {
1064                /* nothing seems to be here - mute flag is not set */
1065                /* try another test */
1066                snd_ac97_write_cache(ac97, reg, val | mask);
1067                val = snd_ac97_read(ac97, reg);
1068                val = snd_ac97_read(ac97, reg);
1069                if (!(val & mask))
1070                        return 0;       /* nothing here */
1071        }
1072        return 1;               /* success, useable */
1073}
1074
1075static void check_volume_resolution(struct snd_ac97 *ac97, int reg, unsigned char *lo_max, unsigned char *hi_max)
1076{
1077        unsigned short cbit[3] = { 0x20, 0x10, 0x01 };
1078        unsigned char max[3] = { 63, 31, 15 };
1079        int i;
1080
1081        /* first look up the static resolution table */
1082        if (ac97->res_table) {
1083                const struct snd_ac97_res_table *tbl;
1084                for (tbl = ac97->res_table; tbl->reg; tbl++) {
1085                        if (tbl->reg == reg) {
1086                                *lo_max = tbl->bits & 0xff;
1087                                *hi_max = (tbl->bits >> 8) & 0xff;
1088                                return;
1089                        }
1090                }
1091        }
1092
1093        *lo_max = *hi_max = 0;
1094        for (i = 0 ; i < ARRAY_SIZE(cbit); i++) {
1095                unsigned short val;
1096                snd_ac97_write(
1097                        ac97, reg,
1098                        AC97_MUTE_MASK_STEREO | cbit[i] | (cbit[i] << 8)
1099                );
1100                /* Do the read twice due to buffers on some ac97 codecs.
1101                 * e.g. The STAC9704 returns exactly what you wrote to the register
1102                 * if you read it immediately. This causes the detect routine to fail.
1103                 */
1104                val = snd_ac97_read(ac97, reg);
1105                val = snd_ac97_read(ac97, reg);
1106                if (! *lo_max && (val & 0x7f) == cbit[i])
1107                        *lo_max = max[i];
1108                if (! *hi_max && ((val >> 8) & 0x7f) == cbit[i])
1109                        *hi_max = max[i];
1110                if (*lo_max && *hi_max)
1111                        break;
1112        }
1113}
1114
1115static int snd_ac97_try_bit(struct snd_ac97 * ac97, int reg, int bit)
1116{
1117        unsigned short mask, val, orig, res;
1118
1119        mask = 1 << bit;
1120        orig = snd_ac97_read(ac97, reg);
1121        val = orig ^ mask;
1122        snd_ac97_write(ac97, reg, val);
1123        res = snd_ac97_read(ac97, reg);
1124        snd_ac97_write_cache(ac97, reg, orig);
1125        return res == val;
1126}
1127
1128/* check the volume resolution of center/lfe */
1129static void snd_ac97_change_volume_params2(struct snd_ac97 * ac97, int reg, int shift, unsigned char *max)
1130{
1131        unsigned short val, val1;
1132
1133        *max = 63;
1134        val = AC97_MUTE_MASK_STEREO | (0x20 << shift);
1135        snd_ac97_write(ac97, reg, val);
1136        val1 = snd_ac97_read(ac97, reg);
1137        if (val != val1) {
1138                *max = 31;
1139        }
1140        /* reset volume to zero */
1141        snd_ac97_write_cache(ac97, reg, AC97_MUTE_MASK_STEREO);
1142}
1143
1144static inline int printable(unsigned int x)
1145{
1146        x &= 0xff;
1147        if (x < ' ' || x >= 0x71) {
1148                if (x <= 0x89)
1149                        return x - 0x71 + 'A';
1150                return '?';
1151        }
1152        return x;
1153}
1154
1155static struct snd_kcontrol *snd_ac97_cnew(const struct snd_kcontrol_new *_template,
1156                                          struct snd_ac97 * ac97)
1157{
1158        struct snd_kcontrol_new template;
1159        memcpy(&template, _template, sizeof(template));
1160        template.index = ac97->num;
1161        return snd_ctl_new1(&template, ac97);
1162}
1163
1164/*
1165 * create mute switch(es) for normal stereo controls
1166 */
1167static int snd_ac97_cmute_new_stereo(struct snd_card *card, char *name, int reg,
1168                                     int check_stereo, int check_amix,
1169                                     struct snd_ac97 *ac97)
1170{
1171        struct snd_kcontrol *kctl;
1172        int err;
1173        unsigned short val, val1, mute_mask;
1174
1175        if (! snd_ac97_valid_reg(ac97, reg))
1176                return 0;
1177
1178        mute_mask = AC97_MUTE_MASK_MONO;
1179        val = snd_ac97_read(ac97, reg);
1180        if (check_stereo || (ac97->flags & AC97_STEREO_MUTES)) {
1181                /* check whether both mute bits work */
1182                val1 = val | AC97_MUTE_MASK_STEREO;
1183                snd_ac97_write(ac97, reg, val1);
1184                if (val1 == snd_ac97_read(ac97, reg))
1185                        mute_mask = AC97_MUTE_MASK_STEREO;
1186        }
1187        if (mute_mask == AC97_MUTE_MASK_STEREO) {
1188                struct snd_kcontrol_new tmp = AC97_DOUBLE(name, reg, 15, 7, 1, 1);
1189                if (check_amix)
1190                        tmp.private_value |= (1 << 30);
1191                tmp.index = ac97->num;
1192                kctl = snd_ctl_new1(&tmp, ac97);
1193        } else {
1194                struct snd_kcontrol_new tmp = AC97_SINGLE(name, reg, 15, 1, 1);
1195                if (check_amix)
1196                        tmp.private_value |= (1 << 30);
1197                tmp.index = ac97->num;
1198                kctl = snd_ctl_new1(&tmp, ac97);
1199        }
1200        err = snd_ctl_add(card, kctl);
1201        if (err < 0)
1202                return err;
1203        /* mute as default */
1204        snd_ac97_write_cache(ac97, reg, val | mute_mask);
1205        return 0;
1206}
1207
1208/*
1209 * set dB information
1210 */
1211static const DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
1212static const DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0);
1213static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
1214static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
1215static const DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
1216
1217static const unsigned int *find_db_scale(unsigned int maxval)
1218{
1219        switch (maxval) {
1220        case 0x0f: return db_scale_4bit;
1221        case 0x1f: return db_scale_5bit;
1222        case 0x3f: return db_scale_6bit;
1223        }
1224        return NULL;
1225}
1226
1227static void set_tlv_db_scale(struct snd_kcontrol *kctl, const unsigned int *tlv)
1228{
1229        kctl->tlv.p = tlv;
1230        if (tlv)
1231                kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1232}
1233
1234/*
1235 * create a volume for normal stereo/mono controls
1236 */
1237static int snd_ac97_cvol_new(struct snd_card *card, char *name, int reg, unsigned int lo_max,
1238                             unsigned int hi_max, struct snd_ac97 *ac97)
1239{
1240        int err;
1241        struct snd_kcontrol *kctl;
1242
1243        if (! snd_ac97_valid_reg(ac97, reg))
1244                return 0;
1245        if (hi_max) {
1246                /* invert */
1247                struct snd_kcontrol_new tmp = AC97_DOUBLE(name, reg, 8, 0, lo_max, 1);
1248                tmp.index = ac97->num;
1249                kctl = snd_ctl_new1(&tmp, ac97);
1250        } else {
1251                /* invert */
1252                struct snd_kcontrol_new tmp = AC97_SINGLE(name, reg, 0, lo_max, 1);
1253                tmp.index = ac97->num;
1254                kctl = snd_ctl_new1(&tmp, ac97);
1255        }
1256        if (!kctl)
1257                return -ENOMEM;
1258        if (reg >= AC97_PHONE && reg <= AC97_PCM)
1259                set_tlv_db_scale(kctl, db_scale_5bit_12db_max);
1260        else
1261                set_tlv_db_scale(kctl, find_db_scale(lo_max));
1262        err = snd_ctl_add(card, kctl);
1263        if (err < 0)
1264                return err;
1265        snd_ac97_write_cache(
1266                ac97, reg,
1267                (snd_ac97_read(ac97, reg) & AC97_MUTE_MASK_STEREO)
1268                | lo_max | (hi_max << 8)
1269        );
1270        return 0;
1271}
1272
1273/*
1274 * create a mute-switch and a volume for normal stereo/mono controls
1275 */
1276static int snd_ac97_cmix_new_stereo(struct snd_card *card, const char *pfx,
1277                                    int reg, int check_stereo, int check_amix,
1278                                    struct snd_ac97 *ac97)
1279{
1280        int err;
1281        char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1282        unsigned char lo_max, hi_max;
1283
1284        if (! snd_ac97_valid_reg(ac97, reg))
1285                return 0;
1286
1287        if (snd_ac97_try_bit(ac97, reg, 15)) {
1288                sprintf(name, "%s Switch", pfx);
1289                err = snd_ac97_cmute_new_stereo(card, name, reg,
1290                                                check_stereo, check_amix,
1291                                                ac97);
1292                if (err < 0)
1293                        return err;
1294        }
1295        check_volume_resolution(ac97, reg, &lo_max, &hi_max);
1296        if (lo_max) {
1297                sprintf(name, "%s Volume", pfx);
1298                err = snd_ac97_cvol_new(card, name, reg, lo_max, hi_max, ac97);
1299                if (err < 0)
1300                        return err;
1301        }
1302        return 0;
1303}
1304
1305#define snd_ac97_cmix_new(card, pfx, reg, acheck, ac97) \
1306        snd_ac97_cmix_new_stereo(card, pfx, reg, 0, acheck, ac97)
1307#define snd_ac97_cmute_new(card, name, reg, acheck, ac97) \
1308        snd_ac97_cmute_new_stereo(card, name, reg, 0, acheck, ac97)
1309
1310static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97);
1311
1312static int snd_ac97_mixer_build(struct snd_ac97 * ac97)
1313{
1314        struct snd_card *card = ac97->bus->card;
1315        struct snd_kcontrol *kctl;
1316        int err;
1317        unsigned int idx;
1318        unsigned char max;
1319
1320        /* build master controls */
1321        /* AD claims to remove this control from AD1887, although spec v2.2 does not allow this */
1322        if (snd_ac97_try_volume_mix(ac97, AC97_MASTER)) {
1323                if (ac97->flags & AC97_HAS_NO_MASTER_VOL)
1324                        err = snd_ac97_cmute_new(card, "Master Playback Switch",
1325                                                 AC97_MASTER, 0, ac97);
1326                else
1327                        err = snd_ac97_cmix_new(card, "Master Playback",
1328                                                AC97_MASTER, 0, ac97);
1329                if (err < 0)
1330                        return err;
1331        }
1332
1333        ac97->regs[AC97_CENTER_LFE_MASTER] = AC97_MUTE_MASK_STEREO;
1334
1335        /* build center controls */
1336        if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER)) 
1337                && !(ac97->flags & AC97_AD_MULTI)) {
1338                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_center[0], ac97));
1339                if (err < 0)
1340                        return err;
1341                err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_center[1], ac97));
1342                if (err < 0)
1343                        return err;
1344                snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 0, &max);
1345                kctl->private_value &= ~(0xff << 16);
1346                kctl->private_value |= (int)max << 16;
1347                set_tlv_db_scale(kctl, find_db_scale(max));
1348                snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max);
1349        }
1350
1351        /* build LFE controls */
1352        if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1))
1353                && !(ac97->flags & AC97_AD_MULTI)) {
1354                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_lfe[0], ac97));
1355                if (err < 0)
1356                        return err;
1357                err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_lfe[1], ac97));
1358                if (err < 0)
1359                        return err;
1360                snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 8, &max);
1361                kctl->private_value &= ~(0xff << 16);
1362                kctl->private_value |= (int)max << 16;
1363                set_tlv_db_scale(kctl, find_db_scale(max));
1364                snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max << 8);
1365        }
1366
1367        /* build surround controls */
1368        if ((snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER)) 
1369                && !(ac97->flags & AC97_AD_MULTI)) {
1370                /* Surround Master (0x38) is with stereo mutes */
1371                err = snd_ac97_cmix_new_stereo(card, "Surround Playback",
1372                                               AC97_SURROUND_MASTER, 1, 0,
1373                                               ac97);
1374                if (err < 0)
1375                        return err;
1376        }
1377
1378        /* build headphone controls */
1379        if (snd_ac97_try_volume_mix(ac97, AC97_HEADPHONE)) {
1380                err = snd_ac97_cmix_new(card, "Headphone Playback",
1381                                        AC97_HEADPHONE, 0, ac97);
1382                if (err < 0)
1383                        return err;
1384        }
1385        
1386        /* build master mono controls */
1387        if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_MONO)) {
1388                err = snd_ac97_cmix_new(card, "Master Mono Playback",
1389                                        AC97_MASTER_MONO, 0, ac97);
1390                if (err < 0)
1391                        return err;
1392        }
1393        
1394        /* build master tone controls */
1395        if (!(ac97->flags & AC97_HAS_NO_TONE)) {
1396                if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_TONE)) {
1397                        for (idx = 0; idx < 2; idx++) {
1398                                kctl = snd_ac97_cnew(&snd_ac97_controls_tone[idx], ac97);
1399                                err = snd_ctl_add(card, kctl);
1400                                if (err < 0)
1401                                        return err;
1402                                if (ac97->id == AC97_ID_YMF743 ||
1403                                    ac97->id == AC97_ID_YMF753) {
1404                                        kctl->private_value &= ~(0xff << 16);
1405                                        kctl->private_value |= 7 << 16;
1406                                }
1407                        }
1408                        snd_ac97_write_cache(ac97, AC97_MASTER_TONE, 0x0f0f);
1409                }
1410        }
1411        
1412        /* build Beep controls */
1413        if (!(ac97->flags & AC97_HAS_NO_PC_BEEP) && 
1414                ((ac97->flags & AC97_HAS_PC_BEEP) ||
1415            snd_ac97_try_volume_mix(ac97, AC97_PC_BEEP))) {
1416                for (idx = 0; idx < 2; idx++) {
1417                        kctl = snd_ac97_cnew(&snd_ac97_controls_pc_beep[idx], ac97);
1418                        err = snd_ctl_add(card, kctl);
1419                        if (err < 0)
1420                                return err;
1421                }
1422                set_tlv_db_scale(kctl, db_scale_4bit);
1423                snd_ac97_write_cache(
1424                        ac97,
1425                        AC97_PC_BEEP,
1426                        (snd_ac97_read(ac97, AC97_PC_BEEP)
1427                                | AC97_MUTE_MASK_MONO | 0x001e)
1428                );
1429        }
1430        
1431        /* build Phone controls */
1432        if (!(ac97->flags & AC97_HAS_NO_PHONE)) {
1433                if (snd_ac97_try_volume_mix(ac97, AC97_PHONE)) {
1434                        err = snd_ac97_cmix_new(card, "Phone Playback",
1435                                                AC97_PHONE, 1, ac97);
1436                        if (err < 0)
1437                                return err;
1438                }
1439        }
1440        
1441        /* build MIC controls */
1442        if (!(ac97->flags & AC97_HAS_NO_MIC)) {
1443                if (snd_ac97_try_volume_mix(ac97, AC97_MIC)) {
1444                        err = snd_ac97_cmix_new(card, "Mic Playback",
1445                                                AC97_MIC, 1, ac97);
1446                        if (err < 0)
1447                                return err;
1448                        err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_boost, ac97));
1449                        if (err < 0)
1450                                return err;
1451                }
1452        }
1453
1454        /* build Line controls */
1455        if (snd_ac97_try_volume_mix(ac97, AC97_LINE)) {
1456                err = snd_ac97_cmix_new(card, "Line Playback",
1457                                        AC97_LINE, 1, ac97);
1458                if (err < 0)
1459                        return err;
1460        }
1461        
1462        /* build CD controls */
1463        if (!(ac97->flags & AC97_HAS_NO_CD)) {
1464                if (snd_ac97_try_volume_mix(ac97, AC97_CD)) {
1465                        err = snd_ac97_cmix_new(card, "CD Playback",
1466                                                AC97_CD, 1, ac97);
1467                        if (err < 0)
1468                                return err;
1469                }
1470        }
1471        
1472        /* build Video controls */
1473        if (!(ac97->flags & AC97_HAS_NO_VIDEO)) {
1474                if (snd_ac97_try_volume_mix(ac97, AC97_VIDEO)) {
1475                        err = snd_ac97_cmix_new(card, "Video Playback",
1476                                                AC97_VIDEO, 1, ac97);
1477                        if (err < 0)
1478                                return err;
1479                }
1480        }
1481
1482        /* build Aux controls */
1483        if (!(ac97->flags & AC97_HAS_NO_AUX)) {
1484                if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
1485                        err = snd_ac97_cmix_new(card, "Aux Playback",
1486                                                AC97_AUX, 1, ac97);
1487                        if (err < 0)
1488                                return err;
1489                }
1490        }
1491
1492        /* build PCM controls */
1493        if (ac97->flags & AC97_AD_MULTI) {
1494                unsigned short init_val;
1495                if (ac97->flags & AC97_STEREO_MUTES)
1496                        init_val = 0x9f9f;
1497                else
1498                        init_val = 0x9f1f;
1499                for (idx = 0; idx < 2; idx++) {
1500                        kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_pcm[idx], ac97);
1501                        err = snd_ctl_add(card, kctl);
1502                        if (err < 0)
1503                                return err;
1504                }
1505                set_tlv_db_scale(kctl, db_scale_5bit);
1506                ac97->spec.ad18xx.pcmreg[0] = init_val;
1507                if (ac97->scaps & AC97_SCAP_SURROUND_DAC) {
1508                        for (idx = 0; idx < 2; idx++) {
1509                                kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_surround[idx], ac97);
1510                                err = snd_ctl_add(card, kctl);
1511                                if (err < 0)
1512                                        return err;
1513                        }
1514                        set_tlv_db_scale(kctl, db_scale_5bit);
1515                        ac97->spec.ad18xx.pcmreg[1] = init_val;
1516                }
1517                if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) {
1518                        for (idx = 0; idx < 2; idx++) {
1519                                kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_center[idx], ac97);
1520                                err = snd_ctl_add(card, kctl);
1521                                if (err < 0)
1522                                        return err;
1523                        }
1524                        set_tlv_db_scale(kctl, db_scale_5bit);
1525                        for (idx = 0; idx < 2; idx++) {
1526                                kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_lfe[idx], ac97);
1527                                err = snd_ctl_add(card, kctl);
1528                                if (err < 0)
1529                                        return err;
1530                        }
1531                        set_tlv_db_scale(kctl, db_scale_5bit);
1532                        ac97->spec.ad18xx.pcmreg[2] = init_val;
1533                }
1534                snd_ac97_write_cache(ac97, AC97_PCM, init_val);
1535        } else {
1536                if (!(ac97->flags & AC97_HAS_NO_STD_PCM)) {
1537                        if (ac97->flags & AC97_HAS_NO_PCM_VOL)
1538                                err = snd_ac97_cmute_new(card,
1539                                                         "PCM Playback Switch",
1540                                                         AC97_PCM, 0, ac97);
1541                        else
1542                                err = snd_ac97_cmix_new(card, "PCM Playback",
1543                                                        AC97_PCM, 0, ac97);
1544                        if (err < 0)
1545                                return err;
1546                }
1547        }
1548
1549        /* build Capture controls */
1550        if (!(ac97->flags & AC97_HAS_NO_REC_GAIN)) {
1551                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_src, ac97));
1552                if (err < 0)
1553                        return err;
1554                if (snd_ac97_try_bit(ac97, AC97_REC_GAIN, 15)) {
1555                        err = snd_ac97_cmute_new(card, "Capture Switch",
1556                                                 AC97_REC_GAIN, 0, ac97);
1557                        if (err < 0)
1558                                return err;
1559                }
1560                kctl = snd_ac97_cnew(&snd_ac97_control_capture_vol, ac97);
1561                err = snd_ctl_add(card, kctl);
1562                if (err < 0)
1563                        return err;
1564                set_tlv_db_scale(kctl, db_scale_rec_gain);
1565                snd_ac97_write_cache(ac97, AC97_REC_SEL, 0x0000);
1566                snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x0000);
1567        }
1568        /* build MIC Capture controls */
1569        if (snd_ac97_try_volume_mix(ac97, AC97_REC_GAIN_MIC)) {
1570                for (idx = 0; idx < 2; idx++) {
1571                        kctl = snd_ac97_cnew(&snd_ac97_controls_mic_capture[idx], ac97);
1572                        err = snd_ctl_add(card, kctl);
1573                        if (err < 0)
1574                                return err;
1575                }
1576                set_tlv_db_scale(kctl, db_scale_rec_gain);
1577                snd_ac97_write_cache(ac97, AC97_REC_GAIN_MIC, 0x0000);
1578        }
1579
1580        /* build PCM out path & mute control */
1581        if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 15)) {
1582                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_PCM_OUT], ac97));
1583                if (err < 0)
1584                        return err;
1585        }
1586
1587        /* build Simulated Stereo Enhancement control */
1588        if (ac97->caps & AC97_BC_SIM_STEREO) {
1589                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_STEREO_ENHANCEMENT], ac97));
1590                if (err < 0)
1591                        return err;
1592        }
1593
1594        /* build 3D Stereo Enhancement control */
1595        if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 13)) {
1596                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_3D], ac97));
1597                if (err < 0)
1598                        return err;
1599        }
1600
1601        /* build Loudness control */
1602        if (ac97->caps & AC97_BC_LOUDNESS) {
1603                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOUDNESS], ac97));
1604                if (err < 0)
1605                        return err;
1606        }
1607
1608        /* build Mono output select control */
1609        if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 9)) {
1610                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MONO], ac97));
1611                if (err < 0)
1612                        return err;
1613        }
1614
1615        /* build Mic select control */
1616        if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 8)) {
1617                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MIC], ac97));
1618                if (err < 0)
1619                        return err;
1620        }
1621
1622        /* build ADC/DAC loopback control */
1623        if (enable_loopback && snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 7)) {
1624                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOOPBACK], ac97));
1625                if (err < 0)
1626                        return err;
1627        }
1628
1629        snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, ~AC97_GP_DRSS_MASK, 0x0000);
1630
1631        /* build 3D controls */
1632        if (ac97->build_ops->build_3d) {
1633                ac97->build_ops->build_3d(ac97);
1634        } else {
1635                if (snd_ac97_try_volume_mix(ac97, AC97_3D_CONTROL)) {
1636                        unsigned short val;
1637                        val = 0x0707;
1638                        snd_ac97_write(ac97, AC97_3D_CONTROL, val);
1639                        val = snd_ac97_read(ac97, AC97_3D_CONTROL);
1640                        val = val == 0x0606;
1641                        kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97);
1642                        err = snd_ctl_add(card, kctl);
1643                        if (err < 0)
1644                                return err;
1645                        if (val)
1646                                kctl->private_value = AC97_3D_CONTROL | (9 << 8) | (7 << 16);
1647                        kctl = snd_ac97_cnew(&snd_ac97_controls_3d[1], ac97);
1648                        err = snd_ctl_add(card, kctl);
1649                        if (err < 0)
1650                                return err;
1651                        if (val)
1652                                kctl->private_value = AC97_3D_CONTROL | (1 << 8) | (7 << 16);
1653                        snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
1654                }
1655        }
1656
1657        /* build S/PDIF controls */
1658
1659        /* Hack for ASUS P5P800-VM, which does not indicate S/PDIF capability */
1660        if (ac97->subsystem_vendor == 0x1043 &&
1661            ac97->subsystem_device == 0x810f)
1662                ac97->ext_id |= AC97_EI_SPDIF;
1663
1664        if ((ac97->ext_id & AC97_EI_SPDIF) && !(ac97->scaps & AC97_SCAP_NO_SPDIF)) {
1665                if (ac97->build_ops->build_spdif) {
1666                        err = ac97->build_ops->build_spdif(ac97);
1667                        if (err < 0)
1668                                return err;
1669                } else {
1670                        for (idx = 0; idx < 5; idx++) {
1671                                err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_spdif[idx], ac97));
1672                                if (err < 0)
1673                                        return err;
1674                        }
1675                        if (ac97->build_ops->build_post_spdif) {
1676                                err = ac97->build_ops->build_post_spdif(ac97);
1677                                if (err < 0)
1678                                        return err;
1679                        }
1680                        /* set default PCM S/PDIF params */
1681                        /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
1682                        snd_ac97_write_cache(ac97, AC97_SPDIF, 0x2a20);
1683                        ac97->rates[AC97_RATES_SPDIF] = snd_ac97_determine_spdif_rates(ac97);
1684                }
1685                ac97->spdif_status = SNDRV_PCM_DEFAULT_CON_SPDIF;
1686        }
1687        
1688        /* build chip specific controls */
1689        if (ac97->build_ops->build_specific) {
1690                err = ac97->build_ops->build_specific(ac97);
1691                if (err < 0)
1692                        return err;
1693        }
1694
1695        if (snd_ac97_try_bit(ac97, AC97_POWERDOWN, 15)) {
1696                kctl = snd_ac97_cnew(&snd_ac97_control_eapd, ac97);
1697                if (! kctl)
1698                        return -ENOMEM;
1699                if (ac97->scaps & AC97_SCAP_INV_EAPD)
1700                        set_inv_eapd(ac97, kctl);
1701                err = snd_ctl_add(card, kctl);
1702                if (err < 0)
1703                        return err;
1704        }
1705
1706        return 0;
1707}
1708
1709static int snd_ac97_modem_build(struct snd_card *card, struct snd_ac97 * ac97)
1710{
1711        int err, idx;
1712
1713        /*
1714        ac97_dbg(ac97, "AC97_GPIO_CFG = %x\n",
1715               snd_ac97_read(ac97,AC97_GPIO_CFG));
1716        */
1717        snd_ac97_write(ac97, AC97_GPIO_CFG, 0xffff & ~(AC97_GPIO_LINE1_OH));
1718        snd_ac97_write(ac97, AC97_GPIO_POLARITY, 0xffff & ~(AC97_GPIO_LINE1_OH));
1719        snd_ac97_write(ac97, AC97_GPIO_STICKY, 0xffff);
1720        snd_ac97_write(ac97, AC97_GPIO_WAKEUP, 0x0);
1721        snd_ac97_write(ac97, AC97_MISC_AFE, 0x0);
1722
1723        /* build modem switches */
1724        for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_modem_switches); idx++) {
1725                err = snd_ctl_add(card, snd_ctl_new1(&snd_ac97_controls_modem_switches[idx], ac97));
1726                if (err < 0)
1727                        return err;
1728        }
1729
1730        /* build chip specific controls */
1731        if (ac97->build_ops->build_specific) {
1732                err = ac97->build_ops->build_specific(ac97);
1733                if (err < 0)
1734                        return err;
1735        }
1736
1737        return 0;
1738}
1739
1740static int snd_ac97_test_rate(struct snd_ac97 *ac97, int reg, int shadow_reg, int rate)
1741{
1742        unsigned short val;
1743        unsigned int tmp;
1744
1745        tmp = ((unsigned int)rate * ac97->bus->clock) / 48000;
1746        snd_ac97_write_cache(ac97, reg, tmp & 0xffff);
1747        if (shadow_reg)
1748                snd_ac97_write_cache(ac97, shadow_reg, tmp & 0xffff);
1749        val = snd_ac97_read(ac97, reg);
1750        return val == (tmp & 0xffff);
1751}
1752
1753static void snd_ac97_determine_rates(struct snd_ac97 *ac97, int reg, int shadow_reg, unsigned int *r_result)
1754{
1755        unsigned int result = 0;
1756        unsigned short saved;
1757
1758        if (ac97->bus->no_vra) {
1759                *r_result = SNDRV_PCM_RATE_48000;
1760                if ((ac97->flags & AC97_DOUBLE_RATE) &&
1761                    reg == AC97_PCM_FRONT_DAC_RATE)
1762                        *r_result |= SNDRV_PCM_RATE_96000;
1763                return;
1764        }
1765
1766        saved = snd_ac97_read(ac97, reg);
1767        if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE)
1768                snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1769                                     AC97_EA_DRA, 0);
1770        /* test a non-standard rate */
1771        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11000))
1772                result |= SNDRV_PCM_RATE_CONTINUOUS;
1773        /* let's try to obtain standard rates */
1774        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 8000))
1775                result |= SNDRV_PCM_RATE_8000;
1776        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11025))
1777                result |= SNDRV_PCM_RATE_11025;
1778        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 16000))
1779                result |= SNDRV_PCM_RATE_16000;
1780        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 22050))
1781                result |= SNDRV_PCM_RATE_22050;
1782        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 32000))
1783                result |= SNDRV_PCM_RATE_32000;
1784        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 44100))
1785                result |= SNDRV_PCM_RATE_44100;
1786        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 48000))
1787                result |= SNDRV_PCM_RATE_48000;
1788        if ((ac97->flags & AC97_DOUBLE_RATE) &&
1789            reg == AC97_PCM_FRONT_DAC_RATE) {
1790                /* test standard double rates */
1791                snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1792                                     AC97_EA_DRA, AC97_EA_DRA);
1793                if (snd_ac97_test_rate(ac97, reg, shadow_reg, 64000 / 2))
1794                        result |= SNDRV_PCM_RATE_64000;
1795                if (snd_ac97_test_rate(ac97, reg, shadow_reg, 88200 / 2))
1796                        result |= SNDRV_PCM_RATE_88200;
1797                if (snd_ac97_test_rate(ac97, reg, shadow_reg, 96000 / 2))
1798                        result |= SNDRV_PCM_RATE_96000;
1799                /* some codecs don't support variable double rates */
1800                if (!snd_ac97_test_rate(ac97, reg, shadow_reg, 76100 / 2))
1801                        result &= ~SNDRV_PCM_RATE_CONTINUOUS;
1802                snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1803                                     AC97_EA_DRA, 0);
1804        }
1805        /* restore the default value */
1806        snd_ac97_write_cache(ac97, reg, saved);
1807        if (shadow_reg)
1808                snd_ac97_write_cache(ac97, shadow_reg, saved);
1809        *r_result = result;
1810}
1811
1812/* check AC97_SPDIF register to accept which sample rates */
1813static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97)
1814{
1815        unsigned int result = 0;
1816        int i;
1817        static const unsigned short ctl_bits[] = {
1818                AC97_SC_SPSR_44K, AC97_SC_SPSR_32K, AC97_SC_SPSR_48K
1819        };
1820        static const unsigned int rate_bits[] = {
1821                SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_32000, SNDRV_PCM_RATE_48000
1822        };
1823
1824        for (i = 0; i < (int)ARRAY_SIZE(ctl_bits); i++) {
1825                snd_ac97_update_bits(ac97, AC97_SPDIF, AC97_SC_SPSR_MASK, ctl_bits[i]);
1826                if ((snd_ac97_read(ac97, AC97_SPDIF) & AC97_SC_SPSR_MASK) == ctl_bits[i])
1827                        result |= rate_bits[i];
1828        }
1829        return result;
1830}
1831
1832/* look for the codec id table matching with the given id */
1833static const struct ac97_codec_id *look_for_codec_id(const struct ac97_codec_id *table,
1834                                                     unsigned int id)
1835{
1836        const struct ac97_codec_id *pid;
1837
1838        for (pid = table; pid->id; pid++)
1839                if (pid->id == (id & pid->mask))
1840                        return pid;
1841        return NULL;
1842}
1843
1844void snd_ac97_get_name(struct snd_ac97 *ac97, unsigned int id, char *name, int modem)
1845{
1846        const struct ac97_codec_id *pid;
1847
1848        sprintf(name, "0x%x %c%c%c", id,
1849                printable(id >> 24),
1850                printable(id >> 16),
1851                printable(id >> 8));
1852        pid = look_for_codec_id(snd_ac97_codec_id_vendors, id);
1853        if (! pid)
1854                return;
1855
1856        strcpy(name, pid->name);
1857        if (ac97 && pid->patch) {
1858                if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
1859                    (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
1860                        pid->patch(ac97);
1861        } 
1862
1863        pid = look_for_codec_id(snd_ac97_codec_ids, id);
1864        if (pid) {
1865                strcat(name, " ");
1866                strcat(name, pid->name);
1867                if (pid->mask != 0xffffffff)
1868                        sprintf(name + strlen(name), " rev %d", id & ~pid->mask);
1869                if (ac97 && pid->patch) {
1870                        if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
1871                            (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
1872                                pid->patch(ac97);
1873                }
1874        } else
1875                sprintf(name + strlen(name), " id %x", id & 0xff);
1876}
1877
1878/**
1879 * snd_ac97_get_short_name - retrieve codec name
1880 * @ac97: the codec instance
1881 *
1882 * Return: The short identifying name of the codec.
1883 */
1884const char *snd_ac97_get_short_name(struct snd_ac97 *ac97)
1885{
1886        const struct ac97_codec_id *pid;
1887
1888        for (pid = snd_ac97_codec_ids; pid->id; pid++)
1889                if (pid->id == (ac97->id & pid->mask))
1890                        return pid->name;
1891        return "unknown codec";
1892}
1893
1894EXPORT_SYMBOL(snd_ac97_get_short_name);
1895
1896/* wait for a while until registers are accessible after RESET
1897 * return 0 if ok, negative not ready
1898 */
1899static int ac97_reset_wait(struct snd_ac97 *ac97, int timeout, int with_modem)
1900{
1901        unsigned long end_time;
1902        unsigned short val;
1903
1904        end_time = jiffies + timeout;
1905        do {
1906                
1907                /* use preliminary reads to settle the communication */
1908                snd_ac97_read(ac97, AC97_RESET);
1909                snd_ac97_read(ac97, AC97_VENDOR_ID1);
1910                snd_ac97_read(ac97, AC97_VENDOR_ID2);
1911                /* modem? */
1912                if (with_modem) {
1913                        val = snd_ac97_read(ac97, AC97_EXTENDED_MID);
1914                        if (val != 0xffff && (val & 1) != 0)
1915                                return 0;
1916                }
1917                if (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) {
1918                        /* probably only Xbox issue - all registers are read as zero */
1919                        val = snd_ac97_read(ac97, AC97_VENDOR_ID1);
1920                        if (val != 0 && val != 0xffff)
1921                                return 0;
1922                } else {
1923                        /* because the PCM or MASTER volume registers can be modified,
1924                         * the REC_GAIN register is used for tests
1925                         */
1926                        /* test if we can write to the record gain volume register */
1927                        snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a05);
1928                        if ((snd_ac97_read(ac97, AC97_REC_GAIN) & 0x7fff) == 0x0a05)
1929                                return 0;
1930                }
1931                schedule_timeout_uninterruptible(1);
1932        } while (time_after_eq(end_time, jiffies));
1933        return -ENODEV;
1934}
1935
1936/**
1937 * snd_ac97_bus - create an AC97 bus component
1938 * @card: the card instance
1939 * @num: the bus number
1940 * @ops: the bus callbacks table
1941 * @private_data: private data pointer for the new instance
1942 * @rbus: the pointer to store the new AC97 bus instance.
1943 *
1944 * Creates an AC97 bus component.  An struct snd_ac97_bus instance is newly
1945 * allocated and initialized.
1946 *
1947 * The ops table must include valid callbacks (at least read and
1948 * write).  The other callbacks, wait and reset, are not mandatory.
1949 * 
1950 * The clock is set to 48000.  If another clock is needed, set
1951 * ``(*rbus)->clock`` manually.
1952 *
1953 * The AC97 bus instance is registered as a low-level device, so you don't
1954 * have to release it manually.
1955 *
1956 * Return: Zero if successful, or a negative error code on failure.
1957 */
1958int snd_ac97_bus(struct snd_card *card, int num,
1959                 const struct snd_ac97_bus_ops *ops,
1960                 void *private_data, struct snd_ac97_bus **rbus)
1961{
1962        int err;
1963        struct snd_ac97_bus *bus;
1964        static const struct snd_device_ops dev_ops = {
1965                .dev_free =     snd_ac97_bus_dev_free,
1966        };
1967
1968        if (snd_BUG_ON(!card))
1969                return -EINVAL;
1970        bus = kzalloc(sizeof(*bus), GFP_KERNEL);
1971        if (bus == NULL)
1972                return -ENOMEM;
1973        bus->card = card;
1974        bus->num = num;
1975        bus->ops = ops;
1976        bus->private_data = private_data;
1977        bus->clock = 48000;
1978        spin_lock_init(&bus->bus_lock);
1979        snd_ac97_bus_proc_init(bus);
1980        err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
1981        if (err < 0) {
1982                snd_ac97_bus_free(bus);
1983                return err;
1984        }
1985        if (rbus)
1986                *rbus = bus;
1987        return 0;
1988}
1989
1990EXPORT_SYMBOL(snd_ac97_bus);
1991
1992/* stop no dev release warning */
1993static void ac97_device_release(struct device * dev)
1994{
1995}
1996
1997/* register ac97 codec to bus */
1998static int snd_ac97_dev_register(struct snd_device *device)
1999{
2000        struct snd_ac97 *ac97 = device->device_data;
2001        int err;
2002
2003        ac97->dev.bus = &ac97_bus_type;
2004        ac97->dev.parent = ac97->bus->card->dev;
2005        ac97->dev.release = ac97_device_release;
2006        dev_set_name(&ac97->dev, "%d-%d:%s",
2007                     ac97->bus->card->number, ac97->num,
2008                     snd_ac97_get_short_name(ac97));
2009        err = device_register(&ac97->dev);
2010        if (err < 0) {
2011                ac97_err(ac97, "Can't register ac97 bus\n");
2012                ac97->dev.bus = NULL;
2013                return err;
2014        }
2015        return 0;
2016}
2017
2018/* disconnect ac97 codec */
2019static int snd_ac97_dev_disconnect(struct snd_device *device)
2020{
2021        struct snd_ac97 *ac97 = device->device_data;
2022        if (ac97->dev.bus)
2023                device_unregister(&ac97->dev);
2024        return 0;
2025}
2026
2027/* build_ops to do nothing */
2028static const struct snd_ac97_build_ops null_build_ops;
2029
2030#ifdef CONFIG_SND_AC97_POWER_SAVE
2031static void do_update_power(struct work_struct *work)
2032{
2033        update_power_regs(
2034                container_of(work, struct snd_ac97, power_work.work));
2035}
2036#endif
2037
2038/**
2039 * snd_ac97_mixer - create an Codec97 component
2040 * @bus: the AC97 bus which codec is attached to
2041 * @template: the template of ac97, including index, callbacks and
2042 *         the private data.
2043 * @rac97: the pointer to store the new ac97 instance.
2044 *
2045 * Creates an Codec97 component.  An struct snd_ac97 instance is newly
2046 * allocated and initialized from the template.  The codec
2047 * is then initialized by the standard procedure.
2048 *
2049 * The template must include the codec number (num) and address (addr),
2050 * and the private data (private_data).
2051 * 
2052 * The ac97 instance is registered as a low-level device, so you don't
2053 * have to release it manually.
2054 *
2055 * Return: Zero if successful, or a negative error code on failure.
2056 */
2057int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template, struct snd_ac97 **rac97)
2058{
2059        int err;
2060        struct snd_ac97 *ac97;
2061        struct snd_card *card;
2062        char name[64];
2063        unsigned long end_time;
2064        unsigned int reg;
2065        const struct ac97_codec_id *pid;
2066        static const struct snd_device_ops ops = {
2067                .dev_free =     snd_ac97_dev_free,
2068                .dev_register = snd_ac97_dev_register,
2069                .dev_disconnect =       snd_ac97_dev_disconnect,
2070        };
2071
2072        if (rac97)
2073                *rac97 = NULL;
2074        if (snd_BUG_ON(!bus || !template))
2075                return -EINVAL;
2076        if (snd_BUG_ON(template->num >= 4))
2077                return -EINVAL;
2078        if (bus->codec[template->num])
2079                return -EBUSY;
2080
2081        card = bus->card;
2082        ac97 = kzalloc(sizeof(*ac97), GFP_KERNEL);
2083        if (ac97 == NULL)
2084                return -ENOMEM;
2085        ac97->private_data = template->private_data;
2086        ac97->private_free = template->private_free;
2087        ac97->bus = bus;
2088        ac97->pci = template->pci;
2089        ac97->num = template->num;
2090        ac97->addr = template->addr;
2091        ac97->scaps = template->scaps;
2092        ac97->res_table = template->res_table;
2093        bus->codec[ac97->num] = ac97;
2094        mutex_init(&ac97->reg_mutex);
2095        mutex_init(&ac97->page_mutex);
2096#ifdef CONFIG_SND_AC97_POWER_SAVE
2097        INIT_DELAYED_WORK(&ac97->power_work, do_update_power);
2098#endif
2099
2100#ifdef CONFIG_PCI
2101        if (ac97->pci) {
2102                pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_VENDOR_ID, &ac97->subsystem_vendor);
2103                pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_ID, &ac97->subsystem_device);
2104        }
2105#endif
2106        if (bus->ops->reset) {
2107                bus->ops->reset(ac97);
2108                goto __access_ok;
2109        }
2110
2111        ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
2112        ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
2113        if (ac97->id && ac97->id != (unsigned int)-1) {
2114                pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
2115                if (pid && (pid->flags & AC97_DEFAULT_POWER_OFF))
2116                        goto __access_ok;
2117        }
2118
2119        /* reset to defaults */
2120        if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO))
2121                snd_ac97_write(ac97, AC97_RESET, 0);
2122        if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM))
2123                snd_ac97_write(ac97, AC97_EXTENDED_MID, 0);
2124        if (bus->ops->wait)
2125                bus->ops->wait(ac97);
2126        else {
2127                udelay(50);
2128                if (ac97->scaps & AC97_SCAP_SKIP_AUDIO)
2129                        err = ac97_reset_wait(ac97, msecs_to_jiffies(500), 1);
2130                else {
2131                        err = ac97_reset_wait(ac97, msecs_to_jiffies(500), 0);
2132                        if (err < 0)
2133                                err = ac97_reset_wait(ac97,
2134                                                      msecs_to_jiffies(500), 1);
2135                }
2136                if (err < 0) {
2137                        ac97_warn(ac97, "AC'97 %d does not respond - RESET\n",
2138                                 ac97->num);
2139                        /* proceed anyway - it's often non-critical */
2140                }
2141        }
2142      __access_ok:
2143        ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
2144        ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
2145        if (! (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) &&
2146            (ac97->id == 0x00000000 || ac97->id == 0xffffffff)) {
2147                ac97_err(ac97,
2148                         "AC'97 %d access is not valid [0x%x], removing mixer.\n",
2149                         ac97->num, ac97->id);
2150                snd_ac97_free(ac97);
2151                return -EIO;
2152        }
2153        pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
2154        if (pid)
2155                ac97->flags |= pid->flags;
2156        
2157        /* test for AC'97 */
2158        if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO) && !(ac97->scaps & AC97_SCAP_AUDIO)) {
2159                /* test if we can write to the record gain volume register */
2160                snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a06);
2161                err = snd_ac97_read(ac97, AC97_REC_GAIN);
2162                if ((err & 0x7fff) == 0x0a06)
2163                        ac97->scaps |= AC97_SCAP_AUDIO;
2164        }
2165        if (ac97->scaps & AC97_SCAP_AUDIO) {
2166                ac97->caps = snd_ac97_read(ac97, AC97_RESET);
2167                ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID);
2168                if (ac97->ext_id == 0xffff)     /* invalid combination */
2169                        ac97->ext_id = 0;
2170        }
2171
2172        /* test for MC'97 */
2173        if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM) && !(ac97->scaps & AC97_SCAP_MODEM)) {
2174                ac97->ext_mid = snd_ac97_read(ac97, AC97_EXTENDED_MID);
2175                if (ac97->ext_mid == 0xffff)    /* invalid combination */
2176                        ac97->ext_mid = 0;
2177                if (ac97->ext_mid & 1)
2178                        ac97->scaps |= AC97_SCAP_MODEM;
2179        }
2180
2181        if (!ac97_is_audio(ac97) && !ac97_is_modem(ac97)) {
2182                if (!(ac97->scaps & (AC97_SCAP_SKIP_AUDIO|AC97_SCAP_SKIP_MODEM)))
2183                        ac97_err(ac97,
2184                                 "AC'97 %d access error (not audio or modem codec)\n",
2185                                 ac97->num);
2186                snd_ac97_free(ac97);
2187                return -EACCES;
2188        }
2189
2190        if (bus->ops->reset) // FIXME: always skipping?
2191                goto __ready_ok;
2192
2193        /* FIXME: add powerdown control */
2194        if (ac97_is_audio(ac97)) {
2195                /* nothing should be in powerdown mode */
2196                snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
2197                if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
2198                        snd_ac97_write_cache(ac97, AC97_RESET, 0); /* reset to defaults */
2199                        udelay(100);
2200                        snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
2201                }
2202                /* nothing should be in powerdown mode */
2203                snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0);
2204                end_time = jiffies + msecs_to_jiffies(5000);
2205                do {
2206                        if ((snd_ac97_read(ac97, AC97_POWERDOWN) & 0x0f) == 0x0f)
2207                                goto __ready_ok;
2208                        schedule_timeout_uninterruptible(1);
2209                } while (time_after_eq(end_time, jiffies));
2210                ac97_warn(ac97,
2211                          "AC'97 %d analog subsections not ready\n", ac97->num);
2212        }
2213
2214        /* FIXME: add powerdown control */
2215        if (ac97_is_modem(ac97)) {
2216                unsigned char tmp;
2217
2218                /* nothing should be in powerdown mode */
2219                /* note: it's important to set the rate at first */
2220                tmp = AC97_MEA_GPIO;
2221                if (ac97->ext_mid & AC97_MEI_LINE1) {
2222                        snd_ac97_write_cache(ac97, AC97_LINE1_RATE, 8000);
2223                        tmp |= AC97_MEA_ADC1 | AC97_MEA_DAC1;
2224                }
2225                if (ac97->ext_mid & AC97_MEI_LINE2) {
2226                        snd_ac97_write_cache(ac97, AC97_LINE2_RATE, 8000);
2227                        tmp |= AC97_MEA_ADC2 | AC97_MEA_DAC2;
2228                }
2229                if (ac97->ext_mid & AC97_MEI_HANDSET) {
2230                        snd_ac97_write_cache(ac97, AC97_HANDSET_RATE, 8000);
2231                        tmp |= AC97_MEA_HADC | AC97_MEA_HDAC;
2232                }
2233                snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0);
2234                udelay(100);
2235                /* nothing should be in powerdown mode */
2236                snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0);
2237                end_time = jiffies + msecs_to_jiffies(100);
2238                do {
2239                        if ((snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS) & tmp) == tmp)
2240                                goto __ready_ok;
2241                        schedule_timeout_uninterruptible(1);
2242                } while (time_after_eq(end_time, jiffies));
2243                ac97_warn(ac97,
2244                          "MC'97 %d converters and GPIO not ready (0x%x)\n",
2245                          ac97->num,
2246                          snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS));
2247        }
2248        
2249      __ready_ok:
2250        if (ac97_is_audio(ac97))
2251                ac97->addr = (ac97->ext_id & AC97_EI_ADDR_MASK) >> AC97_EI_ADDR_SHIFT;
2252        else
2253                ac97->addr = (ac97->ext_mid & AC97_MEI_ADDR_MASK) >> AC97_MEI_ADDR_SHIFT;
2254        if (ac97->ext_id & 0x01c9) {    /* L/R, MIC, SDAC, LDAC VRA support */
2255                reg = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
2256                reg |= ac97->ext_id & 0x01c0; /* LDAC/SDAC/CDAC */
2257                if (! bus->no_vra)
2258                        reg |= ac97->ext_id & 0x0009; /* VRA/VRM */
2259                snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, reg);
2260        }
2261        if ((ac97->ext_id & AC97_EI_DRA) && bus->dra) {
2262                /* Intel controllers require double rate data to be put in
2263                 * slots 7+8, so let's hope the codec supports it. */
2264                snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, AC97_GP_DRSS_MASK, AC97_GP_DRSS_78);
2265                if ((snd_ac97_read(ac97, AC97_GENERAL_PURPOSE) & AC97_GP_DRSS_MASK) == AC97_GP_DRSS_78)
2266                        ac97->flags |= AC97_DOUBLE_RATE;
2267                /* restore to slots 10/11 to avoid the confliction with surrounds */
2268                snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, AC97_GP_DRSS_MASK, 0);
2269        }
2270        if (ac97->ext_id & AC97_EI_VRA) {       /* VRA support */
2271                snd_ac97_determine_rates(ac97, AC97_PCM_FRONT_DAC_RATE, 0, &ac97->rates[AC97_RATES_FRONT_DAC]);
2272                snd_ac97_determine_rates(ac97, AC97_PCM_LR_ADC_RATE, 0, &ac97->rates[AC97_RATES_ADC]);
2273        } else {
2274                ac97->rates[AC97_RATES_FRONT_DAC] = SNDRV_PCM_RATE_48000;
2275                if (ac97->flags & AC97_DOUBLE_RATE)
2276                        ac97->rates[AC97_RATES_FRONT_DAC] |= SNDRV_PCM_RATE_96000;
2277                ac97->rates[AC97_RATES_ADC] = SNDRV_PCM_RATE_48000;
2278        }
2279        if (ac97->ext_id & AC97_EI_SPDIF) {
2280                /* codec specific code (patch) should override these values */
2281                ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_32000;
2282        }
2283        if (ac97->ext_id & AC97_EI_VRM) {       /* MIC VRA support */
2284                snd_ac97_determine_rates(ac97, AC97_PCM_MIC_ADC_RATE, 0, &ac97->rates[AC97_RATES_MIC_ADC]);
2285        } else {
2286                ac97->rates[AC97_RATES_MIC_ADC] = SNDRV_PCM_RATE_48000;
2287        }
2288        if (ac97->ext_id & AC97_EI_SDAC) {      /* SDAC support */
2289                snd_ac97_determine_rates(ac97, AC97_PCM_SURR_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_SURR_DAC]);
2290                ac97->scaps |= AC97_SCAP_SURROUND_DAC;
2291        }
2292        if (ac97->ext_id & AC97_EI_LDAC) {      /* LDAC support */
2293                snd_ac97_determine_rates(ac97, AC97_PCM_LFE_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_LFE_DAC]);
2294                ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC;
2295        }
2296        /* additional initializations */
2297        if (bus->ops->init)
2298                bus->ops->init(ac97);
2299        snd_ac97_get_name(ac97, ac97->id, name, !ac97_is_audio(ac97));
2300        snd_ac97_get_name(NULL, ac97->id, name, !ac97_is_audio(ac97));  // ac97->id might be changed in the special setup code
2301        if (! ac97->build_ops)
2302                ac97->build_ops = &null_build_ops;
2303
2304        if (ac97_is_audio(ac97)) {
2305                char comp[16];
2306                if (card->mixername[0] == '\0') {
2307                        strcpy(card->mixername, name);
2308                } else {
2309                        if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
2310                                strcat(card->mixername, ",");
2311                                strcat(card->mixername, name);
2312                        }
2313                }
2314                sprintf(comp, "AC97a:%08x", ac97->id);
2315                err = snd_component_add(card, comp);
2316                if (err < 0) {
2317                        snd_ac97_free(ac97);
2318                        return err;
2319                }
2320                if (snd_ac97_mixer_build(ac97) < 0) {
2321                        snd_ac97_free(ac97);
2322                        return -ENOMEM;
2323                }
2324        }
2325        if (ac97_is_modem(ac97)) {
2326                char comp[16];
2327                if (card->mixername[0] == '\0') {
2328                        strcpy(card->mixername, name);
2329                } else {
2330                        if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
2331                                strcat(card->mixername, ",");
2332                                strcat(card->mixername, name);
2333                        }
2334                }
2335                sprintf(comp, "AC97m:%08x", ac97->id);
2336                err = snd_component_add(card, comp);
2337                if (err < 0) {
2338                        snd_ac97_free(ac97);
2339                        return err;
2340                }
2341                if (snd_ac97_modem_build(card, ac97) < 0) {
2342                        snd_ac97_free(ac97);
2343                        return -ENOMEM;
2344                }
2345        }
2346        if (ac97_is_audio(ac97))
2347                update_power_regs(ac97);
2348        snd_ac97_proc_init(ac97);
2349        err = snd_device_new(card, SNDRV_DEV_CODEC, ac97, &ops);
2350        if (err < 0) {
2351                snd_ac97_free(ac97);
2352                return err;
2353        }
2354        *rac97 = ac97;
2355        return 0;
2356}
2357
2358EXPORT_SYMBOL(snd_ac97_mixer);
2359
2360/*
2361 * Power down the chip.
2362 *
2363 * MASTER and HEADPHONE registers are muted but the register cache values
2364 * are not changed, so that the values can be restored in snd_ac97_resume().
2365 */
2366static void snd_ac97_powerdown(struct snd_ac97 *ac97)
2367{
2368        unsigned short power;
2369
2370        if (ac97_is_audio(ac97)) {
2371                /* some codecs have stereo mute bits */
2372                snd_ac97_write(ac97, AC97_MASTER, 0x9f9f);
2373                snd_ac97_write(ac97, AC97_HEADPHONE, 0x9f9f);
2374        }
2375
2376        /* surround, CLFE, mic powerdown */
2377        power = ac97->regs[AC97_EXTENDED_STATUS];
2378        if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
2379                power |= AC97_EA_PRJ;
2380        if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
2381                power |= AC97_EA_PRI | AC97_EA_PRK;
2382        power |= AC97_EA_PRL;
2383        snd_ac97_write(ac97, AC97_EXTENDED_STATUS, power);
2384
2385        /* powerdown external amplifier */
2386        if (ac97->scaps & AC97_SCAP_INV_EAPD)
2387                power = ac97->regs[AC97_POWERDOWN] & ~AC97_PD_EAPD;
2388        else if (! (ac97->scaps & AC97_SCAP_EAPD_LED))
2389                power = ac97->regs[AC97_POWERDOWN] | AC97_PD_EAPD;
2390        power |= AC97_PD_PR6;   /* Headphone amplifier powerdown */
2391        power |= AC97_PD_PR0 | AC97_PD_PR1;     /* ADC & DAC powerdown */
2392        snd_ac97_write(ac97, AC97_POWERDOWN, power);
2393        udelay(100);
2394        power |= AC97_PD_PR2;   /* Analog Mixer powerdown (Vref on) */
2395        snd_ac97_write(ac97, AC97_POWERDOWN, power);
2396        if (ac97_is_power_save_mode(ac97)) {
2397                power |= AC97_PD_PR3;   /* Analog Mixer powerdown */
2398                snd_ac97_write(ac97, AC97_POWERDOWN, power);
2399                udelay(100);
2400                /* AC-link powerdown, internal Clk disable */
2401                /* FIXME: this may cause click noises on some boards */
2402                power |= AC97_PD_PR4 | AC97_PD_PR5;
2403                snd_ac97_write(ac97, AC97_POWERDOWN, power);
2404        }
2405}
2406
2407
2408struct ac97_power_reg {
2409        unsigned short reg;
2410        unsigned short power_reg;
2411        unsigned short mask;
2412};
2413
2414enum { PWIDX_ADC, PWIDX_FRONT, PWIDX_CLFE, PWIDX_SURR, PWIDX_MIC, PWIDX_SIZE };
2415
2416static const struct ac97_power_reg power_regs[PWIDX_SIZE] = {
2417        [PWIDX_ADC] = { AC97_PCM_LR_ADC_RATE, AC97_POWERDOWN, AC97_PD_PR0},
2418        [PWIDX_FRONT] = { AC97_PCM_FRONT_DAC_RATE, AC97_POWERDOWN, AC97_PD_PR1},
2419        [PWIDX_CLFE] = { AC97_PCM_LFE_DAC_RATE, AC97_EXTENDED_STATUS,
2420                         AC97_EA_PRI | AC97_EA_PRK},
2421        [PWIDX_SURR] = { AC97_PCM_SURR_DAC_RATE, AC97_EXTENDED_STATUS,
2422                         AC97_EA_PRJ},
2423        [PWIDX_MIC] = { AC97_PCM_MIC_ADC_RATE, AC97_EXTENDED_STATUS,
2424                        AC97_EA_PRL},
2425};
2426
2427#ifdef CONFIG_SND_AC97_POWER_SAVE
2428/**
2429 * snd_ac97_update_power - update the powerdown register
2430 * @ac97: the codec instance
2431 * @reg: the rate register, e.g. AC97_PCM_FRONT_DAC_RATE
2432 * @powerup: non-zero when power up the part
2433 *
2434 * Update the AC97 powerdown register bits of the given part.
2435 *
2436 * Return: Zero.
2437 */
2438int snd_ac97_update_power(struct snd_ac97 *ac97, int reg, int powerup)
2439{
2440        int i;
2441
2442        if (! ac97)
2443                return 0;
2444
2445        if (reg) {
2446                /* SPDIF requires DAC power, too */
2447                if (reg == AC97_SPDIF)
2448                        reg = AC97_PCM_FRONT_DAC_RATE;
2449                for (i = 0; i < PWIDX_SIZE; i++) {
2450                        if (power_regs[i].reg == reg) {
2451                                if (powerup)
2452                                        ac97->power_up |= (1 << i);
2453                                else
2454                                        ac97->power_up &= ~(1 << i);
2455                                break;
2456                        }
2457                }
2458        }
2459
2460        if (ac97_is_power_save_mode(ac97) && !powerup)
2461                /* adjust power-down bits after two seconds delay
2462                 * (for avoiding loud click noises for many (OSS) apps
2463                 *  that open/close frequently)
2464                 */
2465                schedule_delayed_work(&ac97->power_work,
2466                                      msecs_to_jiffies(power_save * 1000));
2467        else {
2468                cancel_delayed_work(&ac97->power_work);
2469                update_power_regs(ac97);
2470        }
2471
2472        return 0;
2473}
2474
2475EXPORT_SYMBOL(snd_ac97_update_power);
2476#endif /* CONFIG_SND_AC97_POWER_SAVE */
2477
2478static void update_power_regs(struct snd_ac97 *ac97)
2479{
2480        unsigned int power_up, bits;
2481        int i;
2482
2483        power_up = (1 << PWIDX_FRONT) | (1 << PWIDX_ADC);
2484        power_up |= (1 << PWIDX_MIC);
2485        if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
2486                power_up |= (1 << PWIDX_SURR);
2487        if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
2488                power_up |= (1 << PWIDX_CLFE);
2489#ifdef CONFIG_SND_AC97_POWER_SAVE
2490        if (ac97_is_power_save_mode(ac97))
2491                power_up = ac97->power_up;
2492#endif
2493        if (power_up) {
2494                if (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2) {
2495                        /* needs power-up analog mix and vref */
2496                        snd_ac97_update_bits(ac97, AC97_POWERDOWN,
2497                                             AC97_PD_PR3, 0);
2498                        msleep(1);
2499                        snd_ac97_update_bits(ac97, AC97_POWERDOWN,
2500                                             AC97_PD_PR2, 0);
2501                }
2502        }
2503        for (i = 0; i < PWIDX_SIZE; i++) {
2504                if (power_up & (1 << i))
2505                        bits = 0;
2506                else
2507                        bits = power_regs[i].mask;
2508                snd_ac97_update_bits(ac97, power_regs[i].power_reg,
2509                                     power_regs[i].mask, bits);
2510        }
2511        if (! power_up) {
2512                if (! (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2)) {
2513                        /* power down analog mix and vref */
2514                        snd_ac97_update_bits(ac97, AC97_POWERDOWN,
2515                                             AC97_PD_PR2, AC97_PD_PR2);
2516                        snd_ac97_update_bits(ac97, AC97_POWERDOWN,
2517                                             AC97_PD_PR3, AC97_PD_PR3);
2518                }
2519        }
2520}
2521
2522
2523#ifdef CONFIG_PM
2524/**
2525 * snd_ac97_suspend - General suspend function for AC97 codec
2526 * @ac97: the ac97 instance
2527 *
2528 * Suspends the codec, power down the chip.
2529 */
2530void snd_ac97_suspend(struct snd_ac97 *ac97)
2531{
2532        if (! ac97)
2533                return;
2534        if (ac97->build_ops->suspend)
2535                ac97->build_ops->suspend(ac97);
2536#ifdef CONFIG_SND_AC97_POWER_SAVE
2537        cancel_delayed_work_sync(&ac97->power_work);
2538#endif
2539        snd_ac97_powerdown(ac97);
2540}
2541
2542EXPORT_SYMBOL(snd_ac97_suspend);
2543
2544/*
2545 * restore ac97 status
2546 */
2547static void snd_ac97_restore_status(struct snd_ac97 *ac97)
2548{
2549        int i;
2550
2551        for (i = 2; i < 0x7c ; i += 2) {
2552                if (i == AC97_POWERDOWN || i == AC97_EXTENDED_ID)
2553                        continue;
2554                /* restore only accessible registers
2555                 * some chip (e.g. nm256) may hang up when unsupported registers
2556                 * are accessed..!
2557                 */
2558                if (test_bit(i, ac97->reg_accessed)) {
2559                        snd_ac97_write(ac97, i, ac97->regs[i]);
2560                        snd_ac97_read(ac97, i);
2561                }
2562        }
2563}
2564
2565/*
2566 * restore IEC958 status
2567 */
2568static void snd_ac97_restore_iec958(struct snd_ac97 *ac97)
2569{
2570        if (ac97->ext_id & AC97_EI_SPDIF) {
2571                if (ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_SPDIF) {
2572                        /* reset spdif status */
2573                        snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
2574                        snd_ac97_write(ac97, AC97_EXTENDED_STATUS, ac97->regs[AC97_EXTENDED_STATUS]);
2575                        if (ac97->flags & AC97_CS_SPDIF)
2576                                snd_ac97_write(ac97, AC97_CSR_SPDIF, ac97->regs[AC97_CSR_SPDIF]);
2577                        else
2578                                snd_ac97_write(ac97, AC97_SPDIF, ac97->regs[AC97_SPDIF]);
2579                        snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
2580                }
2581        }
2582}
2583
2584/**
2585 * snd_ac97_resume - General resume function for AC97 codec
2586 * @ac97: the ac97 instance
2587 *
2588 * Do the standard resume procedure, power up and restoring the
2589 * old register values.
2590 */
2591void snd_ac97_resume(struct snd_ac97 *ac97)
2592{
2593        unsigned long end_time;
2594
2595        if (! ac97)
2596                return;
2597
2598        if (ac97->bus->ops->reset) {
2599                ac97->bus->ops->reset(ac97);
2600                goto  __reset_ready;
2601        }
2602
2603        snd_ac97_write(ac97, AC97_POWERDOWN, 0);
2604        if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
2605                if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO))
2606                        snd_ac97_write(ac97, AC97_RESET, 0);
2607                else if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM))
2608                        snd_ac97_write(ac97, AC97_EXTENDED_MID, 0);
2609                udelay(100);
2610                snd_ac97_write(ac97, AC97_POWERDOWN, 0);
2611        }
2612        snd_ac97_write(ac97, AC97_GENERAL_PURPOSE, 0);
2613
2614        snd_ac97_write(ac97, AC97_POWERDOWN, ac97->regs[AC97_POWERDOWN]);
2615        if (ac97_is_audio(ac97)) {
2616                ac97->bus->ops->write(ac97, AC97_MASTER, 0x8101);
2617                end_time = jiffies + msecs_to_jiffies(100);
2618                do {
2619                        if (snd_ac97_read(ac97, AC97_MASTER) == 0x8101)
2620                                break;
2621                        schedule_timeout_uninterruptible(1);
2622                } while (time_after_eq(end_time, jiffies));
2623                /* FIXME: extra delay */
2624                ac97->bus->ops->write(ac97, AC97_MASTER, AC97_MUTE_MASK_MONO);
2625                if (snd_ac97_read(ac97, AC97_MASTER) != AC97_MUTE_MASK_MONO)
2626                        msleep(250);
2627        } else {
2628                end_time = jiffies + msecs_to_jiffies(100);
2629                do {
2630                        unsigned short val = snd_ac97_read(ac97, AC97_EXTENDED_MID);
2631                        if (val != 0xffff && (val & 1) != 0)
2632                                break;
2633                        schedule_timeout_uninterruptible(1);
2634                } while (time_after_eq(end_time, jiffies));
2635        }
2636__reset_ready:
2637
2638        if (ac97->bus->ops->init)
2639                ac97->bus->ops->init(ac97);
2640
2641        if (ac97->build_ops->resume)
2642                ac97->build_ops->resume(ac97);
2643        else {
2644                snd_ac97_restore_status(ac97);
2645                snd_ac97_restore_iec958(ac97);
2646        }
2647}
2648
2649EXPORT_SYMBOL(snd_ac97_resume);
2650#endif
2651
2652
2653/*
2654 * Hardware tuning
2655 */
2656static void set_ctl_name(char *dst, const char *src, const char *suffix)
2657{
2658        if (suffix)
2659                sprintf(dst, "%s %s", src, suffix);
2660        else
2661                strcpy(dst, src);
2662}       
2663
2664/* remove the control with the given name and optional suffix */
2665static int snd_ac97_remove_ctl(struct snd_ac97 *ac97, const char *name,
2666                               const char *suffix)
2667{
2668        struct snd_ctl_elem_id id;
2669        memset(&id, 0, sizeof(id));
2670        set_ctl_name(id.name, name, suffix);
2671        id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2672        return snd_ctl_remove_id(ac97->bus->card, &id);
2673}
2674
2675static struct snd_kcontrol *ctl_find(struct snd_ac97 *ac97, const char *name, const char *suffix)
2676{
2677        struct snd_ctl_elem_id sid;
2678        memset(&sid, 0, sizeof(sid));
2679        set_ctl_name(sid.name, name, suffix);
2680        sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2681        return snd_ctl_find_id(ac97->bus->card, &sid);
2682}
2683
2684/* rename the control with the given name and optional suffix */
2685static int snd_ac97_rename_ctl(struct snd_ac97 *ac97, const char *src,
2686                               const char *dst, const char *suffix)
2687{
2688        struct snd_kcontrol *kctl = ctl_find(ac97, src, suffix);
2689        if (kctl) {
2690                set_ctl_name(kctl->id.name, dst, suffix);
2691                return 0;
2692        }
2693        return -ENOENT;
2694}
2695
2696/* rename both Volume and Switch controls - don't check the return value */
2697static void snd_ac97_rename_vol_ctl(struct snd_ac97 *ac97, const char *src,
2698                                    const char *dst)
2699{
2700        snd_ac97_rename_ctl(ac97, src, dst, "Switch");
2701        snd_ac97_rename_ctl(ac97, src, dst, "Volume");
2702}
2703
2704/* swap controls */
2705static int snd_ac97_swap_ctl(struct snd_ac97 *ac97, const char *s1,
2706                             const char *s2, const char *suffix)
2707{
2708        struct snd_kcontrol *kctl1, *kctl2;
2709        kctl1 = ctl_find(ac97, s1, suffix);
2710        kctl2 = ctl_find(ac97, s2, suffix);
2711        if (kctl1 && kctl2) {
2712                set_ctl_name(kctl1->id.name, s2, suffix);
2713                set_ctl_name(kctl2->id.name, s1, suffix);
2714                return 0;
2715        }
2716        return -ENOENT;
2717}
2718
2719#if 1
2720/* bind hp and master controls instead of using only hp control */
2721static int bind_hp_volsw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2722{
2723        int err = snd_ac97_put_volsw(kcontrol, ucontrol);
2724        if (err > 0) {
2725                unsigned long priv_saved = kcontrol->private_value;
2726                kcontrol->private_value = (kcontrol->private_value & ~0xff) | AC97_HEADPHONE;
2727                snd_ac97_put_volsw(kcontrol, ucontrol);
2728                kcontrol->private_value = priv_saved;
2729        }
2730        return err;
2731}
2732
2733/* ac97 tune: bind Master and Headphone controls */
2734static int tune_hp_only(struct snd_ac97 *ac97)
2735{
2736        struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
2737        struct snd_kcontrol *mvol = ctl_find(ac97, "Master Playback Volume", NULL);
2738        if (! msw || ! mvol)
2739                return -ENOENT;
2740        msw->put = bind_hp_volsw_put;
2741        mvol->put = bind_hp_volsw_put;
2742        snd_ac97_remove_ctl(ac97, "Headphone Playback", "Switch");
2743        snd_ac97_remove_ctl(ac97, "Headphone Playback", "Volume");
2744        return 0;
2745}
2746
2747#else
2748/* ac97 tune: use Headphone control as master */
2749static int tune_hp_only(struct snd_ac97 *ac97)
2750{
2751        if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL)
2752                return -ENOENT;
2753        snd_ac97_remove_ctl(ac97, "Master Playback", "Switch");
2754        snd_ac97_remove_ctl(ac97, "Master Playback", "Volume");
2755        snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
2756        return 0;
2757}
2758#endif
2759
2760/* ac97 tune: swap Headphone and Master controls */
2761static int tune_swap_hp(struct snd_ac97 *ac97)
2762{
2763        if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL)
2764                return -ENOENT;
2765        snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Line-Out Playback");
2766        snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
2767        return 0;
2768}
2769
2770/* ac97 tune: swap Surround and Master controls */
2771static int tune_swap_surround(struct snd_ac97 *ac97)
2772{
2773        if (snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Switch") ||
2774            snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Volume"))
2775                return -ENOENT;
2776        return 0;
2777}
2778
2779/* ac97 tune: set up mic sharing for AD codecs */
2780static int tune_ad_sharing(struct snd_ac97 *ac97)
2781{
2782        unsigned short scfg;
2783        if ((ac97->id & 0xffffff00) != 0x41445300) {
2784                ac97_err(ac97, "ac97_quirk AD_SHARING is only for AD codecs\n");
2785                return -EINVAL;
2786        }
2787        /* Turn on OMS bit to route microphone to back panel */
2788        scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
2789        snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x0200);
2790        return 0;
2791}
2792
2793static const struct snd_kcontrol_new snd_ac97_alc_jack_detect = 
2794AC97_SINGLE("Jack Detect", AC97_ALC650_CLOCK, 5, 1, 0);
2795
2796/* ac97 tune: set up ALC jack-select */
2797static int tune_alc_jack(struct snd_ac97 *ac97)
2798{
2799        if ((ac97->id & 0xffffff00) != 0x414c4700) {
2800                ac97_err(ac97,
2801                         "ac97_quirk ALC_JACK is only for Realtek codecs\n");
2802                return -EINVAL;
2803        }
2804        snd_ac97_update_bits(ac97, 0x7a, 0x20, 0x20); /* select jack detect function */
2805        snd_ac97_update_bits(ac97, 0x7a, 0x01, 0x01); /* Line-out auto mute */
2806        if (ac97->id == AC97_ID_ALC658D)
2807                snd_ac97_update_bits(ac97, 0x74, 0x0800, 0x0800);
2808        return snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&snd_ac97_alc_jack_detect, ac97));
2809}
2810
2811/* ac97 tune: inversed EAPD bit */
2812static int tune_inv_eapd(struct snd_ac97 *ac97)
2813{
2814        struct snd_kcontrol *kctl = ctl_find(ac97, "External Amplifier", NULL);
2815        if (! kctl)
2816                return -ENOENT;
2817        set_inv_eapd(ac97, kctl);
2818        return 0;
2819}
2820
2821static int master_mute_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2822{
2823        int err = snd_ac97_put_volsw(kcontrol, ucontrol);
2824        if (err > 0) {
2825                struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2826                int shift = (kcontrol->private_value >> 8) & 0x0f;
2827                int rshift = (kcontrol->private_value >> 12) & 0x0f;
2828                unsigned short mask;
2829                if (shift != rshift)
2830                        mask = AC97_MUTE_MASK_STEREO;
2831                else
2832                        mask = AC97_MUTE_MASK_MONO;
2833                snd_ac97_update_bits(ac97, AC97_POWERDOWN, AC97_PD_EAPD,
2834                                     (ac97->regs[AC97_MASTER] & mask) == mask ?
2835                                     AC97_PD_EAPD : 0);
2836        }
2837        return err;
2838}
2839
2840/* ac97 tune: EAPD controls mute LED bound with the master mute */
2841static int tune_mute_led(struct snd_ac97 *ac97)
2842{
2843        struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
2844        if (! msw)
2845                return -ENOENT;
2846        msw->put = master_mute_sw_put;
2847        snd_ac97_remove_ctl(ac97, "External Amplifier", NULL);
2848        snd_ac97_update_bits(
2849                ac97, AC97_POWERDOWN,
2850                AC97_PD_EAPD, AC97_PD_EAPD /* mute LED on */
2851        );
2852        ac97->scaps |= AC97_SCAP_EAPD_LED;
2853        return 0;
2854}
2855
2856static int hp_master_mute_sw_put(struct snd_kcontrol *kcontrol,
2857                                 struct snd_ctl_elem_value *ucontrol)
2858{
2859        int err = bind_hp_volsw_put(kcontrol, ucontrol);
2860        if (err > 0) {
2861                struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2862                int shift = (kcontrol->private_value >> 8) & 0x0f;
2863                int rshift = (kcontrol->private_value >> 12) & 0x0f;
2864                unsigned short mask;
2865                if (shift != rshift)
2866                        mask = AC97_MUTE_MASK_STEREO;
2867                else
2868                        mask = AC97_MUTE_MASK_MONO;
2869                snd_ac97_update_bits(ac97, AC97_POWERDOWN, AC97_PD_EAPD,
2870                                     (ac97->regs[AC97_MASTER] & mask) == mask ?
2871                                     AC97_PD_EAPD : 0);
2872        }
2873        return err;
2874}
2875
2876static int tune_hp_mute_led(struct snd_ac97 *ac97)
2877{
2878        struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
2879        struct snd_kcontrol *mvol = ctl_find(ac97, "Master Playback Volume", NULL);
2880        if (! msw || ! mvol)
2881                return -ENOENT;
2882        msw->put = hp_master_mute_sw_put;
2883        mvol->put = bind_hp_volsw_put;
2884        snd_ac97_remove_ctl(ac97, "External Amplifier", NULL);
2885        snd_ac97_remove_ctl(ac97, "Headphone Playback", "Switch");
2886        snd_ac97_remove_ctl(ac97, "Headphone Playback", "Volume");
2887        snd_ac97_update_bits(
2888                ac97, AC97_POWERDOWN,
2889                AC97_PD_EAPD, AC97_PD_EAPD /* mute LED on */
2890        );
2891        return 0;
2892}
2893
2894struct quirk_table {
2895        const char *name;
2896        int (*func)(struct snd_ac97 *);
2897};
2898
2899static const struct quirk_table applicable_quirks[] = {
2900        { "none", NULL },
2901        { "hp_only", tune_hp_only },
2902        { "swap_hp", tune_swap_hp },
2903        { "swap_surround", tune_swap_surround },
2904        { "ad_sharing", tune_ad_sharing },
2905        { "alc_jack", tune_alc_jack },
2906        { "inv_eapd", tune_inv_eapd },
2907        { "mute_led", tune_mute_led },
2908        { "hp_mute_led", tune_hp_mute_led },
2909};
2910
2911/* apply the quirk with the given type */
2912static int apply_quirk(struct snd_ac97 *ac97, int type)
2913{
2914        if (type <= 0)
2915                return 0;
2916        else if (type >= ARRAY_SIZE(applicable_quirks))
2917                return -EINVAL;
2918        if (applicable_quirks[type].func)
2919                return applicable_quirks[type].func(ac97);
2920        return 0;
2921}
2922
2923/* apply the quirk with the given name */
2924static int apply_quirk_str(struct snd_ac97 *ac97, const char *typestr)
2925{
2926        int i;
2927        const struct quirk_table *q;
2928
2929        for (i = 0; i < ARRAY_SIZE(applicable_quirks); i++) {
2930                q = &applicable_quirks[i];
2931                if (q->name && ! strcmp(typestr, q->name))
2932                        return apply_quirk(ac97, i);
2933        }
2934        /* for compatibility, accept the numbers, too */
2935        if (*typestr >= '0' && *typestr <= '9')
2936                return apply_quirk(ac97, (int)simple_strtoul(typestr, NULL, 10));
2937        return -EINVAL;
2938}
2939
2940/**
2941 * snd_ac97_tune_hardware - tune up the hardware
2942 * @ac97: the ac97 instance
2943 * @quirk: quirk list
2944 * @override: explicit quirk value (overrides the list if non-NULL)
2945 *
2946 * Do some workaround for each pci device, such as renaming of the
2947 * headphone (true line-out) control as "Master".
2948 * The quirk-list must be terminated with a zero-filled entry.
2949 *
2950 * Return: Zero if successful, or a negative error code on failure.
2951 */
2952
2953int snd_ac97_tune_hardware(struct snd_ac97 *ac97,
2954                           const struct ac97_quirk *quirk, const char *override)
2955{
2956        int result;
2957
2958        /* quirk overriden? */
2959        if (override && strcmp(override, "-1") && strcmp(override, "default")) {
2960                result = apply_quirk_str(ac97, override);
2961                if (result < 0)
2962                        ac97_err(ac97, "applying quirk type %s failed (%d)\n",
2963                                 override, result);
2964                return result;
2965        }
2966
2967        if (! quirk)
2968                return -EINVAL;
2969
2970        for (; quirk->subvendor; quirk++) {
2971                if (quirk->subvendor != ac97->subsystem_vendor)
2972                        continue;
2973                if ((! quirk->mask && quirk->subdevice == ac97->subsystem_device) ||
2974                    quirk->subdevice == (quirk->mask & ac97->subsystem_device)) {
2975                        if (quirk->codec_id && quirk->codec_id != ac97->id)
2976                                continue;
2977                        ac97_dbg(ac97, "ac97 quirk for %s (%04x:%04x)\n",
2978                                 quirk->name, ac97->subsystem_vendor,
2979                                 ac97->subsystem_device);
2980                        result = apply_quirk(ac97, quirk->type);
2981                        if (result < 0)
2982                                ac97_err(ac97,
2983                                         "applying quirk type %d for %s failed (%d)\n",
2984                                         quirk->type, quirk->name, result);
2985                        return result;
2986                }
2987        }
2988        return 0;
2989}
2990
2991EXPORT_SYMBOL(snd_ac97_tune_hardware);
2992
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.