linux/sound/oss/sb_common.c
<<
>>
Prefs
   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
  48int sb_be_quiet;
  49
  50static sb_devc *detected_devc;  /* For communication from probe to init */
  51static sb_devc *last_devc;      /* For MPU401 initialization */
  52
  53static unsigned char jazz_irq_bits[] = {
  54        0, 0, 2, 3, 0, 1, 0, 4, 0, 2, 5, 0, 0, 0, 0, 6
  55};
  56
  57static unsigned char jazz_dma_bits[] = {
  58        0, 1, 0, 2, 0, 3, 0, 4
  59};
  60
  61void *smw_free;
  62
  63/*
  64 * Jazz16 chipset specific control variables
  65 */
  66
  67static int jazz16_base;                 /* Not detected */
  68static unsigned char jazz16_bits;       /* I/O relocation bits */
  69static 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
  78static unsigned char *smw_ucode;
  79static int      smw_ucodeLen;
  80
  81#endif
  82
  83static sb_devc *last_sb;                /* Last sb loaded */
  84
  85int 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
 112int 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
 124static 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
 195static 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
 203static 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
 224int 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
 253static 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
 281static 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
 299static 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
 322static 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
 348static 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
 383static 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
 443static 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
 503int 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
 639int 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   
 881void 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
 928void 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
 947unsigned 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
 966void 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
 980static 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
 993static 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
1008static 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
1113static 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
1187int 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
1273void 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
1284EXPORT_SYMBOL(sb_dsp_init);
1285EXPORT_SYMBOL(sb_dsp_detect);
1286EXPORT_SYMBOL(sb_dsp_unload);
1287EXPORT_SYMBOL(sb_be_quiet);
1288EXPORT_SYMBOL(probe_sbmpu);
1289EXPORT_SYMBOL(unload_sbmpu);
1290EXPORT_SYMBOL(smw_free);
1291MODULE_LICENSE("GPL");
1292
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.