Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* Copyright (C) by Paul Barton-Davis 1998-1999
0003  *
0004  * Some portions of this file are taken from work that is
0005  * copyright (C) by Hannu Savolainen 1993-1996
0006  */
0007 
0008 /*  
0009  * An ALSA lowlevel driver for Turtle Beach ICS2115 wavetable synth
0010  *                                             (Maui, Tropez, Tropez Plus)
0011  *
0012  * This driver supports the onboard wavetable synthesizer (an ICS2115),
0013  * including patch, sample and program loading and unloading, conversion
0014  * of GUS patches during loading, and full user-level access to all
0015  * WaveFront commands. It tries to provide semi-intelligent patch and
0016  * sample management as well.
0017  *
0018  */
0019 
0020 #include <linux/io.h>
0021 #include <linux/interrupt.h>
0022 #include <linux/init.h>
0023 #include <linux/delay.h>
0024 #include <linux/time.h>
0025 #include <linux/wait.h>
0026 #include <linux/sched/signal.h>
0027 #include <linux/firmware.h>
0028 #include <linux/moduleparam.h>
0029 #include <linux/slab.h>
0030 #include <linux/module.h>
0031 #include <sound/core.h>
0032 #include <sound/snd_wavefront.h>
0033 #include <sound/initval.h>
0034 
0035 static int wf_raw = 0; /* we normally check for "raw state" to firmware
0036               loading. if non-zero, then during driver loading, the
0037               state of the board is ignored, and we reset the
0038               board and load the firmware anyway.
0039                */
0040            
0041 static int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
0042               whatever state it is when the driver is loaded.
0043               The default is to download the microprogram and
0044               associated coefficients to set it up for "default"
0045               operation, whatever that means.
0046                */
0047 
0048 static int debug_default = 0;  /* you can set this to control debugging
0049                   during driver loading. it takes any combination
0050                   of the WF_DEBUG_* flags defined in
0051                   wavefront.h
0052                    */
0053 
0054 /* XXX this needs to be made firmware and hardware version dependent */
0055 
0056 #define DEFAULT_OSPATH  "wavefront.os"
0057 static char *ospath = DEFAULT_OSPATH; /* the firmware file name */
0058 
0059 static int wait_usecs = 150; /* This magic number seems to give pretty optimal
0060                 throughput based on my limited experimentation.
0061                 If you want to play around with it and find a better
0062                 value, be my guest. Remember, the idea is to
0063                 get a number that causes us to just busy wait
0064                 for as many WaveFront commands as possible, without
0065                 coming up with a number so large that we hog the
0066                 whole CPU.
0067 
0068                 Specifically, with this number, out of about 134,000
0069                 status waits, only about 250 result in a sleep.
0070                 */
0071 
0072 static int sleep_interval = 100;   /* HZ/sleep_interval seconds per sleep */
0073 static int sleep_tries = 50;       /* number of times we'll try to sleep */
0074 
0075 static int reset_time = 2;        /* hundreths of a second we wait after a HW
0076                      reset for the expected interrupt.
0077                   */
0078 
0079 static int ramcheck_time = 20;    /* time in seconds to wait while ROM code
0080                      checks on-board RAM.
0081                   */
0082 
0083 static int osrun_time = 10;       /* time in seconds we wait for the OS to
0084                      start running.
0085                   */
0086 module_param(wf_raw, int, 0444);
0087 MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
0088 module_param(fx_raw, int, 0444);
0089 MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
0090 module_param(debug_default, int, 0444);
0091 MODULE_PARM_DESC(debug_default, "debug parameters for card initialization");
0092 module_param(wait_usecs, int, 0444);
0093 MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs");
0094 module_param(sleep_interval, int, 0444);
0095 MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply");
0096 module_param(sleep_tries, int, 0444);
0097 MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait");
0098 module_param(ospath, charp, 0444);
0099 MODULE_PARM_DESC(ospath, "pathname to processed ICS2115 OS firmware");
0100 module_param(reset_time, int, 0444);
0101 MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect");
0102 module_param(ramcheck_time, int, 0444);
0103 MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test");
0104 module_param(osrun_time, int, 0444);
0105 MODULE_PARM_DESC(osrun_time, "how many seconds to wait for the ICS2115 OS");
0106 
0107 /* if WF_DEBUG not defined, no run-time debugging messages will
0108    be available via the debug flag setting. Given the current
0109    beta state of the driver, this will remain set until a future 
0110    version.
0111 */
0112 
0113 #define WF_DEBUG 1
0114 
0115 #ifdef WF_DEBUG
0116 
0117 #define DPRINT(cond, ...) \
0118        if ((dev->debug & (cond)) == (cond)) { \
0119          snd_printk (__VA_ARGS__); \
0120        }
0121 #else
0122 #define DPRINT(cond, args...)
0123 #endif /* WF_DEBUG */
0124 
0125 #define LOGNAME "WaveFront: "
0126 
0127 /* bitmasks for WaveFront status port value */
0128 
0129 #define STAT_RINTR_ENABLED  0x01
0130 #define STAT_CAN_READ       0x02
0131 #define STAT_INTR_READ      0x04
0132 #define STAT_WINTR_ENABLED  0x10
0133 #define STAT_CAN_WRITE      0x20
0134 #define STAT_INTR_WRITE     0x40
0135 
0136 static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
0137 static int wavefront_find_free_sample (snd_wavefront_t *);
0138 
0139 struct wavefront_command {
0140     int cmd;
0141     char *action;
0142     unsigned int read_cnt;
0143     unsigned int write_cnt;
0144     int need_ack;
0145 };
0146 
0147 static struct {
0148     int errno;
0149     const char *errstr;
0150 } wavefront_errors[] = {
0151     { 0x01, "Bad sample number" },
0152     { 0x02, "Out of sample memory" },
0153     { 0x03, "Bad patch number" },
0154     { 0x04, "Error in number of voices" },
0155     { 0x06, "Sample load already in progress" },
0156     { 0x0B, "No sample load request pending" },
0157     { 0x0E, "Bad MIDI channel number" },
0158     { 0x10, "Download Record Error" },
0159     { 0x80, "Success" },
0160     { 0x0 }
0161 };
0162 
0163 #define NEEDS_ACK 1
0164 
0165 static struct wavefront_command wavefront_commands[] = {
0166     { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK },
0167     { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0},
0168     { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK },
0169     { WFC_GET_NVOICES, "get number of voices", 1, 0, 0 },
0170     { WFC_SET_TUNING, "set synthesizer tuning", 0, 2, NEEDS_ACK },
0171     { WFC_GET_TUNING, "get synthesizer tuning", 2, 0, 0 },
0172     { WFC_DISABLE_CHANNEL, "disable synth channel", 0, 1, NEEDS_ACK },
0173     { WFC_ENABLE_CHANNEL, "enable synth channel", 0, 1, NEEDS_ACK },
0174     { WFC_GET_CHANNEL_STATUS, "get synth channel status", 3, 0, 0 },
0175     { WFC_MISYNTH_OFF, "disable midi-in to synth", 0, 0, NEEDS_ACK },
0176     { WFC_MISYNTH_ON, "enable midi-in to synth", 0, 0, NEEDS_ACK },
0177     { WFC_VMIDI_ON, "enable virtual midi mode", 0, 0, NEEDS_ACK },
0178     { WFC_VMIDI_OFF, "disable virtual midi mode", 0, 0, NEEDS_ACK },
0179     { WFC_MIDI_STATUS, "report midi status", 1, 0, 0 },
0180     { WFC_FIRMWARE_VERSION, "report firmware version", 2, 0, 0 },
0181     { WFC_HARDWARE_VERSION, "report hardware version", 2, 0, 0 },
0182     { WFC_GET_NSAMPLES, "report number of samples", 2, 0, 0 },
0183     { WFC_INSTOUT_LEVELS, "report instantaneous output levels", 7, 0, 0 },
0184     { WFC_PEAKOUT_LEVELS, "report peak output levels", 7, 0, 0 },
0185     { WFC_DOWNLOAD_SAMPLE, "download sample",
0186       0, WF_SAMPLE_BYTES, NEEDS_ACK },
0187     { WFC_DOWNLOAD_BLOCK, "download block", 0, 0, NEEDS_ACK},
0188     { WFC_DOWNLOAD_SAMPLE_HEADER, "download sample header",
0189       0, WF_SAMPLE_HDR_BYTES, NEEDS_ACK },
0190     { WFC_UPLOAD_SAMPLE_HEADER, "upload sample header", 13, 2, 0 },
0191 
0192     /* This command requires a variable number of bytes to be written.
0193        There is a hack in snd_wavefront_cmd() to support this. The actual
0194        count is passed in as the read buffer ptr, cast appropriately.
0195        Ugh.
0196     */
0197 
0198     { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
0199 
0200     /* This one is a hack as well. We just read the first byte of the
0201        response, don't fetch an ACK, and leave the rest to the 
0202        calling function. Ugly, ugly, ugly.
0203     */
0204 
0205     { WFC_UPLOAD_MULTISAMPLE, "upload multisample", 2, 1, 0 },
0206     { WFC_DOWNLOAD_SAMPLE_ALIAS, "download sample alias",
0207       0, WF_ALIAS_BYTES, NEEDS_ACK },
0208     { WFC_UPLOAD_SAMPLE_ALIAS, "upload sample alias", WF_ALIAS_BYTES, 2, 0},
0209     { WFC_DELETE_SAMPLE, "delete sample", 0, 2, NEEDS_ACK },
0210     { WFC_IDENTIFY_SAMPLE_TYPE, "identify sample type", 5, 2, 0 },
0211     { WFC_UPLOAD_SAMPLE_PARAMS, "upload sample parameters" },
0212     { WFC_REPORT_FREE_MEMORY, "report free memory", 4, 0, 0 },
0213     { WFC_DOWNLOAD_PATCH, "download patch", 0, 134, NEEDS_ACK },
0214     { WFC_UPLOAD_PATCH, "upload patch", 132, 2, 0 },
0215     { WFC_DOWNLOAD_PROGRAM, "download program", 0, 33, NEEDS_ACK },
0216     { WFC_UPLOAD_PROGRAM, "upload program", 32, 1, 0 },
0217     { WFC_DOWNLOAD_EDRUM_PROGRAM, "download enhanced drum program", 0, 9,
0218       NEEDS_ACK},
0219     { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
0220     { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
0221       0, 1, NEEDS_ACK },
0222     { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
0223     { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
0224       32, 0, 0 },
0225     { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
0226     { 0x00 }
0227 };
0228 
0229 static const char *
0230 wavefront_errorstr (int errnum)
0231 
0232 {
0233     int i;
0234 
0235     for (i = 0; wavefront_errors[i].errstr; i++) {
0236         if (wavefront_errors[i].errno == errnum) {
0237             return wavefront_errors[i].errstr;
0238         }
0239     }
0240 
0241     return "Unknown WaveFront error";
0242 }
0243 
0244 static struct wavefront_command *
0245 wavefront_get_command (int cmd) 
0246 
0247 {
0248     int i;
0249 
0250     for (i = 0; wavefront_commands[i].cmd != 0; i++) {
0251         if (cmd == wavefront_commands[i].cmd) {
0252             return &wavefront_commands[i];
0253         }
0254     }
0255 
0256     return NULL;
0257 }
0258 
0259 static inline int
0260 wavefront_status (snd_wavefront_t *dev) 
0261 
0262 {
0263     return inb (dev->status_port);
0264 }
0265 
0266 static int
0267 wavefront_sleep (int limit)
0268 
0269 {
0270     schedule_timeout_interruptible(limit);
0271 
0272     return signal_pending(current);
0273 }
0274 
0275 static int
0276 wavefront_wait (snd_wavefront_t *dev, int mask)
0277 
0278 {
0279     int             i;
0280 
0281     /* Spin for a short period of time, because >99% of all
0282        requests to the WaveFront can be serviced inline like this.
0283     */
0284 
0285     for (i = 0; i < wait_usecs; i += 5) {
0286         if (wavefront_status (dev) & mask) {
0287             return 1;
0288         }
0289         udelay(5);
0290     }
0291 
0292     for (i = 0; i < sleep_tries; i++) {
0293 
0294         if (wavefront_status (dev) & mask) {
0295             return 1;
0296         }
0297 
0298         if (wavefront_sleep (HZ/sleep_interval)) {
0299             return (0);
0300         }
0301     }
0302 
0303     return (0);
0304 }
0305 
0306 static int
0307 wavefront_read (snd_wavefront_t *dev)
0308 
0309 {
0310     if (wavefront_wait (dev, STAT_CAN_READ))
0311         return inb (dev->data_port);
0312 
0313     DPRINT (WF_DEBUG_DATA, "read timeout.\n");
0314 
0315     return -1;
0316 }
0317 
0318 static int
0319 wavefront_write (snd_wavefront_t *dev, unsigned char data)
0320 
0321 {
0322     if (wavefront_wait (dev, STAT_CAN_WRITE)) {
0323         outb (data, dev->data_port);
0324         return 0;
0325     }
0326 
0327     DPRINT (WF_DEBUG_DATA, "write timeout.\n");
0328 
0329     return -1;
0330 }
0331 
0332 int
0333 snd_wavefront_cmd (snd_wavefront_t *dev, 
0334            int cmd, unsigned char *rbuf, unsigned char *wbuf)
0335 
0336 {
0337     int ack;
0338     unsigned int i;
0339     int c;
0340     struct wavefront_command *wfcmd;
0341 
0342     wfcmd = wavefront_get_command(cmd);
0343     if (!wfcmd) {
0344         snd_printk ("command 0x%x not supported.\n",
0345             cmd);
0346         return 1;
0347     }
0348 
0349     /* Hack to handle the one variable-size write command. See
0350        wavefront_send_multisample() for the other half of this
0351        gross and ugly strategy.
0352     */
0353 
0354     if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
0355         wfcmd->write_cnt = (unsigned long) rbuf;
0356         rbuf = NULL;
0357     }
0358 
0359     DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
0360                    cmd, wfcmd->action, wfcmd->read_cnt,
0361                    wfcmd->write_cnt, wfcmd->need_ack);
0362     
0363     if (wavefront_write (dev, cmd)) { 
0364         DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
0365                              "0x%x [%s].\n",
0366                              cmd, wfcmd->action);
0367         return 1;
0368     } 
0369 
0370     if (wfcmd->write_cnt > 0) {
0371         DPRINT (WF_DEBUG_DATA, "writing %d bytes "
0372                     "for 0x%x\n",
0373                     wfcmd->write_cnt, cmd);
0374 
0375         for (i = 0; i < wfcmd->write_cnt; i++) {
0376             if (wavefront_write (dev, wbuf[i])) {
0377                 DPRINT (WF_DEBUG_IO, "bad write for byte "
0378                               "%d of 0x%x [%s].\n",
0379                               i, cmd, wfcmd->action);
0380                 return 1;
0381             }
0382 
0383             DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
0384                         i, wbuf[i]);
0385         }
0386     }
0387 
0388     if (wfcmd->read_cnt > 0) {
0389         DPRINT (WF_DEBUG_DATA, "reading %d ints "
0390                     "for 0x%x\n",
0391                     wfcmd->read_cnt, cmd);
0392 
0393         for (i = 0; i < wfcmd->read_cnt; i++) {
0394 
0395             c = wavefront_read(dev);
0396             if (c == -1) {
0397                 DPRINT (WF_DEBUG_IO, "bad read for byte "
0398                               "%d of 0x%x [%s].\n",
0399                               i, cmd, wfcmd->action);
0400                 return 1;
0401             }
0402 
0403             /* Now handle errors. Lots of special cases here */
0404         
0405             if (c == 0xff) { 
0406                 c = wavefront_read(dev);
0407                 if (c == -1) {
0408                     DPRINT (WF_DEBUG_IO, "bad read for "
0409                                   "error byte at "
0410                                   "read byte %d "
0411                                   "of 0x%x [%s].\n",
0412                                   i, cmd,
0413                                   wfcmd->action);
0414                     return 1;
0415                 }
0416 
0417                 /* Can you believe this madness ? */
0418 
0419                 if (c == 1 &&
0420                     wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
0421                     rbuf[0] = WF_ST_EMPTY;
0422                     return (0);
0423 
0424                 } else if (c == 3 &&
0425                        wfcmd->cmd == WFC_UPLOAD_PATCH) {
0426 
0427                     return 3;
0428 
0429                 } else if (c == 1 &&
0430                        wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
0431 
0432                     return 1;
0433 
0434                 } else {
0435 
0436                     DPRINT (WF_DEBUG_IO, "error %d (%s) "
0437                                   "during "
0438                                   "read for byte "
0439                                   "%d of 0x%x "
0440                                   "[%s].\n",
0441                                   c,
0442                                   wavefront_errorstr (c),
0443                                   i, cmd,
0444                                   wfcmd->action);
0445                     return 1;
0446 
0447                 }
0448         
0449         } else {
0450                 rbuf[i] = c;
0451             }
0452             
0453             DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
0454         }
0455     }
0456     
0457     if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
0458 
0459         DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
0460 
0461         /* Some commands need an ACK, but return zero instead
0462            of the standard value.
0463         */
0464         
0465         ack = wavefront_read(dev);
0466         if (ack == 0)
0467             ack = WF_ACK;
0468     
0469         if (ack != WF_ACK) {
0470             if (ack == -1) {
0471                 DPRINT (WF_DEBUG_IO, "cannot read ack for "
0472                               "0x%x [%s].\n",
0473                               cmd, wfcmd->action);
0474                 return 1;
0475         
0476             } else {
0477                 int err = -1; /* something unknown */
0478 
0479                 if (ack == 0xff) { /* explicit error */
0480             
0481                     err = wavefront_read(dev);
0482                     if (err == -1) {
0483                         DPRINT (WF_DEBUG_DATA,
0484                             "cannot read err "
0485                             "for 0x%x [%s].\n",
0486                             cmd, wfcmd->action);
0487                     }
0488                 }
0489                 
0490                 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
0491                     "failed (0x%x, 0x%x, %s)\n",
0492                     cmd, wfcmd->action, ack, err,
0493                     wavefront_errorstr (err));
0494                 
0495                 return -err;
0496             }
0497         }
0498         
0499         DPRINT (WF_DEBUG_DATA, "ack received "
0500                     "for 0x%x [%s]\n",
0501                     cmd, wfcmd->action);
0502     } else {
0503 
0504         DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
0505                        "ACK (%d,%d,%d)\n",
0506                        cmd, wfcmd->action, wfcmd->read_cnt,
0507                        wfcmd->write_cnt, wfcmd->need_ack);
0508     }
0509 
0510     return 0;
0511     
0512 }
0513 
0514 /***********************************************************************
0515 WaveFront data munging   
0516 
0517 Things here are weird. All data written to the board cannot 
0518 have its most significant bit set. Any data item with values 
0519 potentially > 0x7F (127) must be split across multiple bytes.
0520 
0521 Sometimes, we need to munge numeric values that are represented on
0522 the x86 side as 8-32 bit values. Sometimes, we need to munge data
0523 that is represented on the x86 side as an array of bytes. The most
0524 efficient approach to handling both cases seems to be to use 2
0525 different functions for munging and 2 for de-munging. This avoids
0526 weird casting and worrying about bit-level offsets.
0527 
0528 **********************************************************************/
0529 
0530 static unsigned char *
0531 munge_int32 (unsigned int src,
0532          unsigned char *dst,
0533          unsigned int dst_size)
0534 {
0535     unsigned int i;
0536 
0537     for (i = 0; i < dst_size; i++) {
0538         *dst = src & 0x7F;  /* Mask high bit of LSB */
0539         src = src >> 7;     /* Rotate Right 7 bits  */
0540                                 /* Note: we leave the upper bits in place */ 
0541 
0542         dst++;
0543     }
0544     return dst;
0545 };
0546 
0547 static int 
0548 demunge_int32 (unsigned char* src, int src_size)
0549 
0550 {
0551     int i;
0552     int outval = 0;
0553     
0554     for (i = src_size - 1; i >= 0; i--) {
0555         outval=(outval<<7)+src[i];
0556     }
0557 
0558     return outval;
0559 };
0560 
0561 static 
0562 unsigned char *
0563 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
0564 
0565 {
0566     unsigned int i;
0567     unsigned int last = dst_size / 2;
0568 
0569     for (i = 0; i < last; i++) {
0570         *dst++ = src[i] & 0x7f;
0571         *dst++ = src[i] >> 7;
0572     }
0573     return dst;
0574 }
0575 
0576 static 
0577 unsigned char *
0578 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
0579 
0580 {
0581     int i;
0582     unsigned char *end = src + src_bytes;
0583     
0584     /* NOTE: src and dst *CAN* point to the same address */
0585 
0586     for (i = 0; src != end; i++) {
0587         dst[i] = *src++;
0588         dst[i] |= (*src++)<<7;
0589     }
0590 
0591     return dst;
0592 }
0593 
0594 /***********************************************************************
0595 WaveFront: sample, patch and program management.
0596 ***********************************************************************/
0597 
0598 static int
0599 wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
0600 
0601 {
0602     unsigned char wbuf[2];
0603     int x;
0604 
0605     wbuf[0] = sample_num & 0x7f;
0606     wbuf[1] = sample_num >> 7;
0607 
0608     x = snd_wavefront_cmd(dev, WFC_DELETE_SAMPLE, NULL, wbuf);
0609     if (!x)
0610         dev->sample_status[sample_num] = WF_ST_EMPTY;
0611 
0612     return x;
0613 }
0614 
0615 static int
0616 wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
0617 
0618 {
0619     int i;
0620     unsigned char rbuf[32], wbuf[32];
0621     unsigned int    sc_real, sc_alias, sc_multi;
0622 
0623     /* check sample status */
0624     
0625     if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
0626         snd_printk ("cannot request sample count.\n");
0627         return -1;
0628     } 
0629     
0630     sc_real = sc_alias = sc_multi = dev->samples_used = 0;
0631     
0632     for (i = 0; i < WF_MAX_SAMPLE; i++) {
0633     
0634         wbuf[0] = i & 0x7f;
0635         wbuf[1] = i >> 7;
0636 
0637         if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
0638             snd_printk(KERN_WARNING "cannot identify sample "
0639                    "type of slot %d\n", i);
0640             dev->sample_status[i] = WF_ST_EMPTY;
0641             continue;
0642         }
0643 
0644         dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
0645 
0646         if (assume_rom) {
0647             dev->sample_status[i] |= WF_SLOT_ROM;
0648         }
0649 
0650         switch (rbuf[0] & WF_ST_MASK) {
0651         case WF_ST_SAMPLE:
0652             sc_real++;
0653             break;
0654         case WF_ST_MULTISAMPLE:
0655             sc_multi++;
0656             break;
0657         case WF_ST_ALIAS:
0658             sc_alias++;
0659             break;
0660         case WF_ST_EMPTY:
0661             break;
0662 
0663         default:
0664             snd_printk ("unknown sample type for "
0665                     "slot %d (0x%x)\n", 
0666                     i, rbuf[0]);
0667         }
0668 
0669         if (rbuf[0] != WF_ST_EMPTY) {
0670             dev->samples_used++;
0671         } 
0672     }
0673 
0674     snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
0675             "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
0676             WF_MAX_SAMPLE - dev->samples_used);
0677 
0678 
0679     return (0);
0680 
0681 }
0682 
0683 static int
0684 wavefront_get_patch_status (snd_wavefront_t *dev)
0685 
0686 {
0687     unsigned char patchbuf[WF_PATCH_BYTES];
0688     unsigned char patchnum[2];
0689     wavefront_patch *p;
0690     int i, x, cnt, cnt2;
0691 
0692     for (i = 0; i < WF_MAX_PATCH; i++) {
0693         patchnum[0] = i & 0x7f;
0694         patchnum[1] = i >> 7;
0695 
0696         x = snd_wavefront_cmd(dev, WFC_UPLOAD_PATCH, patchbuf,
0697                       patchnum);
0698         if (x == 0) {
0699 
0700             dev->patch_status[i] |= WF_SLOT_FILLED;
0701             p = (wavefront_patch *) patchbuf;
0702             dev->sample_status
0703                 [p->sample_number|(p->sample_msb<<7)] |=
0704                 WF_SLOT_USED;
0705         
0706         } else if (x == 3) { /* Bad patch number */
0707             dev->patch_status[i] = 0;
0708         } else {
0709             snd_printk ("upload patch "
0710                     "error 0x%x\n", x);
0711             dev->patch_status[i] = 0;
0712             return 1;
0713         }
0714     }
0715 
0716     /* program status has already filled in slot_used bits */
0717 
0718     for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
0719         if (dev->patch_status[i] & WF_SLOT_FILLED) {
0720             cnt++;
0721         }
0722         if (dev->patch_status[i] & WF_SLOT_USED) {
0723             cnt2++;
0724         }
0725     
0726     }
0727     snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
0728 
0729     return (0);
0730 }
0731 
0732 static int
0733 wavefront_get_program_status (snd_wavefront_t *dev)
0734 
0735 {
0736     unsigned char progbuf[WF_PROGRAM_BYTES];
0737     wavefront_program prog;
0738     unsigned char prognum;
0739     int i, x, l, cnt;
0740 
0741     for (i = 0; i < WF_MAX_PROGRAM; i++) {
0742         prognum = i;
0743 
0744         x = snd_wavefront_cmd(dev, WFC_UPLOAD_PROGRAM, progbuf,
0745                       &prognum);
0746         if (x == 0) {
0747 
0748             dev->prog_status[i] |= WF_SLOT_USED;
0749 
0750             demunge_buf (progbuf, (unsigned char *) &prog,
0751                      WF_PROGRAM_BYTES);
0752 
0753             for (l = 0; l < WF_NUM_LAYERS; l++) {
0754                 if (prog.layer[l].mute) {
0755                     dev->patch_status
0756                         [prog.layer[l].patch_number] |=
0757                         WF_SLOT_USED;
0758                 }
0759             }
0760         } else if (x == 1) { /* Bad program number */
0761             dev->prog_status[i] = 0;
0762         } else {
0763             snd_printk ("upload program "
0764                     "error 0x%x\n", x);
0765             dev->prog_status[i] = 0;
0766         }
0767     }
0768 
0769     for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
0770         if (dev->prog_status[i]) {
0771             cnt++;
0772         }
0773     }
0774 
0775     snd_printk ("%d programs slots in use\n", cnt);
0776 
0777     return (0);
0778 }
0779 
0780 static int
0781 wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
0782 
0783 {
0784     unsigned char buf[WF_PATCH_BYTES+2];
0785     unsigned char *bptr;
0786 
0787     DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
0788                       header->number);
0789 
0790     if (header->number >= ARRAY_SIZE(dev->patch_status))
0791         return -EINVAL;
0792 
0793     dev->patch_status[header->number] |= WF_SLOT_FILLED;
0794 
0795     bptr = munge_int32 (header->number, buf, 2);
0796     munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
0797     
0798     if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
0799         snd_printk ("download patch failed\n");
0800         return -EIO;
0801     }
0802 
0803     return (0);
0804 }
0805 
0806 static int
0807 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
0808 
0809 {
0810     unsigned char buf[WF_PROGRAM_BYTES+1];
0811     int i;
0812 
0813     DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
0814         header->number);
0815 
0816     if (header->number >= ARRAY_SIZE(dev->prog_status))
0817         return -EINVAL;
0818 
0819     dev->prog_status[header->number] = WF_SLOT_USED;
0820 
0821     /* XXX need to zero existing SLOT_USED bit for program_status[i]
0822        where `i' is the program that's being (potentially) overwritten.
0823     */
0824     
0825     for (i = 0; i < WF_NUM_LAYERS; i++) {
0826         if (header->hdr.pr.layer[i].mute) {
0827             dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
0828                 WF_SLOT_USED;
0829 
0830             /* XXX need to mark SLOT_USED for sample used by
0831                patch_number, but this means we have to load it. Ick.
0832             */
0833         }
0834     }
0835 
0836     buf[0] = header->number;
0837     munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
0838     
0839     if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
0840         snd_printk ("download patch failed\n"); 
0841         return -EIO;
0842     }
0843 
0844     return (0);
0845 }
0846 
0847 static int
0848 wavefront_freemem (snd_wavefront_t *dev)
0849 
0850 {
0851     char rbuf[8];
0852 
0853     if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
0854         snd_printk ("can't get memory stats.\n");
0855         return -1;
0856     } else {
0857         return demunge_int32 (rbuf, 4);
0858     }
0859 }
0860 
0861 static int
0862 wavefront_send_sample (snd_wavefront_t *dev, 
0863                wavefront_patch_info *header,
0864                u16 __user *dataptr,
0865                int data_is_unsigned)
0866 
0867 {
0868     /* samples are downloaded via a 16-bit wide i/o port
0869        (you could think of it as 2 adjacent 8-bit wide ports
0870        but its less efficient that way). therefore, all
0871        the blocksizes and so forth listed in the documentation,
0872        and used conventionally to refer to sample sizes,
0873        which are given in 8-bit units (bytes), need to be
0874        divided by 2.
0875         */
0876 
0877     u16 sample_short = 0;
0878     u32 length;
0879     u16 __user *data_end = NULL;
0880     unsigned int i;
0881     const unsigned int max_blksize = 4096/2;
0882     unsigned int written;
0883     unsigned int blocksize;
0884     int dma_ack;
0885     int blocknum;
0886     unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
0887     unsigned char *shptr;
0888     int skip = 0;
0889     int initial_skip = 0;
0890 
0891     DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
0892                       "type %d, %d bytes from 0x%lx\n",
0893                       header->size ? "" : "header ", 
0894                       header->number, header->subkey,
0895                       header->size,
0896                       (unsigned long) header->dataptr);
0897 
0898     if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
0899         int x;
0900 
0901         x = wavefront_find_free_sample(dev);
0902         if (x < 0)
0903             return -ENOMEM;
0904         snd_printk ("unspecified sample => %d\n", x);
0905         header->number = x;
0906     }
0907 
0908     if (header->number >= WF_MAX_SAMPLE)
0909         return -EINVAL;
0910 
0911     if (header->size) {
0912 
0913         /* XXX it's a debatable point whether or not RDONLY semantics
0914            on the ROM samples should cover just the sample data or
0915            the sample header. For now, it only covers the sample data,
0916            so anyone is free at all times to rewrite sample headers.
0917 
0918            My reason for this is that we have the sample headers
0919            available in the WFB file for General MIDI, and so these
0920            can always be reset if needed. The sample data, however,
0921            cannot be recovered without a complete reset and firmware
0922            reload of the ICS2115, which is a very expensive operation.
0923 
0924            So, doing things this way allows us to honor the notion of
0925            "RESETSAMPLES" reasonably cheaply. Note however, that this
0926            is done purely at user level: there is no WFB parser in
0927            this driver, and so a complete reset (back to General MIDI,
0928            or theoretically some other configuration) is the
0929            responsibility of the user level library. 
0930 
0931            To try to do this in the kernel would be a little
0932            crazy: we'd need 158K of kernel space just to hold
0933            a copy of the patch/program/sample header data.
0934         */
0935 
0936         if (dev->rom_samples_rdonly) {
0937             if (dev->sample_status[header->number] & WF_SLOT_ROM) {
0938                 snd_printk ("sample slot %d "
0939                         "write protected\n",
0940                         header->number);
0941                 return -EACCES;
0942             }
0943         }
0944 
0945         wavefront_delete_sample (dev, header->number);
0946     }
0947 
0948     if (header->size) {
0949         dev->freemem = wavefront_freemem (dev);
0950 
0951         if (dev->freemem < (int)header->size) {
0952             snd_printk ("insufficient memory to "
0953                     "load %d byte sample.\n",
0954                     header->size);
0955             return -ENOMEM;
0956         }
0957     
0958     }
0959 
0960     skip = WF_GET_CHANNEL(&header->hdr.s);
0961 
0962     if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
0963         snd_printk ("channel selection only "
0964                 "possible on 16-bit samples");
0965         return -EINVAL;
0966     }
0967 
0968     switch (skip) {
0969     case 0:
0970         initial_skip = 0;
0971         skip = 1;
0972         break;
0973     case 1:
0974         initial_skip = 0;
0975         skip = 2;
0976         break;
0977     case 2:
0978         initial_skip = 1;
0979         skip = 2;
0980         break;
0981     case 3:
0982         initial_skip = 2;
0983         skip = 3;
0984         break;
0985     case 4:
0986         initial_skip = 3;
0987         skip = 4;
0988         break;
0989     case 5:
0990         initial_skip = 4;
0991         skip = 5;
0992         break;
0993     case 6:
0994         initial_skip = 5;
0995         skip = 6;
0996         break;
0997     }
0998 
0999     DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
1000                       "initial skip = %d, skip = %d\n",
1001                       WF_GET_CHANNEL (&header->hdr.s),
1002                       initial_skip, skip);
1003     
1004     /* Be safe, and zero the "Unused" bits ... */
1005 
1006     WF_SET_CHANNEL(&header->hdr.s, 0);
1007 
1008     /* adjust size for 16 bit samples by dividing by two.  We always
1009        send 16 bits per write, even for 8 bit samples, so the length
1010        is always half the size of the sample data in bytes.
1011     */
1012 
1013     length = header->size / 2;
1014 
1015     /* the data we're sent has not been munged, and in fact, the
1016        header we have to send isn't just a munged copy either.
1017        so, build the sample header right here.
1018     */
1019 
1020     shptr = &sample_hdr[0];
1021 
1022     shptr = munge_int32 (header->number, shptr, 2);
1023 
1024     if (header->size) {
1025         shptr = munge_int32 (length, shptr, 4);
1026     }
1027 
1028     /* Yes, a 4 byte result doesn't contain all of the offset bits,
1029        but the offset only uses 24 bits.
1030     */
1031 
1032     shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1033                  shptr, 4);
1034     shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1035                  shptr, 4);
1036     shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1037                  shptr, 4);
1038     shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1039                  shptr, 4);
1040     
1041     /* This one is truly weird. What kind of weirdo decided that in
1042        a system dominated by 16 and 32 bit integers, they would use
1043        a just 12 bits ?
1044     */
1045     
1046     shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1047     
1048     /* Why is this nybblified, when the MSB is *always* zero ? 
1049        Anyway, we can't take address of bitfield, so make a
1050        good-faith guess at where it starts.
1051     */
1052     
1053     shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1054                  shptr, 2);
1055 
1056     if (snd_wavefront_cmd (dev, 
1057                header->size ?
1058                WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1059                NULL, sample_hdr)) {
1060         snd_printk ("sample %sdownload refused.\n",
1061                 header->size ? "" : "header ");
1062         return -EIO;
1063     }
1064 
1065     if (header->size == 0) {
1066         goto sent; /* Sorry. Just had to have one somewhere */
1067     }
1068     
1069     data_end = dataptr + length;
1070 
1071     /* Do any initial skip over an unused channel's data */
1072 
1073     dataptr += initial_skip;
1074     
1075     for (written = 0, blocknum = 0;
1076          written < length; written += max_blksize, blocknum++) {
1077     
1078         if ((length - written) > max_blksize) {
1079             blocksize = max_blksize;
1080         } else {
1081             /* round to nearest 16-byte value */
1082             blocksize = ALIGN(length - written, 8);
1083         }
1084 
1085         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1086             snd_printk ("download block "
1087                     "request refused.\n");
1088             return -EIO;
1089         }
1090 
1091         for (i = 0; i < blocksize; i++) {
1092 
1093             if (dataptr < data_end) {
1094         
1095                 if (get_user(sample_short, dataptr))
1096                     return -EFAULT;
1097                 dataptr += skip;
1098         
1099                 if (data_is_unsigned) { /* GUS ? */
1100 
1101                     if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1102             
1103                         /* 8 bit sample
1104                          resolution, sign
1105                          extend both bytes.
1106                         */
1107             
1108                         ((unsigned char*)
1109                          &sample_short)[0] += 0x7f;
1110                         ((unsigned char*)
1111                          &sample_short)[1] += 0x7f;
1112             
1113                     } else {
1114             
1115                         /* 16 bit sample
1116                          resolution, sign
1117                          extend the MSB.
1118                         */
1119             
1120                         sample_short += 0x7fff;
1121                     }
1122                 }
1123 
1124             } else {
1125 
1126                 /* In padding section of final block:
1127 
1128                    Don't fetch unsupplied data from
1129                    user space, just continue with
1130                    whatever the final value was.
1131                 */
1132             }
1133         
1134             if (i < blocksize - 1) {
1135                 outw (sample_short, dev->block_port);
1136             } else {
1137                 outw (sample_short, dev->last_block_port);
1138             }
1139         }
1140 
1141         /* Get "DMA page acknowledge", even though its really
1142            nothing to do with DMA at all.
1143         */
1144     
1145         dma_ack = wavefront_read(dev);
1146         if (dma_ack != WF_DMA_ACK) {
1147             if (dma_ack == -1) {
1148                 snd_printk ("upload sample "
1149                         "DMA ack timeout\n");
1150                 return -EIO;
1151             } else {
1152                 snd_printk ("upload sample "
1153                         "DMA ack error 0x%x\n",
1154                         dma_ack);
1155                 return -EIO;
1156             }
1157         }
1158     }
1159 
1160     dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1161 
1162     /* Note, label is here because sending the sample header shouldn't
1163        alter the sample_status info at all.
1164     */
1165 
1166  sent:
1167     return (0);
1168 }
1169 
1170 static int
1171 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1172 
1173 {
1174     unsigned char alias_hdr[WF_ALIAS_BYTES];
1175 
1176     DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1177                       "alias for %d\n",
1178                       header->number,
1179                       header->hdr.a.OriginalSample);
1180 
1181     if (header->number >= WF_MAX_SAMPLE)
1182         return -EINVAL;
1183 
1184     munge_int32 (header->number, &alias_hdr[0], 2);
1185     munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1186     munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1187              &alias_hdr[4], 4);
1188     munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1189              &alias_hdr[8], 4);
1190     munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1191              &alias_hdr[12], 4);
1192     munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1193              &alias_hdr[16], 4);
1194     munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1195     munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1196 
1197     if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1198         snd_printk ("download alias failed.\n");
1199         return -EIO;
1200     }
1201 
1202     dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1203 
1204     return (0);
1205 }
1206 
1207 static int
1208 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1209 {
1210     int i;
1211     int num_samples;
1212     unsigned char *msample_hdr;
1213 
1214     if (header->number >= WF_MAX_SAMPLE)
1215         return -EINVAL;
1216 
1217     msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1218     if (! msample_hdr)
1219         return -ENOMEM;
1220 
1221     munge_int32 (header->number, &msample_hdr[0], 2);
1222 
1223     /* You'll recall at this point that the "number of samples" value
1224        in a wavefront_multisample struct is actually the log2 of the
1225        real number of samples.
1226     */
1227 
1228     num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1229     msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1230 
1231     DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1232                       header->number,
1233                       header->hdr.ms.NumberOfSamples,
1234                       num_samples);
1235 
1236     for (i = 0; i < num_samples; i++) {
1237         DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1238                i, header->hdr.ms.SampleNumber[i]);
1239         munge_int32 (header->hdr.ms.SampleNumber[i],
1240              &msample_hdr[3+(i*2)], 2);
1241     }
1242     
1243     /* Need a hack here to pass in the number of bytes
1244        to be written to the synth. This is ugly, and perhaps
1245        one day, I'll fix it.
1246     */
1247 
1248     if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE, 
1249                (unsigned char *) (long) ((num_samples*2)+3),
1250                msample_hdr)) {
1251         snd_printk ("download of multisample failed.\n");
1252         kfree(msample_hdr);
1253         return -EIO;
1254     }
1255 
1256     dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1257 
1258     kfree(msample_hdr);
1259     return (0);
1260 }
1261 
1262 static int
1263 wavefront_fetch_multisample (snd_wavefront_t *dev, 
1264                  wavefront_patch_info *header)
1265 {
1266     int i;
1267     unsigned char log_ns[1];
1268     unsigned char number[2];
1269     int num_samples;
1270 
1271     munge_int32 (header->number, number, 2);
1272     
1273     if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1274         snd_printk ("upload multisample failed.\n");
1275         return -EIO;
1276     }
1277     
1278     DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1279                 header->number, log_ns[0]);
1280 
1281     header->hdr.ms.NumberOfSamples = log_ns[0];
1282 
1283     /* get the number of samples ... */
1284 
1285     num_samples = (1 << log_ns[0]);
1286     
1287     for (i = 0; i < num_samples; i++) {
1288         char d[2];
1289         int val;
1290     
1291         val = wavefront_read(dev);
1292         if (val == -1) {
1293             snd_printk ("upload multisample failed "
1294                     "during sample loop.\n");
1295             return -EIO;
1296         }
1297         d[0] = val;
1298 
1299         val = wavefront_read(dev);
1300         if (val == -1) {
1301             snd_printk ("upload multisample failed "
1302                     "during sample loop.\n");
1303             return -EIO;
1304         }
1305         d[1] = val;
1306     
1307         header->hdr.ms.SampleNumber[i] =
1308             demunge_int32 ((unsigned char *) d, 2);
1309     
1310         DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1311                     i, header->hdr.ms.SampleNumber[i]);
1312     }
1313 
1314     return (0);
1315 }
1316 
1317 
1318 static int
1319 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1320 
1321 {
1322     unsigned char drumbuf[WF_DRUM_BYTES];
1323     wavefront_drum *drum = &header->hdr.d;
1324     int i;
1325 
1326     DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1327         "note %d, patch = %d\n", 
1328         header->number, drum->PatchNumber);
1329 
1330     drumbuf[0] = header->number & 0x7f;
1331 
1332     for (i = 0; i < 4; i++) {
1333         munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1334     }
1335 
1336     if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1337         snd_printk ("download drum failed.\n");
1338         return -EIO;
1339     }
1340 
1341     return (0);
1342 }
1343 
1344 static int 
1345 wavefront_find_free_sample (snd_wavefront_t *dev)
1346 
1347 {
1348     int i;
1349 
1350     for (i = 0; i < WF_MAX_SAMPLE; i++) {
1351         if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1352             return i;
1353         }
1354     }
1355     snd_printk ("no free sample slots!\n");
1356     return -1;
1357 }
1358 
1359 #if 0
1360 static int 
1361 wavefront_find_free_patch (snd_wavefront_t *dev)
1362 
1363 {
1364     int i;
1365 
1366     for (i = 0; i < WF_MAX_PATCH; i++) {
1367         if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1368             return i;
1369         }
1370     }
1371     snd_printk ("no free patch slots!\n");
1372     return -1;
1373 }
1374 #endif
1375 
1376 static int
1377 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1378 {
1379     wavefront_patch_info *header;
1380     int err;
1381     
1382     header = kmalloc(sizeof(*header), GFP_KERNEL);
1383     if (! header)
1384         return -ENOMEM;
1385 
1386     if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1387                 sizeof(wavefront_any))) {
1388         snd_printk ("bad address for load patch.\n");
1389         err = -EFAULT;
1390         goto __error;
1391     }
1392 
1393     DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1394                       "Sample type: %d "
1395                       "Sample number: %d "
1396                       "Sample size: %d\n",
1397                       header->subkey,
1398                       header->number,
1399                       header->size);
1400 
1401     switch (header->subkey) {
1402     case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */
1403 
1404         if (copy_from_user (&header->hdr.s, header->hdrptr,
1405                     sizeof (wavefront_sample))) {
1406             err = -EFAULT;
1407             break;
1408         }
1409 
1410         err = wavefront_send_sample (dev, header, header->dataptr, 0);
1411         break;
1412 
1413     case WF_ST_MULTISAMPLE:
1414 
1415         if (copy_from_user (&header->hdr.s, header->hdrptr,
1416                     sizeof (wavefront_multisample))) {
1417             err = -EFAULT;
1418             break;
1419         }
1420 
1421         err = wavefront_send_multisample (dev, header);
1422         break;
1423 
1424     case WF_ST_ALIAS:
1425 
1426         if (copy_from_user (&header->hdr.a, header->hdrptr,
1427                     sizeof (wavefront_alias))) {
1428             err = -EFAULT;
1429             break;
1430         }
1431 
1432         err = wavefront_send_alias (dev, header);
1433         break;
1434 
1435     case WF_ST_DRUM:
1436         if (copy_from_user (&header->hdr.d, header->hdrptr,
1437                     sizeof (wavefront_drum))) {
1438             err = -EFAULT;
1439             break;
1440         }
1441 
1442         err = wavefront_send_drum (dev, header);
1443         break;
1444 
1445     case WF_ST_PATCH:
1446         if (copy_from_user (&header->hdr.p, header->hdrptr,
1447                     sizeof (wavefront_patch))) {
1448             err = -EFAULT;
1449             break;
1450         }
1451         
1452         err = wavefront_send_patch (dev, header);
1453         break;
1454 
1455     case WF_ST_PROGRAM:
1456         if (copy_from_user (&header->hdr.pr, header->hdrptr,
1457                     sizeof (wavefront_program))) {
1458             err = -EFAULT;
1459             break;
1460         }
1461 
1462         err = wavefront_send_program (dev, header);
1463         break;
1464 
1465     default:
1466         snd_printk ("unknown patch type %d.\n",
1467                 header->subkey);
1468         err = -EINVAL;
1469         break;
1470     }
1471 
1472  __error:
1473     kfree(header);
1474     return err;
1475 }
1476 
1477 /***********************************************************************
1478 WaveFront: hardware-dependent interface
1479 ***********************************************************************/
1480 
1481 static void
1482 process_sample_hdr (u8 *buf)
1483 
1484 {
1485     wavefront_sample s;
1486     u8 *ptr;
1487 
1488     ptr = buf;
1489 
1490     /* The board doesn't send us an exact copy of a "wavefront_sample"
1491        in response to an Upload Sample Header command. Instead, we 
1492        have to convert the data format back into our data structure,
1493        just as in the Download Sample command, where we have to do
1494        something very similar in the reverse direction.
1495     */
1496 
1497     *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1498     *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1499     *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1500     *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1501     *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1502 
1503     s.SampleResolution = *ptr & 0x3;
1504     s.Loop = *ptr & 0x8;
1505     s.Bidirectional = *ptr & 0x10;
1506     s.Reverse = *ptr & 0x40;
1507 
1508     /* Now copy it back to where it came from */
1509 
1510     memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1511 }
1512 
1513 static int
1514 wavefront_synth_control (snd_wavefront_card_t *acard, 
1515              wavefront_control *wc)
1516 
1517 {
1518     snd_wavefront_t *dev = &acard->wavefront;
1519     unsigned char patchnumbuf[2];
1520     int i;
1521 
1522     DPRINT (WF_DEBUG_CMD, "synth control with "
1523         "cmd 0x%x\n", wc->cmd);
1524 
1525     /* Pre-handling of or for various commands */
1526 
1527     switch (wc->cmd) {
1528         
1529     case WFC_DISABLE_INTERRUPTS:
1530         snd_printk ("interrupts disabled.\n");
1531         outb (0x80|0x20, dev->control_port);
1532         dev->interrupts_are_midi = 1;
1533         return 0;
1534 
1535     case WFC_ENABLE_INTERRUPTS:
1536         snd_printk ("interrupts enabled.\n");
1537         outb (0x80|0x40|0x20, dev->control_port);
1538         dev->interrupts_are_midi = 1;
1539         return 0;
1540 
1541     case WFC_INTERRUPT_STATUS:
1542         wc->rbuf[0] = dev->interrupts_are_midi;
1543         return 0;
1544 
1545     case WFC_ROMSAMPLES_RDONLY:
1546         dev->rom_samples_rdonly = wc->wbuf[0];
1547         wc->status = 0;
1548         return 0;
1549 
1550     case WFC_IDENTIFY_SLOT_TYPE:
1551         i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1552         if (i <0 || i >= WF_MAX_SAMPLE) {
1553             snd_printk ("invalid slot ID %d\n",
1554                 i);
1555             wc->status = EINVAL;
1556             return -EINVAL;
1557         }
1558         wc->rbuf[0] = dev->sample_status[i];
1559         wc->status = 0;
1560         return 0;
1561 
1562     case WFC_DEBUG_DRIVER:
1563         dev->debug = wc->wbuf[0];
1564         snd_printk ("debug = 0x%x\n", dev->debug);
1565         return 0;
1566 
1567     case WFC_UPLOAD_PATCH:
1568         munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1569         memcpy (wc->wbuf, patchnumbuf, 2);
1570         break;
1571 
1572     case WFC_UPLOAD_MULTISAMPLE:
1573         /* multisamples have to be handled differently, and
1574            cannot be dealt with properly by snd_wavefront_cmd() alone.
1575         */
1576         wc->status = wavefront_fetch_multisample
1577             (dev, (wavefront_patch_info *) wc->rbuf);
1578         return 0;
1579 
1580     case WFC_UPLOAD_SAMPLE_ALIAS:
1581         snd_printk ("support for sample alias upload "
1582             "being considered.\n");
1583         wc->status = EINVAL;
1584         return -EINVAL;
1585     }
1586 
1587     wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1588 
1589     /* Post-handling of certain commands.
1590 
1591        In particular, if the command was an upload, demunge the data
1592        so that the user-level doesn't have to think about it.
1593     */
1594 
1595     if (wc->status == 0) {
1596         switch (wc->cmd) {
1597             /* intercept any freemem requests so that we know
1598                we are always current with the user-level view
1599                of things.
1600             */
1601 
1602         case WFC_REPORT_FREE_MEMORY:
1603             dev->freemem = demunge_int32 (wc->rbuf, 4);
1604             break;
1605 
1606         case WFC_UPLOAD_PATCH:
1607             demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1608             break;
1609 
1610         case WFC_UPLOAD_PROGRAM:
1611             demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1612             break;
1613 
1614         case WFC_UPLOAD_EDRUM_PROGRAM:
1615             demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1616             break;
1617 
1618         case WFC_UPLOAD_SAMPLE_HEADER:
1619             process_sample_hdr (wc->rbuf);
1620             break;
1621 
1622         case WFC_UPLOAD_SAMPLE_ALIAS:
1623             snd_printk ("support for "
1624                     "sample aliases still "
1625                     "being considered.\n");
1626             break;
1627 
1628         case WFC_VMIDI_OFF:
1629             snd_wavefront_midi_disable_virtual (acard);
1630             break;
1631 
1632         case WFC_VMIDI_ON:
1633             snd_wavefront_midi_enable_virtual (acard);
1634             break;
1635         }
1636     }
1637 
1638     return 0;
1639 }
1640 
1641 int 
1642 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1643 
1644 {
1645     if (!try_module_get(hw->card->module))
1646         return -EFAULT;
1647     file->private_data = hw;
1648     return 0;
1649 }
1650 
1651 int 
1652 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1653 
1654 {
1655     module_put(hw->card->module);
1656     return 0;
1657 }
1658 
1659 int
1660 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1661                unsigned int cmd, unsigned long arg)
1662 
1663 {
1664     struct snd_card *card;
1665     snd_wavefront_t *dev;
1666     snd_wavefront_card_t *acard;
1667     wavefront_control *wc;
1668     void __user *argp = (void __user *)arg;
1669     int err;
1670 
1671     card = (struct snd_card *) hw->card;
1672 
1673     if (snd_BUG_ON(!card))
1674         return -ENODEV;
1675     if (snd_BUG_ON(!card->private_data))
1676         return -ENODEV;
1677 
1678     acard = card->private_data;
1679     dev = &acard->wavefront;
1680     
1681     switch (cmd) {
1682     case WFCTL_LOAD_SPP:
1683         if (wavefront_load_patch (dev, argp) != 0) {
1684             return -EIO;
1685         }
1686         break;
1687 
1688     case WFCTL_WFCMD:
1689         wc = memdup_user(argp, sizeof(*wc));
1690         if (IS_ERR(wc))
1691             return PTR_ERR(wc);
1692 
1693         if (wavefront_synth_control (acard, wc) < 0)
1694             err = -EIO;
1695         else if (copy_to_user (argp, wc, sizeof (*wc)))
1696             err = -EFAULT;
1697         else
1698             err = 0;
1699         kfree(wc);
1700         return err;
1701 
1702     default:
1703         return -EINVAL;
1704     }
1705 
1706     return 0;
1707 }
1708 
1709 
1710 /***********************************************************************/
1711 /*  WaveFront: interface for card-level wavefront module               */
1712 /***********************************************************************/
1713 
1714 void
1715 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1716 {
1717     snd_wavefront_t *dev = &card->wavefront;
1718 
1719     /*
1720        Some comments on interrupts. I attempted a version of this
1721        driver that used interrupts throughout the code instead of
1722        doing busy and/or sleep-waiting. Alas, it appears that once
1723        the Motorola firmware is downloaded, the card *never*
1724        generates an RX interrupt. These are successfully generated
1725        during firmware loading, and after that wavefront_status()
1726        reports that an interrupt is pending on the card from time
1727        to time, but it never seems to be delivered to this
1728        driver. Note also that wavefront_status() continues to
1729        report that RX interrupts are enabled, suggesting that I
1730        didn't goof up and disable them by mistake.
1731 
1732        Thus, I stepped back to a prior version of
1733        wavefront_wait(), the only place where this really
1734        matters. Its sad, but I've looked through the code to check
1735        on things, and I really feel certain that the Motorola
1736        firmware prevents RX-ready interrupts.
1737     */
1738 
1739     if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1740         return;
1741     }
1742 
1743     spin_lock(&dev->irq_lock);
1744     dev->irq_ok = 1;
1745     dev->irq_cnt++;
1746     spin_unlock(&dev->irq_lock);
1747     wake_up(&dev->interrupt_sleeper);
1748 }
1749 
1750 /* STATUS REGISTER 
1751 
1752 0 Host Rx Interrupt Enable (1=Enabled)
1753 1 Host Rx Register Full (1=Full)
1754 2 Host Rx Interrupt Pending (1=Interrupt)
1755 3 Unused
1756 4 Host Tx Interrupt (1=Enabled)
1757 5 Host Tx Register empty (1=Empty)
1758 6 Host Tx Interrupt Pending (1=Interrupt)
1759 7 Unused
1760 */
1761 
1762 static int
1763 snd_wavefront_interrupt_bits (int irq)
1764 
1765 {
1766     int bits;
1767 
1768     switch (irq) {
1769     case 9:
1770         bits = 0x00;
1771         break;
1772     case 5:
1773         bits = 0x08;
1774         break;
1775     case 12:
1776         bits = 0x10;
1777         break;
1778     case 15:
1779         bits = 0x18;
1780         break;
1781     
1782     default:
1783         snd_printk ("invalid IRQ %d\n", irq);
1784         bits = -1;
1785     }
1786 
1787     return bits;
1788 }
1789 
1790 static void
1791 wavefront_should_cause_interrupt (snd_wavefront_t *dev, 
1792                   int val, int port, unsigned long timeout)
1793 
1794 {
1795     wait_queue_entry_t wait;
1796 
1797     init_waitqueue_entry(&wait, current);
1798     spin_lock_irq(&dev->irq_lock);
1799     add_wait_queue(&dev->interrupt_sleeper, &wait);
1800     dev->irq_ok = 0;
1801     outb (val,port);
1802     spin_unlock_irq(&dev->irq_lock);
1803     while (!dev->irq_ok && time_before(jiffies, timeout)) {
1804         schedule_timeout_uninterruptible(1);
1805         barrier();
1806     }
1807 }
1808 
1809 static int
1810 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1811 
1812 {
1813     int bits;
1814     int hwv[2];
1815 
1816     /* IRQ already checked */
1817 
1818     bits = snd_wavefront_interrupt_bits (dev->irq);
1819 
1820     /* try reset of port */
1821 
1822     outb (0x0, dev->control_port); 
1823   
1824     /* At this point, the board is in reset, and the H/W initialization
1825        register is accessed at the same address as the data port.
1826      
1827        Bit 7 - Enable IRQ Driver    
1828        0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1829        1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1830      
1831        Bit 6 - MIDI Interface Select
1832 
1833        0 - Use the MIDI Input from the 26-pin WaveBlaster
1834        compatible header as the serial MIDI source
1835        1 - Use the MIDI Input from the 9-pin D connector as the
1836        serial MIDI source.
1837      
1838        Bits 5:3 - IRQ Selection
1839        0 0 0 - IRQ 2/9
1840        0 0 1 - IRQ 5
1841        0 1 0 - IRQ 12
1842        0 1 1 - IRQ 15
1843        1 0 0 - Reserved
1844        1 0 1 - Reserved
1845        1 1 0 - Reserved
1846        1 1 1 - Reserved
1847      
1848        Bits 2:1 - Reserved
1849        Bit 0 - Disable Boot ROM
1850        0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1851        1 - memory accesses to 03FC30-03FFFFH are directed to external 
1852        storage.
1853      
1854     */
1855 
1856     /* configure hardware: IRQ, enable interrupts, 
1857        plus external 9-pin MIDI interface selected
1858     */
1859 
1860     outb (0x80 | 0x40 | bits, dev->data_port);  
1861   
1862     /* CONTROL REGISTER
1863 
1864        0 Host Rx Interrupt Enable (1=Enabled)      0x1
1865        1 Unused                                    0x2
1866        2 Unused                                    0x4
1867        3 Unused                                    0x8
1868        4 Host Tx Interrupt Enable                 0x10
1869        5 Mute (0=Mute; 1=Play)                    0x20
1870        6 Master Interrupt Enable (1=Enabled)      0x40
1871        7 Master Reset (0=Reset; 1=Run)            0x80
1872 
1873        Take us out of reset, mute output, master + TX + RX interrupts on.
1874        
1875        We'll get an interrupt presumably to tell us that the TX
1876        register is clear.
1877     */
1878 
1879     wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1880                      dev->control_port,
1881                      (reset_time*HZ)/100);
1882 
1883     /* Note: data port is now the data port, not the h/w initialization
1884        port.
1885      */
1886 
1887     if (!dev->irq_ok) {
1888         snd_printk ("intr not received after h/w un-reset.\n");
1889         goto gone_bad;
1890     } 
1891 
1892     /* Note: data port is now the data port, not the h/w initialization
1893        port.
1894 
1895        At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1896        will work. So, issue one of them, and wait for TX
1897        interrupt. This can take a *long* time after a cold boot,
1898        while the ISC ROM does its RAM test. The SDK says up to 4
1899        seconds - with 12MB of RAM on a Tropez+, it takes a lot
1900        longer than that (~16secs). Note that the card understands
1901        the difference between a warm and a cold boot, so
1902        subsequent ISC2115 reboots (say, caused by module
1903        reloading) will get through this much faster.
1904 
1905        XXX Interesting question: why is no RX interrupt received first ?
1906     */
1907 
1908     wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION, 
1909                      dev->data_port, ramcheck_time*HZ);
1910 
1911     if (!dev->irq_ok) {
1912         snd_printk ("post-RAM-check interrupt not received.\n");
1913         goto gone_bad;
1914     } 
1915 
1916     if (!wavefront_wait (dev, STAT_CAN_READ)) {
1917         snd_printk ("no response to HW version cmd.\n");
1918         goto gone_bad;
1919     }
1920     
1921     hwv[0] = wavefront_read(dev);
1922     if (hwv[0] == -1) {
1923         snd_printk ("board not responding correctly.\n");
1924         goto gone_bad;
1925     }
1926 
1927     if (hwv[0] == 0xFF) { /* NAK */
1928 
1929         /* Board's RAM test failed. Try to read error code,
1930            and tell us about it either way.
1931         */
1932         
1933         hwv[0] = wavefront_read(dev);
1934         if (hwv[0] == -1) {
1935             snd_printk ("on-board RAM test failed "
1936                     "(bad error code).\n");
1937         } else {
1938             snd_printk ("on-board RAM test failed "
1939                     "(error code: 0x%x).\n",
1940                 hwv[0]);
1941         }
1942         goto gone_bad;
1943     }
1944 
1945     /* We're OK, just get the next byte of the HW version response */
1946 
1947     hwv[1] = wavefront_read(dev);
1948     if (hwv[1] == -1) {
1949         snd_printk ("incorrect h/w response.\n");
1950         goto gone_bad;
1951     }
1952 
1953     snd_printk ("hardware version %d.%d\n",
1954             hwv[0], hwv[1]);
1955 
1956     return 0;
1957 
1958 
1959      gone_bad:
1960     return (1);
1961 }
1962 
1963 static int
1964 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1965 
1966 {
1967     const unsigned char *buf;
1968     int len, err;
1969     int section_cnt_downloaded = 0;
1970     const struct firmware *firmware;
1971 
1972     err = request_firmware(&firmware, path, dev->card->dev);
1973     if (err < 0) {
1974         snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1975         return 1;
1976     }
1977 
1978     len = 0;
1979     buf = firmware->data;
1980     for (;;) {
1981         int section_length = *(signed char *)buf;
1982         if (section_length == 0)
1983             break;
1984         if (section_length < 0 || section_length > WF_SECTION_MAX) {
1985             snd_printk(KERN_ERR
1986                    "invalid firmware section length %d\n",
1987                    section_length);
1988             goto failure;
1989         }
1990         buf++;
1991         len++;
1992 
1993         if (firmware->size < len + section_length) {
1994             snd_printk(KERN_ERR "firmware section read error.\n");
1995             goto failure;
1996         }
1997 
1998         /* Send command */
1999         if (wavefront_write(dev, WFC_DOWNLOAD_OS))
2000             goto failure;
2001     
2002         for (; section_length; section_length--) {
2003             if (wavefront_write(dev, *buf))
2004                 goto failure;
2005             buf++;
2006             len++;
2007         }
2008     
2009         /* get ACK */
2010         if (!wavefront_wait(dev, STAT_CAN_READ)) {
2011             snd_printk(KERN_ERR "time out for firmware ACK.\n");
2012             goto failure;
2013         }
2014         err = inb(dev->data_port);
2015         if (err != WF_ACK) {
2016             snd_printk(KERN_ERR
2017                    "download of section #%d not "
2018                    "acknowledged, ack = 0x%x\n",
2019                    section_cnt_downloaded + 1, err);
2020             goto failure;
2021         }
2022 
2023         section_cnt_downloaded++;
2024     }
2025 
2026     release_firmware(firmware);
2027     return 0;
2028 
2029  failure:
2030     release_firmware(firmware);
2031     snd_printk(KERN_ERR "firmware download failed!!!\n");
2032     return 1;
2033 }
2034 
2035 
2036 static int
2037 wavefront_do_reset (snd_wavefront_t *dev)
2038 
2039 {
2040     char voices[1];
2041 
2042     if (wavefront_reset_to_cleanliness (dev)) {
2043         snd_printk ("hw reset failed.\n");
2044         goto gone_bad;
2045     }
2046 
2047     if (dev->israw) {
2048         if (wavefront_download_firmware (dev, ospath)) {
2049             goto gone_bad;
2050         }
2051 
2052         dev->israw = 0;
2053 
2054         /* Wait for the OS to get running. The protocol for
2055            this is non-obvious, and was determined by
2056            using port-IO tracing in DOSemu and some
2057            experimentation here.
2058            
2059            Rather than using timed waits, use interrupts creatively.
2060         */
2061 
2062         wavefront_should_cause_interrupt (dev, WFC_NOOP,
2063                           dev->data_port,
2064                           (osrun_time*HZ));
2065 
2066         if (!dev->irq_ok) {
2067             snd_printk ("no post-OS interrupt.\n");
2068             goto gone_bad;
2069         }
2070         
2071         /* Now, do it again ! */
2072         
2073         wavefront_should_cause_interrupt (dev, WFC_NOOP,
2074                           dev->data_port, (10*HZ));
2075         
2076         if (!dev->irq_ok) {
2077             snd_printk ("no post-OS interrupt(2).\n");
2078             goto gone_bad;
2079         }
2080 
2081         /* OK, no (RX/TX) interrupts any more, but leave mute
2082            in effect. 
2083         */
2084         
2085         outb (0x80|0x40, dev->control_port); 
2086     }
2087 
2088     /* SETUPSND.EXE asks for sample memory config here, but since i
2089        have no idea how to interpret the result, we'll forget
2090        about it.
2091     */
2092     
2093     dev->freemem = wavefront_freemem(dev);
2094     if (dev->freemem < 0)
2095         goto gone_bad;
2096         
2097     snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2098 
2099     if (wavefront_write (dev, 0xf0) ||
2100         wavefront_write (dev, 1) ||
2101         (wavefront_read (dev) < 0)) {
2102         dev->debug = 0;
2103         snd_printk ("MPU emulation mode not set.\n");
2104         goto gone_bad;
2105     }
2106 
2107     voices[0] = 32;
2108 
2109     if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2110         snd_printk ("cannot set number of voices to 32.\n");
2111         goto gone_bad;
2112     }
2113 
2114 
2115     return 0;
2116 
2117  gone_bad:
2118     /* reset that sucker so that it doesn't bother us. */
2119 
2120     outb (0x0, dev->control_port);
2121     dev->interrupts_are_midi = 0;
2122     return 1;
2123 }
2124 
2125 int
2126 snd_wavefront_start (snd_wavefront_t *dev)
2127 
2128 {
2129     int samples_are_from_rom;
2130 
2131     /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2132        wavefront_reset_to_cleanliness() has already been called 
2133     */
2134 
2135     if (dev->israw) {
2136         samples_are_from_rom = 1;
2137     } else {
2138         /* XXX is this always true ? */
2139         samples_are_from_rom = 0;
2140     }
2141 
2142     if (dev->israw || fx_raw) {
2143         if (wavefront_do_reset (dev)) {
2144             return -1;
2145         }
2146     }
2147     /* Check for FX device, present only on Tropez+ */
2148 
2149     dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2150 
2151     if (dev->has_fx && fx_raw) {
2152         snd_wavefront_fx_start (dev);
2153     }
2154 
2155     wavefront_get_sample_status (dev, samples_are_from_rom);
2156     wavefront_get_program_status (dev);
2157     wavefront_get_patch_status (dev);
2158 
2159     /* Start normal operation: unreset, master interrupt enabled, no mute
2160     */
2161 
2162     outb (0x80|0x40|0x20, dev->control_port); 
2163 
2164     return (0);
2165 }
2166 
2167 int
2168 snd_wavefront_detect (snd_wavefront_card_t *card)
2169 
2170 {
2171     unsigned char   rbuf[4], wbuf[4];
2172     snd_wavefront_t *dev = &card->wavefront;
2173     
2174     /* returns zero if a WaveFront card is successfully detected.
2175        negative otherwise.
2176     */
2177 
2178     dev->israw = 0;
2179     dev->has_fx = 0;
2180     dev->debug = debug_default;
2181     dev->interrupts_are_midi = 0;
2182     dev->irq_cnt = 0;
2183     dev->rom_samples_rdonly = 1;
2184 
2185     if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2186 
2187         dev->fw_version[0] = rbuf[0];
2188         dev->fw_version[1] = rbuf[1];
2189 
2190         snd_printk ("firmware %d.%d already loaded.\n",
2191                 rbuf[0], rbuf[1]);
2192 
2193         /* check that a command actually works */
2194       
2195         if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2196                        rbuf, wbuf) == 0) {
2197             dev->hw_version[0] = rbuf[0];
2198             dev->hw_version[1] = rbuf[1];
2199         } else {
2200             snd_printk ("not raw, but no "
2201                     "hardware version!\n");
2202             return -1;
2203         }
2204 
2205         if (!wf_raw) {
2206             return 0;
2207         } else {
2208             snd_printk ("reloading firmware as you requested.\n");
2209             dev->israw = 1;
2210         }
2211 
2212     } else {
2213 
2214         dev->israw = 1;
2215         snd_printk ("no response to firmware probe, assume raw.\n");
2216 
2217     }
2218 
2219     return 0;
2220 }
2221 
2222 MODULE_FIRMWARE(DEFAULT_OSPATH);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!