Logo Search packages:      
Sourcecode: linux version File versions  Download package

msnd_pinnacle.c

/*********************************************************************
 *
 * Turtle Beach MultiSound Sound Card Driver for Linux
 * Linux 2.0/2.2 Version
 *
 * msnd_pinnacle.c / msnd_classic.c
 *
 * -- If MSND_CLASSIC is defined:
 *
 *     -> driver for Turtle Beach Classic/Monterey/Tahiti
 *
 * -- Else
 *
 *     -> driver for Turtle Beach Pinnacle/Fiji
 *
 * Copyright (C) 1998 Andrew Veliath
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * $Id: msnd_pinnacle.c,v 1.8 2000/12/30 00:33:21 sycamore Exp $
 *
 * 12-3-2000  Modified IO port validation  Steve Sycamore
 *
 *
 * $$$: msnd_pinnacle.c,v 1.75 1999/03/21 16:50:09 andrewtv $$$ $
 *
 ********************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/smp_lock.h>
#include <asm/irq.h>
#include <asm/io.h>
#include "sound_config.h"
#include "sound_firmware.h"
#ifdef MSND_CLASSIC
# ifndef __alpha__
#  define SLOWIO
# endif
#endif
#include "msnd.h"
#ifdef MSND_CLASSIC
#  ifdef CONFIG_MSNDCLAS_HAVE_BOOT
#    define HAVE_DSPCODEH
#  endif
#  include "msnd_classic.h"
#  define LOGNAME             "msnd_classic"
#else
#  ifdef CONFIG_MSNDPIN_HAVE_BOOT
#    define HAVE_DSPCODEH
#  endif
#  include "msnd_pinnacle.h"
#  define LOGNAME             "msnd_pinnacle"
#endif

#ifndef CONFIG_MSND_WRITE_NDELAY
#  define CONFIG_MSND_WRITE_NDELAY  1
#endif

#define get_play_delay_jiffies(size)      ((size) * HZ *                \
                               dev.play_sample_size / 8 /   \
                               dev.play_sample_rate /       \
                               dev.play_channels)

#define get_rec_delay_jiffies(size) ((size) * HZ *                \
                               dev.rec_sample_size / 8 /    \
                               dev.rec_sample_rate /        \
                               dev.rec_channels)

static multisound_dev_t             dev;

#ifndef HAVE_DSPCODEH
static char                   *dspini, *permini;
static int                    sizeof_dspini, sizeof_permini;
#endif

static int                    dsp_full_reset(void);
static void                   dsp_write_flush(void);

static __inline__ int chk_send_dsp_cmd(multisound_dev_t *dev, register BYTE cmd)
{
      if (msnd_send_dsp_cmd(dev, cmd) == 0)
            return 0;
      dsp_full_reset();
      return msnd_send_dsp_cmd(dev, cmd);
}

static void reset_play_queue(void)
{
      int n;
      LPDAQD lpDAQ;

      dev.last_playbank = -1;
      writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wHead);
      writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wTail);

      for (n = 0, lpDAQ = dev.base + DAPQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
            writew(PCTODSP_BASED((DWORD)(DAP_BUFF_SIZE * n)), lpDAQ + DAQDS_wStart);
            writew(0, lpDAQ + DAQDS_wSize);
            writew(1, lpDAQ + DAQDS_wFormat);
            writew(dev.play_sample_size, lpDAQ + DAQDS_wSampleSize);
            writew(dev.play_channels, lpDAQ + DAQDS_wChannels);
            writew(dev.play_sample_rate, lpDAQ + DAQDS_wSampleRate);
            writew(HIMT_PLAY_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
            writew(n, lpDAQ + DAQDS_wFlags);
      }
}

static void reset_record_queue(void)
{
      int n;
      LPDAQD lpDAQ;
      unsigned long flags;

      dev.last_recbank = 2;
      writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DARQ + JQS_wHead);
      writew(PCTODSP_OFFSET(dev.last_recbank * DAQDS__size), dev.DARQ + JQS_wTail);

      /* Critical section: bank 1 access */
      spin_lock_irqsave(&dev.lock, flags);
      msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
      memset_io(dev.base, 0, DAR_BUFF_SIZE * 3);
      msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
      spin_unlock_irqrestore(&dev.lock, flags);

      for (n = 0, lpDAQ = dev.base + DARQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
            writew(PCTODSP_BASED((DWORD)(DAR_BUFF_SIZE * n)) + 0x4000, lpDAQ + DAQDS_wStart);
            writew(DAR_BUFF_SIZE, lpDAQ + DAQDS_wSize);
            writew(1, lpDAQ + DAQDS_wFormat);
            writew(dev.rec_sample_size, lpDAQ + DAQDS_wSampleSize);
            writew(dev.rec_channels, lpDAQ + DAQDS_wChannels);
            writew(dev.rec_sample_rate, lpDAQ + DAQDS_wSampleRate);
            writew(HIMT_RECORD_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
            writew(n, lpDAQ + DAQDS_wFlags);
      }
}

static void reset_queues(void)
{
      if (dev.mode & FMODE_WRITE) {
            msnd_fifo_make_empty(&dev.DAPF);
            reset_play_queue();
      }
      if (dev.mode & FMODE_READ) {
            msnd_fifo_make_empty(&dev.DARF);
            reset_record_queue();
      }
}

static int dsp_set_format(struct file *file, int val)
{
      int data, i;
      LPDAQD lpDAQ, lpDARQ;

      lpDAQ = dev.base + DAPQ_DATA_BUFF;
      lpDARQ = dev.base + DARQ_DATA_BUFF;

      switch (val) {
      case AFMT_U8:
      case AFMT_S16_LE:
            data = val;
            break;
      default:
            data = DEFSAMPLESIZE;
            break;
      }

      for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
            if (file->f_mode & FMODE_WRITE)
                  writew(data, lpDAQ + DAQDS_wSampleSize);
            if (file->f_mode & FMODE_READ)
                  writew(data, lpDARQ + DAQDS_wSampleSize);
      }
      if (file->f_mode & FMODE_WRITE)
            dev.play_sample_size = data;
      if (file->f_mode & FMODE_READ)
            dev.rec_sample_size = data;

      return data;
}

static int dsp_get_frag_size(void)
{
      int size;
      size = dev.fifosize / 4;
      if (size > 32 * 1024)
            size = 32 * 1024;
      return size;
}

