?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] iSeries build with newer assemblers and compilers
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / sound / oss / ac97_codec.c
blob3ecef4689f1b23d6a2454f443413c447e2a72bbc
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 wolfson_init13(struct ac97_codec * codec);
75 static int tritech_init(struct ac97_codec * codec);
76 static int tritech_maestro_init(struct ac97_codec * codec);
77 static int sigmatel_9708_init(struct ac97_codec *codec);
78 static int sigmatel_9721_init(struct ac97_codec *codec);
79 static int sigmatel_9744_init(struct ac97_codec *codec);
80 static int ad1886_init(struct ac97_codec *codec);
81 static int eapd_control(struct ac97_codec *codec, int);
82 static int crystal_digital_control(struct ac97_codec *codec, int slots, int rate, int mode);
83 static int cmedia_init(struct ac97_codec * codec);
84 static int cmedia_digital_control(struct ac97_codec *codec, int slots, int rate, int mode);
85 static int generic_digital_control(struct ac97_codec *codec, int slots, int rate, int mode);
86
87
88 /*
89 * AC97 operations.
90 *
91 * If you are adding a codec then you should be able to use
92 * eapd_ops - any codec that supports EAPD amp control (most)
93 * null_ops - any ancient codec that supports nothing
94 *
95 * The three functions are
96 * init - used for non AC97 standard initialisation
97 * amplifier - used to do amplifier control (1=on 0=off)
98 * digital - switch to digital modes (0 = analog)
99 *
100 * Not all codecs support all features, not all drivers use all the
101 * operations yet
102 */
103
104 static struct ac97_ops null_ops = { NULL, NULL, NULL };
105 static struct ac97_ops default_ops = { NULL, eapd_control, NULL };
106 static struct ac97_ops default_digital_ops = { NULL, eapd_control, generic_digital_control};
107 static struct ac97_ops wolfson_ops03 = { wolfson_init03, NULL, NULL };
108 static struct ac97_ops wolfson_ops04 = { wolfson_init04, NULL, NULL };
109 static struct ac97_ops wolfson_ops05 = { wolfson_init05, NULL, NULL };
110 static struct ac97_ops wolfson_ops11 = { wolfson_init11, NULL, NULL };
111 static struct ac97_ops wolfson_ops13 = { wolfson_init13, NULL, NULL };
112 static struct ac97_ops tritech_ops = { tritech_init, NULL, NULL };
113 static struct ac97_ops tritech_m_ops = { tritech_maestro_init, NULL, NULL };
114 static struct ac97_ops sigmatel_9708_ops = { sigmatel_9708_init, NULL, NULL };
115 static struct ac97_ops sigmatel_9721_ops = { sigmatel_9721_init, NULL, NULL };
116 static struct ac97_ops sigmatel_9744_ops = { sigmatel_9744_init, NULL, NULL };
117 static struct ac97_ops crystal_digital_ops = { NULL, eapd_control, crystal_digital_control };
118 static struct ac97_ops ad1886_ops = { ad1886_init, eapd_control, NULL };
119 static struct ac97_ops cmedia_ops = { NULL, eapd_control, NULL};
120 static struct ac97_ops cmedia_digital_ops = { cmedia_init, eapd_control, cmedia_digital_control};
121
122 /* sorted by vendor/device id */
123 static const struct {
124 u32 id;
125 char *name;
126 struct ac97_ops *ops;
127 int flags;
128 } ac97_codec_ids[] = {
129 {0x41445303, "Analog Devices AD1819", &null_ops},
130 {0x41445340, "Analog Devices AD1881", &null_ops},
131 {0x41445348, "Analog Devices AD1881A", &null_ops},
132 {0x41445360, "Analog Devices AD1885", &default_ops},
133 {0x41445361, "Analog Devices AD1886", &ad1886_ops},
134 {0x41445370, "Analog Devices AD1981", &null_ops},
135 {0x41445372, "Analog Devices AD1981A", &null_ops},
136 {0x41445374, "Analog Devices AD1981B", &null_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 */
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 */
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 */
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 */
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
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 memset(&info, 0, sizeof(info));
525 strlcpy(info.id, codec->name, sizeof(info.id));
526 strlcpy(info.name, codec->name, sizeof(info.name));
527 info.modify_counter = codec->modcnt;
528 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
529 return -EFAULT;
530 return 0;
531 }
532 if (cmd == SOUND_OLD_MIXER_INFO) {
533 _old_mixer_info info;
534 memset(&info, 0, sizeof(info));
535 strlcpy(info.id, codec->name, sizeof(info.id));
536 strlcpy(info.name, codec->name, sizeof(info.name));
537 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
538 return -EFAULT;
539 return 0;
540 }
541
542 if (_IOC_TYPE(cmd) != 'M' || _SIOC_SIZE(cmd) != sizeof(int))
543 return -EINVAL;
544
545 if (cmd == OSS_GETVERSION)
546 return put_user(SOUND_VERSION, (int __user *)arg);
547
548 if (_SIOC_DIR(cmd) == _SIOC_READ) {
549 switch (_IOC_NR(cmd)) {
550 case SOUND_MIXER_RECSRC: /* give them the current record source */
551 if (!codec->recmask_io) {
552 val = 0;
553 } else {
554 val = codec->recmask_io(codec, 1, 0);
555 }
556 break;
557
558 case SOUND_MIXER_DEVMASK: /* give them the supported mixers */
559 val = codec->supported_mixers;
560 break;
561
562 case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
563 val = codec->record_sources;
564 break;
565
566 case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
567 val = codec->stereo_mixers;
568 break;
569
570 case SOUND_MIXER_CAPS:
571 val = SOUND_CAP_EXCL_INPUT;
572 break;
573
574 default: /* read a specific mixer */
575 i = _IOC_NR(cmd);
576
577 if (!supported_mixer(codec, i))
578 return -EINVAL;
579
580 /* do we ever want to touch the hardware? */
581 /* val = codec->read_mixer(codec, i); */
582 val = codec->mixer_state[i];
583 break;
584 }
585 return put_user(val, (int __user *)arg);
586 }
587
588 if (_SIOC_DIR(cmd) == (_SIOC_WRITE|_SIOC_READ)) {
589 codec->modcnt++;
590 if (get_user(val, (int __user *)arg))
591 return -EFAULT;
592
593 switch (_IOC_NR(cmd)) {
594 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
595 if (!codec->recmask_io) return -EINVAL;
596 if (!val) return 0;
597 if (!(val &= codec->record_sources)) return -EINVAL;
598
599 codec->recmask_io(codec, 0, val);
600
601 return 0;
602 default: /* write a specific mixer */
603 i = _IOC_NR(cmd);
604
605 if (!supported_mixer(codec, i))
606 return -EINVAL;
607
608 ac97_set_mixer(codec, i, val);
609
610 return 0;
611 }
612 }
613 return -EINVAL;
614 }
615
616 /* entry point for /proc/driver/controller_vendor/ac97/%d */
617 int ac97_read_proc (char *page, char **start, off_t off,
618 int count, int *eof, void *data)
619 {
620 int len = 0, cap, extid, val, id1, id2;
621 struct ac97_codec *codec;
622 int is_ac97_20 = 0;
623
624 if ((codec = data) == NULL)
625 return -ENODEV;
626
627 id1 = codec->codec_read(codec, AC97_VENDOR_ID1);
628 id2 = codec->codec_read(codec, AC97_VENDOR_ID2);
629 len += sprintf (page+len, "Vendor name : %s\n", codec->name);
630 len += sprintf (page+len, "Vendor id : %04X %04X\n", id1, id2);
631
632 extid = codec->codec_read(codec, AC97_EXTENDED_ID);
633 extid &= ~((1<<2)|(1<<4)|(1<<5)|(1<<10)|(1<<11)|(1<<12)|(1<<13));
634 len += sprintf (page+len, "AC97 Version : %s\n",
635 extid ? "2.0 or later" : "1.0");
636 if (extid) is_ac97_20 = 1;
637
638 cap = codec->codec_read(codec, AC97_RESET);
639 len += sprintf (page+len, "Capabilities :%s%s%s%s%s%s\n",
640 cap & 0x0001 ? " -dedicated MIC PCM IN channel-" : "",
641 cap & 0x0002 ? " -reserved1-" : "",
642 cap & 0x0004 ? " -bass & treble-" : "",
643 cap & 0x0008 ? " -simulated stereo-" : "",
644 cap & 0x0010 ? " -headphone out-" : "",
645 cap & 0x0020 ? " -loudness-" : "");
646 val = cap & 0x00c0;
647 len += sprintf (page+len, "DAC resolutions :%s%s%s\n",
648 " -16-bit-",
649 val & 0x0040 ? " -18-bit-" : "",
650 val & 0x0080 ? " -20-bit-" : "");
651 val = cap & 0x0300;
652 len += sprintf (page+len, "ADC resolutions :%s%s%s\n",
653 " -16-bit-",
654 val & 0x0100 ? " -18-bit-" : "",
655 val & 0x0200 ? " -20-bit-" : "");
656 len += sprintf (page+len, "3D enhancement : %s\n",
657 ac97_stereo_enhancements[(cap >> 10) & 0x1f]);
658
659 val = codec->codec_read(codec, AC97_GENERAL_PURPOSE);
660 len += sprintf (page+len, "POP path : %s 3D\n"
661 "Sim. stereo : %s\n"
662 "3D enhancement : %s\n"
663 "Loudness : %s\n"
664 "Mono output : %s\n"
665 "MIC select : %s\n"
666 "ADC/DAC loopback : %s\n",
667 val & 0x8000 ? "post" : "pre",
668 val & 0x4000 ? "on" : "off",
669 val & 0x2000 ? "on" : "off",
670 val & 0x1000 ? "on" : "off",
671 val & 0x0200 ? "MIC" : "MIX",
672 val & 0x0100 ? "MIC2" : "MIC1",
673 val & 0x0080 ? "on" : "off");
674
675 extid = codec->codec_read(codec, AC97_EXTENDED_ID);
676 cap = extid;
677 len += sprintf (page+len, "Ext Capabilities :%s%s%s%s%s%s%s\n",
678 cap & 0x0001 ? " -var rate PCM audio-" : "",
679 cap & 0x0002 ? " -2x PCM audio out-" : "",
680 cap & 0x0008 ? " -var rate MIC in-" : "",
681 cap & 0x0040 ? " -PCM center DAC-" : "",
682 cap & 0x0080 ? " -PCM surround DAC-" : "",
683 cap & 0x0100 ? " -PCM LFE DAC-" : "",
684 cap & 0x0200 ? " -slot/DAC mappings-" : "");
685 if (is_ac97_20) {
686 len += sprintf (page+len, "Front DAC rate : %d\n",
687 codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE));
688 }
689
690 return len;
691 }
692
693 /**
694 * codec_id - Turn id1/id2 into a PnP string
695 * @id1: Vendor ID1
696 * @id2: Vendor ID2
697 * @buf: CODEC_ID_BUFSZ byte buffer
698 *
699 * Fills buf with a zero terminated PnP ident string for the id1/id2
700 * pair. For convenience the return is the passed in buffer pointer.
701 */
702
703 static char *codec_id(u16 id1, u16 id2, char *buf)
704 {
705 if(id1&0x8080) {
706 snprintf(buf, CODEC_ID_BUFSZ, "0x%04x:0x%04x", id1, id2);
707 } else {
708 buf[0] = (id1 >> 8);
709 buf[1] = (id1 & 0xFF);
710 buf[2] = (id2 >> 8);
711 snprintf(buf+3, CODEC_ID_BUFSZ - 3, "%d", id2&0xFF);
712 }
713 return buf;
714 }
715
716 /**
717 * ac97_check_modem - Check if the Codec is a modem
718 * @codec: codec to check
719 *
720 * Return true if the device is an AC97 1.0 or AC97 2.0 modem
721 */
722
723 static int ac97_check_modem(struct ac97_codec *codec)
724 {
725 /* Check for an AC97 1.0 soft modem (ID1) */
726 if(codec->codec_read(codec, AC97_RESET) & 2)
727 return 1;
728 /* Check for an AC97 2.x soft modem */
729 codec->codec_write(codec, AC97_EXTENDED_MODEM_ID, 0L);
730 if(codec->codec_read(codec, AC97_EXTENDED_MODEM_ID) & 1)
731 return 1;
732 return 0;
733 }
734
735
736 /**
737 * ac97_alloc_codec - Allocate an AC97 codec
738 *
739 * Returns a new AC97 codec structure. AC97 codecs may become
740 * refcounted soon so this interface is needed. Returns with
741 * one reference taken.
742 */
743
744 struct ac97_codec *ac97_alloc_codec(void)
745 {
746 struct ac97_codec *codec = kmalloc(sizeof(struct ac97_codec), GFP_KERNEL);
747 if(!codec)
748 return NULL;
749
750 memset(codec, 0, sizeof(*codec));
751 spin_lock_init(&codec->lock);
752 INIT_LIST_HEAD(&codec->list);
753 return codec;
754 }
755
756 EXPORT_SYMBOL(ac97_alloc_codec);
757
758 /**
759 * ac97_release_codec - Release an AC97 codec
760 * @codec: codec to release
761 *
762 * Release an allocated AC97 codec. This will be refcounted in
763 * time but for the moment is trivial. Calls the unregister
764 * handler if the codec is now defunct.
765 */
766
767 void ac97_release_codec(struct ac97_codec *codec)
768 {
769 /* Remove from the list first, we don't want to be
770 "rediscovered" */
771 down(&codec_sem);
772 list_del(&codec->list);
773 up(&codec_sem);
774 /*
775 * The driver needs to deal with internal
776 * locking to avoid accidents here.
777 */
778 if(codec->driver)
779 codec->driver->remove(codec, codec->driver);
780 kfree(codec);
781 }
782
783 EXPORT_SYMBOL(ac97_release_codec);
784
785 /**
786 * ac97_probe_codec - Initialize and setup AC97-compatible codec
787 * @codec: (in/out) Kernel info for a single AC97 codec
788 *
789 * Reset the AC97 codec, then initialize the mixer and
790 * the rest of the @codec structure.
791 *
792 * The codec_read and codec_write fields of @codec are
793 * required to be setup and working when this function
794 * is called. All other fields are set by this function.
795 *
796 * codec_wait field of @codec can optionally be provided
797 * when calling this function. If codec_wait is not %NULL,
798 * this function will call codec_wait any time it is
799 * necessary to wait for the audio chip to reach the
800 * codec-ready state. If codec_wait is %NULL, then
801 * the default behavior is to call schedule_timeout.
802 * Currently codec_wait is used to wait for AC97 codec
803 * reset to complete.
804 *
805 * Some codecs will power down when a register reset is
806 * performed. We now check for such codecs.
807 *
808 * Returns 1 (true) on success, or 0 (false) on failure.
809 */
810
811 int ac97_probe_codec(struct ac97_codec *codec)
812 {
813 u16 id1, id2;
814 u16 audio;
815 int i;
816 char cidbuf[CODEC_ID_BUFSZ];
817 u16 f;
818 struct list_head *l;
819 struct ac97_driver *d;
820
821 /* wait for codec-ready state */
822 if (codec->codec_wait)
823 codec->codec_wait(codec);
824 else
825 udelay(10);
826
827 /* will the codec power down if register reset ? */
828 id1 = codec->codec_read(codec, AC97_VENDOR_ID1);
829 id2 = codec->codec_read(codec, AC97_VENDOR_ID2);
830 codec->name = NULL;
831 codec->codec_ops = &null_ops;
832 for (i = 0; i < ARRAY_SIZE(ac97_codec_ids); i++) {
833 if (ac97_codec_ids[i].id == ((id1 << 16) | id2)) {
834 codec->type = ac97_codec_ids[i].id;
835 codec->name = ac97_codec_ids[i].name;
836 codec->codec_ops = ac97_codec_ids[i].ops;
837 codec->flags = ac97_codec_ids[i].flags;
838 break;
839 }
840 }
841
842 codec->model = (id1 << 16) | id2;
843 if ((codec->flags & AC97_DEFAULT_POWER_OFF) == 0) {
844 /* reset codec and wait for the ready bit before we continue */
845 codec->codec_write(codec, AC97_RESET, 0L);
846 if (codec->codec_wait)
847 codec->codec_wait(codec);
848 else
849 udelay(10);
850 }
851
852 /* probing AC97 codec, AC97 2.0 says that bit 15 of register 0x00 (reset) should
853 * be read zero.
854 *
855 * FIXME: is the following comment outdated? -jgarzik
856 * Probing of AC97 in this way is not reliable, it is not even SAFE !!
857 */
858 if ((audio = codec->codec_read(codec, AC97_RESET)) & 0x8000) {
859 printk(KERN_ERR "ac97_codec: %s ac97 codec not present\n",
860 (codec->id & 0x2) ? (codec->id&1 ? "4th" : "Tertiary")
861 : (codec->id&1 ? "Secondary": "Primary"));
862 return 0;
863 }
864
865 /* probe for Modem Codec */
866 codec->modem = ac97_check_modem(codec);
867
868 /* enable SPDIF */
869 f = codec->codec_read(codec, AC97_EXTENDED_STATUS);
870 if((codec->codec_ops == &null_ops) && (f & 4))
871 codec->codec_ops = &default_digital_ops;
872
873 /* A device which thinks its a modem but isnt */
874 if(codec->flags & AC97_DELUDED_MODEM)
875 codec->modem = 0;
876
877 if (codec->name == NULL)
878 codec->name = "Unknown";
879 printk(KERN_INFO "ac97_codec: AC97 %s codec, id: %s (%s)\n",
880 codec->modem ? "Modem" : (audio ? "Audio" : ""),
881 codec_id(id1, id2, cidbuf), codec->name);
882
883 if(!ac97_init_mixer(codec))
884 return 0;
885
886 /*
887 * Attach last so the caller can override the mixer
888 * callbacks.
889 */
890
891 down(&codec_sem);
892 list_add(&codec->list, &codecs);
893
894 list_for_each(l, &codec_drivers) {
895 d = list_entry(l, struct ac97_driver, list);
896 if ((codec->model ^ d->codec_id) & d->codec_mask)
897 continue;
898 if(d->probe(codec, d) == 0)
899 {
900 codec->driver = d;
901 break;
902 }
903 }
904
905 up(&codec_sem);
906 return 1;
907 }
908
909 static int ac97_init_mixer(struct ac97_codec *codec)
910 {
911 u16 cap;
912 int i;
913
914 cap = codec->codec_read(codec, AC97_RESET);
915
916 /* mixer masks */
917 codec->supported_mixers = AC97_SUPPORTED_MASK;
918 codec->stereo_mixers = AC97_STEREO_MASK;
919 codec->record_sources = AC97_RECORD_MASK;
920 if (!(cap & 0x04))
921 codec->supported_mixers &= ~(SOUND_MASK_BASS|SOUND_MASK_TREBLE);
922 if (!(cap & 0x10))
923 codec->supported_mixers &= ~SOUND_MASK_ALTPCM;
924
925
926 /* detect bit resolution */
927 codec->codec_write(codec, AC97_MASTER_VOL_STEREO, 0x2020);
928 if(codec->codec_read(codec, AC97_MASTER_VOL_STEREO) == 0x2020)
929 codec->bit_resolution = 6;
930 else
931 codec->bit_resolution = 5;
932
933 /* generic OSS to AC97 wrapper */
934 codec->read_mixer = ac97_read_mixer;
935 codec->write_mixer = ac97_write_mixer;
936 codec->recmask_io = ac97_recmask_io;
937 codec->mixer_ioctl = ac97_mixer_ioctl;
938
939 /* initialize mixer channel volumes */
940 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
941 struct mixer_defaults *md = &mixer_defaults[i];
942 if (md->mixer == -1)
943 break;
944 if (!supported_mixer(codec, md->mixer))
945 continue;
946 ac97_set_mixer(codec, md->mixer, md->value);
947 }
948
949 /* codec specific initialization for 4-6 channel output or secondary codec stuff */
950 if (codec->codec_ops->init != NULL) {
951 codec->codec_ops->init(codec);
952 }
953
954 /*
955 * Volume is MUTE only on this device. We have to initialise
956 * it but its useless beyond that.
957 */
958 if(codec->flags & AC97_NO_PCM_VOLUME)
959 {
960 codec->supported_mixers &= ~SOUND_MASK_PCM;
961 printk(KERN_WARNING "AC97 codec does not have proper volume support.\n");
962 }
963 return 1;
964 }
965
966 #define AC97_SIGMATEL_ANALOG 0x6c /* Analog Special */
967 #define AC97_SIGMATEL_DAC2INVERT 0x6e
968 #define AC97_SIGMATEL_BIAS1 0x70
969 #define AC97_SIGMATEL_BIAS2 0x72
970 #define AC97_SIGMATEL_MULTICHN 0x74 /* Multi-Channel programming */
971 #define AC97_SIGMATEL_CIC1 0x76
972 #define AC97_SIGMATEL_CIC2 0x78
973
974
975 static int sigmatel_9708_init(struct ac97_codec * codec)
976 {
977 u16 codec72, codec6c;
978
979 codec72 = codec->codec_read(codec, AC97_SIGMATEL_BIAS2) & 0x8000;
980 codec6c = codec->codec_read(codec, AC97_SIGMATEL_ANALOG);
981
982 if ((codec72==0) && (codec6c==0)) {
983 codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
984 codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x1000);
985 codec->codec_write(codec, AC97_SIGMATEL_BIAS1, 0xabba);
986 codec->codec_write(codec, AC97_SIGMATEL_BIAS2, 0x0007);
987 } else if ((codec72==0x8000) && (codec6c==0)) {
988 codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
989 codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x1001);
990 codec->codec_write(codec, AC97_SIGMATEL_DAC2INVERT, 0x0008);
991 } else if ((codec72==0x8000) && (codec6c==0x0080)) {
992 /* nothing */
993 }
994 codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x0000);
995 return 0;
996 }
997
998
999 static int sigmatel_9721_init(struct ac97_codec * codec)
1000 {
1001 /* Only set up secondary codec */
1002 if (codec->id == 0)
1003 return 0;
1004
1005 codec->codec_write(codec, AC97_SURROUND_MASTER, 0L);
1006
1007 /* initialize SigmaTel STAC9721/23 as secondary codec, decoding AC link
1008 sloc 3,4 = 0x01, slot 7,8 = 0x00, */
1009 codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x00);
1010
1011 /* we don't have the crystal when we are on an AMR card, so use
1012 BIT_CLK as our clock source. Write the magic word ABBA and read
1013 back to enable register 0x78 */
1014 codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
1015 codec->codec_read(codec, AC97_SIGMATEL_CIC1);
1016
1017 /* sync all the clocks*/
1018 codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x3802);
1019
1020 return 0;
1021 }
1022
1023
1024 static int sigmatel_9744_init(struct ac97_codec * codec)
1025 {
1026 // patch for SigmaTel
1027 codec->codec_write(codec, AC97_SIGMATEL_CIC1, 0xabba);
1028 codec->codec_write(codec, AC97_SIGMATEL_CIC2, 0x0000); // is this correct? --jk
1029 codec->codec_write(codec, AC97_SIGMATEL_BIAS1, 0xabba);
1030 codec->codec_write(codec, AC97_SIGMATEL_BIAS2, 0x0002);
1031 codec->codec_write(codec, AC97_SIGMATEL_MULTICHN, 0x0000);
1032 return 0;
1033 }
1034
1035 static int cmedia_init(struct ac97_codec *codec)
1036 {
1037 /* Initialise the CMedia 9739 */
1038 /*
1039 We could set various options here
1040 Register 0x20 bit 0x100 sets mic as center bass
1041 Also do multi_channel_ctrl &=~0x3000 |=0x1000
1042
1043 For now we set up the GPIO and PC beep
1044 */
1045
1046 u16 v;
1047
1048 /* MIC */
1049 codec->codec_write(codec, 0x64, 0x3000);
1050 v = codec->codec_read(codec, 0x64);
1051 v &= ~0x8000;
1052 codec->codec_write(codec, 0x64, v);
1053 codec->codec_write(codec, 0x70, 0x0100);
1054 codec->codec_write(codec, 0x72, 0x0020);
1055 return 0;
1056 }
1057
1058 #define AC97_WM97XX_FMIXER_VOL 0x72
1059 #define AC97_WM97XX_RMIXER_VOL 0x74
1060 #define AC97_WM97XX_TEST 0x5a
1061 #define AC97_WM9704_RPCM_VOL 0x70
1062 #define AC97_WM9711_OUT3VOL 0x16
1063
1064 static int wolfson_init03(struct ac97_codec * codec)
1065 {
1066 /* this is known to work for the ViewSonic ViewPad 1000 */
1067 codec->codec_write(codec, AC97_WM97XX_FMIXER_VOL, 0x0808);
1068 codec->codec_write(codec, AC97_GENERAL_PURPOSE, 0x8000);
1069 return 0;
1070 }
1071
1072 static int wolfson_init04(struct ac97_codec * codec)
1073 {
1074 codec->codec_write(codec, AC97_WM97XX_FMIXER_VOL, 0x0808);
1075 codec->codec_write(codec, AC97_WM97XX_RMIXER_VOL, 0x0808);
1076
1077 // patch for DVD noise
1078 codec->codec_write(codec, AC97_WM97XX_TEST, 0x0200);
1079
1080 // init vol as PCM vol
1081 codec->codec_write(codec, AC97_WM9704_RPCM_VOL,
1082 codec->codec_read(codec, AC97_PCMOUT_VOL));
1083
1084 /* set rear surround volume */
1085 codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0000);
1086 return 0;
1087 }
1088
1089 /* WM9705, WM9710 */
1090 static int wolfson_init05(struct ac97_codec * codec)
1091 {
1092 /* set front mixer volume */
1093 codec->codec_write(codec, AC97_WM97XX_FMIXER_VOL, 0x0808);
1094 return 0;
1095 }
1096
1097 /* WM9711, WM9712 */
1098 static int wolfson_init11(struct ac97_codec * codec)
1099 {
1100 /* stop pop's during suspend/resume */
1101 codec->codec_write(codec, AC97_WM97XX_TEST,
1102 codec->codec_read(codec, AC97_WM97XX_TEST) & 0xffbf);
1103
1104 /* set out3 volume */
1105 codec->codec_write(codec, AC97_WM9711_OUT3VOL, 0x0808);
1106 return 0;
1107 }
1108
1109 /* WM9713 */
1110 static int wolfson_init13(struct ac97_codec * codec)
1111 {
1112 codec->codec_write(codec, AC97_RECORD_GAIN, 0x00a0);
1113 codec->codec_write(codec, AC97_POWER_CONTROL, 0x0000);
1114 codec->codec_write(codec, AC97_EXTENDED_MODEM_ID, 0xDA00);
1115 codec->codec_write(codec, AC97_EXTEND_MODEM_STAT, 0x3810);
1116 codec->codec_write(codec, AC97_PHONE_VOL, 0x0808);
1117 codec->codec_write(codec, AC97_PCBEEP_VOL, 0x0808);
1118
1119 return 0;
1120 }
1121
1122 static int tritech_init(struct ac97_codec * codec)
1123 {
1124 codec->codec_write(codec, 0x26, 0x0300);
1125 codec->codec_write(codec, 0x26, 0x0000);
1126 codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0000);
1127 codec->codec_write(codec, AC97_RESERVED_3A, 0x0000);
1128 return 0;
1129 }
1130
1131
1132 /* copied from drivers/sound/maestro.c */
1133 static int tritech_maestro_init(struct ac97_codec * codec)
1134 {
1135 /* no idea what this does */
1136 codec->codec_write(codec, 0x2A, 0x0001);
1137 codec->codec_write(codec, 0x2C, 0x0000);
1138 codec->codec_write(codec, 0x2C, 0XFFFF);
1139 return 0;
1140 }
1141
1142
1143
1144 /*
1145 * Presario700 workaround
1146 * for Jack Sense/SPDIF Register mis-setting causing
1147 * no audible output
1148 * by Santiago Nullo 04/05/2002
1149 */
1150
1151 #define AC97_AD1886_JACK_SENSE 0x72
1152
1153 static int ad1886_init(struct ac97_codec * codec)
1154 {
1155 /* from AD1886 Specs */
1156 codec->codec_write(codec, AC97_AD1886_JACK_SENSE, 0x0010);
1157 return 0;
1158 }
1159
1160
1161
1162
1163 /*
1164 * This is basically standard AC97. It should work as a default for
1165 * almost all modern codecs. Note that some cards wire EAPD *backwards*
1166 * That side of it is up to the card driver not us to cope with.
1167 *
1168 */
1169
1170 static int eapd_control(struct ac97_codec * codec, int on)
1171 {
1172 if(on)
1173 codec->codec_write(codec, AC97_POWER_CONTROL,
1174 codec->codec_read(codec, AC97_POWER_CONTROL)|0x8000);
1175 else
1176 codec->codec_write(codec, AC97_POWER_CONTROL,
1177 codec->codec_read(codec, AC97_POWER_CONTROL)&~0x8000);
1178 return 0;
1179 }
1180
1181 static int generic_digital_control(struct ac97_codec *codec, int slots, int rate, int mode)
1182 {
1183 u16 reg;
1184
1185 reg = codec->codec_read(codec, AC97_SPDIF_CONTROL);
1186
1187 switch(rate)
1188 {
1189 /* Off by default */
1190 default:
1191 case 0:
1192 reg = codec->codec_read(codec, AC97_EXTENDED_STATUS);
1193 codec->codec_write(codec, AC97_EXTENDED_STATUS, (reg & ~AC97_EA_SPDIF));
1194 if(rate == 0)
1195 return 0;
1196 return -EINVAL;
1197 case 1:
1198 reg = (reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_48K;
1199 break;
1200 case 2:
1201 reg = (reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_44K;
1202 break;
1203 case 3:
1204 reg = (reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_32K;
1205 break;
1206 }
1207
1208 reg &= ~AC97_SC_CC_MASK;
1209 reg |= (mode & AUDIO_CCMASK) << 6;
1210
1211 if(mode & AUDIO_DIGITAL)
1212 reg |= 2;
1213 if(mode & AUDIO_PRO)
1214 reg |= 1;
1215 if(mode & AUDIO_DRS)
1216 reg |= 0x4000;
1217
1218 codec->codec_write(codec, AC97_SPDIF_CONTROL, reg);
1219
1220 reg = codec->codec_read(codec, AC97_EXTENDED_STATUS);
1221 reg &= (AC97_EA_SLOT_MASK);
1222 reg |= AC97_EA_VRA | AC97_EA_SPDIF | slots;
1223 codec->codec_write(codec, AC97_EXTENDED_STATUS, reg);
1224
1225 reg = codec->codec_read(codec, AC97_EXTENDED_STATUS);
1226 if(!(reg & 0x0400))
1227 {
1228 codec->codec_write(codec, AC97_EXTENDED_STATUS, reg & ~ AC97_EA_SPDIF);
1229 return -EINVAL;
1230 }
1231 return 0;
1232 }
1233
1234 /*
1235 * Crystal digital audio control (CS4299)
1236 */
1237
1238 static int crystal_digital_control(struct ac97_codec *codec, int slots, int rate, int mode)
1239 {
1240 u16 cv;
1241
1242 if(mode & AUDIO_DIGITAL)
1243 return -EINVAL;
1244
1245 switch(rate)
1246 {
1247 case 0: cv = 0x0; break; /* SPEN off */
1248 case 48000: cv = 0x8004; break; /* 48KHz digital */
1249 case 44100: cv = 0x8104; break; /* 44.1KHz digital */
1250 case 32768: /* 32Khz */
1251 default:
1252 return -EINVAL;
1253 }
1254 codec->codec_write(codec, 0x68, cv);
1255 return 0;
1256 }
1257
1258 /*
1259 * CMedia digital audio control
1260 * Needs more work.
1261 */
1262
1263 static int cmedia_digital_control(struct ac97_codec *codec, int slots, int rate, int mode)
1264 {
1265 u16 cv;
1266
1267 if(mode & AUDIO_DIGITAL)
1268 return -EINVAL;
1269
1270 switch(rate)
1271 {
1272 case 0: cv = 0x0001; break; /* SPEN off */
1273 case 48000: cv = 0x0009; break; /* 48KHz digital */
1274 default:
1275 return -EINVAL;
1276 }
1277 codec->codec_write(codec, 0x2A, 0x05c4);
1278 codec->codec_write(codec, 0x6C, cv);
1279
1280 /* Switch on mix to surround */
1281 cv = codec->codec_read(codec, 0x64);
1282 cv &= ~0x0200;
1283 if(mode)
1284 cv |= 0x0200;
1285 codec->codec_write(codec, 0x64, cv);
1286 return 0;
1287 }
1288
1289
1290 /* copied from drivers/sound/maestro.c */
1291 #if 0 /* there has been 1 person on the planet with a pt101 that we
1292 know of. If they care, they can put this back in :) */
1293 static int pt101_init(struct ac97_codec * codec)
1294 {
1295 printk(KERN_INFO "ac97_codec: PT101 Codec detected, initializing but _not_ installing mixer device.\n");
1296 /* who knows.. */
1297 codec->codec_write(codec, 0x2A, 0x0001);
1298 codec->codec_write(codec, 0x2C, 0x0000);
1299 codec->codec_write(codec, 0x2C, 0xFFFF);
1300 codec->codec_write(codec, 0x10, 0x9F1F);
1301 codec->codec_write(codec, 0x12, 0x0808);
1302 codec->codec_write(codec, 0x14, 0x9F1F);
1303 codec->codec_write(codec, 0x16, 0x9F1F);
1304 codec->codec_write(codec, 0x18, 0x0404);
1305 codec->codec_write(codec, 0x1A, 0x0000);
1306 codec->codec_write(codec, 0x1C, 0x0000);
1307 codec->codec_write(codec, 0x02, 0x0404);
1308 codec->codec_write(codec, 0x04, 0x0808);
1309 codec->codec_write(codec, 0x0C, 0x801F);
1310 codec->codec_write(codec, 0x0E, 0x801F);
1311 return 0;
1312 }
1313 #endif
1314
1315
1316 EXPORT_SYMBOL(ac97_read_proc);
1317 EXPORT_SYMBOL(ac97_probe_codec);
1318
1319 /*
1320 * AC97 library support routines
1321 */
1322
1323 /**
1324 * ac97_set_dac_rate - set codec rate adaption
1325 * @codec: ac97 code
1326 * @rate: rate in hertz
1327 *
1328 * Set the DAC rate. Assumes the codec supports VRA. The caller is
1329 * expected to have checked this little detail.
1330 */
1331
1332 unsigned int ac97_set_dac_rate(struct ac97_codec *codec, unsigned int rate)
1333 {
1334 unsigned int new_rate = rate;
1335 u32 dacp;
1336 u32 mast_vol, phone_vol, mono_vol, pcm_vol;
1337 u32 mute_vol = 0x8000; /* The mute volume? */
1338
1339 if(rate != codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE))
1340 {
1341 /* Mute several registers */
1342 mast_vol = codec->codec_read(codec, AC97_MASTER_VOL_STEREO);
1343 mono_vol = codec->codec_read(codec, AC97_MASTER_VOL_MONO);
1344 phone_vol = codec->codec_read(codec, AC97_HEADPHONE_VOL);
1345 pcm_vol = codec->codec_read(codec, AC97_PCMOUT_VOL);
1346 codec->codec_write(codec, AC97_MASTER_VOL_STEREO, mute_vol);
1347 codec->codec_write(codec, AC97_MASTER_VOL_MONO, mute_vol);
1348 codec->codec_write(codec, AC97_HEADPHONE_VOL, mute_vol);
1349 codec->codec_write(codec, AC97_PCMOUT_VOL, mute_vol);
1350
1351 /* Power down the DAC */
1352 dacp=codec->codec_read(codec, AC97_POWER_CONTROL);
1353 codec->codec_write(codec, AC97_POWER_CONTROL, dacp|0x0200);
1354 /* Load the rate and read the effective rate */
1355 codec->codec_write(codec, AC97_PCM_FRONT_DAC_RATE, rate);
1356 new_rate=codec->codec_read(codec, AC97_PCM_FRONT_DAC_RATE);
1357 /* Power it back up */
1358 codec->codec_write(codec, AC97_POWER_CONTROL, dacp);
1359
1360 /* Restore volumes */
1361 codec->codec_write(codec, AC97_MASTER_VOL_STEREO, mast_vol);
1362 codec->codec_write(codec, AC97_MASTER_VOL_MONO, mono_vol);
1363 codec->codec_write(codec, AC97_HEADPHONE_VOL, phone_vol);
1364 codec->codec_write(codec, AC97_PCMOUT_VOL, pcm_vol);
1365 }
1366 return new_rate;
1367 }
1368
1369 EXPORT_SYMBOL(ac97_set_dac_rate);
1370
1371 /**
1372 * ac97_set_adc_rate - set codec rate adaption
1373 * @codec: ac97 code
1374 * @rate: rate in hertz
1375 *
1376 * Set the ADC rate. Assumes the codec supports VRA. The caller is
1377 * expected to have checked this little detail.
1378 */
1379
1380 unsigned int ac97_set_adc_rate(struct ac97_codec *codec, unsigned int rate)
1381 {
1382 unsigned int new_rate = rate;
1383 u32 dacp;
1384
1385 if(rate != codec->codec_read(codec, AC97_PCM_LR_ADC_RATE))
1386 {
1387 /* Power down the ADC */
1388 dacp=codec->codec_read(codec, AC97_POWER_CONTROL);
1389 codec->codec_write(codec, AC97_POWER_CONTROL, dacp|0x0100);
1390 /* Load the rate and read the effective rate */
1391 codec->codec_write(codec, AC97_PCM_LR_ADC_RATE, rate);
1392 new_rate=codec->codec_read(codec, AC97_PCM_LR_ADC_RATE);
1393 /* Power it back up */
1394 codec->codec_write(codec, AC97_POWER_CONTROL, dacp);
1395 }
1396 return new_rate;
1397 }
1398
1399 EXPORT_SYMBOL(ac97_set_adc_rate);
1400
1401 int ac97_save_state(struct ac97_codec *codec)
1402 {
1403 return 0;
1404 }
1405
1406 EXPORT_SYMBOL(ac97_save_state);
1407
1408 int ac97_restore_state(struct ac97_codec *codec)
1409 {
1410 int i;
1411 unsigned int left, right, val;
1412
1413 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
1414 if (!supported_mixer(codec, i))
1415 continue;
1416
1417 val = codec->mixer_state[i];
1418 right = val >> 8;
1419 left = val & 0xff;
1420 codec->write_mixer(codec, i, left, right);
1421 }
1422 return 0;
1423 }
1424
1425 EXPORT_SYMBOL(ac97_restore_state);
1426
1427 /**
1428 * ac97_register_driver - register a codec helper
1429 * @driver: Driver handler
1430 *
1431 * Register a handler for codecs matching the codec id. The handler
1432 * attach function is called for all present codecs and will be
1433 * called when new codecs are discovered.
1434 */
1435
1436 int ac97_register_driver(struct ac97_driver *driver)
1437 {
1438 struct list_head *l;
1439 struct ac97_codec *c;
1440
1441 down(&codec_sem);
1442 INIT_LIST_HEAD(&driver->list);
1443 list_add(&driver->list, &codec_drivers);
1444
1445 list_for_each(l, &codecs)
1446 {
1447 c = list_entry(l, struct ac97_codec, list);
1448 if(c->driver != NULL || ((c->model ^ driver->codec_id) & driver->codec_mask))
1449 continue;
1450 if(driver->probe(c, driver))
1451 continue;
1452 c->driver = driver;
1453 }
1454 up(&codec_sem);
1455 return 0;
1456 }
1457
1458 EXPORT_SYMBOL_GPL(ac97_register_driver);
1459
1460 /**
1461 * ac97_unregister_driver - unregister a codec helper
1462 * @driver: Driver handler
1463 *
1464 * Unregister a handler for codecs matching the codec id. The handler
1465 * remove function is called for all matching codecs.
1466 */
1467
1468 void ac97_unregister_driver(struct ac97_driver *driver)
1469 {
1470 struct list_head *l;
1471 struct ac97_codec *c;
1472
1473 down(&codec_sem);
1474 list_del_init(&driver->list);
1475
1476 list_for_each(l, &codecs)
1477 {
1478 c = list_entry(l, struct ac97_codec, list);
1479 if (c->driver == driver) {
1480 driver->remove(c, driver);
1481 c->driver = NULL;
1482 }
1483 }
1484
1485 up(&codec_sem);
1486 }
1487
1488 EXPORT_SYMBOL_GPL(ac97_unregister_driver);
1489
1490 static int swap_headphone(int remove_master)
1491 {
1492 struct list_head *l;
1493 struct ac97_codec *c;
1494
1495 if (remove_master) {
1496 down(&codec_sem);
1497 list_for_each(l, &codecs)
1498 {
1499 c = list_entry(l, struct ac97_codec, list);
1500 if (supported_mixer(c, SOUND_MIXER_PHONEOUT))
1501 c->supported_mixers &= ~SOUND_MASK_PHONEOUT;
1502 }
1503 up(&codec_sem);
1504 } else
1505 ac97_hw[SOUND_MIXER_PHONEOUT].offset = AC97_MASTER_VOL_STEREO;
1506
1507 /* Scale values already match */
1508 ac97_hw[SOUND_MIXER_VOLUME].offset = AC97_MASTER_VOL_MONO;
1509 return 0;
1510 }
1511
1512 static int apply_quirk(int quirk)
1513 {
1514 switch (quirk) {
1515 case AC97_TUNE_NONE:
1516 return 0;
1517 case AC97_TUNE_HP_ONLY:
1518 return swap_headphone(1);
1519 case AC97_TUNE_SWAP_HP:
1520 return swap_headphone(0);
1521 case AC97_TUNE_SWAP_SURROUND:
1522 return -ENOSYS; /* not yet implemented */
1523 case AC97_TUNE_AD_SHARING:
1524 return -ENOSYS; /* not yet implemented */
1525 case AC97_TUNE_ALC_JACK:
1526 return -ENOSYS; /* not yet implemented */
1527 }
1528 return -EINVAL;
1529 }
1530
1531 /**
1532 * ac97_tune_hardware - tune up the hardware
1533 * @pdev: pci_dev pointer
1534 * @quirk: quirk list
1535 * @override: explicit quirk value (overrides if not AC97_TUNE_DEFAULT)
1536 *
1537 * Do some workaround for each pci device, such as renaming of the
1538 * headphone (true line-out) control as "Master".
1539 * The quirk-list must be terminated with a zero-filled entry.
1540 *
1541 * Returns zero if successful, or a negative error code on failure.
1542 */
1543
1544 int ac97_tune_hardware(struct pci_dev *pdev, struct ac97_quirk *quirk, int override)
1545 {
1546 int result;
1547
1548 if (!quirk)
1549 return -EINVAL;
1550
1551 if (override != AC97_TUNE_DEFAULT) {
1552 result = apply_quirk(override);
1553 if (result < 0)
1554 printk(KERN_ERR "applying quirk type %d failed (%d)\n", override, result);
1555 return result;
1556 }
1557
1558 for (; quirk->vendor; quirk++) {
1559 if (quirk->vendor != pdev->subsystem_vendor)
1560 continue;
1561 if ((! quirk->mask && quirk->device == pdev->subsystem_device) ||
1562 quirk->device == (quirk->mask & pdev->subsystem_device)) {
1563 #ifdef DEBUG
1564 printk("ac97 quirk for %s (%04x:%04x)\n", quirk->name, ac97->subsystem_vendor, pdev->subsystem_device);
1565 #endif
1566 result = apply_quirk(quirk->type);
1567 if (result < 0)
1568 printk(KERN_ERR "applying quirk type %d for %s failed (%d)\n", quirk->type, quirk->name, result);
1569 return result;
1570 }
1571 }
1572 return 0;
1573 }
1574
1575 EXPORT_SYMBOL_GPL(ac97_tune_hardware);
1576
1577 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree