Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Audio Command Interface (ACI) driver (sound/aci.c) | |
3 | * | |
4 | * ACI is a protocol used to communicate with the microcontroller on | |
5 | * some sound cards produced by miro, e.g. the miroSOUND PCM12 and | |
6 | * PCM20. The ACI has been developed for miro by Norberto Pellicci | |
7 | * <pellicci@home.com>. Special thanks to both him and miro for | |
8 | * providing the ACI specification. | |
9 | * | |
10 | * The main function of the ACI is to control the mixer and to get a | |
11 | * product identification. On the PCM20, ACI also controls the radio | |
12 | * tuner on this card, this is supported in the Video for Linux | |
13 | * miropcm20 driver. | |
14 | * - | |
15 | * This is a fullfeatured implementation. Unsupported features | |
16 | * are bugs... (: | |
17 | * | |
18 | * It is not longer necessary to load the mad16 module first. The | |
19 | * user is currently responsible to set the mad16 mixer correctly. | |
20 | * | |
21 | * To toggle the solo mode for full duplex operation just use the OSS | |
22 | * record switch for the pcm ('wave') controller. Robert | |
23 | * - | |
24 | * | |
25 | * Revision history: | |
26 | * | |
27 | * 1995-11-10 Markus Kuhn <mskuhn@cip.informatik.uni-erlangen.de> | |
28 | * First version written. | |
29 | * 1995-12-31 Markus Kuhn | |
30 | * Second revision, general code cleanup. | |
31 | * 1996-05-16 Hannu Savolainen | |
32 | * Integrated with other parts of the driver. | |
33 | * 1996-05-28 Markus Kuhn | |
34 | * Initialize CS4231A mixer, make ACI first mixer, | |
35 | * use new private mixer API for solo mode. | |
36 | * 1998-08-18 Ruurd Reitsma <R.A.Reitsma@wbmt.tudelft.nl> | |
37 | * Small modification to export ACI functions and | |
38 | * complete modularisation. | |
39 | * 2000-06-20 Robert Siemer <Robert.Siemer@gmx.de> | |
40 | * Don't initialize the CS4231A mixer anymore, so the code is | |
41 | * working again, and other small changes to fit in todays | |
42 | * kernels. | |
43 | * 2000-08-26 Robert Siemer | |
44 | * Clean up and rewrite for 2.4.x. Maybe it's SMP safe now... (: | |
45 | * ioctl bugfix, and integration of solo-mode into OSS-API, | |
46 | * added (OSS-limited) equalizer support, return value bugfix, | |
47 | * changed param aci_reset to reset, new params: ide, wss. | |
48 | * 2001-04-20 Robert Siemer | |
49 | * even more cleanups... | |
50 | * 2001-10-08 Arnaldo Carvalho de Melo <acme@conectiva.com.br> | |
51 | * Get rid of check_region, .bss optimizations, use set_current_state | |
52 | */ | |
53 | ||
54 | #include <linux/kernel.h> | |
55 | #include <linux/init.h> | |
56 | #include <linux/module.h> | |
57 | #include <linux/proc_fs.h> | |
58 | #include <linux/slab.h> | |
59 | #include <asm/semaphore.h> | |
60 | #include <asm/io.h> | |
61 | #include <asm/uaccess.h> | |
62 | #include "sound_config.h" | |
63 | ||
64 | int aci_port; /* as determined by bit 4 in the OPTi 929 MC4 register */ | |
65 | static int aci_idcode[2]; /* manufacturer and product ID */ | |
66 | int aci_version; /* ACI firmware version */ | |
67 | ||
68 | EXPORT_SYMBOL(aci_port); | |
69 | EXPORT_SYMBOL(aci_version); | |
70 | ||
71 | #include "aci.h" | |
72 | ||
73 | ||
74 | static int aci_solo; /* status bit of the card that can't be * | |
75 | * checked with ACI versions prior to 0xb0 */ | |
76 | static int aci_amp; /* status bit for power-amp/line-out level | |
77 | but I have no docs about what is what... */ | |
78 | static int aci_micpreamp=3; /* microphone preamp-level that can't be * | |
79 | * checked with ACI versions prior to 0xb0 */ | |
80 | ||
81 | static int mixer_device; | |
82 | static struct semaphore aci_sem; | |
83 | ||
84 | #ifdef MODULE | |
85 | static int reset; | |
86 | module_param(reset, bool, 0); | |
87 | MODULE_PARM_DESC(reset,"When set to 1, reset aci mixer."); | |
88 | #else | |
89 | static int reset = 1; | |
90 | #endif | |
91 | ||
92 | static int ide=-1; | |
93 | module_param(ide, int, 0); | |
94 | MODULE_PARM_DESC(ide,"1 enable, 0 disable ide-port - untested" | |
95 | " default: do nothing"); | |
96 | static int wss=-1; | |
97 | module_param(wss, int, 0); | |
98 | MODULE_PARM_DESC(wss,"change between ACI/WSS-mixer; use 0 and 1 - untested" | |
99 | " default: do nothing; for PCM1-pro only"); | |
100 | ||
101 | #ifdef DEBUG | |
102 | static void print_bits(unsigned char c) | |
103 | { | |
104 | int j; | |
105 | printk(KERN_DEBUG "aci: "); | |
106 | ||
107 | for (j=7; j>=0; j--) { | |
108 | printk("%d", (c >> j) & 0x1); | |
109 | } | |
110 | ||
111 | printk("\n"); | |
112 | } | |
113 | #endif | |
114 | ||
115 | /* | |
116 | * This busy wait code normally requires less than 15 loops and | |
117 | * practically always less than 100 loops on my i486/DX2 66 MHz. | |
118 | * | |
119 | * Warning: Waiting on the general status flag after reseting the MUTE | |
120 | * function can take a VERY long time, because the PCM12 does some kind | |
121 | * of fade-in effect. For this reason, access to the MUTE function has | |
122 | * not been implemented at all. | |
123 | * | |
124 | * - The OSS interface has no mute option. It takes about 3 seconds to | |
125 | * fade-in on my PCM20. busy_wait() handles it great now... Robert | |
126 | */ | |
127 | ||
128 | static int busy_wait(void) | |
129 | { | |
130 | #define MINTIME 500 | |
131 | long timeout; | |
132 | unsigned char byte; | |
133 | ||
134 | for (timeout = 1; timeout <= MINTIME+30; timeout++) { | |
135 | if (((byte=inb(BUSY_REGISTER)) & 1) == 0) { | |
136 | if (timeout >= MINTIME) | |
137 | printk(KERN_DEBUG "aci: Got READYFLAG in round %ld.\n", timeout-MINTIME); | |
138 | return byte; | |
139 | } | |
140 | if (timeout >= MINTIME) { | |
141 | long out=10*HZ; | |
142 | switch (timeout-MINTIME) { | |
143 | case 0 ... 9: | |
144 | out /= 10; | |
145 | case 10 ... 19: | |
146 | out /= 10; | |
147 | case 20 ... 30: | |
148 | out /= 10; | |
149 | default: | |
150 | set_current_state(TASK_UNINTERRUPTIBLE); | |
151 | schedule_timeout(out); | |
152 | break; | |
153 | } | |
154 | } | |
155 | } | |
156 | printk(KERN_WARNING "aci: busy_wait() time out.\n"); | |
157 | return -EBUSY; | |
158 | } | |
159 | ||
160 | /* The four ACI command types are fucked up. [-: | |
161 | * implied is: 1w - special case for INIT | |
162 | * write is: 2w1r | |
163 | * read is: x(1w1r) where x is 1 or 2 (1 CHECK_SIG, 1 CHECK_STER, | |
164 | * 1 VERSION, 2 IDCODE) | |
165 | * the command is only in the first write, rest is protocol overhead | |
166 | * | |
167 | * indexed is technically a write and used for STATUS | |
168 | * and the special case for TUNE is: 3w1r | |
169 | * | |
170 | * Here the new general sheme: TUNE --> aci_rw_cmd(x, y, z) | |
171 | * indexed and write --> aci_rw_cmd(x, y, -1) | |
172 | * implied and read (x=1) --> aci_rw_cmd(x, -1, -1) | |
173 | * | |
174 | * Read (x>=2) is not implemented (only used during initialization). | |
175 | * Use aci_idcode[2] and aci_version... Robert | |
176 | */ | |
177 | ||
178 | /* Some notes for error detection: theoretically it is possible. | |
179 | * But it doubles the I/O-traffic from ww(r) to wwwrw(r) in the normal | |
180 | * case and doesn't seem to be designed for that... Robert | |
181 | */ | |
182 | ||
183 | static inline int aci_rawwrite(unsigned char byte) | |
184 | { | |
185 | if (busy_wait() >= 0) { | |
186 | #ifdef DEBUG | |
187 | printk(KERN_DEBUG "aci_rawwrite(%d)\n", byte); | |
188 | #endif | |
189 | outb(byte, COMMAND_REGISTER); | |
190 | return 0; | |
191 | } else | |
192 | return -EBUSY; | |
193 | } | |
194 | ||
195 | static inline int aci_rawread(void) | |
196 | { | |
197 | unsigned char byte; | |
198 | ||
199 | if (busy_wait() >= 0) { | |
200 | byte=inb(STATUS_REGISTER); | |
201 | #ifdef DEBUG | |
202 | printk(KERN_DEBUG "%d = aci_rawread()\n", byte); | |
203 | #endif | |
204 | return byte; | |
205 | } else | |
206 | return -EBUSY; | |
207 | } | |
208 | ||
209 | ||
210 | int aci_rw_cmd(int write1, int write2, int write3) | |
211 | { | |
212 | int write[] = {write1, write2, write3}; | |
213 | int read = -EINTR, i; | |
214 | ||
215 | if (down_interruptible(&aci_sem)) | |
216 | goto out; | |
217 | ||
218 | for (i=0; i<3; i++) { | |
219 | if (write[i]< 0 || write[i] > 255) | |
220 | break; | |
221 | else { | |
222 | read = aci_rawwrite(write[i]); | |
223 | if (read < 0) | |
224 | goto out_up; | |
225 | } | |
226 | ||
227 | } | |
228 | ||
229 | read = aci_rawread(); | |
230 | out_up: up(&aci_sem); | |
231 | out: return read; | |
232 | } | |
233 | ||
234 | EXPORT_SYMBOL(aci_rw_cmd); | |
235 | ||
236 | static int setvolume(int __user *arg, | |
237 | unsigned char left_index, unsigned char right_index) | |
238 | { | |
239 | int vol, ret, uservol, buf; | |
240 | ||
241 | __get_user(uservol, arg); | |
242 | ||
243 | /* left channel */ | |
244 | vol = uservol & 0xff; | |
245 | if (vol > 100) | |
246 | vol = 100; | |
247 | vol = SCALE(100, 0x20, vol); | |
248 | if ((buf=aci_write_cmd(left_index, 0x20 - vol))<0) | |
249 | return buf; | |
250 | ret = SCALE(0x20, 100, vol); | |
251 | ||
252 | ||
253 | /* right channel */ | |
254 | vol = (uservol >> 8) & 0xff; | |
255 | if (vol > 100) | |
256 | vol = 100; | |
257 | vol = SCALE(100, 0x20, vol); | |
258 | if ((buf=aci_write_cmd(right_index, 0x20 - vol))<0) | |
259 | return buf; | |
260 | ret |= SCALE(0x20, 100, vol) << 8; | |
261 | ||
262 | __put_user(ret, arg); | |
263 | ||
264 | return 0; | |
265 | } | |
266 | ||
267 | static int getvolume(int __user *arg, | |
268 | unsigned char left_index, unsigned char right_index) | |
269 | { | |
270 | int vol; | |
271 | int buf; | |
272 | ||
273 | /* left channel */ | |
274 | if ((buf=aci_indexed_cmd(ACI_STATUS, left_index))<0) | |
275 | return buf; | |
276 | vol = SCALE(0x20, 100, buf < 0x20 ? 0x20-buf : 0); | |
277 | ||
278 | /* right channel */ | |
279 | if ((buf=aci_indexed_cmd(ACI_STATUS, right_index))<0) | |
280 | return buf; | |
281 | vol |= SCALE(0x20, 100, buf < 0x20 ? 0x20-buf : 0) << 8; | |
282 | ||
283 | __put_user(vol, arg); | |
284 | ||
285 | return 0; | |
286 | } | |
287 | ||
288 | ||
289 | /* The equalizer is somewhat strange on the ACI. From -12dB to +12dB | |
290 | * write: 0xff..down.to..0x80==0x00..up.to..0x7f | |
291 | */ | |
292 | ||
293 | static inline unsigned int eq_oss2aci(unsigned int vol) | |
294 | { | |
295 | int boost=0; | |
296 | unsigned int ret; | |
297 | ||
298 | if (vol > 100) | |
299 | vol = 100; | |
300 | if (vol > 50) { | |
301 | vol -= 51; | |
302 | boost=1; | |
303 | } | |
304 | if (boost) | |
305 | ret=SCALE(49, 0x7e, vol)+1; | |
306 | else | |
307 | ret=0xff - SCALE(50, 0x7f, vol); | |
308 | return ret; | |
309 | } | |
310 | ||
311 | static inline unsigned int eq_aci2oss(unsigned int vol) | |
312 | { | |
313 | if (vol < 0x80) | |
314 | return SCALE(0x7f, 50, vol) + 50; | |
315 | else | |
316 | return SCALE(0x7f, 50, 0xff-vol); | |
317 | } | |
318 | ||
319 | ||
320 | static int setequalizer(int __user *arg, | |
321 | unsigned char left_index, unsigned char right_index) | |
322 | { | |
323 | int buf; | |
324 | unsigned int vol; | |
325 | ||
326 | __get_user(vol, arg); | |
327 | ||
328 | /* left channel */ | |
329 | if ((buf=aci_write_cmd(left_index, eq_oss2aci(vol & 0xff)))<0) | |
330 | return buf; | |
331 | ||
332 | /* right channel */ | |
333 | if ((buf=aci_write_cmd(right_index, eq_oss2aci((vol>>8) & 0xff)))<0) | |
334 | return buf; | |
335 | ||
336 | /* the ACI equalizer is more precise */ | |
337 | return 0; | |
338 | } | |
339 | ||
340 | static int getequalizer(int __user *arg, | |
341 | unsigned char left_index, unsigned char right_index) | |
342 | { | |
343 | int buf; | |
344 | unsigned int vol; | |
345 | ||
346 | /* left channel */ | |
347 | if ((buf=aci_indexed_cmd(ACI_STATUS, left_index))<0) | |
348 | return buf; | |
349 | vol = eq_aci2oss(buf); | |
350 | ||
351 | /* right channel */ | |
352 | if ((buf=aci_indexed_cmd(ACI_STATUS, right_index))<0) | |
353 | return buf; | |
354 | vol |= eq_aci2oss(buf) << 8; | |
355 | ||
356 | __put_user(vol, arg); | |
357 | ||
358 | return 0; | |
359 | } | |
360 | ||
361 | static int aci_mixer_ioctl (int dev, unsigned int cmd, void __user * arg) | |
362 | { | |
363 | int vol, buf; | |
364 | int __user *p = arg; | |
365 | ||
366 | switch (cmd) { | |
367 | case SOUND_MIXER_WRITE_VOLUME: | |
368 | return setvolume(p, 0x01, 0x00); | |
369 | case SOUND_MIXER_WRITE_CD: | |
370 | return setvolume(p, 0x3c, 0x34); | |
371 | case SOUND_MIXER_WRITE_MIC: | |
372 | return setvolume(p, 0x38, 0x30); | |
373 | case SOUND_MIXER_WRITE_LINE: | |
374 | return setvolume(p, 0x39, 0x31); | |
375 | case SOUND_MIXER_WRITE_SYNTH: | |
376 | return setvolume(p, 0x3b, 0x33); | |
377 | case SOUND_MIXER_WRITE_PCM: | |
378 | return setvolume(p, 0x3a, 0x32); | |
379 | case MIXER_WRITE(SOUND_MIXER_RADIO): /* fall through */ | |
380 | case SOUND_MIXER_WRITE_LINE1: /* AUX1 or radio */ | |
381 | return setvolume(p, 0x3d, 0x35); | |
382 | case SOUND_MIXER_WRITE_LINE2: /* AUX2 */ | |
383 | return setvolume(p, 0x3e, 0x36); | |
384 | case SOUND_MIXER_WRITE_BASS: /* set band one and two */ | |
385 | if (aci_idcode[1]=='C') { | |
386 | if ((buf=setequalizer(p, 0x48, 0x40)) || | |
387 | (buf=setequalizer(p, 0x49, 0x41))); | |
388 | return buf; | |
389 | } | |
390 | break; | |
391 | case SOUND_MIXER_WRITE_TREBLE: /* set band six and seven */ | |
392 | if (aci_idcode[1]=='C') { | |
393 | if ((buf=setequalizer(p, 0x4d, 0x45)) || | |
394 | (buf=setequalizer(p, 0x4e, 0x46))); | |
395 | return buf; | |
396 | } | |
397 | break; | |
398 | case SOUND_MIXER_WRITE_IGAIN: /* MIC pre-amp */ | |
399 | if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { | |
400 | __get_user(vol, p); | |
401 | vol = vol & 0xff; | |
402 | if (vol > 100) | |
403 | vol = 100; | |
404 | vol = SCALE(100, 3, vol); | |
405 | if ((buf=aci_write_cmd(ACI_WRITE_IGAIN, vol))<0) | |
406 | return buf; | |
407 | aci_micpreamp = vol; | |
408 | vol = SCALE(3, 100, vol); | |
409 | vol |= (vol << 8); | |
410 | __put_user(vol, p); | |
411 | return 0; | |
412 | } | |
413 | break; | |
414 | case SOUND_MIXER_WRITE_OGAIN: /* Power-amp/line-out level */ | |
415 | if (aci_idcode[1]=='A' || aci_idcode[1]=='B') { | |
416 | __get_user(buf, p); | |
417 | buf = buf & 0xff; | |
418 | if (buf > 50) | |
419 | vol = 1; | |
420 | else | |
421 | vol = 0; | |
422 | if ((buf=aci_write_cmd(ACI_SET_POWERAMP, vol))<0) | |
423 | return buf; | |
424 | aci_amp = vol; | |
425 | if (aci_amp) | |
426 | buf = (100 || 100<<8); | |
427 | else | |
428 | buf = 0; | |
429 | __put_user(buf, p); | |
430 | return 0; | |
431 | } | |
432 | break; | |
433 | case SOUND_MIXER_WRITE_RECSRC: | |
434 | /* handle solo mode control */ | |
435 | __get_user(buf, p); | |
436 | /* unset solo when RECSRC for PCM is requested */ | |
437 | if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { | |
438 | vol = !(buf & SOUND_MASK_PCM); | |
439 | if ((buf=aci_write_cmd(ACI_SET_SOLOMODE, vol))<0) | |
440 | return buf; | |
441 | aci_solo = vol; | |
442 | } | |
443 | buf = (SOUND_MASK_CD| SOUND_MASK_MIC| SOUND_MASK_LINE| | |
444 | SOUND_MASK_SYNTH| SOUND_MASK_LINE2); | |
445 | if (aci_idcode[1] == 'C') /* PCM20 radio */ | |
446 | buf |= SOUND_MASK_RADIO; | |
447 | else | |
448 | buf |= SOUND_MASK_LINE1; | |
449 | if (!aci_solo) | |
450 | buf |= SOUND_MASK_PCM; | |
451 | __put_user(buf, p); | |
452 | return 0; | |
453 | case SOUND_MIXER_READ_DEVMASK: | |
454 | buf = (SOUND_MASK_VOLUME | SOUND_MASK_CD | | |
455 | SOUND_MASK_MIC | SOUND_MASK_LINE | | |
456 | SOUND_MASK_SYNTH | SOUND_MASK_PCM | | |
457 | SOUND_MASK_LINE2); | |
458 | switch (aci_idcode[1]) { | |
459 | case 'C': /* PCM20 radio */ | |
460 | buf |= (SOUND_MASK_RADIO | SOUND_MASK_IGAIN | | |
461 | SOUND_MASK_BASS | SOUND_MASK_TREBLE); | |
462 | break; | |
463 | case 'B': /* PCM12 */ | |
464 | buf |= (SOUND_MASK_LINE1 | SOUND_MASK_IGAIN | | |
465 | SOUND_MASK_OGAIN); | |
466 | break; | |
467 | case 'A': /* PCM1-pro */ | |
468 | buf |= (SOUND_MASK_LINE1 | SOUND_MASK_OGAIN); | |
469 | break; | |
470 | default: | |
471 | buf |= SOUND_MASK_LINE1; | |
472 | } | |
473 | __put_user(buf, p); | |
474 | return 0; | |
475 | case SOUND_MIXER_READ_STEREODEVS: | |
476 | buf = (SOUND_MASK_VOLUME | SOUND_MASK_CD | | |
477 | SOUND_MASK_MIC | SOUND_MASK_LINE | | |
478 | SOUND_MASK_SYNTH | SOUND_MASK_PCM | | |
479 | SOUND_MASK_LINE2); | |
480 | switch (aci_idcode[1]) { | |
481 | case 'C': /* PCM20 radio */ | |
482 | buf |= (SOUND_MASK_RADIO | | |
483 | SOUND_MASK_BASS | SOUND_MASK_TREBLE); | |
484 | break; | |
485 | default: | |
486 | buf |= SOUND_MASK_LINE1; | |
487 | } | |
488 | __put_user(buf, p); | |
489 | return 0; | |
490 | case SOUND_MIXER_READ_RECMASK: | |
491 | buf = (SOUND_MASK_CD| SOUND_MASK_MIC| SOUND_MASK_LINE| | |
492 | SOUND_MASK_SYNTH| SOUND_MASK_LINE2| SOUND_MASK_PCM); | |
493 | if (aci_idcode[1] == 'C') /* PCM20 radio */ | |
494 | buf |= SOUND_MASK_RADIO; | |
495 | else | |
496 | buf |= SOUND_MASK_LINE1; | |
497 | ||
498 | __put_user(buf, p); | |
499 | return 0; | |
500 | case SOUND_MIXER_READ_RECSRC: | |
501 | buf = (SOUND_MASK_CD | SOUND_MASK_MIC | SOUND_MASK_LINE | | |
502 | SOUND_MASK_SYNTH | SOUND_MASK_LINE2); | |
503 | /* do we need aci_solo or can I get it from the ACI? */ | |
504 | switch (aci_idcode[1]) { | |
505 | case 'B': /* PCM12 */ | |
506 | case 'C': /* PCM20 radio */ | |
507 | if (aci_version >= 0xb0) { | |
508 | if ((vol=aci_rw_cmd(ACI_STATUS, | |
509 | ACI_S_GENERAL, -1))<0) | |
510 | return vol; | |
511 | if (vol & 0x20) | |
512 | buf |= SOUND_MASK_PCM; | |
513 | } | |
514 | else | |
515 | if (!aci_solo) | |
516 | buf |= SOUND_MASK_PCM; | |
517 | break; | |
518 | default: | |
519 | buf |= SOUND_MASK_PCM; | |
520 | } | |
521 | if (aci_idcode[1] == 'C') /* PCM20 radio */ | |
522 | buf |= SOUND_MASK_RADIO; | |
523 | else | |
524 | buf |= SOUND_MASK_LINE1; | |
525 | ||
526 | __put_user(buf, p); | |
527 | return 0; | |
528 | case SOUND_MIXER_READ_CAPS: | |
529 | __put_user(0, p); | |
530 | return 0; | |
531 | case SOUND_MIXER_READ_VOLUME: | |
532 | return getvolume(p, 0x04, 0x03); | |
533 | case SOUND_MIXER_READ_CD: | |
534 | return getvolume(p, 0x0a, 0x09); | |
535 | case SOUND_MIXER_READ_MIC: | |
536 | return getvolume(p, 0x06, 0x05); | |
537 | case SOUND_MIXER_READ_LINE: | |
538 | return getvolume(p, 0x08, 0x07); | |
539 | case SOUND_MIXER_READ_SYNTH: | |
540 | return getvolume(p, 0x0c, 0x0b); | |
541 | case SOUND_MIXER_READ_PCM: | |
542 | return getvolume(p, 0x0e, 0x0d); | |
543 | case MIXER_READ(SOUND_MIXER_RADIO): /* fall through */ | |
544 | case SOUND_MIXER_READ_LINE1: /* AUX1 */ | |
545 | return getvolume(p, 0x11, 0x10); | |
546 | case SOUND_MIXER_READ_LINE2: /* AUX2 */ | |
547 | return getvolume(p, 0x13, 0x12); | |
548 | case SOUND_MIXER_READ_BASS: /* get band one */ | |
549 | if (aci_idcode[1]=='C') { | |
550 | return getequalizer(p, 0x23, 0x22); | |
551 | } | |
552 | break; | |
553 | case SOUND_MIXER_READ_TREBLE: /* get band seven */ | |
554 | if (aci_idcode[1]=='C') { | |
555 | return getequalizer(p, 0x2f, 0x2e); | |
556 | } | |
557 | break; | |
558 | case SOUND_MIXER_READ_IGAIN: /* MIC pre-amp */ | |
559 | if (aci_idcode[1]=='B' || aci_idcode[1]=='C') { | |
560 | /* aci_micpreamp or ACI? */ | |
561 | if (aci_version >= 0xb0) { | |
562 | if ((buf=aci_indexed_cmd(ACI_STATUS, | |
563 | ACI_S_READ_IGAIN))<0) | |
564 | return buf; | |
565 | } | |
566 | else | |
567 | buf=aci_micpreamp; | |
568 | vol = SCALE(3, 100, buf <= 3 ? buf : 3); | |
569 | vol |= vol << 8; | |
570 | __put_user(vol, p); | |
571 | return 0; | |
572 | } | |
573 | break; | |
574 | case SOUND_MIXER_READ_OGAIN: | |
575 | if (aci_amp) | |
576 | buf = (100 || 100<<8); | |
577 | else | |
578 | buf = 0; | |
579 | __put_user(buf, p); | |
580 | return 0; | |
581 | } | |
582 | return -EINVAL; | |
583 | } | |
584 | ||
585 | static struct mixer_operations aci_mixer_operations = | |
586 | { | |
587 | .owner = THIS_MODULE, | |
588 | .id = "ACI", | |
589 | .ioctl = aci_mixer_ioctl | |
590 | }; | |
591 | ||
592 | /* | |
593 | * There is also an internal mixer in the codec (CS4231A or AD1845), | |
594 | * that deserves no purpose in an ACI based system which uses an | |
595 | * external ACI controlled stereo mixer. Make sure that this codec | |
596 | * mixer has the AUX1 input selected as the recording source, that the | |
597 | * input gain is set near maximum and that the other channels going | |
598 | * from the inputs to the codec output are muted. | |
599 | */ | |
600 | ||
601 | static int __init attach_aci(void) | |
602 | { | |
603 | char *boardname; | |
604 | int i, rc = -EBUSY; | |
605 | ||
606 | init_MUTEX(&aci_sem); | |
607 | ||
608 | outb(0xE3, 0xf8f); /* Write MAD16 password */ | |
609 | aci_port = (inb(0xf90) & 0x10) ? | |
610 | 0x344: 0x354; /* Get aci_port from MC4_PORT */ | |
611 | ||
612 | if (!request_region(aci_port, 3, "sound mixer (ACI)")) { | |
613 | printk(KERN_NOTICE | |
614 | "aci: I/O area 0x%03x-0x%03x already used.\n", | |
615 | aci_port, aci_port+2); | |
616 | goto out; | |
617 | } | |
618 | ||
619 | /* force ACI into a known state */ | |
620 | rc = -EFAULT; | |
621 | for (i=0; i<3; i++) | |
622 | if (aci_rw_cmd(ACI_ERROR_OP, -1, -1)<0) | |
623 | goto out_release_region; | |
624 | ||
625 | /* official this is one aci read call: */ | |
626 | rc = -EFAULT; | |
627 | if ((aci_idcode[0]=aci_rw_cmd(ACI_READ_IDCODE, -1, -1))<0 || | |
628 | (aci_idcode[1]=aci_rw_cmd(ACI_READ_IDCODE, -1, -1))<0) { | |
629 | printk(KERN_ERR "aci: Failed to read idcode on 0x%03x.\n", | |
630 | aci_port); | |
631 | goto out_release_region; | |
632 | } | |
633 | ||
634 | if ((aci_version=aci_rw_cmd(ACI_READ_VERSION, -1, -1))<0) { | |
635 | printk(KERN_ERR "aci: Failed to read version on 0x%03x.\n", | |
636 | aci_port); | |
637 | goto out_release_region; | |
638 | } | |
639 | ||
640 | if (aci_idcode[0] == 'm') { | |
641 | /* It looks like a miro sound card. */ | |
642 | switch (aci_idcode[1]) { | |
643 | case 'A': | |
644 | boardname = "PCM1 pro / early PCM12"; | |
645 | break; | |
646 | case 'B': | |
647 | boardname = "PCM12"; | |
648 | break; | |
649 | case 'C': | |
650 | boardname = "PCM20 radio"; | |
651 | break; | |
652 | default: | |
653 | boardname = "unknown miro"; | |
654 | } | |
655 | } else { | |
656 | printk(KERN_WARNING "aci: Warning: unsupported card! - " | |
657 | "no hardware, no specs...\n"); | |
658 | boardname = "unknown Cardinal Technologies"; | |
659 | } | |
660 | ||
661 | printk(KERN_INFO "<ACI 0x%02x, id %02x/%02x \"%c/%c\", (%s)> at 0x%03x\n", | |
662 | aci_version, | |
663 | aci_idcode[0], aci_idcode[1], | |
664 | aci_idcode[0], aci_idcode[1], | |
665 | boardname, aci_port); | |
666 | ||
667 | rc = -EBUSY; | |
668 | if (reset) { | |
669 | /* first write()s after reset fail with my PCM20 */ | |
670 | if (aci_rw_cmd(ACI_INIT, -1, -1)<0 || | |
671 | aci_rw_cmd(ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP)<0 || | |
672 | aci_rw_cmd(ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP)<0) | |
673 | goto out_release_region; | |
674 | } | |
675 | ||
676 | /* the PCM20 is muted after reset (and reboot) */ | |
677 | if (aci_rw_cmd(ACI_SET_MUTE, 0x00, -1)<0) | |
678 | goto out_release_region; | |
679 | ||
680 | if (ide>=0) | |
681 | if (aci_rw_cmd(ACI_SET_IDE, !ide, -1)<0) | |
682 | goto out_release_region; | |
683 | ||
684 | if (wss>=0 && aci_idcode[1]=='A') | |
685 | if (aci_rw_cmd(ACI_SET_WSS, !!wss, -1)<0) | |
686 | goto out_release_region; | |
687 | ||
688 | mixer_device = sound_install_mixer(MIXER_DRIVER_VERSION, boardname, | |
689 | &aci_mixer_operations, | |
690 | sizeof(aci_mixer_operations), NULL); | |
691 | rc = 0; | |
692 | if (mixer_device < 0) { | |
693 | printk(KERN_ERR "aci: Failed to install mixer.\n"); | |
694 | rc = mixer_device; | |
695 | goto out_release_region; | |
696 | } /* else Maybe initialize the CS4231A mixer here... */ | |
697 | out: return rc; | |
698 | out_release_region: | |
699 | release_region(aci_port, 3); | |
700 | goto out; | |
701 | } | |
702 | ||
703 | static void __exit unload_aci(void) | |
704 | { | |
705 | sound_unload_mixerdev(mixer_device); | |
706 | release_region(aci_port, 3); | |
707 | } | |
708 | ||
709 | module_init(attach_aci); | |
710 | module_exit(unload_aci); | |
711 | MODULE_LICENSE("GPL"); |