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

wavfront.c

/*  -*- linux-c -*-
 *
 * sound/wavfront.c
 *
 * A Linux driver for Turtle Beach WaveFront Series (Maui, Tropez, Tropez Plus)
 *
 * This driver supports the onboard wavetable synthesizer (an ICS2115),
 * including patch, sample and program loading and unloading, conversion
 * of GUS patches during loading, and full user-level access to all
 * WaveFront commands. It tries to provide semi-intelligent patch and
 * sample management as well.
 *
 * It also provides support for the ICS emulation of an MPU-401.  Full
 * support for the ICS emulation's "virtual MIDI mode" is provided in
 * wf_midi.c.
 *
 * Support is also provided for the Tropez Plus' onboard FX processor,
 * a Yamaha YSS225. Currently, code exists to configure the YSS225,
 * and there is an interface allowing tweaking of any of its memory
 * addresses. However, I have been unable to decipher the logical
 * positioning of the configuration info for various effects, so for
 * now, you just get the YSS225 in the same state as Turtle Beach's
 * "SETUPSND.EXE" utility leaves it.
 *
 * The boards' DAC/ADC (a Crystal CS4232) is supported by cs4232.[co],
 * This chip also controls the configuration of the card: the wavefront
 * synth is logical unit 4.
 *
 *
 * Supported devices:
 *
 *   /dev/dsp                      - using cs4232+ad1848 modules, OSS compatible
 *   /dev/midiNN and /dev/midiNN+1 - using wf_midi code, OSS compatible
 *   /dev/synth00                  - raw synth interface
 * 
 **********************************************************************
 *
 * Copyright (C) by Paul Barton-Davis 1998
 *
 * Some portions of this file are taken from work that is
 * copyright (C) by Hannu Savolainen 1993-1996
 *
 * Although the relevant code here is all new, the handling of
 * sample/alias/multi- samples is entirely based on a driver by Matt
 * Martin and Rutger Nijlunsing which demonstrated how to get things
 * to work correctly. The GUS patch loading code has been almost
 * unaltered by me, except to fit formatting and function names in the
 * rest of the file. Many thanks to them.
 *
 * Appreciation and thanks to Hannu Savolainen for his early work on the Maui
 * driver, and answering a few questions while this one was developed.
 *
 * Absolutely NO thanks to Turtle Beach/Voyetra and Yamaha for their
 * complete lack of help in developing this driver, and in particular
 * for their utter silence in response to questions about undocumented
 * aspects of configuring a WaveFront soundcard, particularly the
 * effects processor.
 *
 * $Id: wavfront.c,v 0.7 1998/09/09 15:47:36 pbd Exp $
 *
 * This program is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 * Version 2 (June 1991). See the "COPYING" file distributed with this software
 * for more info.
 *
 * Changes:
 * 11-10-2000     Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
 *          Added some __init and __initdata to entries in yss225.c
 */

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/smp_lock.h>
#include <linux/ptrace.h>
#include <linux/fcntl.h>
#include <linux/syscalls.h>
#include <linux/ioport.h>    
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/config.h>

#include <linux/delay.h>

#include "sound_config.h"

#include <linux/wavefront.h>

#define _MIDI_SYNTH_C_
#define MIDI_SYNTH_NAME "WaveFront MIDI"
#define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
#include "midi_synth.h"

/* Compile-time control of the extent to which OSS is supported.

   I consider /dev/sequencer to be an anachronism, but given its
   widespread usage by various Linux MIDI software, it seems worth
   offering support to it if it's not too painful. Instead of using
   /dev/sequencer, I recommend:

     for synth programming and patch loading: /dev/synthNN
     for kernel-synchronized MIDI sequencing: the ALSA sequencer
     for direct MIDI control: /dev/midiNN

   I have never tried static compilation into the kernel. The #if's
   for this are really just notes to myself about what the code is
   for.
*/

#define OSS_SUPPORT_SEQ            0x1  /* use of /dev/sequencer */
#define OSS_SUPPORT_STATIC_INSTALL 0x2  /* static compilation into kernel */

#define OSS_SUPPORT_LEVEL          0x1  /* just /dev/sequencer for now */

#if    OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
static int (*midi_load_patch) (int devno, int format, const char __user *addr,
                         int offs, int count, int pmgr_flag) = NULL;
#endif /* OSS_SUPPORT_SEQ */

/* if WF_DEBUG not defined, no run-time debugging messages will
   be available via the debug flag setting. Given the current
   beta state of the driver, this will remain set until a future 
   version.
*/

#define WF_DEBUG 1

#ifdef WF_DEBUG

/* Thank goodness for gcc's preprocessor ... */

#define DPRINT(cond, format, args...) \
       if ((dev.debug & (cond)) == (cond)) { \
           printk (KERN_DEBUG LOGNAME format, ## args); \
       }
#else
#define DPRINT(cond, format, args...)
#endif

#define LOGNAME "WaveFront: "

/* bitmasks for WaveFront status port value */

#define STAT_RINTR_ENABLED    0x01
#define STAT_CAN_READ         0x02
#define STAT_INTR_READ        0x04
#define STAT_WINTR_ENABLED    0x10
#define STAT_CAN_WRITE        0x20
#define STAT_INTR_WRITE       0x40

/*** Module-accessible parameters ***************************************/

static int wf_raw;     /* we normally check for "raw state" to firmware
                     loading. if set, then during driver loading, the
                     state of the board is ignored, and we reset the
                     board and load the firmware anyway.
                  */
               
static int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
                      whatever state it is when the driver is loaded.
                      The default is to download the microprogram and
                      associated coefficients to set it up for "default"
                      operation, whatever that means.
                   */

static int debug_default;  /* you can set this to control debugging
                        during driver loading. it takes any combination
                        of the WF_DEBUG_* flags defined in
                        wavefront.h
                     */

/* XXX this needs to be made firmware and hardware version dependent */

static char *ospath = "/etc/sound/wavefront.os"; /* where to find a processed
                                          version of the WaveFront OS
                                        */

static int wait_polls = 2000; /* This is a number of tries we poll the
                         status register before resorting to sleeping.
                         WaveFront being an ISA card each poll takes
                         about 1.2us. So before going to
                           sleep we wait up to 2.4ms in a loop.
                       */

static int sleep_length = HZ/100; /* This says how long we're going to
                             sleep between polls.
                               10ms sounds reasonable for fast response.
                            */

static int sleep_tries = 50;       /* Wait for status 0.5 seconds total. */

static int reset_time = 2; /* hundreths of a second we wait after a HW reset for
                        the expected interrupt.
                     */

static int ramcheck_time = 20;    /* time in seconds to wait while ROM code
                               checks on-board RAM.
                            */

static int osrun_time = 10;  /* time in seconds we wait for the OS to
                          start running.
                       */

module_param(wf_raw, int, 0);
module_param(fx_raw, int, 0);
module_param(debug_default, int, 0);
module_param(wait_polls, int, 0);
module_param(sleep_length, int, 0);
module_param(sleep_tries, int, 0);
module_param(ospath, charp, 0);
module_param(reset_time, int, 0);
module_param(ramcheck_time, int, 0);
module_param(osrun_time, int, 0);

/***************************************************************************/

/* Note: because this module doesn't export any symbols, this really isn't
   a global variable, even if it looks like one. I was quite confused by
   this when I started writing this as a (newer) module -- pbd.
*/

struct wf_config {
      int devno;            /* device number from kernel */
      int irq;              /* "you were one, one of the few ..." */
      int base;             /* low i/o port address */

#define mpu_data_port    base 
#define mpu_command_port base + 1 /* write semantics */
#define mpu_status_port  base + 1 /* read semantics */
#define data_port        base + 2 
#define status_port      base + 3 /* read semantics */
#define control_port     base + 3 /* write semantics  */
#define block_port       base + 4 /* 16 bit, writeonly */
#define last_block_port  base + 6 /* 16 bit, writeonly */

      /* FX ports. These are mapped through the ICS2115 to the YS225.
         The ICS2115 takes care of flipping the relevant pins on the
         YS225 so that access to each of these ports does the right
         thing. Note: these are NOT documented by Turtle Beach.
      */

#define fx_status       base + 8 
#define fx_op           base + 8 
#define fx_lcr          base + 9 
#define fx_dsp_addr     base + 0xa
#define fx_dsp_page     base + 0xb 
#define fx_dsp_lsb      base + 0xc 
#define fx_dsp_msb      base + 0xd 
#define fx_mod_addr     base + 0xe
#define fx_mod_data     base + 0xf 

      volatile int irq_ok;               /* set by interrupt handler */
        volatile int irq_cnt;              /* ditto */
      int opened;                        /* flag, holds open(2) mode */
      char debug;                        /* debugging flags */
      int freemem;                       /* installed RAM, in bytes */ 

      int synth_dev;                     /* devno for "raw" synth */
      int mididev;                       /* devno for internal MIDI */
      int ext_mididev;                   /* devno for external MIDI */ 
        int fx_mididev;                    /* devno for FX MIDI interface */
#if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
      int oss_dev;                      /* devno for OSS sequencer synth */
#endif /* OSS_SUPPORT_SEQ */

      char fw_version[2];                /* major = [0], minor = [1] */
      char hw_version[2];                /* major = [0], minor = [1] */
      char israw;                        /* needs Motorola microcode */
      char has_fx;                       /* has FX processor (Tropez+) */
      char prog_status[WF_MAX_PROGRAM];  /* WF_SLOT_* */
      char patch_status[WF_MAX_PATCH];   /* WF_SLOT_* */
      char sample_status[WF_MAX_SAMPLE]; /* WF_ST_* | WF_SLOT_* */
      int samples_used;                  /* how many */
      char interrupts_on;                /* h/w MPU interrupts enabled ? */
      char rom_samples_rdonly;           /* can we write on ROM samples */
      wait_queue_head_t interrupt_sleeper; 
} dev;

static DEFINE_SPINLOCK(lock);
static int  detect_wffx(void);
static int  wffx_ioctl (wavefront_fx_info *);
static int  wffx_init (void);

static int wavefront_delete_sample (int sampnum);
static int wavefront_find_free_sample (void);

/* From wf_midi.c */

extern int  virtual_midi_enable  (void);
extern int  virtual_midi_disable (void);
extern int  detect_wf_mpu (int, int);
extern int  install_wf_mpu (void);
extern int  uninstall_wf_mpu (void);

typedef struct {
      int cmd;
      char *action;
      unsigned int read_cnt;
      unsigned int write_cnt;
      int need_ack;
} wavefront_command;

static struct {
      int errno;
      const char *errstr;
} wavefront_errors[] = {
      { 0x01, "Bad sample number" },
      { 0x02, "Out of sample memory" },
      { 0x03, "Bad patch number" },
      { 0x04, "Error in number of voices" },
      { 0x06, "Sample load already in progress" },
      { 0x0B, "No sample load request pending" },
      { 0x0E, "Bad MIDI channel number" },
      { 0x10, "Download Record Error" },
      { 0x80, "Success" },
      { 0 }
};

#define NEEDS_ACK 1

static wavefront_command wavefront_commands[] = {
      { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK },
      { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0},
      { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK },
      { WFC_GET_NVOICES, "get number of voices", 1, 0, 0 },
      { WFC_SET_TUNING, "set synthesizer tuning", 0, 2, NEEDS_ACK },
      { WFC_GET_TUNING, "get synthesizer tuning", 2, 0, 0 },
      { WFC_DISABLE_CHANNEL, "disable synth channel", 0, 1, NEEDS_ACK },
      { WFC_ENABLE_CHANNEL, "enable synth channel", 0, 1, NEEDS_ACK },
      { WFC_GET_CHANNEL_STATUS, "get synth channel status", 3, 0, 0 },
      { WFC_MISYNTH_OFF, "disable midi-in to synth", 0, 0, NEEDS_ACK },
      { WFC_MISYNTH_ON, "enable midi-in to synth", 0, 0, NEEDS_ACK },
      { WFC_VMIDI_ON, "enable virtual midi mode", 0, 0, NEEDS_ACK },
      { WFC_VMIDI_OFF, "disable virtual midi mode", 0, 0, NEEDS_ACK },
      { WFC_MIDI_STATUS, "report midi status", 1, 0, 0 },
      { WFC_FIRMWARE_VERSION, "report firmware version", 2, 0, 0 },
      { WFC_HARDWARE_VERSION, "report hardware version", 2, 0, 0 },
      { WFC_GET_NSAMPLES, "report number of samples", 2, 0, 0 },
      { WFC_INSTOUT_LEVELS, "report instantaneous output levels", 7, 0, 0 },
      { WFC_PEAKOUT_LEVELS, "report peak output levels", 7, 0, 0 },
      { WFC_DOWNLOAD_SAMPLE, "download sample",
        0, WF_SAMPLE_BYTES, NEEDS_ACK },
      { WFC_DOWNLOAD_BLOCK, "download block", 0, 0, NEEDS_ACK},
      { WFC_DOWNLOAD_SAMPLE_HEADER, "download sample header",
        0, WF_SAMPLE_HDR_BYTES, NEEDS_ACK },
      { WFC_UPLOAD_SAMPLE_HEADER, "upload sample header", 13, 2, 0 },

      /* This command requires a variable number of bytes to be written.
         There is a hack in wavefront_cmd() to support this. The actual
         count is passed in as the read buffer ptr, cast appropriately.
         Ugh.
      */

      { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },

      /* This one is a hack as well. We just read the first byte of the
         response, don't fetch an ACK, and leave the rest to the 
         calling function. Ugly, ugly, ugly.
      */

      { WFC_UPLOAD_MULTISAMPLE, "upload multisample", 2, 1, 0 },
      { WFC_DOWNLOAD_SAMPLE_ALIAS, "download sample alias",
        0, WF_ALIAS_BYTES, NEEDS_ACK },
      { WFC_UPLOAD_SAMPLE_ALIAS, "upload sample alias", WF_ALIAS_BYTES, 2, 0},
      { WFC_DELETE_SAMPLE, "delete sample", 0, 2, NEEDS_ACK },
      { WFC_IDENTIFY_SAMPLE_TYPE, "identify sample type", 5, 2, 0 },
      { WFC_UPLOAD_SAMPLE_PARAMS, "upload sample parameters" },
      { WFC_REPORT_FREE_MEMORY, "report free memory", 4, 0, 0 },
      { WFC_DOWNLOAD_PATCH, "download patch", 0, 134, NEEDS_ACK },
      { WFC_UPLOAD_PATCH, "upload patch", 132, 2, 0 },
      { WFC_DOWNLOAD_PROGRAM, "download program", 0, 33, NEEDS_ACK },
      { WFC_UPLOAD_PROGRAM, "upload program", 32, 1, 0 },
      { WFC_DOWNLOAD_EDRUM_PROGRAM, "download enhanced drum program", 0, 9,
        NEEDS_ACK},
      { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
      { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
        0, 1, NEEDS_ACK },
      { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
      { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
        32, 0, 0 },
      { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
      { 0x00 }
};

static const char *
wavefront_errorstr (int errnum)

{
      int i;

      for (i = 0; wavefront_errors[i].errstr; i++) {
            if (wavefront_errors[i].errno == errnum) {
                  return wavefront_errors[i].errstr;
            }
      }

      return "Unknown WaveFront error";
}

static wavefront_command *
wavefront_get_command (int cmd) 

{
      int i;

      for (i = 0; wavefront_commands[i].cmd != 0; i++) {
            if (cmd == wavefront_commands[i].cmd) {
                  return &wavefront_commands[i];
            }
      }

      return (wavefront_command *) 0;
}

static inline int
wavefront_status (void) 

{
      return inb (dev.status_port);
}

static int
wavefront_wait (int mask)

{
      int i;

      for (i = 0; i < wait_polls; i++)
            if (wavefront_status() & mask)
                  return 1;

      for (i = 0; i < sleep_tries; i++) {

            if (wavefront_status() & mask) {
                  set_current_state(TASK_RUNNING);
                  return 1;
            }

            set_current_state(TASK_INTERRUPTIBLE);
            schedule_timeout(sleep_length);
            if (signal_pending(current))
                  break;
      }

      set_current_state(TASK_RUNNING);
      return 0;
}

static int
wavefront_read (void)

{
      if (wavefront_wait (STAT_CAN_READ))
            return inb (dev.data_port);

      DPRINT (WF_DEBUG_DATA, "read timeout.\n");

      return -1;
}

static int
wavefront_write (unsigned char data)

{
      if (wavefront_wait (STAT_CAN_WRITE)) {
            outb (data, dev.data_port);
            return 0;
      }

      DPRINT (WF_DEBUG_DATA, "write timeout.\n");

      return -1;
}

static int
wavefront_cmd (int cmd, unsigned char *rbuf, unsigned char *wbuf)

{
      int ack;
      int i;
      int c;
      wavefront_command *wfcmd;

      if ((wfcmd = wavefront_get_command (cmd)) == (wavefront_command *) 0) {
            printk (KERN_WARNING LOGNAME "command 0x%x not supported.\n",
                  cmd);
            return 1;
      }

      /* Hack to handle the one variable-size write command. See
         wavefront_send_multisample() for the other half of this
         gross and ugly strategy.
      */

      if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
            wfcmd->write_cnt = (unsigned int) rbuf;
            rbuf = NULL;
      }

      DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
                         cmd, wfcmd->action, wfcmd->read_cnt,
                         wfcmd->write_cnt, wfcmd->need_ack);
    
      if (wavefront_write (cmd)) { 
            DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
                                         "0x%x [%s].\n",
                                         cmd, wfcmd->action);
            return 1;
      } 

      if (wfcmd->write_cnt > 0) {
            DPRINT (WF_DEBUG_DATA, "writing %d bytes "
                              "for 0x%x\n",
                              wfcmd->write_cnt, cmd);

            for (i = 0; i < wfcmd->write_cnt; i++) {
                  if (wavefront_write (wbuf[i])) {
                        DPRINT (WF_DEBUG_IO, "bad write for byte "
                                          "%d of 0x%x [%s].\n",
                                          i, cmd, wfcmd->action);
                        return 1;
                  }

                  DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
                                    i, wbuf[i]);
            }
      }

      if (wfcmd->read_cnt > 0) {
            DPRINT (WF_DEBUG_DATA, "reading %d ints "
                              "for 0x%x\n",
                              wfcmd->read_cnt, cmd);

            for (i = 0; i < wfcmd->read_cnt; i++) {

                  if ((c = wavefront_read()) == -1) {
                        DPRINT (WF_DEBUG_IO, "bad read for byte "
                                          "%d of 0x%x [%s].\n",
                                          i, cmd, wfcmd->action);
                        return 1;
                  }

                  /* Now handle errors. Lots of special cases here */
          
                  if (c == 0xff) { 
                        if ((c = wavefront_read ()) == -1) {
                              DPRINT (WF_DEBUG_IO, "bad read for "
                                                "error byte at "
                                                "read byte %d "
                                                "of 0x%x [%s].\n",
                                                i, cmd,
                                                wfcmd->action);
                              return 1;
                        }

                        /* Can you believe this madness ? */

                        if (c == 1 &&
                            wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
                              rbuf[0] = WF_ST_EMPTY;
                              return (0);

                        } else if (c == 3 &&
                                 wfcmd->cmd == WFC_UPLOAD_PATCH) {

                              return 3;

                        } else if (c == 1 &&
                                 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {

                              return 1;

                        } else {

                              DPRINT (WF_DEBUG_IO, "error %d (%s) "
                                                "during "
                                                "read for byte "
                                                "%d of 0x%x "
                                                "[%s].\n",
                                                c,
                                                wavefront_errorstr (c),
                                                i, cmd,
                                                wfcmd->action);
                              return 1;

                        }
            
            } else {
                        rbuf[i] = c;
                  }
                  
                  DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
            }
      }
      
      if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {

            DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);

            /* Some commands need an ACK, but return zero instead
               of the standard value.
            */
          
            if ((ack = wavefront_read()) == 0) {
                  ack = WF_ACK;
            }
      
            if (ack != WF_ACK) {
                  if (ack == -1) {
                        DPRINT (WF_DEBUG_IO, "cannot read ack for "
                                          "0x%x [%s].\n",
                                          cmd, wfcmd->action);
                        return 1;
            
                  } else {
                        int err = -1; /* something unknown */

                        if (ack == 0xff) { /* explicit error */
                
                              if ((err = wavefront_read ()) == -1) {
                                    DPRINT (WF_DEBUG_DATA,
                                          "cannot read err "
                                          "for 0x%x [%s].\n",
                                          cmd, wfcmd->action);
                              }
                        }
                        
                        DPRINT (WF_DEBUG_IO, "0x%x [%s] "
                              "failed (0x%x, 0x%x, %s)\n",
                              cmd, wfcmd->action, ack, err,
                              wavefront_errorstr (err));
                        
                        return -err;
                  }
            }
            
            DPRINT (WF_DEBUG_DATA, "ack received "
                              "for 0x%x [%s]\n",
                              cmd, wfcmd->action);
      } else {

            DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
                               "ACK (%d,%d,%d)\n",
                               cmd, wfcmd->action, wfcmd->read_cnt,
                               wfcmd->write_cnt, wfcmd->need_ack);
      }

      return 0;
      
}

/***********************************************************************
WaveFront: data munging   

Things here are weird. All data written to the board cannot 
have its most significant bit set. Any data item with values 
potentially > 0x7F (127) must be split across multiple bytes.

Sometimes, we need to munge numeric values that are represented on
the x86 side as 8-32 bit values. Sometimes, we need to munge data
that is represented on the x86 side as an array of bytes. The most
efficient approach to handling both cases seems to be to use 2
different functions for munging and 2 for de-munging. This avoids
weird casting and worrying about bit-level offsets.

**********************************************************************/

static 
unsigned char *
munge_int32 (unsigned int src,
           unsigned char *dst,
           unsigned int dst_size)
{
      int i;

      for (i = 0;i < dst_size; i++) {
            *dst = src & 0x7F;  /* Mask high bit of LSB */
            src = src >> 7;     /* Rotate Right 7 bits  */
                                  /* Note: we leave the upper bits in place */ 

            dst++;
      };
      return dst;
};

static int 
demunge_int32 (unsigned char* src, int src_size)

{
      int i;
      int outval = 0;
      
      for (i = src_size - 1; i >= 0; i--) {
            outval=(outval<<7)+src[i];
      }

      return outval;
};

static 
unsigned char *
munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)

{
      int i;
      unsigned int last = dst_size / 2;

      for (i = 0; i < last; i++) {
            *dst++ = src[i] & 0x7f;
            *dst++ = src[i] >> 7;
      }
      return dst;
}

static 
unsigned char *
demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)

{
      int i;
      unsigned char *end = src + src_bytes;
    
      end = src + src_bytes;

      /* NOTE: src and dst *CAN* point to the same address */

      for (i = 0; src != end; i++) {
            dst[i] = *src++;
            dst[i] |= (*src++)<<7;
      }

      return dst;
}

/***********************************************************************
WaveFront: sample, patch and program management.
***********************************************************************/

static int
wavefront_delete_sample (int sample_num)

{
      unsigned char wbuf[2];
      int x;

      wbuf[0] = sample_num & 0x7f;
      wbuf[1] = sample_num >> 7;

      if ((x = wavefront_cmd (WFC_DELETE_SAMPLE, NULL, wbuf)) == 0) {
            dev.sample_status[sample_num] = WF_ST_EMPTY;
      }

      return x;
}

static int
wavefront_get_sample_status (int assume_rom)

{
      int i;
      unsigned char rbuf[32], wbuf[32];
      unsigned int    sc_real, sc_alias, sc_multi;

      /* check sample status */
    
      if (wavefront_cmd (WFC_GET_NSAMPLES, rbuf, wbuf)) {
            printk (KERN_WARNING LOGNAME "cannot request sample count.\n");
            return -1;
      } 
    
      sc_real = sc_alias = sc_multi = dev.samples_used = 0;
    
      for (i = 0; i < WF_MAX_SAMPLE; i++) {
      
            wbuf[0] = i & 0x7f;
            wbuf[1] = i >> 7;

            if (wavefront_cmd (WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
                  printk (KERN_WARNING LOGNAME
                        "cannot identify sample "
                        "type of slot %d\n", i);
                  dev.sample_status[i] = WF_ST_EMPTY;
                  continue;
            }

            dev.sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);

            if (assume_rom) {
                  dev.sample_status[i] |= WF_SLOT_ROM;
            }

            switch (rbuf[0] & WF_ST_MASK) {
            case WF_ST_SAMPLE:
                  sc_real++;
                  break;
            case WF_ST_MULTISAMPLE:
                  sc_multi++;
                  break;
            case WF_ST_ALIAS:
                  sc_alias++;
                  break;
            case WF_ST_EMPTY:
                  break;

            default:
                  printk (KERN_WARNING LOGNAME "unknown sample type for "
                        "slot %d (0x%x)\n", 
                        i, rbuf[0]);
            }

            if (rbuf[0] != WF_ST_EMPTY) {
                  dev.samples_used++;
            } 
      }

      printk (KERN_INFO LOGNAME
            "%d samples used (%d real, %d aliases, %d multi), "
            "%d empty\n", dev.samples_used, sc_real, sc_alias, sc_multi,
            WF_MAX_SAMPLE - dev.samples_used);


      return (0);

}

static int
wavefront_get_patch_status (void)

{
      unsigned char patchbuf[WF_PATCH_BYTES];
      unsigned char patchnum[2];
      wavefront_patch *p;
      int i, x, cnt, cnt2;

      for (i = 0; i < WF_MAX_PATCH; i++) {
            patchnum[0] = i & 0x7f;
            patchnum[1] = i >> 7;

            if ((x = wavefront_cmd (WFC_UPLOAD_PATCH, patchbuf,
                              patchnum)) == 0) {

                  dev.patch_status[i] |= WF_SLOT_FILLED;
                  p = (wavefront_patch *) patchbuf;
                  dev.sample_status
                        [p->sample_number|(p->sample_msb<<7)] |=
                        WF_SLOT_USED;
          
            } else if (x == 3) { /* Bad patch number */
                  dev.patch_status[i] = 0;
            } else {
                  printk (KERN_ERR LOGNAME "upload patch "
                        "error 0x%x\n", x);
                  dev.patch_status[i] = 0;
                  return 1;
            }
      }

      /* program status has already filled in slot_used bits */

      for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
            if (dev.patch_status[i] & WF_SLOT_FILLED) {
                  cnt++;
            }
            if (dev.patch_status[i] & WF_SLOT_USED) {
                  cnt2++;
            }
      
      }
      printk (KERN_INFO LOGNAME
            "%d patch slots filled, %d in use\n", cnt, cnt2);

      return (0);
}

static int
wavefront_get_program_status (void)

{
      unsigned char progbuf[WF_PROGRAM_BYTES];
      wavefront_program prog;
      unsigned char prognum;
      int i, x, l, cnt;

      for (i = 0; i < WF_MAX_PROGRAM; i++) {
            prognum = i;

            if ((x = wavefront_cmd (WFC_UPLOAD_PROGRAM, progbuf,
                              &prognum)) == 0) {

                  dev.prog_status[i] |= WF_SLOT_USED;

                  demunge_buf (progbuf, (unsigned char *) &prog,
                             WF_PROGRAM_BYTES);

                  for (l = 0; l < WF_NUM_LAYERS; l++) {
                        if (prog.layer[l].mute) {
                              dev.patch_status
                                    [prog.layer[l].patch_number] |=
                                    WF_SLOT_USED;
                        }
                  }
            } else if (x == 1) { /* Bad program number */
                  dev.prog_status[i] = 0;
            } else {
                  printk (KERN_ERR LOGNAME "upload program "
                        "error 0x%x\n", x);
                  dev.prog_status[i] = 0;
            }
      }

      for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
            if (dev.prog_status[i]) {
                  cnt++;
            }
      }

      printk (KERN_INFO LOGNAME "%d programs slots in use\n", cnt);

      return (0);
}

static int
wavefront_send_patch (wavefront_patch_info *header)

{
      unsigned char buf[WF_PATCH_BYTES+2];
      unsigned char *bptr;

      DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
                              header->number);

      dev.patch_status[header->number] |= WF_SLOT_FILLED;

      bptr = buf;
      bptr = munge_int32 (header->number, buf, 2);
      munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
    
      if (wavefront_cmd (WFC_DOWNLOAD_PATCH, NULL, buf)) {
            printk (KERN_ERR LOGNAME "download patch failed\n");
            return -(EIO);
      }

      return (0);
}

static int
wavefront_send_program (wavefront_patch_info *header)

{
      unsigned char buf[WF_PROGRAM_BYTES+1];
      int i;

      DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
            header->number);

      dev.prog_status[header->number] = WF_SLOT_USED;

      /* XXX need to zero existing SLOT_USED bit for program_status[i]
         where `i' is the program that's being (potentially) overwritten.
      */
    
      for (i = 0; i < WF_NUM_LAYERS; i++) {
            if (header->hdr.pr.layer[i].mute) {
                  dev.patch_status[header->hdr.pr.layer[i].patch_number] |=
                        WF_SLOT_USED;

                  /* XXX need to mark SLOT_USED for sample used by
                     patch_number, but this means we have to load it. Ick.
                  */
            }
      }

      buf[0] = header->number;
      munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
    
      if (wavefront_cmd (WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
            printk (KERN_WARNING LOGNAME "download patch failed\n");    
            return -(EIO);
      }

      return (0);
}

static int
wavefront_freemem (void)

{
      char rbuf[8];

      if (wavefront_cmd (WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
            printk (KERN_WARNING LOGNAME "can't get memory stats.\n");
            return -1;
      } else {
            return demunge_int32 (rbuf, 4);
      }
}

static int
wavefront_send_sample (wavefront_patch_info *header,
                   UINT16 __user *dataptr,
                   int data_is_unsigned)

{
      /* samples are downloaded via a 16-bit wide i/o port
         (you could think of it as 2 adjacent 8-bit wide ports
         but its less efficient that way). therefore, all
         the blocksizes and so forth listed in the documentation,
         and used conventionally to refer to sample sizes,
         which are given in 8-bit units (bytes), need to be
         divided by 2.
        */

      UINT16 sample_short;
      UINT32 length;
      UINT16 __user *data_end = NULL;
      unsigned int i;
      const int max_blksize = 4096/2;
      unsigned int written;
      unsigned int blocksize;
      int dma_ack;
      int blocknum;
      unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
      unsigned char *shptr;
      int skip = 0;
      int initial_skip = 0;

      DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
                              "type %d, %d bytes from %p\n",
                              header->size ? "" : "header ", 
                              header->number, header->subkey,
                              header->size,
                              header->dataptr);

      if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
            int x;

            if ((x = wavefront_find_free_sample ()) < 0) {
                  return -ENOMEM;
            }
            printk (KERN_DEBUG LOGNAME "unspecified sample => %d\n", x);
            header->number = x;
      }

      if (header->size) {

            /* XXX it's a debatable point whether or not RDONLY semantics
               on the ROM samples should cover just the sample data or
               the sample header. For now, it only covers the sample data,
               so anyone is free at all times to rewrite sample headers.

               My reason for this is that we have the sample headers
               available in the WFB file for General MIDI, and so these
               can always be reset if needed. The sample data, however,
               cannot be recovered without a complete reset and firmware
               reload of the ICS2115, which is a very expensive operation.

               So, doing things this way allows us to honor the notion of
               "RESETSAMPLES" reasonably cheaply. Note however, that this
               is done purely at user level: there is no WFB parser in
               this driver, and so a complete reset (back to General MIDI,
               or theoretically some other configuration) is the
               responsibility of the user level library. 

               To try to do this in the kernel would be a little
               crazy: we'd need 158K of kernel space just to hold
               a copy of the patch/program/sample header data.
            */

            if (dev.rom_samples_rdonly) {
                  if (dev.sample_status[header->number] & WF_SLOT_ROM) {
                        printk (KERN_ERR LOGNAME "sample slot %d "
                              "write protected\n",
                              header->number);
                        return -EACCES;
                  }
            }

            wavefront_delete_sample (header->number);
      }

      if (header->size) {
            dev.freemem = wavefront_freemem ();

            if (dev.freemem < header->size) {
                  printk (KERN_ERR LOGNAME
                        "insufficient memory to "
                        "load %d byte sample.\n",
                        header->size);
                  return -ENOMEM;
            }
      
      }

      skip = WF_GET_CHANNEL(&header->hdr.s);

      if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
            printk (KERN_ERR LOGNAME "channel selection only "
                  "possible on 16-bit samples");
            return -(EINVAL);
      }

      switch (skip) {
      case 0:
            initial_skip = 0;
            skip = 1;
            break;
      case 1:
            initial_skip = 0;
            skip = 2;
            break;
      case 2:
            initial_skip = 1;
            skip = 2;
            break;
      case 3:
            initial_skip = 2;
            skip = 3;
            break;
      case 4:
            initial_skip = 3;
            skip = 4;
            break;
      case 5:
            initial_skip = 4;
            skip = 5;
            break;
      case 6:
            initial_skip = 5;
            skip = 6;
            break;
      }

      DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
                              "initial skip = %d, skip = %d\n",
                              WF_GET_CHANNEL (&header->hdr.s),
                              initial_skip, skip);
    
      /* Be safe, and zero the "Unused" bits ... */

      WF_SET_CHANNEL(&header->hdr.s, 0);

      /* adjust size for 16 bit samples by dividing by two.  We always
         send 16 bits per write, even for 8 bit samples, so the length
         is always half the size of the sample data in bytes.
      */

      length = header->size / 2;

      /* the data we're sent has not been munged, and in fact, the
         header we have to send isn't just a munged copy either.
         so, build the sample header right here.
      */

      shptr = &sample_hdr[0];

      shptr = munge_int32 (header->number, shptr, 2);

      if (header->size) {
            shptr = munge_int32 (length, shptr, 4);
      }

      /* Yes, a 4 byte result doesn't contain all of the offset bits,
         but the offset only uses 24 bits.
      */

      shptr = munge_int32 (*((UINT32 *) &header->hdr.s.sampleStartOffset),
                       shptr, 4);
      shptr = munge_int32 (*((UINT32 *) &header->hdr.s.loopStartOffset),
                       shptr, 4);
      shptr = munge_int32 (*((UINT32 *) &header->hdr.s.loopEndOffset),
                       shptr, 4);
      shptr = munge_int32 (*((UINT32 *) &header->hdr.s.sampleEndOffset),
                       shptr, 4);
      
      /* This one is truly weird. What kind of weirdo decided that in
         a system dominated by 16 and 32 bit integers, they would use
         a just 12 bits ?
      */
      
      shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
      
      /* Why is this nybblified, when the MSB is *always* zero ? 
         Anyway, we can't take address of bitfield, so make a
         good-faith guess at where it starts.
      */
      
      shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
                       shptr, 2);

      if (wavefront_cmd (header->size ?
                     WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
                     NULL, sample_hdr)) {
            printk (KERN_WARNING LOGNAME "sample %sdownload refused.\n",
                  header->size ? "" : "header ");
            return -(EIO);
      }

      if (header->size == 0) {
            goto sent; /* Sorry. Just had to have one somewhere */
      }
    
      data_end = dataptr + length;

      /* Do any initial skip over an unused channel's data */

      dataptr += initial_skip;
    
      for (written = 0, blocknum = 0;
           written < length; written += max_blksize, blocknum++) {
      
            if ((length - written) > max_blksize) {
                  blocksize = max_blksize;
            } else {
                  /* round to nearest 16-byte value */
                  blocksize = ((length-written+7)&~0x7);
            }

            if (wavefront_cmd (WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
                  printk (KERN_WARNING LOGNAME "download block "
                        "request refused.\n");
                  return -(EIO);
            }

            for (i = 0; i < blocksize; i++) {

                  if (dataptr < data_end) {
            
                        __get_user (sample_short, dataptr);
                        dataptr += skip;
            
                        if (data_is_unsigned) { /* GUS ? */

                              if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
                  
                                    /* 8 bit sample
                                     resolution, sign
                                     extend both bytes.
                                    */
                  
                                    ((unsigned char*)
                                     &sample_short)[0] += 0x7f;
                                    ((unsigned char*)
                                     &sample_short)[1] += 0x7f;
                  
                              } else {
                  
                                    /* 16 bit sample
                                     resolution, sign
                                     extend the MSB.
                                    */
                  
                                    sample_short += 0x7fff;
                              }
                        }

                  } else {

                        /* In padding section of final block:

                           Don't fetch unsupplied data from
                           user space, just continue with
                           whatever the final value was.
                        */
                  }
          
                  if (i < blocksize - 1) {
                        outw (sample_short, dev.block_port);
                  } else {
                        outw (sample_short, dev.last_block_port);
                  }
            }

            /* Get "DMA page acknowledge", even though its really
               nothing to do with DMA at all.
            */
      
            if ((dma_ack = wavefront_read ()) != WF_DMA_ACK) {
                  if (dma_ack == -1) {
                        printk (KERN_ERR LOGNAME "upload sample "
                              "DMA ack timeout\n");
                        return -(EIO);
                  } else {
                        printk (KERN_ERR LOGNAME "upload sample "
                              "DMA ack error 0x%x\n",
                              dma_ack);
                        return -(EIO);
                  }
            }
      }

      dev.sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);

      /* Note, label is here because sending the sample header shouldn't
         alter the sample_status info at all.
      */

 sent:
      return (0);
}