static int dsp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
      int val, i, data, tmp;
      LPDAQD lpDAQ, lpDARQ;
        audio_buf_info abinfo;
      unsigned long flags;
      int __user *p = (int __user *)arg;

      lpDAQ = dev.base + DAPQ_DATA_BUFF;
      lpDARQ = dev.base + DARQ_DATA_BUFF;

      switch (cmd) {
      case SNDCTL_DSP_SUBDIVIDE:
      case SNDCTL_DSP_SETFRAGMENT:
      case SNDCTL_DSP_SETDUPLEX:
      case SNDCTL_DSP_POST:
            return 0;

      case SNDCTL_DSP_GETIPTR:
      case SNDCTL_DSP_GETOPTR:
      case SNDCTL_DSP_MAPINBUF:
      case SNDCTL_DSP_MAPOUTBUF:
            return -EINVAL;

      case SNDCTL_DSP_GETOSPACE:
            if (!(file->f_mode & FMODE_WRITE))
                  return -EINVAL;
            spin_lock_irqsave(&dev.lock, flags);
            abinfo.fragsize = dsp_get_frag_size();
                abinfo.bytes = dev.DAPF.n - dev.DAPF.len;
                abinfo.fragstotal = dev.DAPF.n / abinfo.fragsize;
                abinfo.fragments = abinfo.bytes / abinfo.fragsize;
            spin_unlock_irqrestore(&dev.lock, flags);
            return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;

      case SNDCTL_DSP_GETISPACE:
            if (!(file->f_mode & FMODE_READ))
                  return -EINVAL;
            spin_lock_irqsave(&dev.lock, flags);
            abinfo.fragsize = dsp_get_frag_size();
                abinfo.bytes = dev.DARF.n - dev.DARF.len;
                abinfo.fragstotal = dev.DARF.n / abinfo.fragsize;
                abinfo.fragments = abinfo.bytes / abinfo.fragsize;
            spin_unlock_irqrestore(&dev.lock, flags);
            return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;

      case SNDCTL_DSP_RESET:
            dev.nresets = 0;
            reset_queues();
            return 0;

      case SNDCTL_DSP_SYNC:
            dsp_write_flush();
            return 0;

      case SNDCTL_DSP_GETBLKSIZE:
            tmp = dsp_get_frag_size();
            if (put_user(tmp, p))
                        return -EFAULT;
            return 0;

      case SNDCTL_DSP_GETFMTS:
            val = AFMT_S16_LE | AFMT_U8;
            if (put_user(val, p))
                  return -EFAULT;
            return 0;

      case SNDCTL_DSP_SETFMT:
            if (get_user(val, p))
                  return -EFAULT;

            if (file->f_mode & FMODE_WRITE)
                  data = val == AFMT_QUERY
                        ? dev.play_sample_size
                        : dsp_set_format(file, val);
            else
                  data = val == AFMT_QUERY
                        ? dev.rec_sample_size
                        : dsp_set_format(file, val);

            if (put_user(data, p))
                  return -EFAULT;
            return 0;

      case SNDCTL_DSP_NONBLOCK:
            if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags) &&
                file->f_mode & FMODE_WRITE)
                  dev.play_ndelay = 1;
            if (file->f_mode & FMODE_READ)
                  dev.rec_ndelay = 1;
            return 0;

      case SNDCTL_DSP_GETCAPS:
            val = DSP_CAP_DUPLEX | DSP_CAP_BATCH;
            if (put_user(val, p))
                  return -EFAULT;
            return 0;

      case SNDCTL_DSP_SPEED:
            if (get_user(val, p))
                  return -EFAULT;

            if (val < 8000)
                  val = 8000;

            if (val > 48000)
                  val = 48000;

            data = val;

            for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
                  if (file->f_mode & FMODE_WRITE)
                        writew(data, lpDAQ + DAQDS_wSampleRate);
                  if (file->f_mode & FMODE_READ)
                        writew(data, lpDARQ + DAQDS_wSampleRate);
            }
            if (file->f_mode & FMODE_WRITE)
                  dev.play_sample_rate = data;
            if (file->f_mode & FMODE_READ)
                  dev.rec_sample_rate = data;

            if (put_user(data, p))
                  return -EFAULT;
            return 0;

      case SNDCTL_DSP_CHANNELS:
      case SNDCTL_DSP_STEREO:
            if (get_user(val, p))
                  return -EFAULT;

            if (cmd == SNDCTL_DSP_CHANNELS) {
                  switch (val) {
                  case 1:
                  case 2:
                        data = val;
                        break;
                  default:
                        val = data = 2;
                        break;
                  }
            } else {
                  switch (val) {
                  case 0:
                        data = 1;
                        break;
                  default:
                        val = 1;
                  case 1:
                        data = 2;
                        break;
                  }
            }

            for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
                  if (file->f_mode & FMODE_WRITE)
                        writew(data, lpDAQ + DAQDS_wChannels);
                  if (file->f_mode & FMODE_READ)
                        writew(data, lpDARQ + DAQDS_wChannels);
            }
            if (file->f_mode & FMODE_WRITE)
                  dev.play_channels = data;
            if (file->f_mode & FMODE_READ)
                  dev.rec_channels = data;

            if (put_user(val, p))
                  return -EFAULT;
            return 0;
      }

      return -EINVAL;
}

static int mixer_get(int d)
{
      if (d > 31)
            return -EINVAL;

      switch (d) {
      case SOUND_MIXER_VOLUME:
      case SOUND_MIXER_PCM:
      case SOUND_MIXER_LINE:
      case SOUND_MIXER_IMIX:
      case SOUND_MIXER_LINE1:
#ifndef MSND_CLASSIC
      case SOUND_MIXER_MIC:
      case SOUND_MIXER_SYNTH:
#endif
            return (dev.left_levels[d] >> 8) * 100 / 0xff | 
                  (((dev.right_levels[d] >> 8) * 100 / 0xff) << 8);
      default:
            return 0;
      }
}

