diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 15:20:36 -0700 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 15:20:36 -0700 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /sound/oss/wavfront.c | |
download | kernel_samsung_aries-1da177e4c3f41524e886b7f1b8a0c1fc7321cac2.zip kernel_samsung_aries-1da177e4c3f41524e886b7f1b8a0c1fc7321cac2.tar.gz kernel_samsung_aries-1da177e4c3f41524e886b7f1b8a0c1fc7321cac2.tar.bz2 |
Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'sound/oss/wavfront.c')
-rw-r--r-- | sound/oss/wavfront.c | 3538 |
1 files changed, 3538 insertions, 0 deletions
diff --git a/sound/oss/wavfront.c b/sound/oss/wavfront.c new file mode 100644 index 0000000..cce1278 --- /dev/null +++ b/sound/oss/wavfront.c @@ -0,0 +1,3538 @@ +/* -*- 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 ***************************************/ + +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, + SA_INTERRUPT|SA_SHIRQ, + "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 (check_region (io_base, 16)) { + 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"); + return 0; + } + + if (!wf_raw) { + 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"); + return 0; + } + + /* Check for FX device, present only on Tropez+ */ + + dev.has_fx = (detect_wffx () == 0); + + 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, §ion_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 ((dev.synth_dev = register_sound_synth (&wavefront_fops, -1)) < 0) { + printk (KERN_ERR LOGNAME "cannot register raw synth\n"); + return -1; + } + +#if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ + if ((dev.oss_dev = sound_alloc_synthdev()) == -1) { + printk (KERN_ERR LOGNAME "Too many sequencers\n"); + return -1; + } 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 */ + + return -1; + } + + request_region (dev.base+2, 6, "wavefront synth"); + + if (dev.has_fx) { + request_region (dev.base+8, 8, "wavefront fx"); + } + + if (wavefront_config_midi ()) { + printk (KERN_WARNING LOGNAME "could not initialize MIDI.\n"); + } + + return dev.oss_dev; +} + +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; +} + +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); |