sound: Use PCI_VDEVICE
[linux-2.6.git] / sound / oss / sb_common.c
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
35 #include "sound_config.h"
36 #include "sound_firmware.h"
37
38 #include "mpu401.h"
39
40 #include "sb_mixer.h"
41 #include "sb.h"
42 #include "sb_ess.h"
43
44 /*
45  * global module flag
46  */
47
48 int sb_be_quiet;
49
50 static sb_devc *detected_devc;  /* For communication from probe to init */
51 static sb_devc *last_devc;      /* For MPU401 initialization */
52
53 static unsigned char jazz_irq_bits[] = {
54         0, 0, 2, 3, 0, 1, 0, 4, 0, 2, 5, 0, 0, 0, 0, 6
55 };
56
57 static unsigned char jazz_dma_bits[] = {
58         0, 1, 0, 2, 0, 3, 0, 4
59 };
60
61 void *smw_free;
62
63 /*
64  * Jazz16 chipset specific control variables
65  */
66
67 static int jazz16_base;                 /* Not detected */
68 static unsigned char jazz16_bits;       /* I/O relocation bits */
69 static DEFINE_SPINLOCK(jazz16_lock);
70
71 /*
72  * Logitech Soundman Wave specific initialization code
73  */
74
75 #ifdef SMW_MIDI0001_INCLUDED
76 #include "smw-midi0001.h"
77 #else
78 static unsigned char *smw_ucode;
79 static int      smw_ucodeLen;
80
81 #endif
82
83 static sb_devc *last_sb;                /* Last sb loaded */
84
85 int sb_dsp_command(sb_devc * devc, unsigned char val)
86 {
87         int i;
88         unsigned long limit;
89
90         limit = jiffies + HZ / 10;      /* Timeout */
91         
92         /*
93          * Note! the i<500000 is an emergency exit. The sb_dsp_command() is sometimes
94          * called while interrupts are disabled. This means that the timer is
95          * disabled also. However the timeout situation is a abnormal condition.
96          * Normally the DSP should be ready to accept commands after just couple of
97          * loops.
98          */
99
100         for (i = 0; i < 500000 && (limit-jiffies)>0; i++)
101         {
102                 if ((inb(DSP_STATUS) & 0x80) == 0)
103                 {
104                         outb((val), DSP_COMMAND);
105                         return 1;
106                 }
107         }
108         printk(KERN_WARNING "Sound Blaster:  DSP command(%x) timeout.\n", val);
109         return 0;
110 }
111
112 int sb_dsp_get_byte(sb_devc * devc)
113 {
114         int i;
115
116         for (i = 1000; i; i--)
117         {
118                 if (inb(DSP_DATA_AVAIL) & 0x80)
119                         return inb(DSP_READ);
120         }
121         return 0xffff;
122 }
123
124 static void sb_intr (sb_devc *devc)
125 {
126         int status;
127         unsigned char   src = 0xff;
128
129         if (devc->model == MDL_SB16)
130         {
131                 src = sb_getmixer(devc, IRQ_STAT);      /* Interrupt source register */
132
133                 if (src & 4)                                            /* MPU401 interrupt */
134                         if(devc->midi_irq_cookie)
135                                 uart401intr(devc->irq, devc->midi_irq_cookie);
136
137                 if (!(src & 3))
138                         return; /* Not a DSP interrupt */
139         }
140         if (devc->intr_active && (!devc->fullduplex || (src & 0x01)))
141         {
142                 switch (devc->irq_mode)
143                 {
144                         case IMODE_OUTPUT:
145                                 DMAbuf_outputintr(devc->dev, 1);
146                                 break;
147
148                         case IMODE_INPUT:
149                                 DMAbuf_inputintr(devc->dev);
150                                 break;
151
152                         case IMODE_INIT:
153                                 break;
154
155                         case IMODE_MIDI:
156                                 sb_midi_interrupt(devc);
157                                 break;
158
159                         default:
160                                 /* printk(KERN_WARN "Sound Blaster: Unexpected interrupt\n"); */
161                                 ;
162                 }
163         }
164         else if (devc->intr_active_16 && (src & 0x02))
165         {
166                 switch (devc->irq_mode_16)
167                 {
168                         case IMODE_OUTPUT:
169                                 DMAbuf_outputintr(devc->dev, 1);
170                                 break;
171
172                         case IMODE_INPUT:
173                                 DMAbuf_inputintr(devc->dev);
174                                 break;
175
176                         case IMODE_INIT:
177                                 break;
178
179                         default:
180                                 /* printk(KERN_WARN "Sound Blaster: Unexpected interrupt\n"); */
181                                 ;
182                 }
183         }
184         /*
185          * Acknowledge interrupts 
186          */
187
188         if (src & 0x01)
189                 status = inb(DSP_DATA_AVAIL);
190
191         if (devc->model == MDL_SB16 && src & 0x02)
192                 status = inb(DSP_DATA_AVL16);
193 }
194
195 static void pci_intr(sb_devc *devc)
196 {
197         int src = inb(devc->pcibase+0x1A);
198         src&=3;
199         if(src)
200                 sb_intr(devc);
201 }
202
203 static irqreturn_t sbintr(int irq, void *dev_id)
204 {
205         sb_devc *devc = dev_id;
206
207         devc->irq_ok = 1;
208
209         switch (devc->model) {
210         case MDL_ESSPCI:
211                 pci_intr (devc);
212                 break;
213                 
214         case MDL_ESS:
215                 ess_intr (devc);
216                 break;
217         default:
218                 sb_intr (devc);
219                 break;
220         }
221         return IRQ_HANDLED;
222 }
223
224 int sb_dsp_reset(sb_devc * devc)
225 {
226         int loopc;
227
228         DEB(printk("Entered sb_dsp_reset()\n"));
229
230         if (devc->model == MDL_ESS) return ess_dsp_reset (devc);
231
232         /* This is only for non-ESS chips */
233
234         outb(1, DSP_RESET);
235
236         udelay(10);
237         outb(0, DSP_RESET);
238         udelay(30);
239
240         for (loopc = 0; loopc < 1000 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++);
241
242         if (inb(DSP_READ) != 0xAA)
243         {
244                 DDB(printk("sb: No response to RESET\n"));
245                 return 0;       /* Sorry */
246         }
247
248         DEB(printk("sb_dsp_reset() OK\n"));
249
250         return 1;
251 }
252
253 static void dsp_get_vers(sb_devc * devc)
254 {
255         int i;
256
257         unsigned long   flags;
258
259         DDB(printk("Entered dsp_get_vers()\n"));
260         spin_lock_irqsave(&devc->lock, flags);
261         devc->major = devc->minor = 0;
262         sb_dsp_command(devc, 0xe1);     /* Get version */
263
264         for (i = 100000; i; i--)
265         {
266                 if (inb(DSP_DATA_AVAIL) & 0x80)
267                 {
268                         if (devc->major == 0)
269                                 devc->major = inb(DSP_READ);
270                         else
271                         {
272                                 devc->minor = inb(DSP_READ);
273                                 break;
274                         }
275                 }
276         }
277         spin_unlock_irqrestore(&devc->lock, flags);
278         DDB(printk("DSP version %d.%02d\n", devc->major, devc->minor));
279 }
280
281 static int sb16_set_dma_hw(sb_devc * devc)
282 {
283         int bits;
284
285         if (devc->dma8 != 0 && devc->dma8 != 1 && devc->dma8 != 3)
286         {
287                 printk(KERN_ERR "SB16: Invalid 8 bit DMA (%d)\n", devc->dma8);
288                 return 0;
289         }
290         bits = (1 << devc->dma8);
291
292         if (devc->dma16 >= 5 && devc->dma16 <= 7)
293                 bits |= (1 << devc->dma16);
294
295         sb_setmixer(devc, DMA_NR, bits);
296         return 1;
297 }
298
299 static void sb16_set_mpu_port(sb_devc * devc, struct address_info *hw_config)
300 {
301         /*
302          * This routine initializes new MIDI port setup register of SB Vibra (CT2502).
303          */
304         unsigned char   bits = sb_getmixer(devc, 0x84) & ~0x06;
305
306         switch (hw_config->io_base)
307         {
308                 case 0x300:
309                         sb_setmixer(devc, 0x84, bits | 0x04);
310                         break;
311
312                 case 0x330:
313                         sb_setmixer(devc, 0x84, bits | 0x00);
314                         break;
315
316                 default:
317                         sb_setmixer(devc, 0x84, bits | 0x02);           /* Disable MPU */
318                         printk(KERN_ERR "SB16: Invalid MIDI I/O port %x\n", hw_config->io_base);
319         }
320 }
321
322 static int sb16_set_irq_hw(sb_devc * devc, int level)
323 {
324         int ival;
325
326         switch (level)
327         {
328                 case 5:
329                         ival = 2;
330                         break;
331                 case 7:
332                         ival = 4;
333                         break;
334                 case 9:
335                         ival = 1;
336                         break;
337                 case 10:
338                         ival = 8;
339                         break;
340                 default:
341                         printk(KERN_ERR "SB16: Invalid IRQ%d\n", level);
342                         return 0;
343         }
344         sb_setmixer(devc, IRQ_NR, ival);
345         return 1;
346 }
347
348 static void relocate_Jazz16(sb_devc * devc, struct address_info *hw_config)
349 {
350         unsigned char bits = 0;
351         unsigned long flags;
352
353         if (jazz16_base != 0 && jazz16_base != hw_config->io_base)
354                 return;
355
356         switch (hw_config->io_base)
357         {
358                 case 0x220:
359                         bits = 1;
360                         break;
361                 case 0x240:
362                         bits = 2;
363                         break;
364                 case 0x260:
365                         bits = 3;
366                         break;
367                 default:
368                         return;
369         }
370         bits = jazz16_bits = bits << 5;
371         jazz16_base = hw_config->io_base;
372
373         /*
374          *      Magic wake up sequence by writing to 0x201 (aka Joystick port)
375          */
376         spin_lock_irqsave(&jazz16_lock, flags);
377         outb((0xAF), 0x201);
378         outb((0x50), 0x201);
379         outb((bits), 0x201);
380         spin_unlock_irqrestore(&jazz16_lock, flags);
381 }
382
383 static int init_Jazz16(sb_devc * devc, struct address_info *hw_config)
384 {
385         char name[100];
386         /*
387          * First try to check that the card has Jazz16 chip. It identifies itself
388          * by returning 0x12 as response to DSP command 0xfa.
389          */
390
391         if (!sb_dsp_command(devc, 0xfa))
392                 return 0;
393
394         if (sb_dsp_get_byte(devc) != 0x12)
395                 return 0;
396
397         /*
398          * OK so far. Now configure the IRQ and DMA channel used by the card.
399          */
400         if (hw_config->irq < 1 || hw_config->irq > 15 || jazz_irq_bits[hw_config->irq] == 0)
401         {
402                 printk(KERN_ERR "Jazz16: Invalid interrupt (IRQ%d)\n", hw_config->irq);
403                 return 0;
404         }
405         if (hw_config->dma < 0 || hw_config->dma > 3 || jazz_dma_bits[hw_config->dma] == 0)
406         {
407                   printk(KERN_ERR "Jazz16: Invalid 8 bit DMA (DMA%d)\n", hw_config->dma);
408                   return 0;
409         }
410         if (hw_config->dma2 < 0)
411         {
412                 printk(KERN_ERR "Jazz16: No 16 bit DMA channel defined\n");
413                 return 0;
414         }
415         if (hw_config->dma2 < 5 || hw_config->dma2 > 7 || jazz_dma_bits[hw_config->dma2] == 0)
416         {
417                 printk(KERN_ERR "Jazz16: Invalid 16 bit DMA (DMA%d)\n", hw_config->dma2);
418                 return 0;
419         }
420         devc->dma16 = hw_config->dma2;
421
422         if (!sb_dsp_command(devc, 0xfb))
423                 return 0;
424
425         if (!sb_dsp_command(devc, jazz_dma_bits[hw_config->dma] |
426                         (jazz_dma_bits[hw_config->dma2] << 4)))
427                 return 0;
428
429         if (!sb_dsp_command(devc, jazz_irq_bits[hw_config->irq]))
430                 return 0;
431
432         /*
433          * Now we have configured a standard Jazz16 device. 
434          */
435         devc->model = MDL_JAZZ;
436         strcpy(name, "Jazz16");
437
438         hw_config->name = "Jazz16";
439         devc->caps |= SB_NO_MIDI;
440         return 1;
441 }
442
443 static void relocate_ess1688(sb_devc * devc)
444 {
445         unsigned char bits;
446
447         switch (devc->base)
448         {
449                 case 0x220:
450                         bits = 0x04;
451                         break;
452                 case 0x230:
453                         bits = 0x05;
454                         break;
455                 case 0x240:
456                         bits = 0x06;
457                         break;
458                 case 0x250:
459                         bits = 0x07;
460                         break;
461                 default:
462                         return; /* Wrong port */
463         }
464
465         DDB(printk("Doing ESS1688 address selection\n"));
466         
467         /*
468          * ES1688 supports two alternative ways for software address config.
469          * First try the so called Read-Sequence-Key method.
470          */
471
472         /* Reset the sequence logic */
473         inb(0x229);
474         inb(0x229);
475         inb(0x229);
476
477         /* Perform the read sequence */
478         inb(0x22b);
479         inb(0x229);
480         inb(0x22b);
481         inb(0x229);
482         inb(0x229);
483         inb(0x22b);
484         inb(0x229);
485
486         /* Select the base address by reading from it. Then probe using the port. */
487         inb(devc->base);
488         if (sb_dsp_reset(devc)) /* Bingo */
489                 return;
490
491 #if 0                           /* This causes system lockups (Nokia 386/25 at least) */
492         /*
493          * The last resort is the system control register method.
494          */
495
496         outb((0x00), 0xfb);     /* 0xFB is the unlock register */
497         outb((0x00), 0xe0);     /* Select index 0 */
498         outb((bits), 0xe1);     /* Write the config bits */
499         outb((0x00), 0xf9);     /* 0xFB is the lock register */
500 #endif
501 }
502
503 int sb_dsp_detect(struct address_info *hw_config, int pci, int pciio, struct sb_module_options *sbmo)
504 {
505         sb_devc sb_info;
506         sb_devc *devc = &sb_info;
507
508         memset((char *) &sb_info, 0, sizeof(sb_info));  /* Zero everything */
509
510         /* Copy module options in place */
511         if(sbmo) memcpy(&devc->sbmo, sbmo, sizeof(struct sb_module_options));
512
513         sb_info.my_mididev = -1;
514         sb_info.my_mixerdev = -1;
515         sb_info.dev = -1;
516
517         /*
518          * Initialize variables 
519          */
520         
521         DDB(printk("sb_dsp_detect(%x) entered\n", hw_config->io_base));
522
523         spin_lock_init(&devc->lock);
524         devc->type = hw_config->card_subtype;
525
526         devc->base = hw_config->io_base;
527         devc->irq = hw_config->irq;
528         devc->dma8 = hw_config->dma;
529
530         devc->dma16 = -1;
531         devc->pcibase = pciio;
532         
533         if(pci == SB_PCI_ESSMAESTRO)
534         {
535                 devc->model = MDL_ESSPCI;
536                 devc->caps |= SB_PCI_IRQ;
537                 hw_config->driver_use_1 |= SB_PCI_IRQ;
538                 hw_config->card_subtype = MDL_ESSPCI;
539         }
540         
541         if(pci == SB_PCI_YAMAHA)
542         {
543                 devc->model = MDL_YMPCI;
544                 devc->caps |= SB_PCI_IRQ;
545                 hw_config->driver_use_1 |= SB_PCI_IRQ;
546                 hw_config->card_subtype = MDL_YMPCI;
547                 
548                 printk("Yamaha PCI mode.\n");
549         }
550         
551         if (devc->sbmo.acer)
552         {
553                 unsigned long flags;
554
555                 spin_lock_irqsave(&devc->lock, flags);
556                 inb(devc->base + 0x09);
557                 inb(devc->base + 0x09);
558                 inb(devc->base + 0x09);
559                 inb(devc->base + 0x0b);
560                 inb(devc->base + 0x09);
561                 inb(devc->base + 0x0b);
562                 inb(devc->base + 0x09);
563                 inb(devc->base + 0x09);
564                 inb(devc->base + 0x0b);
565                 inb(devc->base + 0x09);
566                 inb(devc->base + 0x00);
567                 spin_unlock_irqrestore(&devc->lock, flags);
568         }
569         /*
570          * Detect the device
571          */
572
573         if (sb_dsp_reset(devc))
574                 dsp_get_vers(devc);
575         else
576                 devc->major = 0;
577
578         if (devc->type == 0 || devc->type == MDL_JAZZ || devc->type == MDL_SMW)
579                 if (devc->major == 0 || (devc->major == 3 && devc->minor == 1))
580                         relocate_Jazz16(devc, hw_config);
581
582         if (devc->major == 0 && (devc->type == MDL_ESS || devc->type == 0))
583                 relocate_ess1688(devc);
584
585         if (!sb_dsp_reset(devc))
586         {
587                 DDB(printk("SB reset failed\n"));
588 #ifdef MODULE
589                 printk(KERN_INFO "sb: dsp reset failed.\n");
590 #endif
591                 return 0;
592         }
593         if (devc->major == 0)
594                 dsp_get_vers(devc);
595
596         if (devc->major == 3 && devc->minor == 1)
597         {
598                 if (devc->type == MDL_AZTECH)           /* SG Washington? */
599                 {
600                         if (sb_dsp_command(devc, 0x09))
601                                 if (sb_dsp_command(devc, 0x00)) /* Enter WSS mode */
602                                 {
603                                         int i;
604
605                                         /* Have some delay */
606                                         for (i = 0; i < 10000; i++)
607                                                 inb(DSP_DATA_AVAIL);
608                                         devc->caps = SB_NO_AUDIO | SB_NO_MIDI;  /* Mixer only */
609                                         devc->model = MDL_AZTECH;
610                                 }
611                 }
612         }
613         
614         if(devc->type == MDL_ESSPCI)
615                 devc->model = MDL_ESSPCI;
616                 
617         if(devc->type == MDL_YMPCI)
618         {
619                 printk("YMPCI selected\n");
620                 devc->model = MDL_YMPCI;
621         }
622                 
623         /*
624          * Save device information for sb_dsp_init()
625          */
626
627
628         detected_devc = kmalloc(sizeof(sb_devc), GFP_KERNEL);
629         if (detected_devc == NULL)
630         {
631                 printk(KERN_ERR "sb: Can't allocate memory for device information\n");
632                 return 0;
633         }
634         memcpy(detected_devc, devc, sizeof(sb_devc));
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                  
680                 int i=(devc->caps&SB_PCI_IRQ)?IRQF_SHARED:0;
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);
917
918         kfree(detected_devc);
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)
1231                         last_sb->midi_irq_cookie =
1232                                 (void *)(long) hw_config->slots[1];
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");