#define update_volm(a,b)                                    \
      writew((dev.left_levels[a] >> 1) *                    \
             readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff,      \
             dev.SMA + SMA_##b##Left);                      \
      writew((dev.right_levels[a] >> 1)  *                  \
             readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff,     \
             dev.SMA + SMA_##b##Right);

#define update_potm(d,s,ar)                                 \
      writeb((dev.left_levels[d] >> 8) *                    \
             readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff,      \
             dev.SMA + SMA_##s##Left);                      \
      writeb((dev.right_levels[d] >> 8) *                   \
             readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff,     \
             dev.SMA + SMA_##s##Right);                     \
      if (msnd_send_word(&dev, 0, 0, ar) == 0)              \
            chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);

#define update_pot(d,s,ar)                      \
      writeb(dev.left_levels[d] >> 8,           \
             dev.SMA + SMA_##s##Left);          \
      writeb(dev.right_levels[d] >> 8,          \
             dev.SMA + SMA_##s##Right);         \
      if (msnd_send_word(&dev, 0, 0, ar) == 0)  \
            chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);

static int mixer_set(int d, int value)
{
      int left = value & 0x000000ff;
      int right = (value & 0x0000ff00) >> 8;
      int bLeft, bRight;
      int wLeft, wRight;
      int updatemaster = 0;

      if (d > 31)
            return -EINVAL;

      bLeft = left * 0xff / 100;
      wLeft = left * 0xffff / 100;

      bRight = right * 0xff / 100;
      wRight = right * 0xffff / 100;

      dev.left_levels[d] = wLeft;
      dev.right_levels[d] = wRight;

      switch (d) {
            /* master volume unscaled controls */
      case SOUND_MIXER_LINE:              /* line pot control */
            /* scaled by IMIX in digital mix */
            writeb(bLeft, dev.SMA + SMA_bInPotPosLeft);
            writeb(bRight, dev.SMA + SMA_bInPotPosRight);
            if (msnd_send_word(&dev, 0, 0, HDEXAR_IN_SET_POTS) == 0)
                  chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
            break;
#ifndef MSND_CLASSIC
      case SOUND_MIXER_MIC:               /* mic pot control */
            /* scaled by IMIX in digital mix */
            writeb(bLeft, dev.SMA + SMA_bMicPotPosLeft);
            writeb(bRight, dev.SMA + SMA_bMicPotPosRight);
            if (msnd_send_word(&dev, 0, 0, HDEXAR_MIC_SET_POTS) == 0)
                  chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
            break;
#endif
      case SOUND_MIXER_VOLUME:            /* master volume */
            writew(wLeft, dev.SMA + SMA_wCurrMastVolLeft);
            writew(wRight, dev.SMA + SMA_wCurrMastVolRight);
            /* fall through */

      case SOUND_MIXER_LINE1:             /* aux pot control */
            /* scaled by master volume */
            /* fall through */

            /* digital controls */
      case SOUND_MIXER_SYNTH:             /* synth vol (dsp mix) */
      case SOUND_MIXER_PCM:               /* pcm vol (dsp mix) */
      case SOUND_MIXER_IMIX:              /* input monitor (dsp mix) */
            /* scaled by master volume */
            updatemaster = 1;
            break;

      default:
            return 0;
      }

      if (updatemaster) {
            /* update master volume scaled controls */
            update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
            update_volm(SOUND_MIXER_IMIX, wCurrInVol);
#ifndef MSND_CLASSIC
            update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
#endif
            update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
      }

      return mixer_get(d);
}

static void mixer_setup(void)
{
      update_pot(SOUND_MIXER_LINE, bInPotPos, HDEXAR_IN_SET_POTS);
      update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
      update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
      update_volm(SOUND_MIXER_IMIX, wCurrInVol);
#ifndef MSND_CLASSIC
      update_pot(SOUND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
      update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
#endif
}

static unsigned long set_recsrc(unsigned long recsrc)
{
      if (dev.recsrc == recsrc)
            return dev.recsrc;
#ifdef HAVE_NORECSRC
      else if (recsrc == 0)
            dev.recsrc = 0;
#endif
      else
            dev.recsrc ^= recsrc;

#ifndef MSND_CLASSIC
      if (dev.recsrc & SOUND_MASK_IMIX) {
            if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
                  chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
      }
      else if (dev.recsrc & SOUND_MASK_SYNTH) {
            if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_SYNTH_IN) == 0)
                  chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
      }
      else if ((dev.recsrc & SOUND_MASK_DIGITAL1) && test_bit(F_HAVEDIGITAL, &dev.flags)) {
            if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_DAT_IN) == 0)
                        chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
      }
      else {
#ifdef HAVE_NORECSRC
            /* Select no input (?) */
            dev.recsrc = 0;
#else
            dev.recsrc = SOUND_MASK_IMIX;
            if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
                  chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
#endif
      }
#endif /* MSND_CLASSIC */

      return dev.recsrc;
}

static unsigned long force_recsrc(unsigned long recsrc)
{
      dev.recsrc = 0;
      return set_recsrc(recsrc);
}

#define set_mixer_info()                                          \
            memset(&info, 0, sizeof(info));                             \
            strlcpy(info.id, "MSNDMIXER", sizeof(info.id));             \
            strlcpy(info.name, "MultiSound Mixer", sizeof(info.name));

static int mixer_ioctl(unsigned int cmd, unsigned long arg)
{
      if (cmd == SOUND_MIXER_INFO) {
            mixer_info info;
            set_mixer_info();
            info.modify_counter = dev.mixer_mod_count;
            if (copy_to_user((void __user *)arg, &info, sizeof(info)))
                  return -EFAULT;
            return 0;
      } else if (cmd == SOUND_OLD_MIXER_INFO) {
            _old_mixer_info info;
            set_mixer_info();
            if (copy_to_user((void __user *)arg, &info, sizeof(info)))
                  return -EFAULT;
            return 0;
      } else if (cmd == SOUND_MIXER_PRIVATE1) {
            dev.nresets = 0;
            dsp_full_reset();
            return 0;
      } else if (((cmd >> 8) & 0xff) == 'M') {
            int val = 0;

            if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
                  switch (cmd & 0xff) {
                  case SOUND_MIXER_RECSRC:
                        if (get_user(val, (int __user *)arg))
                              return -EFAULT;
                        val = set_recsrc(val);
                        break;

                  default:
                        if (get_user(val, (int __user *)arg))
                              return -EFAULT;
                        val = mixer_set(cmd & 0xff, val);
                        break;
                  }
                  ++dev.mixer_mod_count;
                  return put_user(val, (int __user *)arg);
            } else {
                  switch (cmd & 0xff) {
                  case SOUND_MIXER_RECSRC:
                        val = dev.recsrc;
                        break;

                  case SOUND_MIXER_DEVMASK:
                  case SOUND_MIXER_STEREODEVS:
                        val =   SOUND_MASK_PCM |
                              SOUND_MASK_LINE |
                              SOUND_MASK_IMIX |
                              SOUND_MASK_LINE1 |
#ifndef MSND_CLASSIC
                              SOUND_MASK_MIC |
                              SOUND_MASK_SYNTH |
#endif
                              SOUND_MASK_VOLUME;
                        break;
                          
                  case SOUND_MIXER_RECMASK:
#ifdef MSND_CLASSIC
                        val =   0;
#else
                        val =   SOUND_MASK_IMIX |
                              SOUND_MASK_SYNTH;
                        if (test_bit(F_HAVEDIGITAL, &dev.flags))
                              val |= SOUND_MASK_DIGITAL1;
#endif
                        break;
                          
                  case SOUND_MIXER_CAPS:
                        val =   SOUND_CAP_EXCL_INPUT;
                        break;

                  default:
                        if ((val = mixer_get(cmd & 0xff)) < 0)
                              return -EINVAL;
                        break;
                  }
            }

            return put_user(val, (int __user *)arg); 
      }

      return -EINVAL;
}

static int dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
      int minor = iminor(inode);

      if (cmd == OSS_GETVERSION) {
            int sound_version = SOUND_VERSION;
            return put_user(sound_version, (int __user *)arg);
      }

      if (minor == dev.dsp_minor)
            return dsp_ioctl(file, cmd, arg);
      else if (minor == dev.mixer_minor)
            return mixer_ioctl(cmd, arg);

      return -EINVAL;
}

static void dsp_write_flush(void)
{
      if (!(dev.mode & FMODE_WRITE) || !test_bit(F_WRITING, &dev.flags))
            return;
      set_bit(F_WRITEFLUSH, &dev.flags);
      interruptible_sleep_on_timeout(
            &dev.writeflush,
            get_play_delay_jiffies(dev.DAPF.len));
      clear_bit(F_WRITEFLUSH, &dev.flags);
      if (!signal_pending(current)) {
            current->state = TASK_INTERRUPTIBLE;
            schedule_timeout(get_play_delay_jiffies(DAP_BUFF_SIZE));
      }
      clear_bit(F_WRITING, &dev.flags);
}

static void dsp_halt(struct file *file)
{
      if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
            clear_bit(F_READING, &dev.flags);
            chk_send_dsp_cmd(&dev, HDEX_RECORD_STOP);
            msnd_disable_irq(&dev);
            if (file) {
                  printk(KERN_DEBUG LOGNAME ": Stopping read for %p\n", file);
                  dev.mode &= ~FMODE_READ;
            }
            clear_bit(F_AUDIO_READ_INUSE, &dev.flags);
      }
      if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
            if (test_bit(F_WRITING, &dev.flags)) {
                  dsp_write_flush();
                  chk_send_dsp_cmd(&dev, HDEX_PLAY_STOP);
            }
            msnd_disable_irq(&dev);
            if (file) {
                  printk(KERN_DEBUG LOGNAME ": Stopping write for %p\n", file);
                  dev.mode &= ~FMODE_WRITE;
            }
            clear_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
      }
}

static int dsp_release(struct file *file)
{
      dsp_halt(file);
      return 0;
}

static int dsp_open(struct file *file)
{
      if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
            set_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
            clear_bit(F_WRITING, &dev.flags);
            msnd_fifo_make_empty(&dev.DAPF);
            reset_play_queue();
            if (file) {
                  printk(KERN_DEBUG LOGNAME ": Starting write for %p\n", file);
                  dev.mode |= FMODE_WRITE;
            }
            msnd_enable_irq(&dev);
      }
      if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
            set_bit(F_AUDIO_READ_INUSE, &dev.flags);
            clear_bit(F_READING, &dev.flags);
            msnd_fifo_make_empty(&dev.DARF);
            reset_record_queue();
            if (file) {
                  printk(KERN_DEBUG LOGNAME ": Starting read for %p\n", file);
                  dev.mode |= FMODE_READ;
            }
            msnd_enable_irq(&dev);
      }
      return 0;
}

static void set_default_play_audio_parameters(void)
{
      dev.play_sample_size = DEFSAMPLESIZE;
      dev.play_sample_rate = DEFSAMPLERATE;
      dev.play_channels = DEFCHANNELS;
}

static void set_default_rec_audio_parameters(void)
{
      dev.rec_sample_size = DEFSAMPLESIZE;
      dev.rec_sample_rate = DEFSAMPLERATE;
      dev.rec_channels = DEFCHANNELS;
}

static void set_default_audio_parameters(void)
{
      set_default_play_audio_parameters();
      set_default_rec_audio_parameters();
}

