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