linux/sound/isa/msnd/msnd_pinnacle.c
<<
>>
Prefs
   1/*********************************************************************
   2 *
   3 * Linux multisound pinnacle/fiji driver for ALSA.
   4 *
   5 * 2002/06/30 Karsten Wiese:
   6 *      for now this is only used to build a pinnacle / fiji driver.
   7 *      the OSS parent of this code is designed to also support
   8 *      the multisound classic via the file msnd_classic.c.
   9 *      to make it easier for some brave heart to implemt classic
  10 *      support in alsa, i left all the MSND_CLASSIC tokens in this file.
  11 *      but for now this untested & undone.
  12 *
  13 *
  14 * ripped from linux kernel 2.4.18 by Karsten Wiese.
  15 *
  16 * the following is a copy of the 2.4.18 OSS FREE file-heading comment:
  17 *
  18 * Turtle Beach MultiSound Sound Card Driver for Linux
  19 * msnd_pinnacle.c / msnd_classic.c
  20 *
  21 * -- If MSND_CLASSIC is defined:
  22 *
  23 *     -> driver for Turtle Beach Classic/Monterey/Tahiti
  24 *
  25 * -- Else
  26 *
  27 *     -> driver for Turtle Beach Pinnacle/Fiji
  28 *
  29 * 12-3-2000  Modified IO port validation  Steve Sycamore
  30 *
  31 * Copyright (C) 1998 Andrew Veliath
  32 *
  33 * This program is free software; you can redistribute it and/or modify
  34 * it under the terms of the GNU General Public License as published by
  35 * the Free Software Foundation; either version 2 of the License, or
  36 * (at your option) any later version.
  37 *
  38 * This program is distributed in the hope that it will be useful,
  39 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  41 * GNU General Public License for more details.
  42 *
  43 * You should have received a copy of the GNU General Public License
  44 * along with this program; if not, write to the Free Software
  45 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  46 *
  47 ********************************************************************/
  48
  49#include <linux/kernel.h>
  50#include <linux/module.h>
  51#include <linux/interrupt.h>
  52#include <linux/types.h>
  53#include <linux/delay.h>
  54#include <linux/ioport.h>
  55#include <linux/firmware.h>
  56#include <linux/isa.h>
  57#include <linux/isapnp.h>
  58#include <linux/irq.h>
  59#include <linux/io.h>
  60
  61#include <sound/core.h>
  62#include <sound/initval.h>
  63#include <sound/asound.h>
  64#include <sound/pcm.h>
  65#include <sound/mpu401.h>
  66
  67#ifdef MSND_CLASSIC
  68# ifndef __alpha__
  69#  define SLOWIO
  70# endif
  71#endif
  72#include "msnd.h"
  73#ifdef MSND_CLASSIC
  74#  include "msnd_classic.h"
  75#  define LOGNAME                       "msnd_classic"
  76#  define DEV_NAME                      "msnd-classic"
  77#else
  78#  include "msnd_pinnacle.h"
  79#  define LOGNAME                       "snd_msnd_pinnacle"
  80#  define DEV_NAME                      "msnd-pinnacle"
  81#endif
  82
  83static void set_default_audio_parameters(struct snd_msnd *chip)
  84{
  85        chip->play_sample_size = snd_pcm_format_width(DEFSAMPLESIZE);
  86        chip->play_sample_rate = DEFSAMPLERATE;
  87        chip->play_channels = DEFCHANNELS;
  88        chip->capture_sample_size = snd_pcm_format_width(DEFSAMPLESIZE);
  89        chip->capture_sample_rate = DEFSAMPLERATE;
  90        chip->capture_channels = DEFCHANNELS;
  91}
  92
  93static void snd_msnd_eval_dsp_msg(struct snd_msnd *chip, u16 wMessage)
  94{
  95        switch (HIBYTE(wMessage)) {
  96        case HIMT_PLAY_DONE: {
  97                if (chip->banksPlayed < 3)
  98                        snd_printdd("%08X: HIMT_PLAY_DONE: %i\n",
  99                                (unsigned)jiffies, LOBYTE(wMessage));
 100
 101                if (chip->last_playbank == LOBYTE(wMessage)) {
 102                        snd_printdd("chip.last_playbank == LOBYTE(wMessage)\n");
 103                        break;
 104                }
 105                chip->banksPlayed++;
 106
 107                if (test_bit(F_WRITING, &chip->flags))
 108                        snd_msnd_DAPQ(chip, 0);
 109
 110                chip->last_playbank = LOBYTE(wMessage);
 111                chip->playDMAPos += chip->play_period_bytes;
 112                if (chip->playDMAPos > chip->playLimit)
 113                        chip->playDMAPos = 0;
 114                snd_pcm_period_elapsed(chip->playback_substream);
 115
 116                break;
 117        }
 118        case HIMT_RECORD_DONE:
 119                if (chip->last_recbank == LOBYTE(wMessage))
 120                        break;
 121                chip->last_recbank = LOBYTE(wMessage);
 122                chip->captureDMAPos += chip->capturePeriodBytes;
 123                if (chip->captureDMAPos > (chip->captureLimit))
 124                        chip->captureDMAPos = 0;
 125
 126                if (test_bit(F_READING, &chip->flags))
 127                        snd_msnd_DARQ(chip, chip->last_recbank);
 128
 129                snd_pcm_period_elapsed(chip->capture_substream);
 130                break;
 131
 132        case HIMT_DSP:
 133                switch (LOBYTE(wMessage)) {
 134#ifndef MSND_CLASSIC
 135                case HIDSP_PLAY_UNDER:
 136#endif
 137                case HIDSP_INT_PLAY_UNDER:
 138                        snd_printd(KERN_WARNING LOGNAME ": Play underflow %i\n",
 139                                chip->banksPlayed);
 140                        if (chip->banksPlayed > 2)
 141                                clear_bit(F_WRITING, &chip->flags);
 142                        break;
 143
 144                case HIDSP_INT_RECORD_OVER:
 145                        snd_printd(KERN_WARNING LOGNAME ": Record overflow\n");
 146                        clear_bit(F_READING, &chip->flags);
 147                        break;
 148
 149                default:
 150                        snd_printd(KERN_WARNING LOGNAME
 151                                   ": DSP message %d 0x%02x\n",
 152                                   LOBYTE(wMessage), LOBYTE(wMessage));
 153                        break;
 154                }
 155                break;
 156
 157        case HIMT_MIDI_IN_UCHAR:
 158                if (chip->msndmidi_mpu)
 159                        snd_msndmidi_input_read(chip->msndmidi_mpu);
 160                break;
 161
 162        default:
 163                snd_printd(KERN_WARNING LOGNAME ": HIMT message %d 0x%02x\n",
 164                           HIBYTE(wMessage), HIBYTE(wMessage));
 165                break;
 166        }
 167}
 168
 169static irqreturn_t snd_msnd_interrupt(int irq, void *dev_id)
 170{
 171        struct snd_msnd *chip = dev_id;
 172        void __iomem *pwDSPQData = chip->mappedbase + DSPQ_DATA_BUFF;
 173        u16 head, tail, size;
 174
 175        /* Send ack to DSP */
 176        /* inb(chip->io + HP_RXL); */
 177
 178        /* Evaluate queued DSP messages */
 179        head = readw(chip->DSPQ + JQS_wHead);
 180        tail = readw(chip->DSPQ + JQS_wTail);
 181        size = readw(chip->DSPQ + JQS_wSize);
 182        if (head > size || tail > size)
 183                goto out;
 184        while (head != tail) {
 185                snd_msnd_eval_dsp_msg(chip, readw(pwDSPQData + 2 * head));
 186                if (++head > size)
 187                        head = 0;
 188                writew(head, chip->DSPQ + JQS_wHead);
 189        }
 190 out:
 191        /* Send ack to DSP */
 192        inb(chip->io + HP_RXL);
 193        return IRQ_HANDLED;
 194}
 195
 196
 197static int snd_msnd_reset_dsp(long io, unsigned char *info)
 198{
 199        int timeout = 100;
 200
 201        outb(HPDSPRESET_ON, io + HP_DSPR);
 202        msleep(1);
 203#ifndef MSND_CLASSIC
 204        if (info)
 205                *info = inb(io + HP_INFO);
 206#endif
 207        outb(HPDSPRESET_OFF, io + HP_DSPR);
 208        msleep(1);
 209        while (timeout-- > 0) {
 210                if (inb(io + HP_CVR) == HP_CVR_DEF)
 211                        return 0;
 212                msleep(1);
 213        }
 214        snd_printk(KERN_ERR LOGNAME ": Cannot reset DSP\n");
 215
 216        return -EIO;
 217}
 218
 219static int snd_msnd_probe(struct snd_card *card)
 220{
 221        struct snd_msnd *chip = card->private_data;
 222        unsigned char info;
 223#ifndef MSND_CLASSIC
 224        char *xv, *rev = NULL;
 225        char *pin = "TB Pinnacle", *fiji = "TB Fiji";
 226        char *pinfiji = "TB Pinnacle/Fiji";
 227#endif
 228
 229        if (!request_region(chip->io, DSP_NUMIO, "probing")) {
 230                snd_printk(KERN_ERR LOGNAME ": I/O port conflict\n");
 231                return -ENODEV;
 232        }
 233
 234        if (snd_msnd_reset_dsp(chip->io, &info) < 0) {
 235                release_region(chip->io, DSP_NUMIO);
 236                return -ENODEV;
 237        }
 238
 239#ifdef MSND_CLASSIC
 240        strcpy(card->shortname, "Classic/Tahiti/Monterey");
 241        strcpy(card->longname, "Turtle Beach Multisound");
 242        printk(KERN_INFO LOGNAME ": %s, "
 243               "I/O 0x%lx-0x%lx, IRQ %d, memory mapped to 0x%lX-0x%lX\n",
 244               card->shortname,
 245               chip->io, chip->io + DSP_NUMIO - 1,
 246               chip->irq,
 247               chip->base, chip->base + 0x7fff);
 248#else
 249        switch (info >> 4) {
 250        case 0xf:
 251                xv = "<= 1.15";
 252                break;
 253        case 0x1:
 254                xv = "1.18/1.2";
 255                break;
 256        case 0x2:
 257                xv = "1.3";
 258                break;
 259        case 0x3:
 260                xv = "1.4";
 261                break;
 262        default:
 263                xv = "unknown";
 264                break;
 265        }
 266
 267        switch (info & 0x7) {
 268        case 0x0:
 269                rev = "I";
 270                strcpy(card->shortname, pin);
 271                break;
 272        case 0x1:
 273                rev = "F";
 274                strcpy(card->shortname, pin);
 275                break;
 276        case 0x2:
 277                rev = "G";
 278                strcpy(card->shortname, pin);
 279                break;
 280        case 0x3:
 281                rev = "H";
 282                strcpy(card->shortname, pin);
 283                break;
 284        case 0x4:
 285                rev = "E";
 286                strcpy(card->shortname, fiji);
 287                break;
 288        case 0x5:
 289                rev = "C";
 290                strcpy(card->shortname, fiji);
 291                break;
 292        case 0x6:
 293                rev = "D";
 294                strcpy(card->shortname, fiji);
 295                break;
 296        case 0x7:
 297                rev = "A-B (Fiji) or A-E (Pinnacle)";
 298                strcpy(card->shortname, pinfiji);
 299                break;
 300        }
 301        strcpy(card->longname, "Turtle Beach Multisound Pinnacle");
 302        printk(KERN_INFO LOGNAME ": %s revision %s, Xilinx version %s, "
 303               "I/O 0x%lx-0x%lx, IRQ %d, memory mapped to 0x%lX-0x%lX\n",
 304               card->shortname,
 305               rev, xv,
 306               chip->io, chip->io + DSP_NUMIO - 1,
 307               chip->irq,
 308               chip->base, chip->base + 0x7fff);
 309#endif
 310
 311        release_region(chip->io, DSP_NUMIO);
 312        return 0;
 313}
 314
 315static int snd_msnd_init_sma(struct snd_msnd *chip)
 316{
 317        static int initted;
 318        u16 mastVolLeft, mastVolRight;
 319        unsigned long flags;
 320
 321#ifdef MSND_CLASSIC
 322        outb(chip->memid, chip->io + HP_MEMM);
 323#endif
 324        outb(HPBLKSEL_0, chip->io + HP_BLKS);
 325        /* Motorola 56k shared memory base */
 326        chip->SMA = chip->mappedbase + SMA_STRUCT_START;
 327
 328        if (initted) {
 329                mastVolLeft = readw(chip->SMA + SMA_wCurrMastVolLeft);
 330                mastVolRight = readw(chip->SMA + SMA_wCurrMastVolRight);
 331        } else
 332                mastVolLeft = mastVolRight = 0;
 333        memset_io(chip->mappedbase, 0, 0x8000);
 334
 335        /* Critical section: bank 1 access */
 336        spin_lock_irqsave(&chip->lock, flags);
 337        outb(HPBLKSEL_1, chip->io + HP_BLKS);
 338        memset_io(chip->mappedbase, 0, 0x8000);
 339        outb(HPBLKSEL_0, chip->io + HP_BLKS);
 340        spin_unlock_irqrestore(&chip->lock, flags);
 341
 342        /* Digital audio play queue */
 343        chip->DAPQ = chip->mappedbase + DAPQ_OFFSET;
 344        snd_msnd_init_queue(chip->DAPQ, DAPQ_DATA_BUFF, DAPQ_BUFF_SIZE);
 345
 346        /* Digital audio record queue */
 347        chip->DARQ = chip->mappedbase + DARQ_OFFSET;
 348        snd_msnd_init_queue(chip->DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE);
 349
 350        /* MIDI out queue */
 351        chip->MODQ = chip->mappedbase + MODQ_OFFSET;
 352        snd_msnd_init_queue(chip->MODQ, MODQ_DATA_BUFF, MODQ_BUFF_SIZE);
 353
 354        /* MIDI in queue */
 355        chip->MIDQ = chip->mappedbase + MIDQ_OFFSET;
 356        snd_msnd_init_queue(chip->MIDQ, MIDQ_DATA_BUFF, MIDQ_BUFF_SIZE);
 357
 358        /* DSP -> host message queue */
 359        chip->DSPQ = chip->mappedbase + DSPQ_OFFSET;
 360        snd_msnd_init_queue(chip->DSPQ, DSPQ_DATA_BUFF, DSPQ_BUFF_SIZE);
 361
 362        /* Setup some DSP values */
 363#ifndef MSND_CLASSIC
 364        writew(1, chip->SMA + SMA_wCurrPlayFormat);
 365        writew(chip->play_sample_size, chip->SMA + SMA_wCurrPlaySampleSize);
 366        writew(chip->play_channels, chip->SMA + SMA_wCurrPlayChannels);
 367        writew(chip->play_sample_rate, chip->SMA + SMA_wCurrPlaySampleRate);
 368#endif
 369        writew(chip->play_sample_rate, chip->SMA + SMA_wCalFreqAtoD);
 370        writew(mastVolLeft, chip->SMA + SMA_wCurrMastVolLeft);
 371        writew(mastVolRight, chip->SMA + SMA_wCurrMastVolRight);
 372#ifndef MSND_CLASSIC
 373        writel(0x00010000, chip->SMA + SMA_dwCurrPlayPitch);
 374        writel(0x00000001, chip->SMA + SMA_dwCurrPlayRate);
 375#endif
 376        writew(0x303, chip->SMA + SMA_wCurrInputTagBits);
 377
 378        initted = 1;
 379
 380        return 0;
 381}
 382
 383
 384static int upload_dsp_code(struct snd_card *card)
 385{
 386        struct snd_msnd *chip = card->private_data;
 387        const struct firmware *init_fw = NULL, *perm_fw = NULL;
 388        int err;
 389
 390        outb(HPBLKSEL_0, chip->io + HP_BLKS);
 391
 392        err = request_firmware(&init_fw, INITCODEFILE, card->dev);
 393        if (err < 0) {
 394                printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
 395                goto cleanup1;
 396        }
 397        err = request_firmware(&perm_fw, PERMCODEFILE, card->dev);
 398        if (err < 0) {
 399                printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
 400                goto cleanup;
 401        }
 402
 403        memcpy_toio(chip->mappedbase, perm_fw->data, perm_fw->size);
 404        if (snd_msnd_upload_host(chip, init_fw->data, init_fw->size) < 0) {
 405                printk(KERN_WARNING LOGNAME ": Error uploading to DSP\n");
 406                err = -ENODEV;
 407                goto cleanup;
 408        }
 409        printk(KERN_INFO LOGNAME ": DSP firmware uploaded\n");
 410        err = 0;
 411
 412cleanup:
 413        release_firmware(perm_fw);
 414cleanup1:
 415        release_firmware(init_fw);
 416        return err;
 417}
 418
 419#ifdef MSND_CLASSIC
 420static void reset_proteus(struct snd_msnd *chip)
 421{
 422        outb(HPPRORESET_ON, chip->io + HP_PROR);
 423        msleep(TIME_PRO_RESET);
 424        outb(HPPRORESET_OFF, chip->io + HP_PROR);
 425        msleep(TIME_PRO_RESET_DONE);
 426}
 427#endif
 428
 429static int snd_msnd_initialize(struct snd_card *card)
 430{
 431        struct snd_msnd *chip = card->private_data;
 432        int err, timeout;
 433
 434#ifdef MSND_CLASSIC
 435        outb(HPWAITSTATE_0, chip->io + HP_WAIT);
 436        outb(HPBITMODE_16, chip->io + HP_BITM);
 437
 438        reset_proteus(chip);
 439#endif
 440        err = snd_msnd_init_sma(chip);
 441        if (err < 0) {
 442                printk(KERN_WARNING LOGNAME ": Cannot initialize SMA\n");
 443                return err;
 444        }
 445
 446        err = snd_msnd_reset_dsp(chip->io, NULL);
 447        if (err < 0)
 448                return err;
 449
 450        err = upload_dsp_code(card);
 451        if (err < 0) {
 452                printk(KERN_WARNING LOGNAME ": Cannot upload DSP code\n");
 453                return err;
 454        }
 455
 456        timeout = 200;
 457
 458        while (readw(chip->mappedbase)) {
 459                msleep(1);
 460                if (!timeout--) {
 461                        snd_printd(KERN_ERR LOGNAME ": DSP reset timeout\n");
 462                        return -EIO;
 463                }
 464        }
 465
 466        snd_msndmix_setup(chip);
 467        return 0;
 468}
 469
 470static int snd_msnd_dsp_full_reset(struct snd_card *card)
 471{
 472        struct snd_msnd *chip = card->private_data;
 473        int rv;
 474
 475        if (test_bit(F_RESETTING, &chip->flags) || ++chip->nresets > 10)
 476                return 0;
 477
 478        set_bit(F_RESETTING, &chip->flags);
 479        snd_msnd_dsp_halt(chip, NULL);  /* Unconditionally halt */
 480
 481        rv = snd_msnd_initialize(card);
 482        if (rv)
 483                printk(KERN_WARNING LOGNAME ": DSP reset failed\n");
 484        snd_msndmix_force_recsrc(chip, 0);
 485        clear_bit(F_RESETTING, &chip->flags);
 486        return rv;
 487}
 488
 489static int snd_msnd_dev_free(struct snd_device *device)
 490{
 491        snd_printdd("snd_msnd_chip_free()\n");
 492        return 0;
 493}
 494
 495static int snd_msnd_send_dsp_cmd_chk(struct snd_msnd *chip, u8 cmd)
 496{
 497        if (snd_msnd_send_dsp_cmd(chip, cmd) == 0)
 498                return 0;
 499        snd_msnd_dsp_full_reset(chip->card);
 500        return snd_msnd_send_dsp_cmd(chip, cmd);
 501}
 502
 503static int snd_msnd_calibrate_adc(struct snd_msnd *chip, u16 srate)
 504{
 505        snd_printdd("snd_msnd_calibrate_adc(%i)\n", srate);
 506        writew(srate, chip->SMA + SMA_wCalFreqAtoD);
 507        if (chip->calibrate_signal == 0)
 508                writew(readw(chip->SMA + SMA_wCurrHostStatusFlags)
 509                       | 0x0001, chip->SMA + SMA_wCurrHostStatusFlags);
 510        else
 511                writew(readw(chip->SMA + SMA_wCurrHostStatusFlags)
 512                       & ~0x0001, chip->SMA + SMA_wCurrHostStatusFlags);
 513        if (snd_msnd_send_word(chip, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
 514            snd_msnd_send_dsp_cmd_chk(chip, HDEX_AUX_REQ) == 0) {
 515                schedule_timeout_interruptible(msecs_to_jiffies(333));
 516                return 0;
 517        }
 518        printk(KERN_WARNING LOGNAME ": ADC calibration failed\n");
 519        return -EIO;
 520}
 521
 522/*
 523 * ALSA callback function, called when attempting to open the MIDI device.
 524 */
 525static int snd_msnd_mpu401_open(struct snd_mpu401 *mpu)
 526{
 527        snd_msnd_enable_irq(mpu->private_data);
 528        snd_msnd_send_dsp_cmd(mpu->private_data, HDEX_MIDI_IN_START);
 529        return 0;
 530}
 531
 532static void snd_msnd_mpu401_close(struct snd_mpu401 *mpu)
 533{
 534        snd_msnd_send_dsp_cmd(mpu->private_data, HDEX_MIDI_IN_STOP);
 535        snd_msnd_disable_irq(mpu->private_data);
 536}
 537
 538static long mpu_io[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 539static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
 540
 541static int snd_msnd_attach(struct snd_card *card)
 542{
 543        struct snd_msnd *chip = card->private_data;
 544        int err;
 545        static struct snd_device_ops ops = {
 546                .dev_free =      snd_msnd_dev_free,
 547                };
 548
 549        err = request_irq(chip->irq, snd_msnd_interrupt, 0, card->shortname,
 550                          chip);
 551        if (err < 0) {
 552                printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", chip->irq);
 553                return err;
 554        }
 555        if (request_region(chip->io, DSP_NUMIO, card->shortname) == NULL) {
 556                free_irq(chip->irq, chip);
 557                return -EBUSY;
 558        }
 559
 560        if (!request_mem_region(chip->base, BUFFSIZE, card->shortname)) {
 561                printk(KERN_ERR LOGNAME
 562                        ": unable to grab memory region 0x%lx-0x%lx\n",
 563                        chip->base, chip->base + BUFFSIZE - 1);
 564                release_region(chip->io, DSP_NUMIO);
 565                free_irq(chip->irq, chip);
 566                return -EBUSY;
 567        }
 568        chip->mappedbase = ioremap_nocache(chip->base, 0x8000);
 569        if (!chip->mappedbase) {
 570                printk(KERN_ERR LOGNAME
 571                        ": unable to map memory region 0x%lx-0x%lx\n",
 572                        chip->base, chip->base + BUFFSIZE - 1);
 573                err = -EIO;
 574                goto err_release_region;
 575        }
 576
 577        err = snd_msnd_dsp_full_reset(card);
 578        if (err < 0)
 579                goto err_release_region;
 580
 581        /* Register device */
 582        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
 583        if (err < 0)
 584                goto err_release_region;
 585
 586        err = snd_msnd_pcm(card, 0);
 587        if (err < 0) {
 588                printk(KERN_ERR LOGNAME ": error creating new PCM device\n");
 589                goto err_release_region;
 590        }
 591
 592        err = snd_msndmix_new(card);
 593        if (err < 0) {
 594                printk(KERN_ERR LOGNAME ": error creating new Mixer device\n");
 595                goto err_release_region;
 596        }
 597
 598
 599        if (mpu_io[0] != SNDRV_AUTO_PORT) {
 600                struct snd_mpu401 *mpu;
 601
 602                err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
 603                                          mpu_io[0],
 604                                          MPU401_MODE_INPUT |
 605                                          MPU401_MODE_OUTPUT,
 606                                          mpu_irq[0],
 607                                          &chip->rmidi);
 608                if (err < 0) {
 609                        printk(KERN_ERR LOGNAME
 610                                ": error creating new Midi device\n");
 611                        goto err_release_region;
 612                }
 613                mpu = chip->rmidi->private_data;
 614
 615                mpu->open_input = snd_msnd_mpu401_open;
 616                mpu->close_input = snd_msnd_mpu401_close;
 617                mpu->private_data = chip;
 618        }
 619
 620        disable_irq(chip->irq);
 621        snd_msnd_calibrate_adc(chip, chip->play_sample_rate);
 622        snd_msndmix_force_recsrc(chip, 0);
 623
 624        err = snd_card_register(card);
 625        if (err < 0)
 626                goto err_release_region;
 627
 628        return 0;
 629
 630err_release_region:
 631        iounmap(chip->mappedbase);
 632        release_mem_region(chip->base, BUFFSIZE);
 633        release_region(chip->io, DSP_NUMIO);
 634        free_irq(chip->irq, chip);
 635        return err;
 636}
 637
 638
 639static void snd_msnd_unload(struct snd_card *card)
 640{
 641        struct snd_msnd *chip = card->private_data;
 642
 643        iounmap(chip->mappedbase);
 644        release_mem_region(chip->base, BUFFSIZE);
 645        release_region(chip->io, DSP_NUMIO);
 646        free_irq(chip->irq, chip);
 647        snd_card_free(card);
 648}
 649
 650#ifndef MSND_CLASSIC
 651
 652/* Pinnacle/Fiji Logical Device Configuration */
 653
 654static int snd_msnd_write_cfg(int cfg, int reg, int value)
 655{
 656        outb(reg, cfg);
 657        outb(value, cfg + 1);
 658        if (value != inb(cfg + 1)) {
 659                printk(KERN_ERR LOGNAME ": snd_msnd_write_cfg: I/O error\n");
 660                return -EIO;
 661        }
 662        return 0;
 663}
 664
 665static int snd_msnd_write_cfg_io0(int cfg, int num, u16 io)
 666{
 667        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
 668                return -EIO;
 669        if (snd_msnd_write_cfg(cfg, IREG_IO0_BASEHI, HIBYTE(io)))
 670                return -EIO;
 671        if (snd_msnd_write_cfg(cfg, IREG_IO0_BASELO, LOBYTE(io)))
 672                return -EIO;
 673        return 0;
 674}
 675
 676static int snd_msnd_write_cfg_io1(int cfg, int num, u16 io)
 677{
 678        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
 679                return -EIO;
 680        if (snd_msnd_write_cfg(cfg, IREG_IO1_BASEHI, HIBYTE(io)))
 681                return -EIO;
 682        if (snd_msnd_write_cfg(cfg, IREG_IO1_BASELO, LOBYTE(io)))
 683                return -EIO;
 684        return 0;
 685}
 686
 687static int snd_msnd_write_cfg_irq(int cfg, int num, u16 irq)
 688{
 689        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
 690                return -EIO;
 691        if (snd_msnd_write_cfg(cfg, IREG_IRQ_NUMBER, LOBYTE(irq)))
 692                return -EIO;
 693        if (snd_msnd_write_cfg(cfg, IREG_IRQ_TYPE, IRQTYPE_EDGE))
 694                return -EIO;
 695        return 0;
 696}
 697
 698static int snd_msnd_write_cfg_mem(int cfg, int num, int mem)
 699{
 700        u16 wmem;
 701
 702        mem >>= 8;
 703        wmem = (u16)(mem & 0xfff);
 704        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
 705                return -EIO;
 706        if (snd_msnd_write_cfg(cfg, IREG_MEMBASEHI, HIBYTE(wmem)))
 707                return -EIO;
 708        if (snd_msnd_write_cfg(cfg, IREG_MEMBASELO, LOBYTE(wmem)))
 709                return -EIO;
 710        if (wmem && snd_msnd_write_cfg(cfg, IREG_MEMCONTROL,
 711                                       MEMTYPE_HIADDR | MEMTYPE_16BIT))
 712                return -EIO;
 713        return 0;
 714}
 715
 716static int snd_msnd_activate_logical(int cfg, int num)
 717{
 718        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
 719                return -EIO;
 720        if (snd_msnd_write_cfg(cfg, IREG_ACTIVATE, LD_ACTIVATE))
 721                return -EIO;
 722        return 0;
 723}
 724
 725static int snd_msnd_write_cfg_logical(int cfg, int num, u16 io0,
 726                                      u16 io1, u16 irq, int mem)
 727{
 728        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
 729                return -EIO;
 730        if (snd_msnd_write_cfg_io0(cfg, num, io0))
 731                return -EIO;
 732        if (snd_msnd_write_cfg_io1(cfg, num, io1))
 733                return -EIO;
 734        if (snd_msnd_write_cfg_irq(cfg, num, irq))
 735                return -EIO;
 736        if (snd_msnd_write_cfg_mem(cfg, num, mem))
 737                return -EIO;
 738        if (snd_msnd_activate_logical(cfg, num))
 739                return -EIO;
 740        return 0;
 741}
 742
 743static int snd_msnd_pinnacle_cfg_reset(int cfg)
 744{
 745        int i;
 746
 747        /* Reset devices if told to */
 748        printk(KERN_INFO LOGNAME ": Resetting all devices\n");
 749        for (i = 0; i < 4; ++i)
 750                if (snd_msnd_write_cfg_logical(cfg, i, 0, 0, 0, 0))
 751                        return -EIO;
 752
 753        return 0;
 754}
 755#endif
 756
 757static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 758static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 759
 760module_param_array(index, int, NULL, 0444);
 761MODULE_PARM_DESC(index, "Index value for msnd_pinnacle soundcard.");
 762module_param_array(id, charp, NULL, 0444);
 763MODULE_PARM_DESC(id, "ID string for msnd_pinnacle soundcard.");
 764
 765static long io[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 766static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
 767static long mem[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 768
 769#ifndef MSND_CLASSIC
 770static long cfg[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 771
 772/* Extra Peripheral Configuration (Default: Disable) */
 773static long ide_io0[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 774static long ide_io1[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 775static int ide_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
 776
 777static long joystick_io[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 778/* If we have the digital daugherboard... */
 779static int digital[SNDRV_CARDS];
 780
 781/* Extra Peripheral Configuration */
 782static int reset[SNDRV_CARDS];
 783#endif
 784
 785static int write_ndelay[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 1 };
 786
 787static int calibrate_signal;
 788
 789#ifdef CONFIG_PNP
 790static bool isapnp[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
 791module_param_array(isapnp, bool, NULL, 0444);
 792MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
 793#define has_isapnp(x) isapnp[x]
 794#else
 795#define has_isapnp(x) 0
 796#endif
 797
 798MODULE_AUTHOR("Karsten Wiese <annabellesgarden@yahoo.de>");
 799MODULE_DESCRIPTION("Turtle Beach " LONGNAME " Linux Driver");
 800MODULE_LICENSE("GPL");
 801MODULE_FIRMWARE(INITCODEFILE);
 802MODULE_FIRMWARE(PERMCODEFILE);
 803
 804module_param_hw_array(io, long, ioport, NULL, 0444);
 805MODULE_PARM_DESC(io, "IO port #");
 806module_param_hw_array(irq, int, irq, NULL, 0444);
 807module_param_hw_array(mem, long, iomem, NULL, 0444);
 808module_param_array(write_ndelay, int, NULL, 0444);
 809module_param(calibrate_signal, int, 0444);
 810#ifndef MSND_CLASSIC
 811module_param_array(digital, int, NULL, 0444);
 812module_param_hw_array(cfg, long, ioport, NULL, 0444);
 813module_param_array(reset, int, NULL, 0444);
 814module_param_hw_array(mpu_io, long, ioport, NULL, 0444);
 815module_param_hw_array(mpu_irq, int, irq, NULL, 0444);
 816module_param_hw_array(ide_io0, long, ioport, NULL, 0444);
 817module_param_hw_array(ide_io1, long, ioport, NULL, 0444);
 818module_param_hw_array(ide_irq, int, irq, NULL, 0444);
 819module_param_hw_array(joystick_io, long, ioport, NULL, 0444);
 820#endif
 821
 822
 823static int snd_msnd_isa_match(struct device *pdev, unsigned int i)
 824{
 825        if (io[i] == SNDRV_AUTO_PORT)
 826                return 0;
 827
 828        if (irq[i] == SNDRV_AUTO_PORT || mem[i] == SNDRV_AUTO_PORT) {
 829                printk(KERN_WARNING LOGNAME ": io, irq and mem must be set\n");
 830                return 0;
 831        }
 832
 833#ifdef MSND_CLASSIC
 834        if (!(io[i] == 0x290 ||
 835              io[i] == 0x260 ||
 836              io[i] == 0x250 ||
 837              io[i] == 0x240 ||
 838              io[i] == 0x230 ||
 839              io[i] == 0x220 ||
 840              io[i] == 0x210 ||
 841              io[i] == 0x3e0)) {
 842                printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must be set "
 843                        " to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, "
 844                        "or 0x3E0\n");
 845                return 0;
 846        }
 847#else
 848        if (io[i] < 0x100 || io[i] > 0x3e0 || (io[i] % 0x10) != 0) {
 849                printk(KERN_ERR LOGNAME
 850                        ": \"io\" - DSP I/O base must within the range 0x100 "
 851                        "to 0x3E0 and must be evenly divisible by 0x10\n");
 852                return 0;
 853        }
 854#endif /* MSND_CLASSIC */
 855
 856        if (!(irq[i] == 5 ||
 857              irq[i] == 7 ||
 858              irq[i] == 9 ||
 859              irq[i] == 10 ||
 860              irq[i] == 11 ||
 861              irq[i] == 12)) {
 862                printk(KERN_ERR LOGNAME
 863                        ": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
 864                return 0;
 865        }
 866
 867        if (!(mem[i] == 0xb0000 ||
 868              mem[i] == 0xc8000 ||
 869              mem[i] == 0xd0000 ||
 870              mem[i] == 0xd8000 ||
 871              mem[i] == 0xe0000 ||
 872              mem[i] == 0xe8000)) {
 873                printk(KERN_ERR LOGNAME ": \"mem\" - must be set to "
 874                       "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or "
 875                       "0xe8000\n");
 876                return 0;
 877        }
 878
 879#ifndef MSND_CLASSIC
 880        if (cfg[i] == SNDRV_AUTO_PORT) {
 881                printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
 882        } else if (cfg[i] != 0x250 && cfg[i] != 0x260 && cfg[i] != 0x270) {
 883                printk(KERN_INFO LOGNAME
 884                        ": Config port must be 0x250, 0x260 or 0x270 "
 885                        "(or unspecified for PnP mode)\n");
 886                return 0;
 887        }
 888#endif /* MSND_CLASSIC */
 889
 890        return 1;
 891}
 892
 893static int snd_msnd_isa_probe(struct device *pdev, unsigned int idx)
 894{
 895        int err;
 896        struct snd_card *card;
 897        struct snd_msnd *chip;
 898
 899        if (has_isapnp(idx)
 900#ifndef MSND_CLASSIC
 901            || cfg[idx] == SNDRV_AUTO_PORT
 902#endif
 903            ) {
 904                printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
 905                return -ENODEV;
 906        }
 907
 908        err = snd_card_new(pdev, index[idx], id[idx], THIS_MODULE,
 909                           sizeof(struct snd_msnd), &card);
 910        if (err < 0)
 911                return err;
 912
 913        chip = card->private_data;
 914        chip->card = card;
 915
 916#ifdef MSND_CLASSIC
 917        switch (irq[idx]) {
 918        case 5:
 919                chip->irqid = HPIRQ_5; break;
 920        case 7:
 921                chip->irqid = HPIRQ_7; break;
 922        case 9:
 923                chip->irqid = HPIRQ_9; break;
 924        case 10:
 925                chip->irqid = HPIRQ_10; break;
 926        case 11:
 927                chip->irqid = HPIRQ_11; break;
 928        case 12:
 929                chip->irqid = HPIRQ_12; break;
 930        }
 931
 932        switch (mem[idx]) {
 933        case 0xb0000:
 934                chip->memid = HPMEM_B000; break;
 935        case 0xc8000:
 936                chip->memid = HPMEM_C800; break;
 937        case 0xd0000:
 938                chip->memid = HPMEM_D000; break;
 939        case 0xd8000:
 940                chip->memid = HPMEM_D800; break;
 941        case 0xe0000:
 942                chip->memid = HPMEM_E000; break;
 943        case 0xe8000:
 944                chip->memid = HPMEM_E800; break;
 945        }
 946#else
 947        printk(KERN_INFO LOGNAME ": Non-PnP mode: configuring at port 0x%lx\n",
 948                        cfg[idx]);
 949
 950        if (!request_region(cfg[idx], 2, "Pinnacle/Fiji Config")) {
 951                printk(KERN_ERR LOGNAME ": Config port 0x%lx conflict\n",
 952                           cfg[idx]);
 953                snd_card_free(card);
 954                return -EIO;
 955        }
 956        if (reset[idx])
 957                if (snd_msnd_pinnacle_cfg_reset(cfg[idx])) {
 958                        err = -EIO;
 959                        goto cfg_error;
 960                }
 961
 962        /* DSP */
 963        err = snd_msnd_write_cfg_logical(cfg[idx], 0,
 964                                         io[idx], 0,
 965                                         irq[idx], mem[idx]);
 966
 967        if (err)
 968                goto cfg_error;
 969
 970        /* The following are Pinnacle specific */
 971
 972        /* MPU */
 973        if (mpu_io[idx] != SNDRV_AUTO_PORT
 974            && mpu_irq[idx] != SNDRV_AUTO_IRQ) {
 975                printk(KERN_INFO LOGNAME
 976                       ": Configuring MPU to I/O 0x%lx IRQ %d\n",
 977                       mpu_io[idx], mpu_irq[idx]);
 978                err = snd_msnd_write_cfg_logical(cfg[idx], 1,
 979                                                 mpu_io[idx], 0,
 980                                                 mpu_irq[idx], 0);
 981
 982                if (err)
 983                        goto cfg_error;
 984        }
 985
 986        /* IDE */
 987        if (ide_io0[idx] != SNDRV_AUTO_PORT
 988            && ide_io1[idx] != SNDRV_AUTO_PORT
 989            && ide_irq[idx] != SNDRV_AUTO_IRQ) {
 990                printk(KERN_INFO LOGNAME
 991                       ": Configuring IDE to I/O 0x%lx, 0x%lx IRQ %d\n",
 992                       ide_io0[idx], ide_io1[idx], ide_irq[idx]);
 993                err = snd_msnd_write_cfg_logical(cfg[idx], 2,
 994                                                 ide_io0[idx], ide_io1[idx],
 995                                                 ide_irq[idx], 0);
 996
 997                if (err)
 998                        goto cfg_error;
 999        }
1000
1001        /* Joystick */
1002        if (joystick_io[idx] != SNDRV_AUTO_PORT) {
1003                printk(KERN_INFO LOGNAME
1004                       ": Configuring joystick to I/O 0x%lx\n",
1005                       joystick_io[idx]);
1006                err = snd_msnd_write_cfg_logical(cfg[idx], 3,
1007                                                 joystick_io[idx], 0,
1008                                                 0, 0);
1009
1010                if (err)
1011                        goto cfg_error;
1012        }
1013        release_region(cfg[idx], 2);
1014
1015#endif /* MSND_CLASSIC */
1016
1017        set_default_audio_parameters(chip);
1018#ifdef MSND_CLASSIC
1019        chip->type = msndClassic;
1020#else
1021        chip->type = msndPinnacle;
1022#endif
1023        chip->io = io[idx];
1024        chip->irq = irq[idx];
1025        chip->base = mem[idx];
1026
1027        chip->calibrate_signal = calibrate_signal ? 1 : 0;
1028        chip->recsrc = 0;
1029        chip->dspq_data_buff = DSPQ_DATA_BUFF;
1030        chip->dspq_buff_size = DSPQ_BUFF_SIZE;
1031        if (write_ndelay[idx])
1032                clear_bit(F_DISABLE_WRITE_NDELAY, &chip->flags);
1033        else
1034                set_bit(F_DISABLE_WRITE_NDELAY, &chip->flags);
1035#ifndef MSND_CLASSIC
1036        if (digital[idx])
1037                set_bit(F_HAVEDIGITAL, &chip->flags);
1038#endif
1039        spin_lock_init(&chip->lock);
1040        err = snd_msnd_probe(card);
1041        if (err < 0) {
1042                printk(KERN_ERR LOGNAME ": Probe failed\n");
1043                snd_card_free(card);
1044                return err;
1045        }
1046
1047        err = snd_msnd_attach(card);
1048        if (err < 0) {
1049                printk(KERN_ERR LOGNAME ": Attach failed\n");
1050                snd_card_free(card);
1051                return err;
1052        }
1053        dev_set_drvdata(pdev, card);
1054
1055        return 0;
1056
1057#ifndef MSND_CLASSIC
1058cfg_error:
1059        release_region(cfg[idx], 2);
1060        snd_card_free(card);
1061        return err;
1062#endif
1063}
1064
1065static int snd_msnd_isa_remove(struct device *pdev, unsigned int dev)
1066{
1067        snd_msnd_unload(dev_get_drvdata(pdev));
1068        return 0;
1069}
1070
1071static struct isa_driver snd_msnd_driver = {
1072        .match          = snd_msnd_isa_match,
1073        .probe          = snd_msnd_isa_probe,
1074        .remove         = snd_msnd_isa_remove,
1075        /* FIXME: suspend, resume */
1076        .driver         = {
1077                .name   = DEV_NAME
1078        },
1079};
1080
1081#ifdef CONFIG_PNP
1082static int snd_msnd_pnp_detect(struct pnp_card_link *pcard,
1083                               const struct pnp_card_device_id *pid)
1084{
1085        static int idx;
1086        struct pnp_dev *pnp_dev;
1087        struct pnp_dev *mpu_dev;
1088        struct snd_card *card;
1089        struct snd_msnd *chip;
1090        int ret;
1091
1092        for ( ; idx < SNDRV_CARDS; idx++) {
1093                if (has_isapnp(idx))
1094                        break;
1095        }
1096        if (idx >= SNDRV_CARDS)
1097                return -ENODEV;
1098
1099        /*
1100         * Check that we still have room for another sound card ...
1101         */
1102        pnp_dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL);
1103        if (!pnp_dev)
1104                return -ENODEV;
1105
1106        mpu_dev = pnp_request_card_device(pcard, pid->devs[1].id, NULL);
1107        if (!mpu_dev)
1108                return -ENODEV;
1109
1110        if (!pnp_is_active(pnp_dev) && pnp_activate_dev(pnp_dev) < 0) {
1111                printk(KERN_INFO "msnd_pinnacle: device is inactive\n");
1112                return -EBUSY;
1113        }
1114
1115        if (!pnp_is_active(mpu_dev) && pnp_activate_dev(mpu_dev) < 0) {
1116                printk(KERN_INFO "msnd_pinnacle: MPU device is inactive\n");
1117                return -EBUSY;
1118        }
1119
1120        /*
1121         * Create a new ALSA sound card entry, in anticipation
1122         * of detecting our hardware ...
1123         */
1124        ret = snd_card_new(&pcard->card->dev,
1125                           index[idx], id[idx], THIS_MODULE,
1126                           sizeof(struct snd_msnd), &card);
1127        if (ret < 0)
1128                return ret;
1129
1130        chip = card->private_data;
1131        chip->card = card;
1132
1133        /*
1134         * Read the correct parameters off the ISA PnP bus ...
1135         */
1136        io[idx] = pnp_port_start(pnp_dev, 0);
1137        irq[idx] = pnp_irq(pnp_dev, 0);
1138        mem[idx] = pnp_mem_start(pnp_dev, 0);
1139        mpu_io[idx] = pnp_port_start(mpu_dev, 0);
1140        mpu_irq[idx] = pnp_irq(mpu_dev, 0);
1141
1142        set_default_audio_parameters(chip);
1143#ifdef MSND_CLASSIC
1144        chip->type = msndClassic;
1145#else
1146        chip->type = msndPinnacle;
1147#endif
1148        chip->io = io[idx];
1149        chip->irq = irq[idx];
1150        chip->base = mem[idx];
1151
1152        chip->calibrate_signal = calibrate_signal ? 1 : 0;
1153        chip->recsrc = 0;
1154        chip->dspq_data_buff = DSPQ_DATA_BUFF;
1155        chip->dspq_buff_size = DSPQ_BUFF_SIZE;
1156        if (write_ndelay[idx])
1157                clear_bit(F_DISABLE_WRITE_NDELAY, &chip->flags);
1158        else
1159                set_bit(F_DISABLE_WRITE_NDELAY, &chip->flags);
1160#ifndef MSND_CLASSIC
1161        if (digital[idx])
1162                set_bit(F_HAVEDIGITAL, &chip->flags);
1163#endif
1164        spin_lock_init(&chip->lock);
1165        ret = snd_msnd_probe(card);
1166        if (ret < 0) {
1167                printk(KERN_ERR LOGNAME ": Probe failed\n");
1168                goto _release_card;
1169        }
1170
1171        ret = snd_msnd_attach(card);
1172        if (ret < 0) {
1173                printk(KERN_ERR LOGNAME ": Attach failed\n");
1174                goto _release_card;
1175        }
1176
1177        pnp_set_card_drvdata(pcard, card);
1178        ++idx;
1179        return 0;
1180
1181_release_card:
1182        snd_card_free(card);
1183        return ret;
1184}
1185
1186static void snd_msnd_pnp_remove(struct pnp_card_link *pcard)
1187{
1188        snd_msnd_unload(pnp_get_card_drvdata(pcard));
1189        pnp_set_card_drvdata(pcard, NULL);
1190}
1191
1192static int isa_registered;
1193static int pnp_registered;
1194
1195static const struct pnp_card_device_id msnd_pnpids[] = {
1196        /* Pinnacle PnP */
1197        { .id = "BVJ0440", .devs = { { "TBS0000" }, { "TBS0001" } } },
1198        { .id = "" }    /* end */
1199};
1200
1201MODULE_DEVICE_TABLE(pnp_card, msnd_pnpids);
1202
1203static struct pnp_card_driver msnd_pnpc_driver = {
1204        .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1205        .name = "msnd_pinnacle",
1206        .id_table = msnd_pnpids,
1207        .probe = snd_msnd_pnp_detect,
1208        .remove = snd_msnd_pnp_remove,
1209};
1210#endif /* CONFIG_PNP */
1211
1212static int __init snd_msnd_init(void)
1213{
1214        int err;
1215
1216        err = isa_register_driver(&snd_msnd_driver, SNDRV_CARDS);
1217#ifdef CONFIG_PNP
1218        if (!err)
1219                isa_registered = 1;
1220
1221        err = pnp_register_card_driver(&msnd_pnpc_driver);
1222        if (!err)
1223                pnp_registered = 1;
1224
1225        if (isa_registered)
1226                err = 0;
1227#endif
1228        return err;
1229}
1230
1231static void __exit snd_msnd_exit(void)
1232{
1233#ifdef CONFIG_PNP
1234        if (pnp_registered)
1235                pnp_unregister_card_driver(&msnd_pnpc_driver);
1236        if (isa_registered)
1237#endif
1238                isa_unregister_driver(&snd_msnd_driver);
1239}
1240
1241module_init(snd_msnd_init);
1242module_exit(snd_msnd_exit);
1243
1244