static int dev_open(struct inode *inode, struct file *file)
{
      int minor = iminor(inode);
      int err = 0;

      if (minor == dev.dsp_minor) {
            if ((file->f_mode & FMODE_WRITE &&
                 test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
                (file->f_mode & FMODE_READ &&
                 test_bit(F_AUDIO_READ_INUSE, &dev.flags)))
                  return -EBUSY;

            if ((err = dsp_open(file)) >= 0) {
                  dev.nresets = 0;
                  if (file->f_mode & FMODE_WRITE) {
                        set_default_play_audio_parameters();
                        if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags))
                              dev.play_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
                        else
                              dev.play_ndelay = 0;
                  }
                  if (file->f_mode & FMODE_READ) {
                        set_default_rec_audio_parameters();
                        dev.rec_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
                  }
            }
      }
      else if (minor == dev.mixer_minor) {
            /* nothing */
      } else
            err = -EINVAL;

      return err;
}

static int dev_release(struct inode *inode, struct file *file)
{
      int minor = iminor(inode);
      int err = 0;

      lock_kernel();
      if (minor == dev.dsp_minor)
            err = dsp_release(file);
      else if (minor == dev.mixer_minor) {
            /* nothing */
      } else
            err = -EINVAL;
      unlock_kernel();
      return err;
}

static __inline__ int pack_DARQ_to_DARF(register int bank)
{
      register int size, timeout = 3;
      register WORD wTmp;
      LPDAQD DAQD;

      /* Increment the tail and check for queue wrap */
      wTmp = readw(dev.DARQ + JQS_wTail) + PCTODSP_OFFSET(DAQDS__size);
      if (wTmp > readw(dev.DARQ + JQS_wSize))
            wTmp = 0;
      while (wTmp == readw(dev.DARQ + JQS_wHead) && timeout--)
            udelay(1);
      writew(wTmp, dev.DARQ + JQS_wTail);

      /* Get our digital audio queue struct */
      DAQD = bank * DAQDS__size + dev.base + DARQ_DATA_BUFF;

      /* Get length of data */
      size = readw(DAQD + DAQDS_wSize);

      /* Read data from the head (unprotected bank 1 access okay
           since this is only called inside an interrupt) */
      msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
      msnd_fifo_write_io(
            &dev.DARF,
            dev.base + bank * DAR_BUFF_SIZE,
            size);
      msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);

      return 1;
}

static __inline__ int pack_DAPF_to_DAPQ(register int start)
{
      register WORD DAPQ_tail;
      register int protect = start, nbanks = 0;
      LPDAQD DAQD;

      DAPQ_tail = readw(dev.DAPQ + JQS_wTail);
      while (DAPQ_tail != readw(dev.DAPQ + JQS_wHead) || start) {
            register int bank_num = DAPQ_tail / PCTODSP_OFFSET(DAQDS__size);
            register int n;
            unsigned long flags;

            /* Write the data to the new tail */
            if (protect) {
                  /* Critical section: protect fifo in non-interrupt */
                  spin_lock_irqsave(&dev.lock, flags);
                  n = msnd_fifo_read_io(
                        &dev.DAPF,
                        dev.base + bank_num * DAP_BUFF_SIZE,
                        DAP_BUFF_SIZE);
                  spin_unlock_irqrestore(&dev.lock, flags);
            } else {
                  n = msnd_fifo_read_io(
                        &dev.DAPF,
                        dev.base + bank_num * DAP_BUFF_SIZE,
                        DAP_BUFF_SIZE);
            }
            if (!n)
                  break;

            if (start)
                  start = 0;

            /* Get our digital audio queue struct */
            DAQD = bank_num * DAQDS__size + dev.base + DAPQ_DATA_BUFF;

            /* Write size of this bank */
            writew(n, DAQD + DAQDS_wSize);
            ++nbanks;

            /* Then advance the tail */
            DAPQ_tail = (++bank_num % 3) * PCTODSP_OFFSET(DAQDS__size);
            writew(DAPQ_tail, dev.DAPQ + JQS_wTail);
            /* Tell the DSP to play the bank */
            msnd_send_dsp_cmd(&dev, HDEX_PLAY_START);
      }
      return nbanks;
}

static int dsp_read(char __user *buf, size_t len)
{
      int count = len;
      char *page = (char *)__get_free_page(GFP_KERNEL);

      if (!page)
            return -ENOMEM;

      while (count > 0) {
            int n, k;
            unsigned long flags;

            k = PAGE_SIZE;
            if (k > count)
                  k = count;

            /* Critical section: protect fifo in non-interrupt */
            spin_lock_irqsave(&dev.lock, flags);
            n = msnd_fifo_read(&dev.DARF, page, k);
            spin_unlock_irqrestore(&dev.lock, flags);
            if (copy_to_user(buf, page, n)) {
                  free_page((unsigned long)page);
                  return -EFAULT;
            }
            buf += n;
            count -= n;

            if (n == k && count)
                  continue;

            if (!test_bit(F_READING, &dev.flags) && dev.mode & FMODE_READ) {
                  dev.last_recbank = -1;
                  if (chk_send_dsp_cmd(&dev, HDEX_RECORD_START) == 0)
                        set_bit(F_READING, &dev.flags);
            }

            if (dev.rec_ndelay) {
                  free_page((unsigned long)page);
                  return count == len ? -EAGAIN : len - count;
            }

            if (count > 0) {
                  set_bit(F_READBLOCK, &dev.flags);
                  if (!interruptible_sleep_on_timeout(
                        &dev.readblock,
                        get_rec_delay_jiffies(DAR_BUFF_SIZE)))
                        clear_bit(F_READING, &dev.flags);
                  clear_bit(F_READBLOCK, &dev.flags);
                  if (signal_pending(current)) {
                        free_page((unsigned long)page);
                        return -EINTR;
                  }
            }
      }
      free_page((unsigned long)page);
      return len - count;
}

static int dsp_write(const char __user *buf, size_t len)
{
      int count = len;
      char *page = (char *)__get_free_page(GFP_KERNEL);

      if (!page)
            return -ENOMEM;

      while (count > 0) {
            int n, k;
            unsigned long flags;

            k = PAGE_SIZE;
            if (k > count)
                  k = count;

            if (copy_from_user(page, buf, k)) {
                  free_page((unsigned long)page);
                  return -EFAULT;
            }

            /* Critical section: protect fifo in non-interrupt */
            spin_lock_irqsave(&dev.lock, flags);
            n = msnd_fifo_write(&dev.DAPF, page, k);
            spin_unlock_irqrestore(&dev.lock, flags);
            buf += n;
            count -= n;

            if (count && n == k)
                  continue;

            if (!test_bit(F_WRITING, &dev.flags) && (dev.mode & FMODE_WRITE)) {
                  dev.last_playbank = -1;
                  if (pack_DAPF_to_DAPQ(1) > 0)
                        set_bit(F_WRITING, &dev.flags);
            }

            if (dev.play_ndelay) {
                  free_page((unsigned long)page);
                  return count == len ? -EAGAIN : len - count;
            }

            if (count > 0) {
                  set_bit(F_WRITEBLOCK, &dev.flags);
                  interruptible_sleep_on_timeout(
                        &dev.writeblock,
                        get_play_delay_jiffies(DAP_BUFF_SIZE));
                  clear_bit(F_WRITEBLOCK, &dev.flags);
                  if (signal_pending(current)) {
                        free_page((unsigned long)page);
                        return -EINTR;
                  }
            }
      }

      free_page((unsigned long)page);
      return len - count;
}

static ssize_t dev_read(struct file *file, char __user *buf, size_t count, loff_t *off)
{
      int minor = iminor(file->f_path.dentry->d_inode);
      if (minor == dev.dsp_minor)
            return dsp_read(buf, count);
      else
            return -EINVAL;
}

static ssize_t dev_write(struct file *file, const char __user *buf, size_t count, loff_t *off)
{
      int minor = iminor(file->f_path.dentry->d_inode);
      if (minor == dev.dsp_minor)
            return dsp_write(buf, count);
      else
            return -EINVAL;
}

