sys/dev/sound/pcm/ac97.c

   1 /*-
   2  * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/sound/pcm/ac97.c,v 1.53.2.5 2007/05/13 20:53:39 ariff Exp $
  27  * $DragonFly: src/sys/dev/sound/pcm/ac97.c,v 1.25 2007/06/16 20:07:22 dillon Exp $
  28  */
  29
  30 #include <dev/sound/pcm/sound.h>
  31 #include <dev/sound/pcm/ac97.h>
  32 #include <dev/sound/pcm/ac97_patch.h>
  33
  34 #include <bus/pci/pcivar.h>
  35
  36 #include "mixer_if.h"
  37
  38 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/ac97.c,v 1.25 2007/06/16 20:07:22 dillon Exp $");
  39
  40 MALLOC_DEFINE(M_AC97, "ac97", "ac97 codec");
  41
  42 struct ac97mixtable_entry {
  43         int      reg:8;         /* register index               */
  44                                 /* reg < 0 if inverted polarity */
  45         unsigned bits:4;        /* width of control field       */
  46         unsigned ofs:4;         /* offset (only if stereo=0)    */
  47         unsigned stereo:1;      /* set for stereo controls      */
  48         unsigned mute:1;        /* bit15 is MUTE                */
  49         unsigned recidx:4;      /* index in rec mux             */
  50         unsigned mask:1;        /* use only masked bits         */
  51         unsigned enable:1;      /* entry is enabled             */
  52 };
  53
  54 #define AC97_NAMELEN    16
  55 struct ac97_info {
  56         kobj_t methods;
  57         device_t dev;
  58         void *devinfo;
  59         u_int32_t id;
  60         u_int32_t subvendor;
  61         unsigned count, caps, se, extcaps, extid, extstat, noext:1;
  62         u_int32_t flags;
  63         struct ac97mixtable_entry mix[32];
  64         char name[AC97_NAMELEN];
  65         sndlock_t       lock;
  66 };
  67
  68 struct ac97_vendorid {
  69         u_int32_t   id;
  70         const char *name;
  71 };
  72
  73 struct ac97_codecid {
  74         u_int32_t  id;
  75         u_int8_t   stepmask;
  76         u_int8_t   noext:1;
  77         char      *name;
  78         ac97_patch patch;
  79 };
  80
  81 static const struct ac97mixtable_entry ac97mixtable_default[32] = {
  82     /*  [offset]                        reg          bits of st mu re mk en */
  83         [SOUND_MIXER_VOLUME]    = { AC97_MIX_MASTER,    5, 0, 1, 1, 6, 0, 1 },
  84         [SOUND_MIXER_OGAIN]     = { AC97_MIX_AUXOUT,    5, 0, 1, 1, 0, 0, 0 },
  85         [SOUND_MIXER_PHONEOUT]  = { AC97_MIX_MONO,      5, 0, 0, 1, 7, 0, 0 },
  86         [SOUND_MIXER_BASS]      = { AC97_MIX_TONE,      4, 8, 0, 0, 0, 1, 0 },
  87         [SOUND_MIXER_TREBLE]    = { AC97_MIX_TONE,      4, 0, 0, 0, 0, 1, 0 },
  88         [SOUND_MIXER_PCM]       = { AC97_MIX_PCM,       5, 0, 1, 1, 0, 0, 1 },
  89         [SOUND_MIXER_SPEAKER]   = { AC97_MIX_BEEP,      4, 1, 0, 1, 0, 0, 0 },
  90         [SOUND_MIXER_LINE]      = { AC97_MIX_LINE,      5, 0, 1, 1, 5, 0, 1 },
  91         [SOUND_MIXER_PHONEIN]   = { AC97_MIX_PHONE,     5, 0, 0, 1, 8, 0, 0 },
  92         [SOUND_MIXER_MIC]       = { AC97_MIX_MIC,       5, 0, 0, 1, 1, 1, 1 },
  93         /* use igain for the mic 20dB boost */
  94         [SOUND_MIXER_IGAIN]     = { -AC97_MIX_MIC,      1, 6, 0, 0, 0, 1, 1 },
  95         [SOUND_MIXER_CD]        = { AC97_MIX_CD,        5, 0, 1, 1, 2, 0, 1 },
  96         [SOUND_MIXER_LINE1]     = { AC97_MIX_AUX,       5, 0, 1, 1, 4, 0, 0 },
  97         [SOUND_MIXER_VIDEO]     = { AC97_MIX_VIDEO,     5, 0, 1, 1, 3, 0, 0 },
  98         [SOUND_MIXER_RECLEV]    = { -AC97_MIX_RGAIN,    4, 0, 1, 1, 0, 0, 1 }
  99 };
 100
 101 static const struct ac97_vendorid ac97vendorid[] = {
 102         { 0x41445300, "Analog Devices" },
 103         { 0x414b4d00, "Asahi Kasei" },
 104         { 0x414c4300, "Realtek" },
 105         { 0x414c4700, "Avance Logic" },
 106         { 0x43525900, "Cirrus Logic" },
 107         { 0x434d4900, "C-Media Electronics" },
 108         { 0x43585400, "Conexant" },
 109         { 0x44543000, "Diamond Technology" },
 110         { 0x454d4300, "eMicro" },
 111         { 0x45838300, "ESS Technology" },
 112         { 0x48525300, "Intersil" },
 113         { 0x49434500, "ICEnsemble" },
 114         { 0x49544500, "ITE, Inc." },
 115         { 0x4e534300, "National Semiconductor" },
 116         { 0x50534300, "Philips Semiconductor" },
 117         { 0x83847600, "SigmaTel" },
 118         { 0x53494c00, "Silicon Laboratories" },
 119         { 0x54524100, "TriTech" },
 120         { 0x54584e00, "Texas Instruments" },
 121         { 0x56494100, "VIA Technologies" },
 122         { 0x57454300, "Winbond" },
 123         { 0x574d4c00, "Wolfson" },
 124         { 0x594d4800, "Yamaha" },
 125         /*
 126          * XXX This is a fluke, really! The real vendor
 127          * should be SigmaTel, not this! This should be
 128          * removed someday!
 129          */
 130         { 0x01408300, "Creative" },
 131         { 0x00000000, NULL }
 132 };
 133
 134 static struct ac97_codecid ac97codecid[] = {
 135         { 0x41445303, 0x00, 0, "AD1819",        0 },
 136         { 0x41445340, 0x00, 0, "AD1881",        0 },
 137         { 0x41445348, 0x00, 0, "AD1881A",       0 },
 138         { 0x41445360, 0x00, 0, "AD1885",        0 },
 139         { 0x41445361, 0x00, 0, "AD1886",        ad1886_patch },
 140         { 0x41445362, 0x00, 0, "AD1887",        0 },
 141         { 0x41445363, 0x00, 0, "AD1886A",       0 },
 142         { 0x41445368, 0x00, 0, "AD1888",        ad198x_patch },
 143         { 0x41445370, 0x00, 0, "AD1980",        ad198x_patch },
 144         { 0x41445372, 0x00, 0, "AD1981A",       0 },
 145         { 0x41445374, 0x00, 0, "AD1981B",       ad1981b_patch },
 146         { 0x41445375, 0x00, 0, "AD1985",        ad198x_patch },
 147         { 0x41445378, 0x00, 0, "AD1986",        ad198x_patch },
 148         { 0x414b4d00, 0x00, 1, "AK4540",        0 },
 149         { 0x414b4d01, 0x00, 1, "AK4542",        0 },
 150         { 0x414b4d02, 0x00, 1, "AK4543",        0 },
 151         { 0x414b4d06, 0x00, 0, "AK4544A",       0 },
 152         { 0x454b4d07, 0x00, 0, "AK4545",        0 },
 153         { 0x414c4320, 0x0f, 0, "ALC100",        0 },
 154         { 0x414c4730, 0x0f, 0, "ALC101",        0 },
 155         { 0x414c4710, 0x0f, 0, "ALC200",        0 },
 156         { 0x414c4740, 0x0f, 0, "ALC202",        0 },
 157         { 0x414c4720, 0x0f, 0, "ALC650",        0 },
 158         { 0x414c4752, 0x0f, 0, "ALC250",        0 },
 159         { 0x414c4760, 0x0f, 0, "ALC655",        alc655_patch },
 160         { 0x414c4770, 0x0f, 0, "ALC203",        0 },
 161         { 0x414c4780, 0x0f, 0, "ALC658",        0 },
 162         { 0x414c4790, 0x0f, 0, "ALC850",        0 },
 163         { 0x43525900, 0x07, 0, "CS4297",        0 },
 164         { 0x43525910, 0x07, 0, "CS4297A",       0 },
 165         { 0x43525920, 0x07, 0, "CS4294/98",     0 },
 166         { 0x4352592d, 0x07, 0, "CS4294",        0 },
 167         { 0x43525930, 0x07, 0, "CS4299",        0 },
 168         { 0x43525940, 0x07, 0, "CS4201",        0 },
 169         { 0x43525958, 0x07, 0, "CS4205",        0 },
 170         { 0x43525960, 0x07, 0, "CS4291A",       0 },
 171         { 0x434d4961, 0x00, 0, "CMI9739",       cmi9739_patch },
 172         { 0x434d4941, 0x00, 0, "CMI9738",       0 },
 173         { 0x434d4978, 0x00, 0, "CMI9761",       0 },
 174         { 0x434d4982, 0x00, 0, "CMI9761",       0 },
 175         { 0x434d4983, 0x00, 0, "CMI9761",       0 },
 176         { 0x43585421, 0x00, 0, "HSD11246",      0 },
 177         { 0x43585428, 0x07, 0, "CX20468",       0 },
 178         { 0x43585430, 0x00, 0, "CX20468-21",    0 },
 179         { 0x44543000, 0x00, 0, "DT0398",        0 },
 180         { 0x454d4323, 0x00, 0, "EM28023",       0 },
 181         { 0x454d4328, 0x00, 0, "EM28028",       0 },
 182         { 0x45838308, 0x00, 0, "ES1988",        0 }, /* Formerly ES1921(?) */
 183         { 0x48525300, 0x00, 0, "HMP9701",       0 },
 184         { 0x49434501, 0x00, 0, "ICE1230",       0 },
 185         { 0x49434511, 0x00, 0, "ICE1232",       0 },
 186         { 0x49434514, 0x00, 0, "ICE1232A",      0 },
 187         { 0x49434551, 0x03, 0, "VT1616",        0 }, /* Via badged ICE */
 188         { 0x49544520, 0x00, 0, "ITE2226E",      0 },
 189         { 0x49544560, 0x07, 0, "ITE2646E",      0 }, /* XXX: patch needed */
 190         { 0x4e534340, 0x00, 0, "LM4540",        0 }, /* Spec blank on revid */
 191         { 0x4e534343, 0x00, 0, "LM4543",        0 }, /* Ditto */
 192         { 0x4e534346, 0x00, 0, "LM4546A",       0 },
 193         { 0x4e534348, 0x00, 0, "LM4548A",       0 },
 194         { 0x4e534331, 0x00, 0, "LM4549",        0 },
 195         { 0x4e534349, 0x00, 0, "LM4549A",       0 },
 196         { 0x4e534350, 0x00, 0, "LM4550",        0 },
 197         { 0x50534301, 0x00, 0, "UCB1510",       0 },
 198         { 0x50534304, 0x00, 0, "UCB1400",       0 },
 199         { 0x83847600, 0x00, 0, "STAC9700/83/84",        0 },
 200         { 0x83847604, 0x00, 0, "STAC9701/03/04/05", 0 },
 201         { 0x83847605, 0x00, 0, "STAC9704",      0 },
 202         { 0x83847608, 0x00, 0, "STAC9708/11",   0 },
 203         { 0x83847609, 0x00, 0, "STAC9721/23",   0 },
 204         { 0x83847644, 0x00, 0, "STAC9744/45",   0 },
 205         { 0x83847650, 0x00, 0, "STAC9750/51",   0 },
 206         { 0x83847652, 0x00, 0, "STAC9752/53",   0 },
 207         { 0x83847656, 0x00, 0, "STAC9756/57",   0 },
 208         { 0x83847658, 0x00, 0, "STAC9758/59",   0 },
 209         { 0x83847660, 0x00, 0, "STAC9760/61",   0 }, /* Extrapolated */
 210         { 0x83847662, 0x00, 0, "STAC9762/63",   0 }, /* Extrapolated */
 211         { 0x83847666, 0x00, 0, "STAC9766/67",   0 },
 212         { 0x53494c22, 0x00, 0, "Si3036",        0 },
 213         { 0x53494c23, 0x00, 0, "Si3038",        0 },
 214         { 0x54524103, 0x00, 0, "TR28023",       0 }, /* Extrapolated */
 215         { 0x54524106, 0x00, 0, "TR28026",       0 },
 216         { 0x54524108, 0x00, 0, "TR28028",       0 },
 217         { 0x54524123, 0x00, 0, "TR28602",       0 },
 218         { 0x54524e03, 0x07, 0, "TLV320AIC27",   0 },
 219         { 0x54584e20, 0x00, 0, "TLC320AD90",    0 },
 220         { 0x56494161, 0x00, 0, "VIA1612A",      0 },
 221         { 0x56494170, 0x00, 0, "VIA1617A",      0 },
 222         { 0x574d4c00, 0x00, 0, "WM9701A",       0 },
 223         { 0x574d4c03, 0x00, 0, "WM9703/4/7/8",  0 },
 224         { 0x574d4c04, 0x00, 0, "WM9704Q",       0 },
 225         { 0x574d4c05, 0x00, 0, "WM9705/10",     0 },
 226         { 0x574d4d09, 0x00, 0, "WM9709",        0 },
 227         { 0x574d4c12, 0x00, 0, "WM9711/12",     0 }, /* XXX: patch needed */
 228         { 0x57454301, 0x00, 0, "W83971D",       0 },
 229         { 0x594d4800, 0x00, 0, "YMF743",        0 },
 230         { 0x594d4802, 0x00, 0, "YMF752",        0 },
 231         { 0x594d4803, 0x00, 0, "YMF753",        0 },
 232         /*
 233          * XXX This is a fluke, really! The real codec
 234          * should be STAC9704, not this! This should be
 235          * removed someday!
 236          */
 237         { 0x01408384, 0x00, 0, "EV1938",        0 },
 238         { 0, 0, 0, NULL, 0 }
 239 };
 240
 241 static char *ac97enhancement[] = {
 242         "no 3D Stereo Enhancement",
 243         "Analog Devices Phat Stereo",
 244         "Creative Stereo Enhancement",
 245         "National Semi 3D Stereo Enhancement",
 246         "Yamaha Ymersion",
 247         "BBE 3D Stereo Enhancement",
 248         "Crystal Semi 3D Stereo Enhancement",
 249         "Qsound QXpander",
 250         "Spatializer 3D Stereo Enhancement",
 251         "SRS 3D Stereo Enhancement",
 252         "Platform Tech 3D Stereo Enhancement",
 253         "AKM 3D Audio",
 254         "Aureal Stereo Enhancement",
 255         "Aztech 3D Enhancement",
 256         "Binaura 3D Audio Enhancement",
 257         "ESS Technology Stereo Enhancement",
 258         "Harman International VMAx",
 259         "Nvidea 3D Stereo Enhancement",
 260         "Philips Incredible Sound",
 261         "Texas Instruments 3D Stereo Enhancement",
 262         "VLSI Technology 3D Stereo Enhancement",
 263         "TriTech 3D Stereo Enhancement",
 264         "Realtek 3D Stereo Enhancement",
 265         "Samsung 3D Stereo Enhancement",
 266         "Wolfson Microelectronics 3D Enhancement",
 267         "Delta Integration 3D Enhancement",
 268         "SigmaTel 3D Enhancement",
 269         "Reserved 27",
 270         "Rockwell 3D Stereo Enhancement",
 271         "Reserved 29",
 272         "Reserved 30",
 273         "Reserved 31"
 274 };
 275
 276 static char *ac97feature[] = {
 277         "mic channel",
 278         "reserved",
 279         "tone",
 280         "simulated stereo",
 281         "headphone",
 282         "bass boost",
 283         "18 bit DAC",
 284         "20 bit DAC",
 285         "18 bit ADC",
 286         "20 bit ADC"
 287 };
 288
 289 static char *ac97extfeature[] = {
 290         "variable rate PCM",
 291         "double rate PCM",
 292         "reserved 1",
 293         "variable rate mic",
 294         "reserved 2",
 295         "reserved 3",
 296         "center DAC",
 297         "surround DAC",
 298         "LFE DAC",
 299         "AMAP",
 300         "reserved 4",
 301         "reserved 5",
 302         "reserved 6",
 303         "reserved 7",
 304 };
 305
 306 u_int16_t
 307 ac97_rdcd(struct ac97_info *codec, int reg)
 308 {
 309         if (codec->flags & AC97_F_RDCD_BUG) {
 310                 u_int16_t i[2], j = 100;
 311
 312                 i[0] = AC97_READ(codec->methods, codec->devinfo, reg);
 313                 i[1] = AC97_READ(codec->methods, codec->devinfo, reg);
 314                 while (i[0] != i[1] && j)
 315                         i[j-- & 1] = AC97_READ(codec->methods, codec->devinfo, reg);
 316 #if 0
 317                 if (j < 100) {
 318                         device_printf(codec->dev, "%s(): Inconsistent register value at"
 319                                         " 0x%08x (retry: %d)\n", __func__, reg, 100 - j);
 320                 }
 321 #endif
 322                 return i[!(j & 1)];
 323         }
 324         return AC97_READ(codec->methods, codec->devinfo, reg);
 325 }
 326
 327 void
 328 ac97_wrcd(struct ac97_info *codec, int reg, u_int16_t val)
 329 {
 330         AC97_WRITE(codec->methods, codec->devinfo, reg, val);
 331 }
 332
 333 static void
 334 ac97_reset(struct ac97_info *codec)
 335 {
 336         u_int32_t i, ps;
 337         ac97_wrcd(codec, AC97_REG_RESET, 0);
 338         for (i = 0; i < 500; i++) {
 339                 ps = ac97_rdcd(codec, AC97_REG_POWER) & AC97_POWER_STATUS;
 340                 if (ps == AC97_POWER_STATUS)
 341                         return;
 342                 DELAY(1000);
 343         }
 344         device_printf(codec->dev, "AC97 reset timed out.\n");
 345 }
 346
 347 int
 348 ac97_setrate(struct ac97_info *codec, int which, int rate)
 349 {
 350         u_int16_t v;
 351
 352         switch(which) {
 353         case AC97_REGEXT_FDACRATE:
 354         case AC97_REGEXT_SDACRATE:
 355         case AC97_REGEXT_LDACRATE:
 356         case AC97_REGEXT_LADCRATE:
 357         case AC97_REGEXT_MADCRATE:
 358                 break;
 359
 360         default:
 361                 return -1;
 362         }
 363
 364         snd_mtxlock(codec->lock);
 365         if (rate != 0) {
 366                 v = rate;
 367                 if (codec->extstat & AC97_EXTCAP_DRA)
 368                         v >>= 1;
 369                 ac97_wrcd(codec, which, v);
 370         }
 371         v = ac97_rdcd(codec, which);
 372         if (codec->extstat & AC97_EXTCAP_DRA)
 373                 v <<= 1;
 374         snd_mtxunlock(codec->lock);
 375         return v;
 376 }
 377
 378 int
 379 ac97_setextmode(struct ac97_info *codec, u_int16_t mode)
 380 {
 381         mode &= AC97_EXTCAPS;
 382         if ((mode & ~codec->extcaps) != 0) {
 383                 device_printf(codec->dev, "ac97 invalid mode set 0x%04x\n",
 384                               mode);
 385                 return -1;
 386         }
 387         snd_mtxlock(codec->lock);
 388         ac97_wrcd(codec, AC97_REGEXT_STAT, mode);
 389         codec->extstat = ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS;
 390         snd_mtxunlock(codec->lock);
 391         return (mode == codec->extstat)? 0 : -1;
 392 }
 393
 394 u_int16_t
 395 ac97_getextmode(struct ac97_info *codec)
 396 {
 397         return codec->extstat;
 398 }
 399
 400 u_int16_t
 401 ac97_getextcaps(struct ac97_info *codec)
 402 {
 403         return codec->extcaps;
 404 }
 405
 406 u_int16_t
 407 ac97_getcaps(struct ac97_info *codec)
 408 {
 409         return codec->caps;
 410 }
 411
 412 u_int32_t
 413 ac97_getsubvendor(struct ac97_info *codec)
 414 {
 415         return codec->subvendor;
 416 }
 417
 418 static int
 419 ac97_setrecsrc(struct ac97_info *codec, int channel)
 420 {
 421         struct ac97mixtable_entry *e = &codec->mix[channel];
 422
 423         if (e->recidx > 0) {
 424                 int val = e->recidx - 1;
 425                 val |= val << 8;
 426                 snd_mtxlock(codec->lock);
 427                 ac97_wrcd(codec, AC97_REG_RECSEL, val);
 428                 snd_mtxunlock(codec->lock);
 429                 return 0;
 430         } else
 431                 return -1;
 432 }
 433
 434 static int
 435 ac97_setmixer(struct ac97_info *codec, unsigned channel, unsigned left, unsigned right)
 436 {
 437         struct ac97mixtable_entry *e = &codec->mix[channel];
 438
 439         if (e->reg && e->enable && e->bits) {
 440                 int mask, max, val, reg;
 441
 442                 reg = (e->reg >= 0) ? e->reg : -e->reg; /* AC97 register    */
 443                 max = (1 << e->bits) - 1;               /* actual range     */
 444                 mask = (max << 8) | max;                /* bits of interest */
 445
 446                 if (!e->stereo)
 447                         right = left;
 448
 449                 /*
 450                  * Invert the range if the polarity requires so,
 451                  * then scale to 0..max-1 to compute the value to
 452                  * write into the codec, and scale back to 0..100
 453                  * for the return value.
 454                  */
 455                 if (e->reg > 0) {
 456                         left = 100 - left;
 457                         right = 100 - right;
 458                 }
 459
 460                 left = (left * max) / 100;
 461                 right = (right * max) / 100;
 462
 463                 val = (left << 8) | right;
 464
 465                 left = (left * 100) / max;
 466                 right = (right * 100) / max;
 467
 468                 if (e->reg > 0) {
 469                         left = 100 - left;
 470                         right = 100 - right;
 471                 }
 472
 473                 /*
 474                  * For mono controls, trim val and mask, also taking
 475                  * care of e->ofs (offset of control field).
 476                  */
 477                 if (e->ofs) {
 478                         val &= max;
 479                         val <<= e->ofs;
 480                         mask = (max << e->ofs);
 481                 }
 482
 483                 /*
 484                  * If we have a mute bit, add it to the mask and
 485                  * update val and set mute if both channels require a
 486                  * zero volume.
 487                  */
 488                 if (e->mute == 1) {
 489                         mask |= AC97_MUTE;
 490                         if (left == 0 && right == 0)
 491                                 val = AC97_MUTE;
 492                 }
 493
 494                 /*
 495                  * If the mask bit is set, do not alter the other bits.
 496                  */
 497                 snd_mtxlock(codec->lock);
 498                 if (e->mask) {
 499                         int cur = ac97_rdcd(codec, reg);
 500                         val |= cur & ~(mask);
 501                 }
 502                 ac97_wrcd(codec, reg, val);
 503                 snd_mtxunlock(codec->lock);
 504                 return left | (right << 8);
 505         } else {
 506 #if 0
 507                 kprintf("ac97_setmixer: reg=%d, bits=%d, enable=%d\n", e->reg, e->bits, e->enable);
 508 #endif
 509                 return -1;
 510         }
 511 }
 512
 513 static void
 514 ac97_fix_auxout(struct ac97_info *codec)
 515 {
 516         int keep_ogain;
 517
 518         /*
 519          * By default, The ac97 aux_out register (0x04) corresponds to OSS's
 520          * OGAIN setting.
 521          *
 522          * We first check whether aux_out is a valid register.  If not
 523          * we may not want to keep ogain.
 524          */
 525         keep_ogain = ac97_rdcd(codec, AC97_MIX_AUXOUT) & 0x8000;
 526
 527         /*
 528          * Determine what AUX_OUT really means, it can be:
 529          *
 530          * 1. Headphone out.
 531          * 2. 4-Channel Out
 532          * 3. True line level out (effectively master volume).
 533          *
 534          * See Sections 5.2.1 and 5.27 for AUX_OUT Options in AC97r2.{2,3}.
 535          */
 536         if (codec->extcaps & AC97_EXTCAP_SDAC &&
 537             ac97_rdcd(codec, AC97_MIXEXT_SURROUND) == 0x8080) {
 538                 codec->mix[SOUND_MIXER_OGAIN].reg = AC97_MIXEXT_SURROUND;
 539                 keep_ogain = 1;
 540         }
 541
 542         if (keep_ogain == 0) {
 543                 bzero(&codec->mix[SOUND_MIXER_OGAIN],
 544                       sizeof(codec->mix[SOUND_MIXER_OGAIN]));
 545         }
 546 }
 547
 548 static void
 549 ac97_fix_tone(struct ac97_info *codec)
 550 {
 551         /*
 552          * YMF chips does not indicate tone and 3D enhancement capability
 553          * in the AC97_REG_RESET register.
 554          */
 555         switch (codec->id) {
 556         case 0x594d4800:        /* YMF743 */
 557         case 0x594d4803:        /* YMF753 */
 558                 codec->caps |= AC97_CAP_TONE;
 559                 codec->se |= 0x04;
 560                 break;
 561         case 0x594d4802:        /* YMF752 */
 562                 codec->se |= 0x04;
 563                 break;
 564         default:
 565                 break;
 566         }
 567
 568         /* Hide treble and bass if they don't exist */
 569         if ((codec->caps & AC97_CAP_TONE) == 0) {
 570                 bzero(&codec->mix[SOUND_MIXER_BASS],
 571                       sizeof(codec->mix[SOUND_MIXER_BASS]));
 572                 bzero(&codec->mix[SOUND_MIXER_TREBLE],
 573                       sizeof(codec->mix[SOUND_MIXER_TREBLE]));
 574         }
 575 }
 576
 577 static void
 578 ac97_fix_volume(struct ac97_info *codec)
 579 {
 580         struct snddev_info *d = device_get_softc(codec->dev);
 581
 582 #if 0
 583         /* XXX For the sake of debugging purposes */
 584         ac97_wrcd(codec, AC97_MIX_PCM, 0);
 585         bzero(&codec->mix[SOUND_MIXER_PCM],
 586                 sizeof(codec->mix[SOUND_MIXER_PCM]));
 587         if (d)
 588                 d->flags |= SD_F_SOFTPCMVOL;
 589         return;
 590 #endif
 591         switch (codec->id) {
 592                 case 0x434d4941:        /* CMI9738 */
 593                 case 0x434d4961:        /* CMI9739 */
 594                 case 0x434d4978:        /* CMI9761 */
 595                 case 0x434d4982:        /* CMI9761 */
 596                 case 0x434d4983:        /* CMI9761 */
 597                         ac97_wrcd(codec, AC97_MIX_PCM, 0);
 598                         break;
 599                 default:
 600                         return;
 601                         break;
 602         }
 603         bzero(&codec->mix[SOUND_MIXER_PCM],
 604                         sizeof(codec->mix[SOUND_MIXER_PCM]));
 605         if (d)
 606                 d->flags |= SD_F_SOFTPCMVOL;
 607 }
 608
 609 static const char*
 610 ac97_hw_desc(u_int32_t id, const char* vname, const char* cname, char* buf)
 611 {
 612         if (cname == NULL) {
 613                 ksprintf(buf, "Unknown AC97 Codec (id = 0x%08x)", id);
 614                 return buf;
 615         }
 616
 617         if (vname == NULL) vname = "Unknown";
 618
 619         if (bootverbose) {
 620                 ksprintf(buf, "%s %s AC97 Codec (id = 0x%08x)", vname, cname, id);
 621         } else {
 622                 ksprintf(buf, "%s %s AC97 Codec", vname, cname);
 623         }
 624         return buf;
 625 }
 626
 627 static unsigned
 628 ac97_initmixer(struct ac97_info *codec)
 629 {
 630         ac97_patch codec_patch;
 631         const char *cname, *vname;
 632         char desc[80];
 633         u_int8_t model, step;
 634         unsigned i, j, k, bit, old;
 635         u_int32_t id;
 636         int reg;
 637
 638         snd_mtxlock(codec->lock);
 639         codec->count = AC97_INIT(codec->methods, codec->devinfo);
 640         if (codec->count == 0) {
 641                 device_printf(codec->dev, "ac97 codec init failed\n");
 642                 snd_mtxunlock(codec->lock);
 643                 return ENODEV;
 644         }
 645
 646         ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
 647         ac97_reset(codec);
 648         ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
 649
 650         i = ac97_rdcd(codec, AC97_REG_RESET);
 651         j = ac97_rdcd(codec, AC97_REG_RESET);
 652         /*
 653          * Let see if this codec can return consistent value.
 654          * If not, turn on aggressive read workaround
 655          * (STAC9704 comes in mind).
 656          */
 657         if (i != j) {
 658                 codec->flags |= AC97_F_RDCD_BUG;
 659                 i = ac97_rdcd(codec, AC97_REG_RESET);
 660         }
 661         codec->caps = i & 0x03ff;
 662         codec->se =  (i & 0x7c00) >> 10;
 663
 664         id = (ac97_rdcd(codec, AC97_REG_ID1) << 16) | ac97_rdcd(codec, AC97_REG_ID2);
 665         if (id == 0 || id == 0xffffffff) {
 666                 device_printf(codec->dev, "ac97 codec invalid or not present (id == %x)\n", id);
 667                 snd_mtxunlock(codec->lock);
 668                 return ENODEV;
 669         }
 670
 671         codec->id = id;
 672         codec->subvendor = (u_int32_t)pci_get_subdevice(codec->dev) << 16;
 673         codec->subvendor |= (u_int32_t)pci_get_subvendor(codec->dev) &
 674             0x0000ffff;
 675         codec->noext = 0;
 676         codec_patch = NULL;
 677
 678         cname = NULL;
 679         model = step = 0;
 680         for (i = 0; ac97codecid[i].id; i++) {
 681                 u_int32_t modelmask = 0xffffffff ^ ac97codecid[i].stepmask;
 682                 if ((ac97codecid[i].id & modelmask) == (id & modelmask)) {
 683                         codec->noext = ac97codecid[i].noext;
 684                         codec_patch = ac97codecid[i].patch;
 685                         cname = ac97codecid[i].name;
 686                         model = (id & modelmask) & 0xff;
 687                         step = (id & ~modelmask) & 0xff;
 688                         break;
 689                 }
 690         }
 691
 692         vname = NULL;
 693         for (i = 0; ac97vendorid[i].id; i++) {
 694                 if (ac97vendorid[i].id == (id & 0xffffff00)) {
 695                         vname = ac97vendorid[i].name;
 696                         break;
 697                 }
 698         }
 699
 700         codec->extcaps = 0;
 701         codec->extid = 0;
 702         codec->extstat = 0;
 703         if (!codec->noext) {
 704                 i = ac97_rdcd(codec, AC97_REGEXT_ID);
 705                 if (i != 0xffff) {
 706                         codec->extcaps = i & 0x3fff;
 707                         codec->extid =  (i & 0xc000) >> 14;
 708                         codec->extstat = ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS;
 709                 }
 710         }
 711
 712         for (i = 0; i < 32; i++) {
 713                 codec->mix[i] = ac97mixtable_default[i];
 714         }
 715         ac97_fix_auxout(codec);
 716         ac97_fix_tone(codec);
 717         ac97_fix_volume(codec);
 718         if (codec_patch)
 719                 codec_patch(codec);
 720
 721         for (i = 0; i < 32; i++) {
 722                 k = codec->noext? codec->mix[i].enable : 1;
 723                 reg = codec->mix[i].reg;
 724                 if (reg < 0)
 725                         reg = -reg;
 726                 if (k && reg) {
 727                         j = old = ac97_rdcd(codec, reg);
 728                         /*
 729                          * Test for mute bit (except for AC97_MIX_TONE,
 730                          * where we simply assume it as available).
 731                          */
 732                         if (codec->mix[i].mute) {
 733                                 ac97_wrcd(codec, reg, j | 0x8000);
 734                                 j = ac97_rdcd(codec, reg);
 735                         } else
 736                                 j |= 0x8000;
 737                         if ((j & 0x8000)) {
 738                                 /*
 739                                  * Test whether the control width should be
 740                                  * 4, 5 or 6 bit. For 5bit register, we should
 741                                  * test it whether it's really 5 or 6bit. Leave
 742                                  * 4bit register alone, because sometimes an
 743                                  * attempt to write past 4th bit may cause
 744                                  * incorrect result especially for AC97_MIX_BEEP
 745                                  * (ac97 2.3).
 746                                  */
 747                                 bit = codec->mix[i].bits;
 748                                 if (bit == 5)
 749                                         bit++;
 750                                 j = ((1 << bit) - 1) << codec->mix[i].ofs;
 751                                 ac97_wrcd(codec, reg,
 752                                         j | (codec->mix[i].mute ? 0x8000 : 0));
 753                                 k = ac97_rdcd(codec, reg) & j;
 754                                 k >>= codec->mix[i].ofs;
 755                                 if (reg == AC97_MIX_TONE &&
 756                                                         ((k & 0x0001) == 0x0000))
 757                                         k >>= 1;
 758                                 for (j = 0; k >> j; j++)
 759                                         ;
 760                                 if (j != 0) {
 761 #if 0
 762                                         device_printf(codec->dev, "%2d: [ac97_rdcd() = %d] [Testbit = %d] %d -> %d\n",
 763                                                 i, k, bit, codec->mix[i].bits, j);
 764 #endif
 765                                         codec->mix[i].enable = 1;
 766                                         codec->mix[i].bits = j;
 767                                 } else if (reg == AC97_MIX_BEEP) {
 768                                         /*
 769                                          * Few codec such as CX20468-21 does
 770                                          * have this control register, although
 771                                          * the only usable part is the mute bit.
 772                                          */
 773                                         codec->mix[i].enable = 1;
 774                                 } else
 775                                         codec->mix[i].enable = 0;
 776                         } else
 777                                 codec->mix[i].enable = 0;
 778                         ac97_wrcd(codec, reg, old);
 779                 }
 780 #if 0
 781                 kprintf("mixch %d, en=%d, b=%d\n", i, codec->mix[i].enable, codec->mix[i].bits);
 782 #endif
 783         }
 784
 785         device_printf(codec->dev, "<%s>\n",
 786                       ac97_hw_desc(codec->id, vname, cname, desc));
 787
 788         if (bootverbose) {
 789                 if (codec->flags & AC97_F_RDCD_BUG)
 790                         device_printf(codec->dev, "Buggy AC97 Codec: aggressive ac97_rdcd() workaround enabled\n");
 791                 device_printf(codec->dev, "Codec features ");
 792                 for (i = j = 0; i < 10; i++)
 793                         if (codec->caps & (1 << i))
 794                                 kprintf("%s%s", j++? ", " : "", ac97feature[i]);
 795                 kprintf("%s%d bit master volume", j++? ", " : "", codec->mix[SOUND_MIXER_VOLUME].bits);
 796                 kprintf("%s%s\n", j? ", " : "", ac97enhancement[codec->se]);
 797
 798                 if (codec->extcaps != 0 || codec->extid) {
 799                         device_printf(codec->dev, "%s codec",
 800                                       codec->extid? "Secondary" : "Primary");
 801                         if (codec->extcaps)
 802                                 kprintf(" extended features ");
 803                         for (i = j = 0; i < 14; i++)
 804                                 if (codec->extcaps & (1 << i))
 805                                         kprintf("%s%s", j++? ", " : "", ac97extfeature[i]);
 806                         kprintf("\n");
 807                 }
 808         }
 809
 810         i = 0;
 811         while ((ac97_rdcd(codec, AC97_REG_POWER) & 2) == 0) {
 812                 if (++i == 100) {
 813                         device_printf(codec->dev, "ac97 codec reports dac not ready\n");
 814                         break;
 815                 }
 816                 DELAY(1000);
 817         }
 818         if (bootverbose)
 819                 device_printf(codec->dev, "ac97 codec dac ready count: %d\n", i);
 820         snd_mtxunlock(codec->lock);
 821         return 0;
 822 }
 823
 824 static unsigned
 825 ac97_reinitmixer(struct ac97_info *codec)
 826 {
 827         snd_mtxlock(codec->lock);
 828         codec->count = AC97_INIT(codec->methods, codec->devinfo);
 829         if (codec->count == 0) {
 830                 device_printf(codec->dev, "ac97 codec init failed\n");
 831                 snd_mtxunlock(codec->lock);
 832                 return ENODEV;
 833         }
 834
 835         ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
 836         ac97_reset(codec);
 837         ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
 838
 839         if (!codec->noext) {
 840                 ac97_wrcd(codec, AC97_REGEXT_STAT, codec->extstat);
 841                 if ((ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS)
 842                     != codec->extstat)
 843                         device_printf(codec->dev, "ac97 codec failed to reset extended mode (%x, got %x)\n",
 844                                       codec->extstat,
 845                                       ac97_rdcd(codec, AC97_REGEXT_STAT) &
 846                                       AC97_EXTCAPS);
 847         }
 848
 849         if ((ac97_rdcd(codec, AC97_REG_POWER) & 2) == 0)
 850                 device_printf(codec->dev, "ac97 codec reports dac not ready\n");
 851         snd_mtxunlock(codec->lock);
 852         return 0;
 853 }
 854
 855 struct ac97_info *
 856 ac97_create(device_t dev, void *devinfo, kobj_class_t cls)
 857 {
 858         struct ac97_info *codec;
 859
 860         codec = (struct ac97_info *)kmalloc(sizeof *codec, M_AC97, M_NOWAIT);
 861         if (codec == NULL)
 862                 return NULL;
 863
 864         ksnprintf(codec->name, AC97_NAMELEN, "%s:ac97", device_get_nameunit(dev));
 865         codec->lock = snd_mtxcreate(codec->name, "ac97 codec");
 866         codec->methods = kobj_create(cls, M_AC97, M_WAITOK);
 867         if (codec->methods == NULL) {
 868                 snd_mtxfree(codec->lock);
 869                 kfree(codec, M_AC97);
 870                 return NULL;
 871         }
 872
 873         codec->dev = dev;
 874         codec->devinfo = devinfo;
 875         codec->flags = 0;
 876         return codec;
 877 }
 878
 879 void
 880 ac97_destroy(struct ac97_info *codec)
 881 {
 882         if (codec->methods != NULL)
 883                 kobj_delete(codec->methods, M_AC97);
 884         snd_mtxfree(codec->lock);
 885         kfree(codec, M_AC97);
 886 }
 887
 888 void
 889 ac97_setflags(struct ac97_info *codec, u_int32_t val)
 890 {
 891         codec->flags = val;
 892 }
 893
 894 u_int32_t
 895 ac97_getflags(struct ac97_info *codec)
 896 {
 897         return codec->flags;
 898 }
 899
 900 /* -------------------------------------------------------------------- */
 901
 902 static int
 903 ac97mix_init(struct snd_mixer *m)
 904 {
 905         struct ac97_info *codec = mix_getdevinfo(m);
 906         u_int32_t i, mask;
 907
 908         if (codec == NULL)
 909                 return -1;
 910
 911         if (ac97_initmixer(codec))
 912                 return -1;
 913
 914         mask = 0;
 915         for (i = 0; i < 32; i++)
 916                 mask |= codec->mix[i].enable? 1 << i : 0;
 917         mix_setdevs(m, mask);
 918
 919         mask = 0;
 920         for (i = 0; i < 32; i++)
 921                 mask |= codec->mix[i].recidx? 1 << i : 0;
 922         mix_setrecdevs(m, mask);
 923         return 0;
 924 }
 925
 926 static int
 927 ac97mix_uninit(struct snd_mixer *m)
 928 {
 929         struct ac97_info *codec = mix_getdevinfo(m);
 930
 931         if (codec == NULL)
 932                 return -1;
 933         /*
 934         if (ac97_uninitmixer(codec))
 935                 return -1;
 936         */
 937         ac97_destroy(codec);
 938         return 0;
 939 }
 940
 941 static int
 942 ac97mix_reinit(struct snd_mixer *m)
 943 {
 944         struct ac97_info *codec = mix_getdevinfo(m);
 945
 946         if (codec == NULL)
 947                 return -1;
 948         return ac97_reinitmixer(codec);
 949 }
 950
 951 static int
 952 ac97mix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
 953 {
 954         struct ac97_info *codec = mix_getdevinfo(m);
 955
 956         if (codec == NULL)
 957                 return -1;
 958         return ac97_setmixer(codec, dev, left, right);
 959 }
 960
 961 static int
 962 ac97mix_setrecsrc(struct snd_mixer *m, u_int32_t src)
 963 {
 964         int i;
 965         struct ac97_info *codec = mix_getdevinfo(m);
 966
 967         if (codec == NULL)
 968                 return -1;
 969         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 970                 if ((src & (1 << i)) != 0)
 971                         break;
 972         return (ac97_setrecsrc(codec, i) == 0)? 1 << i : -1;
 973 }
 974
 975 static kobj_method_t ac97mixer_methods[] = {
 976         KOBJMETHOD(mixer_init,          ac97mix_init),
 977         KOBJMETHOD(mixer_uninit,        ac97mix_uninit),
 978         KOBJMETHOD(mixer_reinit,        ac97mix_reinit),
 979         KOBJMETHOD(mixer_set,           ac97mix_set),
 980         KOBJMETHOD(mixer_setrecsrc,     ac97mix_setrecsrc),
 981         { 0, 0 }
 982 };
 983 MIXER_DECLARE(ac97mixer);
 984
 985 /* -------------------------------------------------------------------- */
 986
 987 kobj_class_t
 988 ac97_getmixerclass(void)
 989 {
 990         return &ac97mixer_class;
 991 }