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                /* fall through */
 222        case AC97_ID_ST7597:
 223                if (reg == 0x22 || reg == 0x7a)
 224                        return 1;
 225                /* fall through */
 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                if ((err = snd_ac97_cmute_new_stereo(card, name, reg,
1290                                                     check_stereo, check_amix,
1291                                                     ac97)) < 0)
1292                        return err;
1293        }
1294        check_volume_resolution(ac97, reg, &lo_max, &hi_max);
1295        if (lo_max) {
1296                sprintf(name, "%s Volume", pfx);
1297                if ((err = snd_ac97_cvol_new(card, name, reg, lo_max, hi_max, ac97)) < 0)
1298                        return err;
1299        }
1300        return 0;
1301}
1302
1303#define snd_ac97_cmix_new(card, pfx, reg, acheck, ac97) \
1304        snd_ac97_cmix_new_stereo(card, pfx, reg, 0, acheck, ac97)
1305#define snd_ac97_cmute_new(card, name, reg, acheck, ac97) \
1306        snd_ac97_cmute_new_stereo(card, name, reg, 0, acheck, ac97)
1307
1308static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97);
1309
1310static int snd_ac97_mixer_build(struct snd_ac97 * ac97)
1311{
1312        struct snd_card *card = ac97->bus->card;
1313        struct snd_kcontrol *kctl;
1314        int err;
1315        unsigned int idx;
1316        unsigned char max;
1317
1318        /* build master controls */
1319        /* AD claims to remove this control from AD1887, although spec v2.2 does not allow this */
1320        if (snd_ac97_try_volume_mix(ac97, AC97_MASTER)) {
1321                if (ac97->flags & AC97_HAS_NO_MASTER_VOL)
1322                        err = snd_ac97_cmute_new(card, "Master Playback Switch",
1323                                                 AC97_MASTER, 0, ac97);
1324                else
1325                        err = snd_ac97_cmix_new(card, "Master Playback",
1326                                                AC97_MASTER, 0, ac97);
1327                if (err < 0)
1328                        return err;
1329        }
1330
1331        ac97->regs[AC97_CENTER_LFE_MASTER] = AC97_MUTE_MASK_STEREO;
1332
1333        /* build center controls */
1334        if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER)) 
1335                && !(ac97->flags & AC97_AD_MULTI)) {
1336                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_center[0], ac97))) < 0)
1337                        return err;
1338                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_center[1], ac97))) < 0)
1339                        return err;
1340                snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 0, &max);
1341                kctl->private_value &= ~(0xff << 16);
1342                kctl->private_value |= (int)max << 16;
1343                set_tlv_db_scale(kctl, find_db_scale(max));
1344                snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max);
1345        }
1346
1347        /* build LFE controls */
1348        if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1))
1349                && !(ac97->flags & AC97_AD_MULTI)) {
1350                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_lfe[0], ac97))) < 0)
1351                        return err;
1352                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_lfe[1], ac97))) < 0)
1353                        return err;
1354                snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 8, &max);
1355                kctl->private_value &= ~(0xff << 16);
1356                kctl->private_value |= (int)max << 16;
1357                set_tlv_db_scale(kctl, find_db_scale(max));
1358                snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max << 8);
1359        }
1360
1361        /* build surround controls */
1362        if ((snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER)) 
1363                && !(ac97->flags & AC97_AD_MULTI)) {
1364                /* Surround Master (0x38) is with stereo mutes */
1365                if ((err = snd_ac97_cmix_new_stereo(card, "Surround Playback",
1366                                                    AC97_SURROUND_MASTER, 1, 0,
1367                                                    ac97)) < 0)
1368                        return err;
1369        }
1370
1371        /* build headphone controls */
1372        if (snd_ac97_try_volume_mix(ac97, AC97_HEADPHONE)) {
1373                if ((err = snd_ac97_cmix_new(card, "Headphone Playback",
1374                                             AC97_HEADPHONE, 0, ac97)) < 0)
1375                        return err;
1376        }
1377        
1378        /* build master mono controls */
1379        if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_MONO)) {
1380                if ((err = snd_ac97_cmix_new(card, "Master Mono Playback",
1381                                             AC97_MASTER_MONO, 0, ac97)) < 0)
1382                        return err;
1383        }
1384        
1385        /* build master tone controls */
1386        if (!(ac97->flags & AC97_HAS_NO_TONE)) {
1387                if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_TONE)) {
1388                        for (idx = 0; idx < 2; idx++) {
1389                                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_tone[idx], ac97))) < 0)
1390                                        return err;
1391                                if (ac97->id == AC97_ID_YMF743 ||
1392                                    ac97->id == AC97_ID_YMF753) {
1393                                        kctl->private_value &= ~(0xff << 16);
1394                                        kctl->private_value |= 7 << 16;
1395                                }
1396                        }
1397                        snd_ac97_write_cache(ac97, AC97_MASTER_TONE, 0x0f0f);
1398                }
1399        }
1400        
1401        /* build Beep controls */
1402        if (!(ac97->flags & AC97_HAS_NO_PC_BEEP) && 
1403                ((ac97->flags & AC97_HAS_PC_BEEP) ||
1404            snd_ac97_try_volume_mix(ac97, AC97_PC_BEEP))) {
1405                for (idx = 0; idx < 2; idx++)
1406                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_pc_beep[idx], ac97))) < 0)
1407                                return err;
1408                set_tlv_db_scale(kctl, db_scale_4bit);
1409                snd_ac97_write_cache(
1410                        ac97,
1411                        AC97_PC_BEEP,
1412                        (snd_ac97_read(ac97, AC97_PC_BEEP)
1413                                | AC97_MUTE_MASK_MONO | 0x001e)
1414                );
1415        }
1416        
1417        /* build Phone controls */
1418        if (!(ac97->flags & AC97_HAS_NO_PHONE)) {
1419                if (snd_ac97_try_volume_mix(ac97, AC97_PHONE)) {
1420                        if ((err = snd_ac97_cmix_new(card, "Phone Playback",
1421                                                     AC97_PHONE, 1, ac97)) < 0)
1422                                return err;
1423                }
1424        }
1425        
1426        /* build MIC controls */
1427        if (!(ac97->flags & AC97_HAS_NO_MIC)) {
1428                if (snd_ac97_try_volume_mix(ac97, AC97_MIC)) {
1429                        if ((err = snd_ac97_cmix_new(card, "Mic Playback",
1430                                                     AC97_MIC, 1, ac97)) < 0)
1431                                return err;
1432                        if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_boost, ac97))) < 0)
1433                                return err;
1434                }
1435        }
1436
1437        /* build Line controls */
1438        if (snd_ac97_try_volume_mix(ac97, AC97_LINE)) {
1439                if ((err = snd_ac97_cmix_new(card, "Line Playback",
1440                                             AC97_LINE, 1, ac97)) < 0)
1441                        return err;
1442        }
1443        
1444        /* build CD controls */
1445        if (!(ac97->flags & AC97_HAS_NO_CD)) {
1446                if (snd_ac97_try_volume_mix(ac97, AC97_CD)) {
1447                        if ((err = snd_ac97_cmix_new(card, "CD Playback",
1448                                                     AC97_CD, 1, ac97)) < 0)
1449                                return err;
1450                }
1451        }
1452        
1453        /* build Video controls */
1454        if (!(ac97->flags & AC97_HAS_NO_VIDEO)) {
1455                if (snd_ac97_try_volume_mix(ac97, AC97_VIDEO)) {
1456                        if ((err = snd_ac97_cmix_new(card, "Video Playback",
1457                                                     AC97_VIDEO, 1, ac97)) < 0)
1458                                return err;
1459                }
1460        }
1461
1462        /* build Aux controls */
1463        if (!(ac97->flags & AC97_HAS_NO_AUX)) {
1464                if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
1465                        if ((err = snd_ac97_cmix_new(card, "Aux Playback",
1466                                                     AC97_AUX, 1, ac97)) < 0)
1467                                return err;
1468                }
1469        }
1470
1471        /* build PCM controls */
1472        if (ac97->flags & AC97_AD_MULTI) {
1473                unsigned short init_val;
1474                if (ac97->flags & AC97_STEREO_MUTES)
1475                        init_val = 0x9f9f;
1476                else
1477                        init_val = 0x9f1f;
1478                for (idx = 0; idx < 2; idx++)
1479                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_pcm[idx], ac97))) < 0)
1480                                return err;
1481                set_tlv_db_scale(kctl, db_scale_5bit);
1482                ac97->spec.ad18xx.pcmreg[0] = init_val;
1483                if (ac97->scaps & AC97_SCAP_SURROUND_DAC) {
1484                        for (idx = 0; idx < 2; idx++)
1485                                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_surround[idx], ac97))) < 0)
1486                                        return err;
1487                        set_tlv_db_scale(kctl, db_scale_5bit);
1488                        ac97->spec.ad18xx.pcmreg[1] = init_val;
1489                }
1490                if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) {
1491                        for (idx = 0; idx < 2; idx++)
1492                                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_center[idx], ac97))) < 0)
1493                                        return err;
1494                        set_tlv_db_scale(kctl, db_scale_5bit);
1495                        for (idx = 0; idx < 2; idx++)
1496                                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_lfe[idx], ac97))) < 0)
1497                                        return err;
1498                        set_tlv_db_scale(kctl, db_scale_5bit);
1499                        ac97->spec.ad18xx.pcmreg[2] = init_val;
1500                }
1501                snd_ac97_write_cache(ac97, AC97_PCM, init_val);
1502        } else {
1503                if (!(ac97->flags & AC97_HAS_NO_STD_PCM)) {
1504                        if (ac97->flags & AC97_HAS_NO_PCM_VOL)
1505                                err = snd_ac97_cmute_new(card,
1506                                                         "PCM Playback Switch",
1507                                                         AC97_PCM, 0, ac97);
1508                        else
1509                                err = snd_ac97_cmix_new(card, "PCM Playback",
1510                                                        AC97_PCM, 0, ac97);
1511                        if (err < 0)
1512                                return err;
1513                }
1514        }
1515
1516        /* build Capture controls */
1517        if (!(ac97->flags & AC97_HAS_NO_REC_GAIN)) {
1518                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_src, ac97))) < 0)
1519                        return err;
1520                if (snd_ac97_try_bit(ac97, AC97_REC_GAIN, 15)) {
1521                        err = snd_ac97_cmute_new(card, "Capture Switch",
1522                                                 AC97_REC_GAIN, 0, ac97);
1523                        if (err < 0)
1524                                return err;
1525                }
1526                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_control_capture_vol, ac97))) < 0)
1527                        return err;
1528                set_tlv_db_scale(kctl, db_scale_rec_gain);
1529                snd_ac97_write_cache(ac97, AC97_REC_SEL, 0x0000);
1530                snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x0000);
1531        }
1532        /* build MIC Capture controls */
1533        if (snd_ac97_try_volume_mix(ac97, AC97_REC_GAIN_MIC)) {
1534                for (idx = 0; idx < 2; idx++)
1535                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_mic_capture[idx], ac97))) < 0)
1536                                return err;
1537                set_tlv_db_scale(kctl, db_scale_rec_gain);
1538                snd_ac97_write_cache(ac97, AC97_REC_GAIN_MIC, 0x0000);
1539        }
1540
1541        /* build PCM out path & mute control */
1542        if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 15)) {
1543                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_PCM_OUT], ac97))) < 0)
1544                        return err;
1545        }
1546
1547        /* build Simulated Stereo Enhancement control */
1548        if (ac97->caps & AC97_BC_SIM_STEREO) {
1549                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_STEREO_ENHANCEMENT], ac97))) < 0)
1550                        return err;
1551        }
1552
1553        /* build 3D Stereo Enhancement control */
1554        if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 13)) {
1555                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_3D], ac97))) < 0)
1556                        return err;
1557        }
1558
1559        /* build Loudness control */
1560        if (ac97->caps & AC97_BC_LOUDNESS) {
1561                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOUDNESS], ac97))) < 0)
1562                        return err;
1563        }
1564
1565        /* build Mono output select control */
1566        if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 9)) {
1567                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MONO], ac97))) < 0)
1568                        return err;
1569        }
1570
1571        /* build Mic select control */
1572        if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 8)) {
1573                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MIC], ac97))) < 0)
1574                        return err;
1575        }
1576
1577        /* build ADC/DAC loopback control */
1578        if (enable_loopback && snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 7)) {
1579                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOOPBACK], ac97))) < 0)
1580                        return err;
1581        }
1582
1583        snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, ~AC97_GP_DRSS_MASK, 0x0000);
1584
1585        /* build 3D controls */
1586        if (ac97->build_ops->build_3d) {
1587                ac97->build_ops->build_3d(ac97);
1588        } else {
1589                if (snd_ac97_try_volume_mix(ac97, AC97_3D_CONTROL)) {
1590                        unsigned short val;
1591                        val = 0x0707;
1592                        snd_ac97_write(ac97, AC97_3D_CONTROL, val);
1593                        val = snd_ac97_read(ac97, AC97_3D_CONTROL);
1594                        val = val == 0x0606;
1595                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
1596                                return err;
1597                        if (val)
1598                                kctl->private_value = AC97_3D_CONTROL | (9 << 8) | (7 << 16);
1599                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[1], ac97))) < 0)
1600                                return err;
1601                        if (val)
1602                                kctl->private_value = AC97_3D_CONTROL | (1 << 8) | (7 << 16);
1603                        snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
1604                }
1605        }
1606
1607        /* build S/PDIF controls */
1608
1609        /* Hack for ASUS P5P800-VM, which does not indicate S/PDIF capability */
1610        if (ac97->subsystem_vendor == 0x1043 &&
1611            ac97->subsystem_device == 0x810f)
1612                ac97->ext_id |= AC97_EI_SPDIF;
1613
1614        if ((ac97->ext_id & AC97_EI_SPDIF) && !(ac97->scaps & AC97_SCAP_NO_SPDIF)) {
1615                if (ac97->build_ops->build_spdif) {
1616                        if ((err = ac97->build_ops->build_spdif(ac97)) < 0)
1617                                return err;
1618                } else {
1619                        for (idx = 0; idx < 5; idx++)
1620                                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_spdif[idx], ac97))) < 0)
1621                                        return err;
1622                        if (ac97->build_ops->build_post_spdif) {
1623                                if ((err = ac97->build_ops->build_post_spdif(ac97)) < 0)
1624                                        return err;
1625                        }
1626                        /* set default PCM S/PDIF params */
1627                        /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
1628                        snd_ac97_write_cache(ac97, AC97_SPDIF, 0x2a20);
1629                        ac97->rates[AC97_RATES_SPDIF] = snd_ac97_determine_spdif_rates(ac97);
1630                }
1631                ac97->spdif_status = SNDRV_PCM_DEFAULT_CON_SPDIF;
1632        }
1633        
1634        /* build chip specific controls */
1635        if (ac97->build_ops->build_specific)
1636                if ((err = ac97->build_ops->build_specific(ac97)) < 0)
1637                        return err;
1638
1639        if (snd_ac97_try_bit(ac97, AC97_POWERDOWN, 15)) {
1640                kctl = snd_ac97_cnew(&snd_ac97_control_eapd, ac97);
1641                if (! kctl)
1642                        return -ENOMEM;
1643                if (ac97->scaps & AC97_SCAP_INV_EAPD)
1644                        set_inv_eapd(ac97, kctl);
1645                if ((err = snd_ctl_add(card, kctl)) < 0)
1646                        return err;
1647        }
1648
1649        return 0;
1650}
1651
1652static int snd_ac97_modem_build(struct snd_card *card, struct snd_ac97 * ac97)
1653{
1654        int err, idx;
1655
1656        /*
1657        ac97_dbg(ac97, "AC97_GPIO_CFG = %x\n",
1658               snd_ac97_read(ac97,AC97_GPIO_CFG));
1659        */
1660        snd_ac97_write(ac97, AC97_GPIO_CFG, 0xffff & ~(AC97_GPIO_LINE1_OH));
1661        snd_ac97_write(ac97, AC97_GPIO_POLARITY, 0xffff & ~(AC97_GPIO_LINE1_OH));
1662        snd_ac97_write(ac97, AC97_GPIO_STICKY, 0xffff);
1663        snd_ac97_write(ac97, AC97_GPIO_WAKEUP, 0x0);
1664        snd_ac97_write(ac97, AC97_MISC_AFE, 0x0);
1665
1666        /* build modem switches */
1667        for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_modem_switches); idx++)
1668                if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_ac97_controls_modem_switches[idx], ac97))) < 0)
1669                        return err;
1670
1671        /* build chip specific controls */
1672        if (ac97->build_ops->build_specific)
1673                if ((err = ac97->build_ops->build_specific(ac97)) < 0)
1674                        return err;
1675
1676        return 0;
1677}
1678
1679static int snd_ac97_test_rate(struct snd_ac97 *ac97, int reg, int shadow_reg, int rate)
1680{
1681        unsigned short val;
1682        unsigned int tmp;
1683
1684        tmp = ((unsigned int)rate * ac97->bus->clock) / 48000;
1685        snd_ac97_write_cache(ac97, reg, tmp & 0xffff);
1686        if (shadow_reg)
1687                snd_ac97_write_cache(ac97, shadow_reg, tmp & 0xffff);
1688        val = snd_ac97_read(ac97, reg);
1689        return val == (tmp & 0xffff);
1690}
1691
1692static void snd_ac97_determine_rates(struct snd_ac97 *ac97, int reg, int shadow_reg, unsigned int *r_result)
1693{
1694        unsigned int result = 0;
1695        unsigned short saved;
1696
1697        if (ac97->bus->no_vra) {
1698                *r_result = SNDRV_PCM_RATE_48000;
1699                if ((ac97->flags & AC97_DOUBLE_RATE) &&
1700                    reg == AC97_PCM_FRONT_DAC_RATE)
1701                        *r_result |= SNDRV_PCM_RATE_96000;
1702                return;
1703        }
1704
1705        saved = snd_ac97_read(ac97, reg);
1706        if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE)
1707                snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1708                                     AC97_EA_DRA, 0);
1709        /* test a non-standard rate */
1710        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11000))
1711                result |= SNDRV_PCM_RATE_CONTINUOUS;
1712        /* let's try to obtain standard rates */
1713        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 8000))
1714                result |= SNDRV_PCM_RATE_8000;
1715        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11025))
1716                result |= SNDRV_PCM_RATE_11025;
1717        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 16000))
1718                result |= SNDRV_PCM_RATE_16000;
1719        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 22050))
1720                result |= SNDRV_PCM_RATE_22050;
1721        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 32000))
1722                result |= SNDRV_PCM_RATE_32000;
1723        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 44100))
1724                result |= SNDRV_PCM_RATE_44100;
1725        if (snd_ac97_test_rate(ac97, reg, shadow_reg, 48000))
1726                result |= SNDRV_PCM_RATE_48000;
1727        if ((ac97->flags & AC97_DOUBLE_RATE) &&
1728            reg == AC97_PCM_FRONT_DAC_RATE) {
1729                /* test standard double rates */
1730                snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1731                                     AC97_EA_DRA, AC97_EA_DRA);
1732                if (snd_ac97_test_rate(ac97, reg, shadow_reg, 64000 / 2))
1733                        result |= SNDRV_PCM_RATE_64000;
1734                if (snd_ac97_test_rate(ac97, reg, shadow_reg, 88200 / 2))
1735                        result |= SNDRV_PCM_RATE_88200;
1736                if (snd_ac97_test_rate(ac97, reg, shadow_reg, 96000 / 2))
1737                        result |= SNDRV_PCM_RATE_96000;
1738                /* some codecs don't support variable double rates */
1739                if (!snd_ac97_test_rate(ac97, reg, shadow_reg, 76100 / 2))
1740                        result &= ~SNDRV_PCM_RATE_CONTINUOUS;
1741                snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
1742                                     AC97_EA_DRA, 0);
1743        }
1744        /* restore the default value */
1745        snd_ac97_write_cache(ac97, reg, saved);
1746        if (shadow_reg)
1747                snd_ac97_write_cache(ac97, shadow_reg, saved);
1748        *r_result = result;
1749}
1750
1751/* check AC97_SPDIF register to accept which sample rates */
1752static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97)
1753{
1754        unsigned int result = 0;
1755        int i;
1756        static unsigned short ctl_bits[] = {
1757                AC97_SC_SPSR_44K, AC97_SC_SPSR_32K, AC97_SC_SPSR_48K
1758        };
1759        static unsigned int rate_bits[] = {
1760                SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_32000, SNDRV_PCM_RATE_48000
1761        };
1762
1763        for (i = 0; i < (int)ARRAY_SIZE(ctl_bits); i++) {
1764                snd_ac97_update_bits(ac97, AC97_SPDIF, AC97_SC_SPSR_MASK, ctl_bits[i]);
1765                if ((snd_ac97_read(ac97, AC97_SPDIF) & AC97_SC_SPSR_MASK) == ctl_bits[i])
1766                        result |= rate_bits[i];
1767        }
1768        return result;
1769}
1770
1771/* look for the codec id table matching with the given id */
1772static const struct ac97_codec_id *look_for_codec_id(const struct ac97_codec_id *table,
1773                                                     unsigned int id)
1774{
1775        const struct ac97_codec_id *pid;
1776
1777        for (pid = table; pid->id; pid++)
1778                if (pid->id == (id & pid->mask))
1779                        return pid;
1780        return NULL;
1781}
1782
1783void snd_ac97_get_name(struct snd_ac97 *ac97, unsigned int id, char *name, int modem)
1784{
1785        const struct ac97_codec_id *pid;
1786
1787        sprintf(name, "0x%x %c%c%c", id,
1788                printable(id >> 24),
1789                printable(id >> 16),
1790                printable(id >> 8));
1791        pid = look_for_codec_id(snd_ac97_codec_id_vendors, id);
1792        if (! pid)
1793                return;
1794
1795        strcpy(name, pid->name);
1796        if (ac97 && pid->patch) {
1797                if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
1798                    (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
1799                        pid->patch(ac97);
1800        } 
1801
1802        pid = look_for_codec_id(snd_ac97_codec_ids, id);
1803        if (pid) {
1804                strcat(name, " ");
1805                strcat(name, pid->name);
1806                if (pid->mask != 0xffffffff)
1807                        sprintf(name + strlen(name), " rev %d", id & ~pid->mask);
1808                if (ac97 && pid->patch) {
1809                        if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
1810                            (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
1811                                pid->patch(ac97);
1812                }
1813        } else
1814                sprintf(name + strlen(name), " id %x", id & 0xff);
1815}
1816
1817/**
1818 * snd_ac97_get_short_name - retrieve codec name
1819 * @ac97: the codec instance
1820 *
1821 * Return: The short identifying name of the codec.
1822 */
1823const char *snd_ac97_get_short_name(struct snd_ac97 *ac97)
1824{
1825        const struct ac97_codec_id *pid;
1826
1827        for (pid = snd_ac97_codec_ids; pid->id; pid++)
1828                if (pid->id == (ac97->id & pid->mask))
1829                        return pid->name;
1830        return "unknown codec";
1831}
1832
1833EXPORT_SYMBOL(snd_ac97_get_short_name);
1834
1835/* wait for a while until registers are accessible after RESET
1836 * return 0 if ok, negative not ready
1837 */
1838static int ac97_reset_wait(struct snd_ac97 *ac97, int timeout, int with_modem)
1839{
1840        unsigned long end_time;
1841        unsigned short val;
1842
1843        end_time = jiffies + timeout;
1844        do {
1845                
1846                /* use preliminary reads to settle the communication */
1847                snd_ac97_read(ac97, AC97_RESET);
1848                snd_ac97_read(ac97, AC97_VENDOR_ID1);
1849                snd_ac97_read(ac97, AC97_VENDOR_ID2);
1850                /* modem? */
1851                if (with_modem) {
1852                        val = snd_ac97_read(ac97, AC97_EXTENDED_MID);
1853                        if (val != 0xffff && (val & 1) != 0)
1854                                return 0;
1855                }
1856                if (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) {
1857                        /* probably only Xbox issue - all registers are read as zero */
1858                        val = snd_ac97_read(ac97, AC97_VENDOR_ID1);
1859                        if (val != 0 && val != 0xffff)
1860                                return 0;
1861                } else {
1862                        /* because the PCM or MASTER volume registers can be modified,
1863                         * the REC_GAIN register is used for tests
1864                         */
1865                        /* test if we can write to the record gain volume register */
1866                        snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a05);
1867                        if ((snd_ac97_read(ac97, AC97_REC_GAIN) & 0x7fff) == 0x0a05)
1868                                return 0;
1869                }
1870                schedule_timeout_uninterruptible(1);
1871        } while (time_after_eq(end_time, jiffies));
1872        return -ENODEV;
1873}
1874
1875/**
1876 * snd_ac97_bus - create an AC97 bus component
1877 * @card: the card instance
1878 * @num: the bus number
1879 * @ops: the bus callbacks table
1880 * @private_data: private data pointer for the new instance
1881 * @rbus: the pointer to store the new AC97 bus instance.
1882 *
1883 * Creates an AC97 bus component.  An struct snd_ac97_bus instance is newly
1884 * allocated and initialized.
1885 *
1886 * The ops table must include valid callbacks (at least read and
1887 * write).  The other callbacks, wait and reset, are not mandatory.
1888 * 
1889 * The clock is set to 48000.  If another clock is needed, set
1890 * ``(*rbus)->clock`` manually.
1891 *
1892 * The AC97 bus instance is registered as a low-level device, so you don't
1893 * have to release it manually.
1894 *
1895 * Return: Zero if successful, or a negative error code on failure.
1896 */
1897int snd_ac97_bus(struct snd_card *card, int num, struct snd_ac97_bus_ops *ops,
1898                 void *private_data, struct snd_ac97_bus **rbus)
1899{
1900        int err;
1901        struct snd_ac97_bus *bus;
1902        static struct snd_device_ops dev_ops = {
1903                .dev_free =     snd_ac97_bus_dev_free,
1904        };
1905
1906        if (snd_BUG_ON(!card))
1907                return -EINVAL;
1908        bus = kzalloc(sizeof(*bus), GFP_KERNEL);
1909        if (bus == NULL)
1910                return -ENOMEM;
1911        bus->card = card;
1912        bus->num = num;
1913        bus->ops = ops;
1914        bus->private_data = private_data;
1915        bus->clock = 48000;
1916        spin_lock_init(&bus->bus_lock);
1917        snd_ac97_bus_proc_init(bus);
1918        if ((err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops)) < 0) {
1919                snd_ac97_bus_free(bus);
1920                return err;
1921        }
1922        if (rbus)
1923                *rbus = bus;
1924        return 0;
1925}
1926
1927EXPORT_SYMBOL(snd_ac97_bus);
1928
1929/* stop no dev release warning */
1930static void ac97_device_release(struct device * dev)
1931{
1932}
1933
1934/* register ac97 codec to bus */
1935static int snd_ac97_dev_register(struct snd_device *device)
1936{
1937        struct snd_ac97 *ac97 = device->device_data;
1938        int err;
1939
1940        ac97->dev.bus = &ac97_bus_type;
1941        ac97->dev.parent = ac97->bus->card->dev;
1942        ac97->dev.release = ac97_device_release;
1943        dev_set_name(&ac97->dev, "%d-%d:%s",
1944                     ac97->bus->card->number, ac97->num,
1945                     snd_ac97_get_short_name(ac97));
1946        if ((err = device_register(&ac97->dev)) < 0) {
1947                ac97_err(ac97, "Can't register ac97 bus\n");
1948                ac97->dev.bus = NULL;
1949                return err;
1950        }
1951        return 0;
1952}
1953
1954/* disconnect ac97 codec */
1955static int snd_ac97_dev_disconnect(struct snd_device *device)
1956{
1957        struct snd_ac97 *ac97 = device->device_data;
1958        if (ac97->dev.bus)
1959                device_unregister(&ac97->dev);
1960        return 0;
1961}
1962
1963/* build_ops to do nothing */
1964static const struct snd_ac97_build_ops null_build_ops;
1965
1966#ifdef CONFIG_SND_AC97_POWER_SAVE
1967static void do_update_power(struct work_struct *work)
1968{
1969        update_power_regs(
1970                container_of(work, struct snd_ac97, power_work.work));
1971}
1972#endif
1973
1974/**
1975 * snd_ac97_mixer - create an Codec97 component
1976 * @bus: the AC97 bus which codec is attached to
1977 * @template: the template of ac97, including index, callbacks and
1978 *         the private data.
1979 * @rac97: the pointer to store the new ac97 instance.
1980 *
1981 * Creates an Codec97 component.  An struct snd_ac97 instance is newly
1982 * allocated and initialized from the template.  The codec
1983 * is then initialized by the standard procedure.
1984 *
1985 * The template must include the codec number (num) and address (addr),
1986 * and the private data (private_data).
1987 * 
1988 * The ac97 instance is registered as a low-level device, so you don't
1989 * have to release it manually.
1990 *
1991 * Return: Zero if successful, or a negative error code on failure.
1992 */
1993int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template, struct snd_ac97 **rac97)
1994{
1995        int err;
1996        struct snd_ac97 *ac97;
1997        struct snd_card *card;
1998        char name[64];
1999        unsigned long end_time;
2000        unsigned int reg;
2001        const struct ac97_codec_id *pid;
2002        static struct snd_device_ops ops = {
2003                .dev_free =     snd_ac97_dev_free,
2004                .dev_register = snd_ac97_dev_register,
2005                .dev_disconnect =       snd_ac97_dev_disconnect,
2006        };
2007
2008        if (rac97)
2009                *rac97 = NULL;
2010        if (snd_BUG_ON(!bus || !template))
2011                return -EINVAL;
2012        if (snd_BUG_ON(template->num >= 4))
2013                return -EINVAL;
2014        if (bus->codec[template->num])
2015                return -EBUSY;
2016
2017        card = bus->card;
2018        ac97 = kzalloc(sizeof(*ac97), GFP_KERNEL);
2019        if (ac97 == NULL)
2020                return -ENOMEM;
2021        ac97->private_data = template->private_data;
2022        ac97->private_free = template->private_free;
2023        ac97->bus = bus;
2024        ac97->pci = template->pci;
2025        ac97->num = template->num;
2026        ac97->addr = template->addr;
2027        ac97->scaps = template->scaps;
2028        ac97->res_table = template->res_table;
2029        bus->codec[ac97->num] = ac97;
2030        mutex_init(&ac97->reg_mutex);
2031        mutex_init(&ac97->page_mutex);
2032#ifdef CONFIG_SND_AC97_POWER_SAVE
2033        INIT_DELAYED_WORK(&ac97->power_work, do_update_power);
2034#endif
2035
2036#ifdef CONFIG_PCI
2037        if (ac97->pci) {
2038                pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_VENDOR_ID, &ac97->subsystem_vendor);
2039                pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_ID, &ac97->subsystem_device);
2040        }
2041#endif
2042        if (bus->ops->reset) {
2043                bus->ops->reset(ac97);
2044                goto __access_ok;
2045        }
2046
2047        ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
2048        ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
2049        if (ac97->id && ac97->id != (unsigned int)-1) {
2050                pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
2051                if (pid && (pid->flags & AC97_DEFAULT_POWER_OFF))
2052                        goto __access_ok;
2053        }
2054
2055        /* reset to defaults */
2056        if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO))
2057                snd_ac97_write(ac97, AC97_RESET, 0);
2058        if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM))
2059                snd_ac97_write(ac97, AC97_EXTENDED_MID, 0);
2060        if (bus->ops->wait)
2061                bus->ops->wait(ac97);
2062        else {
2063                udelay(50);
2064                if (ac97->scaps & AC97_SCAP_SKIP_AUDIO)
2065                        err = ac97_reset_wait(ac97, msecs_to_jiffies(500), 1);
2066                else {
2067                        err = ac97_reset_wait(ac97, msecs_to_jiffies(500), 0);
2068                        if (err < 0)
2069                                err = ac97_reset_wait(ac97,
2070                                                      msecs_to_jiffies(500), 1);
2071                }
2072                if (err < 0) {
2073                        ac97_warn(ac97, "AC'97 %d does not respond - RESET\n",
2074                                 ac97->num);
2075                        /* proceed anyway - it's often non-critical */
2076                }
2077        }
2078      __access_ok:
2079        ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
2080        ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
2081        if (! (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) &&
2082            (ac97->id == 0x00000000 || ac97->id == 0xffffffff)) {
2083                ac97_err(ac97,
2084                         "AC'97 %d access is not valid [0x%x], removing mixer.\n",
2085                         ac97->num, ac97->id);
2086                snd_ac97_free(ac97);
2087                return -EIO;
2088        }
2089        pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
2090        if (pid)
2091                ac97->flags |= pid->flags;
2092        
2093        /* test for AC'97 */
2094        if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO) && !(ac97->scaps & AC97_SCAP_AUDIO)) {
2095                /* test if we can write to the record gain volume register */
2096                snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a06);
2097                if (((err = snd_ac97_read(ac97, AC97_REC_GAIN)) & 0x7fff) == 0x0a06)
2098                        ac97->scaps |= AC97_SCAP_AUDIO;
2099        }
2100        if (ac97->scaps & AC97_SCAP_AUDIO) {
2101                ac97->caps = snd_ac97_read(ac97, AC97_RESET);
2102                ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID);
2103                if (ac97->ext_id == 0xffff)     /* invalid combination */
2104                        ac97->ext_id = 0;
2105        }
2106
2107        /* test for MC'97 */
2108        if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM) && !(ac97->scaps & AC97_SCAP_MODEM)) {
2109                ac97->ext_mid = snd_ac97_read(ac97, AC97_EXTENDED_MID);
2110                if (ac97->ext_mid == 0xffff)    /* invalid combination */
2111                        ac97->ext_mid = 0;
2112                if (ac97->ext_mid & 1)
2113                        ac97->scaps |= AC97_SCAP_MODEM;
2114        }
2115
2116        if (!ac97_is_audio(ac97) && !ac97_is_modem(ac97)) {
2117                if (!(ac97->scaps & (AC97_SCAP_SKIP_AUDIO|AC97_SCAP_SKIP_MODEM)))
2118                        ac97_err(ac97,
2119                                 "AC'97 %d access error (not audio or modem codec)\n",
2120                                 ac97->num);
2121                snd_ac97_free(ac97);
2122                return -EACCES;
2123        }
2124
2125        if (bus->ops->reset) // FIXME: always skipping?
2126                goto __ready_ok;
2127
2128        /* FIXME: add powerdown control */
2129        if (ac97_is_audio(ac97)) {
2130                /* nothing should be in powerdown mode */
2131                snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
2132                if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
2133                        snd_ac97_write_cache(ac97, AC97_RESET, 0); /* reset to defaults */
2134                        udelay(100);
2135                        snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
2136                }
2137                /* nothing should be in powerdown mode */
2138                snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0);
2139                end_time = jiffies + msecs_to_jiffies(5000);
2140                do {
2141                        if ((snd_ac97_read(ac97, AC97_POWERDOWN) & 0x0f) == 0x0f)
2142                                goto __ready_ok;
2143                        schedule_timeout_uninterruptible(1);
2144                } while (time_after_eq(end_time, jiffies));
2145                ac97_warn(ac97,
2146                          "AC'97 %d analog subsections not ready\n", ac97->num);
2147        }
2148
2149        /* FIXME: add powerdown control */
2150        if (ac97_is_modem(ac97)) {
2151                unsigned char tmp;
2152
2153                /* nothing should be in powerdown mode */
2154                /* note: it's important to set the rate at first */
2155                tmp = AC97_MEA_GPIO;
2156                if (ac97->ext_mid & AC97_MEI_LINE1) {
2157                        snd_ac97_write_cache(ac97, AC97_LINE1_RATE, 8000);
2158                        tmp |= AC97_MEA_ADC1 | AC97_MEA_DAC1;
2159                }
2160                if (ac97->ext_mid & AC97_MEI_LINE2) {
2161                        snd_ac97_write_cache(ac97, AC97_LINE2_RATE, 8000);
2162                        tmp |= AC97_MEA_ADC2 | AC97_MEA_DAC2;
2163                }
2164                if (ac97->ext_mid & AC97_MEI_HANDSET) {
2165                        snd_ac97_write_cache(ac97, AC97_HANDSET_RATE, 8000);
2166                        tmp |= AC97_MEA_HADC | AC97_MEA_HDAC;
2167                }
2168                snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0);
2169                udelay(100);
2170                /* nothing should be in powerdown mode */
2171                snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0);
2172                end_time = jiffies + msecs_to_jiffies(100);
2173                do {
2174                        if ((snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS) & tmp) == tmp)
2175                                goto __ready_ok;
2176                        schedule_timeout_uninterruptible(1);
2177                } while (time_after_eq(end_time, jiffies));
2178                ac97_warn(ac97,
2179                          "MC'97 %d converters and GPIO not ready (0x%x)\n",
2180                          ac97->num,
2181                          snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS));
2182        }
2183        
2184      __ready_ok:
2185        if (ac97_is_audio(ac97))
2186                ac97->addr = (ac97->ext_id & AC97_EI_ADDR_MASK) >> AC97_EI_ADDR_SHIFT;
2187        else
2188                ac97->addr = (ac97->ext_mid & AC97_MEI_ADDR_MASK) >> AC97_MEI_ADDR_SHIFT;
2189        if (ac97->ext_id & 0x01c9) {    /* L/R, MIC, SDAC, LDAC VRA support */
2190                reg = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
2191                reg |= ac97->ext_id & 0x01c0; /* LDAC/SDAC/CDAC */
2192                if (! bus->no_vra)
2193                        reg |= ac97->ext_id & 0x0009; /* VRA/VRM */
2194                snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, reg);
2195        }
2196        if ((ac97->ext_id & AC97_EI_DRA) && bus->dra) {
2197                /* Intel controllers require double rate data to be put in
2198                 * slots 7+8, so let's hope the codec supports it. */
2199                snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, AC97_GP_DRSS_MASK, AC97_GP_DRSS_78);
2200                if ((snd_ac97_read(ac97, AC97_GENERAL_PURPOSE) & AC97_GP_DRSS_MASK) == AC97_GP_DRSS_78)
2201                        ac97->flags |= AC97_DOUBLE_RATE;
2202                /* restore to slots 10/11 to avoid the confliction with surrounds */
2203                snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, AC97_GP_DRSS_MASK, 0);
2204        }
2205        if (ac97->ext_id & AC97_EI_VRA) {       /* VRA support */
2206                snd_ac97_determine_rates(ac97, AC97_PCM_FRONT_DAC_RATE, 0, &ac97->rates[AC97_RATES_FRONT_DAC]);
2207                snd_ac97_determine_rates(ac97, AC97_PCM_LR_ADC_RATE, 0, &ac97->rates[AC97_RATES_ADC]);
2208        } else {
2209                ac97->rates[AC97_RATES_FRONT_DAC] = SNDRV_PCM_RATE_48000;
2210                if (ac97->flags & AC97_DOUBLE_RATE)
2211                        ac97->rates[AC97_RATES_FRONT_DAC] |= SNDRV_PCM_RATE_96000;
2212                ac97->rates[AC97_RATES_ADC] = SNDRV_PCM_RATE_48000;
2213        }
2214        if (ac97->ext_id & AC97_EI_SPDIF) {
2215                /* codec specific code (patch) should override these values */
2216                ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_32000;
2217        }
2218        if (ac97->ext_id & AC97_EI_VRM) {       /* MIC VRA support */
2219                snd_ac97_determine_rates(ac97, AC97_PCM_MIC_ADC_RATE, 0, &ac97->rates[AC97_RATES_MIC_ADC]);
2220        } else {
2221                ac97->rates[AC97_RATES_MIC_ADC] = SNDRV_PCM_RATE_48000;
2222        }
2223        if (ac97->ext_id & AC97_EI_SDAC) {      /* SDAC support */
2224                snd_ac97_determine_rates(ac97, AC97_PCM_SURR_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_SURR_DAC]);
2225                ac97->scaps |= AC97_SCAP_SURROUND_DAC;
2226        }
2227        if (ac97->ext_id & AC97_EI_LDAC) {      /* LDAC support */
2228                snd_ac97_determine_rates(ac97, AC97_PCM_LFE_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_LFE_DAC]);
2229                ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC;
2230        }
2231        /* additional initializations */
2232        if (bus->ops->init)
2233                bus->ops->init(ac97);
2234        snd_ac97_get_name(ac97, ac97->id, name, !ac97_is_audio(ac97));
2235        snd_ac97_get_name(NULL, ac97->id, name, !ac97_is_audio(ac97));  // ac97->id might be changed in the special setup code
2236        if (! ac97->build_ops)
2237                ac97->build_ops = &null_build_ops;
2238
2239        if (ac97_is_audio(ac97)) {
2240                char comp[16];
2241                if (card->mixername[0] == '\0') {
2242                        strcpy(card->mixername, name);
2243                } else {
2244                        if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
2245                                strcat(card->mixername, ",");
2246                                strcat(card->mixername, name);
2247                        }
2248                }
2249                sprintf(comp, "AC97a:%08x", ac97->id);
2250                if ((err = snd_component_add(card, comp)) < 0) {
2251                        snd_ac97_free(ac97);
2252                        return err;
2253                }
2254                if (snd_ac97_mixer_build(ac97) < 0) {
2255                        snd_ac97_free(ac97);
2256                        return -ENOMEM;
2257                }
2258        }
2259        if (ac97_is_modem(ac97)) {
2260                char comp[16];
2261                if (card->mixername[0] == '\0') {
2262                        strcpy(card->mixername, name);
2263                } else {
2264                        if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
2265                                strcat(card->mixername, ",");
2266                                strcat(card->mixername, name);
2267                        }
2268                }
2269                sprintf(comp, "AC97m:%08x", ac97->id);
2270                if ((err = snd_component_add(card, comp)) < 0) {
2271                        snd_ac97_free(ac97);
2272                        return err;
2273                }
2274                if (snd_ac97_modem_build(card, ac97) < 0) {
2275                        snd_ac97_free(ac97);
2276                        return -ENOMEM;
2277                }
2278        }
2279        if (ac97_is_audio(ac97))
2280                update_power_regs(ac97);
2281        snd_ac97_proc_init(ac97);
2282        if ((err = snd_device_new(card, SNDRV_DEV_CODEC, ac97, &ops)) < 0) {
2283                snd_ac97_free(ac97);
2284                return err;
2285        }
2286        *rac97 = ac97;
2287        return 0;
2288}
2289
2290EXPORT_SYMBOL(snd_ac97_mixer);
2291
2292/*
2293 * Power down the chip.
2294 *
2295 * MASTER and HEADPHONE registers are muted but the register cache values
2296 * are not changed, so that the values can be restored in snd_ac97_resume().
2297 */
2298static void snd_ac97_powerdown(struct snd_ac97 *ac97)
2299{
2300        unsigned short power;
2301
2302        if (ac97_is_audio(ac97)) {
2303                /* some codecs have stereo mute bits */
2304                snd_ac97_write(ac97, AC97_MASTER, 0x9f9f);
2305                snd_ac97_write(ac97, AC97_HEADPHONE, 0x9f9f);
2306        }
2307
2308        /* surround, CLFE, mic powerdown */
2309        power = ac97->regs[AC97_EXTENDED_STATUS];
2310        if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
2311                power |= AC97_EA_PRJ;
2312        if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
2313                power |= AC97_EA_PRI | AC97_EA_PRK;
2314        power |= AC97_EA_PRL;
2315        snd_ac97_write(ac97, AC97_EXTENDED_STATUS, power);
2316
2317        /* powerdown external amplifier */
2318        if (ac97->scaps & AC97_SCAP_INV_EAPD)
2319                power = ac97->regs[AC97_POWERDOWN] & ~AC97_PD_EAPD;
2320        else if (! (ac97->scaps & AC97_SCAP_EAPD_LED))
2321                power = ac97->regs[AC97_POWERDOWN] | AC97_PD_EAPD;
2322        power |= AC97_PD_PR6;   /* Headphone amplifier powerdown */
2323        power |= AC97_PD_PR0 | AC97_PD_PR1;     /* ADC & DAC powerdown */
2324        snd_ac97_write(ac97, AC97_POWERDOWN, power);
2325        udelay(100);
2326        power |= AC97_PD_PR2;   /* Analog Mixer powerdown (Vref on) */
2327        snd_ac97_write(ac97, AC97_POWERDOWN, power);
2328        if (ac97_is_power_save_mode(ac97)) {
2329                power |= AC97_PD_PR3;   /* Analog Mixer powerdown */
2330                snd_ac97_write(ac97, AC97_POWERDOWN, power);
2331                udelay(100);
2332                /* AC-link powerdown, internal Clk disable */
2333                /* FIXME: this may cause click noises on some boards */
2334                power |= AC97_PD_PR4 | AC97_PD_PR5;
2335                snd_ac97_write(ac97, AC97_POWERDOWN, power);
2336        }
2337}
2338
2339
2340struct ac97_power_reg {
2341        unsigned short reg;
2342        unsigned short power_reg;
2343        unsigned short mask;
2344};
2345
2346enum { PWIDX_ADC, PWIDX_FRONT, PWIDX_CLFE, PWIDX_SURR, PWIDX_MIC, PWIDX_SIZE };
2347
2348static struct ac97_power_reg power_regs[PWIDX_SIZE] = {
2349        [PWIDX_ADC] = { AC97_PCM_LR_ADC_RATE, AC97_POWERDOWN, AC97_PD_PR0},
2350        [PWIDX_FRONT] = { AC97_PCM_FRONT_DAC_RATE, AC97_POWERDOWN, AC97_PD_PR1},
2351        [PWIDX_CLFE] = { AC97_PCM_LFE_DAC_RATE, AC97_EXTENDED_STATUS,
2352                         AC97_EA_PRI | AC97_EA_PRK},
2353        [PWIDX_SURR] = { AC97_PCM_SURR_DAC_RATE, AC97_EXTENDED_STATUS,
2354                         AC97_EA_PRJ},
2355        [PWIDX_MIC] = { AC97_PCM_MIC_ADC_RATE, AC97_EXTENDED_STATUS,
2356                        AC97_EA_PRL},
2357};
2358
2359#ifdef CONFIG_SND_AC97_POWER_SAVE
2360/**
2361 * snd_ac97_update_power - update the powerdown register
2362 * @ac97: the codec instance
2363 * @reg: the rate register, e.g. AC97_PCM_FRONT_DAC_RATE
2364 * @powerup: non-zero when power up the part
2365 *
2366 * Update the AC97 powerdown register bits of the given part.
2367 *
2368 * Return: Zero.
2369 */
2370int snd_ac97_update_power(struct snd_ac97 *ac97, int reg, int powerup)
2371{
2372        int i;
2373
2374        if (! ac97)
2375                return 0;
2376
2377        if (reg) {
2378                /* SPDIF requires DAC power, too */
2379                if (reg == AC97_SPDIF)
2380                        reg = AC97_PCM_FRONT_DAC_RATE;
2381                for (i = 0; i < PWIDX_SIZE; i++) {
2382                        if (power_regs[i].reg == reg) {
2383                                if (powerup)
2384                                        ac97->power_up |= (1 << i);
2385                                else
2386                                        ac97->power_up &= ~(1 << i);
2387                                break;
2388                        }
2389                }
2390        }
2391
2392        if (ac97_is_power_save_mode(ac97) && !powerup)
2393                /* adjust power-down bits after two seconds delay
2394                 * (for avoiding loud click noises for many (OSS) apps
2395                 *  that open/close frequently)
2396                 */
2397                schedule_delayed_work(&ac97->power_work,
2398                                      msecs_to_jiffies(power_save * 1000));
2399        else {
2400                cancel_delayed_work(&ac97->power_work);
2401                update_power_regs(ac97);
2402        }
2403
2404        return 0;
2405}
2406
2407EXPORT_SYMBOL(snd_ac97_update_power);
2408#endif /* CONFIG_SND_AC97_POWER_SAVE */
2409
2410static void update_power_regs(struct snd_ac97 *ac97)
2411{
2412        unsigned int power_up, bits;
2413        int i;
2414
2415        power_up = (1 << PWIDX_FRONT) | (1 << PWIDX_ADC);
2416        power_up |= (1 << PWIDX_MIC);
2417        if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
2418                power_up |= (1 << PWIDX_SURR);
2419        if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
2420                power_up |= (1 << PWIDX_CLFE);
2421#ifdef CONFIG_SND_AC97_POWER_SAVE
2422        if (ac97_is_power_save_mode(ac97))
2423                power_up = ac97->power_up;
2424#endif
2425        if (power_up) {
2426                if (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2) {
2427                        /* needs power-up analog mix and vref */
2428                        snd_ac97_update_bits(ac97, AC97_POWERDOWN,
2429                                             AC97_PD_PR3, 0);
2430                        msleep(1);
2431                        snd_ac97_update_bits(ac97, AC97_POWERDOWN,
2432                                             AC97_PD_PR2, 0);
2433                }
2434        }
2435        for (i = 0; i < PWIDX_SIZE; i++) {
2436                if (power_up & (1 << i))
2437                        bits = 0;
2438                else
2439                        bits = power_regs[i].mask;
2440                snd_ac97_update_bits(ac97, power_regs[i].power_reg,
2441                                     power_regs[i].mask, bits);
2442        }
2443        if (! power_up) {
2444                if (! (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2)) {
2445                        /* power down analog mix and vref */
2446                        snd_ac97_update_bits(ac97, AC97_POWERDOWN,
2447                                             AC97_PD_PR2, AC97_PD_PR2);
2448                        snd_ac97_update_bits(ac97, AC97_POWERDOWN,
2449                                             AC97_PD_PR3, AC97_PD_PR3);
2450                }
2451        }
2452}
2453
2454
2455#ifdef CONFIG_PM
2456/**
2457 * snd_ac97_suspend - General suspend function for AC97 codec
2458 * @ac97: the ac97 instance
2459 *
2460 * Suspends the codec, power down the chip.
2461 */
2462void snd_ac97_suspend(struct snd_ac97 *ac97)
2463{
2464        if (! ac97)
2465                return;
2466        if (ac97->build_ops->suspend)
2467                ac97->build_ops->suspend(ac97);
2468#ifdef CONFIG_SND_AC97_POWER_SAVE
2469        cancel_delayed_work_sync(&ac97->power_work);
2470#endif
2471        snd_ac97_powerdown(ac97);
2472}
2473
2474EXPORT_SYMBOL(snd_ac97_suspend);
2475
2476/*
2477 * restore ac97 status
2478 */
2479static void snd_ac97_restore_status(struct snd_ac97 *ac97)
2480{
2481        int i;
2482
2483        for (i = 2; i < 0x7c ; i += 2) {
2484                if (i == AC97_POWERDOWN || i == AC97_EXTENDED_ID)
2485                        continue;
2486                /* restore only accessible registers
2487                 * some chip (e.g. nm256) may hang up when unsupported registers
2488                 * are accessed..!
2489                 */
2490                if (test_bit(i, ac97->reg_accessed)) {
2491                        snd_ac97_write(ac97, i, ac97->regs[i]);
2492                        snd_ac97_read(ac97, i);
2493                }
2494        }
2495}
2496
2497/*
2498 * restore IEC958 status
2499 */
2500static void snd_ac97_restore_iec958(struct snd_ac97 *ac97)
2501{
2502        if (ac97->ext_id & AC97_EI_SPDIF) {
2503                if (ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_SPDIF) {
2504                        /* reset spdif status */
2505                        snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
2506                        snd_ac97_write(ac97, AC97_EXTENDED_STATUS, ac97->regs[AC97_EXTENDED_STATUS]);
2507                        if (ac97->flags & AC97_CS_SPDIF)
2508                                snd_ac97_write(ac97, AC97_CSR_SPDIF, ac97->regs[AC97_CSR_SPDIF]);
2509                        else
2510                                snd_ac97_write(ac97, AC97_SPDIF, ac97->regs[AC97_SPDIF]);
2511                        snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
2512                }
2513        }
2514}
2515
2516/**
2517 * snd_ac97_resume - General resume function for AC97 codec
2518 * @ac97: the ac97 instance
2519 *
2520 * Do the standard resume procedure, power up and restoring the
2521 * old register values.
2522 */
2523void snd_ac97_resume(struct snd_ac97 *ac97)
2524{
2525        unsigned long end_time;
2526
2527        if (! ac97)
2528                return;
2529
2530        if (ac97->bus->ops->reset) {
2531                ac97->bus->ops->reset(ac97);
2532                goto  __reset_ready;
2533        }
2534
2535        snd_ac97_write(ac97, AC97_POWERDOWN, 0);
2536        if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
2537                if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO))
2538                        snd_ac97_write(ac97, AC97_RESET, 0);
2539                else if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM))
2540                        snd_ac97_write(ac97, AC97_EXTENDED_MID, 0);
2541                udelay(100);
2542                snd_ac97_write(ac97, AC97_POWERDOWN, 0);
2543        }
2544        snd_ac97_write(ac97, AC97_GENERAL_PURPOSE, 0);
2545
2546        snd_ac97_write(ac97, AC97_POWERDOWN, ac97->regs[AC97_POWERDOWN]);
2547        if (ac97_is_audio(ac97)) {
2548                ac97->bus->ops->write(ac97, AC97_MASTER, 0x8101);
2549                end_time = jiffies + msecs_to_jiffies(100);
2550                do {
2551                        if (snd_ac97_read(ac97, AC97_MASTER) == 0x8101)
2552                                break;
2553                        schedule_timeout_uninterruptible(1);
2554                } while (time_after_eq(end_time, jiffies));
2555                /* FIXME: extra delay */
2556                ac97->bus->ops->write(ac97, AC97_MASTER, AC97_MUTE_MASK_MONO);
2557                if (snd_ac97_read(ac97, AC97_MASTER) != AC97_MUTE_MASK_MONO)
2558                        msleep(250);
2559        } else {
2560                end_time = jiffies + msecs_to_jiffies(100);
2561                do {
2562                        unsigned short val = snd_ac97_read(ac97, AC97_EXTENDED_MID);
2563                        if (val != 0xffff && (val & 1) != 0)
2564                                break;
2565                        schedule_timeout_uninterruptible(1);
2566                } while (time_after_eq(end_time, jiffies));
2567        }
2568__reset_ready:
2569
2570        if (ac97->bus->ops->init)
2571                ac97->bus->ops->init(ac97);
2572
2573        if (ac97->build_ops->resume)
2574                ac97->build_ops->resume(ac97);
2575        else {
2576                snd_ac97_restore_status(ac97);
2577                snd_ac97_restore_iec958(ac97);
2578        }
2579}
2580
2581EXPORT_SYMBOL(snd_ac97_resume);
2582#endif
2583
2584
2585/*
2586 * Hardware tuning
2587 */
2588static void set_ctl_name(char *dst, const char *src, const char *suffix)
2589{
2590        if (suffix)
2591                sprintf(dst, "%s %s", src, suffix);
2592        else
2593                strcpy(dst, src);
2594}       
2595
2596/* remove the control with the given name and optional suffix */
2597static int snd_ac97_remove_ctl(struct snd_ac97 *ac97, const char *name,
2598                               const char *suffix)
2599{
2600        struct snd_ctl_elem_id id;
2601        memset(&id, 0, sizeof(id));
2602        set_ctl_name(id.name, name, suffix);
2603        id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2604        return snd_ctl_remove_id(ac97->bus->card, &id);
2605}
2606
2607static struct snd_kcontrol *ctl_find(struct snd_ac97 *ac97, const char *name, const char *suffix)
2608{
2609        struct snd_ctl_elem_id sid;
2610        memset(&sid, 0, sizeof(sid));
2611        set_ctl_name(sid.name, name, suffix);
2612        sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2613        return snd_ctl_find_id(ac97->bus->card, &sid);
2614}
2615
2616/* rename the control with the given name and optional suffix */
2617static int snd_ac97_rename_ctl(struct snd_ac97 *ac97, const char *src,
2618                               const char *dst, const char *suffix)
2619{
2620        struct snd_kcontrol *kctl = ctl_find(ac97, src, suffix);
2621        if (kctl) {
2622                set_ctl_name(kctl->id.name, dst, suffix);
2623                return 0;
2624        }
2625        return -ENOENT;
2626}
2627
2628/* rename both Volume and Switch controls - don't check the return value */
2629static void snd_ac97_rename_vol_ctl(struct snd_ac97 *ac97, const char *src,
2630                                    const char *dst)
2631{
2632        snd_ac97_rename_ctl(ac97, src, dst, "Switch");
2633        snd_ac97_rename_ctl(ac97, src, dst, "Volume");
2634}
2635
2636/* swap controls */
2637static int snd_ac97_swap_ctl(struct snd_ac97 *ac97, const char *s1,
2638                             const char *s2, const char *suffix)
2639{
2640        struct snd_kcontrol *kctl1, *kctl2;
2641        kctl1 = ctl_find(ac97, s1, suffix);
2642        kctl2 = ctl_find(ac97, s2, suffix);
2643        if (kctl1 && kctl2) {
2644                set_ctl_name(kctl1->id.name, s2, suffix);
2645                set_ctl_name(kctl2->id.name, s1, suffix);
2646                return 0;
2647        }
2648        return -ENOENT;
2649}
2650
2651#if 1
2652/* bind hp and master controls instead of using only hp control */
2653static int bind_hp_volsw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2654{
2655        int err = snd_ac97_put_volsw(kcontrol, ucontrol);
2656        if (err > 0) {
2657                unsigned long priv_saved = kcontrol->private_value;
2658                kcontrol->private_value = (kcontrol->private_value & ~0xff) | AC97_HEADPHONE;
2659                snd_ac97_put_volsw(kcontrol, ucontrol);
2660                kcontrol->private_value = priv_saved;
2661        }
2662        return err;
2663}
2664
2665/* ac97 tune: bind Master and Headphone controls */
2666static int tune_hp_only(struct snd_ac97 *ac97)
2667{
2668        struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
2669        struct snd_kcontrol *mvol = ctl_find(ac97, "Master Playback Volume", NULL);
2670        if (! msw || ! mvol)
2671                return -ENOENT;
2672        msw->put = bind_hp_volsw_put;
2673        mvol->put = bind_hp_volsw_put;
2674        snd_ac97_remove_ctl(ac97, "Headphone Playback", "Switch");
2675        snd_ac97_remove_ctl(ac97, "Headphone Playback", "Volume");
2676        return 0;
2677}
2678
2679#else
2680/* ac97 tune: use Headphone control as master */
2681static int tune_hp_only(struct snd_ac97 *ac97)
2682{
2683        if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL)
2684                return -ENOENT;
2685        snd_ac97_remove_ctl(ac97, "Master Playback", "Switch");
2686        snd_ac97_remove_ctl(ac97, "Master Playback", "Volume");
2687        snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
2688        return 0;
2689}
2690#endif
2691
2692/* ac97 tune: swap Headphone and Master controls */
2693static int tune_swap_hp(struct snd_ac97 *ac97)
2694{
2695        if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL)
2696                return -ENOENT;
2697        snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Line-Out Playback");
2698        snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
2699        return 0;
2700}
2701
2702/* ac97 tune: swap Surround and Master controls */
2703static int tune_swap_surround(struct snd_ac97 *ac97)
2704{
2705        if (snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Switch") ||
2706            snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Volume"))
2707                return -ENOENT;
2708        return 0;
2709}
2710
2711/* ac97 tune: set up mic sharing for AD codecs */
2712static int tune_ad_sharing(struct snd_ac97 *ac97)
2713{
2714        unsigned short scfg;
2715        if ((ac97->id & 0xffffff00) != 0x41445300) {
2716                ac97_err(ac97, "ac97_quirk AD_SHARING is only for AD codecs\n");
2717                return -EINVAL;
2718        }
2719        /* Turn on OMS bit to route microphone to back panel */
2720        scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
2721        snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x0200);
2722        return 0;
2723}
2724
2725static const struct snd_kcontrol_new snd_ac97_alc_jack_detect = 
2726AC97_SINGLE("Jack Detect", AC97_ALC650_CLOCK, 5, 1, 0);
2727
2728/* ac97 tune: set up ALC jack-select */
2729static int tune_alc_jack(struct snd_ac97 *ac97)
2730{
2731        if ((ac97->id & 0xffffff00) != 0x414c4700) {
2732                ac97_err(ac97,
2733                         "ac97_quirk ALC_JACK is only for Realtek codecs\n");
2734                return -EINVAL;
2735        }
2736        snd_ac97_update_bits(ac97, 0x7a, 0x20, 0x20); /* select jack detect function */
2737        snd_ac97_update_bits(ac97, 0x7a, 0x01, 0x01); /* Line-out auto mute */
2738        if (ac97->id == AC97_ID_ALC658D)
2739                snd_ac97_update_bits(ac97, 0x74, 0x0800, 0x0800);
2740        return snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&snd_ac97_alc_jack_detect, ac97));
2741}
2742
2743/* ac97 tune: inversed EAPD bit */
2744static int tune_inv_eapd(struct snd_ac97 *ac97)
2745{
2746        struct snd_kcontrol *kctl = ctl_find(ac97, "External Amplifier", NULL);
2747        if (! kctl)
2748                return -ENOENT;
2749        set_inv_eapd(ac97, kctl);
2750        return 0;
2751}
2752
2753static int master_mute_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2754{
2755        int err = snd_ac97_put_volsw(kcontrol, ucontrol);
2756        if (err > 0) {
2757                struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2758                int shift = (kcontrol->private_value >> 8) & 0x0f;
2759                int rshift = (kcontrol->private_value >> 12) & 0x0f;
2760                unsigned short mask;
2761                if (shift != rshift)
2762                        mask = AC97_MUTE_MASK_STEREO;
2763                else
2764                        mask = AC97_MUTE_MASK_MONO;
2765                snd_ac97_update_bits(ac97, AC97_POWERDOWN, AC97_PD_EAPD,
2766                                     (ac97->regs[AC97_MASTER] & mask) == mask ?
2767                                     AC97_PD_EAPD : 0);
2768        }
2769        return err;
2770}
2771
2772/* ac97 tune: EAPD controls mute LED bound with the master mute */
2773static int tune_mute_led(struct snd_ac97 *ac97)
2774{
2775        struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
2776        if (! msw)
2777                return -ENOENT;
2778        msw->put = master_mute_sw_put;
2779        snd_ac97_remove_ctl(ac97, "External Amplifier", NULL);
2780        snd_ac97_update_bits(
2781                ac97, AC97_POWERDOWN,
2782                AC97_PD_EAPD, AC97_PD_EAPD /* mute LED on */
2783        );
2784        ac97->scaps |= AC97_SCAP_EAPD_LED;
2785        return 0;
2786}
2787
2788static int hp_master_mute_sw_put(struct snd_kcontrol *kcontrol,
2789                                 struct snd_ctl_elem_value *ucontrol)
2790{
2791        int err = bind_hp_volsw_put(kcontrol, ucontrol);
2792        if (err > 0) {
2793                struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2794                int shift = (kcontrol->private_value >> 8) & 0x0f;
2795                int rshift = (kcontrol->private_value >> 12) & 0x0f;
2796                unsigned short mask;
2797                if (shift != rshift)
2798                        mask = AC97_MUTE_MASK_STEREO;
2799                else
2800                        mask = AC97_MUTE_MASK_MONO;
2801                snd_ac97_update_bits(ac97, AC97_POWERDOWN, AC97_PD_EAPD,
2802                                     (ac97->regs[AC97_MASTER] & mask) == mask ?
2803                                     AC97_PD_EAPD : 0);
2804        }
2805        return err;
2806}
2807
2808static int tune_hp_mute_led(struct snd_ac97 *ac97)
2809{
2810        struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
2811        struct snd_kcontrol *mvol = ctl_find(ac97, "Master Playback Volume", NULL);
2812        if (! msw || ! mvol)
2813                return -ENOENT;
2814        msw->put = hp_master_mute_sw_put;
2815        mvol->put = bind_hp_volsw_put;
2816        snd_ac97_remove_ctl(ac97, "External Amplifier", NULL);
2817        snd_ac97_remove_ctl(ac97, "Headphone Playback", "Switch");
2818        snd_ac97_remove_ctl(ac97, "Headphone Playback", "Volume");
2819        snd_ac97_update_bits(
2820                ac97, AC97_POWERDOWN,
2821                AC97_PD_EAPD, AC97_PD_EAPD /* mute LED on */
2822        );
2823        return 0;
2824}
2825
2826struct quirk_table {
2827        const char *name;
2828        int (*func)(struct snd_ac97 *);
2829};
2830
2831static struct quirk_table applicable_quirks[] = {
2832        { "none", NULL },
2833        { "hp_only", tune_hp_only },
2834        { "swap_hp", tune_swap_hp },
2835        { "swap_surround", tune_swap_surround },
2836        { "ad_sharing", tune_ad_sharing },
2837        { "alc_jack", tune_alc_jack },
2838        { "inv_eapd", tune_inv_eapd },
2839        { "mute_led", tune_mute_led },
2840        { "hp_mute_led", tune_hp_mute_led },
2841};
2842
2843/* apply the quirk with the given type */
2844static int apply_quirk(struct snd_ac97 *ac97, int type)
2845{
2846        if (type <= 0)
2847                return 0;
2848        else if (type >= ARRAY_SIZE(applicable_quirks))
2849                return -EINVAL;
2850        if (applicable_quirks[type].func)
2851                return applicable_quirks[type].func(ac97);
2852        return 0;
2853}
2854
2855/* apply the quirk with the given name */
2856static int apply_quirk_str(struct snd_ac97 *ac97, const char *typestr)
2857{
2858        int i;
2859        struct quirk_table *q;
2860
2861        for (i = 0; i < ARRAY_SIZE(applicable_quirks); i++) {
2862                q = &applicable_quirks[i];
2863                if (q->name && ! strcmp(typestr, q->name))
2864                        return apply_quirk(ac97, i);
2865        }
2866        /* for compatibility, accept the numbers, too */
2867        if (*typestr >= '0' && *typestr <= '9')
2868                return apply_quirk(ac97, (int)simple_strtoul(typestr, NULL, 10));
2869        return -EINVAL;
2870}
2871
2872/**
2873 * snd_ac97_tune_hardware - tune up the hardware
2874 * @ac97: the ac97 instance
2875 * @quirk: quirk list
2876 * @override: explicit quirk value (overrides the list if non-NULL)
2877 *
2878 * Do some workaround for each pci device, such as renaming of the
2879 * headphone (true line-out) control as "Master".
2880 * The quirk-list must be terminated with a zero-filled entry.
2881 *
2882 * Return: Zero if successful, or a negative error code on failure.
2883 */
2884
2885int snd_ac97_tune_hardware(struct snd_ac97 *ac97,
2886                           const struct ac97_quirk *quirk, const char *override)
2887{
2888        int result;
2889
2890        /* quirk overriden? */
2891        if (override && strcmp(override, "-1") && strcmp(override, "default")) {
2892                result = apply_quirk_str(ac97, override);
2893                if (result < 0)
2894                        ac97_err(ac97, "applying quirk type %s failed (%d)\n",
2895                                 override, result);
2896                return result;
2897        }
2898
2899        if (! quirk)
2900                return -EINVAL;
2901
2902        for (; quirk->subvendor; quirk++) {
2903                if (quirk->subvendor != ac97->subsystem_vendor)
2904                        continue;
2905                if ((! quirk->mask && quirk->subdevice == ac97->subsystem_device) ||
2906                    quirk->subdevice == (quirk->mask & ac97->subsystem_device)) {
2907                        if (quirk->codec_id && quirk->codec_id != ac97->id)
2908                                continue;
2909                        ac97_dbg(ac97, "ac97 quirk for %s (%04x:%04x)\n",
2910                                 quirk->name, ac97->subsystem_vendor,
2911                                 ac97->subsystem_device);
2912                        result = apply_quirk(ac97, quirk->type);
2913                        if (result < 0)
2914                                ac97_err(ac97,
2915                                         "applying quirk type %d for %s failed (%d)\n",
2916                                         quirk->type, quirk->name, result);
2917                        return result;
2918                }
2919        }
2920        return 0;
2921}
2922
2923EXPORT_SYMBOL(snd_ac97_tune_hardware);
2924