File: /usr/src/linux/drivers/sound/ac97.c
1 #include <linux/module.h>
2 #include <linux/kernel.h>
3 #include <linux/init.h>
4 #include "ac97.h"
5
6 /* Flag for mono controls. */
7 #define MO 0
8 /* And for stereo. */
9 #define ST 1
10
11 /* Whether or not the bits in the channel are inverted. */
12 #define INV 1
13 #define NINV 0
14
15 static struct ac97_chn_desc {
16 int ac97_regnum;
17 int oss_channel;
18 int maxval;
19 int is_stereo;
20 int oss_mask;
21 int recordNum;
22 u16 regmask;
23 int is_inverted;
24 } mixerRegs[] = {
25 { AC97_MASTER_VOL_STEREO, SOUND_MIXER_VOLUME, 0x3f, ST, SOUND_MASK_VOLUME, 5, 0x0000, INV },
26 { AC97_MASTER_VOL_MONO, SOUND_MIXER_PHONEOUT, 0x3f, MO, SOUND_MASK_PHONEOUT, 6, 0x0000, INV },
27 { AC97_MASTER_TONE, SOUND_MIXER_TREBLE, 0x0f, MO, SOUND_MASK_TREBLE, -1, 0x00ff, INV },
28 { AC97_MASTER_TONE, SOUND_MIXER_BASS, 0x0f, MO, SOUND_MASK_BASS, -1, 0xff00, INV },
29 { AC97_PCBEEP_VOL, SOUND_MIXER_SPEAKER, 0x0f, MO, SOUND_MASK_SPEAKER, -1, 0x001e, INV },
30 { AC97_PHONE_VOL, SOUND_MIXER_PHONEIN, 0x1f, MO, SOUND_MASK_PHONEIN, 7, 0x0000, INV },
31 { AC97_MIC_VOL, SOUND_MIXER_MIC, 0x1f, MO, SOUND_MASK_MIC, 0, 0x0000, INV },
32 { AC97_LINEIN_VOL, SOUND_MIXER_LINE, 0x1f, ST, SOUND_MASK_LINE, 4, 0x0000, INV },
33 { AC97_CD_VOL, SOUND_MIXER_CD, 0x1f, ST, SOUND_MASK_CD, 1, 0x0000, INV },
34 { AC97_VIDEO_VOL, SOUND_MIXER_VIDEO, 0x1f, ST, SOUND_MASK_VIDEO, 2, 0x0000, INV },
35 { AC97_AUX_VOL, SOUND_MIXER_LINE1, 0x1f, ST, SOUND_MASK_LINE1, 3, 0x0000, INV },
36 { AC97_PCMOUT_VOL, SOUND_MIXER_PCM, 0x1f, ST, SOUND_MASK_PCM, -1, 0x0000, INV },
37 { AC97_RECORD_GAIN, SOUND_MIXER_IGAIN, 0x0f, ST, SOUND_MASK_IGAIN, -1, 0x0000, NINV },
38 { -1, -1, 0xff, 0, 0, -1, 0x0000, 0 },
39 };
40
41 static struct ac97_chn_desc *
42 ac97_find_chndesc (struct ac97_hwint *dev, int oss_channel)
43 {
44 int x;
45
46 for (x = 0; mixerRegs[x].oss_channel != -1; x++) {
47 if (mixerRegs[x].oss_channel == oss_channel)
48 return mixerRegs + x;
49 }
50
51 return NULL;
52 }
53
54 static inline int
55 ac97_is_valid_channel (struct ac97_hwint *dev, struct ac97_chn_desc *chn)
56 {
57 return (dev->last_written_mixer_values[chn->ac97_regnum / 2]
58 != AC97_REG_UNSUPPORTED);
59 }
60
61 int
62 ac97_init (struct ac97_hwint *dev)
63 {
64 int x;
65 int reg0;
66
67 /* Clear out the arrays of cached values. */
68 for (x = 0; x < AC97_REG_CNT; x++)
69 dev->last_written_mixer_values[x] = AC97_REGVAL_UNKNOWN;
70
71 for (x = 0; x < SOUND_MIXER_NRDEVICES; x++)
72 dev->last_written_OSS_values[x] = AC97_REGVAL_UNKNOWN;
73
74 /* Clear the device masks. */
75 dev->mixer_devmask = 0;
76 dev->mixer_stereomask = 0;
77 dev->mixer_recmask = 0;
78
79 /* ??? Do a "standard reset" via register 0? */
80
81 /* Hardware-dependent reset. */
82 if (dev->reset_device (dev))
83 return -1;
84
85 /* Check the mixer device capabilities. */
86 reg0 = dev->read_reg (dev, AC97_RESET);
87
88 if (reg0 < 0)
89 return -1;
90
91 /* Check for support for treble/bass controls. */
92 if (! (reg0 & 4)) {
93 dev->last_written_mixer_values[AC97_MASTER_TONE / 2]
94 = AC97_REG_UNSUPPORTED;
95 }
96
97 /* ??? There may be other tests here? */
98
99 /* Fill in the device masks. */
100 for (x = 0; mixerRegs[x].ac97_regnum != -1; x++) {
101 if (ac97_is_valid_channel (dev, mixerRegs + x)) {
102 dev->mixer_devmask |= mixerRegs[x].oss_mask;
103
104 if (mixerRegs[x].is_stereo)
105 dev->mixer_stereomask |= mixerRegs[x].oss_mask;
106
107 if (mixerRegs[x].recordNum != -1)
108 dev->mixer_recmask |= mixerRegs[x].oss_mask;
109 }
110 }
111
112 return 0;
113 }
114
115 /* Reset the mixer to the currently saved settings. */
116 int
117 ac97_reset (struct ac97_hwint *dev)
118 {
119 int x;
120
121 if (dev->reset_device (dev))
122 return -1;
123
124 /* Now set the registers back to their last-written values. */
125 for (x = 0; mixerRegs[x].ac97_regnum != -1; x++) {
126 int regnum = mixerRegs[x].ac97_regnum;
127 int value = dev->last_written_mixer_values [regnum / 2];
128 if (value >= 0)
129 ac97_put_register (dev, regnum, value);
130 }
131 return 0;
132 }
133
134 /* Return the contents of register REG; use the cache if the value in it
135 is valid. Returns a negative error code on failure. */
136 int
137 ac97_get_register (struct ac97_hwint *dev, u8 reg)
138 {
139 if (reg > 127 || (reg & 1))
140 return -EINVAL;
141
142 /* See if it's in the cache, or if it's just plain invalid. */
143 switch (dev->last_written_mixer_values[reg / 2]) {
144 case AC97_REG_UNSUPPORTED:
145 return -EINVAL;
146 break;
147 case AC97_REGVAL_UNKNOWN:
148 dev->last_written_mixer_values[reg / 2] = dev->read_reg (dev, reg);
149 break;
150 default:
151 break;
152 }
153 return dev->last_written_mixer_values[reg / 2];
154 }
155
156 /* Write VALUE to AC97 register REG, and cache its value in the last-written
157 cache. Returns a negative error code on failure, or 0 on success. */
158 int
159 ac97_put_register (struct ac97_hwint *dev, u8 reg, u16 value)
160 {
161 if (reg > 127 || (reg & 1))
162 return -EINVAL;
163
164 if (dev->last_written_mixer_values[reg / 2] == AC97_REG_UNSUPPORTED)
165 return -EINVAL;
166 else {
167 int res = dev->write_reg (dev, reg, value);
168 if (res >= 0) {
169 dev->last_written_mixer_values[reg / 2] = value;
170 return 0;
171 }
172 else
173 return res;
174 }
175 }
176
177 /* Scale VALUE (a value fro 0 to MAXVAL) to a value from 0-100. If
178 IS_STEREO is set, VALUE is a stereo value; the left channel value
179 is in the lower 8 bits, and the right channel value is in the upper
180 8 bits.
181
182 A negative error code is returned on failure, or the unsigned
183 scaled value on success. */
184
185 static int
186 ac97_scale_to_oss_val (int value, int maxval, int is_stereo, int inv)
187 {
188 /* Muted? */
189 if (value & AC97_MUTE)
190 return 0;
191
192 if (is_stereo)
193 return (ac97_scale_to_oss_val (value & 255, maxval, 0, inv) << 8)
194 | (ac97_scale_to_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0);
195 else {
196 int i;
197
198 /* Inverted. */
199 if (inv)
200 value = maxval - value;
201
202 i = (value * 100 + (maxval / 2)) / maxval;
203 if (i > 100)
204 i = 100;
205 if (i < 0)
206 i = 0;
207 return i;
208 }
209 }
210
211 static int
212 ac97_scale_from_oss_val (int value, int maxval, int is_stereo, int inv)
213 {
214 if (is_stereo)
215 return (ac97_scale_from_oss_val (value & 255, maxval, 0, inv) << 8)
216 | (ac97_scale_from_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0);
217 else {
218 int i = ((value & 255) * maxval + 50) / 100;
219 if (inv)
220 i = maxval - i;
221 if (i < 0)
222 i = 0;
223 if (i > maxval)
224 i = maxval;
225 return i;
226 }
227 }
228
229 int
230 ac97_set_mixer (struct ac97_hwint *dev, int oss_channel, u16 oss_value)
231 {
232 int scaled_value;
233 struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel);
234 int result;
235
236 if (channel == NULL)
237 return -ENODEV;
238 if (! ac97_is_valid_channel (dev, channel))
239 return -ENODEV;
240 scaled_value = ac97_scale_from_oss_val (oss_value, channel->maxval,
241 channel->is_stereo,
242 channel->is_inverted);
243 if (scaled_value < 0)
244 return scaled_value;
245
246 if (channel->regmask != 0) {
247 int mv;
248
249 int oldval = ac97_get_register (dev, channel->ac97_regnum);
250 if (oldval < 0)
251 return oldval;
252
253 for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
254 scaled_value <<= 1;
255
256 scaled_value &= channel->regmask;
257 scaled_value |= (oldval & ~channel->regmask);
258 }
259 result = ac97_put_register (dev, channel->ac97_regnum, scaled_value);
260 if (result == 0)
261 dev->last_written_OSS_values[oss_channel] = oss_value;
262 return result;
263 }
264
265 int
266 ac97_get_mixer_scaled (struct ac97_hwint *dev, int oss_channel)
267 {
268 struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel);
269 int regval;
270
271 if (channel == NULL)
272 return -ENODEV;
273
274 if (! ac97_is_valid_channel (dev, channel))
275 return -ENODEV;
276
277 regval = ac97_get_register (dev, channel->ac97_regnum);
278
279 if (regval < 0)
280 return regval;
281
282 if (channel->regmask != 0) {
283 int mv;
284
285 regval &= channel->regmask;
286
287 for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
288 regval >>= 1;
289 }
290 return ac97_scale_to_oss_val (regval, channel->maxval,
291 channel->is_stereo,
292 channel->is_inverted);
293 }
294
295 int
296 ac97_get_recmask (struct ac97_hwint *dev)
297 {
298 int recReg = ac97_get_register (dev, AC97_RECORD_SELECT);
299
300 if (recReg < 0)
301 return recReg;
302 else {
303 int x;
304 for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) {
305 if (mixerRegs[x].recordNum == (recReg & 7))
306 return mixerRegs[x].oss_mask;
307 }
308 return -ENODEV;
309 }
310 }
311
312 int
313 ac97_set_recmask (struct ac97_hwint *dev, int oss_recmask)
314 {
315 int x;
316
317 if (oss_recmask == 0)
318 oss_recmask = SOUND_MIXER_MIC;
319
320 for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) {
321 if ((mixerRegs[x].recordNum >= 0)
322 && (oss_recmask & mixerRegs[x].oss_mask))
323 break;
324 }
325 if (mixerRegs[x].ac97_regnum < 0)
326 return -ENODEV;
327 else {
328 int regval = (mixerRegs[x].recordNum << 8) | mixerRegs[x].recordNum;
329 int res = ac97_put_register (dev, AC97_RECORD_SELECT, regval);
330 if (res == 0)
331 return ac97_get_recmask (dev);
332 else
333 return res;
334 }
335 }
336
337 /* Set the mixer DEV to the list of values in VALUE_LIST. Return 0 on
338 success, or a negative error code. */
339 int
340 ac97_set_values (struct ac97_hwint *dev,
341 struct ac97_mixer_value_list *value_list)
342 {
343 int x;
344
345 for (x = 0; value_list[x].oss_channel != -1; x++) {
346 int chnum = value_list[x].oss_channel;
347 struct ac97_chn_desc *chent = ac97_find_chndesc (dev, chnum);
348 if (chent != NULL) {
349 u16 val;
350 int res;
351
352 if (chent->is_stereo)
353 val = (value_list[x].value.stereo.right << 8)
354 | value_list[x].value.stereo.left;
355 else {
356 /* We do this so the returned value looks OK in the
357 mixer app. It's not necessary otherwise. */
358 val = (value_list[x].value.mono << 8)
359 | value_list[x].value.mono;
360 }
361 res = ac97_set_mixer (dev, chnum, val);
362 if (res < 0)
363 return res;
364 }
365 else
366 return -ENODEV;
367 }
368 return 0;
369 }
370
371 int
372 ac97_mixer_ioctl (struct ac97_hwint *dev, unsigned int cmd, caddr_t arg)
373 {
374 int ret;
375
376 switch (cmd) {
377 case SOUND_MIXER_READ_RECSRC:
378 ret = ac97_get_recmask (dev);
379 break;
380
381 case SOUND_MIXER_WRITE_RECSRC:
382 {
383 if (get_user (ret, (int *) arg))
384 ret = -EFAULT;
385 else
386 ret = ac97_set_recmask (dev, ret);
387 }
388 break;
389
390 case SOUND_MIXER_READ_CAPS:
391 ret = SOUND_CAP_EXCL_INPUT;
392 break;
393
394 case SOUND_MIXER_READ_DEVMASK:
395 ret = dev->mixer_devmask;
396 break;
397
398 case SOUND_MIXER_READ_RECMASK:
399 ret = dev->mixer_recmask;
400 break;
401
402 case SOUND_MIXER_READ_STEREODEVS:
403 ret = dev->mixer_stereomask;
404 break;
405
406 default:
407 /* Read or write request. */
408 ret = -EINVAL;
409 if (_IOC_TYPE (cmd) == 'M') {
410 int dir = _SIOC_DIR (cmd);
411 int channel = _IOC_NR (cmd);
412
413 if (channel >= 0 && channel < SOUND_MIXER_NRDEVICES) {
414 ret = 0;
415 if (dir & _SIOC_WRITE) {
416 int val;
417 if (get_user (val, (int *) arg) == 0)
418 ret = ac97_set_mixer (dev, channel, val);
419 else
420 ret = -EFAULT;
421 }
422 if (ret >= 0 && (dir & _SIOC_READ)) {
423 if (dev->last_written_OSS_values[channel]
424 == AC97_REGVAL_UNKNOWN)
425 dev->last_written_OSS_values[channel]
426 = ac97_get_mixer_scaled (dev, channel);
427 ret = dev->last_written_OSS_values[channel];
428 }
429 }
430 }
431 break;
432 }
433
434 if (ret < 0)
435 return ret;
436 else
437 return put_user(ret, (int *) arg);
438 }
439
440 EXPORT_SYMBOL(ac97_init);
441 EXPORT_SYMBOL(ac97_set_values);
442 EXPORT_SYMBOL(ac97_set_mixer);
443 EXPORT_SYMBOL(ac97_get_register);
444 EXPORT_SYMBOL(ac97_put_register);
445 EXPORT_SYMBOL(ac97_get_mixer_scaled);
446 EXPORT_SYMBOL(ac97_mixer_ioctl);
447 EXPORT_SYMBOL(ac97_reset);
448
449 /*
450 * Local variables:
451 * c-basic-offset: 4
452 * End:
453 */
454