sound/oss/msnd_pinnacle.c

   1 /*********************************************************************
   2  *
   3  * Turtle Beach MultiSound Sound Card Driver for Linux
   4  * Linux 2.0/2.2 Version
   5  *
   6  * msnd_pinnacle.c / msnd_classic.c
   7  *
   8  * -- If MSND_CLASSIC is defined:
   9  *
  10  *     -> driver for Turtle Beach Classic/Monterey/Tahiti
  11  *
  12  * -- Else
  13  *
  14  *     -> driver for Turtle Beach Pinnacle/Fiji
  15  *
  16  * Copyright (C) 1998 Andrew Veliath
  17  *
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 2 of the License, or
  21  * (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31  *
  32  * $Id: msnd_pinnacle.c,v 1.8 2000/12/30 00:33:21 sycamore Exp $
  33  *
  34  * 12-3-2000  Modified IO port validation  Steve Sycamore
  35  *
  36  *
  37  * $$$: msnd_pinnacle.c,v 1.75 1999/03/21 16:50:09 andrewtv $$$ $
  38  *
  39  ********************************************************************/
  40
  41 #include <linux/kernel.h>
  42 #include <linux/config.h>
  43 #include <linux/module.h>
  44 #include <linux/slab.h>
  45 #include <linux/types.h>
  46 #include <linux/delay.h>
  47 #include <linux/init.h>
  48 #include <linux/interrupt.h>
  49 #include <linux/smp_lock.h>
  50 #include <asm/irq.h>
  51 #include <asm/io.h>
  52 #include "sound_config.h"
  53 #include "sound_firmware.h"
  54 #ifdef MSND_CLASSIC
  55 # ifndef __alpha__
  56 #  define SLOWIO
  57 # endif
  58 #endif
  59 #include "msnd.h"
  60 #ifdef MSND_CLASSIC
  61 #  ifdef CONFIG_MSNDCLAS_HAVE_BOOT
  62 #    define HAVE_DSPCODEH
  63 #  endif
  64 #  include "msnd_classic.h"
  65 #  define LOGNAME                       "msnd_classic"
  66 #else
  67 #  ifdef CONFIG_MSNDPIN_HAVE_BOOT
  68 #    define HAVE_DSPCODEH
  69 #  endif
  70 #  include "msnd_pinnacle.h"
  71 #  define LOGNAME                       "msnd_pinnacle"
  72 #endif
  73
  74 #ifndef CONFIG_MSND_WRITE_NDELAY
  75 #  define CONFIG_MSND_WRITE_NDELAY      1
  76 #endif
  77
  78 #define get_play_delay_jiffies(size)    ((size) * HZ *                  \
  79                                          dev.play_sample_size / 8 /     \
  80                                          dev.play_sample_rate /         \
  81                                          dev.play_channels)
  82
  83 #define get_rec_delay_jiffies(size)     ((size) * HZ *                  \
  84                                          dev.rec_sample_size / 8 /      \
  85                                          dev.rec_sample_rate /          \
  86                                          dev.rec_channels)
  87
  88 static multisound_dev_t                 dev;
  89
  90 #ifndef HAVE_DSPCODEH
  91 static char                             *dspini, *permini;
  92 static int                              sizeof_dspini, sizeof_permini;
  93 #endif
  94
  95 static int                              dsp_full_reset(void);
  96 static void                             dsp_write_flush(void);
  97
  98 static __inline__ int chk_send_dsp_cmd(multisound_dev_t *dev, register BYTE cmd)
  99 {
 100         if (msnd_send_dsp_cmd(dev, cmd) == 0)
 101                 return 0;
 102         dsp_full_reset();
 103         return msnd_send_dsp_cmd(dev, cmd);
 104 }
 105
 106 static void reset_play_queue(void)
 107 {
 108         int n;
 109         LPDAQD lpDAQ;
 110
 111         dev.last_playbank = -1;
 112         isa_writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wHead);
 113         isa_writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wTail);
 114
 115         for (n = 0, lpDAQ = dev.base + DAPQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
 116                 isa_writew(PCTODSP_BASED((DWORD)(DAP_BUFF_SIZE * n)), lpDAQ + DAQDS_wStart);
 117                 isa_writew(0, lpDAQ + DAQDS_wSize);
 118                 isa_writew(1, lpDAQ + DAQDS_wFormat);
 119                 isa_writew(dev.play_sample_size, lpDAQ + DAQDS_wSampleSize);
 120                 isa_writew(dev.play_channels, lpDAQ + DAQDS_wChannels);
 121                 isa_writew(dev.play_sample_rate, lpDAQ + DAQDS_wSampleRate);
 122                 isa_writew(HIMT_PLAY_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
 123                 isa_writew(n, lpDAQ + DAQDS_wFlags);
 124         }
 125 }
 126
 127 static void reset_record_queue(void)
 128 {
 129         int n;
 130         LPDAQD lpDAQ;
 131         unsigned long flags;
 132
 133         dev.last_recbank = 2;
 134         isa_writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DARQ + JQS_wHead);
 135         isa_writew(PCTODSP_OFFSET(dev.last_recbank * DAQDS__size), dev.DARQ + JQS_wTail);
 136
 137         /* Critical section: bank 1 access */
 138         spin_lock_irqsave(&dev.lock, flags);
 139         outb(HPBLKSEL_1, dev.io + HP_BLKS);
 140         isa_memset_io(dev.base, 0, DAR_BUFF_SIZE * 3);
 141         outb(HPBLKSEL_0, dev.io + HP_BLKS);
 142         spin_unlock_irqrestore(&dev.lock, flags);
 143
 144         for (n = 0, lpDAQ = dev.base + DARQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
 145                 isa_writew(PCTODSP_BASED((DWORD)(DAR_BUFF_SIZE * n)) + 0x4000, lpDAQ + DAQDS_wStart);
 146                 isa_writew(DAR_BUFF_SIZE, lpDAQ + DAQDS_wSize);
 147                 isa_writew(1, lpDAQ + DAQDS_wFormat);
 148                 isa_writew(dev.rec_sample_size, lpDAQ + DAQDS_wSampleSize);
 149                 isa_writew(dev.rec_channels, lpDAQ + DAQDS_wChannels);
 150                 isa_writew(dev.rec_sample_rate, lpDAQ + DAQDS_wSampleRate);
 151                 isa_writew(HIMT_RECORD_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
 152                 isa_writew(n, lpDAQ + DAQDS_wFlags);
 153         }
 154 }
 155
 156 static void reset_queues(void)
 157 {
 158         if (dev.mode & FMODE_WRITE) {
 159                 msnd_fifo_make_empty(&dev.DAPF);
 160                 reset_play_queue();
 161         }
 162         if (dev.mode & FMODE_READ) {
 163                 msnd_fifo_make_empty(&dev.DARF);
 164                 reset_record_queue();
 165         }
 166 }
 167
 168 static int dsp_set_format(struct file *file, int val)
 169 {
 170         int data, i;
 171         LPDAQD lpDAQ, lpDARQ;
 172
 173         lpDAQ = dev.base + DAPQ_DATA_BUFF;
 174         lpDARQ = dev.base + DARQ_DATA_BUFF;
 175
 176         switch (val) {
 177         case AFMT_U8:
 178         case AFMT_S16_LE:
 179                 data = val;
 180                 break;
 181         default:
 182                 data = DEFSAMPLESIZE;
 183                 break;
 184         }
 185
 186         for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
 187                 if (file->f_mode & FMODE_WRITE)
 188                         isa_writew(data, lpDAQ + DAQDS_wSampleSize);
 189                 if (file->f_mode & FMODE_READ)
 190                         isa_writew(data, lpDARQ + DAQDS_wSampleSize);
 191         }
 192         if (file->f_mode & FMODE_WRITE)
 193                 dev.play_sample_size = data;
 194         if (file->f_mode & FMODE_READ)
 195                 dev.rec_sample_size = data;
 196
 197         return data;
 198 }
 199
 200 static int dsp_get_frag_size(void)
 201 {
 202         int size;
 203         size = dev.fifosize / 4;
 204         if (size > 32 * 1024)
 205                 size = 32 * 1024;
 206         return size;
 207 }
 208
 209 static int dsp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 210 {
 211         int val, i, data, tmp;
 212         LPDAQD lpDAQ, lpDARQ;
 213         audio_buf_info abinfo;
 214         unsigned long flags;
 215         int __user *p = (int __user *)arg;
 216
 217         lpDAQ = dev.base + DAPQ_DATA_BUFF;
 218         lpDARQ = dev.base + DARQ_DATA_BUFF;
 219
 220         switch (cmd) {
 221         case SNDCTL_DSP_SUBDIVIDE:
 222         case SNDCTL_DSP_SETFRAGMENT:
 223         case SNDCTL_DSP_SETDUPLEX:
 224         case SNDCTL_DSP_POST:
 225                 return 0;
 226
 227         case SNDCTL_DSP_GETIPTR:
 228         case SNDCTL_DSP_GETOPTR:
 229         case SNDCTL_DSP_MAPINBUF:
 230         case SNDCTL_DSP_MAPOUTBUF:
 231                 return -EINVAL;
 232
 233         case SNDCTL_DSP_GETOSPACE:
 234                 if (!(file->f_mode & FMODE_WRITE))
 235                         return -EINVAL;
 236                 spin_lock_irqsave(&dev.lock, flags);
 237                 abinfo.fragsize = dsp_get_frag_size();
 238                 abinfo.bytes = dev.DAPF.n - dev.DAPF.len;
 239                 abinfo.fragstotal = dev.DAPF.n / abinfo.fragsize;
 240                 abinfo.fragments = abinfo.bytes / abinfo.fragsize;
 241                 spin_unlock_irqrestore(&dev.lock, flags);
 242                 return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 243
 244         case SNDCTL_DSP_GETISPACE:
 245                 if (!(file->f_mode & FMODE_READ))
 246                         return -EINVAL;
 247                 spin_lock_irqsave(&dev.lock, flags);
 248                 abinfo.fragsize = dsp_get_frag_size();
 249                 abinfo.bytes = dev.DARF.n - dev.DARF.len;
 250                 abinfo.fragstotal = dev.DARF.n / abinfo.fragsize;
 251                 abinfo.fragments = abinfo.bytes / abinfo.fragsize;
 252                 spin_unlock_irqrestore(&dev.lock, flags);
 253                 return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 254
 255         case SNDCTL_DSP_RESET:
 256                 dev.nresets = 0;
 257                 reset_queues();
 258                 return 0;
 259
 260         case SNDCTL_DSP_SYNC:
 261                 dsp_write_flush();
 262                 return 0;
 263
 264         case SNDCTL_DSP_GETBLKSIZE:
 265                 tmp = dsp_get_frag_size();
 266                 if (put_user(tmp, p))
 267                         return -EFAULT;
 268                 return 0;
 269
 270         case SNDCTL_DSP_GETFMTS:
 271                 val = AFMT_S16_LE | AFMT_U8;
 272                 if (put_user(val, p))
 273                         return -EFAULT;
 274                 return 0;
 275
 276         case SNDCTL_DSP_SETFMT:
 277                 if (get_user(val, p))
 278                         return -EFAULT;
 279
 280                 if (file->f_mode & FMODE_WRITE)
 281                         data = val == AFMT_QUERY
 282                                 ? dev.play_sample_size
 283                                 : dsp_set_format(file, val);
 284                 else
 285                         data = val == AFMT_QUERY
 286                                 ? dev.rec_sample_size
 287                                 : dsp_set_format(file, val);
 288
 289                 if (put_user(data, p))
 290                         return -EFAULT;
 291                 return 0;
 292
 293         case SNDCTL_DSP_NONBLOCK:
 294                 if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags) &&
 295                     file->f_mode & FMODE_WRITE)
 296                         dev.play_ndelay = 1;
 297                 if (file->f_mode & FMODE_READ)
 298                         dev.rec_ndelay = 1;
 299                 return 0;
 300
 301         case SNDCTL_DSP_GETCAPS:
 302                 val = DSP_CAP_DUPLEX | DSP_CAP_BATCH;
 303                 if (put_user(val, p))
 304                         return -EFAULT;
 305                 return 0;
 306
 307         case SNDCTL_DSP_SPEED:
 308                 if (get_user(val, p))
 309                         return -EFAULT;
 310
 311                 if (val < 8000)
 312                         val = 8000;
 313
 314                 if (val > 48000)
 315                         val = 48000;
 316
 317                 data = val;
 318
 319                 for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
 320                         if (file->f_mode & FMODE_WRITE)
 321                                 isa_writew(data, lpDAQ + DAQDS_wSampleRate);
 322                         if (file->f_mode & FMODE_READ)
 323                                 isa_writew(data, lpDARQ + DAQDS_wSampleRate);
 324                 }
 325                 if (file->f_mode & FMODE_WRITE)
 326                         dev.play_sample_rate = data;
 327                 if (file->f_mode & FMODE_READ)
 328                         dev.rec_sample_rate = data;
 329
 330                 if (put_user(data, p))
 331                         return -EFAULT;
 332                 return 0;
 333
 334         case SNDCTL_DSP_CHANNELS:
 335         case SNDCTL_DSP_STEREO:
 336                 if (get_user(val, p))
 337                         return -EFAULT;
 338
 339                 if (cmd == SNDCTL_DSP_CHANNELS) {
 340                         switch (val) {
 341                         case 1:
 342                         case 2:
 343                                 data = val;
 344                                 break;
 345                         default:
 346                                 val = data = 2;
 347                                 break;
 348                         }
 349                 } else {
 350                         switch (val) {
 351                         case 0:
 352                                 data = 1;
 353                                 break;
 354                         default:
 355                                 val = 1;
 356                         case 1:
 357                                 data = 2;
 358                                 break;
 359                         }
 360                 }
 361
 362                 for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
 363                         if (file->f_mode & FMODE_WRITE)
 364                                 isa_writew(data, lpDAQ + DAQDS_wChannels);
 365                         if (file->f_mode & FMODE_READ)
 366                                 isa_writew(data, lpDARQ + DAQDS_wChannels);
 367                 }
 368                 if (file->f_mode & FMODE_WRITE)
 369                         dev.play_channels = data;
 370                 if (file->f_mode & FMODE_READ)
 371                         dev.rec_channels = data;
 372
 373                 if (put_user(val, p))
 374                         return -EFAULT;
 375                 return 0;
 376         }
 377
 378         return -EINVAL;
 379 }
 380
 381 static int mixer_get(int d)
 382 {
 383         if (d > 31)
 384                 return -EINVAL;
 385
 386         switch (d) {
 387         case SOUND_MIXER_VOLUME:
 388         case SOUND_MIXER_PCM:
 389         case SOUND_MIXER_LINE:
 390         case SOUND_MIXER_IMIX:
 391         case SOUND_MIXER_LINE1:
 392 #ifndef MSND_CLASSIC
 393         case SOUND_MIXER_MIC:
 394         case SOUND_MIXER_SYNTH:
 395 #endif
 396                 return (dev.left_levels[d] >> 8) * 100 / 0xff |
 397                         (((dev.right_levels[d] >> 8) * 100 / 0xff) << 8);
 398         default:
 399                 return 0;
 400         }
 401 }
 402
 403 #define update_volm(a,b)                                                \
 404         isa_writew((dev.left_levels[a] >> 1) *                          \
 405                isa_readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff,      \
 406                dev.SMA + SMA_##b##Left);                                \
 407         isa_writew((dev.right_levels[a] >> 1)  *                        \
 408                isa_readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff,     \
 409                dev.SMA + SMA_##b##Right);
 410
 411 #define update_potm(d,s,ar)                                             \
 412         isa_writeb((dev.left_levels[d] >> 8) *                          \
 413                isa_readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff,      \
 414                dev.SMA + SMA_##s##Left);                                \
 415         isa_writeb((dev.right_levels[d] >> 8) *                         \
 416                isa_readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff,     \
 417                dev.SMA + SMA_##s##Right);                               \
 418         if (msnd_send_word(&dev, 0, 0, ar) == 0)                        \
 419                 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
 420
 421 #define update_pot(d,s,ar)                              \
 422         isa_writeb(dev.left_levels[d] >> 8,             \
 423                dev.SMA + SMA_##s##Left);                \
 424         isa_writeb(dev.right_levels[d] >> 8,            \
 425                dev.SMA + SMA_##s##Right);               \
 426         if (msnd_send_word(&dev, 0, 0, ar) == 0)        \
 427                 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
 428
 429 static int mixer_set(int d, int value)
 430 {
 431         int left = value & 0x000000ff;
 432         int right = (value & 0x0000ff00) >> 8;
 433         int bLeft, bRight;
 434         int wLeft, wRight;
 435         int updatemaster = 0;
 436
 437         if (d > 31)
 438                 return -EINVAL;
 439
 440         bLeft = left * 0xff / 100;
 441         wLeft = left * 0xffff / 100;
 442
 443         bRight = right * 0xff / 100;
 444         wRight = right * 0xffff / 100;
 445
 446         dev.left_levels[d] = wLeft;
 447         dev.right_levels[d] = wRight;
 448
 449         switch (d) {
 450                 /* master volume unscaled controls */
 451         case SOUND_MIXER_LINE:                  /* line pot control */
 452                 /* scaled by IMIX in digital mix */
 453                 isa_writeb(bLeft, dev.SMA + SMA_bInPotPosLeft);
 454                 isa_writeb(bRight, dev.SMA + SMA_bInPotPosRight);
 455                 if (msnd_send_word(&dev, 0, 0, HDEXAR_IN_SET_POTS) == 0)
 456                         chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
 457                 break;
 458 #ifndef MSND_CLASSIC
 459         case SOUND_MIXER_MIC:                   /* mic pot control */
 460                 /* scaled by IMIX in digital mix */
 461                 isa_writeb(bLeft, dev.SMA + SMA_bMicPotPosLeft);
 462                 isa_writeb(bRight, dev.SMA + SMA_bMicPotPosRight);
 463                 if (msnd_send_word(&dev, 0, 0, HDEXAR_MIC_SET_POTS) == 0)
 464                         chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
 465                 break;
 466 #endif
 467         case SOUND_MIXER_VOLUME:                /* master volume */
 468                 isa_writew(wLeft, dev.SMA + SMA_wCurrMastVolLeft);
 469                 isa_writew(wRight, dev.SMA + SMA_wCurrMastVolRight);
 470                 /* fall through */
 471
 472         case SOUND_MIXER_LINE1:                 /* aux pot control */
 473                 /* scaled by master volume */
 474                 /* fall through */
 475
 476                 /* digital controls */
 477         case SOUND_MIXER_SYNTH:                 /* synth vol (dsp mix) */
 478         case SOUND_MIXER_PCM:                   /* pcm vol (dsp mix) */
 479         case SOUND_MIXER_IMIX:                  /* input monitor (dsp mix) */
 480                 /* scaled by master volume */
 481                 updatemaster = 1;
 482                 break;
 483
 484         default:
 485                 return 0;
 486         }
 487
 488         if (updatemaster) {
 489                 /* update master volume scaled controls */
 490                 update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
 491                 update_volm(SOUND_MIXER_IMIX, wCurrInVol);
 492 #ifndef MSND_CLASSIC
 493                 update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
 494 #endif
 495                 update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
 496         }
 497
 498         return mixer_get(d);
 499 }
 500
 501 static void mixer_setup(void)
 502 {
 503         update_pot(SOUND_MIXER_LINE, bInPotPos, HDEXAR_IN_SET_POTS);
 504         update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
 505         update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
 506         update_volm(SOUND_MIXER_IMIX, wCurrInVol);
 507 #ifndef MSND_CLASSIC
 508         update_pot(SOUND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
 509         update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
 510 #endif
 511 }
 512
 513 static unsigned long set_recsrc(unsigned long recsrc)
 514 {
 515         if (dev.recsrc == recsrc)
 516                 return dev.recsrc;
 517 #ifdef HAVE_NORECSRC
 518         else if (recsrc == 0)
 519                 dev.recsrc = 0;
 520 #endif
 521         else
 522                 dev.recsrc ^= recsrc;
 523
 524 #ifndef MSND_CLASSIC
 525         if (dev.recsrc & SOUND_MASK_IMIX) {
 526                 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
 527                         chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
 528         }
 529         else if (dev.recsrc & SOUND_MASK_SYNTH) {
 530                 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_SYNTH_IN) == 0)
 531                         chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
 532         }
 533         else if ((dev.recsrc & SOUND_MASK_DIGITAL1) && test_bit(F_HAVEDIGITAL, &dev.flags)) {
 534                 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_DAT_IN) == 0)
 535                         chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
 536         }
 537         else {
 538 #ifdef HAVE_NORECSRC
 539                 /* Select no input (?) */
 540                 dev.recsrc = 0;
 541 #else
 542                 dev.recsrc = SOUND_MASK_IMIX;
 543                 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
 544                         chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
 545 #endif
 546         }
 547 #endif /* MSND_CLASSIC */
 548
 549         return dev.recsrc;
 550 }
 551
 552 static unsigned long force_recsrc(unsigned long recsrc)
 553 {
 554         dev.recsrc = 0;
 555         return set_recsrc(recsrc);
 556 }
 557
 558 #define set_mixer_info()                                                        \
 559                 memset(&info, 0, sizeof(info));                                 \
 560                 strlcpy(info.id, "MSNDMIXER", sizeof(info.id));                 \
 561                 strlcpy(info.name, "MultiSound Mixer", sizeof(info.name));
 562
 563 static int mixer_ioctl(unsigned int cmd, unsigned long arg)
 564 {
 565         if (cmd == SOUND_MIXER_INFO) {
 566                 mixer_info info;
 567                 set_mixer_info();
 568                 info.modify_counter = dev.mixer_mod_count;
 569                 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
 570                         return -EFAULT;
 571                 return 0;
 572         } else if (cmd == SOUND_OLD_MIXER_INFO) {
 573                 _old_mixer_info info;
 574                 set_mixer_info();
 575                 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
 576                         return -EFAULT;
 577                 return 0;
 578         } else if (cmd == SOUND_MIXER_PRIVATE1) {
 579                 dev.nresets = 0;
 580                 dsp_full_reset();
 581                 return 0;
 582         } else if (((cmd >> 8) & 0xff) == 'M') {
 583                 int val = 0;
 584
 585                 if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
 586                         switch (cmd & 0xff) {
 587                         case SOUND_MIXER_RECSRC:
 588                                 if (get_user(val, (int __user *)arg))
 589                                         return -EFAULT;
 590                                 val = set_recsrc(val);
 591                                 break;
 592
 593                         default:
 594                                 if (get_user(val, (int __user *)arg))
 595                                         return -EFAULT;
 596                                 val = mixer_set(cmd & 0xff, val);
 597                                 break;
 598                         }
 599                         ++dev.mixer_mod_count;
 600                         return put_user(val, (int __user *)arg);
 601                 } else {
 602                         switch (cmd & 0xff) {
 603                         case SOUND_MIXER_RECSRC:
 604                                 val = dev.recsrc;
 605                                 break;
 606
 607                         case SOUND_MIXER_DEVMASK:
 608                         case SOUND_MIXER_STEREODEVS:
 609                                 val =   SOUND_MASK_PCM |
 610                                         SOUND_MASK_LINE |
 611                                         SOUND_MASK_IMIX |
 612                                         SOUND_MASK_LINE1 |
 613 #ifndef MSND_CLASSIC
 614                                         SOUND_MASK_MIC |
 615                                         SOUND_MASK_SYNTH |
 616 #endif
 617                                         SOUND_MASK_VOLUME;
 618                                 break;
 619
 620                         case SOUND_MIXER_RECMASK:
 621 #ifdef MSND_CLASSIC
 622                                 val =   0;
 623 #else
 624                                 val =   SOUND_MASK_IMIX |
 625                                         SOUND_MASK_SYNTH;
 626                                 if (test_bit(F_HAVEDIGITAL, &dev.flags))
 627                                         val |= SOUND_MASK_DIGITAL1;
 628 #endif
 629                                 break;
 630
 631                         case SOUND_MIXER_CAPS:
 632                                 val =   SOUND_CAP_EXCL_INPUT;
 633                                 break;
 634
 635                         default:
 636                                 if ((val = mixer_get(cmd & 0xff)) < 0)
 637                                         return -EINVAL;
 638                                 break;
 639                         }
 640                 }
 641
 642                 return put_user(val, (int __user *)arg);
 643         }
 644
 645         return -EINVAL;
 646 }
 647
 648 static int dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 649 {
 650         int minor = iminor(inode);
 651
 652         if (cmd == OSS_GETVERSION) {
 653                 int sound_version = SOUND_VERSION;
 654                 return put_user(sound_version, (int __user *)arg);
 655         }
 656
 657         if (minor == dev.dsp_minor)
 658                 return dsp_ioctl(file, cmd, arg);
 659         else if (minor == dev.mixer_minor)
 660                 return mixer_ioctl(cmd, arg);
 661
 662         return -EINVAL;
 663 }
 664
 665 static void dsp_write_flush(void)
 666 {
 667         if (!(dev.mode & FMODE_WRITE) || !test_bit(F_WRITING, &dev.flags))
 668                 return;
 669         set_bit(F_WRITEFLUSH, &dev.flags);
 670         interruptible_sleep_on_timeout(
 671                 &dev.writeflush,
 672                 get_play_delay_jiffies(dev.DAPF.len));
 673         clear_bit(F_WRITEFLUSH, &dev.flags);
 674         if (!signal_pending(current)) {
 675                 current->state = TASK_INTERRUPTIBLE;
 676                 schedule_timeout(get_play_delay_jiffies(DAP_BUFF_SIZE));
 677         }
 678         clear_bit(F_WRITING, &dev.flags);
 679 }
 680
 681 static void dsp_halt(struct file *file)
 682 {
 683         if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
 684                 clear_bit(F_READING, &dev.flags);
 685                 chk_send_dsp_cmd(&dev, HDEX_RECORD_STOP);
 686                 msnd_disable_irq(&dev);
 687                 if (file) {
 688                         printk(KERN_DEBUG LOGNAME ": Stopping read for %p\n", file);
 689                         dev.mode &= ~FMODE_READ;
 690                 }
 691                 clear_bit(F_AUDIO_READ_INUSE, &dev.flags);
 692         }
 693         if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
 694                 if (test_bit(F_WRITING, &dev.flags)) {
 695                         dsp_write_flush();
 696                         chk_send_dsp_cmd(&dev, HDEX_PLAY_STOP);
 697                 }
 698                 msnd_disable_irq(&dev);
 699                 if (file) {
 700                         printk(KERN_DEBUG LOGNAME ": Stopping write for %p\n", file);
 701                         dev.mode &= ~FMODE_WRITE;
 702                 }
 703                 clear_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
 704         }
 705 }
 706
 707 static int dsp_release(struct file *file)
 708 {
 709         dsp_halt(file);
 710         return 0;
 711 }
 712
 713 static int dsp_open(struct file *file)
 714 {
 715         if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
 716                 set_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
 717                 clear_bit(F_WRITING, &dev.flags);
 718                 msnd_fifo_make_empty(&dev.DAPF);
 719                 reset_play_queue();
 720                 if (file) {
 721                         printk(KERN_DEBUG LOGNAME ": Starting write for %p\n", file);
 722                         dev.mode |= FMODE_WRITE;
 723                 }
 724                 msnd_enable_irq(&dev);
 725         }
 726         if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
 727                 set_bit(F_AUDIO_READ_INUSE, &dev.flags);
 728                 clear_bit(F_READING, &dev.flags);
 729                 msnd_fifo_make_empty(&dev.DARF);
 730                 reset_record_queue();
 731                 if (file) {
 732                         printk(KERN_DEBUG LOGNAME ": Starting read for %p\n", file);
 733                         dev.mode |= FMODE_READ;
 734                 }
 735                 msnd_enable_irq(&dev);
 736         }
 737         return 0;
 738 }
 739
 740 static void set_default_play_audio_parameters(void)
 741 {
 742         dev.play_sample_size = DEFSAMPLESIZE;
 743         dev.play_sample_rate = DEFSAMPLERATE;
 744         dev.play_channels = DEFCHANNELS;
 745 }
 746
 747 static void set_default_rec_audio_parameters(void)
 748 {
 749         dev.rec_sample_size = DEFSAMPLESIZE;
 750         dev.rec_sample_rate = DEFSAMPLERATE;
 751         dev.rec_channels = DEFCHANNELS;
 752 }
 753
 754 static void set_default_audio_parameters(void)
 755 {
 756         set_default_play_audio_parameters();
 757         set_default_rec_audio_parameters();
 758 }
 759
 760 static int dev_open(struct inode *inode, struct file *file)
 761 {
 762         int minor = iminor(inode);
 763         int err = 0;
 764
 765         if (minor == dev.dsp_minor) {
 766                 if ((file->f_mode & FMODE_WRITE &&
 767                      test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
 768                     (file->f_mode & FMODE_READ &&
 769                      test_bit(F_AUDIO_READ_INUSE, &dev.flags)))
 770                         return -EBUSY;
 771
 772                 if ((err = dsp_open(file)) >= 0) {
 773                         dev.nresets = 0;
 774                         if (file->f_mode & FMODE_WRITE) {
 775                                 set_default_play_audio_parameters();
 776                                 if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags))
 777                                         dev.play_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
 778                                 else
 779                                         dev.play_ndelay = 0;
 780                         }
 781                         if (file->f_mode & FMODE_READ) {
 782                                 set_default_rec_audio_parameters();
 783                                 dev.rec_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
 784                         }
 785                 }
 786         }
 787         else if (minor == dev.mixer_minor) {
 788                 /* nothing */
 789         } else
 790                 err = -EINVAL;
 791
 792         return err;
 793 }
 794
 795 static int dev_release(struct inode *inode, struct file *file)
 796 {
 797         int minor = iminor(inode);
 798         int err = 0;
 799
 800         lock_kernel();
 801         if (minor == dev.dsp_minor)
 802                 err = dsp_release(file);
 803         else if (minor == dev.mixer_minor) {
 804                 /* nothing */
 805         } else
 806                 err = -EINVAL;
 807         unlock_kernel();
 808         return err;
 809 }
 810
 811 static __inline__ int pack_DARQ_to_DARF(register int bank)
 812 {
 813         register int size, timeout = 3;
 814         register WORD wTmp;
 815         LPDAQD DAQD;
 816
 817         /* Increment the tail and check for queue wrap */
 818         wTmp = isa_readw(dev.DARQ + JQS_wTail) + PCTODSP_OFFSET(DAQDS__size);
 819         if (wTmp > isa_readw(dev.DARQ + JQS_wSize))
 820                 wTmp = 0;
 821         while (wTmp == isa_readw(dev.DARQ + JQS_wHead) && timeout--)
 822                 udelay(1);
 823         isa_writew(wTmp, dev.DARQ + JQS_wTail);
 824
 825         /* Get our digital audio queue struct */
 826         DAQD = bank * DAQDS__size + dev.base + DARQ_DATA_BUFF;
 827
 828         /* Get length of data */
 829         size = isa_readw(DAQD + DAQDS_wSize);
 830
 831         /* Read data from the head (unprotected bank 1 access okay
 832            since this is only called inside an interrupt) */
 833         outb(HPBLKSEL_1, dev.io + HP_BLKS);
 834         msnd_fifo_write(
 835                 &dev.DARF,
 836                 (char *)(dev.base + bank * DAR_BUFF_SIZE),
 837                 size);
 838         outb(HPBLKSEL_0, dev.io + HP_BLKS);
 839
 840         return 1;
 841 }
 842
 843 static __inline__ int pack_DAPF_to_DAPQ(register int start)
 844 {
 845         register WORD DAPQ_tail;
 846         register int protect = start, nbanks = 0;
 847         LPDAQD DAQD;
 848
 849         DAPQ_tail = isa_readw(dev.DAPQ + JQS_wTail);
 850         while (DAPQ_tail != isa_readw(dev.DAPQ + JQS_wHead) || start) {
 851                 register int bank_num = DAPQ_tail / PCTODSP_OFFSET(DAQDS__size);
 852                 register int n;
 853                 unsigned long flags;
 854
 855                 /* Write the data to the new tail */
 856                 if (protect) {
 857                         /* Critical section: protect fifo in non-interrupt */
 858                         spin_lock_irqsave(&dev.lock, flags);
 859                         n = msnd_fifo_read(
 860                                 &dev.DAPF,
 861                                 (char *)(dev.base + bank_num * DAP_BUFF_SIZE),
 862                                 DAP_BUFF_SIZE);
 863                         spin_unlock_irqrestore(&dev.lock, flags);
 864                 } else {
 865                         n = msnd_fifo_read(
 866                                 &dev.DAPF,
 867                                 (char *)(dev.base + bank_num * DAP_BUFF_SIZE),
 868                                 DAP_BUFF_SIZE);
 869                 }
 870                 if (!n)
 871                         break;
 872
 873                 if (start)
 874                         start = 0;
 875
 876                 /* Get our digital audio queue struct */
 877                 DAQD = bank_num * DAQDS__size + dev.base + DAPQ_DATA_BUFF;
 878
 879                 /* Write size of this bank */
 880                 isa_writew(n, DAQD + DAQDS_wSize);
 881                 ++nbanks;
 882
 883                 /* Then advance the tail */
 884                 DAPQ_tail = (++bank_num % 3) * PCTODSP_OFFSET(DAQDS__size);
 885                 isa_writew(DAPQ_tail, dev.DAPQ + JQS_wTail);
 886                 /* Tell the DSP to play the bank */
 887                 msnd_send_dsp_cmd(&dev, HDEX_PLAY_START);
 888         }
 889         return nbanks;
 890 }
 891
 892 static int dsp_read(char __user *buf, size_t len)
 893 {
 894         int count = len;
 895         char *page = (char *)__get_free_page(PAGE_SIZE);
 896
 897         if (!page)
 898                 return -ENOMEM;
 899
 900         while (count > 0) {
 901                 int n, k;
 902                 unsigned long flags;
 903
 904                 k = PAGE_SIZE;
 905                 if (k > count)
 906                         k = count;
 907
 908                 /* Critical section: protect fifo in non-interrupt */
 909                 spin_lock_irqsave(&dev.lock, flags);
 910                 n = msnd_fifo_read(&dev.DARF, page, k);
 911                 spin_unlock_irqrestore(&dev.lock, flags);
 912                 if (copy_to_user(buf, page, n)) {
 913                         free_page((unsigned long)page);
 914                         return -EFAULT;
 915                 }
 916                 buf += n;
 917                 count -= n;
 918
 919                 if (n == k && count)
 920                         continue;
 921
 922                 if (!test_bit(F_READING, &dev.flags) && dev.mode & FMODE_READ) {
 923                         dev.last_recbank = -1;
 924                         if (chk_send_dsp_cmd(&dev, HDEX_RECORD_START) == 0)
 925                                 set_bit(F_READING, &dev.flags);
 926                 }
 927
 928                 if (dev.rec_ndelay) {
 929                         free_page((unsigned long)page);
 930                         return count == len ? -EAGAIN : len - count;
 931                 }
 932
 933                 if (count > 0) {
 934                         set_bit(F_READBLOCK, &dev.flags);
 935                         if (!interruptible_sleep_on_timeout(
 936                                 &dev.readblock,
 937                                 get_rec_delay_jiffies(DAR_BUFF_SIZE)))
 938                                 clear_bit(F_READING, &dev.flags);
 939                         clear_bit(F_READBLOCK, &dev.flags);
 940                         if (signal_pending(current)) {
 941                                 free_page((unsigned long)page);
 942                                 return -EINTR;
 943                         }
 944                 }
 945         }
 946         free_page((unsigned long)page);
 947         return len - count;
 948 }
 949
 950 static int dsp_write(const char __user *buf, size_t len)
 951 {
 952         int count = len;
 953         char *page = (char *)__get_free_page(GFP_KERNEL);
 954
 955         if (!page)
 956                 return -ENOMEM;
 957
 958         while (count > 0) {
 959                 int n, k;
 960                 unsigned long flags;
 961
 962                 k = PAGE_SIZE;
 963                 if (k > count)
 964                         k = count;
 965
 966                 if (copy_from_user(page, buf, k)) {
 967                         free_page((unsigned long)page);
 968                         return -EFAULT;
 969                 }
 970
 971                 /* Critical section: protect fifo in non-interrupt */
 972                 spin_lock_irqsave(&dev.lock, flags);
 973                 n = msnd_fifo_write(&dev.DAPF, page, k);
 974                 spin_unlock_irqrestore(&dev.lock, flags);
 975                 buf += n;
 976                 count -= n;
 977
 978                 if (count && n == k)
 979                         continue;
 980
 981                 if (!test_bit(F_WRITING, &dev.flags) && (dev.mode & FMODE_WRITE)) {
 982                         dev.last_playbank = -1;
 983                         if (pack_DAPF_to_DAPQ(1) > 0)
 984                                 set_bit(F_WRITING, &dev.flags);
 985                 }
 986
 987                 if (dev.play_ndelay) {
 988                         free_page((unsigned long)page);
 989                         return count == len ? -EAGAIN : len - count;
 990                 }
 991
 992                 if (count > 0) {
 993                         set_bit(F_WRITEBLOCK, &dev.flags);
 994                         interruptible_sleep_on_timeout(
 995                                 &dev.writeblock,
 996                                 get_play_delay_jiffies(DAP_BUFF_SIZE));
 997                         clear_bit(F_WRITEBLOCK, &dev.flags);
 998                         if (signal_pending(current)) {
 999                                 free_page((unsigned long)page);
1000                                 return -EINTR;
1001                         }
1002                 }
1003         }
1004
1005         free_page((unsigned long)page);
1006         return len - count;
1007 }
1008
1009 static ssize_t dev_read(struct file *file, char __user *buf, size_t count, loff_t *off)
1010 {
1011         int minor = iminor(file->f_dentry->d_inode);
1012         if (minor == dev.dsp_minor)
1013                 return dsp_read(buf, count);
1014         else
1015                 return -EINVAL;
1016 }
1017
1018 static ssize_t dev_write(struct file *file, const char __user *buf, size_t count, loff_t *off)
1019 {
1020         int minor = iminor(file->f_dentry->d_inode);
1021         if (minor == dev.dsp_minor)
1022                 return dsp_write(buf, count);
1023         else
1024                 return -EINVAL;
1025 }
1026
1027 static __inline__ void eval_dsp_msg(register WORD wMessage)
1028 {
1029         switch (HIBYTE(wMessage)) {
1030         case HIMT_PLAY_DONE:
1031                 if (dev.last_playbank == LOBYTE(wMessage) || !test_bit(F_WRITING, &dev.flags))
1032                         break;
1033                 dev.last_playbank = LOBYTE(wMessage);
1034
1035                 if (pack_DAPF_to_DAPQ(0) <= 0) {
1036                         if (!test_bit(F_WRITEBLOCK, &dev.flags)) {
1037                                 if (test_and_clear_bit(F_WRITEFLUSH, &dev.flags))
1038                                         wake_up_interruptible(&dev.writeflush);
1039                         }
1040                         clear_bit(F_WRITING, &dev.flags);
1041                 }
1042
1043                 if (test_bit(F_WRITEBLOCK, &dev.flags))
1044                         wake_up_interruptible(&dev.writeblock);
1045                 break;
1046
1047         case HIMT_RECORD_DONE:
1048                 if (dev.last_recbank == LOBYTE(wMessage))
1049                         break;
1050                 dev.last_recbank = LOBYTE(wMessage);
1051
1052                 pack_DARQ_to_DARF(dev.last_recbank);
1053
1054                 if (test_bit(F_READBLOCK, &dev.flags))
1055                         wake_up_interruptible(&dev.readblock);
1056                 break;
1057
1058         case HIMT_DSP:
1059                 switch (LOBYTE(wMessage)) {
1060 #ifndef MSND_CLASSIC
1061                 case HIDSP_PLAY_UNDER:
1062 #endif
1063                 case HIDSP_INT_PLAY_UNDER:
1064 /*                      printk(KERN_DEBUG LOGNAME ": Play underflow\n"); */
1065                         clear_bit(F_WRITING, &dev.flags);
1066                         break;
1067
1068                 case HIDSP_INT_RECORD_OVER:
1069 /*                      printk(KERN_DEBUG LOGNAME ": Record overflow\n"); */
1070                         clear_bit(F_READING, &dev.flags);
1071                         break;
1072
1073                 default:
1074 /*                      printk(KERN_DEBUG LOGNAME ": DSP message %d 0x%02x\n",
1075                         LOBYTE(wMessage), LOBYTE(wMessage)); */
1076                         break;
1077                 }
1078                 break;
1079
1080         case HIMT_MIDI_IN_UCHAR:
1081                 if (dev.midi_in_interrupt)
1082                         (*dev.midi_in_interrupt)(&dev);
1083                 break;
1084
1085         default:
1086 /*              printk(KERN_DEBUG LOGNAME ": HIMT message %d 0x%02x\n", HIBYTE(wMessage), HIBYTE(wMessage)); */
1087                 break;
1088         }
1089 }
1090
1091 static irqreturn_t intr(int irq, void *dev_id, struct pt_regs *regs)
1092 {
1093         /* Send ack to DSP */
1094         inb(dev.io + HP_RXL);
1095
1096         /* Evaluate queued DSP messages */
1097         while (isa_readw(dev.DSPQ + JQS_wTail) != isa_readw(dev.DSPQ + JQS_wHead)) {
1098                 register WORD wTmp;
1099
1100                 eval_dsp_msg(isa_readw(dev.pwDSPQData + 2*isa_readw(dev.DSPQ + JQS_wHead)));
1101
1102                 if ((wTmp = isa_readw(dev.DSPQ + JQS_wHead) + 1) > isa_readw(dev.DSPQ + JQS_wSize))
1103                         isa_writew(0, dev.DSPQ + JQS_wHead);
1104                 else
1105                         isa_writew(wTmp, dev.DSPQ + JQS_wHead);
1106         }
1107         return IRQ_HANDLED;
1108 }
1109
1110 static struct file_operations dev_fileops = {
1111         .owner          = THIS_MODULE,
1112         .read           = dev_read,
1113         .write          = dev_write,
1114         .ioctl          = dev_ioctl,
1115         .open           = dev_open,
1116         .release        = dev_release,
1117 };
1118
1119 static int reset_dsp(void)
1120 {
1121         int timeout = 100;
1122
1123         outb(HPDSPRESET_ON, dev.io + HP_DSPR);
1124         mdelay(1);
1125 #ifndef MSND_CLASSIC
1126         dev.info = inb(dev.io + HP_INFO);
1127 #endif
1128         outb(HPDSPRESET_OFF, dev.io + HP_DSPR);
1129         mdelay(1);
1130         while (timeout-- > 0) {
1131                 if (inb(dev.io + HP_CVR) == HP_CVR_DEF)
1132                         return 0;
1133                 mdelay(1);
1134         }
1135         printk(KERN_ERR LOGNAME ": Cannot reset DSP\n");
1136
1137         return -EIO;
1138 }
1139
1140 static int __init probe_multisound(void)
1141 {
1142 #ifndef MSND_CLASSIC
1143         char *xv, *rev = NULL;
1144         char *pin = "Pinnacle", *fiji = "Fiji";
1145         char *pinfiji = "Pinnacle/Fiji";
1146 #endif
1147
1148         if (check_region(dev.io, dev.numio)) {
1149                 printk(KERN_ERR LOGNAME ": I/O port conflict\n");
1150                 return -ENODEV;
1151         }
1152         request_region(dev.io, dev.numio, "probing");
1153
1154         if (reset_dsp() < 0) {
1155                 release_region(dev.io, dev.numio);
1156                 return -ENODEV;
1157         }
1158
1159 #ifdef MSND_CLASSIC
1160         dev.name = "Classic/Tahiti/Monterey";
1161         printk(KERN_INFO LOGNAME ": %s, "
1162 #else
1163         switch (dev.info >> 4) {
1164         case 0xf: xv = "<= 1.15"; break;
1165         case 0x1: xv = "1.18/1.2"; break;
1166         case 0x2: xv = "1.3"; break;
1167         case 0x3: xv = "1.4"; break;
1168         default: xv = "unknown"; break;
1169         }
1170
1171         switch (dev.info & 0x7) {
1172         case 0x0: rev = "I"; dev.name = pin; break;
1173         case 0x1: rev = "F"; dev.name = pin; break;
1174         case 0x2: rev = "G"; dev.name = pin; break;
1175         case 0x3: rev = "H"; dev.name = pin; break;
1176         case 0x4: rev = "E"; dev.name = fiji; break;
1177         case 0x5: rev = "C"; dev.name = fiji; break;
1178         case 0x6: rev = "D"; dev.name = fiji; break;
1179         case 0x7:
1180                 rev = "A-B (Fiji) or A-E (Pinnacle)";
1181                 dev.name = pinfiji;
1182                 break;
1183         }
1184         printk(KERN_INFO LOGNAME ": %s revision %s, Xilinx version %s, "
1185 #endif /* MSND_CLASSIC */
1186                "I/O 0x%x-0x%x, IRQ %d, memory mapped to 0x%lX-0x%lX\n",
1187                dev.name,
1188 #ifndef MSND_CLASSIC
1189                rev, xv,
1190 #endif
1191                dev.io, dev.io + dev.numio - 1,
1192                dev.irq,
1193                dev.base, dev.base + 0x7fff);
1194
1195         release_region(dev.io, dev.numio);
1196         return 0;
1197 }
1198
1199 static int init_sma(void)
1200 {
1201         static int initted;
1202         WORD mastVolLeft, mastVolRight;
1203         unsigned long flags;
1204
1205 #ifdef MSND_CLASSIC
1206         outb(dev.memid, dev.io + HP_MEMM);
1207 #endif
1208         outb(HPBLKSEL_0, dev.io + HP_BLKS);
1209         if (initted) {
1210                 mastVolLeft = isa_readw(dev.SMA + SMA_wCurrMastVolLeft);
1211                 mastVolRight = isa_readw(dev.SMA + SMA_wCurrMastVolRight);
1212         } else
1213                 mastVolLeft = mastVolRight = 0;
1214         isa_memset_io(dev.base, 0, 0x8000);
1215
1216         /* Critical section: bank 1 access */
1217         spin_lock_irqsave(&dev.lock, flags);
1218         outb(HPBLKSEL_1, dev.io + HP_BLKS);
1219         isa_memset_io(dev.base, 0, 0x8000);
1220         outb(HPBLKSEL_0, dev.io + HP_BLKS);
1221         spin_unlock_irqrestore(&dev.lock, flags);
1222
1223         dev.pwDSPQData = (dev.base + DSPQ_DATA_BUFF);
1224         dev.pwMODQData = (dev.base + MODQ_DATA_BUFF);
1225         dev.pwMIDQData = (dev.base + MIDQ_DATA_BUFF);
1226
1227         /* Motorola 56k shared memory base */
1228         dev.SMA = dev.base + SMA_STRUCT_START;
1229
1230         /* Digital audio play queue */
1231         dev.DAPQ = dev.base + DAPQ_OFFSET;
1232         msnd_init_queue(dev.DAPQ, DAPQ_DATA_BUFF, DAPQ_BUFF_SIZE);
1233
1234         /* Digital audio record queue */
1235         dev.DARQ = dev.base + DARQ_OFFSET;
1236         msnd_init_queue(dev.DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE);
1237
1238         /* MIDI out queue */
1239         dev.MODQ = dev.base + MODQ_OFFSET;
1240         msnd_init_queue(dev.MODQ, MODQ_DATA_BUFF, MODQ_BUFF_SIZE);
1241
1242         /* MIDI in queue */
1243         dev.MIDQ = dev.base + MIDQ_OFFSET;
1244         msnd_init_queue(dev.MIDQ, MIDQ_DATA_BUFF, MIDQ_BUFF_SIZE);
1245
1246         /* DSP -> host message queue */
1247         dev.DSPQ = dev.base + DSPQ_OFFSET;
1248         msnd_init_queue(dev.DSPQ, DSPQ_DATA_BUFF, DSPQ_BUFF_SIZE);
1249
1250         /* Setup some DSP values */
1251 #ifndef MSND_CLASSIC
1252         isa_writew(1, dev.SMA + SMA_wCurrPlayFormat);
1253         isa_writew(dev.play_sample_size, dev.SMA + SMA_wCurrPlaySampleSize);
1254         isa_writew(dev.play_channels, dev.SMA + SMA_wCurrPlayChannels);
1255         isa_writew(dev.play_sample_rate, dev.SMA + SMA_wCurrPlaySampleRate);
1256 #endif
1257         isa_writew(dev.play_sample_rate, dev.SMA + SMA_wCalFreqAtoD);
1258         isa_writew(mastVolLeft, dev.SMA + SMA_wCurrMastVolLeft);
1259         isa_writew(mastVolRight, dev.SMA + SMA_wCurrMastVolRight);
1260 #ifndef MSND_CLASSIC
1261         isa_writel(0x00010000, dev.SMA + SMA_dwCurrPlayPitch);
1262         isa_writel(0x00000001, dev.SMA + SMA_dwCurrPlayRate);
1263 #endif
1264         isa_writew(0x303, dev.SMA + SMA_wCurrInputTagBits);
1265
1266         initted = 1;
1267
1268         return 0;
1269 }
1270
1271 static int __init calibrate_adc(WORD srate)
1272 {
1273         isa_writew(srate, dev.SMA + SMA_wCalFreqAtoD);
1274         if (dev.calibrate_signal == 0)
1275                 isa_writew(isa_readw(dev.SMA + SMA_wCurrHostStatusFlags)
1276                        | 0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
1277         else
1278                 isa_writew(isa_readw(dev.SMA + SMA_wCurrHostStatusFlags)
1279                        & ~0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
1280         if (msnd_send_word(&dev, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
1281             chk_send_dsp_cmd(&dev, HDEX_AUX_REQ) == 0) {
1282                 current->state = TASK_INTERRUPTIBLE;
1283                 schedule_timeout(HZ / 3);
1284                 return 0;
1285         }
1286         printk(KERN_WARNING LOGNAME ": ADC calibration failed\n");
1287
1288         return -EIO;
1289 }
1290
1291 static int upload_dsp_code(void)
1292 {
1293         outb(HPBLKSEL_0, dev.io + HP_BLKS);
1294 #ifndef HAVE_DSPCODEH
1295         INITCODESIZE = mod_firmware_load(INITCODEFILE, &INITCODE);
1296         if (!INITCODE) {
1297                 printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
1298                 return -EBUSY;
1299         }
1300
1301         PERMCODESIZE = mod_firmware_load(PERMCODEFILE, &PERMCODE);
1302         if (!PERMCODE) {
1303                 printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
1304                 vfree(INITCODE);
1305                 return -EBUSY;
1306         }
1307 #endif
1308         isa_memcpy_toio(dev.base, PERMCODE, PERMCODESIZE);
1309         if (msnd_upload_host(&dev, INITCODE, INITCODESIZE) < 0) {
1310                 printk(KERN_WARNING LOGNAME ": Error uploading to DSP\n");
1311                 return -ENODEV;
1312         }
1313 #ifdef HAVE_DSPCODEH
1314         printk(KERN_INFO LOGNAME ": DSP firmware uploaded (resident)\n");
1315 #else
1316         printk(KERN_INFO LOGNAME ": DSP firmware uploaded\n");
1317 #endif
1318
1319 #ifndef HAVE_DSPCODEH
1320         vfree(INITCODE);
1321         vfree(PERMCODE);
1322 #endif
1323
1324         return 0;
1325 }
1326
1327 #ifdef MSND_CLASSIC
1328 static void reset_proteus(void)
1329 {
1330         outb(HPPRORESET_ON, dev.io + HP_PROR);
1331         mdelay(TIME_PRO_RESET);
1332         outb(HPPRORESET_OFF, dev.io + HP_PROR);
1333         mdelay(TIME_PRO_RESET_DONE);
1334 }
1335 #endif
1336
1337 static int initialize(void)
1338 {
1339         int err, timeout;
1340
1341 #ifdef MSND_CLASSIC
1342         outb(HPWAITSTATE_0, dev.io + HP_WAIT);
1343         outb(HPBITMODE_16, dev.io + HP_BITM);
1344
1345         reset_proteus();
1346 #endif
1347         if ((err = init_sma()) < 0) {
1348                 printk(KERN_WARNING LOGNAME ": Cannot initialize SMA\n");
1349                 return err;
1350         }
1351
1352         if ((err = reset_dsp()) < 0)
1353                 return err;
1354
1355         if ((err = upload_dsp_code()) < 0) {
1356                 printk(KERN_WARNING LOGNAME ": Cannot upload DSP code\n");
1357                 return err;
1358         }
1359
1360         timeout = 200;
1361         while (isa_readw(dev.base)) {
1362                 mdelay(1);
1363                 if (!timeout--) {
1364                         printk(KERN_DEBUG LOGNAME ": DSP reset timeout\n");
1365                         return -EIO;
1366                 }
1367         }
1368
1369         mixer_setup();
1370
1371         return 0;
1372 }
1373
1374 static int dsp_full_reset(void)
1375 {
1376         int rv;
1377
1378         if (test_bit(F_RESETTING, &dev.flags) || ++dev.nresets > 10)
1379                 return 0;
1380
1381         set_bit(F_RESETTING, &dev.flags);
1382         printk(KERN_INFO LOGNAME ": DSP reset\n");
1383         dsp_halt(NULL);                 /* Unconditionally halt */
1384         if ((rv = initialize()))
1385                 printk(KERN_WARNING LOGNAME ": DSP reset failed\n");
1386         force_recsrc(dev.recsrc);
1387         dsp_open(NULL);
1388         clear_bit(F_RESETTING, &dev.flags);
1389
1390         return rv;
1391 }
1392
1393 static int __init attach_multisound(void)
1394 {
1395         int err;
1396
1397         if ((err = request_irq(dev.irq, intr, 0, dev.name, &dev)) < 0) {
1398                 printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
1399                 return err;
1400         }
1401         request_region(dev.io, dev.numio, dev.name);
1402
1403         if ((err = dsp_full_reset()) < 0) {
1404                 release_region(dev.io, dev.numio);
1405                 free_irq(dev.irq, &dev);
1406                 return err;
1407         }
1408
1409         if ((err = msnd_register(&dev)) < 0) {
1410                 printk(KERN_ERR LOGNAME ": Unable to register MultiSound\n");
1411                 release_region(dev.io, dev.numio);
1412                 free_irq(dev.irq, &dev);
1413                 return err;
1414         }
1415
1416         if ((dev.dsp_minor = register_sound_dsp(&dev_fileops, -1)) < 0) {
1417                 printk(KERN_ERR LOGNAME ": Unable to register DSP operations\n");
1418                 msnd_unregister(&dev);
1419                 release_region(dev.io, dev.numio);
1420                 free_irq(dev.irq, &dev);
1421                 return dev.dsp_minor;
1422         }
1423
1424         if ((dev.mixer_minor = register_sound_mixer(&dev_fileops, -1)) < 0) {
1425                 printk(KERN_ERR LOGNAME ": Unable to register mixer operations\n");
1426                 unregister_sound_mixer(dev.mixer_minor);
1427                 msnd_unregister(&dev);
1428                 release_region(dev.io, dev.numio);
1429                 free_irq(dev.irq, &dev);
1430                 return dev.mixer_minor;
1431         }
1432
1433         dev.ext_midi_dev = dev.hdr_midi_dev = -1;
1434
1435         disable_irq(dev.irq);
1436         calibrate_adc(dev.play_sample_rate);
1437 #ifndef MSND_CLASSIC
1438         force_recsrc(SOUND_MASK_IMIX);
1439 #endif
1440
1441         return 0;
1442 }
1443
1444 static void __exit unload_multisound(void)
1445 {
1446         release_region(dev.io, dev.numio);
1447         free_irq(dev.irq, &dev);
1448         unregister_sound_mixer(dev.mixer_minor);
1449         unregister_sound_dsp(dev.dsp_minor);
1450         msnd_unregister(&dev);
1451 }
1452
1453 #ifndef MSND_CLASSIC
1454
1455 /* Pinnacle/Fiji Logical Device Configuration */
1456
1457 static int __init msnd_write_cfg(int cfg, int reg, int value)
1458 {
1459         outb(reg, cfg);
1460         outb(value, cfg + 1);
1461         if (value != inb(cfg + 1)) {
1462                 printk(KERN_ERR LOGNAME ": msnd_write_cfg: I/O error\n");
1463                 return -EIO;
1464         }
1465         return 0;
1466 }
1467
1468 static int __init msnd_write_cfg_io0(int cfg, int num, WORD io)
1469 {
1470         if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1471                 return -EIO;
1472         if (msnd_write_cfg(cfg, IREG_IO0_BASEHI, HIBYTE(io)))
1473                 return -EIO;
1474         if (msnd_write_cfg(cfg, IREG_IO0_BASELO, LOBYTE(io)))
1475                 return -EIO;
1476         return 0;
1477 }
1478
1479 static int __init msnd_write_cfg_io1(int cfg, int num, WORD io)
1480 {
1481         if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1482                 return -EIO;
1483         if (msnd_write_cfg(cfg, IREG_IO1_BASEHI, HIBYTE(io)))
1484                 return -EIO;
1485         if (msnd_write_cfg(cfg, IREG_IO1_BASELO, LOBYTE(io)))
1486                 return -EIO;
1487         return 0;
1488 }
1489
1490 static int __init msnd_write_cfg_irq(int cfg, int num, WORD irq)
1491 {
1492         if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1493                 return -EIO;
1494         if (msnd_write_cfg(cfg, IREG_IRQ_NUMBER, LOBYTE(irq)))
1495                 return -EIO;
1496         if (msnd_write_cfg(cfg, IREG_IRQ_TYPE, IRQTYPE_EDGE))
1497                 return -EIO;
1498         return 0;
1499 }
1500
1501 static int __init msnd_write_cfg_mem(int cfg, int num, int mem)
1502 {
1503         WORD wmem;
1504
1505         mem >>= 8;
1506         mem &= 0xfff;
1507         wmem = (WORD)mem;
1508         if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1509                 return -EIO;
1510         if (msnd_write_cfg(cfg, IREG_MEMBASEHI, HIBYTE(wmem)))
1511                 return -EIO;
1512         if (msnd_write_cfg(cfg, IREG_MEMBASELO, LOBYTE(wmem)))
1513                 return -EIO;
1514         if (wmem && msnd_write_cfg(cfg, IREG_MEMCONTROL, (MEMTYPE_HIADDR | MEMTYPE_16BIT)))
1515                 return -EIO;
1516         return 0;
1517 }
1518
1519 static int __init msnd_activate_logical(int cfg, int num)
1520 {
1521         if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1522                 return -EIO;
1523         if (msnd_write_cfg(cfg, IREG_ACTIVATE, LD_ACTIVATE))
1524                 return -EIO;
1525         return 0;
1526 }
1527
1528 static int __init msnd_write_cfg_logical(int cfg, int num, WORD io0, WORD io1, WORD irq, int mem)
1529 {
1530         if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1531                 return -EIO;
1532         if (msnd_write_cfg_io0(cfg, num, io0))
1533                 return -EIO;
1534         if (msnd_write_cfg_io1(cfg, num, io1))
1535                 return -EIO;
1536         if (msnd_write_cfg_irq(cfg, num, irq))
1537                 return -EIO;
1538         if (msnd_write_cfg_mem(cfg, num, mem))
1539                 return -EIO;
1540         if (msnd_activate_logical(cfg, num))
1541                 return -EIO;
1542         return 0;
1543 }
1544
1545 typedef struct msnd_pinnacle_cfg_device {
1546         WORD io0, io1, irq;
1547         int mem;
1548 } msnd_pinnacle_cfg_t[4];
1549
1550 static int __init msnd_pinnacle_cfg_devices(int cfg, int reset, msnd_pinnacle_cfg_t device)
1551 {
1552         int i;
1553
1554         /* Reset devices if told to */
1555         if (reset) {
1556                 printk(KERN_INFO LOGNAME ": Resetting all devices\n");
1557                 for (i = 0; i < 4; ++i)
1558                         if (msnd_write_cfg_logical(cfg, i, 0, 0, 0, 0))
1559                                 return -EIO;
1560         }
1561
1562         /* Configure specified devices */
1563         for (i = 0; i < 4; ++i) {
1564
1565                 switch (i) {
1566                 case 0:         /* DSP */
1567                         if (!(device[i].io0 && device[i].irq && device[i].mem))
1568                                 continue;
1569                         break;
1570                 case 1:         /* MPU */
1571                         if (!(device[i].io0 && device[i].irq))
1572                                 continue;
1573                         printk(KERN_INFO LOGNAME
1574                                ": Configuring MPU to I/O 0x%x IRQ %d\n",
1575                                device[i].io0, device[i].irq);
1576                         break;
1577                 case 2:         /* IDE */
1578                         if (!(device[i].io0 && device[i].io1 && device[i].irq))
1579                                 continue;
1580                         printk(KERN_INFO LOGNAME
1581                                ": Configuring IDE to I/O 0x%x, 0x%x IRQ %d\n",
1582                                device[i].io0, device[i].io1, device[i].irq);
1583                         break;
1584                 case 3:         /* Joystick */
1585                         if (!(device[i].io0))
1586                                 continue;
1587                         printk(KERN_INFO LOGNAME
1588                                ": Configuring joystick to I/O 0x%x\n",
1589                                device[i].io0);
1590                         break;
1591                 }
1592
1593                 /* Configure the device */
1594                 if (msnd_write_cfg_logical(cfg, i, device[i].io0, device[i].io1, device[i].irq, device[i].mem))
1595                         return -EIO;
1596         }
1597
1598         return 0;
1599 }
1600 #endif
1601
1602 #ifdef MODULE
1603 MODULE_AUTHOR                           ("Andrew Veliath <andrewtv@usa.net>");
1604 MODULE_DESCRIPTION                      ("Turtle Beach " LONGNAME " Linux Driver");
1605 MODULE_LICENSE("GPL");
1606
1607 MODULE_PARM                             (io, "i");
1608 MODULE_PARM                             (irq, "i");
1609 MODULE_PARM                             (mem, "i");
1610 MODULE_PARM                             (write_ndelay, "i");
1611 MODULE_PARM                             (fifosize, "i");
1612 MODULE_PARM                             (calibrate_signal, "i");
1613 #ifndef MSND_CLASSIC
1614 MODULE_PARM                             (digital, "i");
1615 MODULE_PARM                             (cfg, "i");
1616 MODULE_PARM                             (reset, "i");
1617 MODULE_PARM                             (mpu_io, "i");
1618 MODULE_PARM                             (mpu_irq, "i");
1619 MODULE_PARM                             (ide_io0, "i");
1620 MODULE_PARM                             (ide_io1, "i");
1621 MODULE_PARM                             (ide_irq, "i");
1622 MODULE_PARM                             (joystick_io, "i");
1623 #endif
1624
1625 static int io __initdata =              -1;
1626 static int irq __initdata =             -1;
1627 static int mem __initdata =             -1;
1628 static int write_ndelay __initdata =    -1;
1629
1630 #ifndef MSND_CLASSIC
1631 /* Pinnacle/Fiji non-PnP Config Port */
1632 static int cfg __initdata =             -1;
1633
1634 /* Extra Peripheral Configuration */
1635 static int reset __initdata = 0;
1636 static int mpu_io __initdata = 0;
1637 static int mpu_irq __initdata = 0;
1638 static int ide_io0 __initdata = 0;
1639 static int ide_io1 __initdata = 0;
1640 static int ide_irq __initdata = 0;
1641 static int joystick_io __initdata = 0;
1642
1643 /* If we have the digital daugherboard... */
1644 static int digital __initdata = 0;
1645 #endif
1646
1647 static int fifosize __initdata =        DEFFIFOSIZE;
1648 static int calibrate_signal __initdata = 0;
1649
1650 #else /* not a module */
1651
1652 static int write_ndelay __initdata =    -1;
1653
1654 #ifdef MSND_CLASSIC
1655 static int io __initdata =              CONFIG_MSNDCLAS_IO;
1656 static int irq __initdata =             CONFIG_MSNDCLAS_IRQ;
1657 static int mem __initdata =             CONFIG_MSNDCLAS_MEM;
1658 #else /* Pinnacle/Fiji */
1659
1660 static int io __initdata =              CONFIG_MSNDPIN_IO;
1661 static int irq __initdata =             CONFIG_MSNDPIN_IRQ;
1662 static int mem __initdata =             CONFIG_MSNDPIN_MEM;
1663
1664 /* Pinnacle/Fiji non-PnP Config Port */
1665 #ifdef CONFIG_MSNDPIN_NONPNP
1666 #  ifndef CONFIG_MSNDPIN_CFG
1667 #    define CONFIG_MSNDPIN_CFG          0x250
1668 #  endif
1669 #else
1670 #  ifdef CONFIG_MSNDPIN_CFG
1671 #    undef CONFIG_MSNDPIN_CFG
1672 #  endif
1673 #  define CONFIG_MSNDPIN_CFG            -1
1674 #endif
1675 static int cfg __initdata =             CONFIG_MSNDPIN_CFG;
1676 /* If not a module, we don't need to bother with reset=1 */
1677 static int reset;
1678
1679 /* Extra Peripheral Configuration (Default: Disable) */
1680 #ifndef CONFIG_MSNDPIN_MPU_IO
1681 #  define CONFIG_MSNDPIN_MPU_IO         0
1682 #endif
1683 static int mpu_io __initdata =          CONFIG_MSNDPIN_MPU_IO;
1684
1685 #ifndef CONFIG_MSNDPIN_MPU_IRQ
1686 #  define CONFIG_MSNDPIN_MPU_IRQ        0
1687 #endif
1688 static int mpu_irq __initdata =         CONFIG_MSNDPIN_MPU_IRQ;
1689
1690 #ifndef CONFIG_MSNDPIN_IDE_IO0
1691 #  define CONFIG_MSNDPIN_IDE_IO0        0
1692 #endif
1693 static int ide_io0 __initdata =         CONFIG_MSNDPIN_IDE_IO0;
1694
1695 #ifndef CONFIG_MSNDPIN_IDE_IO1
1696 #  define CONFIG_MSNDPIN_IDE_IO1        0
1697 #endif
1698 static int ide_io1 __initdata =         CONFIG_MSNDPIN_IDE_IO1;
1699
1700 #ifndef CONFIG_MSNDPIN_IDE_IRQ
1701 #  define CONFIG_MSNDPIN_IDE_IRQ        0
1702 #endif
1703 static int ide_irq __initdata =         CONFIG_MSNDPIN_IDE_IRQ;
1704
1705 #ifndef CONFIG_MSNDPIN_JOYSTICK_IO
1706 #  define CONFIG_MSNDPIN_JOYSTICK_IO    0
1707 #endif
1708 static int joystick_io __initdata =     CONFIG_MSNDPIN_JOYSTICK_IO;
1709
1710 /* Have SPDIF (Digital) Daughterboard */
1711 #ifndef CONFIG_MSNDPIN_DIGITAL
1712 #  define CONFIG_MSNDPIN_DIGITAL        0
1713 #endif
1714 static int digital __initdata =         CONFIG_MSNDPIN_DIGITAL;
1715
1716 #endif /* MSND_CLASSIC */
1717
1718 #ifndef CONFIG_MSND_FIFOSIZE
1719 #  define CONFIG_MSND_FIFOSIZE          DEFFIFOSIZE
1720 #endif
1721 static int fifosize __initdata =        CONFIG_MSND_FIFOSIZE;
1722
1723 #ifndef CONFIG_MSND_CALSIGNAL
1724 #  define CONFIG_MSND_CALSIGNAL         0
1725 #endif
1726 static int
1727 calibrate_signal __initdata =           CONFIG_MSND_CALSIGNAL;
1728 #endif /* MODULE */
1729
1730
1731 static int __init msnd_init(void)
1732 {
1733         int err;
1734 #ifndef MSND_CLASSIC
1735         static msnd_pinnacle_cfg_t pinnacle_devs;
1736 #endif /* MSND_CLASSIC */
1737
1738         printk(KERN_INFO LOGNAME ": Turtle Beach " LONGNAME " Linux Driver Version "
1739                VERSION ", Copyright (C) 1998 Andrew Veliath\n");
1740
1741         if (io == -1 || irq == -1 || mem == -1)
1742                 printk(KERN_WARNING LOGNAME ": io, irq and mem must be set\n");
1743
1744 #ifdef MSND_CLASSIC
1745         if (io == -1 ||
1746             !(io == 0x290 ||
1747               io == 0x260 ||
1748               io == 0x250 ||
1749               io == 0x240 ||
1750               io == 0x230 ||
1751               io == 0x220 ||
1752               io == 0x210 ||
1753               io == 0x3e0)) {
1754                 printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must be set to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, or 0x3E0\n");
1755                 return -EINVAL;
1756         }
1757 #else
1758         if (io == -1 ||
1759                 io < 0x100 ||
1760                 io > 0x3e0 ||
1761                 (io % 0x10) != 0) {
1762                         printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must within the range 0x100 to 0x3E0 and must be evenly divisible by 0x10\n");
1763                         return -EINVAL;
1764         }
1765 #endif /* MSND_CLASSIC */
1766
1767         if (irq == -1 ||
1768             !(irq == 5 ||
1769               irq == 7 ||
1770               irq == 9 ||
1771               irq == 10 ||
1772               irq == 11 ||
1773               irq == 12)) {
1774                 printk(KERN_ERR LOGNAME ": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
1775                 return -EINVAL;
1776         }
1777
1778         if (mem == -1 ||
1779             !(mem == 0xb0000 ||
1780               mem == 0xc8000 ||
1781               mem == 0xd0000 ||
1782               mem == 0xd8000 ||
1783               mem == 0xe0000 ||
1784               mem == 0xe8000)) {
1785                 printk(KERN_ERR LOGNAME ": \"mem\" - must be set to "
1786                        "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or 0xe8000\n");
1787                 return -EINVAL;
1788         }
1789
1790 #ifdef MSND_CLASSIC
1791         switch (irq) {
1792         case 5: dev.irqid = HPIRQ_5; break;
1793         case 7: dev.irqid = HPIRQ_7; break;
1794         case 9: dev.irqid = HPIRQ_9; break;
1795         case 10: dev.irqid = HPIRQ_10; break;
1796         case 11: dev.irqid = HPIRQ_11; break;
1797         case 12: dev.irqid = HPIRQ_12; break;
1798         }
1799
1800         switch (mem) {
1801         case 0xb0000: dev.memid = HPMEM_B000; break;
1802         case 0xc8000: dev.memid = HPMEM_C800; break;
1803         case 0xd0000: dev.memid = HPMEM_D000; break;
1804         case 0xd8000: dev.memid = HPMEM_D800; break;
1805         case 0xe0000: dev.memid = HPMEM_E000; break;
1806         case 0xe8000: dev.memid = HPMEM_E800; break;
1807         }
1808 #else
1809         if (cfg == -1) {
1810                 printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
1811         } else if (cfg != 0x250 && cfg != 0x260 && cfg != 0x270) {
1812                 printk(KERN_INFO LOGNAME ": Config port must be 0x250, 0x260 or 0x270 (or unspecified for PnP mode)\n");
1813                 return -EINVAL;
1814         } else {
1815                 printk(KERN_INFO LOGNAME ": Non-PnP mode: configuring at port 0x%x\n", cfg);
1816
1817                 /* DSP */
1818                 pinnacle_devs[0].io0 = io;
1819                 pinnacle_devs[0].irq = irq;
1820                 pinnacle_devs[0].mem = mem;
1821
1822                 /* The following are Pinnacle specific */
1823
1824                 /* MPU */
1825                 pinnacle_devs[1].io0 = mpu_io;
1826                 pinnacle_devs[1].irq = mpu_irq;
1827
1828                 /* IDE */
1829                 pinnacle_devs[2].io0 = ide_io0;
1830                 pinnacle_devs[2].io1 = ide_io1;
1831                 pinnacle_devs[2].irq = ide_irq;
1832
1833                 /* Joystick */
1834                 pinnacle_devs[3].io0 = joystick_io;
1835
1836                 if (check_region(cfg, 2)) {
1837                         printk(KERN_ERR LOGNAME ": Config port 0x%x conflict\n", cfg);
1838                         return -EIO;
1839                 }
1840
1841                 request_region(cfg, 2, "Pinnacle/Fiji Config");
1842                 if (msnd_pinnacle_cfg_devices(cfg, reset, pinnacle_devs)) {
1843                         printk(KERN_ERR LOGNAME ": Device configuration error\n");
1844                         release_region(cfg, 2);
1845                         return -EIO;
1846                 }
1847                 release_region(cfg, 2);
1848         }
1849 #endif /* MSND_CLASSIC */
1850
1851         if (fifosize < 16)
1852                 fifosize = 16;
1853
1854         if (fifosize > 1024)
1855                 fifosize = 1024;
1856
1857         set_default_audio_parameters();
1858 #ifdef MSND_CLASSIC
1859         dev.type = msndClassic;
1860 #else
1861         dev.type = msndPinnacle;
1862 #endif
1863         dev.io = io;
1864         dev.numio = DSP_NUMIO;
1865         dev.irq = irq;
1866         dev.base = mem;
1867         dev.fifosize = fifosize * 1024;
1868         dev.calibrate_signal = calibrate_signal ? 1 : 0;
1869         dev.recsrc = 0;
1870         dev.dspq_data_buff = DSPQ_DATA_BUFF;
1871         dev.dspq_buff_size = DSPQ_BUFF_SIZE;
1872         if (write_ndelay == -1)
1873                 write_ndelay = CONFIG_MSND_WRITE_NDELAY;
1874         if (write_ndelay)
1875                 clear_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
1876         else
1877                 set_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
1878 #ifndef MSND_CLASSIC
1879         if (digital)
1880                 set_bit(F_HAVEDIGITAL, &dev.flags);
1881 #endif
1882         init_waitqueue_head(&dev.writeblock);
1883         init_waitqueue_head(&dev.readblock);
1884         init_waitqueue_head(&dev.writeflush);
1885         msnd_fifo_init(&dev.DAPF);
1886         msnd_fifo_init(&dev.DARF);
1887         spin_lock_init(&dev.lock);
1888         printk(KERN_INFO LOGNAME ": %u byte audio FIFOs (x2)\n", dev.fifosize);
1889         if ((err = msnd_fifo_alloc(&dev.DAPF, dev.fifosize)) < 0) {
1890                 printk(KERN_ERR LOGNAME ": Couldn't allocate write FIFO\n");
1891                 return err;
1892         }
1893
1894         if ((err = msnd_fifo_alloc(&dev.DARF, dev.fifosize)) < 0) {
1895                 printk(KERN_ERR LOGNAME ": Couldn't allocate read FIFO\n");
1896                 msnd_fifo_free(&dev.DAPF);
1897                 return err;
1898         }
1899
1900         if ((err = probe_multisound()) < 0) {
1901                 printk(KERN_ERR LOGNAME ": Probe failed\n");
1902                 msnd_fifo_free(&dev.DAPF);
1903                 msnd_fifo_free(&dev.DARF);
1904                 return err;
1905         }
1906
1907         if ((err = attach_multisound()) < 0) {
1908                 printk(KERN_ERR LOGNAME ": Attach failed\n");
1909                 msnd_fifo_free(&dev.DAPF);
1910                 msnd_fifo_free(&dev.DARF);
1911                 return err;
1912         }
1913
1914         return 0;
1915 }
1916
1917 static void __exit msdn_cleanup(void)
1918 {
1919         unload_multisound();
1920         msnd_fifo_free(&dev.DAPF);
1921         msnd_fifo_free(&dev.DARF);
1922 }
1923
1924 module_init(msnd_init);
1925 module_exit(msdn_cleanup);