Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | |
2 | /* | |
3 | * sound/pas2_mixer.c | |
4 | * | |
5 | * Mixer routines for the Pro Audio Spectrum cards. | |
6 | */ | |
7 | ||
8 | /* | |
9 | * Copyright (C) by Hannu Savolainen 1993-1997 | |
10 | * | |
11 | * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) | |
12 | * Version 2 (June 1991). See the "COPYING" file distributed with this software | |
13 | * for more info. | |
14 | */ | |
15 | /* | |
16 | * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed) | |
17 | * Bartlomiej Zolnierkiewicz : added __init to pas_init_mixer() | |
18 | */ | |
19 | #include <linux/init.h> | |
20 | #include "sound_config.h" | |
21 | ||
22 | #include "pas2.h" | |
23 | ||
24 | #ifndef DEB | |
25 | #define DEB(what) /* (what) */ | |
26 | #endif | |
27 | ||
28 | extern int pas_translate_code; | |
29 | extern char pas_model; | |
30 | extern int *pas_osp; | |
31 | extern int pas_audiodev; | |
32 | ||
33 | static int rec_devices = (SOUND_MASK_MIC); /* Default recording source */ | |
34 | static int mode_control; | |
35 | ||
36 | #define POSSIBLE_RECORDING_DEVICES (SOUND_MASK_SYNTH | SOUND_MASK_SPEAKER | SOUND_MASK_LINE | SOUND_MASK_MIC | \ | |
37 | SOUND_MASK_CD | SOUND_MASK_ALTPCM) | |
38 | ||
39 | #define SUPPORTED_MIXER_DEVICES (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | SOUND_MASK_LINE | SOUND_MASK_MIC | \ | |
40 | SOUND_MASK_CD | SOUND_MASK_ALTPCM | SOUND_MASK_IMIX | \ | |
41 | SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE | SOUND_MASK_RECLEV) | |
42 | ||
43 | static int *levels; | |
44 | ||
45 | static int default_levels[32] = | |
46 | { | |
47 | 0x3232, /* Master Volume */ | |
48 | 0x3232, /* Bass */ | |
49 | 0x3232, /* Treble */ | |
50 | 0x5050, /* FM */ | |
51 | 0x4b4b, /* PCM */ | |
52 | 0x3232, /* PC Speaker */ | |
53 | 0x4b4b, /* Ext Line */ | |
54 | 0x4b4b, /* Mic */ | |
55 | 0x4b4b, /* CD */ | |
56 | 0x6464, /* Recording monitor */ | |
57 | 0x4b4b, /* SB PCM */ | |
58 | 0x6464 /* Recording level */ | |
59 | }; | |
60 | ||
61 | void | |
62 | mix_write(unsigned char data, int ioaddr) | |
63 | { | |
64 | /* | |
65 | * The Revision D cards have a problem with their MVA508 interface. The | |
66 | * kludge-o-rama fix is to make a 16-bit quantity with identical LSB and | |
67 | * MSBs out of the output byte and to do a 16-bit out to the mixer port - | |
68 | * 1. We need to do this because it isn't timing problem but chip access | |
69 | * sequence problem. | |
70 | */ | |
71 | ||
72 | if (pas_model == 4) | |
73 | { | |
74 | outw(data | (data << 8), (ioaddr + pas_translate_code) - 1); | |
75 | outb((0x80), 0); | |
76 | } else | |
77 | pas_write(data, ioaddr); | |
78 | } | |
79 | ||
80 | static int | |
81 | mixer_output(int right_vol, int left_vol, int div, int bits, | |
82 | int mixer) /* Input or output mixer */ | |
83 | { | |
84 | int left = left_vol * div / 100; | |
85 | int right = right_vol * div / 100; | |
86 | ||
87 | ||
88 | if (bits & 0x10) | |
89 | { | |
90 | left |= mixer; | |
91 | right |= mixer; | |
92 | } | |
93 | if (bits == 0x03 || bits == 0x04) | |
94 | { | |
95 | mix_write(0x80 | bits, 0x078B); | |
96 | mix_write(left, 0x078B); | |
97 | right_vol = left_vol; | |
98 | } else | |
99 | { | |
100 | mix_write(0x80 | 0x20 | bits, 0x078B); | |
101 | mix_write(left, 0x078B); | |
102 | mix_write(0x80 | 0x40 | bits, 0x078B); | |
103 | mix_write(right, 0x078B); | |
104 | } | |
105 | ||
106 | return (left_vol | (right_vol << 8)); | |
107 | } | |
108 | ||
109 | static void | |
110 | set_mode(int new_mode) | |
111 | { | |
112 | mix_write(0x80 | 0x05, 0x078B); | |
113 | mix_write(new_mode, 0x078B); | |
114 | ||
115 | mode_control = new_mode; | |
116 | } | |
117 | ||
118 | static int | |
119 | pas_mixer_set(int whichDev, unsigned int level) | |
120 | { | |
121 | int left, right, devmask, changed, i, mixer = 0; | |
122 | ||
123 | DEB(printk("static int pas_mixer_set(int whichDev = %d, unsigned int level = %X)\n", whichDev, level)); | |
124 | ||
125 | left = level & 0x7f; | |
126 | right = (level & 0x7f00) >> 8; | |
127 | ||
128 | if (whichDev < SOUND_MIXER_NRDEVICES) { | |
129 | if ((1 << whichDev) & rec_devices) | |
130 | mixer = 0x20; | |
131 | else | |
132 | mixer = 0x00; | |
133 | } | |
134 | ||
135 | switch (whichDev) | |
136 | { | |
137 | case SOUND_MIXER_VOLUME: /* Master volume (0-63) */ | |
138 | levels[whichDev] = mixer_output(right, left, 63, 0x01, 0); | |
139 | break; | |
140 | ||
141 | /* | |
142 | * Note! Bass and Treble are mono devices. Will use just the left | |
143 | * channel. | |
144 | */ | |
145 | case SOUND_MIXER_BASS: /* Bass (0-12) */ | |
146 | levels[whichDev] = mixer_output(right, left, 12, 0x03, 0); | |
147 | break; | |
148 | case SOUND_MIXER_TREBLE: /* Treble (0-12) */ | |
149 | levels[whichDev] = mixer_output(right, left, 12, 0x04, 0); | |
150 | break; | |
151 | ||
152 | case SOUND_MIXER_SYNTH: /* Internal synthesizer (0-31) */ | |
153 | levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x00, mixer); | |
154 | break; | |
155 | case SOUND_MIXER_PCM: /* PAS PCM (0-31) */ | |
156 | levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x05, mixer); | |
157 | break; | |
158 | case SOUND_MIXER_ALTPCM: /* SB PCM (0-31) */ | |
159 | levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x07, mixer); | |
160 | break; | |
161 | case SOUND_MIXER_SPEAKER: /* PC speaker (0-31) */ | |
162 | levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x06, mixer); | |
163 | break; | |
164 | case SOUND_MIXER_LINE: /* External line (0-31) */ | |
165 | levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x02, mixer); | |
166 | break; | |
167 | case SOUND_MIXER_CD: /* CD (0-31) */ | |
168 | levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x03, mixer); | |
169 | break; | |
170 | case SOUND_MIXER_MIC: /* External microphone (0-31) */ | |
171 | levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x04, mixer); | |
172 | break; | |
173 | case SOUND_MIXER_IMIX: /* Recording monitor (0-31) (Output mixer only) */ | |
174 | levels[whichDev] = mixer_output(right, left, 31, 0x10 | 0x01, | |
175 | 0x00); | |
176 | break; | |
177 | case SOUND_MIXER_RECLEV: /* Recording level (0-15) */ | |
178 | levels[whichDev] = mixer_output(right, left, 15, 0x02, 0); | |
179 | break; | |
180 | ||
181 | ||
182 | case SOUND_MIXER_RECSRC: | |
183 | devmask = level & POSSIBLE_RECORDING_DEVICES; | |
184 | ||
185 | changed = devmask ^ rec_devices; | |
186 | rec_devices = devmask; | |
187 | ||
188 | for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) | |
189 | if (changed & (1 << i)) | |
190 | { | |
191 | pas_mixer_set(i, levels[i]); | |
192 | } | |
193 | return rec_devices; | |
194 | break; | |
195 | ||
196 | default: | |
197 | return -EINVAL; | |
198 | } | |
199 | ||
200 | return (levels[whichDev]); | |
201 | } | |
202 | ||
203 | /*****/ | |
204 | ||
205 | static void | |
206 | pas_mixer_reset(void) | |
207 | { | |
208 | int foo; | |
209 | ||
210 | DEB(printk("pas2_mixer.c: void pas_mixer_reset(void)\n")); | |
211 | ||
212 | for (foo = 0; foo < SOUND_MIXER_NRDEVICES; foo++) | |
213 | pas_mixer_set(foo, levels[foo]); | |
214 | ||
215 | set_mode(0x04 | 0x01); | |
216 | } | |
217 | ||
218 | static int pas_mixer_ioctl(int dev, unsigned int cmd, void __user *arg) | |
219 | { | |
220 | int level,v ; | |
221 | int __user *p = (int __user *)arg; | |
222 | ||
223 | DEB(printk("pas2_mixer.c: int pas_mixer_ioctl(unsigned int cmd = %X, unsigned int arg = %X)\n", cmd, arg)); | |
224 | if (cmd == SOUND_MIXER_PRIVATE1) { /* Set loudness bit */ | |
225 | if (get_user(level, p)) | |
226 | return -EFAULT; | |
227 | if (level == -1) /* Return current settings */ | |
228 | level = (mode_control & 0x04); | |
229 | else { | |
230 | mode_control &= ~0x04; | |
231 | if (level) | |
232 | mode_control |= 0x04; | |
233 | set_mode(mode_control); | |
234 | } | |
235 | level = !!level; | |
236 | return put_user(level, p); | |
237 | } | |
238 | if (cmd == SOUND_MIXER_PRIVATE2) { /* Set enhance bit */ | |
239 | if (get_user(level, p)) | |
240 | return -EFAULT; | |
241 | if (level == -1) { /* Return current settings */ | |
242 | if (!(mode_control & 0x03)) | |
243 | level = 0; | |
244 | else | |
245 | level = ((mode_control & 0x03) + 1) * 20; | |
246 | } else { | |
247 | int i = 0; | |
248 | ||
249 | level &= 0x7f; | |
250 | if (level) | |
251 | i = (level / 20) - 1; | |
252 | mode_control &= ~0x03; | |
253 | mode_control |= i & 0x03; | |
254 | set_mode(mode_control); | |
255 | if (i) | |
256 | i = (i + 1) * 20; | |
257 | level = i; | |
258 | } | |
259 | return put_user(level, p); | |
260 | } | |
261 | if (cmd == SOUND_MIXER_PRIVATE3) { /* Set mute bit */ | |
262 | if (get_user(level, p)) | |
263 | return -EFAULT; | |
264 | if (level == -1) /* Return current settings */ | |
265 | level = !(pas_read(0x0B8A) & 0x20); | |
266 | else { | |
267 | if (level) | |
268 | pas_write(pas_read(0x0B8A) & (~0x20), 0x0B8A); | |
269 | else | |
270 | pas_write(pas_read(0x0B8A) | 0x20, 0x0B8A); | |
271 | ||
272 | level = !(pas_read(0x0B8A) & 0x20); | |
273 | } | |
274 | return put_user(level, p); | |
275 | } | |
276 | if (((cmd >> 8) & 0xff) == 'M') { | |
277 | if (get_user(v, p)) | |
278 | return -EFAULT; | |
279 | if (_SIOC_DIR(cmd) & _SIOC_WRITE) { | |
280 | v = pas_mixer_set(cmd & 0xff, v); | |
281 | } else { | |
282 | switch (cmd & 0xff) { | |
283 | case SOUND_MIXER_RECSRC: | |
284 | v = rec_devices; | |
285 | break; | |
286 | ||
287 | case SOUND_MIXER_STEREODEVS: | |
288 | v = SUPPORTED_MIXER_DEVICES & ~(SOUND_MASK_BASS | SOUND_MASK_TREBLE); | |
289 | break; | |
290 | ||
291 | case SOUND_MIXER_DEVMASK: | |
292 | v = SUPPORTED_MIXER_DEVICES; | |
293 | break; | |
294 | ||
295 | case SOUND_MIXER_RECMASK: | |
296 | v = POSSIBLE_RECORDING_DEVICES & SUPPORTED_MIXER_DEVICES; | |
297 | break; | |
298 | ||
299 | case SOUND_MIXER_CAPS: | |
300 | v = 0; /* No special capabilities */ | |
301 | break; | |
302 | ||
303 | default: | |
304 | v = levels[cmd & 0xff]; | |
305 | break; | |
306 | } | |
307 | } | |
308 | return put_user(v, p); | |
309 | } | |
310 | return -EINVAL; | |
311 | } | |
312 | ||
313 | static struct mixer_operations pas_mixer_operations = | |
314 | { | |
315 | .owner = THIS_MODULE, | |
316 | .id = "PAS16", | |
317 | .name = "Pro Audio Spectrum 16", | |
318 | .ioctl = pas_mixer_ioctl | |
319 | }; | |
320 | ||
321 | int __init | |
322 | pas_init_mixer(void) | |
323 | { | |
324 | int d; | |
325 | ||
326 | levels = load_mixer_volumes("PAS16_1", default_levels, 1); | |
327 | ||
328 | pas_mixer_reset(); | |
329 | ||
330 | if ((d = sound_alloc_mixerdev()) != -1) | |
331 | { | |
332 | audio_devs[pas_audiodev]->mixer_dev = d; | |
333 | mixer_devs[d] = &pas_mixer_operations; | |
334 | } | |
335 | return 1; | |
336 | } |