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