static __inline__ void eval_dsp_msg(register WORD wMessage)
{
      switch (HIBYTE(wMessage)) {
      case HIMT_PLAY_DONE:
            if (dev.last_playbank == LOBYTE(wMessage) || !test_bit(F_WRITING, &dev.flags))
                  break;
            dev.last_playbank = LOBYTE(wMessage);

            if (pack_DAPF_to_DAPQ(0) <= 0) {
                  if (!test_bit(F_WRITEBLOCK, &dev.flags)) {
                        if (test_and_clear_bit(F_WRITEFLUSH, &dev.flags))
                              wake_up_interruptible(&dev.writeflush);
                  }
                  clear_bit(F_WRITING, &dev.flags);
            }

            if (test_bit(F_WRITEBLOCK, &dev.flags))
                  wake_up_interruptible(&dev.writeblock);
            break;

      case HIMT_RECORD_DONE:
            if (dev.last_recbank == LOBYTE(wMessage))
                  break;
            dev.last_recbank = LOBYTE(wMessage);

            pack_DARQ_to_DARF(dev.last_recbank);

            if (test_bit(F_READBLOCK, &dev.flags))
                  wake_up_interruptible(&dev.readblock);
            break;

      case HIMT_DSP:
            switch (LOBYTE(wMessage)) {
#ifndef MSND_CLASSIC
            case HIDSP_PLAY_UNDER:
#endif
            case HIDSP_INT_PLAY_UNDER:
/*                printk(KERN_DEBUG LOGNAME ": Play underflow\n"); */
                  clear_bit(F_WRITING, &dev.flags);
                  break;

            case HIDSP_INT_RECORD_OVER:
/*                printk(KERN_DEBUG LOGNAME ": Record overflow\n"); */
                  clear_bit(F_READING, &dev.flags);
                  break;

            default:
/*                printk(KERN_DEBUG LOGNAME ": DSP message %d 0x%02x\n",
                  LOBYTE(wMessage), LOBYTE(wMessage)); */
                  break;
            }
            break;

        case HIMT_MIDI_IN_UCHAR:
            if (dev.midi_in_interrupt)
                  (*dev.midi_in_interrupt)(&dev);
            break;

      default:
/*          printk(KERN_DEBUG LOGNAME ": HIMT message %d 0x%02x\n", HIBYTE(wMessage), HIBYTE(wMessage)); */
            break;
      }
}

static irqreturn_t intr(int irq, void *dev_id)
{
      /* Send ack to DSP */
      msnd_inb(dev.io + HP_RXL);

      /* Evaluate queued DSP messages */
      while (readw(dev.DSPQ + JQS_wTail) != readw(dev.DSPQ + JQS_wHead)) {
            register WORD wTmp;

            eval_dsp_msg(readw(dev.pwDSPQData + 2*readw(dev.DSPQ + JQS_wHead)));

            if ((wTmp = readw(dev.DSPQ + JQS_wHead) + 1) > readw(dev.DSPQ + JQS_wSize))
                  writew(0, dev.DSPQ + JQS_wHead);
            else
                  writew(wTmp, dev.DSPQ + JQS_wHead);
      }
      return IRQ_HANDLED;
}

static const struct file_operations dev_fileops = {
      .owner            = THIS_MODULE,
      .read       = dev_read,
      .write            = dev_write,
      .ioctl            = dev_ioctl,
      .open       = dev_open,
      .release    = dev_release,
};

static int reset_dsp(void)
{
      int timeout = 100;

      msnd_outb(HPDSPRESET_ON, dev.io + HP_DSPR);
      mdelay(1);
#ifndef MSND_CLASSIC
      dev.info = msnd_inb(dev.io + HP_INFO);
#endif
      msnd_outb(HPDSPRESET_OFF, dev.io + HP_DSPR);
      mdelay(1);
      while (timeout-- > 0) {
            if (msnd_inb(dev.io + HP_CVR) == HP_CVR_DEF)
                  return 0;
            mdelay(1);
      }
      printk(KERN_ERR LOGNAME ": Cannot reset DSP\n");

      return -EIO;
}

