?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remap and virtualize mixer controls for HP nx6110 with AD1981B AC97 codec,
[dragonfly/netmp.git] / sys / dev / sound / pcm / ac97.c
blob3edbe41b55ac677948f9c6b973b249b91ba97463
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.6 2007/10/31 04:00:07 ariff Exp $
27 * $DragonFly: src/sys/dev/sound/pcm/ac97.c,v 1.26 2007/11/30 07:59:56 hasso 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.26 2007/11/30 07:59:56 hasso 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 const char*
578 ac97_hw_desc(u_int32_t id, const char* vname, const char* cname, char* buf)
579 {
580 if (cname == NULL) {
581 ksprintf(buf, "Unknown AC97 Codec (id = 0x%08x)", id);
582 return buf;
583 }
584
585 if (vname == NULL) vname = "Unknown";
586
587 if (bootverbose) {
588 ksprintf(buf, "%s %s AC97 Codec (id = 0x%08x)", vname, cname, id);
589 } else {
590 ksprintf(buf, "%s %s AC97 Codec", vname, cname);
591 }
592 return buf;
593 }
594
595 static unsigned
596 ac97_initmixer(struct ac97_info *codec)
597 {
598 ac97_patch codec_patch;
599 const char *cname, *vname;
600 char desc[80];
601 u_int8_t model, step;
602 unsigned i, j, k, bit, old;
603 u_int32_t id;
604 int reg;
605
606 snd_mtxlock(codec->lock);
607 codec->count = AC97_INIT(codec->methods, codec->devinfo);
608 if (codec->count == 0) {
609 device_printf(codec->dev, "ac97 codec init failed\n");
610 snd_mtxunlock(codec->lock);
611 return ENODEV;
612 }
613
614 ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
615 ac97_reset(codec);
616 ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
617
618 i = ac97_rdcd(codec, AC97_REG_RESET);
619 j = ac97_rdcd(codec, AC97_REG_RESET);
620 /*
621 * Let see if this codec can return consistent value.
622 * If not, turn on aggressive read workaround
623 * (STAC9704 comes in mind).
624 */
625 if (i != j) {
626 codec->flags |= AC97_F_RDCD_BUG;
627 i = ac97_rdcd(codec, AC97_REG_RESET);
628 }
629 codec->caps = i & 0x03ff;
630 codec->se = (i & 0x7c00) >> 10;
631
632 id = (ac97_rdcd(codec, AC97_REG_ID1) << 16) | ac97_rdcd(codec, AC97_REG_ID2);
633 if (id == 0 || id == 0xffffffff) {
634 device_printf(codec->dev, "ac97 codec invalid or not present (id == %x)\n", id);
635 snd_mtxunlock(codec->lock);
636 return ENODEV;
637 }
638
639 codec->id = id;
640 codec->subvendor = (u_int32_t)pci_get_subdevice(codec->dev) << 16;
641 codec->subvendor |= (u_int32_t)pci_get_subvendor(codec->dev) &
642 0x0000ffff;
643 codec->noext = 0;
644 codec_patch = NULL;
645
646 cname = NULL;
647 model = step = 0;
648 for (i = 0; ac97codecid[i].id; i++) {
649 u_int32_t modelmask = 0xffffffff ^ ac97codecid[i].stepmask;
650 if ((ac97codecid[i].id & modelmask) == (id & modelmask)) {
651 codec->noext = ac97codecid[i].noext;
652 codec_patch = ac97codecid[i].patch;
653 cname = ac97codecid[i].name;
654 model = (id & modelmask) & 0xff;
655 step = (id & ~modelmask) & 0xff;
656 break;
657 }
658 }
659
660 vname = NULL;
661 for (i = 0; ac97vendorid[i].id; i++) {
662 if (ac97vendorid[i].id == (id & 0xffffff00)) {
663 vname = ac97vendorid[i].name;
664 break;
665 }
666 }
667
668 codec->extcaps = 0;
669 codec->extid = 0;
670 codec->extstat = 0;
671 if (!codec->noext) {
672 i = ac97_rdcd(codec, AC97_REGEXT_ID);
673 if (i != 0xffff) {
674 codec->extcaps = i & 0x3fff;
675 codec->extid = (i & 0xc000) >> 14;
676 codec->extstat = ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS;
677 }
678 }
679
680 for (i = 0; i < 32; i++) {
681 codec->mix[i] = ac97mixtable_default[i];
682 }
683 ac97_fix_auxout(codec);
684 ac97_fix_tone(codec);
685 if (codec_patch)
686 codec_patch(codec);
687
688 for (i = 0; i < 32; i++) {
689 k = codec->noext? codec->mix[i].enable : 1;
690 reg = codec->mix[i].reg;
691 if (reg < 0)
692 reg = -reg;
693 if (k && reg) {
694 j = old = ac97_rdcd(codec, reg);
695 /*
696 * Test for mute bit (except for AC97_MIX_TONE,
697 * where we simply assume it as available).
698 */
699 if (codec->mix[i].mute) {
700 ac97_wrcd(codec, reg, j | 0x8000);
701 j = ac97_rdcd(codec, reg);
702 } else
703 j |= 0x8000;
704 if ((j & 0x8000)) {
705 /*
706 * Test whether the control width should be
707 * 4, 5 or 6 bit. For 5bit register, we should
708 * test it whether it's really 5 or 6bit. Leave
709 * 4bit register alone, because sometimes an
710 * attempt to write past 4th bit may cause
711 * incorrect result especially for AC97_MIX_BEEP
712 * (ac97 2.3).
713 */
714 bit = codec->mix[i].bits;
715 if (bit == 5)
716 bit++;
717 j = ((1 << bit) - 1) << codec->mix[i].ofs;
718 ac97_wrcd(codec, reg,
719 j | (codec->mix[i].mute ? 0x8000 : 0));
720 k = ac97_rdcd(codec, reg) & j;
721 k >>= codec->mix[i].ofs;
722 if (reg == AC97_MIX_TONE &&
723 ((k & 0x0001) == 0x0000))
724 k >>= 1;
725 for (j = 0; k >> j; j++)
726 ;
727 if (j != 0) {
728 #if 0
729 device_printf(codec->dev, "%2d: [ac97_rdcd() = %d] [Testbit = %d] %d -> %d\n",
730 i, k, bit, codec->mix[i].bits, j);
731 #endif
732 codec->mix[i].enable = 1;
733 codec->mix[i].bits = j;
734 } else if (reg == AC97_MIX_BEEP) {
735 /*
736 * Few codec such as CX20468-21 does
737 * have this control register, although
738 * the only usable part is the mute bit.
739 */
740 codec->mix[i].enable = 1;
741 } else
742 codec->mix[i].enable = 0;
743 } else
744 codec->mix[i].enable = 0;
745 ac97_wrcd(codec, reg, old);
746 }
747 #if 0
748 kprintf("mixch %d, en=%d, b=%d\n", i, codec->mix[i].enable, codec->mix[i].bits);
749 #endif
750 }
751
752 device_printf(codec->dev, "<%s>\n",
753 ac97_hw_desc(codec->id, vname, cname, desc));
754
755 if (bootverbose) {
756 if (codec->flags & AC97_F_RDCD_BUG)
757 device_printf(codec->dev, "Buggy AC97 Codec: aggressive ac97_rdcd() workaround enabled\n");
758 device_printf(codec->dev, "Codec features ");
759 for (i = j = 0; i < 10; i++)
760 if (codec->caps & (1 << i))
761 kprintf("%s%s", j++? ", " : "", ac97feature[i]);
762 kprintf("%s%d bit master volume", j++? ", " : "", codec->mix[SOUND_MIXER_VOLUME].bits);
763 kprintf("%s%s\n", j? ", " : "", ac97enhancement[codec->se]);
764
765 if (codec->extcaps != 0 || codec->extid) {
766 device_printf(codec->dev, "%s codec",
767 codec->extid? "Secondary" : "Primary");
768 if (codec->extcaps)
769 kprintf(" extended features ");
770 for (i = j = 0; i < 14; i++)
771 if (codec->extcaps & (1 << i))
772 kprintf("%s%s", j++? ", " : "", ac97extfeature[i]);
773 kprintf("\n");
774 }
775 }
776
777 i = 0;
778 while ((ac97_rdcd(codec, AC97_REG_POWER) & 2) == 0) {
779 if (++i == 100) {
780 device_printf(codec->dev, "ac97 codec reports dac not ready\n");
781 break;
782 }
783 DELAY(1000);
784 }
785 if (bootverbose)
786 device_printf(codec->dev, "ac97 codec dac ready count: %d\n", i);
787 snd_mtxunlock(codec->lock);
788 return 0;
789 }
790
791 static unsigned
792 ac97_reinitmixer(struct ac97_info *codec)
793 {
794 snd_mtxlock(codec->lock);
795 codec->count = AC97_INIT(codec->methods, codec->devinfo);
796 if (codec->count == 0) {
797 device_printf(codec->dev, "ac97 codec init failed\n");
798 snd_mtxunlock(codec->lock);
799 return ENODEV;
800 }
801
802 ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
803 ac97_reset(codec);
804 ac97_wrcd(codec, AC97_REG_POWER, (codec->flags & AC97_F_EAPD_INV)? 0x8000 : 0x0000);
805
806 if (!codec->noext) {
807 ac97_wrcd(codec, AC97_REGEXT_STAT, codec->extstat);
808 if ((ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS)
809 != codec->extstat)
810 device_printf(codec->dev, "ac97 codec failed to reset extended mode (%x, got %x)\n",
811 codec->extstat,
812 ac97_rdcd(codec, AC97_REGEXT_STAT) &
813 AC97_EXTCAPS);
814 }
815
816 if ((ac97_rdcd(codec, AC97_REG_POWER) & 2) == 0)
817 device_printf(codec->dev, "ac97 codec reports dac not ready\n");
818 snd_mtxunlock(codec->lock);
819 return 0;
820 }
821
822 struct ac97_info *
823 ac97_create(device_t dev, void *devinfo, kobj_class_t cls)
824 {
825 struct ac97_info *codec;
826
827 codec = (struct ac97_info *)kmalloc(sizeof *codec, M_AC97, M_NOWAIT);
828 if (codec == NULL)
829 return NULL;
830
831 ksnprintf(codec->name, AC97_NAMELEN, "%s:ac97", device_get_nameunit(dev));
832 codec->lock = snd_mtxcreate(codec->name, "ac97 codec");
833 codec->methods = kobj_create(cls, M_AC97, M_WAITOK);
834 if (codec->methods == NULL) {
835 snd_mtxfree(codec->lock);
836 kfree(codec, M_AC97);
837 return NULL;
838 }
839
840 codec->dev = dev;
841 codec->devinfo = devinfo;
842 codec->flags = 0;
843 return codec;
844 }
845
846 void
847 ac97_destroy(struct ac97_info *codec)
848 {
849 if (codec->methods != NULL)
850 kobj_delete(codec->methods, M_AC97);
851 snd_mtxfree(codec->lock);
852 kfree(codec, M_AC97);
853 }
854
855 void
856 ac97_setflags(struct ac97_info *codec, u_int32_t val)
857 {
858 codec->flags = val;
859 }
860
861 u_int32_t
862 ac97_getflags(struct ac97_info *codec)
863 {
864 return codec->flags;
865 }
866
867 /* -------------------------------------------------------------------- */
868
869 static int
870 ac97mix_init(struct snd_mixer *m)
871 {
872 struct ac97_info *codec = mix_getdevinfo(m);
873 u_int32_t i, mask;
874
875 if (codec == NULL)
876 return -1;
877
878 if (ac97_initmixer(codec))
879 return -1;
880
881 switch (codec->id) {
882 case 0x41445374: /* AD1981B */
883 switch (codec->subvendor) {
884 case 0x02d91014:
885 /*
886 * IBM Thinkcentre:
887 *
888 * Tie "ogain" and "phout" to "vol" since its
889 * master volume is basically useless and can't
890 * control anything.
891 */
892 mask = 0;
893 if (codec->mix[SOUND_MIXER_OGAIN].enable)
894 mask |= SOUND_MASK_OGAIN;
895 if (codec->mix[SOUND_MIXER_PHONEOUT].enable)
896 mask |= SOUND_MASK_PHONEOUT;
897 if (codec->mix[SOUND_MIXER_VOLUME].enable)
898 mix_setparentchild(m, SOUND_MIXER_VOLUME,
899 mask);
900 else {
901 mix_setparentchild(m, SOUND_MIXER_VOLUME,
902 mask);
903 mix_setrealdev(m, SOUND_MIXER_VOLUME,
904 SOUND_MIXER_NONE);
905 }
906 break;
907 case 0x099c103c:
908 /*
909 * HP nx6110:
910 *
911 * By default, "vol" is controlling internal speakers
912 * (not a master volume!) and "ogain" is controlling
913 * headphone. Enable dummy "phout" so it can be
914 * remapped to internal speakers and virtualize
915 * "vol" to control both.
916 */
917 codec->mix[SOUND_MIXER_OGAIN].enable = 1;
918 codec->mix[SOUND_MIXER_PHONEOUT].enable = 1;
919 mix_setrealdev(m, SOUND_MIXER_PHONEOUT,
920 SOUND_MIXER_VOLUME);
921 mix_setrealdev(m, SOUND_MIXER_VOLUME,
922 SOUND_MIXER_NONE);
923 mix_setparentchild(m, SOUND_MIXER_VOLUME,
924 SOUND_MASK_OGAIN | SOUND_MASK_PHONEOUT);
925 break;
926 default:
927 break;
928 }
929 break;
930 case 0x434d4941: /* CMI9738 */
931 case 0x434d4961: /* CMI9739 */
932 case 0x434d4978: /* CMI9761 */
933 case 0x434d4982: /* CMI9761 */
934 case 0x434d4983: /* CMI9761 */
935 ac97_wrcd(codec, AC97_MIX_PCM, 0);
936 bzero(&codec->mix[SOUND_MIXER_PCM],
937 sizeof(codec->mix[SOUND_MIXER_PCM]));
938 pcm_setflags(codec->dev, pcm_getflags(codec->dev) |
939 SD_F_SOFTPCMVOL);
940 /* XXX How about master volume ? */
941 break;
942 default:
943 break;
944 }
945
946 #if 0
947 /* XXX For the sake of debugging purposes */
948 mix_setparentchild(m, SOUND_MIXER_VOLUME,
949 SOUND_MASK_PCM | SOUND_MASK_CD);
950 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE);
951 ac97_wrcd(codec, AC97_MIX_MASTER, 0);
952 #endif
953
954 mask = 0;
955 for (i = 0; i < 32; i++)
956 mask |= codec->mix[i].enable? 1 << i : 0;
957 mix_setdevs(m, mask);
958
959 mask = 0;
960 for (i = 0; i < 32; i++)
961 mask |= codec->mix[i].recidx? 1 << i : 0;
962 mix_setrecdevs(m, mask);
963 return 0;
964 }
965
966 static int
967 ac97mix_uninit(struct snd_mixer *m)
968 {
969 struct ac97_info *codec = mix_getdevinfo(m);
970
971 if (codec == NULL)
972 return -1;
973 /*
974 if (ac97_uninitmixer(codec))
975 return -1;
976 */
977 ac97_destroy(codec);
978 return 0;
979 }
980
981 static int
982 ac97mix_reinit(struct snd_mixer *m)
983 {
984 struct ac97_info *codec = mix_getdevinfo(m);
985
986 if (codec == NULL)
987 return -1;
988 return ac97_reinitmixer(codec);
989 }
990
991 static int
992 ac97mix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
993 {
994 struct ac97_info *codec = mix_getdevinfo(m);
995
996 if (codec == NULL)
997 return -1;
998 return ac97_setmixer(codec, dev, left, right);
999 }
1000
1001 static int
1002 ac97mix_setrecsrc(struct snd_mixer *m, u_int32_t src)
1003 {
1004 int i;
1005 struct ac97_info *codec = mix_getdevinfo(m);
1006
1007 if (codec == NULL)
1008 return -1;
1009 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
1010 if ((src & (1 << i)) != 0)
1011 break;
1012 return (ac97_setrecsrc(codec, i) == 0)? 1 << i : -1;
1013 }
1014
1015 static kobj_method_t ac97mixer_methods[] = {
1016 KOBJMETHOD(mixer_init, ac97mix_init),
1017 KOBJMETHOD(mixer_uninit, ac97mix_uninit),
1018 KOBJMETHOD(mixer_reinit, ac97mix_reinit),
1019 KOBJMETHOD(mixer_set, ac97mix_set),
1020 KOBJMETHOD(mixer_setrecsrc, ac97mix_setrecsrc),
1021 { 0, 0 }
1022 };
1023 MIXER_DECLARE(ac97mixer);
1024
1025 /* -------------------------------------------------------------------- */
1026
1027 kobj_class_t
1028 ac97_getmixerclass(void)
1029 {
1030 return &ac97mixer_class;
1031 }
MP support for (parts of) the network stack