Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
f30c2269 | 2 | * sound/oss/sb_common.c |
1da177e4 LT |
3 | * |
4 | * Common routines for 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 | * Daniel J. Rodriksson: Modified sbintr to handle 8 and 16 bit interrupts | |
15 | * for full duplex support ( only sb16 by now ) | |
16 | * Rolf Fokkens: Added (BETA?) support for ES1887 chips. | |
17 | * (fokkensr@vertis.nl) Which means: You can adjust the recording levels. | |
18 | * | |
19 | * 2000/01/18 - separated sb_card and sb_common - | |
20 | * Jeff Garzik <jgarzik@pobox.com> | |
21 | * | |
22 | * 2000/09/18 - got rid of attach_uart401 | |
23 | * Arnaldo Carvalho de Melo <acme@conectiva.com.br> | |
24 | * | |
25 | * 2001/01/26 - replaced CLI/STI with spinlocks | |
26 | * Chris Rankin <rankinc@zipworld.com.au> | |
27 | */ | |
28 | ||
1da177e4 LT |
29 | #include <linux/init.h> |
30 | #include <linux/interrupt.h> | |
31 | #include <linux/module.h> | |
32 | #include <linux/delay.h> | |
33 | #include <linux/spinlock.h> | |
5a0e3ad6 | 34 | #include <linux/slab.h> |
1da177e4 LT |
35 | |
36 | #include "sound_config.h" | |
37 | #include "sound_firmware.h" | |
38 | ||
39 | #include "mpu401.h" | |
40 | ||
41 | #include "sb_mixer.h" | |
42 | #include "sb.h" | |
43 | #include "sb_ess.h" | |
44 | ||
45 | /* | |
46 | * global module flag | |
47 | */ | |
48 | ||
49 | int sb_be_quiet; | |
50 | ||
51 | static sb_devc *detected_devc; /* For communication from probe to init */ | |
52 | static sb_devc *last_devc; /* For MPU401 initialization */ | |
53 | ||
54 | static unsigned char jazz_irq_bits[] = { | |
55 | 0, 0, 2, 3, 0, 1, 0, 4, 0, 2, 5, 0, 0, 0, 0, 6 | |
56 | }; | |
57 | ||
58 | static unsigned char jazz_dma_bits[] = { | |
59 | 0, 1, 0, 2, 0, 3, 0, 4 | |
60 | }; | |
61 | ||
62 | void *smw_free; | |
63 | ||
64 | /* | |
65 | * Jazz16 chipset specific control variables | |
66 | */ | |
67 | ||
68 | static int jazz16_base; /* Not detected */ | |
69 | static unsigned char jazz16_bits; /* I/O relocation bits */ | |
70 | static DEFINE_SPINLOCK(jazz16_lock); | |
71 | ||
72 | /* | |
73 | * Logitech Soundman Wave specific initialization code | |
74 | */ | |
75 | ||
76 | #ifdef SMW_MIDI0001_INCLUDED | |
77 | #include "smw-midi0001.h" | |
78 | #else | |
79 | static unsigned char *smw_ucode; | |
80 | static int smw_ucodeLen; | |
81 | ||
82 | #endif | |
83 | ||
84 | static sb_devc *last_sb; /* Last sb loaded */ | |
85 | ||
86 | int sb_dsp_command(sb_devc * devc, unsigned char val) | |
87 | { | |
88 | int i; | |
89 | unsigned long limit; | |
90 | ||
91 | limit = jiffies + HZ / 10; /* Timeout */ | |
92 | ||
93 | /* | |
94 | * Note! the i<500000 is an emergency exit. The sb_dsp_command() is sometimes | |
95 | * called while interrupts are disabled. This means that the timer is | |
96 | * disabled also. However the timeout situation is a abnormal condition. | |
97 | * Normally the DSP should be ready to accept commands after just couple of | |
98 | * loops. | |
99 | */ | |
100 | ||
101 | for (i = 0; i < 500000 && (limit-jiffies)>0; i++) | |
102 | { | |
103 | if ((inb(DSP_STATUS) & 0x80) == 0) | |
104 | { | |
105 | outb((val), DSP_COMMAND); | |
106 | return 1; | |
107 | } | |
108 | } | |
109 | printk(KERN_WARNING "Sound Blaster: DSP command(%x) timeout.\n", val); | |
110 | return 0; | |
111 | } | |
112 | ||
113 | int sb_dsp_get_byte(sb_devc * devc) | |
114 | { | |
115 | int i; | |
116 | ||
117 | for (i = 1000; i; i--) | |
118 | { | |
119 | if (inb(DSP_DATA_AVAIL) & 0x80) | |
120 | return inb(DSP_READ); | |
121 | } | |
122 | return 0xffff; | |
123 | } | |
124 | ||
125 | static void sb_intr (sb_devc *devc) | |
126 | { | |
127 | int status; | |
128 | unsigned char src = 0xff; | |
129 | ||
130 | if (devc->model == MDL_SB16) | |
131 | { | |
132 | src = sb_getmixer(devc, IRQ_STAT); /* Interrupt source register */ | |
133 | ||
134 | if (src & 4) /* MPU401 interrupt */ | |
135 | if(devc->midi_irq_cookie) | |
7d12e780 | 136 | uart401intr(devc->irq, devc->midi_irq_cookie); |
1da177e4 LT |
137 | |
138 | if (!(src & 3)) | |
139 | return; /* Not a DSP interrupt */ | |
140 | } | |
141 | if (devc->intr_active && (!devc->fullduplex || (src & 0x01))) | |
142 | { | |
143 | switch (devc->irq_mode) | |
144 | { | |
145 | case IMODE_OUTPUT: | |
146 | DMAbuf_outputintr(devc->dev, 1); | |
147 | break; | |
148 | ||
149 | case IMODE_INPUT: | |
150 | DMAbuf_inputintr(devc->dev); | |
151 | break; | |
152 | ||
153 | case IMODE_INIT: | |
154 | break; | |
155 | ||
156 | case IMODE_MIDI: | |
157 | sb_midi_interrupt(devc); | |
158 | break; | |
159 | ||
160 | default: | |
f702cf46 | 161 | /* printk(KERN_WARNING "Sound Blaster: Unexpected interrupt\n"); */ |
1da177e4 LT |
162 | ; |
163 | } | |
164 | } | |
165 | else if (devc->intr_active_16 && (src & 0x02)) | |
166 | { | |
167 | switch (devc->irq_mode_16) | |
168 | { | |
169 | case IMODE_OUTPUT: | |
170 | DMAbuf_outputintr(devc->dev, 1); | |
171 | break; | |
172 | ||
173 | case IMODE_INPUT: | |
174 | DMAbuf_inputintr(devc->dev); | |
175 | break; | |
176 | ||
177 | case IMODE_INIT: | |
178 | break; | |
179 | ||
180 | default: | |
f702cf46 | 181 | /* printk(KERN_WARNING "Sound Blaster: Unexpected interrupt\n"); */ |
1da177e4 LT |
182 | ; |
183 | } | |
184 | } | |
185 | /* | |
186 | * Acknowledge interrupts | |
187 | */ | |
188 | ||
189 | if (src & 0x01) | |
190 | status = inb(DSP_DATA_AVAIL); | |
191 | ||
192 | if (devc->model == MDL_SB16 && src & 0x02) | |
193 | status = inb(DSP_DATA_AVL16); | |
194 | } | |
195 | ||
196 | static void pci_intr(sb_devc *devc) | |
197 | { | |
198 | int src = inb(devc->pcibase+0x1A); | |
199 | src&=3; | |
200 | if(src) | |
201 | sb_intr(devc); | |
202 | } | |
203 | ||
7d12e780 | 204 | static irqreturn_t sbintr(int irq, void *dev_id) |
1da177e4 LT |
205 | { |
206 | sb_devc *devc = dev_id; | |
207 | ||
208 | devc->irq_ok = 1; | |
209 | ||
210 | switch (devc->model) { | |
211 | case MDL_ESSPCI: | |
212 | pci_intr (devc); | |
213 | break; | |
214 | ||
215 | case MDL_ESS: | |
216 | ess_intr (devc); | |
217 | break; | |
218 | default: | |
219 | sb_intr (devc); | |
220 | break; | |
221 | } | |
222 | return IRQ_HANDLED; | |
223 | } | |
224 | ||
225 | int sb_dsp_reset(sb_devc * devc) | |
226 | { | |
227 | int loopc; | |
228 | ||
229 | DEB(printk("Entered sb_dsp_reset()\n")); | |
230 | ||
231 | if (devc->model == MDL_ESS) return ess_dsp_reset (devc); | |
232 | ||
233 | /* This is only for non-ESS chips */ | |
234 | ||
235 | outb(1, DSP_RESET); | |
236 | ||
237 | udelay(10); | |
238 | outb(0, DSP_RESET); | |
239 | udelay(30); | |
240 | ||
241 | for (loopc = 0; loopc < 1000 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++); | |
242 | ||
243 | if (inb(DSP_READ) != 0xAA) | |
244 | { | |
245 | DDB(printk("sb: No response to RESET\n")); | |
246 | return 0; /* Sorry */ | |
247 | } | |
248 | ||
249 | DEB(printk("sb_dsp_reset() OK\n")); | |
250 | ||
251 | return 1; | |
252 | } | |
253 | ||
254 | static void dsp_get_vers(sb_devc * devc) | |
255 | { | |
256 | int i; | |
257 | ||
258 | unsigned long flags; | |
259 | ||
260 | DDB(printk("Entered dsp_get_vers()\n")); | |
261 | spin_lock_irqsave(&devc->lock, flags); | |
262 | devc->major = devc->minor = 0; | |
263 | sb_dsp_command(devc, 0xe1); /* Get version */ | |
264 | ||
265 | for (i = 100000; i; i--) | |
266 | { | |
267 | if (inb(DSP_DATA_AVAIL) & 0x80) | |
268 | { | |
269 | if (devc->major == 0) | |
270 | devc->major = inb(DSP_READ); | |
271 | else | |
272 | { | |
273 | devc->minor = inb(DSP_READ); | |
274 | break; | |
275 | } | |
276 | } | |
277 | } | |
278 | spin_unlock_irqrestore(&devc->lock, flags); | |
279 | DDB(printk("DSP version %d.%02d\n", devc->major, devc->minor)); | |
280 | } | |
281 | ||
282 | static int sb16_set_dma_hw(sb_devc * devc) | |
283 | { | |
284 | int bits; | |
285 | ||
286 | if (devc->dma8 != 0 && devc->dma8 != 1 && devc->dma8 != 3) | |
287 | { | |
288 | printk(KERN_ERR "SB16: Invalid 8 bit DMA (%d)\n", devc->dma8); | |
289 | return 0; | |
290 | } | |
291 | bits = (1 << devc->dma8); | |
292 | ||
293 | if (devc->dma16 >= 5 && devc->dma16 <= 7) | |
294 | bits |= (1 << devc->dma16); | |
295 | ||
296 | sb_setmixer(devc, DMA_NR, bits); | |
297 | return 1; | |
298 | } | |
299 | ||
300 | static void sb16_set_mpu_port(sb_devc * devc, struct address_info *hw_config) | |
301 | { | |
302 | /* | |
303 | * This routine initializes new MIDI port setup register of SB Vibra (CT2502). | |
304 | */ | |
305 | unsigned char bits = sb_getmixer(devc, 0x84) & ~0x06; | |
306 | ||
307 | switch (hw_config->io_base) | |
308 | { | |
309 | case 0x300: | |
310 | sb_setmixer(devc, 0x84, bits | 0x04); | |
311 | break; | |
312 | ||
313 | case 0x330: | |
314 | sb_setmixer(devc, 0x84, bits | 0x00); | |
315 | break; | |
316 | ||
317 | default: | |
318 | sb_setmixer(devc, 0x84, bits | 0x02); /* Disable MPU */ | |
319 | printk(KERN_ERR "SB16: Invalid MIDI I/O port %x\n", hw_config->io_base); | |
320 | } | |
321 | } | |
322 | ||
323 | static int sb16_set_irq_hw(sb_devc * devc, int level) | |
324 | { | |
325 | int ival; | |
326 | ||
327 | switch (level) | |
328 | { | |
329 | case 5: | |
330 | ival = 2; | |
331 | break; | |
332 | case 7: | |
333 | ival = 4; | |
334 | break; | |
335 | case 9: | |
336 | ival = 1; | |
337 | break; | |
338 | case 10: | |
339 | ival = 8; | |
340 | break; | |
341 | default: | |
342 | printk(KERN_ERR "SB16: Invalid IRQ%d\n", level); | |
343 | return 0; | |
344 | } | |
345 | sb_setmixer(devc, IRQ_NR, ival); | |
346 | return 1; | |
347 | } | |
348 | ||
349 | static void relocate_Jazz16(sb_devc * devc, struct address_info *hw_config) | |
350 | { | |
351 | unsigned char bits = 0; | |
352 | unsigned long flags; | |
353 | ||
354 | if (jazz16_base != 0 && jazz16_base != hw_config->io_base) | |
355 | return; | |
356 | ||
357 | switch (hw_config->io_base) | |
358 | { | |
359 | case 0x220: | |
360 | bits = 1; | |
361 | break; | |
362 | case 0x240: | |
363 | bits = 2; | |
364 | break; | |
365 | case 0x260: | |
366 | bits = 3; | |
367 | break; | |
368 | default: | |
369 | return; | |
370 | } | |
371 | bits = jazz16_bits = bits << 5; | |
372 | jazz16_base = hw_config->io_base; | |
373 | ||
374 | /* | |
375 | * Magic wake up sequence by writing to 0x201 (aka Joystick port) | |
376 | */ | |
377 | spin_lock_irqsave(&jazz16_lock, flags); | |
378 | outb((0xAF), 0x201); | |
379 | outb((0x50), 0x201); | |
380 | outb((bits), 0x201); | |
381 | spin_unlock_irqrestore(&jazz16_lock, flags); | |
382 | } | |
383 | ||
384 | static int init_Jazz16(sb_devc * devc, struct address_info *hw_config) | |
385 | { | |
386 | char name[100]; | |
387 | /* | |
388 | * First try to check that the card has Jazz16 chip. It identifies itself | |
389 | * by returning 0x12 as response to DSP command 0xfa. | |
390 | */ | |
391 | ||
392 | if (!sb_dsp_command(devc, 0xfa)) | |
393 | return 0; | |
394 | ||
395 | if (sb_dsp_get_byte(devc) != 0x12) | |
396 | return 0; | |
397 | ||
398 | /* | |
399 | * OK so far. Now configure the IRQ and DMA channel used by the card. | |
400 | */ | |
401 | if (hw_config->irq < 1 || hw_config->irq > 15 || jazz_irq_bits[hw_config->irq] == 0) | |
402 | { | |
403 | printk(KERN_ERR "Jazz16: Invalid interrupt (IRQ%d)\n", hw_config->irq); | |
404 | return 0; | |
405 | } | |
406 | if (hw_config->dma < 0 || hw_config->dma > 3 || jazz_dma_bits[hw_config->dma] == 0) | |
407 | { | |
408 | printk(KERN_ERR "Jazz16: Invalid 8 bit DMA (DMA%d)\n", hw_config->dma); | |
409 | return 0; | |
410 | } | |
411 | if (hw_config->dma2 < 0) | |
412 | { | |
413 | printk(KERN_ERR "Jazz16: No 16 bit DMA channel defined\n"); | |
414 | return 0; | |
415 | } | |
416 | if (hw_config->dma2 < 5 || hw_config->dma2 > 7 || jazz_dma_bits[hw_config->dma2] == 0) | |
417 | { | |
418 | printk(KERN_ERR "Jazz16: Invalid 16 bit DMA (DMA%d)\n", hw_config->dma2); | |
419 | return 0; | |
420 | } | |
421 | devc->dma16 = hw_config->dma2; | |
422 | ||
423 | if (!sb_dsp_command(devc, 0xfb)) | |
424 | return 0; | |
425 | ||
426 | if (!sb_dsp_command(devc, jazz_dma_bits[hw_config->dma] | | |
427 | (jazz_dma_bits[hw_config->dma2] << 4))) | |
428 | return 0; | |
429 | ||
430 | if (!sb_dsp_command(devc, jazz_irq_bits[hw_config->irq])) | |
431 | return 0; | |
432 | ||
433 | /* | |
434 | * Now we have configured a standard Jazz16 device. | |
435 | */ | |
436 | devc->model = MDL_JAZZ; | |
437 | strcpy(name, "Jazz16"); | |
438 | ||
439 | hw_config->name = "Jazz16"; | |
440 | devc->caps |= SB_NO_MIDI; | |
441 | return 1; | |
442 | } | |
443 | ||
444 | static void relocate_ess1688(sb_devc * devc) | |
445 | { | |
446 | unsigned char bits; | |
447 | ||
448 | switch (devc->base) | |
449 | { | |
450 | case 0x220: | |
451 | bits = 0x04; | |
452 | break; | |
453 | case 0x230: | |
454 | bits = 0x05; | |
455 | break; | |
456 | case 0x240: | |
457 | bits = 0x06; | |
458 | break; | |
459 | case 0x250: | |
460 | bits = 0x07; | |
461 | break; | |
462 | default: | |
463 | return; /* Wrong port */ | |
464 | } | |
465 | ||
466 | DDB(printk("Doing ESS1688 address selection\n")); | |
467 | ||
468 | /* | |
469 | * ES1688 supports two alternative ways for software address config. | |
470 | * First try the so called Read-Sequence-Key method. | |
471 | */ | |
472 | ||
473 | /* Reset the sequence logic */ | |
474 | inb(0x229); | |
475 | inb(0x229); | |
476 | inb(0x229); | |
477 | ||
478 | /* Perform the read sequence */ | |
479 | inb(0x22b); | |
480 | inb(0x229); | |
481 | inb(0x22b); | |
482 | inb(0x229); | |
483 | inb(0x229); | |
484 | inb(0x22b); | |
485 | inb(0x229); | |
486 | ||
487 | /* Select the base address by reading from it. Then probe using the port. */ | |
488 | inb(devc->base); | |
489 | if (sb_dsp_reset(devc)) /* Bingo */ | |
490 | return; | |
491 | ||
492 | #if 0 /* This causes system lockups (Nokia 386/25 at least) */ | |
493 | /* | |
494 | * The last resort is the system control register method. | |
495 | */ | |
496 | ||
497 | outb((0x00), 0xfb); /* 0xFB is the unlock register */ | |
498 | outb((0x00), 0xe0); /* Select index 0 */ | |
499 | outb((bits), 0xe1); /* Write the config bits */ | |
500 | outb((0x00), 0xf9); /* 0xFB is the lock register */ | |
501 | #endif | |
502 | } | |
503 | ||
504 | int sb_dsp_detect(struct address_info *hw_config, int pci, int pciio, struct sb_module_options *sbmo) | |
505 | { | |
506 | sb_devc sb_info; | |
507 | sb_devc *devc = &sb_info; | |
508 | ||
509 | memset((char *) &sb_info, 0, sizeof(sb_info)); /* Zero everything */ | |
510 | ||
511 | /* Copy module options in place */ | |
512 | if(sbmo) memcpy(&devc->sbmo, sbmo, sizeof(struct sb_module_options)); | |
513 | ||
514 | sb_info.my_mididev = -1; | |
515 | sb_info.my_mixerdev = -1; | |
516 | sb_info.dev = -1; | |
517 | ||
518 | /* | |
519 | * Initialize variables | |
520 | */ | |
521 | ||
522 | DDB(printk("sb_dsp_detect(%x) entered\n", hw_config->io_base)); | |
523 | ||
524 | spin_lock_init(&devc->lock); | |
525 | devc->type = hw_config->card_subtype; | |
526 | ||
527 | devc->base = hw_config->io_base; | |
528 | devc->irq = hw_config->irq; | |
529 | devc->dma8 = hw_config->dma; | |
530 | ||
531 | devc->dma16 = -1; | |
532 | devc->pcibase = pciio; | |
533 | ||
534 | if(pci == SB_PCI_ESSMAESTRO) | |
535 | { | |
536 | devc->model = MDL_ESSPCI; | |
537 | devc->caps |= SB_PCI_IRQ; | |
538 | hw_config->driver_use_1 |= SB_PCI_IRQ; | |
539 | hw_config->card_subtype = MDL_ESSPCI; | |
540 | } | |
541 | ||
542 | if(pci == SB_PCI_YAMAHA) | |
543 | { | |
544 | devc->model = MDL_YMPCI; | |
545 | devc->caps |= SB_PCI_IRQ; | |
546 | hw_config->driver_use_1 |= SB_PCI_IRQ; | |
547 | hw_config->card_subtype = MDL_YMPCI; | |
548 | ||
549 | printk("Yamaha PCI mode.\n"); | |
550 | } | |
551 | ||
552 | if (devc->sbmo.acer) | |
553 | { | |
554 | unsigned long flags; | |
555 | ||
556 | spin_lock_irqsave(&devc->lock, flags); | |
557 | inb(devc->base + 0x09); | |
558 | inb(devc->base + 0x09); | |
559 | inb(devc->base + 0x09); | |
560 | inb(devc->base + 0x0b); | |
561 | inb(devc->base + 0x09); | |
562 | inb(devc->base + 0x0b); | |
563 | inb(devc->base + 0x09); | |
564 | inb(devc->base + 0x09); | |
565 | inb(devc->base + 0x0b); | |
566 | inb(devc->base + 0x09); | |
567 | inb(devc->base + 0x00); | |
568 | spin_unlock_irqrestore(&devc->lock, flags); | |
569 | } | |
570 | /* | |
571 | * Detect the device | |
572 | */ | |
573 | ||
574 | if (sb_dsp_reset(devc)) | |
575 | dsp_get_vers(devc); | |
576 | else | |
577 | devc->major = 0; | |
578 | ||
579 | if (devc->type == 0 || devc->type == MDL_JAZZ || devc->type == MDL_SMW) | |
580 | if (devc->major == 0 || (devc->major == 3 && devc->minor == 1)) | |
581 | relocate_Jazz16(devc, hw_config); | |
582 | ||
583 | if (devc->major == 0 && (devc->type == MDL_ESS || devc->type == 0)) | |
584 | relocate_ess1688(devc); | |
585 | ||
586 | if (!sb_dsp_reset(devc)) | |
587 | { | |
588 | DDB(printk("SB reset failed\n")); | |
589 | #ifdef MODULE | |
590 | printk(KERN_INFO "sb: dsp reset failed.\n"); | |
591 | #endif | |
592 | return 0; | |
593 | } | |
594 | if (devc->major == 0) | |
595 | dsp_get_vers(devc); | |
596 | ||
597 | if (devc->major == 3 && devc->minor == 1) | |
598 | { | |
599 | if (devc->type == MDL_AZTECH) /* SG Washington? */ | |
600 | { | |
601 | if (sb_dsp_command(devc, 0x09)) | |
602 | if (sb_dsp_command(devc, 0x00)) /* Enter WSS mode */ | |
603 | { | |
604 | int i; | |
605 | ||
606 | /* Have some delay */ | |
607 | for (i = 0; i < 10000; i++) | |
608 | inb(DSP_DATA_AVAIL); | |
609 | devc->caps = SB_NO_AUDIO | SB_NO_MIDI; /* Mixer only */ | |
610 | devc->model = MDL_AZTECH; | |
611 | } | |
612 | } | |
613 | } | |
614 | ||
615 | if(devc->type == MDL_ESSPCI) | |
616 | devc->model = MDL_ESSPCI; | |
617 | ||
618 | if(devc->type == MDL_YMPCI) | |
619 | { | |
620 | printk("YMPCI selected\n"); | |
621 | devc->model = MDL_YMPCI; | |
622 | } | |
623 | ||
624 | /* | |
625 | * Save device information for sb_dsp_init() | |
626 | */ | |
627 | ||
628 | ||
b8e63df9 | 629 | detected_devc = kmemdup(devc, sizeof(sb_devc), GFP_KERNEL); |
1da177e4 LT |
630 | if (detected_devc == NULL) |
631 | { | |
632 | printk(KERN_ERR "sb: Can't allocate memory for device information\n"); | |
633 | return 0; | |
634 | } | |
1da177e4 LT |
635 | MDB(printk(KERN_INFO "SB %d.%02d detected OK (%x)\n", devc->major, devc->minor, hw_config->io_base)); |
636 | return 1; | |
637 | } | |
638 | ||
639 | int sb_dsp_init(struct address_info *hw_config, struct module *owner) | |
640 | { | |
641 | sb_devc *devc; | |
642 | char name[100]; | |
643 | extern int sb_be_quiet; | |
644 | int mixer22, mixer30; | |
645 | ||
646 | /* | |
647 | * Check if we had detected a SB device earlier | |
648 | */ | |
649 | DDB(printk("sb_dsp_init(%x) entered\n", hw_config->io_base)); | |
650 | name[0] = 0; | |
651 | ||
652 | if (detected_devc == NULL) | |
653 | { | |
654 | MDB(printk("No detected device\n")); | |
655 | return 0; | |
656 | } | |
657 | devc = detected_devc; | |
658 | detected_devc = NULL; | |
659 | ||
660 | if (devc->base != hw_config->io_base) | |
661 | { | |
662 | DDB(printk("I/O port mismatch\n")); | |
663 | release_region(devc->base, 16); | |
664 | return 0; | |
665 | } | |
666 | /* | |
667 | * Now continue initialization of the device | |
668 | */ | |
669 | ||
670 | devc->caps = hw_config->driver_use_1; | |
671 | ||
672 | if (!((devc->caps & SB_NO_AUDIO) && (devc->caps & SB_NO_MIDI)) && hw_config->irq > 0) | |
673 | { /* IRQ setup */ | |
674 | ||
675 | /* | |
676 | * ESS PCI cards do shared PCI IRQ stuff. Since they | |
677 | * will get shared PCI irq lines we must cope. | |
678 | */ | |
679 | ||
65ca68b3 | 680 | int i=(devc->caps&SB_PCI_IRQ)?IRQF_SHARED:0; |
1da177e4 LT |
681 | |
682 | if (request_irq(hw_config->irq, sbintr, i, "soundblaster", devc) < 0) | |
683 | { | |
684 | printk(KERN_ERR "SB: Can't allocate IRQ%d\n", hw_config->irq); | |
685 | release_region(devc->base, 16); | |
686 | return 0; | |
687 | } | |
688 | devc->irq_ok = 0; | |
689 | ||
690 | if (devc->major == 4) | |
691 | if (!sb16_set_irq_hw(devc, devc->irq)) /* Unsupported IRQ */ | |
692 | { | |
693 | free_irq(devc->irq, devc); | |
694 | release_region(devc->base, 16); | |
695 | return 0; | |
696 | } | |
697 | if ((devc->type == 0 || devc->type == MDL_ESS) && | |
698 | devc->major == 3 && devc->minor == 1) | |
699 | { /* Handle various chipsets which claim they are SB Pro compatible */ | |
700 | if ((devc->type != 0 && devc->type != MDL_ESS) || | |
701 | !ess_init(devc, hw_config)) | |
702 | { | |
703 | if ((devc->type != 0 && devc->type != MDL_JAZZ && | |
704 | devc->type != MDL_SMW) || !init_Jazz16(devc, hw_config)) | |
705 | { | |
706 | DDB(printk("This is a genuine SB Pro\n")); | |
707 | } | |
708 | } | |
709 | } | |
710 | if (devc->major == 4 && devc->minor <= 11 ) /* Won't work */ | |
711 | devc->irq_ok = 1; | |
712 | else | |
713 | { | |
714 | int n; | |
715 | ||
716 | for (n = 0; n < 3 && devc->irq_ok == 0; n++) | |
717 | { | |
718 | if (sb_dsp_command(devc, 0xf2)) /* Cause interrupt immediately */ | |
719 | { | |
720 | int i; | |
721 | ||
722 | for (i = 0; !devc->irq_ok && i < 10000; i++); | |
723 | } | |
724 | } | |
725 | if (!devc->irq_ok) | |
726 | printk(KERN_WARNING "sb: Interrupt test on IRQ%d failed - Probable IRQ conflict\n", devc->irq); | |
727 | else | |
728 | { | |
729 | DDB(printk("IRQ test OK (IRQ%d)\n", devc->irq)); | |
730 | } | |
731 | } | |
732 | } /* IRQ setup */ | |
733 | ||
734 | last_sb = devc; | |
735 | ||
736 | switch (devc->major) | |
737 | { | |
738 | case 1: /* SB 1.0 or 1.5 */ | |
739 | devc->model = hw_config->card_subtype = MDL_SB1; | |
740 | break; | |
741 | ||
742 | case 2: /* SB 2.x */ | |
743 | if (devc->minor == 0) | |
744 | devc->model = hw_config->card_subtype = MDL_SB2; | |
745 | else | |
746 | devc->model = hw_config->card_subtype = MDL_SB201; | |
747 | break; | |
748 | ||
749 | case 3: /* SB Pro and most clones */ | |
750 | switch (devc->model) { | |
751 | case 0: | |
752 | devc->model = hw_config->card_subtype = MDL_SBPRO; | |
753 | if (hw_config->name == NULL) | |
754 | hw_config->name = "Sound Blaster Pro (8 BIT ONLY)"; | |
755 | break; | |
756 | case MDL_ESS: | |
757 | ess_dsp_init(devc, hw_config); | |
758 | break; | |
759 | } | |
760 | break; | |
761 | ||
762 | case 4: | |
763 | devc->model = hw_config->card_subtype = MDL_SB16; | |
764 | /* | |
765 | * ALS007 and ALS100 return DSP version 4.2 and have 2 post-reset !=0 | |
766 | * registers at 0x3c and 0x4c (output ctrl registers on ALS007) whereas | |
767 | * a "standard" SB16 doesn't have a register at 0x4c. ALS100 actively | |
768 | * updates register 0x22 whenever 0x30 changes, as per the SB16 spec. | |
769 | * Since ALS007 doesn't, this can be used to differentiate the 2 cards. | |
770 | */ | |
771 | if ((devc->minor == 2) && sb_getmixer(devc,0x3c) && sb_getmixer(devc,0x4c)) | |
772 | { | |
773 | mixer30 = sb_getmixer(devc,0x30); | |
774 | sb_setmixer(devc,0x22,(mixer22=sb_getmixer(devc,0x22)) & 0x0f); | |
775 | sb_setmixer(devc,0x30,0xff); | |
776 | /* ALS100 will force 0x30 to 0xf8 like SB16; ALS007 will allow 0xff. */ | |
777 | /* Register 0x22 & 0xf0 on ALS100 == 0xf0; on ALS007 it == 0x10. */ | |
778 | if ((sb_getmixer(devc,0x30) != 0xff) || ((sb_getmixer(devc,0x22) & 0xf0) != 0x10)) | |
779 | { | |
780 | devc->submodel = SUBMDL_ALS100; | |
781 | if (hw_config->name == NULL) | |
782 | hw_config->name = "Sound Blaster 16 (ALS-100)"; | |
783 | } | |
784 | else | |
785 | { | |
786 | sb_setmixer(devc,0x3c,0x1f); /* Enable all inputs */ | |
787 | sb_setmixer(devc,0x4c,0x1f); | |
788 | sb_setmixer(devc,0x22,mixer22); /* Restore 0x22 to original value */ | |
789 | devc->submodel = SUBMDL_ALS007; | |
790 | if (hw_config->name == NULL) | |
791 | hw_config->name = "Sound Blaster 16 (ALS-007)"; | |
792 | } | |
793 | sb_setmixer(devc,0x30,mixer30); | |
794 | } | |
795 | else if (hw_config->name == NULL) | |
796 | hw_config->name = "Sound Blaster 16"; | |
797 | ||
798 | if (hw_config->dma2 == -1) | |
799 | devc->dma16 = devc->dma8; | |
800 | else if (hw_config->dma2 < 5 || hw_config->dma2 > 7) | |
801 | { | |
802 | printk(KERN_WARNING "SB16: Bad or missing 16 bit DMA channel\n"); | |
803 | devc->dma16 = devc->dma8; | |
804 | } | |
805 | else | |
806 | devc->dma16 = hw_config->dma2; | |
807 | ||
808 | if(!sb16_set_dma_hw(devc)) { | |
809 | free_irq(devc->irq, devc); | |
810 | release_region(hw_config->io_base, 16); | |
811 | return 0; | |
812 | } | |
813 | ||
814 | devc->caps |= SB_NO_MIDI; | |
815 | } | |
816 | ||
817 | if (!(devc->caps & SB_NO_MIXER)) | |
818 | if (devc->major == 3 || devc->major == 4) | |
819 | sb_mixer_init(devc, owner); | |
820 | ||
821 | if (!(devc->caps & SB_NO_MIDI)) | |
822 | sb_dsp_midi_init(devc, owner); | |
823 | ||
824 | if (hw_config->name == NULL) | |
825 | hw_config->name = "Sound Blaster (8 BIT/MONO ONLY)"; | |
826 | ||
827 | sprintf(name, "%s (%d.%02d)", hw_config->name, devc->major, devc->minor); | |
828 | conf_printf(name, hw_config); | |
829 | ||
830 | /* | |
831 | * Assuming that a sound card is Sound Blaster (compatible) is the most common | |
832 | * configuration error and the mother of all problems. Usually sound cards | |
833 | * emulate SB Pro but in addition they have a 16 bit native mode which should be | |
834 | * used in Unix. See Readme.cards for more information about configuring OSS/Free | |
835 | * properly. | |
836 | */ | |
837 | if (devc->model <= MDL_SBPRO) | |
838 | { | |
839 | if (devc->major == 3 && devc->minor != 1) /* "True" SB Pro should have v3.1 (rare ones may have 3.2). */ | |
840 | { | |
841 | printk(KERN_INFO "This sound card may not be fully Sound Blaster Pro compatible.\n"); | |
842 | printk(KERN_INFO "In many cases there is another way to configure OSS so that\n"); | |
843 | printk(KERN_INFO "it works properly with OSS (for example in 16 bit mode).\n"); | |
844 | printk(KERN_INFO "Please ignore this message if you _really_ have a SB Pro.\n"); | |
845 | } | |
846 | else if (!sb_be_quiet && devc->model == MDL_SBPRO) | |
847 | { | |
848 | printk(KERN_INFO "SB DSP version is just %d.%02d which means that your card is\n", devc->major, devc->minor); | |
849 | printk(KERN_INFO "several years old (8 bit only device) or alternatively the sound driver\n"); | |
850 | printk(KERN_INFO "is incorrectly configured.\n"); | |
851 | } | |
852 | } | |
853 | hw_config->card_subtype = devc->model; | |
854 | hw_config->slots[0]=devc->dev; | |
855 | last_devc = devc; /* For SB MPU detection */ | |
856 | ||
857 | if (!(devc->caps & SB_NO_AUDIO) && devc->dma8 >= 0) | |
858 | { | |
859 | if (sound_alloc_dma(devc->dma8, "SoundBlaster8")) | |
860 | { | |
861 | printk(KERN_WARNING "Sound Blaster: Can't allocate 8 bit DMA channel %d\n", devc->dma8); | |
862 | } | |
863 | if (devc->dma16 >= 0 && devc->dma16 != devc->dma8) | |
864 | { | |
865 | if (sound_alloc_dma(devc->dma16, "SoundBlaster16")) | |
866 | printk(KERN_WARNING "Sound Blaster: can't allocate 16 bit DMA channel %d.\n", devc->dma16); | |
867 | } | |
868 | sb_audio_init(devc, name, owner); | |
869 | hw_config->slots[0]=devc->dev; | |
870 | } | |
871 | else | |
872 | { | |
873 | MDB(printk("Sound Blaster: no audio devices found.\n")); | |
874 | } | |
875 | return 1; | |
876 | } | |
877 | ||
878 | /* if (sbmpu) below we allow mpu401 to manage the midi devs | |
879 | otherwise we have to unload them. (Andrzej Krzysztofowicz) */ | |
880 | ||
881 | void sb_dsp_unload(struct address_info *hw_config, int sbmpu) | |
882 | { | |
883 | sb_devc *devc; | |
884 | ||
885 | devc = audio_devs[hw_config->slots[0]]->devc; | |
886 | ||
887 | if (devc && devc->base == hw_config->io_base) | |
888 | { | |
889 | if ((devc->model & MDL_ESS) && devc->pcibase) | |
890 | release_region(devc->pcibase, 8); | |
891 | ||
892 | release_region(devc->base, 16); | |
893 | ||
894 | if (!(devc->caps & SB_NO_AUDIO)) | |
895 | { | |
896 | sound_free_dma(devc->dma8); | |
897 | if (devc->dma16 >= 0) | |
898 | sound_free_dma(devc->dma16); | |
899 | } | |
900 | if (!(devc->caps & SB_NO_AUDIO && devc->caps & SB_NO_MIDI)) | |
901 | { | |
902 | if (devc->irq > 0) | |
903 | free_irq(devc->irq, devc); | |
904 | ||
905 | sb_mixer_unload(devc); | |
906 | /* We don't have to do this bit any more the UART401 is its own | |
907 | master -- Krzysztof Halasa */ | |
908 | /* But we have to do it, if UART401 is not detected */ | |
909 | if (!sbmpu) | |
910 | sound_unload_mididev(devc->my_mididev); | |
911 | sound_unload_audiodev(devc->dev); | |
912 | } | |
913 | kfree(devc); | |
914 | } | |
915 | else | |
916 | release_region(hw_config->io_base, 16); | |
09417379 JJ |
917 | |
918 | kfree(detected_devc); | |
1da177e4 LT |
919 | } |
920 | ||
921 | /* | |
922 | * Mixer access routines | |
923 | * | |
924 | * ES1887 modifications: some mixer registers reside in the | |
925 | * range above 0xa0. These must be accessed in another way. | |
926 | */ | |
927 | ||
928 | void sb_setmixer(sb_devc * devc, unsigned int port, unsigned int value) | |
929 | { | |
930 | unsigned long flags; | |
931 | ||
932 | if (devc->model == MDL_ESS) { | |
933 | ess_setmixer (devc, port, value); | |
934 | return; | |
935 | } | |
936 | ||
937 | spin_lock_irqsave(&devc->lock, flags); | |
938 | ||
939 | outb(((unsigned char) (port & 0xff)), MIXER_ADDR); | |
940 | udelay(20); | |
941 | outb(((unsigned char) (value & 0xff)), MIXER_DATA); | |
942 | udelay(20); | |
943 | ||
944 | spin_unlock_irqrestore(&devc->lock, flags); | |
945 | } | |
946 | ||
947 | unsigned int sb_getmixer(sb_devc * devc, unsigned int port) | |
948 | { | |
949 | unsigned int val; | |
950 | unsigned long flags; | |
951 | ||
952 | if (devc->model == MDL_ESS) return ess_getmixer (devc, port); | |
953 | ||
954 | spin_lock_irqsave(&devc->lock, flags); | |
955 | ||
956 | outb(((unsigned char) (port & 0xff)), MIXER_ADDR); | |
957 | udelay(20); | |
958 | val = inb(MIXER_DATA); | |
959 | udelay(20); | |
960 | ||
961 | spin_unlock_irqrestore(&devc->lock, flags); | |
962 | ||
963 | return val; | |
964 | } | |
965 | ||
966 | void sb_chgmixer | |
967 | (sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val) | |
968 | { | |
969 | int value; | |
970 | ||
971 | value = sb_getmixer(devc, reg); | |
972 | value = (value & ~mask) | (val & mask); | |
973 | sb_setmixer(devc, reg, value); | |
974 | } | |
975 | ||
976 | /* | |
977 | * MPU401 MIDI initialization. | |
978 | */ | |
979 | ||
980 | static void smw_putmem(sb_devc * devc, int base, int addr, unsigned char val) | |
981 | { | |
982 | unsigned long flags; | |
983 | ||
984 | spin_lock_irqsave(&jazz16_lock, flags); /* NOT the SB card? */ | |
985 | ||
986 | outb((addr & 0xff), base + 1); /* Low address bits */ | |
987 | outb((addr >> 8), base + 2); /* High address bits */ | |
988 | outb((val), base); /* Data */ | |
989 | ||
990 | spin_unlock_irqrestore(&jazz16_lock, flags); | |
991 | } | |
992 | ||
993 | static unsigned char smw_getmem(sb_devc * devc, int base, int addr) | |
994 | { | |
995 | unsigned long flags; | |
996 | unsigned char val; | |
997 | ||
998 | spin_lock_irqsave(&jazz16_lock, flags); /* NOT the SB card? */ | |
999 | ||
1000 | outb((addr & 0xff), base + 1); /* Low address bits */ | |
1001 | outb((addr >> 8), base + 2); /* High address bits */ | |
1002 | val = inb(base); /* Data */ | |
1003 | ||
1004 | spin_unlock_irqrestore(&jazz16_lock, flags); | |
1005 | return val; | |
1006 | } | |
1007 | ||
1008 | static int smw_midi_init(sb_devc * devc, struct address_info *hw_config) | |
1009 | { | |
1010 | int mpu_base = hw_config->io_base; | |
1011 | int mp_base = mpu_base + 4; /* Microcontroller base */ | |
1012 | int i; | |
1013 | unsigned char control; | |
1014 | ||
1015 | ||
1016 | /* | |
1017 | * Reset the microcontroller so that the RAM can be accessed | |
1018 | */ | |
1019 | ||
1020 | control = inb(mpu_base + 7); | |
1021 | outb((control | 3), mpu_base + 7); /* Set last two bits to 1 (?) */ | |
1022 | outb(((control & 0xfe) | 2), mpu_base + 7); /* xxxxxxx0 resets the mc */ | |
1023 | ||
1024 | mdelay(3); /* Wait at least 1ms */ | |
1025 | ||
1026 | outb((control & 0xfc), mpu_base + 7); /* xxxxxx00 enables RAM */ | |
1027 | ||
1028 | /* | |
1029 | * Detect microcontroller by probing the 8k RAM area | |
1030 | */ | |
1031 | smw_putmem(devc, mp_base, 0, 0x00); | |
1032 | smw_putmem(devc, mp_base, 1, 0xff); | |
1033 | udelay(10); | |
1034 | ||
1035 | if (smw_getmem(devc, mp_base, 0) != 0x00 || smw_getmem(devc, mp_base, 1) != 0xff) | |
1036 | { | |
1037 | DDB(printk("SM Wave: No microcontroller RAM detected (%02x, %02x)\n", smw_getmem(devc, mp_base, 0), smw_getmem(devc, mp_base, 1))); | |
1038 | return 0; /* No RAM */ | |
1039 | } | |
1040 | /* | |
1041 | * There is RAM so assume it's really a SM Wave | |
1042 | */ | |
1043 | ||
1044 | devc->model = MDL_SMW; | |
1045 | smw_mixer_init(devc); | |
1046 | ||
1047 | #ifdef MODULE | |
1048 | if (!smw_ucode) | |
1049 | { | |
1050 | smw_ucodeLen = mod_firmware_load("/etc/sound/midi0001.bin", (void *) &smw_ucode); | |
1051 | smw_free = smw_ucode; | |
1052 | } | |
1053 | #endif | |
1054 | if (smw_ucodeLen > 0) | |
1055 | { | |
1056 | if (smw_ucodeLen != 8192) | |
1057 | { | |
1058 | printk(KERN_ERR "SM Wave: Invalid microcode (MIDI0001.BIN) length\n"); | |
1059 | return 1; | |
1060 | } | |
1061 | /* | |
1062 | * Download microcode | |
1063 | */ | |
1064 | ||
1065 | for (i = 0; i < 8192; i++) | |
1066 | smw_putmem(devc, mp_base, i, smw_ucode[i]); | |
1067 | ||
1068 | /* | |
1069 | * Verify microcode | |
1070 | */ | |
1071 | ||
1072 | for (i = 0; i < 8192; i++) | |
1073 | if (smw_getmem(devc, mp_base, i) != smw_ucode[i]) | |
1074 | { | |
1075 | printk(KERN_ERR "SM Wave: Microcode verification failed\n"); | |
1076 | return 0; | |
1077 | } | |
1078 | } | |
1079 | control = 0; | |
1080 | #ifdef SMW_SCSI_IRQ | |
1081 | /* | |
1082 | * Set the SCSI interrupt (IRQ2/9, IRQ3 or IRQ10). The SCSI interrupt | |
1083 | * is disabled by default. | |
1084 | * | |
1085 | * FIXME - make this a module option | |
1086 | * | |
1087 | * BTW the Zilog 5380 SCSI controller is located at MPU base + 0x10. | |
1088 | */ | |
1089 | { | |
1090 | static unsigned char scsi_irq_bits[] = { | |
1091 | 0, 0, 3, 1, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0 | |
1092 | }; | |
1093 | control |= scsi_irq_bits[SMW_SCSI_IRQ] << 6; | |
1094 | } | |
1095 | #endif | |
1096 | ||
1097 | #ifdef SMW_OPL4_ENABLE | |
1098 | /* | |
1099 | * Make the OPL4 chip visible on the PC bus at 0x380. | |
1100 | * | |
1101 | * There is no need to enable this feature since this driver | |
1102 | * doesn't support OPL4 yet. Also there is no RAM in SM Wave so | |
1103 | * enabling OPL4 is pretty useless. | |
1104 | */ | |
1105 | control |= 0x10; /* Uses IRQ12 if bit 0x20 == 0 */ | |
1106 | /* control |= 0x20; Uncomment this if you want to use IRQ7 */ | |
1107 | #endif | |
1108 | outb((control | 0x03), mpu_base + 7); /* xxxxxx11 restarts */ | |
1109 | hw_config->name = "SoundMan Wave"; | |
1110 | return 1; | |
1111 | } | |
1112 | ||
1113 | static int init_Jazz16_midi(sb_devc * devc, struct address_info *hw_config) | |
1114 | { | |
1115 | int mpu_base = hw_config->io_base; | |
1116 | int sb_base = devc->base; | |
1117 | int irq = hw_config->irq; | |
1118 | ||
1119 | unsigned char bits = 0; | |
1120 | unsigned long flags; | |
1121 | ||
1122 | if (irq < 0) | |
1123 | irq *= -1; | |
1124 | ||
1125 | if (irq < 1 || irq > 15 || | |
1126 | jazz_irq_bits[irq] == 0) | |
1127 | { | |
1128 | printk(KERN_ERR "Jazz16: Invalid MIDI interrupt (IRQ%d)\n", irq); | |
1129 | return 0; | |
1130 | } | |
1131 | switch (sb_base) | |
1132 | { | |
1133 | case 0x220: | |
1134 | bits = 1; | |
1135 | break; | |
1136 | case 0x240: | |
1137 | bits = 2; | |
1138 | break; | |
1139 | case 0x260: | |
1140 | bits = 3; | |
1141 | break; | |
1142 | default: | |
1143 | return 0; | |
1144 | } | |
1145 | bits = jazz16_bits = bits << 5; | |
1146 | switch (mpu_base) | |
1147 | { | |
1148 | case 0x310: | |
1149 | bits |= 1; | |
1150 | break; | |
1151 | case 0x320: | |
1152 | bits |= 2; | |
1153 | break; | |
1154 | case 0x330: | |
1155 | bits |= 3; | |
1156 | break; | |
1157 | default: | |
1158 | printk(KERN_ERR "Jazz16: Invalid MIDI I/O port %x\n", mpu_base); | |
1159 | return 0; | |
1160 | } | |
1161 | /* | |
1162 | * Magic wake up sequence by writing to 0x201 (aka Joystick port) | |
1163 | */ | |
1164 | spin_lock_irqsave(&jazz16_lock, flags); | |
1165 | outb(0xAF, 0x201); | |
1166 | outb(0x50, 0x201); | |
1167 | outb(bits, 0x201); | |
1168 | spin_unlock_irqrestore(&jazz16_lock, flags); | |
1169 | ||
1170 | hw_config->name = "Jazz16"; | |
1171 | smw_midi_init(devc, hw_config); | |
1172 | ||
1173 | if (!sb_dsp_command(devc, 0xfb)) | |
1174 | return 0; | |
1175 | ||
1176 | if (!sb_dsp_command(devc, jazz_dma_bits[devc->dma8] | | |
1177 | (jazz_dma_bits[devc->dma16] << 4))) | |
1178 | return 0; | |
1179 | ||
1180 | if (!sb_dsp_command(devc, jazz_irq_bits[devc->irq] | | |
1181 | (jazz_irq_bits[irq] << 4))) | |
1182 | return 0; | |
1183 | ||
1184 | return 1; | |
1185 | } | |
1186 | ||
1187 | int probe_sbmpu(struct address_info *hw_config, struct module *owner) | |
1188 | { | |
1189 | sb_devc *devc = last_devc; | |
1190 | int ret; | |
1191 | ||
1192 | if (last_devc == NULL) | |
1193 | return 0; | |
1194 | ||
1195 | last_devc = NULL; | |
1196 | ||
1197 | if (hw_config->io_base <= 0) | |
1198 | { | |
1199 | /* The real vibra16 is fine about this, but we have to go | |
1200 | wipe up after Cyrix again */ | |
1201 | ||
1202 | if(devc->model == MDL_SB16 && devc->minor >= 12) | |
1203 | { | |
1204 | unsigned char bits = sb_getmixer(devc, 0x84) & ~0x06; | |
1205 | sb_setmixer(devc, 0x84, bits | 0x02); /* Disable MPU */ | |
1206 | } | |
1207 | return 0; | |
1208 | } | |
1209 | ||
1210 | #if defined(CONFIG_SOUND_MPU401) | |
1211 | if (devc->model == MDL_ESS) | |
1212 | { | |
1213 | struct resource *ports; | |
1214 | ports = request_region(hw_config->io_base, 2, "mpu401"); | |
1215 | if (!ports) { | |
1216 | printk(KERN_ERR "sbmpu: I/O port conflict (%x)\n", hw_config->io_base); | |
1217 | return 0; | |
1218 | } | |
1219 | if (!ess_midi_init(devc, hw_config)) { | |
1220 | release_region(hw_config->io_base, 2); | |
1221 | return 0; | |
1222 | } | |
1223 | hw_config->name = "ESS1xxx MPU"; | |
1224 | devc->midi_irq_cookie = NULL; | |
1225 | if (!probe_mpu401(hw_config, ports)) { | |
1226 | release_region(hw_config->io_base, 2); | |
1227 | return 0; | |
1228 | } | |
1229 | attach_mpu401(hw_config, owner); | |
1230 | if (last_sb->irq == -hw_config->irq) | |
73de76a0 JG |
1231 | last_sb->midi_irq_cookie = |
1232 | (void *)(long) hw_config->slots[1]; | |
1da177e4 LT |
1233 | return 1; |
1234 | } | |
1235 | #endif | |
1236 | ||
1237 | switch (devc->model) | |
1238 | { | |
1239 | case MDL_SB16: | |
1240 | if (hw_config->io_base != 0x300 && hw_config->io_base != 0x330) | |
1241 | { | |
1242 | printk(KERN_ERR "SB16: Invalid MIDI port %x\n", hw_config->io_base); | |
1243 | return 0; | |
1244 | } | |
1245 | hw_config->name = "Sound Blaster 16"; | |
1246 | if (hw_config->irq < 3 || hw_config->irq == devc->irq) | |
1247 | hw_config->irq = -devc->irq; | |
1248 | if (devc->minor > 12) /* What is Vibra's version??? */ | |
1249 | sb16_set_mpu_port(devc, hw_config); | |
1250 | break; | |
1251 | ||
1252 | case MDL_JAZZ: | |
1253 | if (hw_config->irq < 3 || hw_config->irq == devc->irq) | |
1254 | hw_config->irq = -devc->irq; | |
1255 | if (!init_Jazz16_midi(devc, hw_config)) | |
1256 | return 0; | |
1257 | break; | |
1258 | ||
1259 | case MDL_YMPCI: | |
1260 | hw_config->name = "Yamaha PCI Legacy"; | |
1261 | printk("Yamaha PCI legacy UART401 check.\n"); | |
1262 | break; | |
1263 | default: | |
1264 | return 0; | |
1265 | } | |
1266 | ||
1267 | ret = probe_uart401(hw_config, owner); | |
1268 | if (ret) | |
1269 | last_sb->midi_irq_cookie=midi_devs[hw_config->slots[4]]->devc; | |
1270 | return ret; | |
1271 | } | |
1272 | ||
1273 | void unload_sbmpu(struct address_info *hw_config) | |
1274 | { | |
1275 | #if defined(CONFIG_SOUND_MPU401) | |
1276 | if (!strcmp (hw_config->name, "ESS1xxx MPU")) { | |
1277 | unload_mpu401(hw_config); | |
1278 | return; | |
1279 | } | |
1280 | #endif | |
1281 | unload_uart401(hw_config); | |
1282 | } | |
1283 | ||
1284 | EXPORT_SYMBOL(sb_dsp_init); | |
1285 | EXPORT_SYMBOL(sb_dsp_detect); | |
1286 | EXPORT_SYMBOL(sb_dsp_unload); | |
1287 | EXPORT_SYMBOL(sb_be_quiet); | |
1288 | EXPORT_SYMBOL(probe_sbmpu); | |
1289 | EXPORT_SYMBOL(unload_sbmpu); | |
1290 | EXPORT_SYMBOL(smw_free); | |
1291 | MODULE_LICENSE("GPL"); |