static int
wavefront_send_alias (wavefront_patch_info *header)

{
      unsigned char alias_hdr[WF_ALIAS_BYTES];

      DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
                              "alias for %d\n",
                              header->number,
                              header->hdr.a.OriginalSample);
    
      munge_int32 (header->number, &alias_hdr[0], 2);
      munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
      munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
                 &alias_hdr[4], 4);
      munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
                 &alias_hdr[8], 4);
      munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
                 &alias_hdr[12], 4);
      munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
                 &alias_hdr[16], 4);
      munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
      munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);

      if (wavefront_cmd (WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
            printk (KERN_ERR LOGNAME "download alias failed.\n");
            return -(EIO);
      }

      dev.sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);

      return (0);
}

static int
wavefront_send_multisample (wavefront_patch_info *header)
{
      int i;
      int num_samples;
      unsigned char msample_hdr[WF_MSAMPLE_BYTES];

      munge_int32 (header->number, &msample_hdr[0], 2);

      /* You'll recall at this point that the "number of samples" value
         in a wavefront_multisample struct is actually the log2 of the
         real number of samples.
      */

      num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
      msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;

      DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
                              header->number,
                              header->hdr.ms.NumberOfSamples,
                              num_samples);

      for (i = 0; i < num_samples; i++) {
            DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
                   i, header->hdr.ms.SampleNumber[i]);
            munge_int32 (header->hdr.ms.SampleNumber[i],
                 &msample_hdr[3+(i*2)], 2);
      }
    
      /* Need a hack here to pass in the number of bytes
         to be written to the synth. This is ugly, and perhaps
         one day, I'll fix it.
      */

      if (wavefront_cmd (WFC_DOWNLOAD_MULTISAMPLE, 
                     (unsigned char *) ((num_samples*2)+3),
                     msample_hdr)) {
            printk (KERN_ERR LOGNAME "download of multisample failed.\n");
            return -(EIO);
      }

      dev.sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);

      return (0);
}

static int
wavefront_fetch_multisample (wavefront_patch_info *header)
{
      int i;
      unsigned char log_ns[1];
      unsigned char number[2];
      int num_samples;

      munge_int32 (header->number, number, 2);
    
      if (wavefront_cmd (WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
            printk (KERN_ERR LOGNAME "upload multisample failed.\n");
            return -(EIO);
      }
    
      DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
                        header->number, log_ns[0]);

      header->hdr.ms.NumberOfSamples = log_ns[0];

      /* get the number of samples ... */

      num_samples = (1 << log_ns[0]);
    
      for (i = 0; i < num_samples; i++) {
            s8 d[2];
      
            if ((d[0] = wavefront_read ()) == -1) {
                  printk (KERN_ERR LOGNAME "upload multisample failed "
                        "during sample loop.\n");
                  return -(EIO);
            }

            if ((d[1] = wavefront_read ()) == -1) {
                  printk (KERN_ERR LOGNAME "upload multisample failed "
                        "during sample loop.\n");
                  return -(EIO);
            }
      
            header->hdr.ms.SampleNumber[i] =
                  demunge_int32 ((unsigned char *) d, 2);
      
            DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
                              i, header->hdr.ms.SampleNumber[i]);
      }

      return (0);
}


static int
wavefront_send_drum (wavefront_patch_info *header)

{
      unsigned char drumbuf[WF_DRUM_BYTES];
      wavefront_drum *drum = &header->hdr.d;
      int i;

      DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
            "note %d, patch = %d\n", 
            header->number, drum->PatchNumber);

      drumbuf[0] = header->number & 0x7f;

      for (i = 0; i < 4; i++) {
            munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
      }

      if (wavefront_cmd (WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
            printk (KERN_ERR LOGNAME "download drum failed.\n");
            return -(EIO);
      }

      return (0);
}

static int 
wavefront_find_free_sample (void)

{
      int i;

      for (i = 0; i < WF_MAX_SAMPLE; i++) {
            if (!(dev.sample_status[i] & WF_SLOT_FILLED)) {
                  return i;
            }
      }
      printk (KERN_WARNING LOGNAME "no free sample slots!\n");
      return -1;
}

static int 
wavefront_find_free_patch (void)

{
      int i;

      for (i = 0; i < WF_MAX_PATCH; i++) {
            if (!(dev.patch_status[i] & WF_SLOT_FILLED)) {
                  return i;
            }
      }
      printk (KERN_WARNING LOGNAME "no free patch slots!\n");
      return -1;
}

static int 
log2_2048(int n)

{
      int tbl[]={0, 0, 2048, 3246, 4096, 4755, 5294, 5749, 6143,
               6492, 6803, 7084, 7342, 7578, 7797, 8001, 8192,
               8371, 8540, 8699, 8851, 8995, 9132, 9264, 9390,
               9510, 9626, 9738, 9845, 9949, 10049, 10146};
      int i;

      /* Returns 2048*log2(n) */

      /* FIXME: this is like doing integer math
         on quantum particles (RuN) */

      i=0;
      while(n>=32*256) {
            n>>=8;
            i+=2048*8;
      }
      while(n>=32) {
            n>>=1;
            i+=2048;
      }
      i+=tbl[n];
      return(i);
}

static int
wavefront_load_gus_patch (int devno, int format, const char __user *addr,
                    int offs, int count, int pmgr_flag)
{
      struct patch_info guspatch;
      wavefront_patch_info *samp, *pat, *prog;
      wavefront_patch *patp;
      wavefront_sample *sampp;
      wavefront_program *progp;

      int i,base_note;
      long sizeof_patch;
      int rc = -ENOMEM;

      samp = kmalloc(3 * sizeof(wavefront_patch_info), GFP_KERNEL);
      if (!samp)
            goto free_fail;
      pat = samp + 1;
      prog = pat + 1;

      /* Copy in the header of the GUS patch */

      sizeof_patch = (long) &guspatch.data[0] - (long) &guspatch; 
      if (copy_from_user(&((char *) &guspatch)[offs],
                     &(addr)[offs], sizeof_patch - offs)) {
            rc = -EFAULT;
            goto free_fail;
      }

      if ((i = wavefront_find_free_patch ()) == -1) {
            rc = -EBUSY;
            goto free_fail;
      }
      pat->number = i;
      pat->subkey = WF_ST_PATCH;
      patp = &pat->hdr.p;

      if ((i = wavefront_find_free_sample ()) == -1) {
            rc = -EBUSY;
            goto free_fail;
      }
      samp->number = i;
      samp->subkey = WF_ST_SAMPLE;
      samp->size = guspatch.len;
      sampp = &samp->hdr.s;

      prog->number = guspatch.instr_no;
      progp = &prog->hdr.pr;

      /* Setup the patch structure */

      patp->amplitude_bias=guspatch.volume;
      patp->portamento=0;
      patp->sample_number= samp->number & 0xff;
      patp->sample_msb= samp->number >> 8;
      patp->pitch_bend= /*12*/ 0;
      patp->mono=1;
      patp->retrigger=1;
      patp->nohold=(guspatch.mode & WAVE_SUSTAIN_ON) ? 0:1;
      patp->frequency_bias=0;
      patp->restart=0;
      patp->reuse=0;
      patp->reset_lfo=1;
      patp->fm_src2=0;
      patp->fm_src1=WF_MOD_MOD_WHEEL;
      patp->am_src=WF_MOD_PRESSURE;
      patp->am_amount=127;
      patp->fc1_mod_amount=0;
      patp->fc2_mod_amount=0; 
      patp->fm_amount1=0;
      patp->fm_amount2=0;
      patp->envelope1.attack_level=127;
      patp->envelope1.decay1_level=127;
      patp->envelope1.decay2_level=127;
      patp->envelope1.sustain_level=127;
      patp->envelope1.release_level=0;
      patp->envelope2.attack_velocity=127;
      patp->envelope2.attack_level=127;
      patp->envelope2.decay1_level=127;
      patp->envelope2.decay2_level=127;
      patp->envelope2.sustain_level=127;
      patp->envelope2.release_level=0;
      patp->envelope2.attack_velocity=127;
      patp->randomizer=0;

      /* Program for this patch */

      progp->layer[0].patch_number= pat->number; /* XXX is this right ? */
      progp->layer[0].mute=1;
      progp->layer[0].pan_or_mod=1;
      progp->layer[0].pan=7;
      progp->layer[0].mix_level=127  /* guspatch.volume */;
      progp->layer[0].split_type=0;
      progp->layer[0].split_point=0;
      progp->layer[0].play_below=0;

      for (i = 1; i < 4; i++) {
            progp->layer[i].mute=0;
      }

      /* Sample data */

      sampp->SampleResolution=((~guspatch.mode & WAVE_16_BITS)<<1);

      for (base_note=0;
           note_to_freq (base_note) < guspatch.base_note;
           base_note++);

      if ((guspatch.base_note-note_to_freq(base_note))
          >(note_to_freq(base_note)-guspatch.base_note))
            base_note++;

      printk(KERN_DEBUG "ref freq=%d,base note=%d\n",
             guspatch.base_freq,
             base_note);

      sampp->FrequencyBias = (29550 - log2_2048(guspatch.base_freq)
                        + base_note*171);
      printk(KERN_DEBUG "Freq Bias is %d\n", sampp->FrequencyBias);
      sampp->Loop=(guspatch.mode & WAVE_LOOPING) ? 1:0;
      sampp->sampleStartOffset.Fraction=0;
      sampp->sampleStartOffset.Integer=0;
      sampp->loopStartOffset.Fraction=0;
      sampp->loopStartOffset.Integer=guspatch.loop_start
            >>((guspatch.mode&WAVE_16_BITS) ? 1:0);
      sampp->loopEndOffset.Fraction=0;
      sampp->loopEndOffset.Integer=guspatch.loop_end
            >>((guspatch.mode&WAVE_16_BITS) ? 1:0);
      sampp->sampleEndOffset.Fraction=0;
      sampp->sampleEndOffset.Integer=guspatch.len >> (guspatch.mode&1);
      sampp->Bidirectional=(guspatch.mode&WAVE_BIDIR_LOOP) ? 1:0;
      sampp->Reverse=(guspatch.mode&WAVE_LOOP_BACK) ? 1:0;

      /* Now ship it down */

      wavefront_send_sample (samp,
                         (unsigned short __user *) &(addr)[sizeof_patch],
                         (guspatch.mode & WAVE_UNSIGNED) ? 1:0);
      wavefront_send_patch (pat);
      wavefront_send_program (prog);

      /* Now pan as best we can ... use the slave/internal MIDI device
         number if it exists (since it talks to the WaveFront), or the
         master otherwise.
      */

      if (dev.mididev > 0) {
            midi_synth_controller (dev.mididev, guspatch.instr_no, 10,
                               ((guspatch.panning << 4) > 127) ?
                               127 : (guspatch.panning << 4));
      }
      rc = 0;

free_fail:
      kfree(samp);
      return rc;
}

static int
wavefront_load_patch (const char __user *addr)


