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