?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
asus-laptop: Add support for P30/P35
[linux-2.6/mini2440.git] / sound / oss / sb_mixer.c
blobfad1a4f25ad6db0402de24f24f0c21e1be301c54
1 /*
2 * sound/oss/sb_mixer.c
3 *
4 * The low level mixer driver for the Sound Blaster compatible cards.
5 */
6 /*
7 * Copyright (C) by Hannu Savolainen 1993-1997
8 *
9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
11 * for more info.
12 *
13 *
14 * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
15 * Rolf Fokkens (Dec 20 1998) : Moved ESS stuff into sb_ess.[ch]
16 * Stanislav Voronyi <stas@esc.kharkov.com> : Support for AWE 3DSE device (Jun 7 1999)
17 */
18
19 #include "sound_config.h"
20
21 #define __SB_MIXER_C__
22
23 #include "sb.h"
24 #include "sb_mixer.h"
25
26 #include "sb_ess.h"
27
28 #define SBPRO_RECORDING_DEVICES (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD)
29
30 /* Same as SB Pro, unless I find otherwise */
31 #define SGNXPRO_RECORDING_DEVICES SBPRO_RECORDING_DEVICES
32
33 #define SBPRO_MIXER_DEVICES (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE | SOUND_MASK_MIC | \
34 SOUND_MASK_CD | SOUND_MASK_VOLUME)
35
36 /* SG NX Pro has treble and bass settings on the mixer. The 'speaker'
37 * channel is the COVOX/DisneySoundSource emulation volume control
38 * on the mixer. It does NOT control speaker volume. Should have own
39 * mask eventually?
40 */
41 #define SGNXPRO_MIXER_DEVICES (SBPRO_MIXER_DEVICES|SOUND_MASK_BASS| \
42 SOUND_MASK_TREBLE|SOUND_MASK_SPEAKER )
43
44 #define SB16_RECORDING_DEVICES (SOUND_MASK_SYNTH | SOUND_MASK_LINE | SOUND_MASK_MIC | \
45 SOUND_MASK_CD)
46
47 #define SB16_OUTFILTER_DEVICES (SOUND_MASK_LINE | SOUND_MASK_MIC | \
48 SOUND_MASK_CD)
49
50 #define SB16_MIXER_DEVICES (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | SOUND_MASK_LINE | SOUND_MASK_MIC | \
51 SOUND_MASK_CD | \
52 SOUND_MASK_IGAIN | SOUND_MASK_OGAIN | \
53 SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE | \
54 SOUND_MASK_IMIX)
55
56 /* These are the only devices that are working at the moment. Others could
57 * be added once they are identified and a method is found to control them.
58 */
59 #define ALS007_MIXER_DEVICES (SOUND_MASK_SYNTH | SOUND_MASK_LINE | \
60 SOUND_MASK_PCM | SOUND_MASK_MIC | \
61 SOUND_MASK_CD | \
62 SOUND_MASK_VOLUME)
63
64 static mixer_tab sbpro_mix = {
65 MIX_ENT(SOUND_MIXER_VOLUME, 0x22, 7, 4, 0x22, 3, 4),
66 MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
67 MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
68 MIX_ENT(SOUND_MIXER_SYNTH, 0x26, 7, 4, 0x26, 3, 4),
69 MIX_ENT(SOUND_MIXER_PCM, 0x04, 7, 4, 0x04, 3, 4),
70 MIX_ENT(SOUND_MIXER_SPEAKER, 0x00, 0, 0, 0x00, 0, 0),
71 MIX_ENT(SOUND_MIXER_LINE, 0x2e, 7, 4, 0x2e, 3, 4),
72 MIX_ENT(SOUND_MIXER_MIC, 0x0a, 2, 3, 0x00, 0, 0),
73 MIX_ENT(SOUND_MIXER_CD, 0x28, 7, 4, 0x28, 3, 4),
74 MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
75 MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
76 MIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0)
77 };
78
79 static mixer_tab sb16_mix = {
80 MIX_ENT(SOUND_MIXER_VOLUME, 0x30, 7, 5, 0x31, 7, 5),
81 MIX_ENT(SOUND_MIXER_BASS, 0x46, 7, 4, 0x47, 7, 4),
82 MIX_ENT(SOUND_MIXER_TREBLE, 0x44, 7, 4, 0x45, 7, 4),
83 MIX_ENT(SOUND_MIXER_SYNTH, 0x34, 7, 5, 0x35, 7, 5),
84 MIX_ENT(SOUND_MIXER_PCM, 0x32, 7, 5, 0x33, 7, 5),
85 MIX_ENT(SOUND_MIXER_SPEAKER, 0x3b, 7, 2, 0x00, 0, 0),
86 MIX_ENT(SOUND_MIXER_LINE, 0x38, 7, 5, 0x39, 7, 5),
87 MIX_ENT(SOUND_MIXER_MIC, 0x3a, 7, 5, 0x00, 0, 0),
88 MIX_ENT(SOUND_MIXER_CD, 0x36, 7, 5, 0x37, 7, 5),
89 MIX_ENT(SOUND_MIXER_IMIX, 0x3c, 0, 1, 0x00, 0, 0),
90 MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
91 MIX_ENT(SOUND_MIXER_RECLEV, 0x3f, 7, 2, 0x40, 7, 2), /* Obsolete. Use IGAIN */
92 MIX_ENT(SOUND_MIXER_IGAIN, 0x3f, 7, 2, 0x40, 7, 2),
93 MIX_ENT(SOUND_MIXER_OGAIN, 0x41, 7, 2, 0x42, 7, 2)
94 };
95
96 static mixer_tab als007_mix =
97 {
98 MIX_ENT(SOUND_MIXER_VOLUME, 0x62, 7, 4, 0x62, 3, 4),
99 MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
100 MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
101 MIX_ENT(SOUND_MIXER_SYNTH, 0x66, 7, 4, 0x66, 3, 4),
102 MIX_ENT(SOUND_MIXER_PCM, 0x64, 7, 4, 0x64, 3, 4),
103 MIX_ENT(SOUND_MIXER_SPEAKER, 0x00, 0, 0, 0x00, 0, 0),
104 MIX_ENT(SOUND_MIXER_LINE, 0x6e, 7, 4, 0x6e, 3, 4),
105 MIX_ENT(SOUND_MIXER_MIC, 0x6a, 2, 3, 0x00, 0, 0),
106 MIX_ENT(SOUND_MIXER_CD, 0x68, 7, 4, 0x68, 3, 4),
107 MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
108 MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
109 MIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0), /* Obsolete. Use IGAIN */
110 MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
111 MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0)
112 };
113
114
115 /* SM_GAMES Master volume is lower and PCM & FM volumes
116 higher than with SB Pro. This improves the
117 sound quality */
118
119 static int smg_default_levels[32] =
120 {
121 0x2020, /* Master Volume */
122 0x4b4b, /* Bass */
123 0x4b4b, /* Treble */
124 0x6464, /* FM */
125 0x6464, /* PCM */
126 0x4b4b, /* PC Speaker */
127 0x4b4b, /* Ext Line */
128 0x0000, /* Mic */
129 0x4b4b, /* CD */
130 0x4b4b, /* Recording monitor */
131 0x4b4b, /* SB PCM */
132 0x4b4b, /* Recording level */
133 0x4b4b, /* Input gain */
134 0x4b4b, /* Output gain */
135 0x4040, /* Line1 */
136 0x4040, /* Line2 */
137 0x1515 /* Line3 */
138 };
139
140 static int sb_default_levels[32] =
141 {
142 0x5a5a, /* Master Volume */
143 0x4b4b, /* Bass */
144 0x4b4b, /* Treble */
145 0x4b4b, /* FM */
146 0x4b4b, /* PCM */
147 0x4b4b, /* PC Speaker */
148 0x4b4b, /* Ext Line */
149 0x1010, /* Mic */
150 0x4b4b, /* CD */
151 0x0000, /* Recording monitor */
152 0x4b4b, /* SB PCM */
153 0x4b4b, /* Recording level */
154 0x4b4b, /* Input gain */
155 0x4b4b, /* Output gain */
156 0x4040, /* Line1 */
157 0x4040, /* Line2 */
158 0x1515 /* Line3 */
159 };
160
161 static unsigned char sb16_recmasks_L[SOUND_MIXER_NRDEVICES] =
162 {
163 0x00, /* SOUND_MIXER_VOLUME */
164 0x00, /* SOUND_MIXER_BASS */
165 0x00, /* SOUND_MIXER_TREBLE */
166 0x40, /* SOUND_MIXER_SYNTH */
167 0x00, /* SOUND_MIXER_PCM */
168 0x00, /* SOUND_MIXER_SPEAKER */
169 0x10, /* SOUND_MIXER_LINE */
170 0x01, /* SOUND_MIXER_MIC */
171 0x04, /* SOUND_MIXER_CD */
172 0x00, /* SOUND_MIXER_IMIX */
173 0x00, /* SOUND_MIXER_ALTPCM */
174 0x00, /* SOUND_MIXER_RECLEV */
175 0x00, /* SOUND_MIXER_IGAIN */
176 0x00 /* SOUND_MIXER_OGAIN */
177 };
178
179 static unsigned char sb16_recmasks_R[SOUND_MIXER_NRDEVICES] =
180 {
181 0x00, /* SOUND_MIXER_VOLUME */
182 0x00, /* SOUND_MIXER_BASS */
183 0x00, /* SOUND_MIXER_TREBLE */
184 0x20, /* SOUND_MIXER_SYNTH */
185 0x00, /* SOUND_MIXER_PCM */
186 0x00, /* SOUND_MIXER_SPEAKER */
187 0x08, /* SOUND_MIXER_LINE */
188 0x01, /* SOUND_MIXER_MIC */
189 0x02, /* SOUND_MIXER_CD */
190 0x00, /* SOUND_MIXER_IMIX */
191 0x00, /* SOUND_MIXER_ALTPCM */
192 0x00, /* SOUND_MIXER_RECLEV */
193 0x00, /* SOUND_MIXER_IGAIN */
194 0x00 /* SOUND_MIXER_OGAIN */
195 };
196
197 static char smw_mix_regs[] = /* Left mixer registers */
198 {
199 0x0b, /* SOUND_MIXER_VOLUME */
200 0x0d, /* SOUND_MIXER_BASS */
201 0x0d, /* SOUND_MIXER_TREBLE */
202 0x05, /* SOUND_MIXER_SYNTH */
203 0x09, /* SOUND_MIXER_PCM */
204 0x00, /* SOUND_MIXER_SPEAKER */
205 0x03, /* SOUND_MIXER_LINE */
206 0x01, /* SOUND_MIXER_MIC */
207 0x07, /* SOUND_MIXER_CD */
208 0x00, /* SOUND_MIXER_IMIX */
209 0x00, /* SOUND_MIXER_ALTPCM */
210 0x00, /* SOUND_MIXER_RECLEV */
211 0x00, /* SOUND_MIXER_IGAIN */
212 0x00, /* SOUND_MIXER_OGAIN */
213 0x00, /* SOUND_MIXER_LINE1 */
214 0x00, /* SOUND_MIXER_LINE2 */
215 0x00 /* SOUND_MIXER_LINE3 */
216 };
217
218 static int sbmixnum = 1;
219
220 static void sb_mixer_reset(sb_devc * devc);
221
222 void sb_mixer_set_stereo(sb_devc * devc, int mode)
223 {
224 sb_chgmixer(devc, OUT_FILTER, STEREO_DAC, (mode ? STEREO_DAC : MONO_DAC));
225 }
226
227 static int detect_mixer(sb_devc * devc)
228 {
229 /* Just trust the mixer is there */
230 return 1;
231 }
232
233 static void change_bits(sb_devc * devc, unsigned char *regval, int dev, int chn, int newval)
234 {
235 unsigned char mask;
236 int shift;
237
238 mask = (1 << (*devc->iomap)[dev][chn].nbits) - 1;
239 newval = (int) ((newval * mask) + 50) / 100; /* Scale */
240
241 shift = (*devc->iomap)[dev][chn].bitoffs - (*devc->iomap)[dev][LEFT_CHN].nbits + 1;
242
243 *regval &= ~(mask << shift); /* Mask out previous value */
244 *regval |= (newval & mask) << shift; /* Set the new value */
245 }
246
247 static int sb_mixer_get(sb_devc * devc, int dev)
248 {
249 if (!((1 << dev) & devc->supported_devices))
250 return -EINVAL;
251 return devc->levels[dev];
252 }
253
254 void smw_mixer_init(sb_devc * devc)
255 {
256 int i;
257
258 sb_setmixer(devc, 0x00, 0x18); /* Mute unused (Telephone) line */
259 sb_setmixer(devc, 0x10, 0x38); /* Config register 2 */
260
261 devc->supported_devices = 0;
262 for (i = 0; i < sizeof(smw_mix_regs); i++)
263 if (smw_mix_regs[i] != 0)
264 devc->supported_devices |= (1 << i);
265
266 devc->supported_rec_devices = devc->supported_devices &
267 ~(SOUND_MASK_BASS | SOUND_MASK_TREBLE | SOUND_MASK_PCM | SOUND_MASK_VOLUME);
268 sb_mixer_reset(devc);
269 }
270
271 int sb_common_mixer_set(sb_devc * devc, int dev, int left, int right)
272 {
273 int regoffs;
274 unsigned char val;
275
276 if ((dev < 0) || (dev >= devc->iomap_sz))
277 return -EINVAL;
278
279 regoffs = (*devc->iomap)[dev][LEFT_CHN].regno;
280
281 if (regoffs == 0)
282 return -EINVAL;
283
284 val = sb_getmixer(devc, regoffs);
285 change_bits(devc, &val, dev, LEFT_CHN, left);
286
287 if ((*devc->iomap)[dev][RIGHT_CHN].regno != regoffs) /*
288 * Change register
289 */
290 {
291 sb_setmixer(devc, regoffs, val); /*
292 * Save the old one
293 */
294 regoffs = (*devc->iomap)[dev][RIGHT_CHN].regno;
295
296 if (regoffs == 0)
297 return left | (left << 8); /*
298 * Just left channel present
299 */
300
301 val = sb_getmixer(devc, regoffs); /*
302 * Read the new one
303 */
304 }
305 change_bits(devc, &val, dev, RIGHT_CHN, right);
306
307 sb_setmixer(devc, regoffs, val);
308
309 return left | (right << 8);
310 }
311
312 static int smw_mixer_set(sb_devc * devc, int dev, int left, int right)
313 {
314 int reg, val;
315
316 switch (dev)
317 {
318 case SOUND_MIXER_VOLUME:
319 sb_setmixer(devc, 0x0b, 96 - (96 * left / 100)); /* 96=mute, 0=max */
320 sb_setmixer(devc, 0x0c, 96 - (96 * right / 100));
321 break;
322
323 case SOUND_MIXER_BASS:
324 case SOUND_MIXER_TREBLE:
325 devc->levels[dev] = left | (right << 8);
326 /* Set left bass and treble values */
327 val = ((devc->levels[SOUND_MIXER_TREBLE] & 0xff) * 16 / (unsigned) 100) << 4;
328 val |= ((devc->levels[SOUND_MIXER_BASS] & 0xff) * 16 / (unsigned) 100) & 0x0f;
329 sb_setmixer(devc, 0x0d, val);
330
331 /* Set right bass and treble values */
332 val = (((devc->levels[SOUND_MIXER_TREBLE] >> 8) & 0xff) * 16 / (unsigned) 100) << 4;
333 val |= (((devc->levels[SOUND_MIXER_BASS] >> 8) & 0xff) * 16 / (unsigned) 100) & 0x0f;
334 sb_setmixer(devc, 0x0e, val);
335
336 break;
337
338 default:
339 /* bounds check */
340 if (dev < 0 || dev >= ARRAY_SIZE(smw_mix_regs))
341 return -EINVAL;
342 reg = smw_mix_regs[dev];
343 if (reg == 0)
344 return -EINVAL;
345 sb_setmixer(devc, reg, (24 - (24 * left / 100)) | 0x20); /* 24=mute, 0=max */
346 sb_setmixer(devc, reg + 1, (24 - (24 * right / 100)) | 0x40);
347 }
348
349 devc->levels[dev] = left | (right << 8);
350 return left | (right << 8);
351 }
352
353 static int sb_mixer_set(sb_devc * devc, int dev, int value)
354 {
355 int left = value & 0x000000ff;
356 int right = (value & 0x0000ff00) >> 8;
357 int retval;
358
359 if (left > 100)
360 left = 100;
361 if (right > 100)
362 right = 100;
363
364 if ((dev < 0) || (dev > 31))
365 return -EINVAL;
366
367 if (!(devc->supported_devices & (1 << dev))) /*
368 * Not supported
369 */
370 return -EINVAL;
371
372 /* Differentiate depending on the chipsets */
373 switch (devc->model) {
374 case MDL_SMW:
375 retval = smw_mixer_set(devc, dev, left, right);
376 break;
377 case MDL_ESS:
378 retval = ess_mixer_set(devc, dev, left, right);
379 break;
380 default:
381 retval = sb_common_mixer_set(devc, dev, left, right);
382 }
383 if (retval >= 0) devc->levels[dev] = retval;
384
385 return retval;
386 }
387
388 /*
389 * set_recsrc doesn't apply to ES188x
390 */
391 static void set_recsrc(sb_devc * devc, int src)
392 {
393 sb_setmixer(devc, RECORD_SRC, (sb_getmixer(devc, RECORD_SRC) & ~7) | (src & 0x7));
394 }
395
396 static int set_recmask(sb_devc * devc, int mask)
397 {
398 int devmask, i;
399 unsigned char regimageL, regimageR;
400
401 devmask = mask & devc->supported_rec_devices;
402
403 switch (devc->model)
404 {
405 case MDL_SBPRO:
406 case MDL_ESS:
407 case MDL_JAZZ:
408 case MDL_SMW:
409 if (devc->model == MDL_ESS && ess_set_recmask (devc, &devmask)) {
410 break;
411 };
412 if (devmask != SOUND_MASK_MIC &&
413 devmask != SOUND_MASK_LINE &&
414 devmask != SOUND_MASK_CD)
415 {
416 /*
417 * More than one device selected. Drop the
418 * previous selection
419 */
420 devmask &= ~devc->recmask;
421 }
422 if (devmask != SOUND_MASK_MIC &&
423 devmask != SOUND_MASK_LINE &&
424 devmask != SOUND_MASK_CD)
425 {
426 /*
427 * More than one device selected. Default to
428 * mic
429 */
430 devmask = SOUND_MASK_MIC;
431 }
432 if (devmask ^ devc->recmask) /*
433 * Input source changed
434 */
435 {
436 switch (devmask)
437 {
438 case SOUND_MASK_MIC:
439 set_recsrc(devc, SRC__MIC);
440 break;
441
442 case SOUND_MASK_LINE:
443 set_recsrc(devc, SRC__LINE);
444 break;
445
446 case SOUND_MASK_CD:
447 set_recsrc(devc, SRC__CD);
448 break;
449
450 default:
451 set_recsrc(devc, SRC__MIC);
452 }
453 }
454 break;
455
456 case MDL_SB16:
457 if (!devmask)
458 devmask = SOUND_MASK_MIC;
459
460 if (devc->submodel == SUBMDL_ALS007)
461 {
462 switch (devmask)
463 {
464 case SOUND_MASK_LINE:
465 sb_setmixer(devc, ALS007_RECORD_SRC, ALS007_LINE);
466 break;
467 case SOUND_MASK_CD:
468 sb_setmixer(devc, ALS007_RECORD_SRC, ALS007_CD);
469 break;
470 case SOUND_MASK_SYNTH:
471 sb_setmixer(devc, ALS007_RECORD_SRC, ALS007_SYNTH);
472 break;
473 default: /* Also takes care of SOUND_MASK_MIC case */
474 sb_setmixer(devc, ALS007_RECORD_SRC, ALS007_MIC);
475 break;
476 }
477 }
478 else
479 {
480 regimageL = regimageR = 0;
481 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
482 {
483 if ((1 << i) & devmask)
484 {
485 regimageL |= sb16_recmasks_L[i];
486 regimageR |= sb16_recmasks_R[i];
487 }
488 sb_setmixer (devc, SB16_IMASK_L, regimageL);
489 sb_setmixer (devc, SB16_IMASK_R, regimageR);
490 }
491 }
492 break;
493 }
494 devc->recmask = devmask;
495 return devc->recmask;
496 }
497
498 static int set_outmask(sb_devc * devc, int mask)
499 {
500 int devmask, i;
501 unsigned char regimage;
502
503 devmask = mask & devc->supported_out_devices;
504
505 switch (devc->model)
506 {
507 case MDL_SB16:
508 if (devc->submodel == SUBMDL_ALS007)
509 break;
510 else
511 {
512 regimage = 0;
513 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
514 {
515 if ((1 << i) & devmask)
516 {
517 regimage |= (sb16_recmasks_L[i] | sb16_recmasks_R[i]);
518 }
519 sb_setmixer (devc, SB16_OMASK, regimage);
520 }
521 }
522 break;
523 default:
524 break;
525 }
526
527 devc->outmask = devmask;
528 return devc->outmask;
529 }
530
531 static int sb_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
532 {
533 sb_devc *devc = mixer_devs[dev]->devc;
534 int val, ret;
535 int __user *p = arg;
536
537 /*
538 * Use ioctl(fd, SOUND_MIXER_AGC, &mode) to turn AGC off (0) or on (1).
539 * Use ioctl(fd, SOUND_MIXER_3DSE, &mode) to turn 3DSE off (0) or on (1)
540 * or mode==2 put 3DSE state to mode.
541 */
542 if (devc->model == MDL_SB16) {
543 if (cmd == SOUND_MIXER_AGC)
544 {
545 if (get_user(val, p))
546 return -EFAULT;
547 sb_setmixer(devc, 0x43, (~val) & 0x01);
548 return 0;
549 }
550 if (cmd == SOUND_MIXER_3DSE)
551 {
552 /* I put here 15, but I don't know the exact version.
553 At least my 4.13 havn't 3DSE, 4.16 has it. */
554 if (devc->minor < 15)
555 return -EINVAL;
556 if (get_user(val, p))
557 return -EFAULT;
558 if (val == 0 || val == 1)
559 sb_chgmixer(devc, AWE_3DSE, 0x01, val);
560 else if (val == 2)
561 {
562 ret = sb_getmixer(devc, AWE_3DSE)&0x01;
563 return put_user(ret, p);
564 }
565 else
566 return -EINVAL;
567 return 0;
568 }
569 }
570 if (((cmd >> 8) & 0xff) == 'M')
571 {
572 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
573 {
574 if (get_user(val, p))
575 return -EFAULT;
576 switch (cmd & 0xff)
577 {
578 case SOUND_MIXER_RECSRC:
579 ret = set_recmask(devc, val);
580 break;
581
582 case SOUND_MIXER_OUTSRC:
583 ret = set_outmask(devc, val);
584 break;
585
586 default:
587 ret = sb_mixer_set(devc, cmd & 0xff, val);
588 }
589 }
590 else switch (cmd & 0xff)
591 {
592 case SOUND_MIXER_RECSRC:
593 ret = devc->recmask;
594 break;
595
596 case SOUND_MIXER_OUTSRC:
597 ret = devc->outmask;
598 break;
599
600 case SOUND_MIXER_DEVMASK:
601 ret = devc->supported_devices;
602 break;
603
604 case SOUND_MIXER_STEREODEVS:
605 ret = devc->supported_devices;
606 /* The ESS seems to have stereo mic controls */
607 if (devc->model == MDL_ESS)
608 ret &= ~(SOUND_MASK_SPEAKER|SOUND_MASK_IMIX);
609 else if (devc->model != MDL_JAZZ && devc->model != MDL_SMW)
610 ret &= ~(SOUND_MASK_MIC | SOUND_MASK_SPEAKER | SOUND_MASK_IMIX);
611 break;
612
613 case SOUND_MIXER_RECMASK:
614 ret = devc->supported_rec_devices;
615 break;
616
617 case SOUND_MIXER_OUTMASK:
618 ret = devc->supported_out_devices;
619 break;
620
621 case SOUND_MIXER_CAPS:
622 ret = devc->mixer_caps;
623 break;
624
625 default:
626 ret = sb_mixer_get(devc, cmd & 0xff);
627 break;
628 }
629 return put_user(ret, p);
630 } else
631 return -EINVAL;
632 }
633
634 static struct mixer_operations sb_mixer_operations =
635 {
636 .owner = THIS_MODULE,
637 .id = "SB",
638 .name = "Sound Blaster",
639 .ioctl = sb_mixer_ioctl
640 };
641
642 static struct mixer_operations als007_mixer_operations =
643 {
644 .owner = THIS_MODULE,
645 .id = "ALS007",
646 .name = "Avance ALS-007",
647 .ioctl = sb_mixer_ioctl
648 };
649
650 static void sb_mixer_reset(sb_devc * devc)
651 {
652 char name[32];
653 int i;
654
655 sprintf(name, "SB_%d", devc->sbmixnum);
656
657 if (devc->sbmo.sm_games)
658 devc->levels = load_mixer_volumes(name, smg_default_levels, 1);
659 else
660 devc->levels = load_mixer_volumes(name, sb_default_levels, 1);
661
662 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
663 sb_mixer_set(devc, i, devc->levels[i]);
664
665 if (devc->model != MDL_ESS || !ess_mixer_reset (devc)) {
666 set_recmask(devc, SOUND_MASK_MIC);
667 };
668 }
669
670 int sb_mixer_init(sb_devc * devc, struct module *owner)
671 {
672 int mixer_type = 0;
673 int m;
674
675 devc->sbmixnum = sbmixnum++;
676 devc->levels = NULL;
677
678 sb_setmixer(devc, 0x00, 0); /* Reset mixer */
679
680 if (!(mixer_type = detect_mixer(devc)))
681 return 0; /* No mixer. Why? */
682
683 switch (devc->model)
684 {
685 case MDL_ESSPCI:
686 case MDL_YMPCI:
687 case MDL_SBPRO:
688 case MDL_AZTECH:
689 case MDL_JAZZ:
690 devc->mixer_caps = SOUND_CAP_EXCL_INPUT;
691 devc->supported_devices = SBPRO_MIXER_DEVICES;
692 devc->supported_rec_devices = SBPRO_RECORDING_DEVICES;
693 devc->iomap = &sbpro_mix;
694 devc->iomap_sz = ARRAY_SIZE(sbpro_mix);
695 break;
696
697 case MDL_ESS:
698 ess_mixer_init (devc);
699 break;
700
701 case MDL_SMW:
702 devc->mixer_caps = SOUND_CAP_EXCL_INPUT;
703 devc->supported_devices = 0;
704 devc->supported_rec_devices = 0;
705 devc->iomap = &sbpro_mix;
706 devc->iomap_sz = ARRAY_SIZE(sbpro_mix);
707 smw_mixer_init(devc);
708 break;
709
710 case MDL_SB16:
711 devc->mixer_caps = 0;
712 devc->supported_rec_devices = SB16_RECORDING_DEVICES;
713 devc->supported_out_devices = SB16_OUTFILTER_DEVICES;
714 if (devc->submodel != SUBMDL_ALS007)
715 {
716 devc->supported_devices = SB16_MIXER_DEVICES;
717 devc->iomap = &sb16_mix;
718 devc->iomap_sz = ARRAY_SIZE(sb16_mix);
719 }
720 else
721 {
722 devc->supported_devices = ALS007_MIXER_DEVICES;
723 devc->iomap = &als007_mix;
724 devc->iomap_sz = ARRAY_SIZE(als007_mix);
725 }
726 break;
727
728 default:
729 printk(KERN_WARNING "sb_mixer: Unsupported mixer type %d\n", devc->model);
730 return 0;
731 }
732
733 m = sound_alloc_mixerdev();
734 if (m == -1)
735 return 0;
736
737 mixer_devs[m] = kmalloc(sizeof(struct mixer_operations), GFP_KERNEL);
738 if (mixer_devs[m] == NULL)
739 {
740 printk(KERN_ERR "sb_mixer: Can't allocate memory\n");
741 sound_unload_mixerdev(m);
742 return 0;
743 }
744
745 if (devc->submodel != SUBMDL_ALS007)
746 memcpy ((char *) mixer_devs[m], (char *) &sb_mixer_operations, sizeof (struct mixer_operations));
747 else
748 memcpy ((char *) mixer_devs[m], (char *) &als007_mixer_operations, sizeof (struct mixer_operations));
749
750 mixer_devs[m]->devc = devc;
751
752 if (owner)
753 mixer_devs[m]->owner = owner;
754
755 devc->my_mixerdev = m;
756 sb_mixer_reset(devc);
757 return 1;
758 }
759
760 void sb_mixer_unload(sb_devc *devc)
761 {
762 if (devc->my_mixerdev == -1)
763 return;
764
765 kfree(mixer_devs[devc->my_mixerdev]);
766 sound_unload_mixerdev(devc->my_mixerdev);
767 sbmixnum--;
768 }
Support for the Chinese Samsung S3C2440 based development boards