sound/oss/ac97_codec.c

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