linux-old/drivers/sound/ac97_codec.c
<<
>>
Prefs
   1/*
   2 * ac97_codec.c: Generic AC97 mixer/modem module
   3 *
   4 * Derived from ac97 mixer in maestro and trident driver.
   5 *
   6 * Copyright 2000 Silicon Integrated System Corporation
   7 *
   8 *      This program is free software; you can redistribute it and/or modify
   9 *      it under the terms of the GNU General Public License as published by
  10 *      the Free Software Foundation; either version 2 of the License, or
  11 *      (at your option) any later version.
  12 *
  13 *      This program is distributed in the hope that it will be useful,
  14 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 *      GNU General Public License for more details.
  17 *
  18 *      You should have received a copy of the GNU General Public License
  19 *      along with this program; if not, write to the Free Software
  20 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 *
  22 **************************************************************************
  23 *
  24 * The Intel Audio Codec '97 specification is available at the Intel
  25 * audio homepage: http://developer.intel.com/ial/scalableplatforms/audio/
  26 *
  27 * The specification itself is currently available at:
  28 * ftp://download.intel.com/ial/scalableplatforms/ac97r22.pdf
  29 *
  30 **************************************************************************
  31 *
  32 * History
  33 * Feb 25, 2004 Liam Girdwood
  34 *  Added support for codecs that require a warm reset to power up.
  35 *  Support for WM9713
  36 * May 02, 2003 Liam Girdwood <liam.girdwood@wolfsonmicro.com>
  37 *      Removed non existant WM9700
  38 *      Added support for WM9705, WM9708, WM9709, WM9710, WM9711
  39 *      WM9712 and WM9717
  40 * Mar 28, 2002 Randolph Bentson <bentson@holmsjoen.com>
  41 *      corrections to support WM9707 in ViewPad 1000
  42 * v0.4 Mar 15 2000 Ollie Lho
  43 *      dual codecs support verified with 4 channels output
  44 * v0.3 Feb 22 2000 Ollie Lho
  45 *      bug fix for record mask setting
  46 * v0.2 Feb 10 2000 Ollie Lho
  47 *      add ac97_read_proc for /proc/driver/{vendor}/ac97
  48 * v0.1 Jan 14 2000 Ollie Lho <ollie@sis.com.tw> 
  49 *      Isolated from trident.c to support multiple ac97 codec
  50 */
  51#include <linux/module.h>
  52#include <linux/version.h>
  53#include <linux/kernel.h>
  54#include <linux/slab.h>
  55#include <linux/string.h>
  56#include <linux/errno.h>
  57#include <linux/bitops.h>
  58#include <linux/delay.h>
  59#include <linux/ac97_codec.h>
  60#include <asm/uaccess.h>
  61
  62#define CODEC_ID_BUFSZ 14
  63
  64static int ac97_read_mixer(struct ac97_codec *codec, int oss_channel);
  65static void ac97_write_mixer(struct ac97_codec *codec, int oss_channel, 
  66                             unsigned int left, unsigned int right);
  67static void ac97_set_mixer(struct ac97_codec *codec, unsigned int oss_mixer, unsigned int val );
  68static int ac97_recmask_io(struct ac97_codec *codec, int rw, int mask);
  69static int ac97_mixer_ioctl(struct ac97_codec *codec, unsigned int cmd, unsigned long arg);
  70
  71static int ac97_init_mixer(struct ac97_codec *codec);
  72
  73static int wolfson_init03(struct ac97_codec * codec);
  74static int wolfson_init04(struct ac97_codec * codec);
  75static int wolfson_init05(struct ac97_codec * codec);
  76static int wolfson_init11(struct ac97_codec * codec);
  77static int wolfson_init13(struct ac97_codec * codec);
  78static int tritech_init(struct ac97_codec * codec);
  79static int tritech_maestro_init(struct ac97_codec * codec);
  80static int sigmatel_9708_init(struct ac97_codec *codec);
  81static int sigmatel_9721_init(struct ac97_codec *codec);
  82static int sigmatel_9744_init(struct ac97_codec *codec);
  83static int ad1886_init(struct ac97_codec *codec);
  84static int eapd_control(struct ac97_codec *codec, int);
  85static int crystal_digital_control(struct ac97_codec *codec, int slots, int rate, int mode);
  86static int cmedia_init(struct ac97_codec * codec);
  87static int cmedia_digital_control(struct ac97_codec *codec, int slots, int rate, int mode);
  88static int generic_digital_control(struct ac97_codec *codec, int slots, int rate, int mode);
  89
  90
  91/*
  92 *      AC97 operations.
  93 *
  94 *      If you are adding a codec then you should be able to use
  95 *              eapd_ops - any codec that supports EAPD amp control (most)
  96 *              null_ops - any ancient codec that supports nothing
  97 *
  98 *      The three functions are
  99 *              init - used for non AC97 standard initialisation
 100 *              amplifier - used to do amplifier control (1=on 0=off)
 101 *              digital - switch to digital modes (0 = analog)
 102 *
 103 *      Not all codecs support all features, not all drivers use all the
 104 *      operations yet
 105 */
 106 
 107static struct ac97_ops null_ops = { NULL, NULL, NULL };
 108static struct ac97_ops default_ops = { NULL, eapd_control, NULL };
 109static struct ac97_ops default_digital_ops = { NULL, eapd_control, generic_digital_control};
 110static struct ac97_ops wolfson_ops03 = { wolfson_init03, NULL, NULL };
 111static struct ac97_ops wolfson_ops04 = { wolfson_init04, NULL, NULL };
 112static struct ac97_ops wolfson_ops05 = { wolfson_init05, NULL, NULL };
 113static struct ac97_ops wolfson_ops11 = { wolfson_init11, NULL, NULL };
 114static struct ac97_ops wolfson_ops13 = { wolfson_init13, NULL, NULL };
 115static struct ac97_ops tritech_ops = { tritech_init, NULL, NULL };
 116static struct ac97_ops tritech_m_ops = { tritech_maestro_init, NULL, NULL };
 117static struct ac97_ops sigmatel_9708_ops = { sigmatel_9708_init, NULL, NULL };
 118static struct ac97_ops sigmatel_9721_ops = { sigmatel_9721_init, NULL, NULL };
 119static struct ac97_ops sigmatel_9744_ops = { sigmatel_9744_init, NULL, NULL };
 120static struct ac97_ops crystal_digital_ops = { NULL, eapd_control, crystal_digital_control };
 121static struct ac97_ops ad1886_ops = { ad1886_init, eapd_control, NULL };
 122static struct ac97_ops cmedia_ops = { NULL, eapd_control, NULL};
 123static struct ac97_ops cmedia_digital_ops = { cmedia_init, eapd_control, cmedia_digital_control};
 124
 125/* sorted by vendor/device id */
 126static const struct {
 127        u32 id;
 128        char *name;
 129        struct ac97_ops *ops;
 130        int flags;
 131} ac97_codec_ids[] = {
 132        {0x41445303, "Analog Devices AD1819",   &null_ops},
 133        {0x41445340, "Analog Devices AD1881",   &null_ops},
 134        {0x41445348, "Analog Devices AD1881A",  &null_ops},
 135        {0x41445360, "Analog Devices AD1885",   &default_ops},
 136        {0x41445361, "Analog Devices AD1886",   &ad1886_ops},
 137        {0x41445460, "Analog Devices AD1885",   &default_ops},
 138        {0x41445461, "Analog Devices AD1886",   &ad1886_ops},
 139        {0x414B4D00, "Asahi Kasei AK4540",      &null_ops},
 140        {0x414B4D01, "Asahi Kasei AK4542",      &null_ops},
 141        {0x414B4D02, "Asahi Kasei AK4543",      &null_ops},
 142        {0x414C4326, "ALC100P",                 &null_ops},
 143        {0x414C4710, "ALC200/200P",             &null_ops},
 144        {0x414C4720, "ALC650",                  &default_digital_ops},
 145        {0x434D4941, "CMedia",                  &cmedia_ops,            AC97_NO_PCM_VOLUME },
 146        {0x434D4942, "CMedia",                  &cmedia_ops,            AC97_NO_PCM_VOLUME },
 147        {0x434D4961, "CMedia",                  &cmedia_digital_ops,    AC97_NO_PCM_VOLUME },
 148        {0x43525900, "Cirrus Logic CS4297",     &default_ops},
 149        {0x43525903, "Cirrus Logic CS4297",     &default_ops},
 150        {0x43525913, "Cirrus Logic CS4297A rev A", &default_ops},
 151        {0x43525914, "Cirrus Logic CS4297A rev B", &default_ops},
 152        {0x43525923, "Cirrus Logic CS4298",     &null_ops},
 153        {0x4352592B, "Cirrus Logic CS4294",     &null_ops},
 154        {0x4352592D, "Cirrus Logic CS4294",     &null_ops},
 155        {0x43525931, "Cirrus Logic CS4299 rev A", &crystal_digital_ops},
 156        {0x43525933, "Cirrus Logic CS4299 rev C", &crystal_digital_ops},
 157        {0x43525934, "Cirrus Logic CS4299 rev D", &crystal_digital_ops},
 158        {0x43585430, "CXT48",                   &default_ops,           AC97_DELUDED_MODEM },
 159        {0x43585442, "CXT66",                   &default_ops,           AC97_DELUDED_MODEM },
 160        {0x44543031, "Diamond Technology DT0893", &default_ops},
 161        {0x45838308, "ESS Allegro ES1988",      &null_ops},
 162        {0x49434511, "ICE1232",                 &null_ops}, /* I hope --jk */
 163        {0x4e534331, "National Semiconductor LM4549", &null_ops},
 164        {0x53494c22, "Silicon Laboratory Si3036", &null_ops},
 165        {0x53494c23, "Silicon Laboratory Si3038", &null_ops},
 166        {0x545200FF, "TriTech TR?????",         &tritech_m_ops},
 167        {0x54524102, "TriTech TR28022",         &null_ops},
 168        {0x54524103, "TriTech TR28023",         &null_ops},
 169        {0x54524106, "TriTech TR28026",         &null_ops},
 170        {0x54524108, "TriTech TR28028",         &tritech_ops},
 171        {0x54524123, "TriTech TR A5",           &null_ops},
 172        {0x574D4C03, "Wolfson WM9703/07/08/17", &wolfson_ops03},
 173        {0x574D4C04, "Wolfson WM9704M/WM9704Q", &wolfson_ops04},
 174        {0x574D4C05, "Wolfson WM9705/WM9710",   &wolfson_ops05},
 175        {0x574D4C09, "Wolfson WM9709",          &null_ops},
 176        {0x574D4C12, "Wolfson WM9711/9712",     &wolfson_ops11},
 177        {0x574D4C13, "Wolfson WM9713",  &wolfson_ops13, AC97_DEFAULT_POWER_OFF},
 178        {0x83847600, "SigmaTel STAC????",       &null_ops},
 179        {0x83847604, "SigmaTel STAC9701/3/4/5", &null_ops},
 180        {0x83847605, "SigmaTel STAC9704",       &null_ops},
 181        {0x83847608, "SigmaTel STAC9708",       &sigmatel_9708_ops},
 182        {0x83847609, "SigmaTel STAC9721/23",    &sigmatel_9721_ops},
 183        {0x83847644, "SigmaTel STAC9744/45",    &sigmatel_9744_ops},
 184        {0x83847652, "SigmaTel STAC9752/53",    &default_ops},
 185        {0x83847656, "SigmaTel STAC9756/57",    &sigmatel_9744_ops},
 186        {0x83847666, "SigmaTel STAC9750T",      &sigmatel_9744_ops},
 187        {0x83847684, "SigmaTel STAC9783/84?",   &null_ops},
 188        {0x57454301, "Winbond 83971D",          &null_ops},
 189};
 190
 191static const char *ac97_stereo_enhancements[] =
 192{
 193        /*   0 */ "No 3D Stereo Enhancement",
 194        /*   1 */ "Analog Devices Phat Stereo",
 195        /*   2 */ "Creative Stereo Enhancement",
 196        /*   3 */ "National Semi 3D Stereo Enhancement",
 197        /*   4 */ "YAMAHA Ymersion",
 198        /*   5 */ "BBE 3D Stereo Enhancement",
 199        /*   6 */ "Crystal Semi 3D Stereo Enhancement",
 200        /*   7 */ "Qsound QXpander",
 201        /*   8 */ "Spatializer 3D Stereo Enhancement",
 202        /*   9 */ "SRS 3D Stereo Enhancement",
 203        /*  10 */ "Platform Tech 3D Stereo Enhancement",
 204        /*  11 */ "AKM 3D Audio",
 205        /*  12 */ "Aureal Stereo Enhancement",
 206        /*  13 */ "Aztech 3D Enhancement",
 207        /*  14 */ "Binaura 3D Audio Enhancement",
 208        /*  15 */ "ESS Technology Stereo Enhancement",
 209        /*  16 */ "Harman International VMAx",
 210        /*  17 */ "Nvidea 3D Stereo Enhancement",
 211        /*  18 */ "Philips Incredible Sound",
 212        /*  19 */ "Texas Instruments 3D Stereo Enhancement",
 213        /*  20 */ "VLSI Technology 3D Stereo Enhancement",
 214        /*  21 */ "TriTech 3D Stereo Enhancement",
 215        /*  22 */ "Realtek 3D Stereo Enhancement",
 216        /*  23 */ "Samsung 3D Stereo Enhancement",
 217        /*  24 */ "Wolfson Microelectronics 3D Enhancement",
 218        /*  25 */ "Delta Integration 3D Enhancement",
 219        /*  26 */ "SigmaTel 3D Enhancement",
 220        /*  27 */ "Winbond 3D Stereo Enhancement",
 221        /*  28 */ "Rockwell 3D Stereo Enhancement",
 222        /*  29 */ "Reserved 29",
 223        /*  30 */ "Reserved 30",
 224        /*  31 */ "Reserved 31"
 225};
 226
 227/* this table has default mixer values for all OSS mixers. */
 228static struct mixer_defaults {
 229        int mixer;
 230        unsigned int value;
 231} mixer_defaults[SOUND_MIXER_NRDEVICES] = {
 232        /* all values 0 -> 100 in bytes */
 233        {SOUND_MIXER_VOLUME,    0x4343},
 234        {SOUND_MIXER_BASS,      0x4343},
 235        {SOUND_MIXER_TREBLE,    0x4343},
 236        {SOUND_MIXER_PCM,       0x4343},
 237        {SOUND_MIXER_SPEAKER,   0x4343},
 238        {SOUND_MIXER_LINE,      0x4343},
 239        {SOUND_MIXER_MIC,       0x0000},
 240        {SOUND_MIXER_CD,        0x4343},
 241        {SOUND_MIXER_ALTPCM,    0x4343},
 242        {SOUND_MIXER_IGAIN,     0x4343},
 243        {SOUND_MIXER_LINE1,     0x4343},
 244        {SOUND_MIXER_PHONEIN,   0x4343},
 245        {SOUND_MIXER_PHONEOUT,  0x4343},
 246        {SOUND_MIXER_VIDEO,     0x4343},
 247        {-1,0}
 248};
 249
 250/* table to scale scale from OSS mixer value to AC97 mixer register value */    
 251static struct ac97_mixer_hw {
 252        unsigned char offset;
 253        int scale;
 254} ac97_hw[SOUND_MIXER_NRDEVICES]= {
 255        [SOUND_MIXER_VOLUME]    =       {AC97_MASTER_VOL_STEREO,64},
 256        [SOUND_MIXER_BASS]      =       {AC97_MASTER_TONE,      16},
 257        [SOUND_MIXER_TREBLE]    =       {AC97_MASTER_TONE,      16},
 258        [SOUND_MIXER_PCM]       =       {AC97_PCMOUT_VOL,       32},
 259        [SOUND_MIXER_SPEAKER]   =       {AC97_PCBEEP_VOL,       16},
 260        [SOUND_MIXER_LINE]      =       {AC97_LINEIN_VOL,       32},
 261        [SOUND_MIXER_MIC]       =       {AC97_MIC_VOL,          32},
 262        [SOUND_MIXER_CD]        =       {AC97_CD_VOL,           32},
 263        [SOUND_MIXER_ALTPCM]    =       {AC97_HEADPHONE_VOL,    64},
 264        [SOUND_MIXER_IGAIN]     =       {AC97_RECORD_GAIN,      16},
 265        [SOUND_MIXER_LINE1]     =       {AC97_AUX_VOL,          32},
 266        [SOUND_MIXER_PHONEIN]   =       {AC97_PHONE_VOL,        32},
 267        [SOUND_MIXER_PHONEOUT]  =       {AC97_MASTER_VOL_MONO,  64},
 268        [SOUND_MIXER_VIDEO]     =       {AC97_VIDEO_VOL,        32},
 269};
 270
 271/* the following tables allow us to go from OSS <-> ac97 quickly. */
 272enum ac97_recsettings {
 273        AC97_REC_MIC=0,
 274        AC97_REC_CD,
 275        AC97_REC_VIDEO,
 276        AC97_REC_AUX,
 277        AC97_REC_LINE,
 278        AC97_REC_STEREO, /* combination of all enabled outputs..  */
 279        AC97_REC_MONO,        /*.. or the mono equivalent */
 280        AC97_REC_PHONE
 281};
 282
 283static const unsigned int ac97_rm2oss[] = {
 284        [AC97_REC_MIC]   = SOUND_MIXER_MIC,
 285        [AC97_REC_CD]    = SOUND_MIXER_CD,
 286        [AC97_REC_VIDEO] = SOUND_MIXER_VIDEO,
 287        [AC97_REC_AUX]   = SOUND_MIXER_LINE1,
 288        [AC97_REC_LINE]  = SOUND_MIXER_LINE,
 289        [AC97_REC_STEREO]= SOUND_MIXER_IGAIN,
 290        [AC97_REC_PHONE] = SOUND_MIXER_PHONEIN
 291};
 292
 293/* indexed by bit position */
 294static const unsigned int ac97_oss_rm[] = {
 295        [SOUND_MIXER_MIC]       = AC97_REC_MIC,
 296        [SOUND_MIXER_CD]        = AC97_REC_CD,
 297        [SOUND_MIXER_VIDEO]     = AC97_REC_VIDEO,
 298        [SOUND_MIXER_LINE1]     = AC97_REC_AUX,
 299        [SOUND_MIXER_LINE]      = AC97_REC_LINE,
 300        [SOUND_MIXER_IGAIN]     = AC97_REC_STEREO,
 301        [SOUND_MIXER_PHONEIN]   = AC97_REC_PHONE
 302};
 303
 304static LIST_HEAD(codecs);
 305static LIST_HEAD(codec_drivers);
 306static DECLARE_MUTEX(codec_sem);
 307
 308/* reads the given OSS mixer from the ac97 the caller must have insured that the ac97 knows
 309   about that given mixer, and should be holding a spinlock for the card */
 310static int ac97_read_mixer(struct ac97_codec *codec, int oss_channel) 
 311{
 312        u16 val;
 313        int ret = 0;
 314        int scale;
 315        struct ac97_mixer_hw *mh = &ac97_hw[oss_channel];
 316
 317        val = codec->codec_read(codec , mh->offset);
 318
 319        if (val & AC97_MUTE) {
 320                ret = 0;
 321        } else if (AC97_STEREO_MASK & (1 << oss_channel)) {
 322                /* nice stereo mixers .. */
 323                int left,right;
 324
 325                left = (val >> 8)  & 0x7f;
 326                right = val  & 0x7f;
 327
 328                if (oss_channel == SOUND_MIXER_IGAIN) {
 329                        right = (right * 100) / mh->scale;
 330                        left = (left * 100) / mh->scale;
 331                } else {
 332                        /* these may have 5 or 6 bit resolution */
 333                        if(oss_channel == SOUND_MIXER_VOLUME || oss_channel == SOUND_MIXER_ALTPCM)
 334                                scale = (1 << codec->bit_resolution);
 335                        else
 336                                scale = mh->scale;
 337
 338                        right = 100 - ((right * 100) / scale);
 339                        left = 100 - ((left * 100) / scale);
 340                }
 341                ret = left | (right << 8);
 342        } else if (oss_channel == SOUND_MIXER_SPEAKER) {
 343                ret = 100 - ((((val & 0x1e)>>1) * 100) / mh->scale);
 344        } else if (oss_channel == SOUND_MIXER_PHONEIN) {
 345                ret = 100 - (((val & 0x1f) * 100) / mh->scale);
 346        } else if (oss_channel == SOUND_MIXER_PHONEOUT) {
 347                scale = (1 << codec->bit_resolution);
 348                ret = 100 - (((val & 0x1f) * 100) / scale);
 349        } else if (oss_channel == SOUND_MIXER_MIC) {
 350                ret = 100 - (((val & 0x1f) * 100) / mh->scale);
 351                /*  the low bit is optional in the tone sliders and masking
 352                    it lets us avoid the 0xf 'bypass'.. */
 353        } else if (oss_channel == SOUND_MIXER_BASS) {
 354                ret = 100 - ((((val >> 8) & 0xe) * 100) / mh->scale);
 355        } else if (oss_channel == SOUND_MIXER_TREBLE) {
 356                ret = 100 - (((val & 0xe) * 100) / mh->scale);
 357        }
 358
 359#ifdef DEBUG
 360        printk("ac97_codec: read OSS mixer %2d (%s ac97 register 0x%02x), "
 361               "0x%04x -> 0x%04x\n",
 362               oss_channel, codec->id ? "Secondary" : "Primary",
 363               mh->offset, val, ret);
 364#endif
 365
 366        return ret;
 367}
 368
 369/* write the OSS encoded volume to the given OSS encoded mixer, again caller's job to
 370   make sure all is well in arg land, call with spinlock held */
 371static void ac97_write_mixer(struct ac97_codec *codec, int oss_channel,
 372                      unsigned int left, unsigned int right)
 373{
 374        u16 val = 0;
 375        int scale;
 376        struct ac97_mixer_hw *mh = &ac97_hw[oss_channel];
 377
 378#ifdef DEBUG
 379        printk("ac97_codec: wrote OSS mixer %2d (%s ac97 register 0x%02x), "
 380               "left vol:%2d, right vol:%2d:",
 381               oss_channel, codec->id ? "Secondary" : "Primary",
 382               mh->offset, left, right);
 383#endif
 384
 385        if (AC97_STEREO_MASK & (1 << oss_channel)) {
 386                /* stereo mixers */
 387                if (left == 0 && right == 0) {
 388                        val = AC97_MUTE;
 389                } else {
 390                        if (oss_channel == SOUND_MIXER_IGAIN) {
 391                                right = (right * mh->scale) / 100;
 392                                left = (left * mh->scale) / 100;
 393                                if (right >= mh->scale)
 394                                        right = mh->scale-1;
 395                                if (left >= mh->scale)
 396                                        left = mh->scale-1;
 397                        } else {
 398                                /* these may have 5 or 6 bit resolution */
 399                                if (oss_channel == SOUND_MIXER_VOLUME ||
 400                                    oss_channel == SOUND_MIXER_ALTPCM)
 401                                        scale = (1 << codec->bit_resolution);
 402                                else
 403                                        scale = mh->scale;
 404
 405                                right = ((100 - right) * scale) / 100;
 406                                left = ((100 - left) * scale) / 100;
 407                                if (right >= scale)
 408                                        right = scale-1;
 409                                if (left >= scale)
 410                                        left = scale-1;
 411                        }
 412                        val = (left << 8) | right;
 413                }
 414        } else if (oss_channel == SOUND_MIXER_BASS) {
 415                val = codec->codec_read(codec , mh->offset) & ~0x0f00;
 416                left = ((100 - left) * mh->scale) / 100;
 417                if (left >= mh->scale)
 418                        left = mh->scale-1;
 419                val |= (left << 8) & 0x0e00;
 420        } else if (oss_channel == SOUND_MIXER_TREBLE) {
 421                val = codec->codec_read(codec , mh->offset) & ~0x000f;
 422                left = ((100 - left) * mh->scale) / 100;
 423                if (left >= mh->scale)
 424                        left = mh->scale-1;
 425                val |= left & 0x000e;
 426        } else if(left == 0) {
 427                val = AC97_MUTE;
 428        } else if (oss_channel == SOUND_MIXER_SPEAKER) {
 429                left = ((100 - left) * mh->scale) / 100;
 430                if (left >= mh->scale)
 431                        left = mh->scale-1;
 432                val = left << 1;
 433        } else if (oss_channel == SOUND_MIXER_PHONEIN) {
 434                left = ((100 - left) * mh->scale) / 100;
 435                if (left >= mh->scale)
 436                        left = mh->scale-1;
 437                val = left;
 438        } else if (oss_channel == SOUND_MIXER_PHONEOUT) {
 439                scale = (1 << codec->bit_resolution);
 440                left = ((100 - left) * scale) / 100;
 441                if (left >= mh->scale)
 442                        left = mh->scale-1;
 443                val = left;
 444        } else if (oss_channel == SOUND_MIXER_MIC) {
 445                val = codec->codec_read(codec , mh->offset) & ~0x801f;
 446                left = ((100 - left) * mh->scale) / 100;
 447                if (left >= mh->scale)
 448                        left = mh->scale-1;
 449                val |= left;
 450                /*  the low bit is optional in the tone sliders and masking
 451                    it lets us avoid the 0xf 'bypass'.. */
 452        }
 453#ifdef DEBUG
 454        printk(" 0x%04x", val);
 455#endif
 456
 457        codec->codec_write(codec, mh->offset, val);
 458
 459#ifdef DEBUG
 460        val = codec->codec_read(codec, mh->offset);
 461        printk(" -> 0x%04x\n", val);
 462#endif
 463}
 464
 465/* a thin wrapper for write_mixer */
 466static void ac97_set_mixer(struct ac97_codec *codec, unsigned int oss_mixer, unsigned int val ) 
 467{
 468        unsigned int left,right;
 469
 470        /* cleanse input a little */
 471        right = ((val >> 8)  & 0xff) ;
 472        left = (val  & 0xff) ;
 473
 474        if (right > 100) right = 100;
 475        if (left > 100) left = 100;
 476
 477        codec->mixer_state[oss_mixer] = (right << 8) | left;
 478        codec->write_mixer(codec, oss_mixer, left, right);
 479}
 480
 481/* read or write the recmask, the ac97 can really have left and right recording
 482   inputs independantly set, but OSS doesn't seem to want us to express that to
 483   the user. the caller guarantees that we have a supported bit set, and they
 484   must be holding the card's spinlock */
 485static int ac97_recmask_io(struct ac97_codec *codec, int rw, int mask) 
 486{
 487        unsigned int val;
 488
 489        if (rw) {
 490                /* read it from the card */
 491                val = codec->codec_read(codec, AC97_RECORD_SELECT);
 492#ifdef DEBUG
 493                printk("ac97_codec: ac97 recmask to set to 0x%04x\n", val);
 494#endif
 495                return (1 << ac97_rm2oss[val & 0x07]);
 496        }
 497
 498        /* else, write the first set in the mask as the
 499           output */    
 500        /* clear out current set value first (AC97 supports only 1 input!) */
 501        val = (1 << ac97_rm2oss[codec->codec_read(codec, AC97_RECORD_SELECT) & 0x07]);
 502        if (mask != val)
 503            mask &= ~val;
 504       
 505        val = ffs(mask); 
 506        val = ac97_oss_rm[val-1];
 507        val |= val << 8;  /* set both channels */
 508
 509#ifdef DEBUG
 510        printk("ac97_codec: setting ac97 recmask to 0x%04x\n", val);
 511#endif
 512
 513        codec->codec_write(codec, AC97_RECORD_SELECT, val);
 514
 515        return 0;
 516};
 517
 518static int ac97_mixer_ioctl(struct ac97_codec *codec, unsigned int cmd, unsigned long arg)
 519{
 520        int i, val = 0;
 521
 522        if (cmd == SOUND_MIXER_INFO) {
 523                mixer_info info;
 524                strncpy(info.id, codec->name, sizeof(info.id));
 525                strncpy(info.name, codec->name, sizeof(info.name));
 526                info.modify_counter = codec->modcnt;
 527                if (copy_to_user((void *)arg, &info, sizeof(info)))
 528                        return -EFAULT;
 529                return 0;
 530        }
 531        if (cmd == SOUND_OLD_MIXER_INFO) {
 532                _old_mixer_info info;
 533                strncpy(info.id, codec->name, sizeof(info.id));
 534                strncpy(info.name, codec->name, sizeof(info.name));
 535                if (copy_to_user((void *)arg, &info, sizeof(info)))
 536                        return -EFAULT;
 537                return 0;
 538        }
 539
 540        if (_IOC_TYPE(cmd) != 'M' || _SIOC_SIZE(cmd) != sizeof(int))
 541                return -EINVAL;
 542
 543        if (cmd == OSS_GETVERSION)
 544                return put_user(SOUND_VERSION, (int *)arg);
 545
 546        if (_SIOC_DIR(cmd) == _SIOC_READ) {
 547                switch (_IOC_NR(cmd)) {
 548                case SOUND_MIXER_RECSRC: /* give them the current record source */
 549                        if (!codec->recmask_io) {
 550                                val = 0;
 551                        } else {
 552                                val = codec->recmask_io(codec, 1, 0);
 553                        }
 554                        break;
 555
 556                case SOUND_MIXER_DEVMASK: /* give them the supported mixers */
 557                        val = codec->supported_mixers;
 558                        break;
 559
 560                case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
 561                        val = codec->record_sources;
 562                        break;
 563
 564                case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
 565                        val = codec->stereo_mixers;
 566                        break;
 567
 568                case SOUND_MIXER_CAPS:
 569                        val = SOUND_CAP_EXCL_INPUT;
 570                        break;
 571
 572                default: /* read a specific mixer */
 573                        i = _IOC_NR(cmd);
 574
 575                        if (!supported_mixer(codec, i)) 
 576                                return -EINVAL;
 577
 578                        /* do we ever want to touch the hardware? */
 579                        /* val = codec->read_mixer(codec, i); */
 580                        val = codec->mixer_state[i];
 581                        break;
 582                }
 583                return put_user(val, (int *)arg);
 584        }
 585
 586        if (_SIOC_DIR(cmd) == (_SIOC_WRITE|_SIOC_READ)) {
 587                codec->modcnt++;
 588                if (get_user(val, (int *)arg))
 589                        return -EFAULT;
 590
 591                switch (_IOC_NR(cmd)) {
 592                case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
 593                        if (!codec->recmask_io) return -EINVAL;
 594                        if (!val) return 0;
 595                        if (!(val &= codec->record_sources)) return -EINVAL;
 596
 597                        codec->recmask_io(codec, 0, val);
 598
 599                        return 0;
 600                default: /* write a specific mixer */
 601                        i = _IOC_NR(cmd);
 602
 603                        if (!supported_mixer(codec, i)) 
 604                                return -EINVAL;
 605
 606                        ac97_set_mixer(codec, i, val);
 607
 608                        return 0;
 609                }
 610        }
 611        return -EINVAL;
 612}
 613
 614/* entry point for /proc/driver/controller_vendor/ac97/%d */
 615int ac97_read_proc (char *page, char **start, off_t off,
 616                    int count, int *eof, void *data)
 617{
 618        int len = 0, cap, extid, val, id1, id2;
 619        struct ac97_codec *codec;
 620        int is_ac97_20 = 0;
 621
 622        if ((codec = data) == NULL)
 623                return -ENODEV;
 624
 625        id1 = codec->codec_read(codec, AC97_VENDOR_ID1);
 626        id2 = codec->codec_read(codec, AC97_VENDOR_ID2);
 627        len += sprintf (page+len, "Vendor name      : %s\n", codec->name);
 628        len += sprintf (page+len, "Vendor id        : %04X %04X\n", id1, id2);
 629
 630        extid = codec->codec_read(codec, AC97_EXTENDED_ID);
 631        extid &= ~((1<<2)|(1<<4)|(1<<5)|(1<<10)|(1<<11)|(1<<12)|(1<<13));
 632        len += sprintf (page+len, "AC97 Version     : %s\n",
 633                        extid ? "2.0 or later" : "1.0");
 634        if (extid) is_ac97_20 = 1;
 635
 636        cap = codec->codec_read(codec, AC97_RESET);
 637        len += sprintf (page+len, "Capabilities     :%s%s%s%s%s%s\n",
 638                        cap & 0x0001 ? " -dedicated MIC PCM IN channel-" : "",
 639                        cap & 0x0002 ? " -reserved1-" : "",
 640                        cap & 0x0004 ? " -bass & treble-" : "",
 641                        cap & 0x0008 ? " -simulated stereo-" : "",
 642                        cap & 0x0010 ? " -headphone out-" : "",
 643                        cap & 0x0020 ? " -loudness-" : "");
 644        val = cap & 0x00c0;
 645        len += sprintf (page+len, "DAC resolutions  :%s%s%s\n",
 646                        " -16-bit-",
 647                        val & 0x0040 ? " -18-bit-" : "",
 648                        val & 0x0080 ? " -20-bit-" : "");
 649        val = cap & 0x0300;
 650        len += sprintf (page+len, "ADC resolutions  :%s%s%s\n",
 651                        " -16-bit-",
 652                        val & 0x0100 ? " -18-bit-" : "",
 653                        val & 0x0200 ? " -20-bit-" : "");
 654        len += sprintf (page+len, "3D enhancement   : %s\n",
 655                        ac97_stereo_enhancements[(cap >> 10) & 0x1f]);
 656
 657        val = codec->codec_read(codec, AC97_GENERAL_PURPOSE);
 658        len += sprintf (page+len, "POP path         : %s 3D\n"
 659                        "Sim. stereo      : %s\n"
 660                        "3D enhancement   : %s\n"
 661                        "Loudness         : %s\n"
 662                        "Mono output      : %s\n"
 663                        "MIC select       : %s\n"
 664                        "ADC/DAC loopback : %s\n",
 665                        val & 0x8000 ? "post" : "pre",
 666                        val & 0x4000 ? "on" : "off",
 667                        val & 0x2000 ? "on" : "off",
 668                        val & 0x1000 ? "on" : "off",
 669                        val & 0x0200 ? "MIC" : "MIX",
 670                        val & 0x0100 ? "MIC2" : "MIC1",
 671                        val & 0x0080 ? "on" : "off");
 672
 673        extid = codec->codec_read(codec, AC97_EXTENDED_ID);
 674        cap = extid;
 675        len += sprintf (page+len, "Ext Capabilities :%s%s%s%s%s%s%s\n",
 676                        cap & 0x0001 ? " -var rate PCM audio-" : "",
 677                        cap & 0x0002 ? " -2x PCM audio out-" : "",
 678                        cap & 0x0008 ? " -var rate MIC in-" : "",
 679                        cap & 0x0040 ? " -PCM center DAC-" : "",
 680                        cap & 0x0080 ? " -PCM surround DAC-" : "",
 681                        cap & 0x0100 ? " -PCM LFE DAC-" : "",
 682                        cap & 0x0200 ? " -slot/DAC mappings-" : "");
 683        if (is_ac97_20) {
 684                len += sprintf (page+len, "Front DAC rate   : %d\n",
 685                                codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE));
 686        }
 687
 688        return len;
 689}
 690
 691/**
 692 *      codec_id        -  Turn id1/id2 into a PnP string
 693 *      @id1: Vendor ID1
 694 *      @id2: Vendor ID2
 695 *      @buf: CODEC_ID_BUFSZ byte buffer
 696 *
 697 *      Fills buf with a zero terminated PnP ident string for the id1/id2
 698 *      pair. For convenience the return is the passed in buffer pointer.
 699 */
 700 
 701static char *codec_id(u16 id1, u16 id2, char *buf)
 702{
 703        if(id1&0x8080) {
 704                snprintf(buf, CODEC_ID_BUFSZ, "0x%04x:0x%04x", id1, id2);
 705        } else {
 706                buf[0] = (id1 >> 8);
 707                buf[1] = (id1 & 0xFF);
 708                buf[2] = (id2 >> 8);
 709                snprintf(buf+3, CODEC_ID_BUFSZ - 3, "%d", id2&0xFF);
 710        }
 711        return buf;
 712}
 713 
 714/**
 715 *      ac97_check_modem - Check if the Codec is a modem
 716 *      @codec: codec to check
 717 *
 718 *      Return true if the device is an AC97 1.0 or AC97 2.0 modem
 719 */
 720 
 721static int ac97_check_modem(struct ac97_codec *codec)
 722{
 723        /* Check for an AC97 1.0 soft modem (ID1) */
 724        if(codec->codec_read(codec, AC97_RESET) & 2)
 725                return 1;
 726        /* Check for an AC97 2.x soft modem */
 727        codec->codec_write(codec, AC97_EXTENDED_MODEM_ID, 0L);
 728        if(codec->codec_read(codec, AC97_EXTENDED_MODEM_ID) & 1)
 729                return 1;
 730        return 0;
 731}
 732
 733
 734/**
 735 *      ac97_alloc_codec - Allocate an AC97 codec
 736 *
 737 *      Returns a new AC97 codec structure. AC97 codecs may become
 738 *      refcounted soon so this interface is needed. Returns with
 739 *      one reference taken.
 740 */
 741 
 742struct ac97_codec *ac97_alloc_codec(void)
 743{
 744        struct ac97_codec *codec = kmalloc(sizeof(struct ac97_codec), GFP_KERNEL);
 745        if(!codec)
 746                return NULL;
 747
 748        memset(codec, 0, sizeof(*codec));
 749        spin_lock_init(&codec->lock);
 750        INIT_LIST_HEAD(&codec->list);
 751        return codec;
 752}
 753
 754EXPORT_SYMBOL(ac97_alloc_codec);
 755
 756/**
 757 *      ac97_release_codec -    Release an AC97 codec
 758 *      @codec: codec to release
 759 *
 760 *      Release an allocated AC97 codec. This will be refcounted in
 761 *      time but for the moment is trivial. Calls the unregister
 762 *      handler if the codec is now defunct.
 763 */
 764 
 765void ac97_release_codec(struct ac97_codec *codec)
 766{
 767        /* Remove from the list first, we don't want to be
 768           "rediscovered" */
 769        down(&codec_sem);
 770        list_del(&codec->list);
 771        up(&codec_sem);
 772        /*
 773         *      The driver needs to deal with internal
 774         *      locking to avoid accidents here. 
 775         */
 776        if(codec->driver)
 777                codec->driver->remove(codec, codec->driver);
 778        kfree(codec);
 779}
 780
 781EXPORT_SYMBOL(ac97_release_codec);
 782
 783/**
 784 *      ac97_probe_codec - Initialize and setup AC97-compatible codec
 785 *      @codec: (in/out) Kernel info for a single AC97 codec
 786 *
 787 *      Reset the AC97 codec, then initialize the mixer and
 788 *      the rest of the @codec structure.
 789 *
 790 *      The codec_read and codec_write fields of @codec are
 791 *      required to be setup and working when this function
 792 *      is called.  All other fields are set by this function.
 793 *
 794 *      codec_wait field of @codec can optionally be provided
 795 *      when calling this function.  If codec_wait is not %NULL,
 796 *      this function will call codec_wait any time it is
 797 *      necessary to wait for the audio chip to reach the
 798 *      codec-ready state.  If codec_wait is %NULL, then
 799 *      the default behavior is to call schedule_timeout.
 800 *      Currently codec_wait is used to wait for AC97 codec
 801 *      reset to complete. 
 802 *
 803 *  Some codecs will power down when a register reset is
 804 *  performed. We now check for such codecs.
 805 *
 806 *      Returns 1 (true) on success, or 0 (false) on failure.
 807 */
 808 
 809int ac97_probe_codec(struct ac97_codec *codec)
 810{
 811        u16 id1, id2;
 812        u16 audio;
 813        int i;
 814        char cidbuf[CODEC_ID_BUFSZ];
 815        u16 f;
 816        struct list_head *l;
 817        struct ac97_driver *d;
 818
 819        /* wait for codec-ready state */        
 820        if (codec->codec_wait)
 821                codec->codec_wait(codec);
 822        else
 823                udelay(10);
 824        
 825        /* will the codec power down if register reset ? */
 826        id1 = codec->codec_read(codec, AC97_VENDOR_ID1);
 827        id2 = codec->codec_read(codec, AC97_VENDOR_ID2);
 828        codec->name = NULL;
 829        codec->codec_ops = &null_ops;
 830        for (i = 0; i < ARRAY_SIZE(ac97_codec_ids); i++) {
 831                if (ac97_codec_ids[i].id == ((id1 << 16) | id2)) {
 832                        codec->type = ac97_codec_ids[i].id;
 833                        codec->name = ac97_codec_ids[i].name;
 834                        codec->codec_ops = ac97_codec_ids[i].ops;
 835                        codec->flags = ac97_codec_ids[i].flags;
 836                        break;
 837                }
 838        }
 839        codec->model = (id1 << 16) | id2;
 840        if ((codec->flags & AC97_DEFAULT_POWER_OFF) == 0) {
 841                /* reset codec and wait for the ready bit before we continue */
 842                codec->codec_write(codec, AC97_RESET, 0L);
 843                if (codec->codec_wait)
 844                        codec->codec_wait(codec);
 845                else
 846                        udelay(10);
 847        }
 848        
 849        /* probing AC97 codec, AC97 2.0 says that bit 15 of register 0x00 (reset) should 
 850         * be read zero.
 851         *
 852         * FIXME: is the following comment outdated?  -jgarzik 
 853         * Probing of AC97 in this way is not reliable, it is not even SAFE !!
 854         */
 855        if ((audio = codec->codec_read(codec, AC97_RESET)) & 0x8000) {
 856                printk(KERN_ERR "ac97_codec: %s ac97 codec not present\n",
 857                       (codec->id & 0x2) ? (codec->id&1 ? "4th" : "Tertiary") 
 858                       : (codec->id&1 ? "Secondary":  "Primary"));
 859                return 0;
 860        }
 861        
 862        /* probe for Modem Codec */
 863        codec->modem = ac97_check_modem(codec);
 864        
 865        /* enable SPDIF */
 866        f = codec->codec_read(codec, AC97_EXTENDED_STATUS);
 867        if((codec->codec_ops == &null_ops) && (f & 4))
 868                codec->codec_ops = &default_digital_ops;
 869        
 870        /* A device which thinks its a modem but isnt */
 871        if(codec->flags & AC97_DELUDED_MODEM)
 872                codec->modem = 0;
 873                
 874        if (codec->name == NULL)
 875                codec->name = "Unknown";
 876        printk(KERN_INFO "ac97_codec: AC97 %s codec, id: %s (%s)\n", 
 877                codec->modem ? "Modem" : (audio ? "Audio" : ""),
 878               codec_id(id1, id2, cidbuf), codec->name);
 879
 880        if(!ac97_init_mixer(codec))
 881                return 0;
 882                
 883        /* 
 884         *      Attach last so the caller can override the mixer
 885         *      callbacks.
 886         */
 887         
 888        down(&codec_sem);
 889        list_add(&codec->list, &codecs);
 890
 891        list_for_each(l, &codec_drivers) {
 892                d = list_entry(l, struct ac97_driver, list);
 893                if ((codec->model ^ d->codec_id) & d->codec_mask)
 894                        continue;
 895                if(d->probe(codec, d) == 0)
 896                {
 897                        codec->driver = d;
 898                        break;
 899                }
 900        }
 901
 902        up(&codec_sem);
 903        return 1;
 904}
 905
 906static int ac97_init_mixer(struct ac97_codec *codec)
 907{
 908        u16 cap;
 909        int i;
 910
 911        cap = codec->codec_read(codec, AC97_RESET);
 912
 913        /* mixer masks */
 914        codec->supported_mixers = AC97_SUPPORTED_MASK;
 915        codec->stereo_mixers = AC97_STEREO_MASK;
 916        codec->record_sources = AC97_RECORD_MASK;
 917        if (!(cap & 0x04))
 918                codec->supported_mixers &= ~(SOUND_MASK_BASS|SOUND_MASK_TREBLE);
 919        if (!(cap & 0x10))
 920                codec->supported_mixers &= ~SOUND_MASK_ALTPCM;
 921
 922
 923        /* detect bit resolution */
 924        codec->codec_write(codec, AC97_MASTER_VOL_STEREO, 0x2020);
 925        if(codec->codec_read(codec, AC97_MASTER_VOL_STEREO) == 0x2020)
 926                codec->bit_resolution = 6;
 927        else
 928                codec->bit_resolution = 5;
 929
 930        /* generic OSS to AC97 wrapper */
 931        codec->read_mixer = ac97_read_mixer;
 932        codec->write_mixer = ac97_write_mixer;
 933        codec->recmask_io = ac97_recmask_io;
 934        codec->mixer_ioctl = ac97_mixer_ioctl;
 935
 936        /* initialize mixer channel volumes */
 937        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 938                struct mixer_defaults *md = &mixer_defaults[i];
 939                if (md->mixer == -1) 
 940                        break;
 941                if (!supported_mixer(codec, md->mixer)) 
 942                        continue;
 943                ac97_set_mixer(codec, md->mixer, md->value);
 944        }
 945        
 946        /* codec specific initialization for 4-6 channel output or secondary codec stuff */
 947        if (codec->codec_ops->init != NULL) {
 948                codec->codec_ops->init(codec);
 949        }
 950
 951        /*
 952         *      Volume is MUTE only on this device. We have to initialise
 953         *      it but its useless beyond that.
 954         */
 955        if(codec->flags & AC97_NO_PCM_VOLUME)
 956        {
 957                codec->supported_mixers &= ~SOUND_MASK_PCM;
 958                printk(KERN_WARNING "AC97 codec does not have proper volume support.\n");
 959        }
 960        return 1;
 961}
 962
 963#define AC97_SIGMATEL_ANALOG    0x6c    /* Analog Special */
 964#define AC97_SIGMATEL_DAC2INVERT 0x6e
 965#define AC97_SIGMATEL_BIAS1     0x70
 966#define AC97_SIGMATEL_BIAS2     0x72
 967#define AC97_SIGMATEL_MULTICHN  0x74    /* Multi-Channel programming */
 968#define AC97_SIGMATEL_CIC1      0x76
 969#define AC97_SIGMATEL_CIC2      0x78
 970
 971
 972static int sigmatel_9708_init(struct ac97_codec * codec)
 973{
 974        u16 codec72, codec6c;
 975
 976        codec72 = codec->codec_read(codec, AC97_SIGMATEL_BIAS2) & 0x8000;
 977        codec6c = codec->codec_read(codec, AC97_SIGMATEL_ANALOG);
 978
 979        if ((codec72==0) && (codec6c==0)) {
 980                codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
 981                codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x1000);
 982                codec->codec_write(codec, AC97_SIGMATEL_BIAS1, 0xabba);
 983                codec->codec_write(codec, AC97_SIGMATEL_BIAS2, 0x0007);
 984        } else if ((codec72==0x8000) && (codec6c==0)) {
 985                codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
 986                codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x1001);
 987                codec->codec_write(codec, AC97_SIGMATEL_DAC2INVERT, 0x0008);
 988        } else if ((codec72==0x8000) && (codec6c==0x0080)) {
 989                /* nothing */
 990        }
 991        codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x0000);
 992        return 0;
 993}
 994
 995
 996static int sigmatel_9721_init(struct ac97_codec * codec)
 997{
 998        /* Only set up secondary codec */
 999        if (codec->id == 0)
1000                return 0;
1001
1002        codec->codec_write(codec, AC97_SURROUND_MASTER, 0L);
1003
1004        /* initialize SigmaTel STAC9721/23 as secondary codec, decoding AC link
1005           sloc 3,4 = 0x01, slot 7,8 = 0x00, */
1006        codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x00);
1007
1008        /* we don't have the crystal when we are on an AMR card, so use
1009           BIT_CLK as our clock source. Write the magic word ABBA and read
1010           back to enable register 0x78 */
1011        codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
1012        codec->codec_read(codec, AC97_SIGMATEL_CIC1);
1013
1014        /* sync all the clocks*/
1015        codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x3802);
1016
1017        return 0;
1018}
1019
1020
1021static int sigmatel_9744_init(struct ac97_codec * codec)
1022{
1023        // patch for SigmaTel
1024        codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
1025        codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x0000); // is this correct? --jk
1026        codec->codec_write(codec, AC97_SIGMATEL_BIAS1, 0xabba);
1027        codec->codec_write(codec, AC97_SIGMATEL_BIAS2, 0x0002);
1028        codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x0000);
1029        return 0;
1030}
1031
1032static int cmedia_init(struct ac97_codec *codec)
1033{
1034        /* Initialise the CMedia 9739 */
1035        /*
1036                We could set various options here
1037                Register 0x20 bit 0x100 sets mic as center bass
1038                Also do multi_channel_ctrl &=~0x3000 |=0x1000
1039                
1040                For now we set up the GPIO and PC beep 
1041        */
1042        
1043        u16 v;
1044        
1045        /* MIC */
1046        codec->codec_write(codec, 0x64, 0x3000);
1047        v = codec->codec_read(codec, 0x64);
1048        v &= ~0x8000;
1049        codec->codec_write(codec, 0x64, v);
1050        codec->codec_write(codec, 0x70, 0x0100);
1051        codec->codec_write(codec, 0x72, 0x0020);
1052        return 0;
1053}
1054        
1055#define AC97_WM97XX_FMIXER_VOL 0x72
1056#define AC97_WM97XX_RMIXER_VOL 0x74
1057#define AC97_WM97XX_TEST 0x5a
1058#define AC97_WM9704_RPCM_VOL 0x70
1059#define AC97_WM9711_OUT3VOL 0x16
1060
1061static int wolfson_init03(struct ac97_codec * codec)
1062{
1063        /* this is known to work for the ViewSonic ViewPad 1000 */
1064        codec->codec_write(codec, AC97_WM97XX_FMIXER_VOL, 0x0808);
1065        codec->codec_write(codec, AC97_GENERAL_PURPOSE, 0x8000);
1066        return 0;
1067}
1068
1069static int wolfson_init04(struct ac97_codec * codec)
1070{
1071        codec->codec_write(codec, AC97_WM97XX_FMIXER_VOL, 0x0808);
1072        codec->codec_write(codec, AC97_WM97XX_RMIXER_VOL, 0x0808);
1073
1074        // patch for DVD noise
1075        codec->codec_write(codec, AC97_WM97XX_TEST, 0x0200);
1076
1077        // init vol as PCM vol
1078        codec->codec_write(codec, AC97_WM9704_RPCM_VOL,
1079                codec->codec_read(codec, AC97_PCMOUT_VOL));
1080
1081        /* set rear surround volume */
1082        codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0000);
1083        return 0;
1084}
1085
1086/* WM9705, WM9710 */
1087static int wolfson_init05(struct ac97_codec * codec)
1088{
1089        /* set front mixer volume */
1090        codec->codec_write(codec, AC97_WM97XX_FMIXER_VOL, 0x0808);
1091        return 0;
1092}
1093
1094/* WM9711, WM9712 */
1095static int wolfson_init11(struct ac97_codec * codec)
1096{
1097        /* stop pop's during suspend/resume */
1098        codec->codec_write(codec, AC97_WM97XX_TEST, codec->codec_read(codec, AC97_WM97XX_TEST) & 0xffbf);
1099
1100        /* set out3 volume */
1101        codec->codec_write(codec, AC97_WM9711_OUT3VOL, 0x0808);
1102        return 0;
1103}
1104
1105/* WM9713 */
1106static int wolfson_init13(struct ac97_codec * codec)
1107{
1108        codec->codec_write(codec, AC97_RECORD_GAIN, 0x00a0);    
1109        codec->codec_write(codec, AC97_POWER_CONTROL, 0x0000);
1110        codec->codec_write(codec, AC97_EXTENDED_MODEM_ID, 0xDA00);
1111        codec->codec_write(codec, AC97_EXTEND_MODEM_STAT, 0x3810);
1112        codec->codec_write(codec, AC97_PHONE_VOL, 0x0808);
1113        codec->codec_write(codec, AC97_PCBEEP_VOL, 0x0808);
1114
1115        return 0;
1116}
1117
1118static int tritech_init(struct ac97_codec * codec)
1119{
1120        codec->codec_write(codec, 0x26, 0x0300);
1121        codec->codec_write(codec, 0x26, 0x0000);
1122        codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0000);
1123        codec->codec_write(codec, AC97_RESERVED_3A, 0x0000);
1124        return 0;
1125}
1126
1127
1128/* copied from drivers/sound/maestro.c */
1129static int tritech_maestro_init(struct ac97_codec * codec)
1130{
1131        /* no idea what this does */
1132        codec->codec_write(codec, 0x2A, 0x0001);
1133        codec->codec_write(codec, 0x2C, 0x0000);
1134        codec->codec_write(codec, 0x2C, 0XFFFF);
1135        return 0;
1136}
1137
1138
1139
1140/* 
1141 *      Presario700 workaround 
1142 *      for Jack Sense/SPDIF Register mis-setting causing
1143 *      no audible output
1144 *      by Santiago Nullo 04/05/2002
1145 */
1146
1147#define AC97_AD1886_JACK_SENSE 0x72
1148
1149static int ad1886_init(struct ac97_codec * codec)
1150{
1151        /* from AD1886 Specs */
1152        codec->codec_write(codec, AC97_AD1886_JACK_SENSE, 0x0010);
1153        return 0;
1154}
1155
1156
1157
1158
1159/*
1160 *      This is basically standard AC97. It should work as a default for
1161 *      almost all modern codecs. Note that some cards wire EAPD *backwards*
1162 *      That side of it is up to the card driver not us to cope with.
1163 *
1164 */
1165
1166static int eapd_control(struct ac97_codec * codec, int on)
1167{
1168        if(on)
1169                codec->codec_write(codec, AC97_POWER_CONTROL,
1170                        codec->codec_read(codec, AC97_POWER_CONTROL)|0x8000);
1171        else
1172                codec->codec_write(codec, AC97_POWER_CONTROL,
1173                        codec->codec_read(codec, AC97_POWER_CONTROL)&~0x8000);
1174        return 0;
1175}
1176
1177static int generic_digital_control(struct ac97_codec *codec, int slots, int rate, int mode)
1178{
1179        u16 reg;
1180        
1181        reg = codec->codec_read(codec, AC97_SPDIF_CONTROL);
1182        
1183        switch(rate)
1184        {
1185                /* Off by default */
1186                default:
1187                case 0:
1188                        reg = codec->codec_read(codec, AC97_EXTENDED_STATUS);
1189                        codec->codec_write(codec, AC97_EXTENDED_STATUS, (reg & ~AC97_EA_SPDIF));
1190                        if(rate == 0)
1191                                return 0;
1192                        return -EINVAL;
1193                case 1:
1194                        reg = (reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_48K;
1195                        break;
1196                case 2:
1197                        reg = (reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_44K;
1198                        break;
1199                case 3:
1200                        reg = (reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_32K;
1201                        break;
1202        }
1203        
1204        reg &= ~AC97_SC_CC_MASK;
1205        reg |= (mode & AUDIO_CCMASK) << 6;
1206        
1207        if(mode & AUDIO_DIGITAL)
1208                reg |= 2;
1209        if(mode & AUDIO_PRO)
1210                reg |= 1;
1211        if(mode & AUDIO_DRS)
1212                reg |= 0x4000;
1213
1214        codec->codec_write(codec, AC97_SPDIF_CONTROL, reg);
1215
1216        reg = codec->codec_read(codec, AC97_EXTENDED_STATUS);
1217        reg &= (AC97_EA_SLOT_MASK);
1218        reg |= AC97_EA_VRA | AC97_EA_SPDIF | slots;
1219        codec->codec_write(codec, AC97_EXTENDED_STATUS, reg);
1220        
1221        reg = codec->codec_read(codec, AC97_EXTENDED_STATUS);
1222        if(!(reg & 0x0400))
1223        {
1224                codec->codec_write(codec, AC97_EXTENDED_STATUS, reg & ~ AC97_EA_SPDIF);
1225                return -EINVAL;
1226        }
1227        return 0;
1228}
1229
1230/*
1231 *      Crystal digital audio control (CS4299)
1232 */
1233 
1234static int crystal_digital_control(struct ac97_codec *codec, int slots, int rate, int mode)
1235{
1236        u16 cv;
1237
1238        if(mode & AUDIO_DIGITAL)
1239                return -EINVAL;
1240                
1241        switch(rate)
1242        {
1243                case 0: cv = 0x0; break;        /* SPEN off */
1244                case 48000: cv = 0x8004; break; /* 48KHz digital */
1245                case 44100: cv = 0x8104; break; /* 44.1KHz digital */
1246                case 32768:                     /* 32Khz */
1247                default:
1248                        return -EINVAL;
1249        }
1250        codec->codec_write(codec, 0x68, cv);
1251        return 0;
1252}
1253
1254/*
1255 *      CMedia digital audio control
1256 *      Needs more work.
1257 */
1258 
1259static int cmedia_digital_control(struct ac97_codec *codec, int slots, int rate, int mode)
1260{
1261        u16 cv;
1262
1263        if(mode & AUDIO_DIGITAL)
1264                return -EINVAL;
1265                
1266        switch(rate)
1267        {
1268                case 0:         cv = 0x0001; break;     /* SPEN off */
1269                case 48000:     cv = 0x0009; break;     /* 48KHz digital */
1270                default:
1271                        return -EINVAL;
1272        }
1273        codec->codec_write(codec, 0x2A, 0x05c4);
1274        codec->codec_write(codec, 0x6C, cv);
1275        
1276        /* Switch on mix to surround */
1277        cv = codec->codec_read(codec, 0x64);
1278        cv &= ~0x0200;
1279        if(mode)
1280                cv |= 0x0200;
1281        codec->codec_write(codec, 0x64, cv);
1282        return 0;
1283}
1284
1285
1286/* copied from drivers/sound/maestro.c */
1287#if 0  /* there has been 1 person on the planet with a pt101 that we
1288        know of.  If they care, they can put this back in :) */
1289static int pt101_init(struct ac97_codec * codec)
1290{
1291        printk(KERN_INFO "ac97_codec: PT101 Codec detected, initializing but _not_ installing mixer device.\n");
1292        /* who knows.. */
1293        codec->codec_write(codec, 0x2A, 0x0001);
1294        codec->codec_write(codec, 0x2C, 0x0000);
1295        codec->codec_write(codec, 0x2C, 0xFFFF);
1296        codec->codec_write(codec, 0x10, 0x9F1F);
1297        codec->codec_write(codec, 0x12, 0x0808);
1298        codec->codec_write(codec, 0x14, 0x9F1F);
1299        codec->codec_write(codec, 0x16, 0x9F1F);
1300        codec->codec_write(codec, 0x18, 0x0404);
1301        codec->codec_write(codec, 0x1A, 0x0000);
1302        codec->codec_write(codec, 0x1C, 0x0000);
1303        codec->codec_write(codec, 0x02, 0x0404);
1304        codec->codec_write(codec, 0x04, 0x0808);
1305        codec->codec_write(codec, 0x0C, 0x801F);
1306        codec->codec_write(codec, 0x0E, 0x801F);
1307        return 0;
1308}
1309#endif
1310        
1311
1312EXPORT_SYMBOL(ac97_read_proc);
1313EXPORT_SYMBOL(ac97_probe_codec);
1314
1315/*
1316 *      AC97 library support routines
1317 */     
1318 
1319/**
1320 *      ac97_set_dac_rate       -       set codec rate adaption
1321 *      @codec: ac97 code
1322 *      @rate: rate in hertz
1323 *
1324 *      Set the DAC rate. Assumes the codec supports VRA. The caller is
1325 *      expected to have checked this little detail.
1326 */
1327 
1328unsigned int ac97_set_dac_rate(struct ac97_codec *codec, unsigned int rate)
1329{
1330        unsigned int new_rate = rate;
1331        u32 dacp;
1332        u32 mast_vol, phone_vol, mono_vol, pcm_vol;
1333        u32 mute_vol = 0x8000;  /* The mute volume? */
1334
1335        if(rate != codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE))
1336        {
1337                /* Mute several registers */
1338                mast_vol = codec->codec_read(codec, AC97_MASTER_VOL_STEREO);
1339                mono_vol = codec->codec_read(codec, AC97_MASTER_VOL_MONO);
1340                phone_vol = codec->codec_read(codec, AC97_HEADPHONE_VOL);
1341                pcm_vol = codec->codec_read(codec, AC97_PCMOUT_VOL);
1342                codec->codec_write(codec, AC97_MASTER_VOL_STEREO, mute_vol);
1343                codec->codec_write(codec, AC97_MASTER_VOL_MONO, mute_vol);
1344                codec->codec_write(codec, AC97_HEADPHONE_VOL, mute_vol);
1345                codec->codec_write(codec, AC97_PCMOUT_VOL, mute_vol);
1346                
1347                /* Power down the DAC */
1348                dacp=codec->codec_read(codec, AC97_POWER_CONTROL);
1349                codec->codec_write(codec, AC97_POWER_CONTROL, dacp|0x0200);
1350                /* Load the rate and read the effective rate */
1351                codec->codec_write(codec, AC97_PCM_FRONT_DAC_RATE, rate);
1352                new_rate=codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE);
1353                /* Power it back up */
1354                codec->codec_write(codec, AC97_POWER_CONTROL, dacp);
1355
1356                /* Restore volumes */
1357                codec->codec_write(codec, AC97_MASTER_VOL_STEREO, mast_vol);
1358                codec->codec_write(codec, AC97_MASTER_VOL_MONO, mono_vol);
1359                codec->codec_write(codec, AC97_HEADPHONE_VOL, phone_vol);
1360                codec->codec_write(codec, AC97_PCMOUT_VOL, pcm_vol);
1361        }
1362        return new_rate;
1363}
1364
1365EXPORT_SYMBOL(ac97_set_dac_rate);
1366
1367/**
1368 *      ac97_set_adc_rate       -       set codec rate adaption
1369 *      @codec: ac97 code
1370 *      @rate: rate in hertz
1371 *
1372 *      Set the ADC rate. Assumes the codec supports VRA. The caller is
1373 *      expected to have checked this little detail.
1374 */
1375
1376unsigned int ac97_set_adc_rate(struct ac97_codec *codec, unsigned int rate)
1377{
1378        unsigned int new_rate = rate;
1379        u32 dacp;
1380
1381        if(rate != codec->codec_read(codec, AC97_PCM_LR_ADC_RATE))
1382        {
1383                /* Power down the ADC */
1384                dacp=codec->codec_read(codec, AC97_POWER_CONTROL);
1385                codec->codec_write(codec, AC97_POWER_CONTROL, dacp|0x0100);
1386                /* Load the rate and read the effective rate */
1387                codec->codec_write(codec, AC97_PCM_LR_ADC_RATE, rate);
1388                new_rate=codec->codec_read(codec, AC97_PCM_LR_ADC_RATE);
1389                /* Power it back up */
1390                codec->codec_write(codec, AC97_POWER_CONTROL, dacp);
1391        }
1392        return new_rate;
1393}
1394
1395EXPORT_SYMBOL(ac97_set_adc_rate);
1396
1397int ac97_save_state(struct ac97_codec *codec)
1398{
1399        return 0;       
1400}
1401
1402EXPORT_SYMBOL(ac97_save_state);
1403
1404int ac97_restore_state(struct ac97_codec *codec)
1405{
1406        int i;
1407        unsigned int left, right, val;
1408
1409        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
1410                if (!supported_mixer(codec, i)) 
1411                        continue;
1412
1413                val = codec->mixer_state[i];
1414                right = val >> 8;
1415                left = val  & 0xff;
1416                codec->write_mixer(codec, i, left, right);
1417        }
1418        return 0;
1419}
1420
1421EXPORT_SYMBOL(ac97_restore_state);
1422
1423/**
1424 *      ac97_register_driver    -       register a codec helper
1425 *      @driver: Driver handler
1426 *
1427 *      Register a handler for codecs matching the codec id. The handler
1428 *      attach function is called for all present codecs and will be 
1429 *      called when new codecs are discovered.
1430 */
1431 
1432int ac97_register_driver(struct ac97_driver *driver)
1433{
1434        struct list_head *l;
1435        struct ac97_codec *c;
1436        
1437        down(&codec_sem);
1438        INIT_LIST_HEAD(&driver->list);
1439        list_add(&driver->list, &codec_drivers);
1440        
1441        list_for_each(l, &codecs)
1442        {
1443                c = list_entry(l, struct ac97_codec, list);
1444                if(c->driver != NULL || ((c->model ^ driver->codec_id) & driver->codec_mask))
1445                        continue;
1446                if(driver->probe(c, driver))
1447                        continue;
1448                c->driver = driver;
1449        }
1450        up(&codec_sem);
1451        return 0;
1452}
1453
1454EXPORT_SYMBOL_GPL(ac97_register_driver);
1455
1456/**
1457 *      ac97_unregister_driver  -       unregister a codec helper
1458 *      @driver: Driver handler
1459 *
1460 *      Register a handler for codecs matching the codec id. The handler
1461 *      attach function is called for all present codecs and will be 
1462 *      called when new codecs are discovered.
1463 */
1464 
1465void ac97_unregister_driver(struct ac97_driver *driver)
1466{
1467        struct list_head *l;
1468        struct ac97_codec *c;
1469        
1470        down(&codec_sem);
1471        list_del_init(&driver->list);
1472        
1473        list_for_each(l, &codecs)
1474        {
1475                c = list_entry(l, struct ac97_codec, list);
1476                if(c->driver == driver)
1477                        driver->remove(c, driver);
1478                c->driver = NULL;
1479        }
1480        
1481        up(&codec_sem);
1482}
1483
1484EXPORT_SYMBOL_GPL(ac97_unregister_driver);
1485        
1486MODULE_LICENSE("GPL");
1487