static int __init probe_multisound(void)
{
#ifndef MSND_CLASSIC
      char *xv, *rev = NULL;
      char *pin = "Pinnacle", *fiji = "Fiji";
      char *pinfiji = "Pinnacle/Fiji";
#endif

      if (!request_region(dev.io, dev.numio, "probing")) {
            printk(KERN_ERR LOGNAME ": I/O port conflict\n");
            return -ENODEV;
      }

      if (reset_dsp() < 0) {
            release_region(dev.io, dev.numio);
            return -ENODEV;
      }

#ifdef MSND_CLASSIC
      dev.name = "Classic/Tahiti/Monterey";
      printk(KERN_INFO LOGNAME ": %s, "
#else
      switch (dev.info >> 4) {
      case 0xf: xv = "<= 1.15"; break;
      case 0x1: xv = "1.18/1.2"; break;
      case 0x2: xv = "1.3"; break;
      case 0x3: xv = "1.4"; break;
      default: xv = "unknown"; break;
      }

      switch (dev.info & 0x7) {
      case 0x0: rev = "I"; dev.name = pin; break;
      case 0x1: rev = "F"; dev.name = pin; break;
      case 0x2: rev = "G"; dev.name = pin; break;
      case 0x3: rev = "H"; dev.name = pin; break;
      case 0x4: rev = "E"; dev.name = fiji; break;
      case 0x5: rev = "C"; dev.name = fiji; break;
      case 0x6: rev = "D"; dev.name = fiji; break;
      case 0x7:
            rev = "A-B (Fiji) or A-E (Pinnacle)";
            dev.name = pinfiji;
            break;
      }
      printk(KERN_INFO LOGNAME ": %s revision %s, Xilinx version %s, "
#endif /* MSND_CLASSIC */
             "I/O 0x%x-0x%x, IRQ %d, memory mapped to %p-%p\n",
             dev.name,
#ifndef MSND_CLASSIC
             rev, xv,
#endif
             dev.io, dev.io + dev.numio - 1,
             dev.irq,
             dev.base, dev.base + 0x7fff);

      release_region(dev.io, dev.numio);
      return 0;
}

static int init_sma(void)
{
      static int initted;
      WORD mastVolLeft, mastVolRight;
      unsigned long flags;

#ifdef MSND_CLASSIC
      msnd_outb(dev.memid, dev.io + HP_MEMM);
#endif
      msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
      if (initted) {
            mastVolLeft = readw(dev.SMA + SMA_wCurrMastVolLeft);
            mastVolRight = readw(dev.SMA + SMA_wCurrMastVolRight);
      } else
            mastVolLeft = mastVolRight = 0;
      memset_io(dev.base, 0, 0x8000);

      /* Critical section: bank 1 access */
      spin_lock_irqsave(&dev.lock, flags);
      msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
      memset_io(dev.base, 0, 0x8000);
      msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
      spin_unlock_irqrestore(&dev.lock, flags);

      dev.pwDSPQData = (dev.base + DSPQ_DATA_BUFF);
      dev.pwMODQData = (dev.base + MODQ_DATA_BUFF);
      dev.pwMIDQData = (dev.base + MIDQ_DATA_BUFF);

      /* Motorola 56k shared memory base */
      dev.SMA = dev.base + SMA_STRUCT_START;

      /* Digital audio play queue */
      dev.DAPQ = dev.base + DAPQ_OFFSET;
      msnd_init_queue(dev.DAPQ, DAPQ_DATA_BUFF, DAPQ_BUFF_SIZE);

      /* Digital audio record queue */
      dev.DARQ = dev.base + DARQ_OFFSET;
      msnd_init_queue(dev.DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE);

      /* MIDI out queue */
      dev.MODQ = dev.base + MODQ_OFFSET;
      msnd_init_queue(dev.MODQ, MODQ_DATA_BUFF, MODQ_BUFF_SIZE);

      /* MIDI in queue */
      dev.MIDQ = dev.base + MIDQ_OFFSET;
      msnd_init_queue(dev.MIDQ, MIDQ_DATA_BUFF, MIDQ_BUFF_SIZE);

      /* DSP -> host message queue */
      dev.DSPQ = dev.base + DSPQ_OFFSET;
      msnd_init_queue(dev.DSPQ, DSPQ_DATA_BUFF, DSPQ_BUFF_SIZE);

      /* Setup some DSP values */
#ifndef MSND_CLASSIC
      writew(1, dev.SMA + SMA_wCurrPlayFormat);
      writew(dev.play_sample_size, dev.SMA + SMA_wCurrPlaySampleSize);
      writew(dev.play_channels, dev.SMA + SMA_wCurrPlayChannels);
      writew(dev.play_sample_rate, dev.SMA + SMA_wCurrPlaySampleRate);
#endif
      writew(dev.play_sample_rate, dev.SMA + SMA_wCalFreqAtoD);
      writew(mastVolLeft, dev.SMA + SMA_wCurrMastVolLeft);
      writew(mastVolRight, dev.SMA + SMA_wCurrMastVolRight);
#ifndef MSND_CLASSIC
      writel(0x00010000, dev.SMA + SMA_dwCurrPlayPitch);
      writel(0x00000001, dev.SMA + SMA_dwCurrPlayRate);
#endif
      writew(0x303, dev.SMA + SMA_wCurrInputTagBits);

      initted = 1;

      return 0;
}

static int __init calibrate_adc(WORD srate)
{
      writew(srate, dev.SMA + SMA_wCalFreqAtoD);
      if (dev.calibrate_signal == 0)
            writew(readw(dev.SMA + SMA_wCurrHostStatusFlags)
                   | 0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
      else
            writew(readw(dev.SMA + SMA_wCurrHostStatusFlags)
                   & ~0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
      if (msnd_send_word(&dev, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
          chk_send_dsp_cmd(&dev, HDEX_AUX_REQ) == 0) {
            current->state = TASK_INTERRUPTIBLE;
            schedule_timeout(HZ / 3);
            return 0;
      }
      printk(KERN_WARNING LOGNAME ": ADC calibration failed\n");

      return -EIO;
}

static int upload_dsp_code(void)
{
      msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
#ifndef HAVE_DSPCODEH
      INITCODESIZE = mod_firmware_load(INITCODEFILE, &INITCODE);
      if (!INITCODE) {
            printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
            return -EBUSY;
      }

      PERMCODESIZE = mod_firmware_load(PERMCODEFILE, &PERMCODE);
      if (!PERMCODE) {
            printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
            vfree(INITCODE);
            return -EBUSY;
      }
#endif
      memcpy_toio(dev.base, PERMCODE, PERMCODESIZE);
      if (msnd_upload_host(&dev, INITCODE, INITCODESIZE) < 0) {
            printk(KERN_WARNING LOGNAME ": Error uploading to DSP\n");
            return -ENODEV;
      }
#ifdef HAVE_DSPCODEH
      printk(KERN_INFO LOGNAME ": DSP firmware uploaded (resident)\n");
#else
      printk(KERN_INFO LOGNAME ": DSP firmware uploaded\n");
#endif

#ifndef HAVE_DSPCODEH
      vfree(INITCODE);
      vfree(PERMCODE);
#endif

      return 0;
}

#ifdef MSND_CLASSIC
static void reset_proteus(void)
{
      msnd_outb(HPPRORESET_ON, dev.io + HP_PROR);
      mdelay(TIME_PRO_RESET);
      msnd_outb(HPPRORESET_OFF, dev.io + HP_PROR);
      mdelay(TIME_PRO_RESET_DONE);
}
#endif

static int initialize(void)
{
      int err, timeout;

#ifdef MSND_CLASSIC
      msnd_outb(HPWAITSTATE_0, dev.io + HP_WAIT);
      msnd_outb(HPBITMODE_16, dev.io + HP_BITM);

      reset_proteus();
#endif
      if ((err = init_sma()) < 0) {
            printk(KERN_WARNING LOGNAME ": Cannot initialize SMA\n");
            return err;
      }

      if ((err = reset_dsp()) < 0)
            return err;

      if ((err = upload_dsp_code()) < 0) {
            printk(KERN_WARNING LOGNAME ": Cannot upload DSP code\n");
            return err;
      }

      timeout = 200;
      while (readw(dev.base)) {
            mdelay(1);
            if (!timeout--) {
                  printk(KERN_DEBUG LOGNAME ": DSP reset timeout\n");
                  return -EIO;
            }
      }

      mixer_setup();

      return 0;
}

static int dsp_full_reset(void)
{
      int rv;

      if (test_bit(F_RESETTING, &dev.flags) || ++dev.nresets > 10)
            return 0;

      set_bit(F_RESETTING, &dev.flags);
      printk(KERN_INFO LOGNAME ": DSP reset\n");
      dsp_halt(NULL);               /* Unconditionally halt */
      if ((rv = initialize()))
            printk(KERN_WARNING LOGNAME ": DSP reset failed\n");
      force_recsrc(dev.recsrc);
      dsp_open(NULL);
      clear_bit(F_RESETTING, &dev.flags);

      return rv;
}

static int __init attach_multisound(void)
{
      int err;

      if ((err = request_irq(dev.irq, intr, 0, dev.name, &dev)) < 0) {
            printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
            return err;
      }
      request_region(dev.io, dev.numio, dev.name);

        if ((err = dsp_full_reset()) < 0) {
            release_region(dev.io, dev.numio);
            free_irq(dev.irq, &dev);
            return err;
      }

      if ((err = msnd_register(&dev)) < 0) {
            printk(KERN_ERR LOGNAME ": Unable to register MultiSound\n");
            release_region(dev.io, dev.numio);
            free_irq(dev.irq, &dev);
            return err;
      }

      if ((dev.dsp_minor = register_sound_dsp(&dev_fileops, -1)) < 0) {
            printk(KERN_ERR LOGNAME ": Unable to register DSP operations\n");
            msnd_unregister(&dev);
            release_region(dev.io, dev.numio);
            free_irq(dev.irq, &dev);
            return dev.dsp_minor;
      }

      if ((dev.mixer_minor = register_sound_mixer(&dev_fileops, -1)) < 0) {
            printk(KERN_ERR LOGNAME ": Unable to register mixer operations\n");
            unregister_sound_mixer(dev.mixer_minor);
            msnd_unregister(&dev);
            release_region(dev.io, dev.numio);
            free_irq(dev.irq, &dev);
            return dev.mixer_minor;
      }

      dev.ext_midi_dev = dev.hdr_midi_dev = -1;

      disable_irq(dev.irq);
      calibrate_adc(dev.play_sample_rate);
#ifndef MSND_CLASSIC
      force_recsrc(SOUND_MASK_IMIX);
#endif

      return 0;
}

static void __exit unload_multisound(void)
{
      release_region(dev.io, dev.numio);
      free_irq(dev.irq, &dev);
      unregister_sound_mixer(dev.mixer_minor);
      unregister_sound_dsp(dev.dsp_minor);
      msnd_unregister(&dev);
}

#ifndef MSND_CLASSIC

/* Pinnacle/Fiji Logical Device Configuration */

static int __init msnd_write_cfg(int cfg, int reg, int value)
{
      msnd_outb(reg, cfg);
      msnd_outb(value, cfg + 1);
      if (value != msnd_inb(cfg + 1)) {
            printk(KERN_ERR LOGNAME ": msnd_write_cfg: I/O error\n");
            return -EIO;
      }
      return 0;
}

static int __init msnd_write_cfg_io0(int cfg, int num, WORD io)
{
      if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_IO0_BASEHI, HIBYTE(io)))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_IO0_BASELO, LOBYTE(io)))
            return -EIO;
      return 0;
}

