diff options
Diffstat (limited to 'drivers/sound/wavfront.c')
| -rw-r--r-- | drivers/sound/wavfront.c | 3412 |
1 files changed, 3412 insertions, 0 deletions
diff --git a/drivers/sound/wavfront.c b/drivers/sound/wavfront.c new file mode 100644 index 000000000..735dcd93f --- /dev/null +++ b/drivers/sound/wavfront.c @@ -0,0 +1,3412 @@ +/* + * sound/wavefront.c + * + * A low level driver for Turtle Beach WaveFront Series + * (Maui, Tropez, Tropez Plus, and perhaps the Monterey & Rio) + * + * 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' CODEC (a Crystal CS4232) is supported by cs4232.[co], + * This chip also controls the configuration of the card: the wavefront + * synth is logical unit 4. + * + * NOTE: this driver has been written to support multiple WaveFront + * cards, but without using PnP to configure the CS4232, all of them + * would end up with the same configuration. Further, the current + * module loading interface doesn't permit this, since it only allows + * once instance of a module (which happens to be equivalent to a + * single hardware configuration) to be installed at one time.In + * addition, there is a hard limit on the available DMA channels that + * also makes installing more than 1 card limited to purely MIDI/synth + * activities on the second card. Still, the coding style gets rid of + * virtually all globals, which I believe is a better way to code + * device drivers (or anything else, for that matter). + * + ********************************************************************** + * + * 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 most aspects of this 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. + * + * 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. */ + +#include <linux/config.h> +#include <linux/module.h> +#include <asm/init.h> + +#include "sound_config.h" +#include "soundmodule.h" + +#include <linux/wavefront.h> + +#define MIDI_SYNTH_NAME "WaveFront MIDI" +#define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT +#include "midi_synth.h" + +#define COPY_FROM_USER(a,b,c) copy_from_user ((a),(b),(c)) +#define COPY_TO_USER(a,b,c) copy_to_user ((a),(b),(c)) + +#if defined(CONFIG_SOUND_WAVEFRONT) || defined(CONFIG_SOUND_WAVEFRONT_MODULE) + +/* This thing is meant to work as a module */ + +#ifdef MODULE + +/* bitmasks for WaveFront status port value */ + +#define STAT_INTR_WRITE 0x40 +#define STAT_CAN_WRITE 0x20 +#define STAT_RINTR_ENABLED 0x10 +#define STAT_INTR_READ 0x04 +#define STAT_CAN_READ 0x02 +#define STAT_WINTR_ENABLED 0x01 + +/*** Module-accessible parameters ***************************************/ + +int wf_raw = 0; /* 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. + */ + +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. + */ + +int wf_debug_default = 0; /* 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 */ + +char *wf_ospath = "/etc/sound/wavefront.os"; /* where to find a processed + version of the WaveFront OS + */ + +/* These three don't need to be messed with unless you're trying to + tweak the driver for optimal I/O performance. Read wavefront_wait() + and wavefront_sleep() to see what they do. You may need or want to + tweak them for CPU's different than the 486/66Mhz that I run on. +*/ + +int wf_short_wait_count = 5000; /* loops, CPU dependent */ +int wf_sleep_interval = 50; /* HZ/wf_sleep_interval seconds per sleep */ +int wf_sleep_tries = 100; /*2sec*/ /* number of times we'll try to sleep */ + +MODULE_PARM(wf_raw,"i"); +MODULE_PARM(fx_raw,"i"); +MODULE_PARM(wf_debug_default,"i"); +MODULE_PARM(wf_ospath,"s"); +MODULE_PARM(wf_short_wait_count,"i"); +MODULE_PARM(wf_sleep_interval,"i"); +MODULE_PARM(wf_sleep_tries,"i"); + +/***************************************************************************/ + +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 (*midi_load_patch) (int dev, int format, const char *addr, + int offs, int count, int pmgr_flag) = NULL; + + +typedef struct wf_config { + int installed; /* well, is it ? note: doesn't mean "working" */ + 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 */ + int opened; /* flag, holds open(1) mode */ + char debug; /* debugging flags */ + unsigned int freemem; /* installed RAM, in bytes */ + int synthdev; /* OSS minor devnum for synth */ + int mididev; /* OSS minor devno for internal MIDI */ + int ext_mididev; /* OSS minor devno for external MIDI */ + char fw_version[2]; /* major = [0], minor = [1] */ + char hw_version[2]; /* major = [0], minor = [1] */ + char israw; /* needs Motorola microcode */ + 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 */ +} wf_config; + +static wf_config wfs[WAVEFRONT_MAX_DEVICES]; + +#define wavefront_status(hw) (inb (hw->status_port)) + +/* forward references */ + +static int wffx_ioctl (struct wf_config *, wavefront_fx_info *); +static int wffx_init (struct wf_config *hw); +static int wavefront_delete_sample (struct wf_config *hw, int sampnum); + +static volatile int irq2hw[17] = +{-1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1}; + +static volatile int dev2hw[17] = +{-1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1}; + +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" }, + { 0x0, 0x0 } +}; + +#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 }, + { 0x00 } +}; + +wf_config * +hw_from_dev (int dev) + +{ + int i; + + if ((i = dev2hw[dev]) == -1) { + printk (KERN_ERR + "WaveFront: no hardware associated with device %d.\n", + dev); + return 0; + } + + return &wfs[i]; +} + +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 int +wavefront_sleep (wf_config *hw, int limit) + +{ + current->timeout = jiffies + limit; + current->state = TASK_INTERRUPTIBLE; + schedule(); + current->timeout = 0; + + return signal_pending(current); +} + +static int +wavefront_wait (wf_config *hw, int mask) + +{ + int i; + + for (i = 0; i < wf_short_wait_count; i++) { + if (wavefront_status(hw) & mask) { + return 1; + } + } + + for (i = 0; i < wf_sleep_tries; i++) { + + if (wavefront_status(hw) & mask) { + return 1; + } + + if (wavefront_sleep (hw, HZ/wf_sleep_interval)) { + return 0; + } + } + + return 0; +} + +static int +wavefront_read (wf_config *hw) +{ + if (wavefront_wait (hw, STAT_CAN_READ)) + return inb (hw->data_port); + + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG "WaveFront: read timeout.\n"); + } + return -1; +} + +static int +wavefront_write (wf_config *hw, unsigned char data) +{ + if (wavefront_wait (hw, STAT_CAN_WRITE)) { + outb (data, hw->data_port); + return 1; + } + + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG "WaveFront: write timeout.\n"); + } + return 0; +} + +static int +wavefront_cmd (wf_config *hw, 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 "WaveFront: 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 = 0; + } + + if (hw->debug & WF_DEBUG_CMD) { + printk (KERN_DEBUG "Wavefront: 0x%x [%s] (%d,%d,%d)\n", + cmd, wfcmd->action, wfcmd->read_cnt, wfcmd->write_cnt, + wfcmd->need_ack); + } + + if (!wavefront_write (hw, cmd)) { + if (hw->debug & (WF_DEBUG_IO|WF_DEBUG_CMD)) { + printk (KERN_DEBUG "WaveFront: cannot request " + "0x%x [%s].\n", + cmd, wfcmd->action); + } + return 1; + } + + if (wfcmd->write_cnt > 0) { + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG "WaveFront: writing %d bytes " + "for 0x%x\n", + wfcmd->write_cnt, cmd); + } + + for (i = 0; i < wfcmd->write_cnt; i++) { + if (!wavefront_write (hw, wbuf[i])) { + if (hw->debug & WF_DEBUG_IO) { + printk (KERN_DEBUG + "WaveFront: bad write for byte %d of 0x%x [%s].\n", + i, cmd, wfcmd->action); + } + return 1; + } + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG + "WaveFront: write[%d] = 0x%x\n", + i, wbuf[i]); + } + } + } + + if (wfcmd->read_cnt > 0) { + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG "WaveFront: reading %d ints " + "for 0x%x\n", + wfcmd->read_cnt, cmd); + } + + for (i = 0; i < wfcmd->read_cnt; i++) { + + if ((c = wavefront_read(hw)) == -1) { + if (hw->debug & WF_DEBUG_IO) { + printk (KERN_DEBUG + "WaveFront: 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 (hw)) == -1) { + if (hw->debug & WF_DEBUG_IO) { + printk (KERN_DEBUG + "WaveFront: 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 { + + if (hw->debug & WF_DEBUG_IO) { + printk (KERN_DEBUG + "WaveFront: 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; + } + + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG + "WaveFront: read[%d] = 0x%x\n", + i, rbuf[i]); + } + } + } + + if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) { + + if (hw->debug & WF_DEBUG_CMD) { + printk (KERN_DEBUG "WaveFront: reading ACK for 0x%x\n", + cmd); + } + + /* Some commands need an ACK, but return zero instead + of the standard value. + */ + + if ((ack = wavefront_read(hw)) == 0) { + ack = WF_ACK; + } + + if (ack != WF_ACK) { + if (ack == -1) { + if (hw->debug & WF_DEBUG_IO) { + printk (KERN_DEBUG + "WaveFront: 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 (hw)) == -1) { + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG + "WaveFront: cannot read err for 0x%x [%s].\n", + cmd, wfcmd->action); + } + } + } + + if (hw->debug & WF_DEBUG_IO) { + printk (KERN_DEBUG + "WaveFront: 0x%x [%s] " + "failed (0x%x, 0x%x, %s)\n", + cmd, wfcmd->action, ack, err, + wavefront_errorstr (err)); + } + return -err; + } + } + + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG "WaveFront: ack received " + "for 0x%x [%s]\n", + cmd, wfcmd->action); + } + } else { + if (hw->debug & WF_DEBUG_CMD) { + printk (KERN_DEBUG + "Wavefront: 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- to 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 (wf_config *hw, int sample_num) + +{ + unsigned char wbuf[2]; + int x; + + wbuf[0] = sample_num & 0x7f; + wbuf[1] = sample_num >> 7; + + if ((x = wavefront_cmd (hw, WFC_DELETE_SAMPLE, 0, wbuf)) == 0) { + hw->sample_status[sample_num] = WF_ST_EMPTY; + } + + return x; +} + +static int +wavefront_get_sample_status (struct wf_config *hw, 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 (hw, WFC_GET_NSAMPLES, rbuf, wbuf)) { + printk ("WaveFront: cannot request sample count.\n"); + } + + sc_real = sc_alias = sc_multi = hw->samples_used = 0; + + for (i = 0; i < WF_MAX_SAMPLE; i++) { + + wbuf[0] = i & 0x7f; + wbuf[1] = i >> 7; + + if (wavefront_cmd (hw, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) { + printk (KERN_WARNING + "WaveFront: cannot identify sample " + "type of slot %d\n", i); + hw->sample_status[i] = WF_ST_EMPTY; + continue; + } + + hw->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]); + + if (assume_rom) { + hw->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 + "WaveFront: unknown sample type for " + "slot %d (0x%x)\n", + i, rbuf[0]); + } + + if (rbuf[0] != WF_ST_EMPTY) { + hw->samples_used++; + } + } + + printk (KERN_INFO + "WaveFront: %d samples used (%d real, %d aliases, %d multi), " + "%d empty\n", hw->samples_used, sc_real, sc_alias, sc_multi, + WF_MAX_SAMPLE - hw->samples_used); + + + return 0; + +} + +static int +wavefront_get_patch_status (struct wf_config *hw) +{ + 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 (hw, WFC_UPLOAD_PATCH, patchbuf, + patchnum)) == 0) { + + hw->patch_status[i] |= WF_SLOT_FILLED; + p = (wavefront_patch *) patchbuf; + hw->sample_status + [p->sample_number|(p->sample_msb<<7)] |= + WF_SLOT_USED; + + } else if (x == 3) { /* Bad patch number */ + hw->patch_status[i] = 0; + } else { + printk (KERN_ERR "WaveFront: upload patch " + "error 0x%x\n", x); + hw->patch_status[i] = 0; + } + } + + /* program status has already filled in slot_used bits */ + + for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) { + if (hw->patch_status[i] & WF_SLOT_FILLED) { + cnt++; + } + if (hw->patch_status[i] & WF_SLOT_USED) { + cnt2++; + } + + } + printk (KERN_INFO + "WaveFront: %d patch slots filled, %d in use\n", cnt, cnt2); + + return 0; +} + +static int +wavefront_get_program_status (struct wf_config *hw) +{ + 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 (hw, WFC_UPLOAD_PROGRAM, progbuf, + &prognum)) == 0) { + + hw->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) { + hw->patch_status + [prog.layer[l].patch_number] |= + WF_SLOT_USED; + } + } + } else if (x == 1) { /* Bad program number */ + hw->prog_status[i] = 0; + } else { + printk (KERN_ERR "WaveFront: upload program " + "error 0x%x\n", x); + hw->prog_status[i] = 0; + } + } + + for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) { + if (hw->prog_status[i]) { + cnt++; + } + } + + printk (KERN_INFO "WaveFront: %d programs slots in use\n", cnt); + + return 0; +} + +static int +wavefront_send_patch (wf_config *hw, + wavefront_patch_info *header) + +{ + unsigned char buf[WF_PATCH_BYTES+2]; + unsigned char *bptr; + + if (hw->debug & WF_DEBUG_LOAD_PATCH) { + printk (KERN_DEBUG "WaveFront: downloading patch %d\n", + header->number); + } + + hw->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 (hw, WFC_DOWNLOAD_PATCH, 0, buf)) { + printk (KERN_ERR "WaveFront: download patch failed\n"); + return -EIO; + } + + return 0; +} + +static int +wavefront_send_program (wf_config *hw, + wavefront_patch_info *header) + +{ + unsigned char buf[WF_PROGRAM_BYTES+1]; + int i; + + if (hw->debug & WF_DEBUG_LOAD_PATCH) { + printk (KERN_DEBUG + "WaveFront: downloading program %d\n", header->number); + } + + hw->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) { + hw->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 (hw, WFC_DOWNLOAD_PROGRAM, 0, buf)) { + printk (KERN_WARNING "WaveFront: download patch failed\n"); + return -EIO; + } + + return 0; +} + +static int +wavefront_freemem (wf_config *hw) + +{ + char rbuf[8]; + + if (wavefront_cmd (hw, WFC_REPORT_FREE_MEMORY, rbuf, 0)) { + printk (KERN_WARNING "WaveFront: can't get memory stats.\n"); + return -1; + } else { + return demunge_int32 (rbuf, 4); + } +} + +static int +wavefront_send_sample (wf_config *hw, + wavefront_patch_info *header, + UINT16 *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 *data_end = 0; + 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; + + if (hw->debug & WF_DEBUG_LOAD_PATCH) { + printk (KERN_DEBUG "WaveFront: sample %sdownload for slot %d, " + "type %d, %d bytes from 0x%x\n", + header->size ? "" : "header ", + header->number, header->subkey, header->size, + (int) header->dataptr); + } + + if (header->size) { + + /* XXX its 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 24 * 512 bytes (12K) of kernel space just to + hold copies of the original sample headers; the whole + patch/program/sample header data is about 158K!!! + */ + + if (hw->rom_samples_rdonly) { + if (hw->sample_status[header->number] & WF_SLOT_ROM) { + printk (KERN_ERR "WaveFront: sample slot %d " + "write protected\n", + header->number); + return -EACCES; + } + } + + wavefront_delete_sample (hw, header->number); + } + + if (header->size) { + hw->freemem = wavefront_freemem (hw); + + if (hw->freemem < header->size) { + printk (KERN_ERR + "WaveFront: insufficient memory to " + "load %d byte sample.\n", + header->size); + return -ENOMEM; + } + + } + + skip = WF_GET_CHANNEL(&header->hdr.s); + + if (skip > 0) { + switch (header->hdr.s.SampleResolution) { + case LINEAR_16BIT: + break; + default: + printk (KERN_ERR + "WaveFront: 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; + } + + if (hw->debug & WF_DEBUG_LOAD_PATCH) { + printk (KERN_DEBUG "WaveFront: 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 12-bit transfer size ? + */ + + 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 (hw, header->size ? + WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER, + 0, sample_hdr)) { + printk (KERN_WARNING "WaveFront: 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 (hw, WFC_DOWNLOAD_BLOCK, 0, 0)) { + printk (KERN_WARNING "WaveFront: 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) { + + 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, hw->block_port); + } else { + outw (sample_short, hw->last_block_port); + } + } + + /* Get "DMA page acknowledge" */ + + if ((dma_ack = wavefront_read (hw)) != WF_DMA_ACK) { + if (dma_ack == -1) { + printk (KERN_ERR "WaveFront: upload sample " + "DMA ack timeout\n"); + return -EIO; + } else { + printk (KERN_ERR "WaveFront: upload sample " + "DMA ack error 0x%x\n", + dma_ack); + return -EIO; + } + } + } + + hw->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 (struct wf_config *hw, + wavefront_patch_info *header) + +{ + unsigned char alias_hdr[WF_ALIAS_BYTES]; + + if (hw->debug & WF_DEBUG_LOAD_PATCH) { + printk (KERN_DEBUG "WaveFront: 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 (hw, WFC_DOWNLOAD_SAMPLE_ALIAS, 0, alias_hdr)) { + printk (KERN_ERR "WaveFront: download alias failed.\n"); + return -EIO; + } + + hw->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS); + + return 0; +} + +static int +wavefront_send_multisample (struct wf_config *hw, + 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; + + if (hw->debug & WF_DEBUG_LOAD_PATCH) { + printk (KERN_DEBUG "WaveFront: multi %d with %d=%d samples\n", + header->number, header->hdr.ms.NumberOfSamples, num_samples); + } + + for (i = 0; i < num_samples; i++) { + if ((hw->debug & (WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA)) == + (WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA)) { + printk (KERN_DEBUG "WaveFront: 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 (hw, WFC_DOWNLOAD_MULTISAMPLE, + (unsigned char *) ((num_samples*2)+3), + msample_hdr)) { + printk (KERN_ERR "WaveFront: download of multisample failed.\n"); + return -EIO; + } + + hw->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE); + + return 0; +} + +static int +wavefront_fetch_multisample (struct wf_config *hw, + 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 (hw, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) { + printk (KERN_ERR "WaveFront: upload multisample failed.\n"); + return -EIO; + } + + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG "WaveFront: 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++) { + char d[2]; + + if ((d[0] = wavefront_read (hw)) == -1) { + printk (KERN_ERR "WaveFront: upload multisample failed " + "during sample loop.\n"); + return -EIO; + } + + if ((d[1] = wavefront_read (hw)) == -1) { + printk (KERN_ERR "WaveFront: upload multisample failed " + "during sample loop.\n"); + return -EIO; + } + + header->hdr.ms.SampleNumber[i] = + demunge_int32 ((unsigned char *) d, 2); + + if (hw->debug & WF_DEBUG_DATA) { + printk (KERN_DEBUG "WaveFront: msample " + "sample[%d] = %d\n", + i, header->hdr.ms.SampleNumber[i]); + } + } + + return 0; +} + + +static int +wavefront_send_drum (struct wf_config *hw, wavefront_patch_info *header) + +{ + unsigned char drumbuf[WF_DRUM_BYTES]; + wavefront_drum *drum = &header->hdr.d; + int i; + + if (hw->debug & WF_DEBUG_LOAD_PATCH) { + printk (KERN_DEBUG + "WaveFront: 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 (hw, WFC_DOWNLOAD_EDRUM_PROGRAM, 0, drumbuf)) { + printk (KERN_ERR "WaveFront: download drum failed.\n"); + return -EIO; + } + + return 0; +} + +static int +wavefront_find_free_sample (struct wf_config *hw) + +{ + int i; + + for (i = 0; i < WF_MAX_SAMPLE; i++) { + if (!(hw->sample_status[i] & WF_SLOT_FILLED)) { + return i; + } + } + printk (KERN_WARNING "WaveFront: no free sample slots!\n"); + return -1; +} + +static int +wavefront_find_free_patch (struct wf_config *hw) + +{ + int i; + + for (i = 0; i < WF_MAX_SAMPLE; i++) { + if (!(hw->patch_status[i] & WF_SLOT_FILLED)) { + return i; + } + } + printk (KERN_WARNING "WaveFront: 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 (struct wf_config *hw, + int dev, int format, const char *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; + + /* Copy in the header of the GUS patch */ + + sizeof_patch = (long) &guspatch.data[0] - (long) &guspatch; + COPY_FROM_USER (&((char *) &guspatch)[offs], + &(addr)[offs], sizeof_patch - offs); + + if ((i = wavefront_find_free_patch (hw)) == -1) { + return -EBUSY; + } + pat.number = i; + pat.subkey = WF_ST_PATCH; + patp = &pat.hdr.p; + + if ((i = wavefront_find_free_sample (hw)) == -1) { + return -EBUSY; + } + 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].updown=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 (hw, &samp, + (unsigned short *) &(addr)[sizeof_patch], + (guspatch.mode & WAVE_UNSIGNED) ? 1:0); + wavefront_send_patch (hw, &pat); + wavefront_send_program (hw, &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. + */ + +#ifdef CONFIG_MIDI + if (hw->mididev > 0) { + midi_synth_controller (hw->mididev, guspatch.instr_no, 10, + ((guspatch.panning << 4) > 127) ? + 127 : (guspatch.panning << 4)); + } +#endif CONFIG_MIDI + + return(0); +} + +int +wavefront_load_patch (int dev, int format, const char *addr, + int offs, int count, int pmgr_flag) +{ + + struct wf_config *hw; + wavefront_patch_info header; + + if ((hw = hw_from_dev (dev)) == 0) { + return -EINVAL; + } + + if (format == SYSEX_PATCH) { /* Handled by midi_synth.c */ + if (midi_load_patch == NULL) { + printk (KERN_ERR + "WaveFront: SYSEX not loadable: " + "no midi patch loader!\n"); + return -EINVAL; + } + return midi_load_patch (dev, format, addr, + offs, count, pmgr_flag); + + } else if (format == GUS_PATCH) { + return wavefront_load_gus_patch (hw, dev, format, + addr, offs, count, pmgr_flag); + + } else if (format != WAVEFRONT_PATCH) { + printk (KERN_ERR "WaveFront: unknown patch format %d\n", format); + return -EINVAL; + } + + if (count < sizeof (wavefront_patch_info)) { + printk (KERN_ERR "WaveFront: sample header too short\n"); + return -EINVAL; + } + + /* copied in so far: `offs' bytes from `addr'. We shouldn't copy + them in again, and they correspond to header->key and header->devno. + So now, copy the rest of the wavefront_patch_info struct, except + for the 'hdr' field, since this is handled via indirection + through the 'hdrptr' field. + */ + + COPY_FROM_USER (&((char *) &header)[offs], &(addr)[offs], + sizeof(wavefront_patch_info) - + sizeof(wavefront_any) - offs); + + if (hw->debug & WF_DEBUG_LOAD_PATCH) { + printk (KERN_DEBUG "WaveFront: 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 */ + + COPY_FROM_USER ((unsigned char *) &header.hdr.s, + (unsigned char *) header.hdrptr, + sizeof (wavefront_sample)); + + return wavefront_send_sample (hw, &header, header.dataptr, 0); + + case WF_ST_MULTISAMPLE: + + COPY_FROM_USER ((unsigned char *) &header.hdr.s, + (unsigned char *) header.hdrptr, + sizeof (wavefront_multisample)); + + return wavefront_send_multisample (hw, &header); + + + case WF_ST_ALIAS: + + COPY_FROM_USER ((unsigned char *) &header.hdr.a, + (unsigned char *) header.hdrptr, + sizeof (wavefront_alias)); + + return wavefront_send_alias (hw, &header); + + case WF_ST_DRUM: + COPY_FROM_USER ((unsigned char *) &header.hdr.d, + (unsigned char *) header.hdrptr, + sizeof (wavefront_drum)); + + return wavefront_send_drum (hw, &header); + + case WF_ST_PATCH: + COPY_FROM_USER ((unsigned char *) &header.hdr.p, + (unsigned char *) header.hdrptr, + sizeof (wavefront_patch)); + + return wavefront_send_patch (hw, &header); + + case WF_ST_PROGRAM: + COPY_FROM_USER ((unsigned char *) &header.hdr.pr, + (unsigned char *) header.hdrptr, + sizeof (wavefront_program)); + + return wavefront_send_program (hw, &header); + + default: + printk (KERN_ERR "WaveFront: 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 dev, int cmd, caddr_t arg) + +{ + struct wf_config *hw; + wavefront_control wc; + unsigned char patchnumbuf[2]; + int i; + + if ((hw = hw_from_dev (dev)) == 0) { + printk (KERN_ERR + "WaveFront: synth_control with unknown " + "device number %d\n", dev); + return -EINVAL; + } + + COPY_FROM_USER (&wc, arg, sizeof (wc)); + + if (hw->debug & WF_DEBUG_CMD) { + printk (KERN_DEBUG "WaveFront: synth control with " + "cmd 0x%x\n", wc.cmd); + } + + /* special case handling of or for various commands */ + + switch (wc.cmd) { + case WFC_DISABLE_INTERRUPTS: + printk (KERN_INFO "WaveFront: interrupts disabled.\n"); + outb (0x80|0x20, hw->control_port); + hw->interrupts_on = 0; + return 0; + + case WFC_ENABLE_INTERRUPTS: + printk (KERN_INFO "WaveFront: interrupts enabled.\n"); + outb (0x80|0x20|0x40, hw->control_port); + hw->interrupts_on = 1; + return 0; + + case WFC_INTERRUPT_STATUS: + wc.rbuf[0] = hw->interrupts_on; + return 0; + + case WFC_ROMSAMPLES_RDONLY: + hw->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 "WaveFront: invalid slot ID %d\n", + i); + wc.status = EINVAL; + return 0; + } + wc.rbuf[0] = hw->sample_status[i]; + wc.status = 0; + return 0; + + case WFC_DEBUG_DRIVER: + hw->debug = wc.wbuf[0]; + printk (KERN_INFO "WaveFront: debug = 0x%x\n", hw->debug); + return 0; + + case WFC_FX_IOCTL: + wffx_ioctl (hw, (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: + case WFC_UPLOAD_SAMPLE_ALIAS: + printk (KERN_INFO "WaveFront: support for various uploads " + "being considered.\n"); + wc.status = EINVAL; + return -EINVAL; + } + + wc.status = wavefront_cmd (hw, wc.cmd, wc.rbuf, wc.wbuf); + + /* Special case 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: + hw->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_MULTISAMPLE: + case WFC_UPLOAD_SAMPLE_ALIAS: + printk (KERN_INFO "WaveFront: support for " + "various uploads " + "being considered.\n"); + break; + + case WFC_VMIDI_OFF: + virtual_midi_disable (hw->mididev); + break; + + case WFC_VMIDI_ON: + virtual_midi_enable (hw->mididev, 0); + break; + + break; + } + } + + /* XXX It would be nice to avoid a complete copy of the whole + struct sometimes. But I think its fast enough that this + is a low priority fix. + */ + + COPY_TO_USER (arg, &wc, sizeof (wc)); + return 0; +} + + +/*********************************************************************** +WaveFront: MIDI synth interface +***********************************************************************/ + + +static int +wavefront_ioctl (int dev, unsigned int cmd, caddr_t arg) +{ + wf_config *hw; + unsigned char rbuf[4]; + + if ((hw = hw_from_dev (dev)) == 0) { + return -EINVAL; + } + + switch (cmd) { + case SNDCTL_SYNTH_INFO: + memcpy (&((char *) arg)[0], &wavefront_info, + sizeof (wavefront_info)); + return 0; + break; + + case SNDCTL_SEQ_RESETSAMPLES: + printk (KERN_WARNING + "WaveFront: cannot reset sample status in kernel.\n"); + return 0; /* don't force an error */ + break; + + case SNDCTL_SEQ_PERCMODE: + /* XXX does this correspond to anything obvious ?*/ + return 0; /* don't force an error */ + break; + + case SNDCTL_SYNTH_MEMAVL: + if (wavefront_cmd (hw, WFC_REPORT_FREE_MEMORY, rbuf, 0) != 0) { + printk (KERN_ERR + "WaveFront: cannot get free memory size\n"); + return 0; + } else { + hw->freemem = demunge_int32 (rbuf, 4); + return hw->freemem; + } + + case SNDCTL_SYNTH_CONTROL: + return wavefront_synth_control (dev, cmd, arg); + + default: + return -EINVAL; + } +} + +static int +wavefront_open (int dev, int mode) + +{ + struct wf_config *hw; + + if ((hw = hw_from_dev (dev)) == 0) { + return -EINVAL; + } + + if (hw->opened) { + printk (KERN_ERR "WaveFront: warning: device in use\n"); + } + + hw->opened = mode; + return 0; +} + +static void +wavefront_close (int dev) + +{ + struct wf_config *hw; + + if ((hw = hw_from_dev (dev)) == 0) { + printk (KERN_ERR + "WaveFront: close() called on non-existent dev %d", dev); + return; + } + + hw->opened = 0; + hw->debug = 0; + + return; +} + +static void +wavefront_aftertouch (int dev, int channel, int pressure) +{ + struct wf_config *hw = hw_from_dev (dev); + if (!hw) return; + midi_synth_aftertouch (hw->mididev,channel,pressure); +}; + +static void +wavefront_bender (int dev, int chn, int value) +{ + struct wf_config *hw = hw_from_dev (dev); + if (!hw) return; + midi_synth_bender (hw->mididev, chn, value); +}; + +static void +wavefront_controller (int dev, int channel, int ctrl_num, int value) +{ + struct wf_config *hw = hw_from_dev (dev); + if (!hw) return; + if(ctrl_num==CTRL_PITCH_BENDER) wavefront_bender(0,channel,value); + midi_synth_controller (hw->mididev, channel,ctrl_num,value); +}; + +static void +wavefront_panning(int dev, int channel, int pressure) +{ + struct wf_config *hw = hw_from_dev (dev); + if (!hw) return; + midi_synth_controller(hw->mididev,channel,CTL_PAN,pressure); +}; + +static int +wavefront_set_instr (int dev, int channel, int instr_no) +{ + struct wf_config *hw = hw_from_dev (dev); + if (!hw) return 1; + return(midi_synth_set_instr(hw->mididev,channel,instr_no)); +}; + +static int +wavefront_kill_note (int dev, int channel, int note, int volume) +{ + struct wf_config *hw = hw_from_dev (dev); + if (!hw) return 1; + if (note==255) + return(midi_synth_start_note(hw->mididev, channel, 0, 0)); + return(midi_synth_kill_note(hw->mididev, channel, note, volume)); +}; + +static int +wavefront_start_note (int dev, int channel, int note, int volume) +{ + struct wf_config *hw = hw_from_dev (dev); + if (!hw) return 1; + + if (note==255) { + /*midi_synth_controller(hw->mididev,channel,7,volume);*/ + midi_synth_aftertouch(hw->mididev,channel,volume); + return(0); + }; + if (volume==0) { + volume=127; + midi_synth_aftertouch(hw->mididev,channel,0); + }; + midi_synth_start_note (hw->mididev, channel, note, volume); + return(0); +}; + +static void +wavefront_setup_voice (int dev, int voice, int chn) +{ +}; + +static void wavefront_reset (int dev) + +{ + int i; + for(i=0;i<16;i++) { + midi_synth_kill_note (dev,i,0,0); + }; +}; + +static struct synth_operations wavefront_operations = +{ + "WaveFront", + &wavefront_info, + 0, + SYNTH_TYPE_SAMPLE, + SAMPLE_TYPE_WAVEFRONT, + wavefront_open, + wavefront_close, + wavefront_ioctl, + wavefront_kill_note, + wavefront_start_note, + wavefront_set_instr, + wavefront_reset, + NULL, + wavefront_load_patch, + wavefront_aftertouch, + wavefront_controller, + wavefront_panning, + NULL, + wavefront_bender, + NULL, + wavefront_setup_voice +}; + + +/*********************************************************************** +WaveFront: OSS/Free and/or Linux kernel installation interface +***********************************************************************/ + +void +wavefrontintr (int irq, void *dev_id, struct pt_regs *dummy) +{ + int i; + + if (irq < 0 || irq > 16) { + printk (KERN_WARNING "WaveFront: bogus interrupt %d recv'd\n", + irq); + } else if ((i = irq2hw[irq]) == -1) { + printk (KERN_ALERT + "WaveFront: interrupt from unknown hw (irq=%d).\n", irq); + } else { + wfs[i].irq_ok = 1; + } +} + +/* 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 + +*/ + +/* 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 +*/ + +int +probe_wavefront (struct address_info *hw_config) + +{ + int i; + int tmp1, tmp2; + unsigned char bits; + unsigned char rbuf[32], wbuf[32]; + wf_config *hw; + + if (hw_config->irq < 0 || hw_config->irq > 16) { + printk (KERN_WARNING "WaveFront: impossible IRQ suggested(%d)\n", + hw_config->irq); + return 0; + } + + /* Yeah yeah, TB docs say 8, but the FX device on the Tropez Plus + takes up another 8 ... + */ + + if (check_region (hw_config->io_base, 16)) { + printk (KERN_ERR "WaveFront: IO address range 0x%x - 0x%x " + "already in use - ignored\n", hw_config->io_base, + hw_config->io_base+15); + return 0; + } + + for (i = 0; i < WAVEFRONT_MAX_DEVICES; i++) { + if (!wfs[i].installed) { + wfs[i].installed = 1; + break; + } + } + + if (i == WAVEFRONT_MAX_DEVICES) { + printk (KERN_WARNING "WaveFront: no device slots available (max = %d).\n", + WAVEFRONT_MAX_DEVICES); + return 0; + } + + hw = &wfs[i]; + + hw->irq = hw_config->irq; + hw->base = hw_config->io_base; + + hw->israw = 0; + hw->debug = wf_debug_default; + hw->interrupts_on = 0; + hw->rom_samples_rdonly = 1; /* XXX default lock on ROM sample slots */ + + hw_config->slots[WF_SYNTH_SLOT] = hw->synthdev = -1; + hw_config->slots[WF_INTERNAL_MIDI_SLOT] = hw->mididev = -1; + hw_config->slots[WF_EXTERNAL_MIDI_SLOT] = hw->ext_mididev = -1; + + irq2hw[hw_config->irq] = i; + + if (wavefront_cmd (hw, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) { + hw->fw_version[0] = rbuf[0]; + hw->fw_version[1] = rbuf[1]; + printk (KERN_INFO "WaveFront: firmware %d.%d already loaded.\n", + rbuf[0], rbuf[1]); + + if (wavefront_cmd (hw, WFC_HARDWARE_VERSION, rbuf, wbuf) == 0) { + hw->hw_version[0] = rbuf[0]; + hw->hw_version[1] = rbuf[1]; + } else { + printk (KERN_INFO "WaveFront: not raw, but no hardware version!\n"); + return 0; + } + if (!wf_raw) { + return 1; + } + } else { + hw->israw = 1; + printk (KERN_INFO + "WaveFront: no response to firmware probe, " + "assume raw.\n"); + } + + if (request_irq (hw_config->irq, wavefrontintr, + 0, "WaveFront", NULL) < 0) { + printk (KERN_WARNING "WaveFront: IRQ %d not available!\n", + hw_config->irq); + return 0; + } + + switch (hw_config->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 "WaveFront: invalid IRQ %d\n", + hw_config->irq); + return 0; + } + + /* try reset of port */ + + outb (0x0, hw->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 + + XXX PBD: I think this documentation is backwards. I leave bit + 6 unset, and get MIDI data from the 9 pin D connector. + + 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, plus external MIDI interface selected */ + + outb (bits | 0x80, hw->data_port); + + /* take us out of reset, unmute, master + TX + RX interrupts on */ + + outb (0x80|0x20|0x40|0x10|0x1, hw->control_port); + + for (i = 0; i < 1000000 && !hw->irq_ok; i++); + + /* Data port is now the data port, not the h/w initialization port + + The boot ROM will check the OSRAM, and will then + wait for the either the "download OS" or + "report h/w version" commands. + + Any other command will supposedly be ignored. + */ + + if (!hw->irq_ok) { + printk (KERN_WARNING + "WaveFront: intr not received after h/w un-reset.\n"); + free_irq (hw_config->irq, NULL); + return 0; + } else { + hw->irq_ok = 0; + } + + hw->interrupts_on = 1; + + /* WaveFront SDK says: + + "When the Master Reset is set to zero (0), the audio board is held + in reset, which is the power-up condition. Setting Master Reset to one + (1) allows the on-board processor to run. It takes approximately two + to four seconds, depending on the memory configuration, for the + on-board processor to complete it's initialization routine before it + will respond to commands after a reset." + + Actually, it seems that most of the time, even with 8MB of RAM, + its actually ready immediately. + */ + + if (!wavefront_wait (hw, STAT_CAN_WRITE)) { + if (!wavefront_wait (hw, STAT_CAN_WRITE)) { + if (!wavefront_wait (hw, STAT_CAN_WRITE)) { + printk (KERN_WARNING + "WaveFront: OS not ready after " + "memory check.\n"); + free_irq (hw_config->irq, NULL); + return 0; + } + } + } + + /* get H/W version, and check we get an interrupt */ + + outb (WFC_HARDWARE_VERSION, hw->data_port); + + for (i = 0; i < 1000000 && !hw->irq_ok; i++); + + /* We don't need the IRQ anymore for the WaveFront code, + and to allow an MPU-401 driver to attach to it later, lets + give it back .... + + DO NOT alter irq2hw[], since we'll still use this to lookup + the config struct from an address_info struct. + */ + + free_irq (hw_config->irq, NULL); + + if (!hw->irq_ok) { + printk (KERN_WARNING + "WaveFront: interrupt not received after " + "h/w version cmd.\n"); + return 0; + } else { + hw->irq_ok = 0; + } + + if ((tmp1 = wavefront_read(hw)) == -1) { + printk (KERN_WARNING + "WaveFront @ 0x%x not ready, ignoring\n", hw->base); + return 0; + } + + if ((tmp2 = wavefront_read(hw)) == -1) { + printk (KERN_WARNING + "WaveFront @ 0x%x not responding correctly, ignoring\n", + hw->base); + return 0; + } + + printk (KERN_INFO "WaveFront: hardware version %d.%d\n", tmp1, tmp2); + + return 1; +} + +#include "os.h" +#define __KERNEL_SYSCALLS__ +#include <linux/fs.h> +#include <linux/mm.h> +#include <linux/malloc.h> +#include <linux/unistd.h> +#include <asm/uaccess.h> + +static int errno; + +static int +wavefront_download_firmware (wf_config *hw, 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 = open (path, 0, 0)) < 0) { + printk (KERN_WARNING "WaveFront: Unable to load \"%s\".\n", path); + return 1; + } + + while (1) { + int x; + + if ((x = read (fd, §ion_length, sizeof (section_length))) != + sizeof (section_length)) { + printk (KERN_ERR "WaveFront: firmware read error.\n"); + goto failure; + } + + if (section_length == 0) { + break; + } + + if (read (fd, section, section_length) != section_length) { + printk (KERN_ERR "WaveFront: firmware section " + "read error.\n"); + goto failure; + } + + /* Send command */ + + if (!wavefront_write (hw, WFC_DOWNLOAD_OS)) { + goto failure; + } + + for (i = 0; i < section_length; i++) { + if (!wavefront_write (hw, section[i])) { + goto failure; + } + } + + /* get ACK */ + + if (wavefront_wait (hw, STAT_CAN_READ)) { + + if ((c = inb (hw->data_port)) != WF_ACK) { + + printk (KERN_ERR "WaveFront: download " + "of section #%d not " + "acknowledged, ack = 0x%x\n", + section_cnt_downloaded + 1, c); + goto failure; + + } else if ((hw->debug & WF_DEBUG_IO) && + !(++section_cnt_downloaded % 10)) { + printk (KERN_DEBUG "."); + } + + } else { + printk (KERN_ERR "WaveFront: timed out " + "for download ACK.\n"); + } + + } + + close (fd); + set_fs (fs); + if (hw->debug & WF_DEBUG_IO) { + printk (KERN_DEBUG "\n"); + } + return 0; + + failure: + close (fd); + set_fs (fs); + printk (KERN_ERR "\nWaveFront: firmware download failed!!!\n"); + return 1; +} + +static int +wavefront_config_midi (wf_config *hw, struct address_info *hw_config) + +{ + unsigned char rbuf[4], wbuf[4]; + + if (!probe_wf_mpu (hw_config)) { + printk (KERN_WARNING "WaveFront: could not install " + "MPU-401 device.\n"); + return 1; + } + + /* Attach an modified MPU-401 driver to the master MIDI interface */ + + hw_config->name = "WaveFront Internal MIDI"; + attach_wf_mpu (hw_config); + + if (hw_config->slots[WF_INTERNAL_MIDI_SLOT] == -1) { + printk (KERN_WARNING "WaveFront: MPU-401 not configured.\n"); + return 1; + } + + hw->mididev = hw_config->slots[WF_INTERNAL_MIDI_SLOT]; + + /* Route external MIDI to WaveFront synth (by default) */ + + if (wavefront_cmd (hw, WFC_MISYNTH_ON, rbuf, wbuf)) { + printk (KERN_WARNING + "WaveFront: cannot enable MIDI-IN to synth routing.\n"); + /* XXX error ? */ + } + + /* 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[hw->mididev]->converter != NULL) { + midi_load_patch = midi_devs[hw->mididev]->converter->load_patch; + midi_devs[hw->mididev]->converter->load_patch = + &wavefront_load_patch; + } + + /* 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 (hw, WFC_VMIDI_OFF, rbuf, wbuf)) { + printk (KERN_WARNING "WaveFront: cannot disable " + "virtual MIDI mode\n"); + /* XXX go ahead and try anyway ? */ + } + + hw_config->name = "WaveFront External MIDI"; + + if (virtual_midi_enable (hw->mididev, hw_config)) { + printk (KERN_WARNING "WaveFront: no virtual MIDI access.\n"); + } else { + hw->ext_mididev = hw_config->slots[WF_EXTERNAL_MIDI_SLOT]; + if (wavefront_cmd (hw, WFC_VMIDI_ON, rbuf, wbuf)) { + printk (KERN_WARNING + "WaveFront: cannot enable virtual MIDI mode.\n"); + virtual_midi_disable (hw->mididev); + } + } + + return 0; +} + +static int +wavefront_init (wf_config *hw, struct address_info *hw_config) + +{ + int samples_are_from_rom = 0; + + /* XXX what state does the board need to be in before + I can download the firmware ? I think any state + after it acknowledges a hardware version command + post-booting. + */ + + if (hw->israw || wf_raw) { + samples_are_from_rom = 1; + + if (wavefront_download_firmware (hw, wf_ospath)) { + return 1; + } + + /* enter normal operation: + bit 7: (on) reset 0x80 + bit 6: interrupts enabled 0x40 + bit 5: (on) mute (i.e. in play mode) 0x20 + bits 4-0: zero + + note: tx and rx interrupts turned off + */ + + outb (0x80|0x40|0x20, hw->control_port); + + /* Set up MPU-401 emulation mode. For some reason, this always + fails the first time, and generates no ACK, so we'll + treat it as a special case by sleeping for a while, and then + trying again. + */ + + wavefront_write (hw, 0xf0); + wavefront_write (hw, 1); + wavefront_sleep (hw, (HZ/wf_sleep_interval) * wf_sleep_tries); + wavefront_write (hw, 0xf0); + wavefront_write (hw, 1); + if (wavefront_read (hw) != 0x80) { + printk (KERN_ERR + "WaveFront: set MPU emulation mode " + "command failed.\n"); + return (1); + } + } + + hw->freemem = wavefront_freemem (hw); + printk (KERN_INFO "WaveFront: available DRAM %dk\n", hw->freemem / 1024); + + wavefront_get_sample_status (hw, samples_are_from_rom); + wavefront_get_program_status (hw); + wavefront_get_patch_status (hw); + + if (fx_raw) { + wffx_init (hw); + } + + return 0; +} + +void +attach_wavefront (struct address_info *hw_config) +{ + int i; + struct wf_config *hw; + + if ((i = irq2hw[hw_config->irq]) == -1) { + printk (KERN_ERR "WaveFront: cannot attach unknown irq 0x%x.\n", + hw_config->irq); + return; + } + + hw = &wfs[i]; + + if ((i = sound_alloc_synthdev()) == -1) { + printk (KERN_ERR "WaveFront: Too many synthesizers\n"); + return; + } else { + hw_config->slots[WF_SYNTH_SLOT] = i; + hw->synthdev = i; + dev2hw[hw->synthdev] = i; + synth_devs[hw->synthdev] = &wavefront_operations; + } + + if (wavefront_init (hw, hw_config)) { + printk (KERN_WARNING "WaveFront: board could not " + "be initialized.\n"); + sound_unload_synthdev (i); + hw->installed = 0; + return; + } + + request_region (hw_config->io_base+2, 6, "WaveFront synth"); + request_region (hw_config->io_base+8, 8, "WaveFront FX"); + + conf_printf2 ("WaveFront Synth", hw_config->io_base, 0, -1, -1); + +#if defined(CONFIG_MIDI) + if (wavefront_config_midi (hw, hw_config)) { + printk (KERN_WARNING "WaveFront: could not initialize MIDI.\n"); + } +#else + printk (KERN_WARNING + "WaveFront: MIDI not configured at kernel-config time.\n"); +#endif CONFIG_MIDI + + return; +} +void +unload_wavefront (struct address_info *hw_config) +{ + struct wf_config *hw; + int i; + + if ((i = irq2hw[hw_config->irq]) == -1) { + printk (KERN_ERR "WaveFront: unloading unrecognized device!\n"); + return; + } + hw = &wfs[i]; + + /* the first two are freed by the wf_mpu code */ + release_region (hw_config->io_base+2, 6); + release_region (hw_config->io_base+8, 8); + sound_unload_synthdev (hw->synthdev); +#if defined(CONFIG_MIDI) + unload_wf_mpu (hw_config); +#endif +} + +/***********************************************************************/ +/* 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 (struct wf_config *hw) + +{ + int i; + unsigned int x = 0x80; + + for (i = 0; i < 1000; i++) { + x = inb (hw->fx_status); + if ((x & 0x80) == 0) { + break; + } + } + + if (x & 0x80) { + printk (KERN_ERR "WaveFront: FX device never idle.\n"); + return 0; + } + + return (1); +} + +static void +wffx_mute (struct wf_config *hw, int onoff) + +{ + if (!wffx_idle(hw)) { + return; + } + + outb (onoff ? 0x02 : 0x00, hw->fx_op); +} + +static int +wffx_memset (struct wf_config *hw, int page, + int addr, int cnt, unsigned short *data) +{ + if (page < 0 || page > 7) { + printk (KERN_ERR "WaveFront: FX memset: " + "page must be >= 0 and <= 7\n"); + return -EINVAL; + } + + if (addr < 0 || addr > 0x7f) { + printk (KERN_ERR "WaveFront: FX memset: " + "addr must be >= 0 and <= 7f\n"); + return -EINVAL; + } + + if (cnt == 1) { + + outb (FX_LSB_TRANSFER, hw->fx_lcr); + outb (page, hw->fx_dsp_page); + outb (addr, hw->fx_dsp_addr); + outb ((data[0] >> 8), hw->fx_dsp_msb); + outb ((data[0] & 0xff), hw->fx_dsp_lsb); + + printk (KERN_INFO "WaveFront: FX: addr %d:%x set to 0x%x\n", + page, addr, data[0]); + + } else { + int i; + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (page, hw->fx_dsp_page); + outb (addr, hw->fx_dsp_addr); + + for (i = 0; i < cnt; i++) { + outb ((data[i] >> 8), hw->fx_dsp_msb); + outb ((data[i] & 0xff), hw->fx_dsp_lsb); + if (!wffx_idle (hw)) { + break; + } + } + + if (i != cnt) { + printk (KERN_WARNING + "WaveFront: FX memset " + "(0x%x, 0x%x, 0x%x, %d) incomplete\n", + page, addr, (int) data, cnt); + return -EIO; + } + } + + return 0; +} + +static int +wffx_ioctl (struct wf_config *hw, wavefront_fx_info *r) + +{ + unsigned short page_data[256]; + unsigned short *pd; + + switch (r->request) { + case WFFX_MUTE: + wffx_mute (hw, r->data[0]); + return 0; + + case WFFX_MEMSET: + + if (r->data[2] <= 0) { + printk (KERN_ERR "WaveFront: 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 + "WaveFront: cannot write " + "> 255 bytes to FX\n"); + return -EINVAL; + } + COPY_FROM_USER(page_data, (unsigned char *) r->data[3], + r->data[2]); + pd = page_data; + } + + return wffx_memset (hw, + r->data[0], /* page */ + r->data[1], /* addr */ + r->data[2], /* cnt */ + pd); + + default: + printk (KERN_WARNING + "WaveFront: 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. It's 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 +wffx_init (struct wf_config *hw) + +{ + 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 (hw)) { + return (-1); + } + + outb (i, hw->fx_mod_addr); + outb (0x0, hw->fx_mod_data); + } + } + + if (!wffx_idle(hw)) return (-1); + outb (0x02, hw->fx_op); /* mute on */ + + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x44, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x42, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x43, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x7c, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x7e, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x46, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x49, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x47, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x4a, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->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 (hw)) { + return (-1); + } + + outb (i, hw->fx_mod_addr); + outb (0x0, hw->fx_mod_data); + } + /* load page zero */ + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x00, hw->fx_dsp_page); + outb (0x00, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_zero); i += 2) { + outb (page_zero[i], hw->fx_dsp_msb); + outb (page_zero[i+1], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + /* Now load page one */ + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x01, hw->fx_dsp_page); + outb (0x00, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_one); i += 2) { + outb (page_one[i], hw->fx_dsp_msb); + outb (page_one[i+1], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x02, hw->fx_dsp_page); + outb (0x00, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_two); i++) { + outb (page_two[i], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x03, hw->fx_dsp_page); + outb (0x00, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_three); i++) { + outb (page_three[i], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x04, hw->fx_dsp_page); + outb (0x00, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_four); i++) { + outb (page_four[i], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + /* Load memory area (page six) */ + + outb (FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x06, hw->fx_dsp_page); + + for (i = 0; i < sizeof (page_six); i += 3) { + outb (page_six[i], hw->fx_dsp_addr); + outb (page_six[i+1], hw->fx_dsp_msb); + outb (page_six[i+2], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x07, hw->fx_dsp_page); + outb (0x00, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_seven); i += 2) { + outb (page_seven[i], hw->fx_dsp_msb); + outb (page_seven[i+1], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) 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, hw->fx_mod_addr); + outb (i, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + outb (0x02, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + for (i = 0xb0; i <= 0xbf; i++) { + outb (i, hw->fx_mod_addr); + outb (0x20, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + for (i = 0xf0; i <= 0xff; i++) { + outb (i, hw->fx_mod_addr); + outb (0x20, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + for (i = 0x10; i <= 0x1d; i++) { + outb (i, hw->fx_mod_addr); + outb (0xff, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + outb (0x1e, hw->fx_mod_addr); + outb (0x40, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + for (i = 0x1f; i <= 0x2d; i++) { + outb (i, hw->fx_mod_addr); + outb (0xff, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + outb (0x2e, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + for (i = 0x2f; i <= 0x3e; i++) { + outb (i, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + outb (0x3f, hw->fx_mod_addr); + outb (0x20, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + for (i = 0x40; i <= 0x4d; i++) { + outb (i, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + outb (0x4e, hw->fx_mod_addr); + outb (0x0e, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + outb (0x4f, hw->fx_mod_addr); + outb (0x0e, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + + for (i = 0x50; i <= 0x6b; i++) { + outb (i, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + outb (0x6c, hw->fx_mod_addr); + outb (0x40, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + outb (0x6d, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + outb (0x6e, hw->fx_mod_addr); + outb (0x40, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + outb (0x6f, hw->fx_mod_addr); + outb (0x40, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + for (i = 0x70; i <= 0x7f; i++) { + outb (i, hw->fx_mod_addr); + outb (0xc0, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + for (i = 0x80; i <= 0xaf; i++) { + outb (i, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + for (i = 0xc0; i <= 0xdd; i++) { + outb (i, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + outb (0xde, hw->fx_mod_addr); + outb (0x10, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + outb (0xdf, hw->fx_mod_addr); + outb (0x10, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + + for (i = 0xe0; i <= 0xef; i++) { + outb (i, hw->fx_mod_addr); + outb (0x00, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + for (i = 0x00; i <= 0x0f; i++) { + outb (0x01, hw->fx_mod_addr); + outb (i, hw->fx_mod_data); + outb (0x02, hw->fx_mod_addr); + outb (0x01, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + outb (0x02, hw->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], hw->fx_dsp_page); + outb (coefficients[i+1], hw->fx_dsp_addr); + outb (coefficients[i+2], hw->fx_dsp_msb); + outb (coefficients[i+3], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + /* Some settings (?) that are too small to bundle into loops */ + + if (!wffx_idle(hw)) return (-1); + outb (0x1e, hw->fx_mod_addr); + outb (0x14, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + outb (0xde, hw->fx_mod_addr); + outb (0x20, hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + outb (0xdf, hw->fx_mod_addr); + outb (0x20, hw->fx_mod_data); + + /* some more coefficients */ + + if (!wffx_idle(hw)) return (-1); + outb (0x06, hw->fx_dsp_page); + outb (0x78, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x40, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x03, hw->fx_dsp_addr); + outb (0x0f, hw->fx_dsp_msb); + outb (0xff, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x0b, hw->fx_dsp_addr); + outb (0x0f, hw->fx_dsp_msb); + outb (0xff, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x02, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x0a, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x46, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + outb (0x07, hw->fx_dsp_page); + outb (0x49, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->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, hw->fx_lcr); + outb (0x00, hw->fx_dsp_page); + outb (0x10, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_zero_v2); i += 2) { + outb (page_zero_v2[i], hw->fx_dsp_msb); + outb (page_zero_v2[i+1], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x01, hw->fx_dsp_page); + outb (0x10, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_one_v2); i += 2) { + outb (page_one_v2[i], hw->fx_dsp_msb); + outb (page_one_v2[i+1], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + if (!wffx_idle(hw)) return (-1); + if (!wffx_idle(hw)) return (-1); + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x02, hw->fx_dsp_page); + outb (0x10, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_two_v2); i++) { + outb (page_two_v2[i], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x03, hw->fx_dsp_page); + outb (0x10, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_three_v2); i++) { + outb (page_three_v2[i], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x04, hw->fx_dsp_page); + outb (0x10, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_four_v2); i++) { + outb (page_four_v2[i], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x06, hw->fx_dsp_page); + + /* Page six v.2 is algorithmic */ + + for (i = 0x10; i <= 0x3e; i += 2) { + outb (i, hw->fx_dsp_addr); + outb (0x00, hw->fx_dsp_msb); + outb (0x00, hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (FX_AUTO_INCR|FX_LSB_TRANSFER, hw->fx_lcr); + outb (0x07, hw->fx_dsp_page); + outb (0x10, hw->fx_dsp_addr); + + for (i = 0; i < sizeof (page_seven_v2); i += 2) { + outb (page_seven_v2[i], hw->fx_dsp_msb); + outb (page_seven_v2[i+1], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + for (i = 0x00; i < sizeof(mod_v2); i += 2) { + outb (mod_v2[i], hw->fx_mod_addr); + outb (mod_v2[i+1], hw->fx_mod_data); + if (!wffx_idle(hw)) return (-1); + } + + for (i = 0; i < sizeof (coefficients2); i += 4) { + outb (coefficients2[i], hw->fx_dsp_page); + outb (coefficients2[i+1], hw->fx_dsp_addr); + outb (coefficients2[i+2], hw->fx_dsp_msb); + outb (coefficients2[i+3], hw->fx_dsp_lsb); + if (!wffx_idle(hw)) return (-1); + } + + outb (0x00, hw->fx_op); + if (!wffx_idle(hw)) return (-1); + + for (i = 0; i < sizeof (coefficients3); i += 2) { + int x; + + outb (0x07, hw->fx_dsp_page); + x = (i % 4) ? 0x4e : 0x4c; + outb (x, hw->fx_dsp_addr); + outb (coefficients3[i], hw->fx_dsp_msb); + outb (coefficients3[i+1], hw->fx_dsp_lsb); + } + + outb (0x00, hw->fx_op); /* mute off */ + + return 0; +} + +EXPORT_NO_SYMBOLS; +struct address_info cfg; + +int io = -1; +int irq = -1; + +MODULE_PARM(io,"i"); +MODULE_PARM(irq,"i"); + +int init_module (void) + +{ + printk ("Turtle Beach WaveFront Driver\n" + "Copyright (C) by Hannu Savolainen, " + "Paul Barton-Davis 1993-1998.\n"); + + if (io == -1 || irq == -1) { + printk (KERN_INFO "WaveFront: irq and io " + "options must be set.\n"); + return -EINVAL; + } + cfg.io_base = io; + cfg.irq = irq; + + if (probe_wavefront (&cfg) == 0) { + return -ENODEV; + } + attach_wavefront (&cfg); + SOUND_LOCK; + return 0; +} + +void cleanup_module (void) + +{ + unload_wavefront (&cfg); + SOUND_LOCK_END; +} + +#endif MODULE +#endif CONFIG_SOUND_WAVEFRONT + + |