File: /usr/src/linux/drivers/sound/mad16.c
1 /*
2 * Copyright (C) by Hannu Savolainen 1993-1997
3 *
4 * mad16.c
5 *
6 * Initialization code for OPTi MAD16 compatible audio chips. Including
7 *
8 * OPTi 82C928 MAD16 (replaced by C929)
9 * OAK OTI-601D Mozart
10 * OAK OTI-605 Mozart (later version with MPU401 Midi)
11 * OPTi 82C929 MAD16 Pro
12 * OPTi 82C930
13 * OPTi 82C924
14 *
15 * These audio interface chips don't produce sound themselves. They just
16 * connect some other components (OPL-[234] and a WSS compatible codec)
17 * to the PC bus and perform I/O, DMA and IRQ address decoding. There is
18 * also a UART for the MPU-401 mode (not 82C928/Mozart).
19 * The Mozart chip appears to be compatible with the 82C928, although later
20 * issues of the card, using the OTI-605 chip, have an MPU-401 compatable Midi
21 * port. This port is configured differently to that of the OPTi audio chips.
22 *
23 * Changes
24 *
25 * Alan Cox Clean up, added module selections.
26 *
27 * A. Wik Added support for Opti924 PnP.
28 * Improved debugging support. 16-May-1998
29 * Fixed bug. 16-Jun-1998
30 *
31 * Torsten Duwe Made Opti924 PnP support non-destructive
32 * 23-Dec-1998
33 *
34 * Paul Grayson Added support for Midi on later Mozart cards.
35 * 25-Nov-1999
36 * Christoph Hellwig Adapted to module_init/module_exit.
37 * Arnaldo C. de Melo got rid of attach_uart401 21-Sep-2000
38 *
39 * Pavel Rabel Clean up Nov-2000
40 */
41
42 #include <linux/config.h>
43 #include <linux/init.h>
44 #include <linux/module.h>
45
46 #include "sound_config.h"
47
48 #include "ad1848.h"
49 #include "sb.h"
50 #include "mpu401.h"
51
52 static int mad16_conf;
53 static int mad16_cdsel;
54
55 static int already_initialized = 0;
56
57 #define C928 1
58 #define MOZART 2
59 #define C929 3
60 #define C930 4
61 #define C924 5
62
63 /*
64 * Registers
65 *
66 * The MAD16 occupies I/O ports 0xf8d to 0xf93 (fixed locations).
67 * All ports are inactive by default. They can be activated by
68 * writing 0xE2 or 0xE3 to the password register. The password is valid
69 * only until the next I/O read or write.
70 *
71 * 82C930 uses 0xE4 as the password and indirect addressing to access
72 * the config registers.
73 */
74
75 #define MC0_PORT 0xf8c /* Dummy port */
76 #define MC1_PORT 0xf8d /* SB address, CD-ROM interface type, joystick */
77 #define MC2_PORT 0xf8e /* CD-ROM address, IRQ, DMA, plus OPL4 bit */
78 #define MC3_PORT 0xf8f
79 #define PASSWD_REG 0xf8f
80 #define MC4_PORT 0xf90
81 #define MC5_PORT 0xf91
82 #define MC6_PORT 0xf92
83 #define MC7_PORT 0xf93
84 #define MC8_PORT 0xf94
85 #define MC9_PORT 0xf95
86 #define MC10_PORT 0xf96
87 #define MC11_PORT 0xf97
88 #define MC12_PORT 0xf98
89
90 static int board_type = C928;
91
92 static int *mad16_osp;
93 static int c931_detected; /* minor differences from C930 */
94 static char c924pnp = 0; /* " " " C924 */
95 static int debug = 0; /* debugging output */
96
97 #ifdef DDB
98 #undef DDB
99 #endif
100 #define DDB(x) {if (debug) x;}
101
102 static unsigned char mad_read(int port)
103 {
104 unsigned long flags;
105 unsigned char tmp;
106
107 save_flags(flags);
108 cli();
109
110 switch (board_type) /* Output password */
111 {
112 case C928:
113 case MOZART:
114 outb((0xE2), PASSWD_REG);
115 break;
116
117 case C929:
118 outb((0xE3), PASSWD_REG);
119 break;
120
121 case C930:
122 /* outb(( 0xE4), PASSWD_REG); */
123 break;
124
125 case C924:
126 /* the c924 has its ports relocated by -128 if
127 PnP is enabled -aw */
128 if (!c924pnp)
129 outb((0xE5), PASSWD_REG); else
130 outb((0xE5), PASSWD_REG - 0x80);
131 break;
132 }
133
134 if (board_type == C930)
135 {
136 outb((port - MC0_PORT), 0xe0e); /* Write to index reg */
137 tmp = inb(0xe0f); /* Read from data reg */
138 }
139 else
140 if (!c924pnp)
141 tmp = inb(port); else
142 tmp = inb(port-0x80);
143 restore_flags(flags);
144
145 return tmp;
146 }
147
148 static void mad_write(int port, int value)
149 {
150 unsigned long flags;
151
152 save_flags(flags);
153 cli();
154
155 switch (board_type) /* Output password */
156 {
157 case C928:
158 case MOZART:
159 outb((0xE2), PASSWD_REG);
160 break;
161
162 case C929:
163 outb((0xE3), PASSWD_REG);
164 break;
165
166 case C930:
167 /* outb(( 0xE4), PASSWD_REG); */
168 break;
169
170 case C924:
171 if (!c924pnp)
172 outb((0xE5), PASSWD_REG); else
173 outb((0xE5), PASSWD_REG - 0x80);
174 break;
175 }
176
177 if (board_type == C930)
178 {
179 outb((port - MC0_PORT), 0xe0e); /* Write to index reg */
180 outb(((unsigned char) (value & 0xff)), 0xe0f);
181 }
182 else
183 if (!c924pnp)
184 outb(((unsigned char) (value & 0xff)), port); else
185 outb(((unsigned char) (value & 0xff)), port-0x80);
186 restore_flags(flags);
187 }
188
189 static int __init detect_c930(void)
190 {
191 unsigned char tmp = mad_read(MC1_PORT);
192
193 if ((tmp & 0x06) != 0x06)
194 {
195 DDB(printk("Wrong C930 signature (%x)\n", tmp));
196 /* return 0; */
197 }
198 mad_write(MC1_PORT, 0);
199
200 if (mad_read(MC1_PORT) != 0x06)
201 {
202 DDB(printk("Wrong C930 signature2 (%x)\n", tmp));
203 /* return 0; */
204 }
205 mad_write(MC1_PORT, tmp); /* Restore bits */
206
207 mad_write(MC7_PORT, 0);
208 if ((tmp = mad_read(MC7_PORT)) != 0)
209 {
210 DDB(printk("MC7 not writable (%x)\n", tmp));
211 return 0;
212 }
213 mad_write(MC7_PORT, 0xcb);
214 if ((tmp = mad_read(MC7_PORT)) != 0xcb)
215 {
216 DDB(printk("MC7 not writable2 (%x)\n", tmp));
217 return 0;
218 }
219
220 tmp = mad_read(MC0_PORT+18);
221 if (tmp == 0xff || tmp == 0x00)
222 return 1;
223 /* We probably have a C931 */
224 DDB(printk("Detected C931 config=0x%02x\n", tmp));
225 c931_detected = 1;
226
227 /*
228 * We cannot configure the chip if it is in PnP mode.
229 * If we have a CSN assigned (bit 8 in MC13) we first try
230 * a software reset, then a software power off, finally
231 * Clearing PnP mode. The last option is not
232 * Bit 8 in MC13
233 */
234 if ((mad_read(MC0_PORT+13) & 0x80) == 0)
235 return 1;
236
237 /* Software reset */
238 mad_write(MC9_PORT, 0x02);
239 mad_write(MC9_PORT, 0x00);
240
241 if ((mad_read(MC0_PORT+13) & 0x80) == 0)
242 return 1;
243
244 /* Power off, and on again */
245 mad_write(MC9_PORT, 0xc2);
246 mad_write(MC9_PORT, 0xc0);
247
248 if ((mad_read(MC0_PORT+13) & 0x80) == 0)
249 return 1;
250
251 #if 0
252 /* Force off PnP mode. This is not recommended because
253 * the PnP bios will not recognize the chip on the next
254 * warm boot and may assignd different resources to other
255 * PnP/PCI cards.
256 */
257 mad_write(MC0_PORT+17, 0x04);
258 #endif
259 return 1;
260 }
261
262 static int __init detect_mad16(void)
263 {
264 unsigned char tmp, tmp2, bit;
265 int i, port;
266
267 /*
268 * Check that reading a register doesn't return bus float (0xff)
269 * when the card is accessed using password. This may fail in case
270 * the card is in low power mode. Normally at least the power saving
271 * mode bit should be 0.
272 */
273
274 if ((tmp = mad_read(MC1_PORT)) == 0xff)
275 {
276 DDB(printk("MC1_PORT returned 0xff\n"));
277 return 0;
278 }
279 for (i = 0xf8d; i <= 0xf98; i++)
280 if (!c924pnp)
281 DDB(printk("Port %0x (init value) = %0x\n", i, mad_read(i))) else
282 DDB(printk("Port %0x (init value) = %0x\n", i-0x80, mad_read(i)));
283
284 if (board_type == C930)
285 return detect_c930();
286
287 /*
288 * Now check that the gate is closed on first I/O after writing
289 * the password. (This is how a MAD16 compatible card works).
290 */
291
292 if ((tmp2 = inb(MC1_PORT)) == tmp) /* It didn't close */
293 {
294 DDB(printk("MC1_PORT didn't close after read (0x%02x)\n", tmp2));
295 return 0;
296 }
297
298 bit = (c924pnp) ? 0x20 : 0x80;
299 port = (c924pnp) ? MC2_PORT : MC1_PORT;
300
301 tmp = mad_read(port);
302 mad_write(port, tmp ^ bit); /* Toggle a bit */
303 if ((tmp2 = mad_read(port)) != (tmp ^ bit)) /* Compare the bit */
304 {
305 mad_write(port, tmp); /* Restore */
306 DDB(printk("Bit revert test failed (0x%02x, 0x%02x)\n", tmp, tmp2));
307 return 0;
308 }
309 mad_write(port, tmp); /* Restore */
310 return 1; /* Bingo */
311 }
312
313 static int __init wss_init(struct address_info *hw_config)
314 {
315 int ad_flags = 0;
316
317 /*
318 * Verify the WSS parameters
319 */
320
321 if (check_region(hw_config->io_base, 8))
322 {
323 printk(KERN_ERR "MSS: I/O port conflict\n");
324 return 0;
325 }
326 if (!ad1848_detect(hw_config->io_base + 4, &ad_flags, mad16_osp))
327 return 0;
328 /*
329 * Check if the IO port returns valid signature. The original MS Sound
330 * system returns 0x04 while some cards (AudioTrix Pro for example)
331 * return 0x00.
332 */
333
334 if ((inb(hw_config->io_base + 3) & 0x3f) != 0x04 &&
335 (inb(hw_config->io_base + 3) & 0x3f) != 0x00)
336 {
337 DDB(printk("No MSS signature detected on port 0x%x (0x%x)\n", hw_config->io_base, inb(hw_config->io_base + 3)));
338 return 0;
339 }
340 if (hw_config->irq > 11)
341 {
342 printk(KERN_ERR "MSS: Bad IRQ %d\n", hw_config->irq);
343 return 0;
344 }
345 if (hw_config->dma != 0 && hw_config->dma != 1 && hw_config->dma != 3)
346 {
347 printk(KERN_ERR "MSS: Bad DMA %d\n", hw_config->dma);
348 return 0;
349 }
350 /*
351 * Check that DMA0 is not in use with a 8 bit board.
352 */
353
354 if (hw_config->dma == 0 && inb(hw_config->io_base + 3) & 0x80)
355 {
356 printk("MSS: Can't use DMA0 with a 8 bit card/slot\n");
357 return 0;
358 }
359 if (hw_config->irq > 7 && hw_config->irq != 9 && inb(hw_config->io_base + 3) & 0x80)
360 printk(KERN_ERR "MSS: Can't use IRQ%d with a 8 bit card/slot\n", hw_config->irq);
361 return 1;
362 }
363
364 static int __init init_c930(struct address_info *hw_config)
365 {
366 unsigned char cfg = 0;
367
368 if(c931_detected)
369 {
370 /* Bit 0 has reversd meaning. Bits 1 and 2 sese
371 reversed on write.
372 Support only IDE cdrom. IDE port programmed
373 somewhere else. */
374 cfg = (cfg & 0x09) ^ 0x07;
375 }
376
377 switch (hw_config->io_base)
378 {
379 case 0x530:
380 cfg |= 0x00;
381 break;
382 case 0xe80:
383 cfg |= 0x10;
384 break;
385 case 0xf40:
386 cfg |= 0x20;
387 break;
388 case 0x604:
389 cfg |= 0x30;
390 break;
391 default:
392 printk(KERN_ERR "MAD16: Invalid codec port %x\n", hw_config->io_base);
393 return 0;
394 }
395 mad_write(MC1_PORT, cfg);
396
397 /* MC2 is CD configuration. Don't touch it. */
398
399 mad_write(MC3_PORT, 0); /* Disable SB mode IRQ and DMA */
400
401 /* bit 2 of MC4 reverses it's meaning between the C930
402 and the C931. */
403 cfg = c931_detected ? 0x04 : 0x00;
404
405 mad_write(MC4_PORT, 0x52|cfg);
406
407 mad_write(MC5_PORT, 0x3C); /* Init it into mode2 */
408 mad_write(MC6_PORT, 0x02); /* Enable WSS, Disable MPU and SB */
409 mad_write(MC7_PORT, 0xCB);
410 mad_write(MC10_PORT, 0x11);
411
412 return wss_init(hw_config);
413 }
414
415 static int __init chip_detect(void)
416 {
417 int i;
418
419 /*
420 * Then try to detect with the old password
421 */
422 board_type = C924;
423
424 DDB(printk("Detect using password = 0xE5\n"));
425
426 if (detect_mad16()) {
427 return 1;
428 }
429
430 board_type = C928;
431
432 DDB(printk("Detect using password = 0xE2\n"));
433
434 if (detect_mad16())
435 {
436 unsigned char model;
437
438 if (((model = mad_read(MC3_PORT)) & 0x03) == 0x03) {
439 DDB(printk("mad16.c: Mozart detected\n"));
440 board_type = MOZART;
441 } else {
442 DDB(printk("mad16.c: 82C928 detected???\n"));
443 board_type = C928;
444 }
445 return 1;
446 }
447
448 board_type = C929;
449
450 DDB(printk("Detect using password = 0xE3\n"));
451
452 if (detect_mad16())
453 {
454 DDB(printk("mad16.c: 82C929 detected\n"));
455 return 1;
456 }
457
458 if (inb(PASSWD_REG) != 0xff)
459 return 0;
460
461 /*
462 * First relocate MC# registers to 0xe0e/0xe0f, disable password
463 */
464
465 outb((0xE4), PASSWD_REG);
466 outb((0x80), PASSWD_REG);
467
468 board_type = C930;
469
470 DDB(printk("Detect using password = 0xE4\n"));
471
472 for (i = 0xf8d; i <= 0xf93; i++)
473 DDB(printk("port %03x = %02x\n", i, mad_read(i)));
474
475 if(detect_mad16()) {
476 DDB(printk("mad16.c: 82C930 detected\n"));
477 return 1;
478 }
479
480 /* The C931 has the password reg at F8D */
481 outb((0xE4), 0xF8D);
482 outb((0x80), 0xF8D);
483 DDB(printk("Detect using password = 0xE4 for C931\n"));
484
485 if (detect_mad16()) {
486 return 1;
487 }
488
489 board_type = C924;
490 c924pnp++;
491 DDB(printk("Detect using password = 0xE5 (again), port offset -0x80\n"));
492 if (detect_mad16()) {
493 DDB(printk("mad16.c: 82C924 PnP detected\n"));
494 return 1;
495 }
496
497 c924pnp=0;
498
499 return 0;
500 }
501
502 static int __init probe_mad16(struct address_info *hw_config)
503 {
504 int i;
505 static int valid_ports[] =
506 {
507 0x530, 0xe80, 0xf40, 0x604
508 };
509 unsigned char tmp;
510 unsigned char cs4231_mode = 0;
511
512 int ad_flags = 0;
513
514 if (already_initialized)
515 return 0;
516
517 mad16_osp = hw_config->osp;
518
519 /*
520 * Check that all ports return 0xff (bus float) when no password
521 * is written to the password register.
522 */
523
524 DDB(printk("--- Detecting MAD16 / Mozart ---\n"));
525 if (!chip_detect())
526 return 0;
527
528 if (board_type == C930)
529 return init_c930(hw_config);
530
531
532 for (i = 0xf8d; i <= 0xf93; i++)
533 if (!c924pnp)
534 DDB(printk("port %03x = %02x\n", i, mad_read(i))) else
535 DDB(printk("port %03x = %02x\n", i-0x80, mad_read(i)));
536
537 /*
538 * Set the WSS address
539 */
540
541 tmp = (mad_read(MC1_PORT) & 0x0f) | 0x80; /* Enable WSS, Disable SB */
542
543 for (i = 0; i < 5; i++)
544 {
545 if (i > 3) /* Not a valid port */
546 {
547 printk(KERN_ERR "MAD16/Mozart: Bad WSS base address 0x%x\n", hw_config->io_base);
548 return 0;
549 }
550 if (valid_ports[i] == hw_config->io_base)
551 {
552 tmp |= i << 4; /* WSS port select bits */
553 break;
554 }
555 }
556
557 /*
558 * Set optional CD-ROM and joystick settings.
559 */
560
561 tmp &= ~0x0f;
562 mad_write(MC1_PORT, tmp);
563
564 tmp = mad_read(MC2_PORT);
565
566 mad_write(MC2_PORT, tmp);
567 mad_write(MC3_PORT, 0xf0); /* Disable SB */
568
569 if (board_type == C924) /* Specific C924 init values */
570 {
571 mad_write(MC4_PORT, 0xA0);
572 mad_write(MC5_PORT, 0x05);
573 mad_write(MC6_PORT, 0x03);
574 }
575 if (!ad1848_detect(hw_config->io_base + 4, &ad_flags, mad16_osp))
576 return 0;
577
578 if (ad_flags & (AD_F_CS4231 | AD_F_CS4248))
579 cs4231_mode = 0x02; /* CS4248/CS4231 sync delay switch */
580
581 if (board_type == C929)
582 {
583 mad_write(MC4_PORT, 0xa2);
584 mad_write(MC5_PORT, 0xA5 | cs4231_mode);
585 mad_write(MC6_PORT, 0x03); /* Disable MPU401 */
586 }
587 else
588 {
589 mad_write(MC4_PORT, 0x02);
590 mad_write(MC5_PORT, 0x30 | cs4231_mode);
591 }
592
593 for (i = 0xf8d; i <= 0xf93; i++) if (!c924pnp)
594 DDB(printk("port %03x after init = %02x\n", i, mad_read(i))) else
595 DDB(printk("port %03x after init = %02x\n", i-0x80, mad_read(i)));
596 wss_init(hw_config);
597
598 return 1;
599 }
600
601 static void __init attach_mad16(struct address_info *hw_config)
602 {
603
604 static signed char interrupt_bits[12] = {
605 -1, -1, -1, -1, -1, -1, -1, 0x08, -1, 0x10, 0x18, 0x20
606 };
607 signed char bits;
608
609 static char dma_bits[4] = {
610 1, 2, 0, 3
611 };
612
613 int config_port = hw_config->io_base + 0, version_port = hw_config->io_base + 3;
614 int ad_flags = 0, dma = hw_config->dma, dma2 = hw_config->dma2;
615 unsigned char dma2_bit = 0;
616
617 already_initialized = 1;
618
619 if (!ad1848_detect(hw_config->io_base + 4, &ad_flags, mad16_osp))
620 return;
621
622 /*
623 * Set the IRQ and DMA addresses.
624 */
625
626 if (board_type == C930 || c924pnp)
627 interrupt_bits[5] = 0x28; /* Also IRQ5 is possible on C930 */
628
629 bits = interrupt_bits[hw_config->irq];
630 if (bits == -1)
631 return;
632
633 outb((bits | 0x40), config_port);
634 if ((inb(version_port) & 0x40) == 0)
635 printk(KERN_ERR "[IRQ Conflict?]\n");
636
637 /*
638 * Handle the capture DMA channel
639 */
640
641 if (ad_flags & AD_F_CS4231 && dma2 != -1 && dma2 != dma)
642 {
643 if (!((dma == 0 && dma2 == 1) ||
644 (dma == 1 && dma2 == 0) ||
645 (dma == 3 && dma2 == 0)))
646 { /* Unsupported combination. Try to swap channels */
647 int tmp = dma;
648
649 dma = dma2;
650 dma2 = tmp;
651 }
652 if ((dma == 0 && dma2 == 1) || (dma == 1 && dma2 == 0) ||
653 (dma == 3 && dma2 == 0))
654 {
655 dma2_bit = 0x04; /* Enable capture DMA */
656 }
657 else
658 {
659 printk("MAD16: Invalid capture DMA\n");
660 dma2 = dma;
661 }
662 }
663 else dma2 = dma;
664
665 outb((bits | dma_bits[dma] | dma2_bit), config_port); /* Write IRQ+DMA setup */
666
667 hw_config->slots[0] = ad1848_init("MAD16 WSS", hw_config->io_base + 4,
668 hw_config->irq,
669 dma,
670 dma2, 0,
671 hw_config->osp,
672 THIS_MODULE);
673 request_region(hw_config->io_base, 4, "MAD16 WSS config");
674 }
675
676 static int __init probe_mad16_mpu(struct address_info *hw_config)
677 {
678 static int mpu_attached = 0;
679 unsigned char tmp;
680
681 if (!already_initialized) /* The MSS port must be initialized first */
682 return 0;
683
684 if (mpu_attached) /* Don't let them call this twice */
685 return 0;
686 mpu_attached = 1;
687
688 if (board_type < C929) /* Early chip. No MPU support. Just SB MIDI */
689 {
690
691 #ifdef CONFIG_MAD16_OLDCARD
692
693 tmp = mad_read(MC3_PORT);
694
695 /*
696 * MAD16 SB base is defined by the WSS base. It cannot be changed
697 * alone.
698 * Ignore configured I/O base. Use the active setting.
699 */
700
701 if (mad_read(MC1_PORT) & 0x20)
702 hw_config->io_base = 0x240;
703 else
704 hw_config->io_base = 0x220;
705
706 switch (hw_config->irq)
707 {
708 case 5:
709 tmp = (tmp & 0x3f) | 0x80;
710 break;
711 case 7:
712 tmp = (tmp & 0x3f);
713 break;
714 case 11:
715 tmp = (tmp & 0x3f) | 0x40;
716 break;
717 default:
718 printk(KERN_ERR "mad16/Mozart: Invalid MIDI IRQ\n");
719 return 0;
720 }
721
722 mad_write(MC3_PORT, tmp | 0x04);
723 hw_config->driver_use_1 = SB_MIDI_ONLY;
724 if (!sb_dsp_detect(hw_config, 0, 0, NULL))
725 return 0;
726
727 if (mad_read(MC1_PORT) & 0x20)
728 hw_config->io_base = 0x240;
729 else
730 hw_config->io_base = 0x220;
731
732 hw_config->name = "Mad16/Mozart";
733 sb_dsp_init(hw_config, THIS_MODULE);
734 return 1;
735 #else
736 /* assuming all later Mozart cards are identified as
737 * either 82C928 or Mozart. If so, following code attempts
738 * to set MPU register. TODO - add probing
739 */
740
741 tmp = mad_read(MC8_PORT);
742
743 switch (hw_config->irq)
744 {
745 case 5:
746 tmp |= 0x08;
747 break;
748 case 7:
749 tmp |= 0x10;
750 break;
751 case 9:
752 tmp |= 0x18;
753 break;
754 case 10:
755 tmp |= 0x20;
756 break;
757 case 11:
758 tmp |= 0x28;
759 break;
760 default:
761 printk(KERN_ERR "mad16/MOZART: invalid mpu_irq\n");
762 return 0;
763 }
764
765 switch (hw_config->io_base)
766 {
767 case 0x300:
768 tmp |= 0x01;
769 break;
770 case 0x310:
771 tmp |= 0x03;
772 break;
773 case 0x320:
774 tmp |= 0x05;
775 break;
776 case 0x330:
777 tmp |= 0x07;
778 break;
779 default:
780 printk(KERN_ERR "mad16/MOZART: invalid mpu_io\n");
781 return 0;
782 }
783
784 mad_write(MC8_PORT, tmp); /* write MPU port parameters */
785 goto probe_401;
786 #endif
787 }
788 tmp = mad_read(MC6_PORT) & 0x83;
789 tmp |= 0x80; /* MPU-401 enable */
790
791 /* Set the MPU base bits */
792
793 switch (hw_config->io_base)
794 {
795 case 0x300:
796 tmp |= 0x60;
797 break;
798 case 0x310:
799 tmp |= 0x40;
800 break;
801 case 0x320:
802 tmp |= 0x20;
803 break;
804 case 0x330:
805 tmp |= 0x00;
806 break;
807 default:
808 printk(KERN_ERR "MAD16: Invalid MIDI port 0x%x\n", hw_config->io_base);
809 return 0;
810 }
811
812 /* Set the MPU IRQ bits */
813
814 switch (hw_config->irq)
815 {
816 case 5:
817 tmp |= 0x10;
818 break;
819 case 7:
820 tmp |= 0x18;
821 break;
822 case 9:
823 tmp |= 0x00;
824 break;
825 case 10:
826 tmp |= 0x08;
827 break;
828 default:
829 printk(KERN_ERR "MAD16: Invalid MIDI IRQ %d\n", hw_config->irq);
830 break;
831 }
832
833 mad_write(MC6_PORT, tmp); /* Write MPU401 config */
834
835 #ifndef CONFIG_MAD16_OLDCARD
836 probe_401:
837 #endif
838 hw_config->driver_use_1 = SB_MIDI_ONLY;
839 hw_config->name = "Mad16/Mozart";
840 return probe_uart401(hw_config, THIS_MODULE);
841 }
842
843 static void __exit unload_mad16(struct address_info *hw_config)
844 {
845 ad1848_unload(hw_config->io_base + 4,
846 hw_config->irq,
847 hw_config->dma,
848 hw_config->dma2, 0);
849 release_region(hw_config->io_base, 4);
850 sound_unload_audiodev(hw_config->slots[0]);
851 }
852
853 static void __exit unload_mad16_mpu(struct address_info *hw_config)
854 {
855 #ifdef CONFIG_MAD16_OLDCARD
856 if (board_type < C929) /* Early chip. No MPU support. Just SB MIDI */
857 {
858 sb_dsp_unload(hw_config, 0);
859 return;
860 }
861 #endif
862
863 unload_uart401(hw_config);
864 }
865
866 static struct address_info cfg;
867 static struct address_info cfg_mpu;
868
869 static int found_mpu;
870
871 static int __initdata mpu_io = 0;
872 static int __initdata mpu_irq = 0;
873 static int __initdata io = -1;
874 static int __initdata dma = -1;
875 static int __initdata dma16 = -1; /* Set this for modules that need it */
876 static int __initdata irq = -1;
877 static int __initdata cdtype = 0;
878 static int __initdata cdirq = 0;
879 static int __initdata cdport = 0x340;
880 static int __initdata cddma = -1;
881 static int __initdata opl4 = 0;
882 static int __initdata joystick = 0;
883
884 MODULE_PARM(mpu_io, "i");
885 MODULE_PARM(mpu_irq, "i");
886 MODULE_PARM(io,"i");
887 MODULE_PARM(dma,"i");
888 MODULE_PARM(dma16,"i");
889 MODULE_PARM(irq,"i");
890 MODULE_PARM(cdtype,"i");
891 MODULE_PARM(cdirq,"i");
892 MODULE_PARM(cdport,"i");
893 MODULE_PARM(cddma,"i");
894 MODULE_PARM(opl4,"i");
895 MODULE_PARM(joystick,"i");
896 MODULE_PARM(debug,"i");
897
898 static int __initdata dma_map[2][8] =
899 {
900 {0x03, -1, -1, -1, -1, 0x00, 0x01, 0x02},
901 {0x03, -1, 0x01, 0x00, -1, -1, -1, -1}
902 };
903
904 static int __initdata irq_map[16] =
905 {
906 0x00, -1, -1, 0x0A,
907 -1, 0x04, -1, 0x08,
908 -1, 0x10, 0x14, 0x18,
909 -1, -1, -1, -1
910 };
911
912 static int __init init_mad16(void)
913 {
914 int dmatype = 0;
915
916 printk(KERN_INFO "MAD16 audio driver Copyright (C) by Hannu Savolainen 1993-1996\n");
917
918 printk(KERN_INFO "CDROM ");
919 switch (cdtype)
920 {
921 case 0x00:
922 printk("Disabled");
923 cdirq = 0;
924 break;
925 case 0x02:
926 printk("Sony CDU31A");
927 dmatype = 1;
928 if(cddma == -1) cddma = 3;
929 break;
930 case 0x04:
931 printk("Mitsumi");
932 dmatype = 0;
933 if(cddma == -1) cddma = 5;
934 break;
935 case 0x06:
936 printk("Panasonic Lasermate");
937 dmatype = 1;
938 if(cddma == -1) cddma = 3;
939 break;
940 case 0x08:
941 printk("Secondary IDE");
942 dmatype = 0;
943 if(cddma == -1) cddma = 5;
944 break;
945 case 0x0A:
946 printk("Primary IDE");
947 dmatype = 0;
948 if(cddma == -1) cddma = 5;
949 break;
950 default:
951 printk("\n");
952 printk(KERN_ERR "Invalid CDROM type\n");
953 return -EINVAL;
954 }
955
956 /*
957 * Build the config words
958 */
959
960 mad16_conf = (joystick ^ 1) | cdtype;
961 mad16_cdsel = 0;
962 if (opl4)
963 mad16_cdsel |= 0x20;
964
965 if(cdtype){
966 if (cddma > 7 || cddma < 0 || dma_map[dmatype][cddma] == -1)
967 {
968 printk("\n");
969 printk(KERN_ERR "Invalid CDROM DMA\n");
970 return -EINVAL;
971 }
972 if (cddma)
973 printk(", DMA %d", cddma);
974 else
975 printk(", no DMA");
976
977 if (!cdirq)
978 printk(", no IRQ");
979 else if (cdirq < 0 || cdirq > 15 || irq_map[cdirq] == -1)
980 {
981 printk(", invalid IRQ (disabling)");
982 cdirq = 0;
983 }
984 else printk(", IRQ %d", cdirq);
985
986 mad16_cdsel |= dma_map[dmatype][cddma];
987
988 if (cdtype < 0x08)
989 {
990 switch (cdport)
991 {
992 case 0x340:
993 mad16_cdsel |= 0x00;
994 break;
995 case 0x330:
996 mad16_cdsel |= 0x40;
997 break;
998 case 0x360:
999 mad16_cdsel |= 0x80;
1000 break;
1001 case 0x320:
1002 mad16_cdsel |= 0xC0;
1003 break;
1004 default:
1005 printk(KERN_ERR "Unknown CDROM I/O base %d\n", cdport);
1006 return -EINVAL;
1007 }
1008 }
1009 mad16_cdsel |= irq_map[cdirq];
1010 }
1011
1012 printk(".\n");
1013 printk(KERN_INFO "Joystick port ");
1014 if (joystick == 1)
1015 printk("enabled.\n");
1016 else
1017 {
1018 joystick = 0;
1019 printk("disabled.\n");
1020 }
1021
1022 cfg.io_base = io;
1023 cfg.irq = irq;
1024 cfg.dma = dma;
1025 cfg.dma2 = dma16;
1026
1027 if (cfg.io_base == -1 || cfg.dma == -1 || cfg.irq == -1) {
1028 printk(KERN_ERR "I/O, DMA and irq are mandatory\n");
1029 return -EINVAL;
1030 }
1031
1032 if (!probe_mad16(&cfg))
1033 return -ENODEV;
1034
1035 cfg_mpu.io_base = mpu_io;
1036 cfg_mpu.irq = mpu_irq;
1037
1038 attach_mad16(&cfg);
1039
1040 found_mpu = probe_mad16_mpu(&cfg_mpu);
1041 return 0;
1042 }
1043
1044 static void __exit cleanup_mad16(void)
1045 {
1046 if (found_mpu)
1047 unload_mad16_mpu(&cfg_mpu);
1048 unload_mad16(&cfg);
1049 }
1050
1051 module_init(init_mad16);
1052 module_exit(cleanup_mad16);
1053
1054 #ifndef MODULE
1055 static int __init setup_mad16(char *str)
1056 {
1057 /* io, irq */
1058 int ints[7];
1059
1060 str = get_options(str, ARRAY_SIZE(ints), ints);
1061
1062 io = ints[1];
1063 irq = ints[2];
1064 dma = ints[3];
1065 dma16 = ints[4];
1066 mpu_io = ints[5];
1067 mpu_irq = ints[6];
1068
1069 return 1;
1070 }
1071
1072 __setup("mad16=", setup_mad16);
1073 #endif
1074