static int __init msnd_write_cfg_io1(int cfg, int num, WORD io)
{
      if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_IO1_BASEHI, HIBYTE(io)))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_IO1_BASELO, LOBYTE(io)))
            return -EIO;
      return 0;
}

static int __init msnd_write_cfg_irq(int cfg, int num, WORD irq)
{
      if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_IRQ_NUMBER, LOBYTE(irq)))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_IRQ_TYPE, IRQTYPE_EDGE))
            return -EIO;
      return 0;
}

static int __init msnd_write_cfg_mem(int cfg, int num, int mem)
{
      WORD wmem;

      mem >>= 8;
      mem &= 0xfff;
      wmem = (WORD)mem;
      if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_MEMBASEHI, HIBYTE(wmem)))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_MEMBASELO, LOBYTE(wmem)))
            return -EIO;
      if (wmem && msnd_write_cfg(cfg, IREG_MEMCONTROL, (MEMTYPE_HIADDR | MEMTYPE_16BIT)))
            return -EIO;
      return 0;
}

static int __init msnd_activate_logical(int cfg, int num)
{
      if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
            return -EIO;
      if (msnd_write_cfg(cfg, IREG_ACTIVATE, LD_ACTIVATE))
            return -EIO;
      return 0;
}

static int __init msnd_write_cfg_logical(int cfg, int num, WORD io0, WORD io1, WORD irq, int mem)
{
      if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
            return -EIO;
      if (msnd_write_cfg_io0(cfg, num, io0))
            return -EIO;
      if (msnd_write_cfg_io1(cfg, num, io1))
            return -EIO;
      if (msnd_write_cfg_irq(cfg, num, irq))
            return -EIO;
      if (msnd_write_cfg_mem(cfg, num, mem))
            return -EIO;
      if (msnd_activate_logical(cfg, num))
            return -EIO;
      return 0;
}

typedef struct msnd_pinnacle_cfg_device {
      WORD io0, io1, irq;
      int mem;
} msnd_pinnacle_cfg_t[4];

static int __init msnd_pinnacle_cfg_devices(int cfg, int reset, msnd_pinnacle_cfg_t device)
{
      int i;

      /* Reset devices if told to */
      if (reset) {
            printk(KERN_INFO LOGNAME ": Resetting all devices\n");
            for (i = 0; i < 4; ++i)
                  if (msnd_write_cfg_logical(cfg, i, 0, 0, 0, 0))
                        return -EIO;
      }

      /* Configure specified devices */
      for (i = 0; i < 4; ++i) {

            switch (i) {
            case 0:           /* DSP */
                  if (!(device[i].io0 && device[i].irq && device[i].mem))
                        continue;
                  break;
            case 1:           /* MPU */
                  if (!(device[i].io0 && device[i].irq))
                        continue;
                  printk(KERN_INFO LOGNAME
                         ": Configuring MPU to I/O 0x%x IRQ %d\n",
                         device[i].io0, device[i].irq);
                  break;
            case 2:           /* IDE */
                  if (!(device[i].io0 && device[i].io1 && device[i].irq))
                        continue;
                  printk(KERN_INFO LOGNAME
                         ": Configuring IDE to I/O 0x%x, 0x%x IRQ %d\n",
                         device[i].io0, device[i].io1, device[i].irq);
                  break;
            case 3:           /* Joystick */
                  if (!(device[i].io0))
                        continue;
                  printk(KERN_INFO LOGNAME
                         ": Configuring joystick to I/O 0x%x\n",
                         device[i].io0);
                  break;
            }

            /* Configure the device */
            if (msnd_write_cfg_logical(cfg, i, device[i].io0, device[i].io1, device[i].irq, device[i].mem))
                  return -EIO;
      }

      return 0;
}
#endif

#ifdef MODULE
MODULE_AUTHOR                       ("Andrew Veliath <andrewtv@usa.net>");
MODULE_DESCRIPTION                  ("Turtle Beach " LONGNAME " Linux Driver");
MODULE_LICENSE("GPL");

static int io __initdata =          -1;
static int irq __initdata =         -1;
static int mem __initdata =         -1;
static int write_ndelay __initdata =      -1;

#ifndef MSND_CLASSIC
/* Pinnacle/Fiji non-PnP Config Port */
static int cfg __initdata =         -1;

/* Extra Peripheral Configuration */
static int reset __initdata = 0;
static int mpu_io __initdata = 0;
static int mpu_irq __initdata = 0;
static int ide_io0 __initdata = 0;
static int ide_io1 __initdata = 0;
static int ide_irq __initdata = 0;
static int joystick_io __initdata = 0;

/* If we have the digital daugherboard... */
static int digital __initdata = 0;
#endif

static int fifosize __initdata =    DEFFIFOSIZE;
static int calibrate_signal __initdata = 0;

#else /* not a module */

static int write_ndelay __initdata =      -1;

#ifdef MSND_CLASSIC
static int io __initdata =          CONFIG_MSNDCLAS_IO;
static int irq __initdata =         CONFIG_MSNDCLAS_IRQ;
static int mem __initdata =         CONFIG_MSNDCLAS_MEM;
#else /* Pinnacle/Fiji */

static int io __initdata =          CONFIG_MSNDPIN_IO;
static int irq __initdata =         CONFIG_MSNDPIN_IRQ;
static int mem __initdata =         CONFIG_MSNDPIN_MEM;

/* Pinnacle/Fiji non-PnP Config Port */
#ifdef CONFIG_MSNDPIN_NONPNP
#  ifndef CONFIG_MSNDPIN_CFG
#    define CONFIG_MSNDPIN_CFG            0x250
#  endif
#else
#  ifdef CONFIG_MSNDPIN_CFG
#    undef CONFIG_MSNDPIN_CFG
#  endif
#  define CONFIG_MSNDPIN_CFG        -1
#endif
static int cfg __initdata =         CONFIG_MSNDPIN_CFG;
/* If not a module, we don't need to bother with reset=1 */
static int reset;

/* Extra Peripheral Configuration (Default: Disable) */
#ifndef CONFIG_MSNDPIN_MPU_IO
#  define CONFIG_MSNDPIN_MPU_IO           0
#endif
static int mpu_io __initdata =            CONFIG_MSNDPIN_MPU_IO;

#ifndef CONFIG_MSNDPIN_MPU_IRQ
#  define CONFIG_MSNDPIN_MPU_IRQ    0
#endif
static int mpu_irq __initdata =           CONFIG_MSNDPIN_MPU_IRQ;

#ifndef CONFIG_MSNDPIN_IDE_IO0
#  define CONFIG_MSNDPIN_IDE_IO0    0
#endif
static int ide_io0 __initdata =           CONFIG_MSNDPIN_IDE_IO0;

#ifndef CONFIG_MSNDPIN_IDE_IO1
#  define CONFIG_MSNDPIN_IDE_IO1    0
#endif
static int ide_io1 __initdata =           CONFIG_MSNDPIN_IDE_IO1;

#ifndef CONFIG_MSNDPIN_IDE_IRQ
#  define CONFIG_MSNDPIN_IDE_IRQ    0
#endif
static int ide_irq __initdata =           CONFIG_MSNDPIN_IDE_IRQ;

#ifndef CONFIG_MSNDPIN_JOYSTICK_IO
#  define CONFIG_MSNDPIN_JOYSTICK_IO      0
#endif
static int joystick_io __initdata = CONFIG_MSNDPIN_JOYSTICK_IO;

/* Have SPDIF (Digital) Daughterboard */
#ifndef CONFIG_MSNDPIN_DIGITAL
#  define CONFIG_MSNDPIN_DIGITAL    0
#endif
static int digital __initdata =           CONFIG_MSNDPIN_DIGITAL;

#endif /* MSND_CLASSIC */

#ifndef CONFIG_MSND_FIFOSIZE
#  define CONFIG_MSND_FIFOSIZE            DEFFIFOSIZE
#endif
static int fifosize __initdata =    CONFIG_MSND_FIFOSIZE;

