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