// SPDX-License-Identifier: GPL-2.0-only /* Copyright (C) by Paul Barton-Davis 1998-1999 * * Some portions of this file are taken from work that is * copyright (C) by Hannu Savolainen 1993-1996 */ /* * An ALSA lowlevel driver for Turtle Beach ICS2115 wavetable synth * (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. * */ #include <linux/io.h> #include <linux/interrupt.h> #include <linux/init.h> #include <linux/delay.h> #include <linux/time.h> #include <linux/wait.h> #include <linux/sched/signal.h> #include <linux/firmware.h> #include <linux/moduleparam.h> #include <linux/slab.h> #include <linux/module.h> #include <sound/core.h> #include <sound/snd_wavefront.h> #include <sound/initval.h> static int wf_raw = …; /* we normally check for "raw state" to firmware loading. if non-zero, 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 = …; /* 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 */ #define DEFAULT_OSPATH … static char *ospath = …; /* the firmware file name */ static int wait_usecs = …; /* This magic number seems to give pretty optimal throughput based on my limited experimentation. If you want to play around with it and find a better value, be my guest. Remember, the idea is to get a number that causes us to just busy wait for as many WaveFront commands as possible, without coming up with a number so large that we hog the whole CPU. Specifically, with this number, out of about 134,000 status waits, only about 250 result in a sleep. */ static int sleep_interval = …; /* HZ/sleep_interval seconds per sleep */ static int sleep_tries = …; /* number of times we'll try to sleep */ static int reset_time = …; /* hundreths of a second we wait after a HW reset for the expected interrupt. */ static int ramcheck_time = …; /* time in seconds to wait while ROM code checks on-board RAM. */ static int osrun_time = …; /* time in seconds we wait for the OS to start running. */ module_param(wf_raw, int, 0444); MODULE_PARM_DESC(…) …; module_param(fx_raw, int, 0444); MODULE_PARM_DESC(…) …; module_param(debug_default, int, 0444); MODULE_PARM_DESC(…) …; module_param(wait_usecs, int, 0444); MODULE_PARM_DESC(…) …; module_param(sleep_interval, int, 0444); MODULE_PARM_DESC(…) …; module_param(sleep_tries, int, 0444); MODULE_PARM_DESC(…) …; module_param(ospath, charp, 0444); MODULE_PARM_DESC(…) …; module_param(reset_time, int, 0444); MODULE_PARM_DESC(…) …; module_param(ramcheck_time, int, 0444); MODULE_PARM_DESC(…) …; module_param(osrun_time, int, 0444); MODULE_PARM_DESC(…) …; /* 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 … #ifdef WF_DEBUG #define DPRINT(cond, ...) … #else #define DPRINT … #endif /* WF_DEBUG */ #define LOGNAME … /* bitmasks for WaveFront status port value */ #define STAT_RINTR_ENABLED … #define STAT_CAN_READ … #define STAT_INTR_READ … #define STAT_WINTR_ENABLED … #define STAT_CAN_WRITE … #define STAT_INTR_WRITE … static int wavefront_delete_sample (snd_wavefront_t *, int sampnum); static int wavefront_find_free_sample (snd_wavefront_t *); struct wavefront_command { … }; static struct { … } wavefront_errors[] = …; #define NEEDS_ACK … static struct wavefront_command wavefront_commands[] = …; static const char * wavefront_errorstr (int errnum) { … } static struct wavefront_command * wavefront_get_command (int cmd) { … } static inline int wavefront_status (snd_wavefront_t *dev) { … } static int wavefront_sleep (int limit) { … } static int wavefront_wait (snd_wavefront_t *dev, int mask) { … } static int wavefront_read (snd_wavefront_t *dev) { … } static int wavefront_write (snd_wavefront_t *dev, unsigned char data) { … } int snd_wavefront_cmd (snd_wavefront_t *dev, int cmd, unsigned char *rbuf, unsigned char *wbuf) { … } /*********************************************************************** 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) { unsigned 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) { … } static unsigned char * demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes) { … } /*********************************************************************** WaveFront: sample, patch and program management. ***********************************************************************/ static int wavefront_delete_sample (snd_wavefront_t *dev, int sample_num) { … } static int wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom) { … } static int wavefront_get_patch_status (snd_wavefront_t *dev) { … } static int wavefront_get_program_status (snd_wavefront_t *dev) { … } static int wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header) { … } static int wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header) { … } static int wavefront_freemem (snd_wavefront_t *dev) { … } static int wavefront_send_sample (snd_wavefront_t *dev, wavefront_patch_info *header, u16 __user *dataptr, int data_is_unsigned) { … } static int wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header) { … } static int wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header) { … } static int wavefront_fetch_multisample (snd_wavefront_t *dev, wavefront_patch_info *header) { … } static int wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header) { … } static int wavefront_find_free_sample (snd_wavefront_t *dev) { … } #if 0 static int wavefront_find_free_patch (snd_wavefront_t *dev) { int i; for (i = 0; i < WF_MAX_PATCH; i++) { if (!(dev->patch_status[i] & WF_SLOT_FILLED)) { return i; } } snd_printk ("no free patch slots!\n"); return -1; } #endif static int wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr) { … } /*********************************************************************** WaveFront: hardware-dependent interface ***********************************************************************/ static void process_sample_hdr (u8 *buf) { … } static int wavefront_synth_control (snd_wavefront_card_t *acard, wavefront_control *wc) { … } int snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file) { … } int snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file) { … } int snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file, unsigned int cmd, unsigned long arg) { … } /***********************************************************************/ /* WaveFront: interface for card-level wavefront module */ /***********************************************************************/ void snd_wavefront_internal_interrupt (snd_wavefront_card_t *card) { … } /* 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 snd_wavefront_interrupt_bits (int irq) { … } static void wavefront_should_cause_interrupt (snd_wavefront_t *dev, int val, int port, unsigned long timeout) { … } static int wavefront_reset_to_cleanliness (snd_wavefront_t *dev) { … } static int wavefront_download_firmware (snd_wavefront_t *dev, char *path) { … } static int wavefront_do_reset (snd_wavefront_t *dev) { … } int snd_wavefront_start (snd_wavefront_t *dev) { … } int snd_wavefront_detect (snd_wavefront_card_t *card) { … } MODULE_FIRMWARE(…);
Codebase Browser
linux