{
      wavefront_patch_info header;
      
      if (copy_from_user (&header, addr, sizeof(wavefront_patch_info) -
                      sizeof(wavefront_any))) {
            printk (KERN_WARNING LOGNAME "bad address for load patch.\n");
            return -EFAULT;
      }

      DPRINT (WF_DEBUG_LOAD_PATCH, "download "
                              "Sample type: %d "
                              "Sample number: %d "
                              "Sample size: %d\n",
                              header.subkey,
                              header.number,
                              header.size);

      switch (header.subkey) {
      case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */

            if (copy_from_user((unsigned char *) &header.hdr.s,
                           (unsigned char __user *) header.hdrptr,
                           sizeof (wavefront_sample)))
                  return -EFAULT;

            return wavefront_send_sample (&header, header.dataptr, 0);

      case WF_ST_MULTISAMPLE:

            if (copy_from_user(&header.hdr.s, header.hdrptr,
                           sizeof(wavefront_multisample)))
                  return -EFAULT;

            return wavefront_send_multisample (&header);


      case WF_ST_ALIAS:

            if (copy_from_user(&header.hdr.a, header.hdrptr,
                           sizeof (wavefront_alias)))
                  return -EFAULT;

            return wavefront_send_alias (&header);

      case WF_ST_DRUM:
            if (copy_from_user(&header.hdr.d, header.hdrptr,
                           sizeof (wavefront_drum)))
                  return -EFAULT;

            return wavefront_send_drum (&header);

      case WF_ST_PATCH:
            if (copy_from_user(&header.hdr.p, header.hdrptr,
                           sizeof (wavefront_patch)))
                  return -EFAULT;

            return wavefront_send_patch (&header);

      case WF_ST_PROGRAM:
            if (copy_from_user(&header.hdr.pr, header.hdrptr,
                           sizeof (wavefront_program)))
                  return -EFAULT;

            return wavefront_send_program (&header);

      default:
            printk (KERN_ERR LOGNAME "unknown patch type %d.\n",
                  header.subkey);
            return -(EINVAL);
      }

      return 0;
}

/***********************************************************************
WaveFront: /dev/sequencer{,2} and other hardware-dependent interfaces
***********************************************************************/

static void
process_sample_hdr (UCHAR8 *buf)

