// 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 = 0 ; /* 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 = 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 = 0 ; /* you can set this to control debugging during driver loading . it takes any combination of the WF_DEBUG_ * flags defined in wavefront . h /* XXX this needs to be made firmware and hardware version dependent */ #define DEFAULT_OSPATH "wavefront.os" static char *ospath = DEFAULT_OSPATH; /* the firmware file name */ static int wait_usecs = 150 ; /* 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 = 100 ; /* HZ/sleep_interval seconds per sleep */ static int sleep_tries = 50 ; /* number of times we'll try to sleep */ 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 . int , 0444 );"if non-zero, assume that we need to boot the OS" );int , 0444 );"if non-zero, assume that the FX process needs help" );int , 0444 );"debug parameters for card initialization" );int , 0444 );"how long to wait without sleeping, usecs" );int , 0444 );"how long to sleep when waiting for reply" );int , 0444 );"how many times to try sleeping during a wait" );0444 );"pathname to processed ICS2115 OS firmware" );int , 0444 );"how long to wait for a reset to take effect" );int , 0444 );"how many seconds to wait for the RAM test" );int , 0444 );"how many seconds to wait for the ICS2115 OS" );/* 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#define DPRINT(cond, ...) \if ((dev->debug & (cond)) == (cond)) { \#else #define DPRINT(cond, args...)#endif /* WF_DEBUG */ #define LOGNAME "WaveFront: " /* bitmasks for WaveFront status port value */ #define STAT_RINTR_ENABLED 0 x01#define STAT_CAN_READ 0 x02#define STAT_INTR_READ 0 x04#define STAT_WINTR_ENABLED 0 x10#define STAT_CAN_WRITE 0 x20#define STAT_INTR_WRITE 0 x40static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);static int wavefront_find_free_sample (snd_wavefront_t *);struct wavefront_command {int cmd;char *action;unsigned int read_cnt;unsigned int write_cnt;int need_ack;static struct {int errno;const char *errstr;0 x01, "Bad sample number" },0 x02, "Out of sample memory" },0 x03, "Bad patch number" },0 x04, "Error in number of voices" },0 x06, "Sample load already in progress" },0 x0B, "No sample load request pending" },0 x0E, "Bad MIDI channel number" },0 x10, "Download Record Error" },0 x80, "Success" },0 x0 }#define NEEDS_ACK 1 static struct wavefront_command wavefront_commands[] = {"set synthesizer volume" , 0 , 1 , NEEDS_ACK },"get synthesizer volume" , 1 , 0 , 0 },"set number of voices" , 0 , 1 , NEEDS_ACK },"get number of voices" , 1 , 0 , 0 },"set synthesizer tuning" , 0 , 2 , NEEDS_ACK },"get synthesizer tuning" , 2 , 0 , 0 },"disable synth channel" , 0 , 1 , NEEDS_ACK },"enable synth channel" , 0 , 1 , NEEDS_ACK },"get synth channel status" , 3 , 0 , 0 },"disable midi-in to synth" , 0 , 0 , NEEDS_ACK },"enable midi-in to synth" , 0 , 0 , NEEDS_ACK },"enable virtual midi mode" , 0 , 0 , NEEDS_ACK },"disable virtual midi mode" , 0 , 0 , NEEDS_ACK },"report midi status" , 1 , 0 , 0 },"report firmware version" , 2 , 0 , 0 },"report hardware version" , 2 , 0 , 0 },"report number of samples" , 2 , 0 , 0 },"report instantaneous output levels" , 7 , 0 , 0 },"report peak output levels" , 7 , 0 , 0 },"download sample" ,0 , WF_SAMPLE_BYTES, NEEDS_ACK },"download block" , 0 , 0 , NEEDS_ACK},"download sample header" ,0 , WF_SAMPLE_HDR_BYTES, NEEDS_ACK },"upload sample header" , 13 , 2 , 0 },/* This command requires a variable number of bytes to be written. There is a hack in snd_wavefront_cmd ( ) to support this . The actual count is passed in as the read buffer ptr , cast appropriately . Ugh . "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 . "upload multisample" , 2 , 1 , 0 },"download sample alias" ,0 , WF_ALIAS_BYTES, NEEDS_ACK },"upload sample alias" , WF_ALIAS_BYTES, 2 , 0 },"delete sample" , 0 , 2 , NEEDS_ACK },"identify sample type" , 5 , 2 , 0 },"upload sample parameters" },"report free memory" , 4 , 0 , 0 },"download patch" , 0 , 134 , NEEDS_ACK },"upload patch" , 132 , 2 , 0 },"download program" , 0 , 33 , NEEDS_ACK },"upload program" , 32 , 1 , 0 },"download enhanced drum program" , 0 , 9 ,"upload enhanced drum program" , 8 , 1 , 0 },"set enhanced drum program channel" ,0 , 1 , NEEDS_ACK },"disable drum program" , 0 , 1 , NEEDS_ACK },"report channel program numbers" ,32 , 0 , 0 },"the no-op command" , 0 , 0 , NEEDS_ACK },0 x00 }static const char *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 struct wavefront_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 NULL;static inline int return inb (dev->status_port);static int int limit)return signal_pending(current);static int int mask)int i;/* Spin for a short period of time, because >99% of all requests to the WaveFront can be serviced inline like this . for (i = 0 ; i < wait_usecs; i += 5 ) {if (wavefront_status (dev) & mask) {return 1 ;5 );for (i = 0 ; i < sleep_tries; i++) {if (wavefront_status (dev) & mask) {return 1 ;if (wavefront_sleep (HZ/sleep_interval)) {return (0 );return (0 );static int if (wavefront_wait (dev, STAT_CAN_READ))return inb (dev->data_port);"read timeout.\n" );return -1 ;static int unsigned char data)if (wavefront_wait (dev, STAT_CAN_WRITE)) {return 0 ;"write timeout.\n" );return -1 ;int int cmd, unsigned char *rbuf, unsigned char *wbuf)int ack;unsigned int i;int c;struct wavefront_command *wfcmd;if (!wfcmd) {"command 0x%x not supported.\n" ,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) {unsigned long ) rbuf;"0x%x [%s] (%d,%d,%d)\n" ,if (wavefront_write (dev, cmd)) { "cannot request " "0x%x [%s].\n" ,return 1 ;if (wfcmd->write_cnt > 0 ) {"writing %d bytes " "for 0x%x\n" ,for (i = 0 ; i < wfcmd->write_cnt; i++) {if (wavefront_write (dev, wbuf[i])) {"bad write for byte " "%d of 0x%x [%s].\n" ,return 1 ;"write[%d] = 0x%x\n" ,if (wfcmd->read_cnt > 0 ) {"reading %d ints " "for 0x%x\n" ,for (i = 0 ; i < wfcmd->read_cnt; i++) {if (c == -1 ) {"bad read for byte " "%d of 0x%x [%s].\n" ,return 1 ;/* Now handle errors. Lots of special cases here */ if (c == 0 xff) { if (c == -1 ) {"bad read for " "error byte at " "read byte %d " "of 0x%x [%s].\n" ,return 1 ;/* Can you believe this madness ? */ if (c == 1 &&0 ] = WF_ST_EMPTY;return (0 );else if (c == 3 &&return 3 ;else if (c == 1 &&return 1 ;else {"error %d (%s) " "during " "read for byte " "%d of 0x%x " "[%s].\n" ,return 1 ;else {"read[%d] = 0x%x\n" ,i, rbuf[i]);if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0 ) || wfcmd->need_ack) {"reading ACK for 0x%x\n" , cmd);/* Some commands need an ACK, but return zero instead of the standard value . if (ack == 0 )if (ack != WF_ACK) {if (ack == -1 ) {"cannot read ack for " "0x%x [%s].\n" ,return 1 ;else {int err = -1 ; /* something unknown */ if (ack == 0 xff) { /* explicit error */ if (err == -1 ) {"cannot read err " "for 0x%x [%s].\n" ,"0x%x [%s] " "failed (0x%x, 0x%x, %s)\n" ,return -err;"ack received " "for 0x%x [%s]\n" ,else {"0x%x [%s] does not need " "ACK (%d,%d,%d)\n" ,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 > 0 x7F ( 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 *unsigned int src,unsigned char *dst,unsigned int dst_size)unsigned int i;for (i = 0 ; i < dst_size; i++) {0 x7F; /* Mask high bit of LSB */ 7 ; /* Rotate Right 7 bits */ /* Note: we leave the upper bits in place */ return dst;static int unsigned char * src, int src_size)int i;int outval = 0 ;for (i = src_size - 1 ; i >= 0 ; i--) {7 )+src[i];return outval;static unsigned char *unsigned char *src, unsigned char *dst, unsigned int dst_size)unsigned int i;unsigned int last = dst_size / 2 ;for (i = 0 ; i < last; i++) {0 x7f;7 ;return dst;static unsigned char *unsigned char *src, unsigned char *dst, unsigned int src_bytes)int i;unsigned char *end = src + src_bytes;/* NOTE: src and dst *CAN* point to the same address */ for (i = 0 ; src != end; i++) {7 ;return dst;/***********************************************************************WaveFront : sample , patch and program management . static int int sample_num)unsigned char wbuf[2 ];int x;0 ] = sample_num & 0 x7f;1 ] = sample_num >> 7 ;if (!x)return x;static int int assume_rom)int i;unsigned char rbuf[32 ], wbuf[32 ];unsigned int sc_real, sc_alias, sc_multi;/* check sample status */ if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {"cannot request sample count.\n" );return -1 ;0 ;for (i = 0 ; i < WF_MAX_SAMPLE; i++) {0 ] = i & 0 x7f;1 ] = i >> 7 ;if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {"cannot identify sample type of slot %d\n" , i);continue ;0 ]);if (assume_rom) {switch (rbuf[0 ] & WF_ST_MASK) {case WF_ST_SAMPLE:break ;case WF_ST_MULTISAMPLE:break ;case WF_ST_ALIAS:break ;case WF_ST_EMPTY:break ;default :"unknown sample type for slot %d (0x%x)\n" ,0 ]);if (rbuf[0 ] != WF_ST_EMPTY) {"%d samples used (%d real, %d aliases, %d multi), %d empty\n" ,return (0 );static int unsigned char patchbuf[WF_PATCH_BYTES];unsigned char patchnum[2 ];int i, x, cnt, cnt2;for (i = 0 ; i < WF_MAX_PATCH; i++) {0 ] = i & 0 x7f;1 ] = i >> 7 ;if (x == 0 ) {7 )] |=else if (x == 3 ) { /* Bad patch number */ 0 ;else {"upload patch error 0x%x\n" , x);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) {if (dev->patch_status[i] & WF_SLOT_USED) {"%d patch slots filled, %d in use\n" ,return (0 );static int unsigned char progbuf[WF_PROGRAM_BYTES];unsigned char prognum;int i, x, l, cnt;for (i = 0 ; i < WF_MAX_PROGRAM; i++) {if (x == 0 ) {unsigned char *) &prog,for (l = 0 ; l < WF_NUM_LAYERS; l++) {if (prog.layer[l].mute) {else if (x == 1 ) { /* Bad program number */ 0 ;else {"upload program error 0x%x\n" , x);0 ;for (i = 0 , cnt = 0 ; i < WF_MAX_PROGRAM; i++) {if (dev->prog_status[i]) {"%d programs slots in use\n" , cnt);return (0 );static int unsigned char buf[WF_PATCH_BYTES+2 ];unsigned char *bptr;"downloading patch %d\n" ,if (header->number >= ARRAY_SIZE(dev->patch_status))return -EINVAL;2 );unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {"download patch failed\n" );return -EIO;return (0 );static int unsigned char buf[WF_PROGRAM_BYTES+1 ];int i;"downloading program %d\n" ,if (header->number >= ARRAY_SIZE(dev->prog_status))return -EINVAL;/* 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) {/* XXX need to mark SLOT_USED for sample used by patch_number , but this means we have to load it . Ick . 0 ] = header->number;unsigned char *)&header->hdr.pr, &buf[1 ], WF_PROGRAM_BYTES);if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {"download patch failed\n" );return -EIO;return (0 );static int char rbuf[8 ];if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {"can't get memory stats.\n" );return -1 ;else {return demunge_int32 (rbuf, 4 );static int 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 . 0 ;unsigned int i;const unsigned 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 ;"sample %sdownload for slot %d, " "type %d, %d bytes from 0x%lx\n" ,"" : "header " , unsigned long ) header->dataptr);if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {int x;if (x < 0 )return -ENOMEM;"unspecified sample => %d\n" , x);if (header->number >= WF_MAX_SAMPLE)return -EINVAL;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 158 K 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) {"sample slot %d write protected\n" ,return -EACCES;if (header->size) {if (dev->freemem < (int )header->size) {"insufficient memory to load %d byte sample.\n" ,return -ENOMEM;if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {"channel selection only possible on 16-bit samples" );return -EINVAL;switch (skip) {case 0 :0 ;1 ;break ;case 1 :0 ;2 ;break ;case 2 :1 ;2 ;break ;case 3 :2 ;3 ;break ;case 4 :3 ;4 ;break ;case 5 :4 ;5 ;break ;case 6 :5 ;6 ;break ;"channel selection: %d => " "initial skip = %d, skip = %d\n" ,/* Be safe, and zero the "Unused" bits ... */ 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 . 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 . 0 ];2 );if (header->size) {4 );/* Yes, a 4 byte result doesn't contain all of the offset bits, but the offset only uses 24 bits . 4 );4 );4 );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 ? 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 . 1 ),2 );if (snd_wavefront_cmd (dev, "sample %sdownload refused.\n" ,"" : "header " );return -EIO;if (header->size == 0 ) {goto sent; /* Sorry. Just had to have one somewhere */ /* Do any initial skip over an unused channel's data */ for (written = 0 , blocknum = 0 ;if ((length - written) > max_blksize) {else {/* round to nearest 16-byte value */ 8 );if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {"download block request refused.\n" );return -EIO;for (i = 0 ; i < blocksize; i++) {if (dataptr < data_end) {if (get_user(sample_short, dataptr))return -EFAULT;if (data_is_unsigned) { /* GUS ? */ if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {/* 8 bit sample resolution , sign extend both bytes . unsigned char *)0 ] += 0 x7f;unsigned char *)1 ] += 0 x7f;else {/* 16 bit sample resolution , sign extend the MSB . 0 x7fff;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 ) {else {/* Get "DMA page acknowledge", even though its really nothing to do with DMA at all . if (dma_ack != WF_DMA_ACK) {if (dma_ack == -1 ) {"upload sample DMA ack timeout\n" );return -EIO;else {"upload sample DMA ack error 0x%x\n" ,return -EIO;/* Note, label is here because sending the sample header shouldn't alter the sample_status info at all . return (0 );static int unsigned char alias_hdr[WF_ALIAS_BYTES];"download alias, %d is " "alias for %d\n" ,if (header->number >= WF_MAX_SAMPLE)return -EINVAL;0 ], 2 );2 ], 2 );unsigned int *)&header->hdr.a.sampleStartOffset),4 ], 4 );unsigned int *)&header->hdr.a.loopStartOffset),8 ], 4 );unsigned int *)&header->hdr.a.loopEndOffset),12 ], 4 );unsigned int *)&header->hdr.a.sampleEndOffset),16 ], 4 );20 ], 3 );1 ), &alias_hdr[23 ], 2 );if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {"download alias failed.\n" );return -EIO;return (0 );static int int i;int num_samples;unsigned char *msample_hdr;if (header->number >= WF_MAX_SAMPLE)return -EINVAL;if (! msample_hdr)return -ENOMEM;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 . 1 <<(header->hdr.ms.NumberOfSamples&7 ));2 ] = (unsigned char ) header->hdr.ms.NumberOfSamples;"multi %d with %d=%d samples\n" ,for (i = 0 ; i < num_samples; i++) {"sample[%d] = %d\n" ,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 (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE, unsigned char *) (long ) ((num_samples*2 )+3 ),"download of multisample failed.\n" );return -EIO;return (0 );static int int i;unsigned char log_ns[1 ];unsigned char number[2 ];int num_samples;2 );if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {"upload multisample failed.\n" );return -EIO;"msample %d has %d samples\n" ,0 ]);0 ];/* get the number of samples ... */ 1 << log_ns[0 ]);for (i = 0 ; i < num_samples; i++) {char d[2 ];int val;if (val == -1 ) {"upload multisample failed during sample loop.\n" );return -EIO;0 ] = val;if (val == -1 ) {"upload multisample failed during sample loop.\n" );return -EIO;1 ] = val;unsigned char *) d, 2 );"msample sample[%d] = %d\n" ,return (0 );static int unsigned char drumbuf[WF_DRUM_BYTES];int i;"downloading edrum for MIDI " "note %d, patch = %d\n" , 0 ] = header->number & 0 x7f;for (i = 0 ; i < 4 ; i++) {unsigned char *)drum)[i], &drumbuf[1 +(i*2 )], 2 );if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {"download drum failed.\n" );return -EIO;return (0 );static int int i;for (i = 0 ; i < WF_MAX_SAMPLE; i++) {if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {return i;"no free sample slots!\n" );return -1 ;#if 0 static int int i;for (i = 0 ; i < WF_MAX_PATCH; i++) {if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {return i;"no free patch slots!\n" );return -1 ;#endif static int const char __user *addr)int err;sizeof (*header), GFP_KERNEL);if (! header)return -ENOMEM;if (copy_from_user (header, addr, sizeof (wavefront_patch_info) -sizeof (wavefront_any))) {"bad address for load patch.\n" );goto __error;"download " "Sample type: %d " "Sample number: %d " "Sample size: %d\n" ,switch (header->subkey) {case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */ if (copy_from_user (&header->hdr.s, header->hdrptr,sizeof (wavefront_sample))) {break ;0 );break ;case WF_ST_MULTISAMPLE:if (copy_from_user (&header->hdr.s, header->hdrptr,sizeof (wavefront_multisample))) {break ;break ;case WF_ST_ALIAS:if (copy_from_user (&header->hdr.a, header->hdrptr,sizeof (wavefront_alias))) {break ;break ;case WF_ST_DRUM:if (copy_from_user (&header->hdr.d, header->hdrptr,sizeof (wavefront_drum))) {break ;break ;case WF_ST_PATCH:if (copy_from_user (&header->hdr.p, header->hdrptr,sizeof (wavefront_patch))) {break ;break ;case WF_ST_PROGRAM:if (copy_from_user (&header->hdr.pr, header->hdrptr,sizeof (wavefront_program))) {break ;break ;default :"unknown patch type %d.\n" ,break ;return err;/***********************************************************************WaveFront : hardware - dependent interface static void /* 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 . 4 ); ptr += 4 ;4 ); ptr += 4 ;4 ); ptr += 4 ;4 ); ptr += 4 ;3 ); ptr += 3 ;0 x3;0 x8;0 x10;0 x40;/* Now copy it back to where it came from */ unsigned char *) &s, sizeof (wavefront_sample));static int unsigned char patchnumbuf[2 ];int i;"synth control with " "cmd 0x%x\n" , wc->cmd);/* Pre-handling of or for various commands */ switch (wc->cmd) {case WFC_DISABLE_INTERRUPTS:"interrupts disabled.\n" );0 x80|0 x20, dev->control_port);1 ;return 0 ;case WFC_ENABLE_INTERRUPTS:"interrupts enabled.\n" );0 x80|0 x40|0 x20, dev->control_port);1 ;return 0 ;case WFC_INTERRUPT_STATUS:0 ] = dev->interrupts_are_midi;return 0 ;case WFC_ROMSAMPLES_RDONLY:0 ];0 ;return 0 ;case WFC_IDENTIFY_SLOT_TYPE:0 ] | (wc->wbuf[1 ] << 7 );if (i <0 || i >= WF_MAX_SAMPLE) {"invalid slot ID %d\n" ,return -EINVAL;0 ] = dev->sample_status[i];0 ;return 0 ;case WFC_DEBUG_DRIVER:0 ];"debug = 0x%x\n" , dev->debug);return 0 ;case WFC_UPLOAD_PATCH:2 );2 );break ;case WFC_UPLOAD_MULTISAMPLE:/* multisamples have to be handled differently, and cannot be dealt with properly by snd_wavefront_cmd ( ) alone . return 0 ;case WFC_UPLOAD_SAMPLE_ALIAS:"support for sample alias upload being considered.\n" );return -EINVAL;/* 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:4 );break ;case WFC_UPLOAD_PATCH:break ;case WFC_UPLOAD_PROGRAM:break ;case WFC_UPLOAD_EDRUM_PROGRAM:1 );break ;case WFC_UPLOAD_SAMPLE_HEADER:break ;case WFC_UPLOAD_SAMPLE_ALIAS:"support for sample aliases still being considered.\n" );break ;case WFC_VMIDI_OFF:break ;case WFC_VMIDI_ON:break ;return 0 ;int struct snd_hwdep *hw, struct file *file)if (!try_module_get(hw->card->module))return -EFAULT;return 0 ;int struct snd_hwdep *hw, struct file *file)return 0 ;int struct snd_hwdep *hw, struct file *file,unsigned int cmd, unsigned long arg)struct snd_card *card;void __user *argp = (void __user *)arg;int err;struct snd_card *) hw->card;if (snd_BUG_ON(!card))return -ENODEV;if (snd_BUG_ON(!card->private_data))return -ENODEV;switch (cmd) {case WFCTL_LOAD_SPP:if (wavefront_load_patch (dev, argp) != 0 ) {return -EIO;break ;case WFCTL_WFCMD:sizeof (*wc));if (IS_ERR(wc))return PTR_ERR(wc);if (wavefront_synth_control (acard, wc) < 0 )else if (copy_to_user (argp, wc, sizeof (*wc)))else 0 ;return err;default :return -EINVAL;return 0 ;/***********************************************************************/ /* WaveFront: interface for card-level wavefront module */ /***********************************************************************/ void /* 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(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0 ) {return ;1 ;/* STATUS REGISTER 0 Host Rx Interrupt Enable ( 1 = Enabled ) 1 Host Rx Register Full ( 1 = Full ) 2 Host Rx Interrupt Pending ( 1 = Interrupt ) 3 Unused 4 Host Tx Interrupt ( 1 = Enabled ) 5 Host Tx Register empty ( 1 = Empty ) 6 Host Tx Interrupt Pending ( 1 = Interrupt ) 7 Unused static int int irq)int bits;switch (irq) {case 9 :0 x00;break ;case 5 :0 x08;break ;case 12 :0 x10;break ;case 15 :0 x18;break ;default :"invalid IRQ %d\n" , irq);1 ;return bits;static void int val, int port, unsigned long timeout)0 ;while (!dev->irq_ok && time_before(jiffies, timeout)) {1 );static int int bits;int hwv[2 ];/* IRQ already checked */ /* try reset of port */ 0 x0, 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 03 FC30 - 03 FFFFH utilize the internal Boot ROM 1 - memory accesses to 03 FC30 - 03 FFFFH are directed to external storage . /* configure hardware: IRQ, enable interrupts, plus external 9 - pin MIDI interface selected 0 x80 | 0 x40 | bits, dev->data_port); /* CONTROL REGISTER 0 Host Rx Interrupt Enable ( 1 = Enabled ) 0 x1 1 Unused 0 x2 2 Unused 0 x4 3 Unused 0 x8 4 Host Tx Interrupt Enable 0 x10 5 Mute ( 0 = Mute ; 1 = Play ) 0 x20 6 Master Interrupt Enable ( 1 = Enabled ) 0 x40 7 Master Reset ( 0 = Reset ; 1 = Run ) 0 x80 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 . 0 x80|0 x40|0 x10|0 x1,100 );/* Note: data port is now the data port, not the h/w initialization port . if (!dev->irq_ok) {"intr not received after h/w un-reset.\n" );goto gone_bad;/* 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 12 MB of RAM on a Tropez + , it takes a lot longer than that ( ~ 16 secs ) . 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 ? if (!dev->irq_ok) {"post-RAM-check interrupt not received.\n" );goto gone_bad;if (!wavefront_wait (dev, STAT_CAN_READ)) {"no response to HW version cmd.\n" );goto gone_bad;0 ] = wavefront_read(dev);if (hwv[0 ] == -1 ) {"board not responding correctly.\n" );goto gone_bad;if (hwv[0 ] == 0 xFF) { /* NAK */ /* Board's RAM test failed. Try to read error code, and tell us about it either way . 0 ] = wavefront_read(dev);if (hwv[0 ] == -1 ) {"on-board RAM test failed (bad error code).\n" );else {"on-board RAM test failed (error code: 0x%x).\n" ,0 ]);goto gone_bad;/* We're OK, just get the next byte of the HW version response */ 1 ] = wavefront_read(dev);if (hwv[1 ] == -1 ) {"incorrect h/w response.\n" );goto gone_bad;"hardware version %d.%d\n" ,0 ], hwv[1 ]);return 0 ;return (1 );static int char *path)const unsigned char *buf;int len, err;int section_cnt_downloaded = 0 ;const struct firmware *firmware;if (err < 0 ) {"firmware (%s) download failed!!!\n" , path);return 1 ;0 ;for (;;) {int section_length = *(signed char *)buf;if (section_length == 0 )break ;if (section_length < 0 || section_length > WF_SECTION_MAX) {"invalid firmware section length %d\n" ,goto failure;if (firmware->size < len + section_length) {"firmware section read error.\n" );goto failure;/* Send command */ if (wavefront_write(dev, WFC_DOWNLOAD_OS))goto failure;for (; section_length; section_length--) {if (wavefront_write(dev, *buf))goto failure;/* get ACK */ if (!wavefront_wait(dev, STAT_CAN_READ)) {"time out for firmware ACK.\n" );goto failure;if (err != WF_ACK) {"download of section #%d not acknowledged, ack = 0x%x\n" ,1 , err);goto failure;return 0 ;"firmware download failed!!!\n" );return 1 ;static int char voices[1 ];if (wavefront_reset_to_cleanliness (dev)) {"hw reset failed.\n" );goto gone_bad;if (dev->israw) {if (wavefront_download_firmware (dev, ospath)) {goto gone_bad;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 . if (!dev->irq_ok) {"no post-OS interrupt.\n" );goto gone_bad;/* Now, do it again ! */ 10 *HZ));if (!dev->irq_ok) {"no post-OS interrupt(2).\n" );goto gone_bad;/* OK, no (RX/TX) interrupts any more, but leave mute in effect . 0 x80|0 x40, dev->control_port); /* 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 < 0 )goto gone_bad;"available DRAM %dk\n" , dev->freemem / 1024 );if (wavefront_write (dev, 0 xf0) ||1 ) ||0 )) {0 ;"MPU emulation mode not set.\n" );goto gone_bad;0 ] = 32 ;if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {"cannot set number of voices to 32.\n" );goto gone_bad;return 0 ;/* reset that sucker so that it doesn't bother us. */ 0 x0, dev->control_port);0 ;return 1 ;int int samples_are_from_rom;/* IMPORTANT: assumes that snd_wavefront_detect() and/or wavefront_reset_to_cleanliness ( ) has already been called if (dev->israw) {1 ;else {/* XXX is this always true ? */ 0 ;if (dev->israw || fx_raw) {if (wavefront_do_reset (dev)) {return -1 ;/* Check for FX device, present only on Tropez+ */ 0 );if (dev->has_fx && fx_raw) {/* Start normal operation: unreset, master interrupt enabled, no mute 0 x80|0 x40|0 x20, dev->control_port); return (0 );int unsigned char rbuf[4 ], wbuf[4 ];/* returns zero if a WaveFront card is successfully detected. negative otherwise . 0 ;0 ;0 ;0 ;1 ;if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0 ) {0 ] = rbuf[0 ];1 ] = rbuf[1 ];"firmware %d.%d already loaded.\n" ,0 ], rbuf[1 ]);/* check that a command actually works */ if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,0 ) {0 ] = rbuf[0 ];1 ] = rbuf[1 ];else {"not raw, but no hardware version!\n" );return -1 ;if (!wf_raw) {return 0 ;else {"reloading firmware as you requested.\n" );1 ;else {1 ;"no response to firmware probe, assume raw.\n" );return 0 ;
Messung V0.5 in Prozent C=95 H=92 G=93
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.67Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-10-11)
¤ *Eine klare Vorstellung vom Zielzustand