#ifndef CONFIG_MSND_CALSIGNAL
#  define CONFIG_MSND_CALSIGNAL           0
#endif
static int
calibrate_signal __initdata =       CONFIG_MSND_CALSIGNAL;
#endif /* MODULE */

module_param                        (io, int, 0);
module_param                        (irq, int, 0);
module_param                        (mem, int, 0);
module_param                        (write_ndelay, int, 0);
module_param                        (fifosize, int, 0);
module_param                        (calibrate_signal, int, 0);
#ifndef MSND_CLASSIC
module_param                        (digital, bool, 0);
module_param                        (cfg, int, 0);
module_param                        (reset, int, 0);
module_param                        (mpu_io, int, 0);
module_param                        (mpu_irq, int, 0);
module_param                        (ide_io0, int, 0);
module_param                        (ide_io1, int, 0);
module_param                        (ide_irq, int, 0);
module_param                        (joystick_io, int, 0);
#endif

static int __init msnd_init(void)
{
      int err;
#ifndef MSND_CLASSIC
      static msnd_pinnacle_cfg_t pinnacle_devs;
#endif /* MSND_CLASSIC */

      printk(KERN_INFO LOGNAME ": Turtle Beach " LONGNAME " Linux Driver Version "
             VERSION ", Copyright (C) 1998 Andrew Veliath\n");

      if (io == -1 || irq == -1 || mem == -1)
            printk(KERN_WARNING LOGNAME ": io, irq and mem must be set\n");

#ifdef MSND_CLASSIC
      if (io == -1 ||
          !(io == 0x290 ||
            io == 0x260 ||
            io == 0x250 ||
            io == 0x240 ||
            io == 0x230 ||
            io == 0x220 ||
            io == 0x210 ||
            io == 0x3e0)) {
            printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must be set to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, or 0x3E0\n");
            return -EINVAL;
      }
#else
      if (io == -1 ||
            io < 0x100 ||
            io > 0x3e0 ||
            (io % 0x10) != 0) {
                  printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must within the range 0x100 to 0x3E0 and must be evenly divisible by 0x10\n");
                  return -EINVAL;
      }
#endif /* MSND_CLASSIC */

      if (irq == -1 ||
          !(irq == 5 ||
            irq == 7 ||
            irq == 9 ||
            irq == 10 ||
            irq == 11 ||
            irq == 12)) {
            printk(KERN_ERR LOGNAME ": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
            return -EINVAL;
      }

      if (mem == -1 ||
          !(mem == 0xb0000 ||
            mem == 0xc8000 ||
            mem == 0xd0000 ||
            mem == 0xd8000 ||
            mem == 0xe0000 ||
            mem == 0xe8000)) {
            printk(KERN_ERR LOGNAME ": \"mem\" - must be set to "
                   "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or 0xe8000\n");
            return -EINVAL;
      }

#ifdef MSND_CLASSIC
      switch (irq) {
      case 5: dev.irqid = HPIRQ_5; break;
      case 7: dev.irqid = HPIRQ_7; break;
      case 9: dev.irqid = HPIRQ_9; break;
      case 10: dev.irqid = HPIRQ_10; break;
      case 11: dev.irqid = HPIRQ_11; break;
      case 12: dev.irqid = HPIRQ_12; break;
      }

      switch (mem) {
      case 0xb0000: dev.memid = HPMEM_B000; break;
      case 0xc8000: dev.memid = HPMEM_C800; break;
      case 0xd0000: dev.memid = HPMEM_D000; break;
      case 0xd8000: dev.memid = HPMEM_D800; break;
      case 0xe0000: dev.memid = HPMEM_E000; break;
      case 0xe8000: dev.memid = HPMEM_E800; break;
      }
#else
      if (cfg == -1) {
            printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
      } else if (cfg != 0x250 && cfg != 0x260 && cfg != 0x270) {
            printk(KERN_INFO LOGNAME ": Config port must be 0x250, 0x260 or 0x270 (or unspecified for PnP mode)\n");
            return -EINVAL;
      } else {
            printk(KERN_INFO LOGNAME ": Non-PnP mode: configuring at port 0x%x\n", cfg);

            /* DSP */
            pinnacle_devs[0].io0 = io;
            pinnacle_devs[0].irq = irq;
            pinnacle_devs[0].mem = mem;

            /* The following are Pinnacle specific */

            /* MPU */
            pinnacle_devs[1].io0 = mpu_io;
            pinnacle_devs[1].irq = mpu_irq;

            /* IDE */
            pinnacle_devs[2].io0 = ide_io0;
            pinnacle_devs[2].io1 = ide_io1;
            pinnacle_devs[2].irq = ide_irq;

            /* Joystick */
            pinnacle_devs[3].io0 = joystick_io;

            if (!request_region(cfg, 2, "Pinnacle/Fiji Config")) {
                  printk(KERN_ERR LOGNAME ": Config port 0x%x conflict\n", cfg);
                  return -EIO;
            }

            if (msnd_pinnacle_cfg_devices(cfg, reset, pinnacle_devs)) {
                  printk(KERN_ERR LOGNAME ": Device configuration error\n");
                  release_region(cfg, 2);
                  return -EIO;
            }
            release_region(cfg, 2);
      }
#endif /* MSND_CLASSIC */

      if (fifosize < 16)
            fifosize = 16;

      if (fifosize > 1024)
            fifosize = 1024;

      set_default_audio_parameters();
#ifdef MSND_CLASSIC
      dev.type = msndClassic;
#else
      dev.type = msndPinnacle;
#endif
      dev.io = io;
      dev.numio = DSP_NUMIO;
      dev.irq = irq;
      dev.base = ioremap(mem, 0x8000);
      dev.fifosize = fifosize * 1024;
      dev.calibrate_signal = calibrate_signal ? 1 : 0;
      dev.recsrc = 0;
      dev.dspq_data_buff = DSPQ_DATA_BUFF;
      dev.dspq_buff_size = DSPQ_BUFF_SIZE;
      if (write_ndelay == -1)
            write_ndelay = CONFIG_MSND_WRITE_NDELAY;
      if (write_ndelay)
            clear_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
      else
            set_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
#ifndef MSND_CLASSIC
      if (digital)
            set_bit(F_HAVEDIGITAL, &dev.flags);
#endif
      init_waitqueue_head(&dev.writeblock);
      init_waitqueue_head(&dev.readblock);
      init_waitqueue_head(&dev.writeflush);
      msnd_fifo_init(&dev.DAPF);
      msnd_fifo_init(&dev.DARF);
      spin_lock_init(&dev.lock);
      printk(KERN_INFO LOGNAME ": %u byte audio FIFOs (x2)\n", dev.fifosize);
      if ((err = msnd_fifo_alloc(&dev.DAPF, dev.fifosize)) < 0) {
            printk(KERN_ERR LOGNAME ": Couldn't allocate write FIFO\n");
            return err;
      }

      if ((err = msnd_fifo_alloc(&dev.DARF, dev.fifosize)) < 0) {
            printk(KERN_ERR LOGNAME ": Couldn't allocate read FIFO\n");
            msnd_fifo_free(&dev.DAPF);
            return err;
      }

      if ((err = probe_multisound()) < 0) {
            printk(KERN_ERR LOGNAME ": Probe failed\n");
            msnd_fifo_free(&dev.DAPF);
            msnd_fifo_free(&dev.DARF);
            return err;
      }

      if ((err = attach_multisound()) < 0) {
            printk(KERN_ERR LOGNAME ": Attach failed\n");
            msnd_fifo_free(&dev.DAPF);
            msnd_fifo_free(&dev.DARF);
            return err;
      }

      return 0;
}

static void __exit msdn_cleanup(void)
{
      unload_multisound();
      msnd_fifo_free(&dev.DAPF);
      msnd_fifo_free(&dev.DARF);
}

module_init(msnd_init);
module_exit(msdn_cleanup);

Generated by  Doxygen 1.6.0   Back to index