{
      wavefront_sample s;
      UCHAR8 *ptr;

      ptr = buf;

      /* The board doesn't send us an exact copy of a "wavefront_sample"
         in response to an Upload Sample Header command. Instead, we 
         have to convert the data format back into our data structure,
         just as in the Download Sample command, where we have to do
         something very similar in the reverse direction.
      */

      *((UINT32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
      *((UINT32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
      *((UINT32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
      *((UINT32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
      *((UINT32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;

      s.SampleResolution = *ptr & 0x3;
      s.Loop = *ptr & 0x8;
      s.Bidirectional = *ptr & 0x10;
      s.Reverse = *ptr & 0x40;

      /* Now copy it back to where it came from */

      memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
}

static int
wavefront_synth_control (int cmd, wavefront_control *wc)

{
      unsigned char patchnumbuf[2];
      int i;

      DPRINT (WF_DEBUG_CMD, "synth control with "
            "cmd 0x%x\n", wc->cmd);

      /* Pre-handling of or for various commands */

      switch (wc->cmd) {
      case WFC_DISABLE_INTERRUPTS:
            printk (KERN_INFO LOGNAME "interrupts disabled.\n");
            outb (0x80|0x20, dev.control_port);
            dev.interrupts_on = 0;
            return 0;

      case WFC_ENABLE_INTERRUPTS:
            printk (KERN_INFO LOGNAME "interrupts enabled.\n");
            outb (0x80|0x40|0x20, dev.control_port);
            dev.interrupts_on = 1;
            return 0;

      case WFC_INTERRUPT_STATUS:
            wc->rbuf[0] = dev.interrupts_on;
            return 0;

      case WFC_ROMSAMPLES_RDONLY:
            dev.rom_samples_rdonly = wc->wbuf[0];
            wc->status = 0;
            return 0;

      case WFC_IDENTIFY_SLOT_TYPE:
            i = wc->wbuf[0] | (wc->wbuf[1] << 7);
            if (i <0 || i >= WF_MAX_SAMPLE) {
                  printk (KERN_WARNING LOGNAME "invalid slot ID %d\n",
                        i);
                  wc->status = EINVAL;
                  return 0;
            }
            wc->rbuf[0] = dev.sample_status[i];
            wc->status = 0;
            return 0;

      case WFC_DEBUG_DRIVER:
            dev.debug = wc->wbuf[0];
            printk (KERN_INFO LOGNAME "debug = 0x%x\n", dev.debug);
            return 0;

      case WFC_FX_IOCTL:
            wffx_ioctl ((wavefront_fx_info *) &wc->wbuf[0]);
            return 0;

      case WFC_UPLOAD_PATCH:
            munge_int32 (*((UINT32 *) wc->wbuf), patchnumbuf, 2);
            memcpy (wc->wbuf, patchnumbuf, 2);
            break;

      case WFC_UPLOAD_MULTISAMPLE:
            /* multisamples have to be handled differently, and
               cannot be dealt with properly by wavefront_cmd() alone.
            */
            wc->status = wavefront_fetch_multisample
                  ((wavefront_patch_info *) wc->rbuf);
            return 0;

      case WFC_UPLOAD_SAMPLE_ALIAS:
            printk (KERN_INFO LOGNAME "support for sample alias upload "
                  "being considered.\n");
            wc->status = EINVAL;
            return -EINVAL;
      }

      wc->status = wavefront_cmd (wc->cmd, wc->rbuf, wc->wbuf);

      /* Post-handling of certain commands.

         In particular, if the command was an upload, demunge the data
         so that the user-level doesn't have to think about it.
      */

      if (wc->status == 0) {
            switch (wc->cmd) {
                  /* intercept any freemem requests so that we know
                     we are always current with the user-level view
                     of things.
                  */

            case WFC_REPORT_FREE_MEMORY:
                  dev.freemem = demunge_int32 (wc->rbuf, 4);
                  break;

            case WFC_UPLOAD_PATCH:
                  demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
                  break;

            case WFC_UPLOAD_PROGRAM:
                  demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
                  break;

            case WFC_UPLOAD_EDRUM_PROGRAM:
                  demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
                  break;

            case WFC_UPLOAD_SAMPLE_HEADER:
                  process_sample_hdr (wc->rbuf);
                  break;

            case WFC_UPLOAD_SAMPLE_ALIAS:
                  printk (KERN_INFO LOGNAME "support for "
                        "sample aliases still "
                        "being considered.\n");
                  break;

            case WFC_VMIDI_OFF:
                  if (virtual_midi_disable () < 0) {
                        return -(EIO);
                  }
                  break;

            case WFC_VMIDI_ON:
                  if (virtual_midi_enable () < 0) {
                        return -(EIO);
                  }
                  break;
            }
      }

      return 0;
}


/***********************************************************************/
/* WaveFront: Linux file system interface (for access via raw synth)    */
/***********************************************************************/

static int 
wavefront_open (struct inode *inode, struct file *file)
{
      /* XXX fix me */
      dev.opened = file->f_flags;
      return 0;
}

static int
wavefront_release(struct inode *inode, struct file *file)
{
      lock_kernel();
      dev.opened = 0;
      dev.debug = 0;
      unlock_kernel();
      return 0;
}

static int
wavefront_ioctl(struct inode *inode, struct file *file,
            unsigned int cmd, unsigned long arg)
{
      wavefront_control wc;
      int err;

      switch (cmd) {

      case WFCTL_WFCMD:
            if (copy_from_user(&wc, (void __user *) arg, sizeof (wc)))
                  return -EFAULT;
            
            if ((err = wavefront_synth_control (cmd, &wc)) == 0) {
                  if (copy_to_user ((void __user *) arg, &wc, sizeof (wc)))
                        return -EFAULT;
            }

            return err;
            
      case WFCTL_LOAD_SPP:
            return wavefront_load_patch ((const char __user *) arg);
            
      default:
            printk (KERN_WARNING LOGNAME "invalid ioctl %#x\n", cmd);
            return -(EINVAL);

      }
      return 0;
}

static /*const*/ struct file_operations wavefront_fops = {
      .owner            = THIS_MODULE,
      .llseek           = no_llseek,
      .ioctl            = wavefront_ioctl,
      .open       = wavefront_open,
      .release    = wavefront_release,
};


/***********************************************************************/
/* WaveFront: OSS installation and support interface                   */
/***********************************************************************/

#if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ

static struct synth_info wavefront_info =
{"Turtle Beach WaveFront", 0, SYNTH_TYPE_SAMPLE, SAMPLE_TYPE_WAVEFRONT,
 0, 32, 0, 0, SYNTH_CAP_INPUT};

static int
wavefront_oss_open (int devno, int mode)

{
      dev.opened = mode;
      return 0;
}

static void
wavefront_oss_close (int devno)

{
      dev.opened = 0;
      dev.debug = 0;
      return;
}

static int
wavefront_oss_ioctl (int devno, unsigned int cmd, void __user * arg)

{
      wavefront_control wc;
      int err;

      switch (cmd) {
      case SNDCTL_SYNTH_INFO:
            if(copy_to_user(arg, &wavefront_info, sizeof (wavefront_info)))
                  return -EFAULT;
            return 0;

      case SNDCTL_SEQ_RESETSAMPLES:
//          printk (KERN_WARNING LOGNAME "driver cannot reset samples.\n");
            return 0; /* don't force an error */

      case SNDCTL_SEQ_PERCMODE:
            return 0; /* don't force an error */

      case SNDCTL_SYNTH_MEMAVL:
            if ((dev.freemem = wavefront_freemem ()) < 0) {
                  printk (KERN_ERR LOGNAME "cannot get memory size\n");
                  return -EIO;
            } else {
                  return dev.freemem;
            }
            break;

      case SNDCTL_SYNTH_CONTROL:
            if(copy_from_user (&wc, arg, sizeof (wc)))
                  err = -EFAULT;
            else if ((err = wavefront_synth_control (cmd, &wc)) == 0) {
                  if(copy_to_user (arg, &wc, sizeof (wc)))
                        err = -EFAULT;
            }

            return err;

      default:
            return -(EINVAL);
      }
}

static int
wavefront_oss_load_patch (int devno, int format, const char __user *addr,
                    int offs, int count, int pmgr_flag)
{

      if (format == SYSEX_PATCH) {  /* Handled by midi_synth.c */
            if (midi_load_patch == NULL) {
                  printk (KERN_ERR LOGNAME
                        "SYSEX not loadable: "
                        "no midi patch loader!\n");
                  return -(EINVAL);
            }

            return midi_load_patch (devno, format, addr,
                              offs, count, pmgr_flag);

      } else if (format == GUS_PATCH) {
            return wavefront_load_gus_patch (devno, format,
                                     addr, offs, count, pmgr_flag);

      } else if (format != WAVEFRONT_PATCH) {
            printk (KERN_ERR LOGNAME "unknown patch format %d\n", format);
            return -(EINVAL);
      }

      if (count < sizeof (wavefront_patch_info)) {
            printk (KERN_ERR LOGNAME "sample header too short\n");
            return -(EINVAL);
      }

      /* "addr" points to a user-space wavefront_patch_info */

      return wavefront_load_patch (addr);
}     

static struct synth_operations wavefront_operations =
{
      .owner            = THIS_MODULE,
      .id         = "WaveFront",
      .info       = &wavefront_info,
      .midi_dev   = 0,
      .synth_type = SYNTH_TYPE_SAMPLE,
      .synth_subtype    = SAMPLE_TYPE_WAVEFRONT,
      .open       = wavefront_oss_open,
      .close            = wavefront_oss_close,
      .ioctl            = wavefront_oss_ioctl,
      .kill_note  = midi_synth_kill_note,
      .start_note = midi_synth_start_note,
      .set_instr  = midi_synth_set_instr,
      .reset            = midi_synth_reset,
      .load_patch = midi_synth_load_patch,
      .aftertouch = midi_synth_aftertouch,
      .controller = midi_synth_controller,
      .panning    = midi_synth_panning,
      .bender           = midi_synth_bender,
      .setup_voice      = midi_synth_setup_voice
};
#endif /* OSS_SUPPORT_SEQ */

#if OSS_SUPPORT_LEVEL & OSS_SUPPORT_STATIC_INSTALL

static void __init attach_wavefront (struct address_info *hw_config)
{
    (void) install_wavefront ();
}

static int __init probe_wavefront (struct address_info *hw_config)
{
    return !detect_wavefront (hw_config->irq, hw_config->io_base);
}

static void __exit unload_wavefront (struct address_info *hw_config) 
{
    (void) uninstall_wavefront ();
}

#endif /* OSS_SUPPORT_STATIC_INSTALL */

/***********************************************************************/
/* WaveFront: Linux modular sound kernel installation interface        */
/***********************************************************************/

static irqreturn_t
wavefrontintr(int irq, void *dev_id, struct pt_regs *dummy)
{
      struct wf_config *hw = dev_id;

      /*
         Some comments on interrupts. I attempted a version of this
         driver that used interrupts throughout the code instead of
         doing busy and/or sleep-waiting. Alas, it appears that once
         the Motorola firmware is downloaded, the card *never*
         generates an RX interrupt. These are successfully generated
         during firmware loading, and after that wavefront_status()
         reports that an interrupt is pending on the card from time
         to time, but it never seems to be delivered to this
         driver. Note also that wavefront_status() continues to
         report that RX interrupts are enabled, suggesting that I
         didn't goof up and disable them by mistake.

         Thus, I stepped back to a prior version of
         wavefront_wait(), the only place where this really
         matters. Its sad, but I've looked through the code to check
         on things, and I really feel certain that the Motorola
         firmware prevents RX-ready interrupts.
      */

      if ((wavefront_status() & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
            return IRQ_NONE;
      }

      hw->irq_ok = 1;
      hw->irq_cnt++;
      wake_up_interruptible (&hw->interrupt_sleeper);
      return IRQ_HANDLED;
}

/* STATUS REGISTER 

0 Host Rx Interrupt Enable (1=Enabled)
1 Host Rx Register Full (1=Full)
2 Host Rx Interrupt Pending (1=Interrupt)
3 Unused
4 Host Tx Interrupt (1=Enabled)
5 Host Tx Register empty (1=Empty)
6 Host Tx Interrupt Pending (1=Interrupt)
7 Unused
*/

static int
wavefront_interrupt_bits (int irq)

{
      int bits;

      switch (irq) {
      case 9:
            bits = 0x00;
            break;
      case 5:
            bits = 0x08;
            break;
      case 12:
            bits = 0x10;
            break;
      case 15:
            bits = 0x18;
            break;
      
      default:
            printk (KERN_WARNING LOGNAME "invalid IRQ %d\n", irq);
            bits = -1;
      }

      return bits;
}

static void
wavefront_should_cause_interrupt (int val, int port, int timeout)

{
      unsigned long flags;

      /* this will not help on SMP - but at least it compiles */
      spin_lock_irqsave(&lock, flags);
      dev.irq_ok = 0;
      outb (val,port);
      interruptible_sleep_on_timeout (&dev.interrupt_sleeper, timeout);
      spin_unlock_irqrestore(&lock,flags);
}

static int __init wavefront_hw_reset (void)
{
      int bits;
      int hwv[2];
      unsigned long irq_mask;
      short reported_irq;

      /* IRQ already checked in init_module() */

      bits = wavefront_interrupt_bits (dev.irq);

      printk (KERN_DEBUG LOGNAME "autodetecting WaveFront IRQ\n");

      irq_mask = probe_irq_on ();

      outb (0x0, dev.control_port); 
      outb (0x80 | 0x40 | bits, dev.data_port); 
      wavefront_should_cause_interrupt(0x80|0x40|0x10|0x1,
                               dev.control_port,
                               (reset_time*HZ)/100);

      reported_irq = probe_irq_off (irq_mask);

      if (reported_irq != dev.irq) {
            if (reported_irq == 0) {
                  printk (KERN_ERR LOGNAME
                        "No unassigned interrupts detected "
                        "after h/w reset\n");
            } else if (reported_irq < 0) {
                  printk (KERN_ERR LOGNAME
                        "Multiple unassigned interrupts detected "
                        "after h/w reset\n");
            } else {
                  printk (KERN_ERR LOGNAME "autodetected IRQ %d not the "
                        "value provided (%d)\n", reported_irq,
                        dev.irq);
            }
            dev.irq = -1;
            return 1;
      } else {
            printk (KERN_INFO LOGNAME "autodetected IRQ at %d\n",
                  reported_irq);
      }

      if (request_irq (dev.irq, wavefrontintr,
                   IRQF_DISABLED|IRQF_SHARED,
                   "wavefront synth", &dev) < 0) {
            printk (KERN_WARNING LOGNAME "IRQ %d not available!\n",
                  dev.irq);
            return 1;
      }

      /* try reset of port */
      
      outb (0x0, dev.control_port); 
  
      /* At this point, the board is in reset, and the H/W initialization
         register is accessed at the same address as the data port.
     
         Bit 7 - Enable IRQ Driver  
         0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
         1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
     
         Bit 6 - MIDI Interface Select

         0 - Use the MIDI Input from the 26-pin WaveBlaster
         compatible header as the serial MIDI source
         1 - Use the MIDI Input from the 9-pin D connector as the
         serial MIDI source.
     
         Bits 5:3 - IRQ Selection
         0 0 0 - IRQ 2/9
         0 0 1 - IRQ 5
         0 1 0 - IRQ 12
         0 1 1 - IRQ 15
         1 0 0 - Reserved
         1 0 1 - Reserved
         1 1 0 - Reserved
         1 1 1 - Reserved
     
         Bits 2:1 - Reserved
         Bit 0 - Disable Boot ROM
         0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
         1 - memory accesses to 03FC30-03FFFFH are directed to external 
         storage.
     
      */

      /* configure hardware: IRQ, enable interrupts, 
         plus external 9-pin MIDI interface selected
      */

      outb (0x80 | 0x40 | bits, dev.data_port); 
  
      /* CONTROL REGISTER

         0 Host Rx Interrupt Enable (1=Enabled)      0x1
         1 Unused                                    0x2
         2 Unused                                    0x4
         3 Unused                                    0x8
         4 Host Tx Interrupt Enable                 0x10
         5 Mute (0=Mute; 1=Play)                    0x20
         6 Master Interrupt Enable (1=Enabled)      0x40
         7 Master Reset (0=Reset; 1=Run)            0x80

         Take us out of reset, mute output, master + TX + RX interrupts on.
         
         We'll get an interrupt presumably to tell us that the TX
         register is clear.
      */

      wavefront_should_cause_interrupt(0x80|0x40|0x10|0x1,
                               dev.control_port,
                               (reset_time*HZ)/100);

      /* Note: data port is now the data port, not the h/w initialization
         port.
       */

      if (!dev.irq_ok) {
            printk (KERN_WARNING LOGNAME
                  "intr not received after h/w un-reset.\n");
            goto gone_bad;
      } 

      dev.interrupts_on = 1;
      
      /* Note: data port is now the data port, not the h/w initialization
         port.

         At this point, only "HW VERSION" or "DOWNLOAD OS" commands
         will work. So, issue one of them, and wait for TX
         interrupt. This can take a *long* time after a cold boot,
         while the ISC ROM does its RAM test. The SDK says up to 4
         seconds - with 12MB of RAM on a Tropez+, it takes a lot
         longer than that (~16secs). Note that the card understands
         the difference between a warm and a cold boot, so
         subsequent ISC2115 reboots (say, caused by module
         reloading) will get through this much faster.

         XXX Interesting question: why is no RX interrupt received first ?
      */

      wavefront_should_cause_interrupt(WFC_HARDWARE_VERSION, 
                               dev.data_port, ramcheck_time*HZ);

      if (!dev.irq_ok) {
            printk (KERN_WARNING LOGNAME
                  "post-RAM-check interrupt not received.\n");
            goto gone_bad;
      } 

      if (!wavefront_wait (STAT_CAN_READ)) {
            printk (KERN_WARNING LOGNAME
                  "no response to HW version cmd.\n");
            goto gone_bad;
      }
      
      if ((hwv[0] = wavefront_read ()) == -1) {
            printk (KERN_WARNING LOGNAME
                  "board not responding correctly.\n");
            goto gone_bad;
      }

      if (hwv[0] == 0xFF) { /* NAK */

            /* Board's RAM test failed. Try to read error code,
               and tell us about it either way.
            */
            
            if ((hwv[0] = wavefront_read ()) == -1) {
                  printk (KERN_WARNING LOGNAME "on-board RAM test failed "
                        "(bad error code).\n");
            } else {
                  printk (KERN_WARNING LOGNAME "on-board RAM test failed "
                        "(error code: 0x%x).\n",
                        hwv[0]);
            }
            goto gone_bad;
      }

      /* We're OK, just get the next byte of the HW version response */

      if ((hwv[1] = wavefront_read ()) == -1) {
            printk (KERN_WARNING LOGNAME "incorrect h/w response.\n");
            goto gone_bad;
      }

      printk (KERN_INFO LOGNAME "hardware version %d.%d\n",
            hwv[0], hwv[1]);

      return 0;


     gone_bad:
      if (dev.irq >= 0) {
            free_irq (dev.irq, &dev);
            dev.irq = -1;
      }
      return (1);
}

static int __init detect_wavefront (int irq, int io_base)
{
      unsigned char   rbuf[4], wbuf[4];

      /* TB docs say the device takes up 8 ports, but we know that
         if there is an FX device present (i.e. a Tropez+) it really
         consumes 16.
      */

      if (!request_region (io_base, 16, "wavfront")) {
            printk (KERN_ERR LOGNAME "IO address range 0x%x - 0x%x "
                  "already in use - ignored\n", dev.base,
                  dev.base+15);
            return -1;
      }
  
      dev.irq = irq;
      dev.base = io_base;
      dev.israw = 0;
      dev.debug = debug_default;
      dev.interrupts_on = 0;
      dev.irq_cnt = 0;
      dev.rom_samples_rdonly = 1; /* XXX default lock on ROM sample slots */

      if (wavefront_cmd (WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {

            dev.fw_version[0] = rbuf[0];
            dev.fw_version[1] = rbuf[1];
            printk (KERN_INFO LOGNAME
                  "firmware %d.%d already loaded.\n",
                  rbuf[0], rbuf[1]);

            /* check that a command actually works */
      
            if (wavefront_cmd (WFC_HARDWARE_VERSION,
                           rbuf, wbuf) == 0) {
                  dev.hw_version[0] = rbuf[0];
                  dev.hw_version[1] = rbuf[1];
            } else {
                  printk (KERN_WARNING LOGNAME "not raw, but no "
                        "hardware version!\n");
                  release_region (io_base, 16);
                  return 0;
            }

            if (!wf_raw) {
                  /* will re-acquire region in install_wavefront() */
                  release_region (io_base, 16);
                  return 1;
            } else {
                  printk (KERN_INFO LOGNAME
                        "reloading firmware anyway.\n");
                  dev.israw = 1;
            }

      } else {

            dev.israw = 1;
            printk (KERN_INFO LOGNAME
                  "no response to firmware probe, assume raw.\n");

      }

      init_waitqueue_head (&dev.interrupt_sleeper);

      if (wavefront_hw_reset ()) {
            printk (KERN_WARNING LOGNAME "hardware reset failed\n");
            release_region (io_base, 16);
            return 0;
      }

      /* Check for FX device, present only on Tropez+ */

      dev.has_fx = (detect_wffx () == 0);

      /* will re-acquire region in install_wavefront() */
      release_region (io_base, 16);
      return 1;
}

#include "os.h"
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <asm/uaccess.h>


static int
wavefront_download_firmware (char *path)

{
      unsigned char section[WF_SECTION_MAX];
      char section_length; /* yes, just a char; max value is WF_SECTION_MAX */
      int section_cnt_downloaded = 0;
      int fd;
      int c;
      int i;
      mm_segment_t fs;

      /* This tries to be a bit cleverer than the stuff Alan Cox did for
         the generic sound firmware, in that it actually knows
         something about the structure of the Motorola firmware. In
         particular, it uses a version that has been stripped of the
         20K of useless header information, and had section lengths
         added, making it possible to load the entire OS without any
         [kv]malloc() activity, since the longest entity we ever read is
         42 bytes (well, WF_SECTION_MAX) long.
      */

      fs = get_fs();
      set_fs (get_ds());

      if ((fd = sys_open (path, 0, 0)) < 0) {
            printk (KERN_WARNING LOGNAME "Unable to load \"%s\".\n",
                  path);
            return 1;
      }

      while (1) {
            int x;

            if ((x = sys_read (fd, &section_length, sizeof (section_length))) !=
                sizeof (section_length)) {
                  printk (KERN_ERR LOGNAME "firmware read error.\n");
                  goto failure;
            }

            if (section_length == 0) {
                  break;
            }

            if (sys_read (fd, section, section_length) != section_length) {
                  printk (KERN_ERR LOGNAME "firmware section "
                        "read error.\n");
                  goto failure;
            }

            /* Send command */
      
            if (wavefront_write (WFC_DOWNLOAD_OS)) {
                  goto failure;
            }
      
            for (i = 0; i < section_length; i++) {
                  if (wavefront_write (section[i])) {
                        goto failure;
                  }
            }
      
            /* get ACK */
      
            if (wavefront_wait (STAT_CAN_READ)) {

                  if ((c = inb (dev.data_port)) != WF_ACK) {

                        printk (KERN_ERR LOGNAME "download "
                              "of section #%d not "
                              "acknowledged, ack = 0x%x\n",
                              section_cnt_downloaded + 1, c);
                        goto failure;
            
                  }

            } else {
                  printk (KERN_ERR LOGNAME "time out for firmware ACK.\n");
                  goto failure;
            }

      }

      sys_close (fd);
      set_fs (fs);
      return 0;

 failure:
      sys_close (fd);
      set_fs (fs);
      printk (KERN_ERR "\nWaveFront: firmware download failed!!!\n");
      return 1;
}

static int __init wavefront_config_midi (void)
{
      unsigned char rbuf[4], wbuf[4];
    
      if (detect_wf_mpu (dev.irq, dev.base) < 0) {
            printk (KERN_WARNING LOGNAME
                  "could not find working MIDI device\n");
            return -1;
      } 

      if ((dev.mididev = install_wf_mpu ()) < 0) {
            printk (KERN_WARNING LOGNAME
                  "MIDI interfaces not configured\n");
            return -1;
      }

      /* Route external MIDI to WaveFront synth (by default) */
    
      if (wavefront_cmd (WFC_MISYNTH_ON, rbuf, wbuf)) {
            printk (KERN_WARNING LOGNAME
                  "cannot enable MIDI-IN to synth routing.\n");
            /* XXX error ? */
      }


#if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
      /* Get the regular MIDI patch loading function, so we can
         use it if we ever get handed a SYSEX patch. This is
         unlikely, because its so damn slow, but we may as well
         leave this functionality from maui.c behind, since it
         could be useful for sequencer applications that can
         only use MIDI to do patch loading.
      */

      if (midi_devs[dev.mididev]->converter != NULL) {
            midi_load_patch = midi_devs[dev.mididev]->converter->load_patch;
            midi_devs[dev.mididev]->converter->load_patch =
                &wavefront_oss_load_patch;
      }

#endif /* OSS_SUPPORT_SEQ */
      
      /* Turn on Virtual MIDI, but first *always* turn it off,
         since otherwise consectutive reloads of the driver will
         never cause the hardware to generate the initial "internal" or 
         "external" source bytes in the MIDI data stream. This
         is pretty important, since the internal hardware generally will
         be used to generate none or very little MIDI output, and
         thus the only source of MIDI data is actually external. Without
         the switch bytes, the driver will think it all comes from
         the internal interface. Duh.
      */

      if (wavefront_cmd (WFC_VMIDI_OFF, rbuf, wbuf)) { 
            printk (KERN_WARNING LOGNAME
                  "virtual MIDI mode not disabled\n");
            return 0; /* We're OK, but missing the external MIDI dev */
      }

      if ((dev.ext_mididev = virtual_midi_enable ()) < 0) {
            printk (KERN_WARNING LOGNAME "no virtual MIDI access.\n");
      } else {
            if (wavefront_cmd (WFC_VMIDI_ON, rbuf, wbuf)) {
                  printk (KERN_WARNING LOGNAME
                        "cannot enable virtual MIDI mode.\n");
                  virtual_midi_disable ();
            } 
      }
    
      return 0;
}

static int __init wavefront_do_reset (int atboot)
{
      char voices[1];

      if (!atboot && wavefront_hw_reset ()) {
            printk (KERN_WARNING LOGNAME "hw reset failed.\n");
            goto gone_bad;
      }

      if (dev.israw) {
            if (wavefront_download_firmware (ospath)) {
                  goto gone_bad;
            }

            dev.israw = 0;

            /* Wait for the OS to get running. The protocol for
               this is non-obvious, and was determined by
               using port-IO tracing in DOSemu and some
               experimentation here.
               
               Rather than using timed waits, use interrupts creatively.
            */

            wavefront_should_cause_interrupt (WFC_NOOP,
                                      dev.data_port,
                                      (osrun_time*HZ));

            if (!dev.irq_ok) {
                  printk (KERN_WARNING LOGNAME
                        "no post-OS interrupt.\n");
                  goto gone_bad;
            }
            
            /* Now, do it again ! */
            
            wavefront_should_cause_interrupt (WFC_NOOP,
                                      dev.data_port, (10*HZ));
            
            if (!dev.irq_ok) {
                  printk (KERN_WARNING LOGNAME
                        "no post-OS interrupt(2).\n");
                  goto gone_bad;
            }

            /* OK, no (RX/TX) interrupts any more, but leave mute
               in effect. 
            */
            
            outb (0x80|0x40, dev.control_port); 

            /* No need for the IRQ anymore */
            
            free_irq (dev.irq, &dev);

      }

      if (dev.has_fx && fx_raw) {
            wffx_init ();
      }

      /* SETUPSND.EXE asks for sample memory config here, but since i
         have no idea how to interpret the result, we'll forget
         about it.
      */
      
      if ((dev.freemem = wavefront_freemem ()) < 0) {
            goto gone_bad;
      }
            
      printk (KERN_INFO LOGNAME "available DRAM %dk\n", dev.freemem / 1024);

      if (wavefront_write (0xf0) ||
          wavefront_write (1) ||
          (wavefront_read () < 0)) {
            dev.debug = 0;
            printk (KERN_WARNING LOGNAME "MPU emulation mode not set.\n");
            goto gone_bad;
      }

      voices[0] = 32;

      if (wavefront_cmd (WFC_SET_NVOICES, NULL, voices)) {
            printk (KERN_WARNING LOGNAME
                  "cannot set number of voices to 32.\n");
            goto gone_bad;
      }


      return 0;

 gone_bad:
      /* reset that sucker so that it doesn't bother us. */

      outb (0x0, dev.control_port);
      dev.interrupts_on = 0;
      if (dev.irq >= 0) {
            free_irq (dev.irq, &dev);
      }
      return 1;
}

static int __init wavefront_init (int atboot)
{
      int samples_are_from_rom;

      if (dev.israw) {
            samples_are_from_rom = 1;
      } else {
            /* XXX is this always true ? */
            samples_are_from_rom = 0;
      }

      if (dev.israw || fx_raw) {
            if (wavefront_do_reset (atboot)) {
                  return -1;
            }
      }

      wavefront_get_sample_status (samples_are_from_rom);
      wavefront_get_program_status ();
      wavefront_get_patch_status ();

      /* Start normal operation: unreset, master interrupt enabled, no mute
      */

      outb (0x80|0x40|0x20, dev.control_port); 

      return (0);
}

static int __init install_wavefront (void)
{
      if (!request_region (dev.base+2, 6, "wavefront synth"))
            return -1;

      if (dev.has_fx) {
            if (!request_region (dev.base+8, 8, "wavefront fx")) {
                  release_region (dev.base+2, 6);
                  return -1;
            }
      }

      if ((dev.synth_dev = register_sound_synth (&wavefront_fops, -1)) < 0) {
            printk (KERN_ERR LOGNAME "cannot register raw synth\n");
            goto err_out;
      }

#if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
      if ((dev.oss_dev = sound_alloc_synthdev()) == -1) {
            printk (KERN_ERR LOGNAME "Too many sequencers\n");
            /* FIXME: leak: should unregister sound synth */
            goto err_out;
      } else {
            synth_devs[dev.oss_dev] = &wavefront_operations;
      }
#endif /* OSS_SUPPORT_SEQ */

      if (wavefront_init (1) < 0) {
            printk (KERN_WARNING LOGNAME "initialization failed.\n");

#if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
            sound_unload_synthdev (dev.oss_dev);
#endif /* OSS_SUPPORT_SEQ */ 

            goto err_out;
      }
    
      if (wavefront_config_midi ()) {
            printk (KERN_WARNING LOGNAME "could not initialize MIDI.\n");
      }

      return dev.oss_dev;

err_out:
      release_region (dev.base+2, 6);
      if (dev.has_fx)
            release_region (dev.base+8, 8);
      return -1;
}

static void __exit uninstall_wavefront (void)
{
      /* the first two i/o addresses are freed by the wf_mpu code */
      release_region (dev.base+2, 6);

      if (dev.has_fx) {
            release_region (dev.base+8, 8);
      }

      unregister_sound_synth (dev.synth_dev);

#if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
      sound_unload_synthdev (dev.oss_dev);
#endif /* OSS_SUPPORT_SEQ */ 
      uninstall_wf_mpu ();
}

/***********************************************************************/
/*   WaveFront FX control                                              */
/***********************************************************************/

#include "yss225.h"

/* Control bits for the Load Control Register
 */

#define FX_LSB_TRANSFER 0x01    /* transfer after DSP LSB byte written */
#define FX_MSB_TRANSFER 0x02    /* transfer after DSP MSB byte written */
#define FX_AUTO_INCR    0x04    /* auto-increment DSP address after transfer */

static int
wffx_idle (void) 
    
{
      int i;
      unsigned int x = 0x80;
    
      for (i = 0; i < 1000; i++) {
            x = inb (dev.fx_status);
            if ((x & 0x80) == 0) {
                  break;
            }
      }
    
      if (x & 0x80) {
            printk (KERN_ERR LOGNAME "FX device never idle.\n");
            return 0;
      }
    
      return (1);
}

int __init detect_wffx (void)
{
      /* This is a crude check, but its the best one I have for now.
         Certainly on the Maui and the Tropez, wffx_idle() will
         report "never idle", which suggests that this test should
         work OK.
      */

      if (inb (dev.fx_status) & 0x80) {
            printk (KERN_INFO LOGNAME "Hmm, probably a Maui or Tropez.\n");
            return -1;
      }

      return 0;
}     

static void
wffx_mute (int onoff)
    
{
      if (!wffx_idle()) {
            return;
      }
    
      outb (onoff ? 0x02 : 0x00, dev.fx_op);
}

static int
wffx_memset (int page,
           int addr, int cnt, unsigned short *data)
{
      if (page < 0 || page > 7) {
            printk (KERN_ERR LOGNAME "FX memset: "
                  "page must be >= 0 and <= 7\n");
            return -(EINVAL);
      }

      if (addr < 0 || addr > 0x7f) {
            printk (KERN_ERR LOGNAME "FX memset: "
                  "addr must be >= 0 and <= 7f\n");
            return -(EINVAL);
      }

      if (cnt == 1) {

            outb (FX_LSB_TRANSFER, dev.fx_lcr);
            outb (page, dev.fx_dsp_page);
            outb (addr, dev.fx_dsp_addr);
            outb ((data[0] >> 8), dev.fx_dsp_msb);
            outb ((data[0] & 0xff), dev.fx_dsp_lsb);

            printk (KERN_INFO LOGNAME "FX: addr %d:%x set to 0x%x\n",
                  page, addr, data[0]);
      
      } else {
            int i;

            outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
            outb (page, dev.fx_dsp_page);
            outb (addr, dev.fx_dsp_addr);

            for (i = 0; i < cnt; i++) {
                  outb ((data[i] >> 8), dev.fx_dsp_msb);
                  outb ((data[i] & 0xff), dev.fx_dsp_lsb);
                  if (!wffx_idle ()) {
                        break;
                  }
            }

            if (i != cnt) {
                  printk (KERN_WARNING LOGNAME
                        "FX memset "
                        "(0x%x, 0x%x, %p, %d) incomplete\n",
                        page, addr, data, cnt);
                  return -(EIO);
            }
      }

      return 0;
}

static int
wffx_ioctl (wavefront_fx_info *r)

{
      unsigned short page_data[256];
      unsigned short *pd;

      switch (r->request) {
      case WFFX_MUTE:
            wffx_mute (r->data[0]);
            return 0;

      case WFFX_MEMSET:

            if (r->data[2] <= 0) {
                  printk (KERN_ERR LOGNAME "cannot write "
                        "<= 0 bytes to FX\n");
                  return -(EINVAL);
            } else if (r->data[2] == 1) {
                  pd = (unsigned short *) &r->data[3];
            } else {
                  if (r->data[2] > sizeof (page_data)) {
                        printk (KERN_ERR LOGNAME "cannot write "
                              "> 255 bytes to FX\n");
                        return -(EINVAL);
                  }
                  if (copy_from_user(page_data,
                                 (unsigned char __user *)r->data[3],
                                 r->data[2]))
                        return -EFAULT;
                  pd = page_data;
            }

            return wffx_memset (r->data[0], /* page */
                            r->data[1], /* addr */
                            r->data[2], /* cnt */
                            pd);

      default:
            printk (KERN_WARNING LOGNAME
                  "FX: ioctl %d not yet supported\n",
                  r->request);
            return -(EINVAL);
      }
}

/* YSS225 initialization.

   This code was developed using DOSEMU. The Turtle Beach SETUPSND
   utility was run with I/O tracing in DOSEMU enabled, and a reconstruction
   of the port I/O done, using the Yamaha faxback document as a guide
   to add more logic to the code. Its really pretty weird.

   There was an alternative approach of just dumping the whole I/O
   sequence as a series of port/value pairs and a simple loop
   that output it. However, I hope that eventually I'll get more
   control over what this code does, and so I tried to stick with
   a somewhat "algorithmic" approach.
*/

static int __init wffx_init (void)
{
      int i;
      int j;

      /* Set all bits for all channels on the MOD unit to zero */
      /* XXX But why do this twice ? */

      for (j = 0; j < 2; j++) {
            for (i = 0x10; i <= 0xff; i++) {
          
                  if (!wffx_idle ()) {
                        return (-1);
                  }
          
                  outb (i, dev.fx_mod_addr);
                  outb (0x0, dev.fx_mod_data);
            }
      }

      if (!wffx_idle()) return (-1);
      outb (0x02, dev.fx_op);                        /* mute on */

      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x44, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x42, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x43, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x7c, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x7e, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x46, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x49, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x47, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x4a, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);

      /* either because of stupidity by TB's programmers, or because it
         actually does something, rezero the MOD page.
      */
      for (i = 0x10; i <= 0xff; i++) {
      
            if (!wffx_idle ()) {
                  return (-1);
            }
      
            outb (i, dev.fx_mod_addr);
            outb (0x0, dev.fx_mod_data);
      }
      /* load page zero */

      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x00, dev.fx_dsp_page);
      outb (0x00, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_zero); i += 2) {
            outb (page_zero[i], dev.fx_dsp_msb);
            outb (page_zero[i+1], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }

      /* Now load page one */

      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x01, dev.fx_dsp_page);
      outb (0x00, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_one); i += 2) {
            outb (page_one[i], dev.fx_dsp_msb);
            outb (page_one[i+1], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
    
      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x02, dev.fx_dsp_page);
      outb (0x00, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_two); i++) {
            outb (page_two[i], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
    
      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x03, dev.fx_dsp_page);
      outb (0x00, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_three); i++) {
            outb (page_three[i], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
    
      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x04, dev.fx_dsp_page);
      outb (0x00, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_four); i++) {
            outb (page_four[i], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }

      /* Load memory area (page six) */
    
      outb (FX_LSB_TRANSFER, dev.fx_lcr); 
      outb (0x06, dev.fx_dsp_page); 

      for (i = 0; i < sizeof (page_six); i += 3) {
            outb (page_six[i], dev.fx_dsp_addr);
            outb (page_six[i+1], dev.fx_dsp_msb);
            outb (page_six[i+2], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
    
      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x07, dev.fx_dsp_page);
      outb (0x00, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_seven); i += 2) {
            outb (page_seven[i], dev.fx_dsp_msb);
            outb (page_seven[i+1], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }

      /* Now setup the MOD area. We do this algorithmically in order to
         save a little data space. It could be done in the same fashion
         as the "pages".
      */

      for (i = 0x00; i <= 0x0f; i++) {
            outb (0x01, dev.fx_mod_addr);
            outb (i, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
            outb (0x02, dev.fx_mod_addr);
            outb (0x00, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      for (i = 0xb0; i <= 0xbf; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0x20, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      for (i = 0xf0; i <= 0xff; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0x20, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      for (i = 0x10; i <= 0x1d; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0xff, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      outb (0x1e, dev.fx_mod_addr);
      outb (0x40, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);

      for (i = 0x1f; i <= 0x2d; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0xff, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      outb (0x2e, dev.fx_mod_addr);
      outb (0x00, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);

      for (i = 0x2f; i <= 0x3e; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0x00, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      outb (0x3f, dev.fx_mod_addr);
      outb (0x20, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);

      for (i = 0x40; i <= 0x4d; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0x00, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      outb (0x4e, dev.fx_mod_addr);
      outb (0x0e, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);
      outb (0x4f, dev.fx_mod_addr);
      outb (0x0e, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);


      for (i = 0x50; i <= 0x6b; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0x00, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      outb (0x6c, dev.fx_mod_addr);
      outb (0x40, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);

      outb (0x6d, dev.fx_mod_addr);
      outb (0x00, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);

      outb (0x6e, dev.fx_mod_addr);
      outb (0x40, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);

      outb (0x6f, dev.fx_mod_addr);
      outb (0x40, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);

      for (i = 0x70; i <= 0x7f; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0xc0, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }
    
      for (i = 0x80; i <= 0xaf; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0x00, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      for (i = 0xc0; i <= 0xdd; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0x00, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      outb (0xde, dev.fx_mod_addr);
      outb (0x10, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);
      outb (0xdf, dev.fx_mod_addr);
      outb (0x10, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);

      for (i = 0xe0; i <= 0xef; i++) {
            outb (i, dev.fx_mod_addr);
            outb (0x00, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      for (i = 0x00; i <= 0x0f; i++) {
            outb (0x01, dev.fx_mod_addr);
            outb (i, dev.fx_mod_data);
            outb (0x02, dev.fx_mod_addr);
            outb (0x01, dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      outb (0x02, dev.fx_op); /* mute on */

      /* Now set the coefficients and so forth for the programs above */

      for (i = 0; i < sizeof (coefficients); i += 4) {
            outb (coefficients[i], dev.fx_dsp_page);
            outb (coefficients[i+1], dev.fx_dsp_addr);
            outb (coefficients[i+2], dev.fx_dsp_msb);
            outb (coefficients[i+3], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }

      /* Some settings (?) that are too small to bundle into loops */

      if (!wffx_idle()) return (-1);
      outb (0x1e, dev.fx_mod_addr);
      outb (0x14, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);
      outb (0xde, dev.fx_mod_addr);
      outb (0x20, dev.fx_mod_data);
      if (!wffx_idle()) return (-1);
      outb (0xdf, dev.fx_mod_addr);
      outb (0x20, dev.fx_mod_data);
    
      /* some more coefficients */

      if (!wffx_idle()) return (-1);
      outb (0x06, dev.fx_dsp_page);
      outb (0x78, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x40, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x03, dev.fx_dsp_addr);
      outb (0x0f, dev.fx_dsp_msb);
      outb (0xff, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x0b, dev.fx_dsp_addr);
      outb (0x0f, dev.fx_dsp_msb);
      outb (0xff, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x02, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x0a, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x46, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
      if (!wffx_idle()) return (-1);
      outb (0x07, dev.fx_dsp_page);
      outb (0x49, dev.fx_dsp_addr);
      outb (0x00, dev.fx_dsp_msb);
      outb (0x00, dev.fx_dsp_lsb);
    
      /* Now, for some strange reason, lets reload every page
         and all the coefficients over again. I have *NO* idea
         why this is done. I do know that no sound is produced
         is this phase is omitted.
      */

      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x00, dev.fx_dsp_page);  
      outb (0x10, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_zero_v2); i += 2) {
            outb (page_zero_v2[i], dev.fx_dsp_msb);
            outb (page_zero_v2[i+1], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
    
      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x01, dev.fx_dsp_page);
      outb (0x10, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_one_v2); i += 2) {
            outb (page_one_v2[i], dev.fx_dsp_msb);
            outb (page_one_v2[i+1], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
    
      if (!wffx_idle()) return (-1);
      if (!wffx_idle()) return (-1);
    
      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x02, dev.fx_dsp_page);
      outb (0x10, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_two_v2); i++) {
            outb (page_two_v2[i], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x03, dev.fx_dsp_page);
      outb (0x10, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_three_v2); i++) {
            outb (page_three_v2[i], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
    
      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x04, dev.fx_dsp_page);
      outb (0x10, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_four_v2); i++) {
            outb (page_four_v2[i], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }
    
      outb (FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x06, dev.fx_dsp_page);

      /* Page six v.2 is algorithmic */
    
      for (i = 0x10; i <= 0x3e; i += 2) {
            outb (i, dev.fx_dsp_addr);
            outb (0x00, dev.fx_dsp_msb);
            outb (0x00, dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }

      outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
      outb (0x07, dev.fx_dsp_page);
      outb (0x10, dev.fx_dsp_addr);

      for (i = 0; i < sizeof (page_seven_v2); i += 2) {
            outb (page_seven_v2[i], dev.fx_dsp_msb);
            outb (page_seven_v2[i+1], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }

      for (i = 0x00; i < sizeof(mod_v2); i += 2) {
            outb (mod_v2[i], dev.fx_mod_addr);
            outb (mod_v2[i+1], dev.fx_mod_data);
            if (!wffx_idle()) return (-1);
      }

      for (i = 0; i < sizeof (coefficients2); i += 4) {
            outb (coefficients2[i], dev.fx_dsp_page);
            outb (coefficients2[i+1], dev.fx_dsp_addr);
            outb (coefficients2[i+2], dev.fx_dsp_msb);
            outb (coefficients2[i+3], dev.fx_dsp_lsb);
            if (!wffx_idle()) return (-1);
      }

      for (i = 0; i < sizeof (coefficients3); i += 2) {
            int x;

            outb (0x07, dev.fx_dsp_page);
            x = (i % 4) ? 0x4e : 0x4c;
            outb (x, dev.fx_dsp_addr);
            outb (coefficients3[i], dev.fx_dsp_msb);
            outb (coefficients3[i+1], dev.fx_dsp_lsb);
      }

      outb (0x00, dev.fx_op); /* mute off */
      if (!wffx_idle()) return (-1);

      return (0);
}

static int io = -1;
static int irq = -1;

MODULE_AUTHOR      ("Paul Barton-Davis <pbd@op.net>");
MODULE_DESCRIPTION ("Turtle Beach WaveFront Linux Driver");
MODULE_LICENSE("GPL");
module_param       (io, int, 0);
module_param       (irq, int, 0);

static int __init init_wavfront (void)
{
      printk ("Turtle Beach WaveFront Driver\n"
            "Copyright (C) by Hannu Solvainen, "
            "Paul Barton-Davis 1993-1998.\n");

      /* XXX t'would be lovely to ask the CS4232 for these values, eh ? */

      if (io == -1 || irq == -1) {
            printk (KERN_INFO LOGNAME "irq and io options must be set.\n");
            return -EINVAL;
      }

      if (wavefront_interrupt_bits (irq) < 0) {
            printk (KERN_INFO LOGNAME
                  "IRQ must be 9, 5, 12 or 15 (not %d)\n", irq);
            return -ENODEV;
      }

      if (detect_wavefront (irq, io) < 0) {
            return -ENODEV;
      } 

      if (install_wavefront () < 0) {
            return -EIO;
      }

      return 0;
}

static void __exit cleanup_wavfront (void)
{
      uninstall_wavefront ();
}

module_init(init_wavfront);
module_exit(cleanup_wavfront);

Generated by  Doxygen 1.6.0   Back to index