?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
freezer: exec should clear PF_NOFREEZE along with PF_KTHREAD
[linux-2.6.git] / sound / oss / sb_common.c
blob7d42c5418d1bb42ea6407ca284a6a0b498e7ec61
1 /*
2 * sound/oss/sb_common.c
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
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>
34 #include <linux/slab.h>
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)
136 uart401intr(devc->irq, devc->midi_irq_cookie);
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:
161 /* printk(KERN_WARNING "Sound Blaster: Unexpected interrupt\n"); */
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:
181 /* printk(KERN_WARNING "Sound Blaster: Unexpected interrupt\n"); */
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
204 static irqreturn_t sbintr(int irq, void *dev_id)
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
629 detected_devc = kmalloc(sizeof(sb_devc), GFP_KERNEL);
630 if (detected_devc == NULL)
631 {
632 printk(KERN_ERR "sb: Can't allocate memory for device information\n");
633 return 0;
634 }
635 memcpy(detected_devc, devc, sizeof(sb_devc));
636 MDB(printk(KERN_INFO "SB %d.%02d detected OK (%x)\n", devc->major, devc->minor, hw_config->io_base));
637 return 1;
638 }
639
640 int sb_dsp_init(struct address_info *hw_config, struct module *owner)
641 {
642 sb_devc *devc;
643 char name[100];
644 extern int sb_be_quiet;
645 int mixer22, mixer30;
646
647 /*
648 * Check if we had detected a SB device earlier
649 */
650 DDB(printk("sb_dsp_init(%x) entered\n", hw_config->io_base));
651 name[0] = 0;
652
653 if (detected_devc == NULL)
654 {
655 MDB(printk("No detected device\n"));
656 return 0;
657 }
658 devc = detected_devc;
659 detected_devc = NULL;
660
661 if (devc->base != hw_config->io_base)
662 {
663 DDB(printk("I/O port mismatch\n"));
664 release_region(devc->base, 16);
665 return 0;
666 }
667 /*
668 * Now continue initialization of the device
669 */
670
671 devc->caps = hw_config->driver_use_1;
672
673 if (!((devc->caps & SB_NO_AUDIO) && (devc->caps & SB_NO_MIDI)) && hw_config->irq > 0)
674 { /* IRQ setup */
675
676 /*
677 * ESS PCI cards do shared PCI IRQ stuff. Since they
678 * will get shared PCI irq lines we must cope.
679 */
680
681 int i=(devc->caps&SB_PCI_IRQ)?IRQF_SHARED:0;
682
683 if (request_irq(hw_config->irq, sbintr, i, "soundblaster", devc) < 0)
684 {
685 printk(KERN_ERR "SB: Can't allocate IRQ%d\n", hw_config->irq);
686 release_region(devc->base, 16);
687 return 0;
688 }
689 devc->irq_ok = 0;
690
691 if (devc->major == 4)
692 if (!sb16_set_irq_hw(devc, devc->irq)) /* Unsupported IRQ */
693 {
694 free_irq(devc->irq, devc);
695 release_region(devc->base, 16);
696 return 0;
697 }
698 if ((devc->type == 0 || devc->type == MDL_ESS) &&
699 devc->major == 3 && devc->minor == 1)
700 { /* Handle various chipsets which claim they are SB Pro compatible */
701 if ((devc->type != 0 && devc->type != MDL_ESS) ||
702 !ess_init(devc, hw_config))
703 {
704 if ((devc->type != 0 && devc->type != MDL_JAZZ &&
705 devc->type != MDL_SMW) || !init_Jazz16(devc, hw_config))
706 {
707 DDB(printk("This is a genuine SB Pro\n"));
708 }
709 }
710 }
711 if (devc->major == 4 && devc->minor <= 11 ) /* Won't work */
712 devc->irq_ok = 1;
713 else
714 {
715 int n;
716
717 for (n = 0; n < 3 && devc->irq_ok == 0; n++)
718 {
719 if (sb_dsp_command(devc, 0xf2)) /* Cause interrupt immediately */
720 {
721 int i;
722
723 for (i = 0; !devc->irq_ok && i < 10000; i++);
724 }
725 }
726 if (!devc->irq_ok)
727 printk(KERN_WARNING "sb: Interrupt test on IRQ%d failed - Probable IRQ conflict\n", devc->irq);
728 else
729 {
730 DDB(printk("IRQ test OK (IRQ%d)\n", devc->irq));
731 }
732 }
733 } /* IRQ setup */
734
735 last_sb = devc;
736
737 switch (devc->major)
738 {
739 case 1: /* SB 1.0 or 1.5 */
740 devc->model = hw_config->card_subtype = MDL_SB1;
741 break;
742
743 case 2: /* SB 2.x */
744 if (devc->minor == 0)
745 devc->model = hw_config->card_subtype = MDL_SB2;
746 else
747 devc->model = hw_config->card_subtype = MDL_SB201;
748 break;
749
750 case 3: /* SB Pro and most clones */
751 switch (devc->model) {
752 case 0:
753 devc->model = hw_config->card_subtype = MDL_SBPRO;
754 if (hw_config->name == NULL)
755 hw_config->name = "Sound Blaster Pro (8 BIT ONLY)";
756 break;
757 case MDL_ESS:
758 ess_dsp_init(devc, hw_config);
759 break;
760 }
761 break;
762
763 case 4:
764 devc->model = hw_config->card_subtype = MDL_SB16;
765 /*
766 * ALS007 and ALS100 return DSP version 4.2 and have 2 post-reset !=0
767 * registers at 0x3c and 0x4c (output ctrl registers on ALS007) whereas
768 * a "standard" SB16 doesn't have a register at 0x4c. ALS100 actively
769 * updates register 0x22 whenever 0x30 changes, as per the SB16 spec.
770 * Since ALS007 doesn't, this can be used to differentiate the 2 cards.
771 */
772 if ((devc->minor == 2) && sb_getmixer(devc,0x3c) && sb_getmixer(devc,0x4c))
773 {
774 mixer30 = sb_getmixer(devc,0x30);
775 sb_setmixer(devc,0x22,(mixer22=sb_getmixer(devc,0x22)) & 0x0f);
776 sb_setmixer(devc,0x30,0xff);
777 /* ALS100 will force 0x30 to 0xf8 like SB16; ALS007 will allow 0xff. */
778 /* Register 0x22 & 0xf0 on ALS100 == 0xf0; on ALS007 it == 0x10. */
779 if ((sb_getmixer(devc,0x30) != 0xff) || ((sb_getmixer(devc,0x22) & 0xf0) != 0x10))
780 {
781 devc->submodel = SUBMDL_ALS100;
782 if (hw_config->name == NULL)
783 hw_config->name = "Sound Blaster 16 (ALS-100)";
784 }
785 else
786 {
787 sb_setmixer(devc,0x3c,0x1f); /* Enable all inputs */
788 sb_setmixer(devc,0x4c,0x1f);
789 sb_setmixer(devc,0x22,mixer22); /* Restore 0x22 to original value */
790 devc->submodel = SUBMDL_ALS007;
791 if (hw_config->name == NULL)
792 hw_config->name = "Sound Blaster 16 (ALS-007)";
793 }
794 sb_setmixer(devc,0x30,mixer30);
795 }
796 else if (hw_config->name == NULL)
797 hw_config->name = "Sound Blaster 16";
798
799 if (hw_config->dma2 == -1)
800 devc->dma16 = devc->dma8;
801 else if (hw_config->dma2 < 5 || hw_config->dma2 > 7)
802 {
803 printk(KERN_WARNING "SB16: Bad or missing 16 bit DMA channel\n");
804 devc->dma16 = devc->dma8;
805 }
806 else
807 devc->dma16 = hw_config->dma2;
808
809 if(!sb16_set_dma_hw(devc)) {
810 free_irq(devc->irq, devc);
811 release_region(hw_config->io_base, 16);
812 return 0;
813 }
814
815 devc->caps |= SB_NO_MIDI;
816 }
817
818 if (!(devc->caps & SB_NO_MIXER))
819 if (devc->major == 3 || devc->major == 4)
820 sb_mixer_init(devc, owner);
821
822 if (!(devc->caps & SB_NO_MIDI))
823 sb_dsp_midi_init(devc, owner);
824
825 if (hw_config->name == NULL)
826 hw_config->name = "Sound Blaster (8 BIT/MONO ONLY)";
827
828 sprintf(name, "%s (%d.%02d)", hw_config->name, devc->major, devc->minor);
829 conf_printf(name, hw_config);
830
831 /*
832 * Assuming that a sound card is Sound Blaster (compatible) is the most common
833 * configuration error and the mother of all problems. Usually sound cards
834 * emulate SB Pro but in addition they have a 16 bit native mode which should be
835 * used in Unix. See Readme.cards for more information about configuring OSS/Free
836 * properly.
837 */
838 if (devc->model <= MDL_SBPRO)
839 {
840 if (devc->major == 3 && devc->minor != 1) /* "True" SB Pro should have v3.1 (rare ones may have 3.2). */
841 {
842 printk(KERN_INFO "This sound card may not be fully Sound Blaster Pro compatible.\n");
843 printk(KERN_INFO "In many cases there is another way to configure OSS so that\n");
844 printk(KERN_INFO "it works properly with OSS (for example in 16 bit mode).\n");
845 printk(KERN_INFO "Please ignore this message if you _really_ have a SB Pro.\n");
846 }
847 else if (!sb_be_quiet && devc->model == MDL_SBPRO)
848 {
849 printk(KERN_INFO "SB DSP version is just %d.%02d which means that your card is\n", devc->major, devc->minor);
850 printk(KERN_INFO "several years old (8 bit only device) or alternatively the sound driver\n");
851 printk(KERN_INFO "is incorrectly configured.\n");
852 }
853 }
854 hw_config->card_subtype = devc->model;
855 hw_config->slots[0]=devc->dev;
856 last_devc = devc; /* For SB MPU detection */
857
858 if (!(devc->caps & SB_NO_AUDIO) && devc->dma8 >= 0)
859 {
860 if (sound_alloc_dma(devc->dma8, "SoundBlaster8"))
861 {
862 printk(KERN_WARNING "Sound Blaster: Can't allocate 8 bit DMA channel %d\n", devc->dma8);
863 }
864 if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
865 {
866 if (sound_alloc_dma(devc->dma16, "SoundBlaster16"))
867 printk(KERN_WARNING "Sound Blaster: can't allocate 16 bit DMA channel %d.\n", devc->dma16);
868 }
869 sb_audio_init(devc, name, owner);
870 hw_config->slots[0]=devc->dev;
871 }
872 else
873 {
874 MDB(printk("Sound Blaster: no audio devices found.\n"));
875 }
876 return 1;
877 }
878
879 /* if (sbmpu) below we allow mpu401 to manage the midi devs
880 otherwise we have to unload them. (Andrzej Krzysztofowicz) */
881
882 void sb_dsp_unload(struct address_info *hw_config, int sbmpu)
883 {
884 sb_devc *devc;
885
886 devc = audio_devs[hw_config->slots[0]]->devc;
887
888 if (devc && devc->base == hw_config->io_base)
889 {
890 if ((devc->model & MDL_ESS) && devc->pcibase)
891 release_region(devc->pcibase, 8);
892
893 release_region(devc->base, 16);
894
895 if (!(devc->caps & SB_NO_AUDIO))
896 {
897 sound_free_dma(devc->dma8);
898 if (devc->dma16 >= 0)
899 sound_free_dma(devc->dma16);
900 }
901 if (!(devc->caps & SB_NO_AUDIO && devc->caps & SB_NO_MIDI))
902 {
903 if (devc->irq > 0)
904 free_irq(devc->irq, devc);
905
906 sb_mixer_unload(devc);
907 /* We don't have to do this bit any more the UART401 is its own
908 master -- Krzysztof Halasa */
909 /* But we have to do it, if UART401 is not detected */
910 if (!sbmpu)
911 sound_unload_mididev(devc->my_mididev);
912 sound_unload_audiodev(devc->dev);
913 }
914 kfree(devc);
915 }
916 else
917 release_region(hw_config->io_base, 16);
918
919 kfree(detected_devc);
920 }
921
922 /*
923 * Mixer access routines
924 *
925 * ES1887 modifications: some mixer registers reside in the
926 * range above 0xa0. These must be accessed in another way.
927 */
928
929 void sb_setmixer(sb_devc * devc, unsigned int port, unsigned int value)
930 {
931 unsigned long flags;
932
933 if (devc->model == MDL_ESS) {
934 ess_setmixer (devc, port, value);
935 return;
936 }
937
938 spin_lock_irqsave(&devc->lock, flags);
939
940 outb(((unsigned char) (port & 0xff)), MIXER_ADDR);
941 udelay(20);
942 outb(((unsigned char) (value & 0xff)), MIXER_DATA);
943 udelay(20);
944
945 spin_unlock_irqrestore(&devc->lock, flags);
946 }
947
948 unsigned int sb_getmixer(sb_devc * devc, unsigned int port)
949 {
950 unsigned int val;
951 unsigned long flags;
952
953 if (devc->model == MDL_ESS) return ess_getmixer (devc, port);
954
955 spin_lock_irqsave(&devc->lock, flags);
956
957 outb(((unsigned char) (port & 0xff)), MIXER_ADDR);
958 udelay(20);
959 val = inb(MIXER_DATA);
960 udelay(20);
961
962 spin_unlock_irqrestore(&devc->lock, flags);
963
964 return val;
965 }
966
967 void sb_chgmixer
968 (sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val)
969 {
970 int value;
971
972 value = sb_getmixer(devc, reg);
973 value = (value & ~mask) | (val & mask);
974 sb_setmixer(devc, reg, value);
975 }
976
977 /*
978 * MPU401 MIDI initialization.
979 */
980
981 static void smw_putmem(sb_devc * devc, int base, int addr, unsigned char val)
982 {
983 unsigned long flags;
984
985 spin_lock_irqsave(&jazz16_lock, flags); /* NOT the SB card? */
986
987 outb((addr & 0xff), base + 1); /* Low address bits */
988 outb((addr >> 8), base + 2); /* High address bits */
989 outb((val), base); /* Data */
990
991 spin_unlock_irqrestore(&jazz16_lock, flags);
992 }
993
994 static unsigned char smw_getmem(sb_devc * devc, int base, int addr)
995 {
996 unsigned long flags;
997 unsigned char val;
998
999 spin_lock_irqsave(&jazz16_lock, flags); /* NOT the SB card? */
1000
1001 outb((addr & 0xff), base + 1); /* Low address bits */
1002 outb((addr >> 8), base + 2); /* High address bits */
1003 val = inb(base); /* Data */
1004
1005 spin_unlock_irqrestore(&jazz16_lock, flags);
1006 return val;
1007 }
1008
1009 static int smw_midi_init(sb_devc * devc, struct address_info *hw_config)
1010 {
1011 int mpu_base = hw_config->io_base;
1012 int mp_base = mpu_base + 4; /* Microcontroller base */
1013 int i;
1014 unsigned char control;
1015
1016
1017 /*
1018 * Reset the microcontroller so that the RAM can be accessed
1019 */
1020
1021 control = inb(mpu_base + 7);
1022 outb((control | 3), mpu_base + 7); /* Set last two bits to 1 (?) */
1023 outb(((control & 0xfe) | 2), mpu_base + 7); /* xxxxxxx0 resets the mc */
1024
1025 mdelay(3); /* Wait at least 1ms */
1026
1027 outb((control & 0xfc), mpu_base + 7); /* xxxxxx00 enables RAM */
1028
1029 /*
1030 * Detect microcontroller by probing the 8k RAM area
1031 */
1032 smw_putmem(devc, mp_base, 0, 0x00);
1033 smw_putmem(devc, mp_base, 1, 0xff);
1034 udelay(10);
1035
1036 if (smw_getmem(devc, mp_base, 0) != 0x00 || smw_getmem(devc, mp_base, 1) != 0xff)
1037 {
1038 DDB(printk("SM Wave: No microcontroller RAM detected (%02x, %02x)\n", smw_getmem(devc, mp_base, 0), smw_getmem(devc, mp_base, 1)));
1039 return 0; /* No RAM */
1040 }
1041 /*
1042 * There is RAM so assume it's really a SM Wave
1043 */
1044
1045 devc->model = MDL_SMW;
1046 smw_mixer_init(devc);
1047
1048 #ifdef MODULE
1049 if (!smw_ucode)
1050 {
1051 smw_ucodeLen = mod_firmware_load("/etc/sound/midi0001.bin", (void *) &smw_ucode);
1052 smw_free = smw_ucode;
1053 }
1054 #endif
1055 if (smw_ucodeLen > 0)
1056 {
1057 if (smw_ucodeLen != 8192)
1058 {
1059 printk(KERN_ERR "SM Wave: Invalid microcode (MIDI0001.BIN) length\n");
1060 return 1;
1061 }
1062 /*
1063 * Download microcode
1064 */
1065
1066 for (i = 0; i < 8192; i++)
1067 smw_putmem(devc, mp_base, i, smw_ucode[i]);
1068
1069 /*
1070 * Verify microcode
1071 */
1072
1073 for (i = 0; i < 8192; i++)
1074 if (smw_getmem(devc, mp_base, i) != smw_ucode[i])
1075 {
1076 printk(KERN_ERR "SM Wave: Microcode verification failed\n");
1077 return 0;
1078 }
1079 }
1080 control = 0;
1081 #ifdef SMW_SCSI_IRQ
1082 /*
1083 * Set the SCSI interrupt (IRQ2/9, IRQ3 or IRQ10). The SCSI interrupt
1084 * is disabled by default.
1085 *
1086 * FIXME - make this a module option
1087 *
1088 * BTW the Zilog 5380 SCSI controller is located at MPU base + 0x10.
1089 */
1090 {
1091 static unsigned char scsi_irq_bits[] = {
1092 0, 0, 3, 1, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0
1093 };
1094 control |= scsi_irq_bits[SMW_SCSI_IRQ] << 6;
1095 }
1096 #endif
1097
1098 #ifdef SMW_OPL4_ENABLE
1099 /*
1100 * Make the OPL4 chip visible on the PC bus at 0x380.
1101 *
1102 * There is no need to enable this feature since this driver
1103 * doesn't support OPL4 yet. Also there is no RAM in SM Wave so
1104 * enabling OPL4 is pretty useless.
1105 */
1106 control |= 0x10; /* Uses IRQ12 if bit 0x20 == 0 */
1107 /* control |= 0x20; Uncomment this if you want to use IRQ7 */
1108 #endif
1109 outb((control | 0x03), mpu_base + 7); /* xxxxxx11 restarts */
1110 hw_config->name = "SoundMan Wave";
1111 return 1;
1112 }
1113
1114 static int init_Jazz16_midi(sb_devc * devc, struct address_info *hw_config)
1115 {
1116 int mpu_base = hw_config->io_base;
1117 int sb_base = devc->base;
1118 int irq = hw_config->irq;
1119
1120 unsigned char bits = 0;
1121 unsigned long flags;
1122
1123 if (irq < 0)
1124 irq *= -1;
1125
1126 if (irq < 1 || irq > 15 ||
1127 jazz_irq_bits[irq] == 0)
1128 {
1129 printk(KERN_ERR "Jazz16: Invalid MIDI interrupt (IRQ%d)\n", irq);
1130 return 0;
1131 }
1132 switch (sb_base)
1133 {
1134 case 0x220:
1135 bits = 1;
1136 break;
1137 case 0x240:
1138 bits = 2;
1139 break;
1140 case 0x260:
1141 bits = 3;
1142 break;
1143 default:
1144 return 0;
1145 }
1146 bits = jazz16_bits = bits << 5;
1147 switch (mpu_base)
1148 {
1149 case 0x310:
1150 bits |= 1;
1151 break;
1152 case 0x320:
1153 bits |= 2;
1154 break;
1155 case 0x330:
1156 bits |= 3;
1157 break;
1158 default:
1159 printk(KERN_ERR "Jazz16: Invalid MIDI I/O port %x\n", mpu_base);
1160 return 0;
1161 }
1162 /*
1163 * Magic wake up sequence by writing to 0x201 (aka Joystick port)
1164 */
1165 spin_lock_irqsave(&jazz16_lock, flags);
1166 outb(0xAF, 0x201);
1167 outb(0x50, 0x201);
1168 outb(bits, 0x201);
1169 spin_unlock_irqrestore(&jazz16_lock, flags);
1170
1171 hw_config->name = "Jazz16";
1172 smw_midi_init(devc, hw_config);
1173
1174 if (!sb_dsp_command(devc, 0xfb))
1175 return 0;
1176
1177 if (!sb_dsp_command(devc, jazz_dma_bits[devc->dma8] |
1178 (jazz_dma_bits[devc->dma16] << 4)))
1179 return 0;
1180
1181 if (!sb_dsp_command(devc, jazz_irq_bits[devc->irq] |
1182 (jazz_irq_bits[irq] << 4)))
1183 return 0;
1184
1185 return 1;
1186 }
1187
1188 int probe_sbmpu(struct address_info *hw_config, struct module *owner)
1189 {
1190 sb_devc *devc = last_devc;
1191 int ret;
1192
1193 if (last_devc == NULL)
1194 return 0;
1195
1196 last_devc = NULL;
1197
1198 if (hw_config->io_base <= 0)
1199 {
1200 /* The real vibra16 is fine about this, but we have to go
1201 wipe up after Cyrix again */
1202
1203 if(devc->model == MDL_SB16 && devc->minor >= 12)
1204 {
1205 unsigned char bits = sb_getmixer(devc, 0x84) & ~0x06;
1206 sb_setmixer(devc, 0x84, bits | 0x02); /* Disable MPU */
1207 }
1208 return 0;
1209 }
1210
1211 #if defined(CONFIG_SOUND_MPU401)
1212 if (devc->model == MDL_ESS)
1213 {
1214 struct resource *ports;
1215 ports = request_region(hw_config->io_base, 2, "mpu401");
1216 if (!ports) {
1217 printk(KERN_ERR "sbmpu: I/O port conflict (%x)\n", hw_config->io_base);
1218 return 0;
1219 }
1220 if (!ess_midi_init(devc, hw_config)) {
1221 release_region(hw_config->io_base, 2);
1222 return 0;
1223 }
1224 hw_config->name = "ESS1xxx MPU";
1225 devc->midi_irq_cookie = NULL;
1226 if (!probe_mpu401(hw_config, ports)) {
1227 release_region(hw_config->io_base, 2);
1228 return 0;
1229 }
1230 attach_mpu401(hw_config, owner);
1231 if (last_sb->irq == -hw_config->irq)
1232 last_sb->midi_irq_cookie =
1233 (void *)(long) hw_config->slots[1];
1234 return 1;
1235 }
1236 #endif
1237
1238 switch (devc->model)
1239 {
1240 case MDL_SB16:
1241 if (hw_config->io_base != 0x300 && hw_config->io_base != 0x330)
1242 {
1243 printk(KERN_ERR "SB16: Invalid MIDI port %x\n", hw_config->io_base);
1244 return 0;
1245 }
1246 hw_config->name = "Sound Blaster 16";
1247 if (hw_config->irq < 3 || hw_config->irq == devc->irq)
1248 hw_config->irq = -devc->irq;
1249 if (devc->minor > 12) /* What is Vibra's version??? */
1250 sb16_set_mpu_port(devc, hw_config);
1251 break;
1252
1253 case MDL_JAZZ:
1254 if (hw_config->irq < 3 || hw_config->irq == devc->irq)
1255 hw_config->irq = -devc->irq;
1256 if (!init_Jazz16_midi(devc, hw_config))
1257 return 0;
1258 break;
1259
1260 case MDL_YMPCI:
1261 hw_config->name = "Yamaha PCI Legacy";
1262 printk("Yamaha PCI legacy UART401 check.\n");
1263 break;
1264 default:
1265 return 0;
1266 }
1267
1268 ret = probe_uart401(hw_config, owner);
1269 if (ret)
1270 last_sb->midi_irq_cookie=midi_devs[hw_config->slots[4]]->devc;
1271 return ret;
1272 }
1273
1274 void unload_sbmpu(struct address_info *hw_config)
1275 {
1276 #if defined(CONFIG_SOUND_MPU401)
1277 if (!strcmp (hw_config->name, "ESS1xxx MPU")) {
1278 unload_mpu401(hw_config);
1279 return;
1280 }
1281 #endif
1282 unload_uart401(hw_config);
1283 }
1284
1285 EXPORT_SYMBOL(sb_dsp_init);
1286 EXPORT_SYMBOL(sb_dsp_detect);
1287 EXPORT_SYMBOL(sb_dsp_unload);
1288 EXPORT_SYMBOL(sb_be_quiet);
1289 EXPORT_SYMBOL(probe_sbmpu);
1290 EXPORT_SYMBOL(unload_sbmpu);
1291 EXPORT_SYMBOL(smw_free);
1292 MODULE_LICENSE("GPL");
Linus' kernel tree