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