File: /usr/src/linux/drivers/sound/sb_mixer.c
1 /*
2 * sound/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 regoffs = (*devc->iomap)[dev][LEFT_CHN].regno;
277
278 if (regoffs == 0)
279 return -EINVAL;
280
281 val = sb_getmixer(devc, regoffs);
282 change_bits(devc, &val, dev, LEFT_CHN, left);
283
284 if ((*devc->iomap)[dev][RIGHT_CHN].regno != regoffs) /*
285 * Change register
286 */
287 {
288 sb_setmixer(devc, regoffs, val); /*
289 * Save the old one
290 */
291 regoffs = (*devc->iomap)[dev][RIGHT_CHN].regno;
292
293 if (regoffs == 0)
294 return left | (left << 8); /*
295 * Just left channel present
296 */
297
298 val = sb_getmixer(devc, regoffs); /*
299 * Read the new one
300 */
301 }
302 change_bits(devc, &val, dev, RIGHT_CHN, right);
303
304 sb_setmixer(devc, regoffs, val);
305
306 return left | (right << 8);
307 }
308
309 static int smw_mixer_set(sb_devc * devc, int dev, int left, int right)
310 {
311 int reg, val;
312
313 switch (dev)
314 {
315 case SOUND_MIXER_VOLUME:
316 sb_setmixer(devc, 0x0b, 96 - (96 * left / 100)); /* 96=mute, 0=max */
317 sb_setmixer(devc, 0x0c, 96 - (96 * right / 100));
318 break;
319
320 case SOUND_MIXER_BASS:
321 case SOUND_MIXER_TREBLE:
322 devc->levels[dev] = left | (right << 8);
323 /* Set left bass and treble values */
324 val = ((devc->levels[SOUND_MIXER_TREBLE] & 0xff) * 16 / (unsigned) 100) << 4;
325 val |= ((devc->levels[SOUND_MIXER_BASS] & 0xff) * 16 / (unsigned) 100) & 0x0f;
326 sb_setmixer(devc, 0x0d, val);
327
328 /* Set right bass and treble values */
329 val = (((devc->levels[SOUND_MIXER_TREBLE] >> 8) & 0xff) * 16 / (unsigned) 100) << 4;
330 val |= (((devc->levels[SOUND_MIXER_BASS] >> 8) & 0xff) * 16 / (unsigned) 100) & 0x0f;
331 sb_setmixer(devc, 0x0e, val);
332
333 break;
334
335 default:
336 reg = smw_mix_regs[dev];
337 if (reg == 0)
338 return -EINVAL;
339 sb_setmixer(devc, reg, (24 - (24 * left / 100)) | 0x20); /* 24=mute, 0=max */
340 sb_setmixer(devc, reg + 1, (24 - (24 * right / 100)) | 0x40);
341 }
342
343 devc->levels[dev] = left | (right << 8);
344 return left | (right << 8);
345 }
346
347 static int sb_mixer_set(sb_devc * devc, int dev, int value)
348 {
349 int left = value & 0x000000ff;
350 int right = (value & 0x0000ff00) >> 8;
351 int retval;
352
353 if (left > 100)
354 left = 100;
355 if (right > 100)
356 right = 100;
357
358 if (dev > 31)
359 return -EINVAL;
360
361 if (!(devc->supported_devices & (1 << dev))) /*
362 * Not supported
363 */
364 return -EINVAL;
365
366 /* Differentiate depending on the chipsets */
367 switch (devc->model) {
368 case MDL_SMW:
369 retval = smw_mixer_set(devc, dev, left, right);
370 break;
371 case MDL_ESS:
372 retval = ess_mixer_set(devc, dev, left, right);
373 break;
374 default:
375 retval = sb_common_mixer_set(devc, dev, left, right);
376 }
377 if (retval >= 0) devc->levels[dev] = retval;
378
379 return retval;
380 }
381
382 /*
383 * set_recsrc doesn't apply to ES188x
384 */
385 static void set_recsrc(sb_devc * devc, int src)
386 {
387 sb_setmixer(devc, RECORD_SRC, (sb_getmixer(devc, RECORD_SRC) & ~7) | (src & 0x7));
388 }
389
390 static int set_recmask(sb_devc * devc, int mask)
391 {
392 int devmask, i;
393 unsigned char regimageL, regimageR;
394
395 devmask = mask & devc->supported_rec_devices;
396
397 switch (devc->model)
398 {
399 case MDL_SBPRO:
400 case MDL_ESS:
401 case MDL_JAZZ:
402 case MDL_SMW:
403 if (devc->model == MDL_ESS && ess_set_recmask (devc, &devmask)) {
404 break;
405 };
406 if (devmask != SOUND_MASK_MIC &&
407 devmask != SOUND_MASK_LINE &&
408 devmask != SOUND_MASK_CD)
409 {
410 /*
411 * More than one device selected. Drop the
412 * previous selection
413 */
414 devmask &= ~devc->recmask;
415 }
416 if (devmask != SOUND_MASK_MIC &&
417 devmask != SOUND_MASK_LINE &&
418 devmask != SOUND_MASK_CD)
419 {
420 /*
421 * More than one device selected. Default to
422 * mic
423 */
424 devmask = SOUND_MASK_MIC;
425 }
426 if (devmask ^ devc->recmask) /*
427 * Input source changed
428 */
429 {
430 switch (devmask)
431 {
432 case SOUND_MASK_MIC:
433 set_recsrc(devc, SRC__MIC);
434 break;
435
436 case SOUND_MASK_LINE:
437 set_recsrc(devc, SRC__LINE);
438 break;
439
440 case SOUND_MASK_CD:
441 set_recsrc(devc, SRC__CD);
442 break;
443
444 default:
445 set_recsrc(devc, SRC__MIC);
446 }
447 }
448 break;
449
450 case MDL_SB16:
451 if (!devmask)
452 devmask = SOUND_MASK_MIC;
453
454 if (devc->submodel == SUBMDL_ALS007)
455 {
456 switch (devmask)
457 {
458 case SOUND_MASK_LINE:
459 sb_setmixer(devc, ALS007_RECORD_SRC, ALS007_LINE);
460 break;
461 case SOUND_MASK_CD:
462 sb_setmixer(devc, ALS007_RECORD_SRC, ALS007_CD);
463 break;
464 case SOUND_MASK_SYNTH:
465 sb_setmixer(devc, ALS007_RECORD_SRC, ALS007_SYNTH);
466 break;
467 default: /* Also takes care of SOUND_MASK_MIC case */
468 sb_setmixer(devc, ALS007_RECORD_SRC, ALS007_MIC);
469 break;
470 }
471 }
472 else
473 {
474 regimageL = regimageR = 0;
475 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
476 {
477 if ((1 << i) & devmask)
478 {
479 regimageL |= sb16_recmasks_L[i];
480 regimageR |= sb16_recmasks_R[i];
481 }
482 sb_setmixer (devc, SB16_IMASK_L, regimageL);
483 sb_setmixer (devc, SB16_IMASK_R, regimageR);
484 }
485 }
486 break;
487 }
488 devc->recmask = devmask;
489 return devc->recmask;
490 }
491
492 static int set_outmask(sb_devc * devc, int mask)
493 {
494 int devmask, i;
495 unsigned char regimage;
496
497 devmask = mask & devc->supported_out_devices;
498
499 switch (devc->model)
500 {
501 case MDL_SB16:
502 if (devc->submodel == SUBMDL_ALS007)
503 break;
504 else
505 {
506 regimage = 0;
507 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
508 {
509 if ((1 << i) & devmask)
510 {
511 regimage |= (sb16_recmasks_L[i] | sb16_recmasks_R[i]);
512 }
513 sb_setmixer (devc, SB16_OMASK, regimage);
514 }
515 }
516 break;
517 default:
518 break;
519 }
520
521 devc->outmask = devmask;
522 return devc->outmask;
523 }
524
525 static int sb_mixer_ioctl(int dev, unsigned int cmd, caddr_t arg)
526 {
527 sb_devc *devc = mixer_devs[dev]->devc;
528 int val, ret;
529
530 /*
531 * Use ioctl(fd, SOUND_MIXER_AGC, &mode) to turn AGC off (0) or on (1).
532 * Use ioctl(fd, SOUND_MIXER_3DSE, &mode) to turn 3DSE off (0) or on (1)
533 * or mode==2 put 3DSE state to mode.
534 */
535 if (devc->model == MDL_SB16) {
536 if (cmd == SOUND_MIXER_AGC)
537 {
538 if (get_user(val, (int *)arg))
539 return -EFAULT;
540 sb_setmixer(devc, 0x43, (~val) & 0x01);
541 return 0;
542 }
543 if (cmd == SOUND_MIXER_3DSE)
544 {
545 /* I put here 15, but I don't know the exact version.
546 At least my 4.13 havn't 3DSE, 4.16 has it. */
547 if (devc->minor < 15)
548 return -EINVAL;
549 if (get_user(val, (int *)arg))
550 return -EFAULT;
551 if (val == 0 || val == 1)
552 sb_chgmixer(devc, AWE_3DSE, 0x01, val);
553 else if (val == 2)
554 {
555 ret = sb_getmixer(devc, AWE_3DSE)&0x01;
556 return put_user(ret, (int *)arg);
557 }
558 else
559 return -EINVAL;
560 return 0;
561 }
562 }
563 if (((cmd >> 8) & 0xff) == 'M')
564 {
565 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
566 {
567 if (get_user(val, (int *)arg))
568 return -EFAULT;
569 switch (cmd & 0xff)
570 {
571 case SOUND_MIXER_RECSRC:
572 ret = set_recmask(devc, val);
573 break;
574
575 case SOUND_MIXER_OUTSRC:
576 ret = set_outmask(devc, val);
577 break;
578
579 default:
580 ret = sb_mixer_set(devc, cmd & 0xff, val);
581 }
582 }
583 else switch (cmd & 0xff)
584 {
585 case SOUND_MIXER_RECSRC:
586 ret = devc->recmask;
587 break;
588
589 case SOUND_MIXER_OUTSRC:
590 ret = devc->outmask;
591 break;
592
593 case SOUND_MIXER_DEVMASK:
594 ret = devc->supported_devices;
595 break;
596
597 case SOUND_MIXER_STEREODEVS:
598 ret = devc->supported_devices;
599 /* The ESS seems to have stereo mic controls */
600 if (devc->model == MDL_ESS)
601 ret &= ~(SOUND_MASK_SPEAKER|SOUND_MASK_IMIX);
602 else if (devc->model != MDL_JAZZ && devc->model != MDL_SMW)
603 ret &= ~(SOUND_MASK_MIC | SOUND_MASK_SPEAKER | SOUND_MASK_IMIX);
604 break;
605
606 case SOUND_MIXER_RECMASK:
607 ret = devc->supported_rec_devices;
608 break;
609
610 case SOUND_MIXER_OUTMASK:
611 ret = devc->supported_out_devices;
612 break;
613
614 case SOUND_MIXER_CAPS:
615 ret = devc->mixer_caps;
616 break;
617
618 default:
619 ret = sb_mixer_get(devc, cmd & 0xff);
620 break;
621 }
622 return put_user(ret, (int *)arg);
623 } else
624 return -EINVAL;
625 }
626
627 static struct mixer_operations sb_mixer_operations =
628 {
629 owner: THIS_MODULE,
630 id: "SB",
631 name: "Sound Blaster",
632 ioctl: sb_mixer_ioctl
633 };
634
635 static struct mixer_operations als007_mixer_operations =
636 {
637 owner: THIS_MODULE,
638 id: "ALS007",
639 name: "Avance ALS-007",
640 ioctl: sb_mixer_ioctl
641 };
642
643 static void sb_mixer_reset(sb_devc * devc)
644 {
645 char name[32];
646 int i;
647
648 sprintf(name, "SB_%d", devc->sbmixnum);
649
650 if (devc->sbmo.sm_games)
651 devc->levels = load_mixer_volumes(name, smg_default_levels, 1);
652 else
653 devc->levels = load_mixer_volumes(name, sb_default_levels, 1);
654
655 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
656 sb_mixer_set(devc, i, devc->levels[i]);
657
658 if (devc->model != MDL_ESS || !ess_mixer_reset (devc)) {
659 set_recmask(devc, SOUND_MASK_MIC);
660 };
661 }
662
663 int sb_mixer_init(sb_devc * devc, struct module *owner)
664 {
665 int mixer_type = 0;
666 int m;
667
668 devc->sbmixnum = sbmixnum++;
669 devc->levels = NULL;
670
671 sb_setmixer(devc, 0x00, 0); /* Reset mixer */
672
673 if (!(mixer_type = detect_mixer(devc)))
674 return 0; /* No mixer. Why? */
675
676 switch (devc->model)
677 {
678 case MDL_ESSPCI:
679 case MDL_YMPCI:
680 case MDL_SBPRO:
681 case MDL_AZTECH:
682 case MDL_JAZZ:
683 devc->mixer_caps = SOUND_CAP_EXCL_INPUT;
684 devc->supported_devices = SBPRO_MIXER_DEVICES;
685 devc->supported_rec_devices = SBPRO_RECORDING_DEVICES;
686 devc->iomap = &sbpro_mix;
687 break;
688
689 case MDL_ESS:
690 ess_mixer_init (devc);
691 break;
692
693 case MDL_SMW:
694 devc->mixer_caps = SOUND_CAP_EXCL_INPUT;
695 devc->supported_devices = 0;
696 devc->supported_rec_devices = 0;
697 devc->iomap = &sbpro_mix;
698 smw_mixer_init(devc);
699 break;
700
701 case MDL_SB16:
702 devc->mixer_caps = 0;
703 devc->supported_rec_devices = SB16_RECORDING_DEVICES;
704 devc->supported_out_devices = SB16_OUTFILTER_DEVICES;
705 if (devc->submodel != SUBMDL_ALS007)
706 {
707 devc->supported_devices = SB16_MIXER_DEVICES;
708 devc->iomap = &sb16_mix;
709 }
710 else
711 {
712 devc->supported_devices = ALS007_MIXER_DEVICES;
713 devc->iomap = &als007_mix;
714 }
715 break;
716
717 default:
718 printk(KERN_WARNING "sb_mixer: Unsupported mixer type %d\n", devc->model);
719 return 0;
720 }
721
722 m = sound_alloc_mixerdev();
723 if (m == -1)
724 return 0;
725
726 mixer_devs[m] = (struct mixer_operations *)kmalloc(sizeof(struct mixer_operations), GFP_KERNEL);
727 if (mixer_devs[m] == NULL)
728 {
729 printk(KERN_ERR "sb_mixer: Can't allocate memory\n");
730 sound_unload_mixerdev(m);
731 return 0;
732 }
733
734 if (devc->submodel != SUBMDL_ALS007)
735 memcpy ((char *) mixer_devs[m], (char *) &sb_mixer_operations, sizeof (struct mixer_operations));
736 else
737 memcpy ((char *) mixer_devs[m], (char *) &als007_mixer_operations, sizeof (struct mixer_operations));
738
739 mixer_devs[m]->devc = devc;
740
741 if (owner)
742 mixer_devs[m]->owner = owner;
743
744 devc->my_mixerdev = m;
745 sb_mixer_reset(devc);
746 return 1;
747 }
748
749 void sb_mixer_unload(sb_devc *devc)
750 {
751 kfree(mixer_devs[devc->my_mixerdev]);
752 sound_unload_mixerdev(devc->my_mixerdev);
753 sbmixnum--;
754 }
755