Add support for the following AC'97 codecs:
[dragonfly.git] / 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.49 2003/11/11 22:15:17 kuriyama Exp $
27  * $DragonFly: src/sys/dev/sound/pcm/ac97.c,v 1.4 2004/01/21 21:18:22 asmodai 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 "mixer_if.h"
35
36 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/ac97.c,v 1.4 2004/01/21 21:18:22 asmodai Exp $");
37
38 MALLOC_DEFINE(M_AC97, "ac97", "ac97 codec");
39
40 struct ac97mixtable_entry {
41         int      reg:8;         /* register index               */
42                                 /* reg < 0 if inverted polarity */
43         unsigned bits:4;        /* width of control field       */
44         unsigned ofs:4;         /* offset (only if stereo=0)    */
45         unsigned stereo:1;      /* set for stereo controls      */
46         unsigned mute:1;        /* bit15 is MUTE                */
47         unsigned recidx:4;      /* index in rec mux             */
48         unsigned mask:1;        /* use only masked bits         */
49         unsigned enable:1;      /* entry is enabled             */
50 };
51
52 #define AC97_NAMELEN    16
53 struct ac97_info {
54         kobj_t methods;
55         device_t dev;
56         void *devinfo;
57         u_int32_t id;
58         unsigned count, caps, se, extcaps, extid, extstat, noext:1;
59         u_int32_t flags;
60         struct ac97mixtable_entry mix[32];
61         char name[AC97_NAMELEN];
62         struct mtx *lock;
63 };
64
65 struct ac97_vendorid {
66         u_int32_t   id;
67         const char *name;
68 };
69
70 struct ac97_codecid {
71         u_int32_t  id;
72         u_int8_t   stepmask;
73         u_int8_t   noext:1;
74         char      *name;
75         ac97_patch patch;
76 };
77
78 static const struct ac97mixtable_entry ac97mixtable_default[32] = {
79     /*  [offset]                        reg          bits of st mu re mk en */
80         [SOUND_MIXER_VOLUME]    = { AC97_MIX_MASTER,    5, 0, 1, 1, 6, 0, 1 },
81         [SOUND_MIXER_OGAIN]     = { AC97_MIX_AUXOUT,    5, 0, 1, 1, 0, 0, 0 },
82         [SOUND_MIXER_PHONEOUT]  = { AC97_MIX_MONO,      5, 0, 0, 1, 7, 0, 0 },
83         [SOUND_MIXER_BASS]      = { AC97_MIX_TONE,      4, 8, 0, 0, 0, 1, 0 },
84         [SOUND_MIXER_TREBLE]    = { AC97_MIX_TONE,      4, 0, 0, 0, 0, 1, 0 },
85         [SOUND_MIXER_PCM]       = { AC97_MIX_PCM,       5, 0, 1, 1, 0, 0, 1 },
86         [SOUND_MIXER_SPEAKER]   = { AC97_MIX_BEEP,      4, 1, 0, 1, 0, 0, 0 },
87         [SOUND_MIXER_LINE]      = { AC97_MIX_LINE,      5, 0, 1, 1, 5, 0, 1 },
88         [SOUND_MIXER_PHONEIN]   = { AC97_MIX_PHONE,     5, 0, 0, 1, 8, 0, 0 },
89         [SOUND_MIXER_MIC]       = { AC97_MIX_MIC,       5, 0, 0, 1, 1, 1, 1 },
90 #if 0
91         /* use igain for the mic 20dB boost */
92         [SOUND_MIXER_IGAIN]     = { -AC97_MIX_MIC,      1, 6, 0, 0, 0, 1, 1 },
93 #endif
94         [SOUND_MIXER_CD]        = { AC97_MIX_CD,        5, 0, 1, 1, 2, 0, 1 },
95         [SOUND_MIXER_LINE1]     = { AC97_MIX_AUX,       5, 0, 1, 1, 4, 0, 0 },
96         [SOUND_MIXER_VIDEO]     = { AC97_MIX_VIDEO,     5, 0, 1, 1, 3, 0, 0 },
97         [SOUND_MIXER_RECLEV]    = { -AC97_MIX_RGAIN,    4, 0, 1, 1, 0, 0, 1 }
98 };
99
100 static const struct ac97_vendorid ac97vendorid[] = {
101         { 0x41445300, "Analog Devices" },
102         { 0x414b4d00, "Asahi Kasei" },
103         { 0x414c4300, "Realtek" },
104         { 0x414c4700, "Avance Logic" },
105         { 0x43525900, "Cirrus Logic" },
106         { 0x434d4900, "C-Media Electronics" },
107         { 0x43585400, "Conexant" },
108         { 0x44543000, "Diamond Technology" },
109         { 0x454d4300, "eMicro" },
110         { 0x45838300, "ESS Technology" },
111         { 0x48525300, "Intersil" },
112         { 0x49434500, "ICEnsemble" },
113         { 0x49544500, "ITE, Inc." },
114         { 0x4e534300, "National Semiconductor" },
115         { 0x50534300, "Philips Semiconductor" },
116         { 0x83847600, "SigmaTel" },
117         { 0x53494c00, "Silicon Laboratory" },
118         { 0x54524100, "TriTech" },
119         { 0x54584e00, "Texas Instruments" },
120         { 0x56494100, "VIA Technologies" },
121         { 0x57454300, "Winbond" },
122         { 0x574d4c00, "Wolfson" },
123         { 0x594d4800, "Yamaha" },
124         { 0x01408300, "Creative" },
125         { 0x00000000, NULL }
126 };
127
128 static struct ac97_codecid ac97codecid[] = {
129         { 0x41445303, 0x00, 0, "AD1819",        0 },
130         { 0x41445340, 0x00, 0, "AD1881",        0 },
131         { 0x41445348, 0x00, 0, "AD1881A",       0 },
132         { 0x41445360, 0x00, 0, "AD1885",        0 },
133         { 0x41445361, 0x00, 0, "AD1886",        ad1886_patch },
134         { 0x41445362, 0x00, 0, "AD1887",        0 },
135         { 0x41445363, 0x00, 0, "AD1886A",       0 },
136         { 0x41445370, 0x00, 0, "AD1980",        ad198x_patch },
137         { 0x41445372, 0x00, 0, "AD1981A",       0 },
138         { 0x41445374, 0x00, 0, "AD1981B",       0 },
139         { 0x41445375, 0x00, 0, "AD1985",        ad198x_patch },
140         { 0x414b4d00, 0x00, 1, "AK4540",        0 },
141         { 0x414b4d01, 0x00, 1, "AK4542",        0 },
142         { 0x414b4d02, 0x00, 1, "AK4543",        0 },
143         { 0x414c4320, 0x0f, 0, "ALC100",        0 },
144         { 0x414c4730, 0x0f, 0, "ALC101",        0 },
145         { 0x414c4710, 0x0f, 0, "ALC200",        0 },
146         { 0x414c4740, 0x0f, 0, "ALC202",        0 },
147         { 0x414c4720, 0x0f, 0, "ALC650",        0 },
148         { 0x414c4760, 0x0f, 0, "ALC655",        0 },
149         { 0x414c4780, 0x0f, 0, "ALC658",        0 },
150         { 0x43525900, 0x07, 0, "CS4297",        0 },
151         { 0x43525910, 0x07, 0, "CS4297A",       0 },
152         { 0x43525920, 0x07, 0, "CS4294/98",     0 },
153         { 0x43525930, 0x07, 0, "CS4299",        0 },
154         { 0x43525940, 0x07, 0, "CS4201",        0 },
155         { 0x43525958, 0x07, 0, "CS4205",        0 },
156         { 0x43525960, 0x07, 0, "CS4291A",       0 },
157         { 0x434d4961, 0x00, 0, "CMI9739",       0 },
158         { 0x434d4941, 0x00, 0, "CMI9738",       0 },
159         { 0x43585429, 0x00, 0, "CX20468",       0 },
160         { 0x44543000, 0x00, 0, "DT0398",        0 },
161         { 0x454d4323, 0x00, 0, "EM28023",       0 },
162         { 0x454d4328, 0x00, 0, "EM28028",       0 },
163         { 0x45838308, 0x00, 0, "ES1988",        0 }, /* Formerly ES1921(?) */
164         { 0x48525300, 0x00, 0, "HMP9701",       0 },
165         { 0x49434501, 0x00, 0, "ICE1230",       0 },
166         { 0x49434511, 0x00, 0, "ICE1232",       0 },
167         { 0x49434514, 0x00, 0, "ICE1232A",      0 },
168         { 0x49434551, 0x03, 0, "VT1616",        0 }, /* Via badged ICE */
169         { 0x49544520, 0x00, 0, "ITE2226E",      0 },
170         { 0x49544560, 0x07, 0, "ITE2646E",      0 }, /* XXX: patch needed */
171         { 0x4e534340, 0x00, 0, "LM4540",        0 }, /* Spec blank on revid */
172         { 0x4e534343, 0x00, 0, "LM4543",        0 }, /* Ditto */
173         { 0x4e534346, 0x00, 0, "LM4546A",       0 },
174         { 0x4e534348, 0x00, 0, "LM4548A",       0 },
175         { 0x4e534331, 0x00, 0, "LM4549",        0 }, /* (?) */
176         { 0x4e534349, 0x00, 0, "LM4549A",       0 },
177         { 0x4e534350, 0x00, 0, "LM4550",        0 },
178         { 0x50534301, 0x00, 0, "UCB1510",       0 },
179         { 0x50534304, 0x00, 0, "UCB1400",       0 },
180         { 0x83847600, 0x00, 0, "STAC9700/83/84",        0 },
181         { 0x83847604, 0x00, 0, "STAC9701/03/04/05", 0 },
182         { 0x83847605, 0x00, 0, "STAC9704",      0 },
183         { 0x83847608, 0x00, 0, "STAC9708/11",   0 },
184         { 0x83847609, 0x00, 0, "STAC9721/23",   0 },
185         { 0x83847644, 0x00, 0, "STAC9744/45",   0 },
186         { 0x83847650, 0x00, 0, "STAC9750/51",   0 },
187         { 0x83847652, 0x00, 0, "STAC9752/53",   0 },
188         { 0x83847656, 0x00, 0, "STAC9756/57",   0 },
189         { 0x83847658, 0x00, 0, "STAC9758/59",   0 },
190         { 0x83847660, 0x00, 0, "STAC9760/61",   0 }, /* Extrapolated */
191         { 0x83847662, 0x00, 0, "STAC9762/63",   0 }, /* Extrapolated */
192         { 0x53494c22, 0x00, 0, "Si3036",        0 },
193         { 0x53494c23, 0x00, 0, "Si3038",        0 },
194         { 0x54524103, 0x00, 0, "TR28023",       0 }, /* Extrapolated */
195         { 0x54524106, 0x00, 0, "TR28026",       0 },
196         { 0x54524108, 0x00, 0, "TR28028",       0 },
197         { 0x54524123, 0x00, 0, "TR28602",       0 },
198         { 0x54584320, 0x00, 0, "TLC320AD90",    0 },
199         { 0x56494161, 0x00, 0, "VIA1612A",      0 },
200         { 0x574d4c00, 0x00, 0, "WM9701A",       0 },
201         { 0x574d4c03, 0x00, 0, "WM9703/4/7/8",  0 },
202         { 0x574d4c04, 0x00, 0, "WM9704Q",       0 },
203         { 0x574d4c05, 0x00, 0, "WM9705/10",     0 },
204         { 0x57454301, 0x00, 0, "W83971D",       0 },
205         { 0x594d4800, 0x00, 0, "YMF743",        0 },
206         { 0x594d4802, 0x00, 0, "YMF752",        0 },
207         { 0x594d4803, 0x00, 0, "YMF753",        0 },
208         { 0x01408384, 0x00, 0, "EV1938",        0 },
209         { 0, 0, 0, NULL, 0 }
210 };
211
212 static char *ac97enhancement[] = {
213         "no 3D Stereo Enhancement",
214         "Analog Devices Phat Stereo",
215         "Creative Stereo Enhancement",
216         "National Semi 3D Stereo Enhancement",
217         "Yamaha Ymersion",
218         "BBE 3D Stereo Enhancement",
219         "Crystal Semi 3D Stereo Enhancement",
220         "Qsound QXpander",
221         "Spatializer 3D Stereo Enhancement",
222         "SRS 3D Stereo Enhancement",
223         "Platform Tech 3D Stereo Enhancement",
224         "AKM 3D Audio",
225         "Aureal Stereo Enhancement",
226         "Aztech 3D Enhancement",
227         "Binaura 3D Audio Enhancement",
228         "ESS Technology Stereo Enhancement",
229         "Harman International VMAx",
230         "Nvidea 3D Stereo Enhancement",
231         "Philips Incredible Sound",
232         "Texas Instruments 3D Stereo Enhancement",
233         "VLSI Technology 3D Stereo Enhancement",
234         "TriTech 3D Stereo Enhancement",
235         "Realtek 3D Stereo Enhancement",
236         "Samsung 3D Stereo Enhancement",
237         "Wolfson Microelectronics 3D Enhancement",
238         "Delta Integration 3D Enhancement",
239         "SigmaTel 3D Enhancement",
240         "Reserved 27",
241         "Rockwell 3D Stereo Enhancement",
242         "Reserved 29",
243         "Reserved 30",
244         "Reserved 31"
245 };
246
247 static char *ac97feature[] = {
248         "mic channel",
249         "reserved",
250         "tone",
251         "simulated stereo",
252         "headphone",
253         "bass boost",
254         "18 bit DAC",
255         "20 bit DAC",
256         "18 bit ADC",
257         "20 bit ADC"
258 };
259
260 static char *ac97extfeature[] = {
261         "variable rate PCM",
262         "double rate PCM",
263         "reserved 1",
264         "variable rate mic",
265         "reserved 2",
266         "reserved 3",
267         "center DAC",
268         "surround DAC",
269         "LFE DAC",
270         "AMAP",
271         "reserved 4",
272         "reserved 5",
273         "reserved 6",
274         "reserved 7",
275 };
276
277 u_int16_t
278 ac97_rdcd(struct ac97_info *codec, int reg)
279 {
280         return AC97_READ(codec->methods, codec->devinfo, reg);
281 }
282
283 void
284 ac97_wrcd(struct ac97_info *codec, int reg, u_int16_t val)
285 {
286         AC97_WRITE(codec->methods, codec->devinfo, reg, val);
287 }
288
289 static void
290 ac97_reset(struct ac97_info *codec)
291 {
292         u_int32_t i, ps;
293         ac97_wrcd(codec, AC97_REG_RESET, 0);
294         for (i = 0; i < 500; i++) {
295                 ps = ac97_rdcd(codec, AC97_REG_POWER) & AC97_POWER_STATUS;
296                 if (ps == AC97_POWER_STATUS)
297                         return;
298                 DELAY(1000);
299         }
300         device_printf(codec->dev, "AC97 reset timed out.\n");
301 }
302
303 int
304 ac97_setrate(struct ac97_info *codec, int which, int rate)
305 {
306         u_int16_t v;
307
308         switch(which) {
309         case AC97_REGEXT_FDACRATE:
310         case AC97_REGEXT_SDACRATE:
311         case AC97_REGEXT_LDACRATE:
312         case AC97_REGEXT_LADCRATE:
313         case AC97_REGEXT_MADCRATE:
314                 break;
315
316         default:
317                 return -1;
318         }
319
320         snd_mtxlock(codec->lock);
321         if (rate != 0) {
322                 v = rate;
323                 if (codec->extstat & AC97_EXTCAP_DRA)
324                         v >>= 1;
325                 ac97_wrcd(codec, which, v);
326         }
327         v = ac97_rdcd(codec, which);
328         if (codec->extstat & AC97_EXTCAP_DRA)
329                 v <<= 1;
330         snd_mtxunlock(codec->lock);
331         return v;
332 }
333
334 int
335 ac97_setextmode(struct ac97_info *codec, u_int16_t mode)
336 {
337         mode &= AC97_EXTCAPS;
338         if ((mode & ~codec->extcaps) != 0) {
339                 device_printf(codec->dev, "ac97 invalid mode set 0x%04x\n",
340                               mode);
341                 return -1;
342         }
343         snd_mtxlock(codec->lock);
344         ac97_wrcd(codec, AC97_REGEXT_STAT, mode);
345         codec->extstat = ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS;
346         snd_mtxunlock(codec->lock);
347         return (mode == codec->extstat)? 0 : -1;
348 }
349
350 u_int16_t
351 ac97_getextmode(struct ac97_info *codec)
352 {
353         return codec->extstat;
354 }
355
356 u_int16_t
357 ac97_getextcaps(struct ac97_info *codec)
358 {
359         return codec->extcaps;
360 }
361
362 u_int16_t
363 ac97_getcaps(struct ac97_info *codec)
364 {
365         return codec->caps;
366 }
367
368 static int
369 ac97_setrecsrc(struct ac97_info *codec, int channel)
370 {
371         struct ac97mixtable_entry *e = &codec->mix[channel];
372
373         if (e->recidx > 0) {
374                 int val = e->recidx - 1;
375                 val |= val << 8;
376                 snd_mtxlock(codec->lock);
377                 ac97_wrcd(codec, AC97_REG_RECSEL, val);
378                 snd_mtxunlock(codec->lock);
379                 return 0;
380         } else
381                 return -1;
382 }
383
384 static int
385 ac97_setmixer(struct ac97_info *codec, unsigned channel, unsigned left, unsigned right)
386 {
387         struct ac97mixtable_entry *e = &codec->mix[channel];
388
389         if (e->reg && e->enable && e->bits) {
390                 int mask, max, val, reg;
391
392                 reg = (e->reg >= 0) ? e->reg : -e->reg; /* AC97 register    */
393                 max = (1 << e->bits) - 1;               /* actual range     */
394                 mask = (max << 8) | max;                /* bits of interest */
395
396                 if (!e->stereo)
397                         right = left;
398
399                 /*
400                  * Invert the range if the polarity requires so,
401                  * then scale to 0..max-1 to compute the value to
402                  * write into the codec, and scale back to 0..100
403                  * for the return value.
404                  */
405                 if (e->reg > 0) {
406                         left = 100 - left;
407                         right = 100 - right;
408                 }
409
410                 left = (left * max) / 100;
411                 right = (right * max) / 100;
412
413                 val = (left << 8) | right;
414
415                 left = (left * 100) / max;
416                 right = (right * 100) / max;
417
418                 if (e->reg > 0) {
419                         left = 100 - left;
420                         right = 100 - right;
421                 }
422
423                 /*
424                  * For mono controls, trim val and mask, also taking
425                  * care of e->ofs (offset of control field).
426                  */
427                 if (e->ofs) {
428                         val &= max;
429                         val <<= e->ofs;
430                         mask = (max << e->ofs);
431                 }
432
433                 /*
434                  * If we have a mute bit, add it to the mask and
435                  * update val and set mute if both channels require a
436                  * zero volume.
437                  */
438                 if (e->mute == 1) {
439                         mask |= AC97_MUTE;
440                         if (left == 0 && right == 0)
441                                 val = AC97_MUTE;
442                 }
443
444                 /*
445                  * If the mask bit is set, do not alter the other bits.
446                  */
447                 snd_mtxlock(codec->lock);
448                 if (e->mask) {
449                         int cur = ac97_rdcd(codec, e->reg);
450                         val |= cur & ~(mask);
451                 }
452                 ac97_wrcd(codec, reg, val);
453                 snd_mtxunlock(codec->lock);
454                 return left | (right << 8);
455         } else {
456                 /* printf("ac97_setmixer: reg=%d, bits=%d, enable=%d\n", e->reg, e->bits, e->enable); */
457                 return -1;
458         }
459 }
460
461 static void
462 ac97_fix_auxout(struct ac97_info *codec)
463 {
464         int keep_ogain;
465
466         /*
467          * By default, The ac97 aux_out register (0x04) corresponds to OSS's
468          * OGAIN setting.
469          *
470          * We first check whether aux_out is a valid register.  If not
471          * we may not want to keep ogain.
472          */
473         keep_ogain = ac97_rdcd(codec, AC97_MIX_AUXOUT) & 0x8000;
474
475         /*
476          * Determine what AUX_OUT really means, it can be:
477          *
478          * 1. Headphone out.
479          * 2. 4-Channel Out
480          * 3. True line level out (effectively master volume).
481          *
482          * See Sections 5.2.1 and 5.27 for AUX_OUT Options in AC97r2.{2,3}.
483          */
484         if (codec->extcaps & AC97_EXTCAP_SDAC &&
485             ac97_rdcd(codec, AC97_MIXEXT_SURROUND) == 0x8080) {
486                 codec->mix[SOUND_MIXER_OGAIN].reg = AC97_MIXEXT_SURROUND;
487                 keep_ogain = 1;
488         }
489
490         if (keep_ogain == 0) {
491                 bzero(&codec->mix[SOUND_MIXER_OGAIN],
492                       sizeof(codec->mix[SOUND_MIXER_OGAIN]));
493         }
494 }
495
496 static void
497 ac97_fix_tone(struct ac97_info *codec)
498 {
499         /* Hide treble and bass if they don't exist */
500         if ((codec->caps & AC97_CAP_TONE) == 0) {
501                 bzero(&codec->mix[SOUND_MIXER_BASS],
502                       sizeof(codec->mix[SOUND_MIXER_BASS]));
503                 bzero(&codec->mix[SOUND_MIXER_TREBLE],
504                       sizeof(codec->mix[SOUND_MIXER_TREBLE]));
505         }
506 }
507
508 static const char*
509 ac97_hw_desc(u_int32_t id, const char* vname, const char* cname, char* buf)
510 {
511         if (cname == NULL) {
512                 sprintf(buf, "Unknown AC97 Codec (id = 0x%08x)", id);
513                 return buf;
514         }
515
516         if (vname == NULL) vname = "Unknown";
517
518         if (bootverbose) {
519                 sprintf(buf, "%s %s AC97 Codec (id = 0x%08x)", vname, cname, id);
520         } else {
521                 sprintf(buf, "%s %s AC97 Codec", vname, cname);
522         }
523         return buf;
524 }
525
526 static unsigned
527 ac97_initmixer(struct ac97_info *codec)
528 {
529         ac97_patch codec_patch;
530         const char *cname, *vname;
531         char desc[80];
532         u_int8_t model, step;
533         unsigned i, j, k, old;
534         u_int32_t id;
535
536         snd_mtxlock(codec->lock);
537         codec->count = AC97_INIT(codec->methods, codec->devinfo);
538         if (codec->count == 0) {
539                 device_printf(codec->dev, "ac97 codec init failed\n");
540                 snd_mtxunlock(codec->lock);
541                 return ENODEV;
542         }
543
544         ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
545         ac97_reset(codec);
546         ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
547
548         i = ac97_rdcd(codec, AC97_REG_RESET);
549         codec->caps = i & 0x03ff;
550         codec->se =  (i & 0x7c00) >> 10;
551
552         id = (ac97_rdcd(codec, AC97_REG_ID1) << 16) | ac97_rdcd(codec, AC97_REG_ID2);
553         if (id == 0 || id == 0xffffffff) {
554                 device_printf(codec->dev, "ac97 codec invalid or not present (id == %x)\n", id);
555                 snd_mtxunlock(codec->lock);
556                 return ENODEV;
557         }
558
559         codec->id = id;
560         codec->noext = 0;
561         codec_patch = NULL;
562
563         cname = NULL;
564         model = step = 0;
565         for (i = 0; ac97codecid[i].id; i++) {
566                 u_int32_t modelmask = 0xffffffff ^ ac97codecid[i].stepmask;
567                 if ((ac97codecid[i].id & modelmask) == (id & modelmask)) {
568                         codec->noext = ac97codecid[i].noext;
569                         codec_patch = ac97codecid[i].patch;
570                         cname = ac97codecid[i].name;
571                         model = (id & modelmask) & 0xff;
572                         step = (id & ~modelmask) & 0xff;
573                         break;
574                 }
575         }
576
577         vname = NULL;
578         for (i = 0; ac97vendorid[i].id; i++) {
579                 if (ac97vendorid[i].id == (id & 0xffffff00)) {
580                         vname = ac97vendorid[i].name;
581                         break;
582                 }
583         }
584
585         codec->extcaps = 0;
586         codec->extid = 0;
587         codec->extstat = 0;
588         if (!codec->noext) {
589                 i = ac97_rdcd(codec, AC97_REGEXT_ID);
590                 if (i != 0xffff) {
591                         codec->extcaps = i & 0x3fff;
592                         codec->extid =  (i & 0xc000) >> 14;
593                         codec->extstat = ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS;
594                 }
595         }
596
597         for (i = 0; i < 32; i++) {
598                 codec->mix[i] = ac97mixtable_default[i];
599         }
600         ac97_fix_auxout(codec);
601         ac97_fix_tone(codec);
602         if (codec_patch)
603                 codec_patch(codec);
604
605         for (i = 0; i < 32; i++) {
606                 k = codec->noext? codec->mix[i].enable : 1;
607                 if (k && (codec->mix[i].reg > 0)) {
608                         old = ac97_rdcd(codec, codec->mix[i].reg);
609                         ac97_wrcd(codec, codec->mix[i].reg, 0x3f);
610                         j = ac97_rdcd(codec, codec->mix[i].reg);
611                         ac97_wrcd(codec, codec->mix[i].reg, old);
612                         codec->mix[i].enable = (j != 0 && j != old)? 1 : 0;
613                         for (k = 1; j & (1 << k); k++);
614                         codec->mix[i].bits = j? k - codec->mix[i].ofs : 0;
615                 }
616                 /* printf("mixch %d, en=%d, b=%d\n", i, codec->mix[i].enable, codec->mix[i].bits); */
617         }
618
619         device_printf(codec->dev, "<%s>\n",
620                       ac97_hw_desc(codec->id, vname, cname, desc));
621
622         if (bootverbose) {
623                 device_printf(codec->dev, "Codec features ");
624                 for (i = j = 0; i < 10; i++)
625                         if (codec->caps & (1 << i))
626                                 printf("%s%s", j++? ", " : "", ac97feature[i]);
627                 printf("%s%d bit master volume", j++? ", " : "", codec->mix[SOUND_MIXER_VOLUME].bits);
628                 printf("%s%s\n", j? ", " : "", ac97enhancement[codec->se]);
629
630                 if (codec->extcaps != 0 || codec->extid) {
631                         device_printf(codec->dev, "%s codec",
632                                       codec->extid? "Secondary" : "Primary");
633                         if (codec->extcaps)
634                                 printf(" extended features ");
635                         for (i = j = 0; i < 14; i++)
636                                 if (codec->extcaps & (1 << i))
637                                         printf("%s%s", j++? ", " : "", ac97extfeature[i]);
638                         printf("\n");
639                 }
640         }
641
642         if ((ac97_rdcd(codec, AC97_REG_POWER) & 2) == 0)
643                 device_printf(codec->dev, "ac97 codec reports dac not ready\n");
644         snd_mtxunlock(codec->lock);
645         return 0;
646 }
647
648 static unsigned
649 ac97_reinitmixer(struct ac97_info *codec)
650 {
651         snd_mtxlock(codec->lock);
652         codec->count = AC97_INIT(codec->methods, codec->devinfo);
653         if (codec->count == 0) {
654                 device_printf(codec->dev, "ac97 codec init failed\n");
655                 snd_mtxunlock(codec->lock);
656                 return ENODEV;
657         }
658
659         ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
660         ac97_reset(codec);
661         ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
662
663         if (!codec->noext) {
664                 ac97_wrcd(codec, AC97_REGEXT_STAT, codec->extstat);
665                 if ((ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS)
666                     != codec->extstat)
667                         device_printf(codec->dev, "ac97 codec failed to reset extended mode (%x, got %x)\n",
668                                       codec->extstat,
669                                       ac97_rdcd(codec, AC97_REGEXT_STAT) &
670                                       AC97_EXTCAPS);
671         }
672
673         if ((ac97_rdcd(codec, AC97_REG_POWER) & 2) == 0)
674                 device_printf(codec->dev, "ac97 codec reports dac not ready\n");
675         snd_mtxunlock(codec->lock);
676         return 0;
677 }
678
679 struct ac97_info *
680 ac97_create(device_t dev, void *devinfo, kobj_class_t cls)
681 {
682         struct ac97_info *codec;
683
684         codec = (struct ac97_info *)malloc(sizeof *codec, M_AC97, M_NOWAIT);
685         if (codec == NULL)
686                 return NULL;
687
688         snprintf(codec->name, AC97_NAMELEN, "%s:ac97", device_get_nameunit(dev));
689         codec->lock = snd_mtxcreate(codec->name, "ac97 codec");
690         codec->methods = kobj_create(cls, M_AC97, 0);
691         if (codec->methods == NULL) {
692                 snd_mtxlock(codec->lock);
693                 snd_mtxfree(codec->lock);
694                 free(codec, M_AC97);
695                 return NULL;
696         }
697
698         codec->dev = dev;
699         codec->devinfo = devinfo;
700         codec->flags = 0;
701         return codec;
702 }
703
704 void
705 ac97_destroy(struct ac97_info *codec)
706 {
707         snd_mtxlock(codec->lock);
708         if (codec->methods != NULL)
709                 kobj_delete(codec->methods, M_AC97);
710         snd_mtxfree(codec->lock);
711         free(codec, M_AC97);
712 }
713
714 void
715 ac97_setflags(struct ac97_info *codec, u_int32_t val)
716 {
717         codec->flags = val;
718 }
719
720 u_int32_t
721 ac97_getflags(struct ac97_info *codec)
722 {
723         return codec->flags;
724 }
725
726 /* -------------------------------------------------------------------- */
727
728 static int
729 ac97mix_init(struct snd_mixer *m)
730 {
731         struct ac97_info *codec = mix_getdevinfo(m);
732         u_int32_t i, mask;
733
734         if (codec == NULL)
735                 return -1;
736
737         if (ac97_initmixer(codec))
738                 return -1;
739
740         mask = 0;
741         for (i = 0; i < 32; i++)
742                 mask |= codec->mix[i].enable? 1 << i : 0;
743         mix_setdevs(m, mask);
744
745         mask = 0;
746         for (i = 0; i < 32; i++)
747                 mask |= codec->mix[i].recidx? 1 << i : 0;
748         mix_setrecdevs(m, mask);
749         return 0;
750 }
751
752 static int
753 ac97mix_uninit(struct snd_mixer *m)
754 {
755         struct ac97_info *codec = mix_getdevinfo(m);
756
757         if (codec == NULL)
758                 return -1;
759         /*
760         if (ac97_uninitmixer(codec))
761                 return -1;
762         */
763         ac97_destroy(codec);
764         return 0;
765 }
766
767 static int
768 ac97mix_reinit(struct snd_mixer *m)
769 {
770         struct ac97_info *codec = mix_getdevinfo(m);
771
772         if (codec == NULL)
773                 return -1;
774         return ac97_reinitmixer(codec);
775 }
776
777 static int
778 ac97mix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
779 {
780         struct ac97_info *codec = mix_getdevinfo(m);
781
782         if (codec == NULL)
783                 return -1;
784         return ac97_setmixer(codec, dev, left, right);
785 }
786
787 static int
788 ac97mix_setrecsrc(struct snd_mixer *m, u_int32_t src)
789 {
790         int i;
791         struct ac97_info *codec = mix_getdevinfo(m);
792
793         if (codec == NULL)
794                 return -1;
795         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
796                 if ((src & (1 << i)) != 0)
797                         break;
798         return (ac97_setrecsrc(codec, i) == 0)? 1 << i : -1;
799 }
800
801 static kobj_method_t ac97mixer_methods[] = {
802         KOBJMETHOD(mixer_init,          ac97mix_init),
803         KOBJMETHOD(mixer_uninit,        ac97mix_uninit),
804         KOBJMETHOD(mixer_reinit,        ac97mix_reinit),
805         KOBJMETHOD(mixer_set,           ac97mix_set),
806         KOBJMETHOD(mixer_setrecsrc,     ac97mix_setrecsrc),
807         { 0, 0 }
808 };
809 MIXER_DECLARE(ac97mixer);
810
811 /* -------------------------------------------------------------------- */
812
813 kobj_class_t
814 ac97_getmixerclass(void)
815 {
816         return &ac97mixer_class;
817 }
818
819