drivers/sound/sb_common.c

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