sound/isa/wavefront/wavefront

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
wavefront_errorstr
wavefront_get_command
wavefront_status
wavefront_sleep
wavefront_wait
wavefront_read
wavefront_write
snd_wavefront_cmd
munge_int32
demunge_int32
munge_buf
demunge_buf
wavefront_delete_sample
wavefront_get_sample_status
wavefront_get_patch_status
wavefront_get_program_status
wavefront_send_patch
wavefront_send_program
wavefront_freemem
wavefront_send_sample
wavefront_send_alias
wavefront_send_multisample
wavefront_fetch_multisample
wavefront_send_drum
wavefront_find_free_sample
wavefront_find_free_patch
wavefront_load_patch
process_sample_hdr
wavefront_synth_control
snd_wavefront_synth_open
snd_wavefront_synth_release
snd_wavefront_synth_ioctl
snd_wavefront_internal_interrupt
snd_wavefront_interrupt_bits
wavefront_should_cause_interrupt
wavefront_reset_to_cleanliness
wavefront_download_firmware
wavefront_do_reset
snd_wavefront_start
snd_wavefront_detect
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (C) by Paul Barton-Davis 1998-1999
   3  *
   4  * Some portions of this file are taken from work that is
   5  * copyright (C) by Hannu Savolainen 1993-1996
   6  */
   7 
   8 /*  
   9  * An ALSA lowlevel driver for Turtle Beach ICS2115 wavetable synth
  10  *                                             (Maui, Tropez, Tropez Plus)
  11  *
  12  * This driver supports the onboard wavetable synthesizer (an ICS2115),
  13  * including patch, sample and program loading and unloading, conversion
  14  * of GUS patches during loading, and full user-level access to all
  15  * WaveFront commands. It tries to provide semi-intelligent patch and
  16  * sample management as well.
  17  *
  18  */
  19 
  20 #include <linux/io.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/init.h>
  23 #include <linux/delay.h>
  24 #include <linux/time.h>
  25 #include <linux/wait.h>
  26 #include <linux/sched/signal.h>
  27 #include <linux/firmware.h>
  28 #include <linux/moduleparam.h>
  29 #include <linux/slab.h>
  30 #include <linux/module.h>
  31 #include <sound/core.h>
  32 #include <sound/snd_wavefront.h>
  33 #include <sound/initval.h>
  34 
  35 static int wf_raw = 0; /* we normally check for "raw state" to firmware
  36                           loading. if non-zero, then during driver loading, the
  37                           state of the board is ignored, and we reset the
  38                           board and load the firmware anyway.
  39                        */
  40                    
  41 static int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
  42                           whatever state it is when the driver is loaded.
  43                           The default is to download the microprogram and
  44                           associated coefficients to set it up for "default"
  45                           operation, whatever that means.
  46                        */
  47 
  48 static int debug_default = 0;  /* you can set this to control debugging
  49                                   during driver loading. it takes any combination
  50                                   of the WF_DEBUG_* flags defined in
  51                                   wavefront.h
  52                                */
  53 
  54 /* XXX this needs to be made firmware and hardware version dependent */
  55 
  56 #define DEFAULT_OSPATH  "wavefront.os"
  57 static char *ospath = DEFAULT_OSPATH; /* the firmware file name */
  58 
  59 static int wait_usecs = 150; /* This magic number seems to give pretty optimal
  60                                 throughput based on my limited experimentation.
  61                                 If you want to play around with it and find a better
  62                                 value, be my guest. Remember, the idea is to
  63                                 get a number that causes us to just busy wait
  64                                 for as many WaveFront commands as possible, without
  65                                 coming up with a number so large that we hog the
  66                                 whole CPU.
  67 
  68                                 Specifically, with this number, out of about 134,000
  69                                 status waits, only about 250 result in a sleep.
  70                             */
  71 
  72 static int sleep_interval = 100;   /* HZ/sleep_interval seconds per sleep */
  73 static int sleep_tries = 50;       /* number of times we'll try to sleep */
  74 
  75 static int reset_time = 2;        /* hundreths of a second we wait after a HW
  76                                      reset for the expected interrupt.
  77                                   */
  78 
  79 static int ramcheck_time = 20;    /* time in seconds to wait while ROM code
  80                                      checks on-board RAM.
  81                                   */
  82 
  83 static int osrun_time = 10;       /* time in seconds we wait for the OS to
  84                                      start running.
  85                                   */
  86 module_param(wf_raw, int, 0444);
  87 MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
  88 module_param(fx_raw, int, 0444);
  89 MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
  90 module_param(debug_default, int, 0444);
  91 MODULE_PARM_DESC(debug_default, "debug parameters for card initialization");
  92 module_param(wait_usecs, int, 0444);
  93 MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs");
  94 module_param(sleep_interval, int, 0444);
  95 MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply");
  96 module_param(sleep_tries, int, 0444);
  97 MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait");
  98 module_param(ospath, charp, 0444);
  99 MODULE_PARM_DESC(ospath, "pathname to processed ICS2115 OS firmware");
 100 module_param(reset_time, int, 0444);
 101 MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect");
 102 module_param(ramcheck_time, int, 0444);
 103 MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test");
 104 module_param(osrun_time, int, 0444);
 105 MODULE_PARM_DESC(osrun_time, "how many seconds to wait for the ICS2115 OS");
 106 
 107 /* if WF_DEBUG not defined, no run-time debugging messages will
 108    be available via the debug flag setting. Given the current
 109    beta state of the driver, this will remain set until a future 
 110    version.
 111 */
 112 
 113 #define WF_DEBUG 1
 114 
 115 #ifdef WF_DEBUG
 116 
 117 #define DPRINT(cond, ...) \
 118        if ((dev->debug & (cond)) == (cond)) { \
 119              snd_printk (__VA_ARGS__); \
 120        }
 121 #else
 122 #define DPRINT(cond, args...)
 123 #endif /* WF_DEBUG */
 124 
 125 #define LOGNAME "WaveFront: "
 126 
 127 /* bitmasks for WaveFront status port value */
 128 
 129 #define STAT_RINTR_ENABLED      0x01
 130 #define STAT_CAN_READ           0x02
 131 #define STAT_INTR_READ          0x04
 132 #define STAT_WINTR_ENABLED      0x10
 133 #define STAT_CAN_WRITE          0x20
 134 #define STAT_INTR_WRITE         0x40
 135 
 136 static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
 137 static int wavefront_find_free_sample (snd_wavefront_t *);
 138 
 139 struct wavefront_command {
 140         int cmd;
 141         char *action;
 142         unsigned int read_cnt;
 143         unsigned int write_cnt;
 144         int need_ack;
 145 };
 146 
 147 static struct {
 148         int errno;
 149         const char *errstr;
 150 } wavefront_errors[] = {
 151         { 0x01, "Bad sample number" },
 152         { 0x02, "Out of sample memory" },
 153         { 0x03, "Bad patch number" },
 154         { 0x04, "Error in number of voices" },
 155         { 0x06, "Sample load already in progress" },
 156         { 0x0B, "No sample load request pending" },
 157         { 0x0E, "Bad MIDI channel number" },
 158         { 0x10, "Download Record Error" },
 159         { 0x80, "Success" },
 160         { 0x0 }
 161 };
 162 
 163 #define NEEDS_ACK 1
 164 
 165 static struct wavefront_command wavefront_commands[] = {
 166         { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK },
 167         { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0},
 168         { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK },
 169         { WFC_GET_NVOICES, "get number of voices", 1, 0, 0 },
 170         { WFC_SET_TUNING, "set synthesizer tuning", 0, 2, NEEDS_ACK },
 171         { WFC_GET_TUNING, "get synthesizer tuning", 2, 0, 0 },
 172         { WFC_DISABLE_CHANNEL, "disable synth channel", 0, 1, NEEDS_ACK },
 173         { WFC_ENABLE_CHANNEL, "enable synth channel", 0, 1, NEEDS_ACK },
 174         { WFC_GET_CHANNEL_STATUS, "get synth channel status", 3, 0, 0 },
 175         { WFC_MISYNTH_OFF, "disable midi-in to synth", 0, 0, NEEDS_ACK },
 176         { WFC_MISYNTH_ON, "enable midi-in to synth", 0, 0, NEEDS_ACK },
 177         { WFC_VMIDI_ON, "enable virtual midi mode", 0, 0, NEEDS_ACK },
 178         { WFC_VMIDI_OFF, "disable virtual midi mode", 0, 0, NEEDS_ACK },
 179         { WFC_MIDI_STATUS, "report midi status", 1, 0, 0 },
 180         { WFC_FIRMWARE_VERSION, "report firmware version", 2, 0, 0 },
 181         { WFC_HARDWARE_VERSION, "report hardware version", 2, 0, 0 },
 182         { WFC_GET_NSAMPLES, "report number of samples", 2, 0, 0 },
 183         { WFC_INSTOUT_LEVELS, "report instantaneous output levels", 7, 0, 0 },
 184         { WFC_PEAKOUT_LEVELS, "report peak output levels", 7, 0, 0 },
 185         { WFC_DOWNLOAD_SAMPLE, "download sample",
 186           0, WF_SAMPLE_BYTES, NEEDS_ACK },
 187         { WFC_DOWNLOAD_BLOCK, "download block", 0, 0, NEEDS_ACK},
 188         { WFC_DOWNLOAD_SAMPLE_HEADER, "download sample header",
 189           0, WF_SAMPLE_HDR_BYTES, NEEDS_ACK },
 190         { WFC_UPLOAD_SAMPLE_HEADER, "upload sample header", 13, 2, 0 },
 191 
 192         /* This command requires a variable number of bytes to be written.
 193            There is a hack in snd_wavefront_cmd() to support this. The actual
 194            count is passed in as the read buffer ptr, cast appropriately.
 195            Ugh.
 196         */
 197 
 198         { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
 199 
 200         /* This one is a hack as well. We just read the first byte of the
 201            response, don't fetch an ACK, and leave the rest to the 
 202            calling function. Ugly, ugly, ugly.
 203         */
 204 
 205         { WFC_UPLOAD_MULTISAMPLE, "upload multisample", 2, 1, 0 },
 206         { WFC_DOWNLOAD_SAMPLE_ALIAS, "download sample alias",
 207           0, WF_ALIAS_BYTES, NEEDS_ACK },
 208         { WFC_UPLOAD_SAMPLE_ALIAS, "upload sample alias", WF_ALIAS_BYTES, 2, 0},
 209         { WFC_DELETE_SAMPLE, "delete sample", 0, 2, NEEDS_ACK },
 210         { WFC_IDENTIFY_SAMPLE_TYPE, "identify sample type", 5, 2, 0 },
 211         { WFC_UPLOAD_SAMPLE_PARAMS, "upload sample parameters" },
 212         { WFC_REPORT_FREE_MEMORY, "report free memory", 4, 0, 0 },
 213         { WFC_DOWNLOAD_PATCH, "download patch", 0, 134, NEEDS_ACK },
 214         { WFC_UPLOAD_PATCH, "upload patch", 132, 2, 0 },
 215         { WFC_DOWNLOAD_PROGRAM, "download program", 0, 33, NEEDS_ACK },
 216         { WFC_UPLOAD_PROGRAM, "upload program", 32, 1, 0 },
 217         { WFC_DOWNLOAD_EDRUM_PROGRAM, "download enhanced drum program", 0, 9,
 218           NEEDS_ACK},
 219         { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
 220         { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
 221           0, 1, NEEDS_ACK },
 222         { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
 223         { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
 224           32, 0, 0 },
 225         { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
 226         { 0x00 }
 227 };
 228 
 229 static const char *
 230 wavefront_errorstr (int errnum)
 231 
 232 {
 233         int i;
 234 
 235         for (i = 0; wavefront_errors[i].errstr; i++) {
 236                 if (wavefront_errors[i].errno == errnum) {
 237                         return wavefront_errors[i].errstr;
 238                 }
 239         }
 240 
 241         return "Unknown WaveFront error";
 242 }
 243 
 244 static struct wavefront_command *
 245 wavefront_get_command (int cmd) 
 246 
 247 {
 248         int i;
 249 
 250         for (i = 0; wavefront_commands[i].cmd != 0; i++) {
 251                 if (cmd == wavefront_commands[i].cmd) {
 252                         return &wavefront_commands[i];
 253                 }
 254         }
 255 
 256         return NULL;
 257 }
 258 
 259 static inline int
 260 wavefront_status (snd_wavefront_t *dev) 
 261 
 262 {
 263         return inb (dev->status_port);
 264 }
 265 
 266 static int
 267 wavefront_sleep (int limit)
 268 
 269 {
 270         schedule_timeout_interruptible(limit);
 271 
 272         return signal_pending(current);
 273 }
 274 
 275 static int
 276 wavefront_wait (snd_wavefront_t *dev, int mask)
 277 
 278 {
 279         int             i;
 280 
 281         /* Spin for a short period of time, because >99% of all
 282            requests to the WaveFront can be serviced inline like this.
 283         */
 284 
 285         for (i = 0; i < wait_usecs; i += 5) {
 286                 if (wavefront_status (dev) & mask) {
 287                         return 1;
 288                 }
 289                 udelay(5);
 290         }
 291 
 292         for (i = 0; i < sleep_tries; i++) {
 293 
 294                 if (wavefront_status (dev) & mask) {
 295                         return 1;
 296                 }
 297 
 298                 if (wavefront_sleep (HZ/sleep_interval)) {
 299                         return (0);
 300                 }
 301         }
 302 
 303         return (0);
 304 }
 305 
 306 static int
 307 wavefront_read (snd_wavefront_t *dev)
 308 
 309 {
 310         if (wavefront_wait (dev, STAT_CAN_READ))
 311                 return inb (dev->data_port);
 312 
 313         DPRINT (WF_DEBUG_DATA, "read timeout.\n");
 314 
 315         return -1;
 316 }
 317 
 318 static int
 319 wavefront_write (snd_wavefront_t *dev, unsigned char data)
 320 
 321 {
 322         if (wavefront_wait (dev, STAT_CAN_WRITE)) {
 323                 outb (data, dev->data_port);
 324                 return 0;
 325         }
 326 
 327         DPRINT (WF_DEBUG_DATA, "write timeout.\n");
 328 
 329         return -1;
 330 }
 331 
 332 int
 333 snd_wavefront_cmd (snd_wavefront_t *dev, 
 334                    int cmd, unsigned char *rbuf, unsigned char *wbuf)
 335 
 336 {
 337         int ack;
 338         unsigned int i;
 339         int c;
 340         struct wavefront_command *wfcmd;
 341 
 342         if ((wfcmd = wavefront_get_command (cmd)) == NULL) {
 343                 snd_printk ("command 0x%x not supported.\n",
 344                         cmd);
 345                 return 1;
 346         }
 347 
 348         /* Hack to handle the one variable-size write command. See
 349            wavefront_send_multisample() for the other half of this
 350            gross and ugly strategy.
 351         */
 352 
 353         if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
 354                 wfcmd->write_cnt = (unsigned long) rbuf;
 355                 rbuf = NULL;
 356         }
 357 
 358         DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
 359                                cmd, wfcmd->action, wfcmd->read_cnt,
 360                                wfcmd->write_cnt, wfcmd->need_ack);
 361     
 362         if (wavefront_write (dev, cmd)) { 
 363                 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
 364                                                      "0x%x [%s].\n",
 365                                                      cmd, wfcmd->action);
 366                 return 1;
 367         } 
 368 
 369         if (wfcmd->write_cnt > 0) {
 370                 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
 371                                         "for 0x%x\n",
 372                                         wfcmd->write_cnt, cmd);
 373 
 374                 for (i = 0; i < wfcmd->write_cnt; i++) {
 375                         if (wavefront_write (dev, wbuf[i])) {
 376                                 DPRINT (WF_DEBUG_IO, "bad write for byte "
 377                                                       "%d of 0x%x [%s].\n",
 378                                                       i, cmd, wfcmd->action);
 379                                 return 1;
 380                         }
 381 
 382                         DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
 383                                                 i, wbuf[i]);
 384                 }
 385         }
 386 
 387         if (wfcmd->read_cnt > 0) {
 388                 DPRINT (WF_DEBUG_DATA, "reading %d ints "
 389                                         "for 0x%x\n",
 390                                         wfcmd->read_cnt, cmd);
 391 
 392                 for (i = 0; i < wfcmd->read_cnt; i++) {
 393 
 394                         if ((c = wavefront_read (dev)) == -1) {
 395                                 DPRINT (WF_DEBUG_IO, "bad read for byte "
 396                                                       "%d of 0x%x [%s].\n",
 397                                                       i, cmd, wfcmd->action);
 398                                 return 1;
 399                         }
 400 
 401                         /* Now handle errors. Lots of special cases here */
 402             
 403                         if (c == 0xff) { 
 404                                 if ((c = wavefront_read (dev)) == -1) {
 405                                         DPRINT (WF_DEBUG_IO, "bad read for "
 406                                                               "error byte at "
 407                                                               "read byte %d "
 408                                                               "of 0x%x [%s].\n",
 409                                                               i, cmd,
 410                                                               wfcmd->action);
 411                                         return 1;
 412                                 }
 413 
 414                                 /* Can you believe this madness ? */
 415 
 416                                 if (c == 1 &&
 417                                     wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
 418                                         rbuf[0] = WF_ST_EMPTY;
 419                                         return (0);
 420 
 421                                 } else if (c == 3 &&
 422                                            wfcmd->cmd == WFC_UPLOAD_PATCH) {
 423 
 424                                         return 3;
 425 
 426                                 } else if (c == 1 &&
 427                                            wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
 428 
 429                                         return 1;
 430 
 431                                 } else {
 432 
 433                                         DPRINT (WF_DEBUG_IO, "error %d (%s) "
 434                                                               "during "
 435                                                               "read for byte "
 436                                                               "%d of 0x%x "
 437                                                               "[%s].\n",
 438                                                               c,
 439                                                               wavefront_errorstr (c),
 440                                                               i, cmd,
 441                                                               wfcmd->action);
 442                                         return 1;
 443 
 444                                 }
 445                 
 446                 } else {
 447                                 rbuf[i] = c;
 448                         }
 449                         
 450                         DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
 451                 }
 452         }
 453         
 454         if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
 455 
 456                 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
 457 
 458                 /* Some commands need an ACK, but return zero instead
 459                    of the standard value.
 460                 */
 461             
 462                 if ((ack = wavefront_read (dev)) == 0) {
 463                         ack = WF_ACK;
 464                 }
 465         
 466                 if (ack != WF_ACK) {
 467                         if (ack == -1) {
 468                                 DPRINT (WF_DEBUG_IO, "cannot read ack for "
 469                                                       "0x%x [%s].\n",
 470                                                       cmd, wfcmd->action);
 471                                 return 1;
 472                 
 473                         } else {
 474                                 int err = -1; /* something unknown */
 475 
 476                                 if (ack == 0xff) { /* explicit error */
 477                     
 478                                         if ((err = wavefront_read (dev)) == -1) {
 479                                                 DPRINT (WF_DEBUG_DATA,
 480                                                         "cannot read err "
 481                                                         "for 0x%x [%s].\n",
 482                                                         cmd, wfcmd->action);
 483                                         }
 484                                 }
 485                                 
 486                                 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
 487                                         "failed (0x%x, 0x%x, %s)\n",
 488                                         cmd, wfcmd->action, ack, err,
 489                                         wavefront_errorstr (err));
 490                                 
 491                                 return -err;
 492                         }
 493                 }
 494                 
 495                 DPRINT (WF_DEBUG_DATA, "ack received "
 496                                         "for 0x%x [%s]\n",
 497                                         cmd, wfcmd->action);
 498         } else {
 499 
 500                 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
 501                                        "ACK (%d,%d,%d)\n",
 502                                        cmd, wfcmd->action, wfcmd->read_cnt,
 503                                        wfcmd->write_cnt, wfcmd->need_ack);
 504         }
 505 
 506         return 0;
 507         
 508 }
 509 
 510 /***********************************************************************
 511 WaveFront data munging   
 512 
 513 Things here are weird. All data written to the board cannot 
 514 have its most significant bit set. Any data item with values 
 515 potentially > 0x7F (127) must be split across multiple bytes.
 516 
 517 Sometimes, we need to munge numeric values that are represented on
 518 the x86 side as 8-32 bit values. Sometimes, we need to munge data
 519 that is represented on the x86 side as an array of bytes. The most
 520 efficient approach to handling both cases seems to be to use 2
 521 different functions for munging and 2 for de-munging. This avoids
 522 weird casting and worrying about bit-level offsets.
 523 
 524 **********************************************************************/
 525 
 526 static unsigned char *
 527 munge_int32 (unsigned int src,
 528              unsigned char *dst,
 529              unsigned int dst_size)
 530 {
 531         unsigned int i;
 532 
 533         for (i = 0; i < dst_size; i++) {
 534                 *dst = src & 0x7F;  /* Mask high bit of LSB */
 535                 src = src >> 7;     /* Rotate Right 7 bits  */
 536                                     /* Note: we leave the upper bits in place */ 
 537 
 538                 dst++;
 539         }
 540         return dst;
 541 };
 542 
 543 static int 
 544 demunge_int32 (unsigned char* src, int src_size)
 545 
 546 {
 547         int i;
 548         int outval = 0;
 549         
 550         for (i = src_size - 1; i >= 0; i--) {
 551                 outval=(outval<<7)+src[i];
 552         }
 553 
 554         return outval;
 555 };
 556 
 557 static 
 558 unsigned char *
 559 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
 560 
 561 {
 562         unsigned int i;
 563         unsigned int last = dst_size / 2;
 564 
 565         for (i = 0; i < last; i++) {
 566                 *dst++ = src[i] & 0x7f;
 567                 *dst++ = src[i] >> 7;
 568         }
 569         return dst;
 570 }
 571 
 572 static 
 573 unsigned char *
 574 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
 575 
 576 {
 577         int i;
 578         unsigned char *end = src + src_bytes;
 579     
 580         end = src + src_bytes;
 581 
 582         /* NOTE: src and dst *CAN* point to the same address */
 583 
 584         for (i = 0; src != end; i++) {
 585                 dst[i] = *src++;
 586                 dst[i] |= (*src++)<<7;
 587         }
 588 
 589         return dst;
 590 }
 591 
 592 /***********************************************************************
 593 WaveFront: sample, patch and program management.
 594 ***********************************************************************/
 595 
 596 static int
 597 wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
 598 
 599 {
 600         unsigned char wbuf[2];
 601         int x;
 602 
 603         wbuf[0] = sample_num & 0x7f;
 604         wbuf[1] = sample_num >> 7;
 605 
 606         if ((x = snd_wavefront_cmd (dev, WFC_DELETE_SAMPLE, NULL, wbuf)) == 0) {
 607                 dev->sample_status[sample_num] = WF_ST_EMPTY;
 608         }
 609 
 610         return x;
 611 }
 612 
 613 static int
 614 wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
 615 
 616 {
 617         int i;
 618         unsigned char rbuf[32], wbuf[32];
 619         unsigned int    sc_real, sc_alias, sc_multi;
 620 
 621         /* check sample status */
 622     
 623         if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
 624                 snd_printk ("cannot request sample count.\n");
 625                 return -1;
 626         } 
 627     
 628         sc_real = sc_alias = sc_multi = dev->samples_used = 0;
 629     
 630         for (i = 0; i < WF_MAX_SAMPLE; i++) {
 631         
 632                 wbuf[0] = i & 0x7f;
 633                 wbuf[1] = i >> 7;
 634 
 635                 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
 636                         snd_printk(KERN_WARNING "cannot identify sample "
 637                                    "type of slot %d\n", i);
 638                         dev->sample_status[i] = WF_ST_EMPTY;
 639                         continue;
 640                 }
 641 
 642                 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
 643 
 644                 if (assume_rom) {
 645                         dev->sample_status[i] |= WF_SLOT_ROM;
 646                 }
 647 
 648                 switch (rbuf[0] & WF_ST_MASK) {
 649                 case WF_ST_SAMPLE:
 650                         sc_real++;
 651                         break;
 652                 case WF_ST_MULTISAMPLE:
 653                         sc_multi++;
 654                         break;
 655                 case WF_ST_ALIAS:
 656                         sc_alias++;
 657                         break;
 658                 case WF_ST_EMPTY:
 659                         break;
 660 
 661                 default:
 662                         snd_printk ("unknown sample type for "
 663                                     "slot %d (0x%x)\n", 
 664                                     i, rbuf[0]);
 665                 }
 666 
 667                 if (rbuf[0] != WF_ST_EMPTY) {
 668                         dev->samples_used++;
 669                 } 
 670         }
 671 
 672         snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
 673                     "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
 674                     WF_MAX_SAMPLE - dev->samples_used);
 675 
 676 
 677         return (0);
 678 
 679 }
 680 
 681 static int
 682 wavefront_get_patch_status (snd_wavefront_t *dev)
 683 
 684 {
 685         unsigned char patchbuf[WF_PATCH_BYTES];
 686         unsigned char patchnum[2];
 687         wavefront_patch *p;
 688         int i, x, cnt, cnt2;
 689 
 690         for (i = 0; i < WF_MAX_PATCH; i++) {
 691                 patchnum[0] = i & 0x7f;
 692                 patchnum[1] = i >> 7;
 693 
 694                 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PATCH, patchbuf,
 695                                         patchnum)) == 0) {
 696 
 697                         dev->patch_status[i] |= WF_SLOT_FILLED;
 698                         p = (wavefront_patch *) patchbuf;
 699                         dev->sample_status
 700                                 [p->sample_number|(p->sample_msb<<7)] |=
 701                                 WF_SLOT_USED;
 702             
 703                 } else if (x == 3) { /* Bad patch number */
 704                         dev->patch_status[i] = 0;
 705                 } else {
 706                         snd_printk ("upload patch "
 707                                     "error 0x%x\n", x);
 708                         dev->patch_status[i] = 0;
 709                         return 1;
 710                 }
 711         }
 712 
 713         /* program status has already filled in slot_used bits */
 714 
 715         for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
 716                 if (dev->patch_status[i] & WF_SLOT_FILLED) {
 717                         cnt++;
 718                 }
 719                 if (dev->patch_status[i] & WF_SLOT_USED) {
 720                         cnt2++;
 721                 }
 722         
 723         }
 724         snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
 725 
 726         return (0);
 727 }
 728 
 729 static int
 730 wavefront_get_program_status (snd_wavefront_t *dev)
 731 
 732 {
 733         unsigned char progbuf[WF_PROGRAM_BYTES];
 734         wavefront_program prog;
 735         unsigned char prognum;
 736         int i, x, l, cnt;
 737 
 738         for (i = 0; i < WF_MAX_PROGRAM; i++) {
 739                 prognum = i;
 740 
 741                 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PROGRAM, progbuf,
 742                                         &prognum)) == 0) {
 743 
 744                         dev->prog_status[i] |= WF_SLOT_USED;
 745 
 746                         demunge_buf (progbuf, (unsigned char *) &prog,
 747                                      WF_PROGRAM_BYTES);
 748 
 749                         for (l = 0; l < WF_NUM_LAYERS; l++) {
 750                                 if (prog.layer[l].mute) {
 751                                         dev->patch_status
 752                                                 [prog.layer[l].patch_number] |=
 753                                                 WF_SLOT_USED;
 754                                 }
 755                         }
 756                 } else if (x == 1) { /* Bad program number */
 757                         dev->prog_status[i] = 0;
 758                 } else {
 759                         snd_printk ("upload program "
 760                                     "error 0x%x\n", x);
 761                         dev->prog_status[i] = 0;
 762                 }
 763         }
 764 
 765         for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
 766                 if (dev->prog_status[i]) {
 767                         cnt++;
 768                 }
 769         }
 770 
 771         snd_printk ("%d programs slots in use\n", cnt);
 772 
 773         return (0);
 774 }
 775 
 776 static int
 777 wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
 778 
 779 {
 780         unsigned char buf[WF_PATCH_BYTES+2];
 781         unsigned char *bptr;
 782 
 783         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
 784                                       header->number);
 785 
 786         if (header->number >= ARRAY_SIZE(dev->patch_status))
 787                 return -EINVAL;
 788 
 789         dev->patch_status[header->number] |= WF_SLOT_FILLED;
 790 
 791         bptr = munge_int32 (header->number, buf, 2);
 792         munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
 793     
 794         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
 795                 snd_printk ("download patch failed\n");
 796                 return -EIO;
 797         }
 798 
 799         return (0);
 800 }
 801 
 802 static int
 803 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
 804 
 805 {
 806         unsigned char buf[WF_PROGRAM_BYTES+1];
 807         int i;
 808 
 809         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
 810                 header->number);
 811 
 812         if (header->number >= ARRAY_SIZE(dev->prog_status))
 813                 return -EINVAL;
 814 
 815         dev->prog_status[header->number] = WF_SLOT_USED;
 816 
 817         /* XXX need to zero existing SLOT_USED bit for program_status[i]
 818            where `i' is the program that's being (potentially) overwritten.
 819         */
 820     
 821         for (i = 0; i < WF_NUM_LAYERS; i++) {
 822                 if (header->hdr.pr.layer[i].mute) {
 823                         dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
 824                                 WF_SLOT_USED;
 825 
 826                         /* XXX need to mark SLOT_USED for sample used by
 827                            patch_number, but this means we have to load it. Ick.
 828                         */
 829                 }
 830         }
 831 
 832         buf[0] = header->number;
 833         munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
 834     
 835         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
 836                 snd_printk ("download patch failed\n"); 
 837                 return -EIO;
 838         }
 839 
 840         return (0);
 841 }
 842 
 843 static int
 844 wavefront_freemem (snd_wavefront_t *dev)
 845 
 846 {
 847         char rbuf[8];
 848 
 849         if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
 850                 snd_printk ("can't get memory stats.\n");
 851                 return -1;
 852         } else {
 853                 return demunge_int32 (rbuf, 4);
 854         }
 855 }
 856 
 857 static int
 858 wavefront_send_sample (snd_wavefront_t *dev, 
 859                        wavefront_patch_info *header,
 860                        u16 __user *dataptr,
 861                        int data_is_unsigned)
 862 
 863 {
 864         /* samples are downloaded via a 16-bit wide i/o port
 865            (you could think of it as 2 adjacent 8-bit wide ports
 866            but its less efficient that way). therefore, all
 867            the blocksizes and so forth listed in the documentation,
 868            and used conventionally to refer to sample sizes,
 869            which are given in 8-bit units (bytes), need to be
 870            divided by 2.
 871         */
 872 
 873         u16 sample_short = 0;
 874         u32 length;
 875         u16 __user *data_end = NULL;
 876         unsigned int i;
 877         const unsigned int max_blksize = 4096/2;
 878         unsigned int written;
 879         unsigned int blocksize;
 880         int dma_ack;
 881         int blocknum;
 882         unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
 883         unsigned char *shptr;
 884         int skip = 0;
 885         int initial_skip = 0;
 886 
 887         DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
 888                                       "type %d, %d bytes from 0x%lx\n",
 889                                       header->size ? "" : "header ", 
 890                                       header->number, header->subkey,
 891                                       header->size,
 892                                       (unsigned long) header->dataptr);
 893 
 894         if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
 895                 int x;
 896 
 897                 if ((x = wavefront_find_free_sample (dev)) < 0) {
 898                         return -ENOMEM;
 899                 }
 900                 snd_printk ("unspecified sample => %d\n", x);
 901                 header->number = x;
 902         }
 903 
 904         if (header->number >= WF_MAX_SAMPLE)
 905                 return -EINVAL;
 906 
 907         if (header->size) {
 908 
 909                 /* XXX it's a debatable point whether or not RDONLY semantics
 910                    on the ROM samples should cover just the sample data or
 911                    the sample header. For now, it only covers the sample data,
 912                    so anyone is free at all times to rewrite sample headers.
 913 
 914                    My reason for this is that we have the sample headers
 915                    available in the WFB file for General MIDI, and so these
 916                    can always be reset if needed. The sample data, however,
 917                    cannot be recovered without a complete reset and firmware
 918                    reload of the ICS2115, which is a very expensive operation.
 919 
 920                    So, doing things this way allows us to honor the notion of
 921                    "RESETSAMPLES" reasonably cheaply. Note however, that this
 922                    is done purely at user level: there is no WFB parser in
 923                    this driver, and so a complete reset (back to General MIDI,
 924                    or theoretically some other configuration) is the
 925                    responsibility of the user level library. 
 926 
 927                    To try to do this in the kernel would be a little
 928                    crazy: we'd need 158K of kernel space just to hold
 929                    a copy of the patch/program/sample header data.
 930                 */
 931 
 932                 if (dev->rom_samples_rdonly) {
 933                         if (dev->sample_status[header->number] & WF_SLOT_ROM) {
 934                                 snd_printk ("sample slot %d "
 935                                             "write protected\n",
 936                                             header->number);
 937                                 return -EACCES;
 938                         }
 939                 }
 940 
 941                 wavefront_delete_sample (dev, header->number);
 942         }
 943 
 944         if (header->size) {
 945                 dev->freemem = wavefront_freemem (dev);
 946 
 947                 if (dev->freemem < (int)header->size) {
 948                         snd_printk ("insufficient memory to "
 949                                     "load %d byte sample.\n",
 950                                     header->size);
 951                         return -ENOMEM;
 952                 }
 953         
 954         }
 955 
 956         skip = WF_GET_CHANNEL(&header->hdr.s);
 957 
 958         if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
 959                 snd_printk ("channel selection only "
 960                             "possible on 16-bit samples");
 961                 return -EINVAL;
 962         }
 963 
 964         switch (skip) {
 965         case 0:
 966                 initial_skip = 0;
 967                 skip = 1;
 968                 break;
 969         case 1:
 970                 initial_skip = 0;
 971                 skip = 2;
 972                 break;
 973         case 2:
 974                 initial_skip = 1;
 975                 skip = 2;
 976                 break;
 977         case 3:
 978                 initial_skip = 2;
 979                 skip = 3;
 980                 break;
 981         case 4:
 982                 initial_skip = 3;
 983                 skip = 4;
 984                 break;
 985         case 5:
 986                 initial_skip = 4;
 987                 skip = 5;
 988                 break;
 989         case 6:
 990                 initial_skip = 5;
 991                 skip = 6;
 992                 break;
 993         }
 994 
 995         DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
 996                                       "initial skip = %d, skip = %d\n",
 997                                       WF_GET_CHANNEL (&header->hdr.s),
 998                                       initial_skip, skip);
 999     
1000         /* Be safe, and zero the "Unused" bits ... */
1001 
1002         WF_SET_CHANNEL(&header->hdr.s, 0);
1003 
1004         /* adjust size for 16 bit samples by dividing by two.  We always
1005            send 16 bits per write, even for 8 bit samples, so the length
1006            is always half the size of the sample data in bytes.
1007         */
1008 
1009         length = header->size / 2;
1010 
1011         /* the data we're sent has not been munged, and in fact, the
1012            header we have to send isn't just a munged copy either.
1013            so, build the sample header right here.
1014         */
1015 
1016         shptr = &sample_hdr[0];
1017 
1018         shptr = munge_int32 (header->number, shptr, 2);
1019 
1020         if (header->size) {
1021                 shptr = munge_int32 (length, shptr, 4);
1022         }
1023 
1024         /* Yes, a 4 byte result doesn't contain all of the offset bits,
1025            but the offset only uses 24 bits.
1026         */
1027 
1028         shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1029                              shptr, 4);
1030         shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1031                              shptr, 4);
1032         shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1033                              shptr, 4);
1034         shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1035                              shptr, 4);
1036         
1037         /* This one is truly weird. What kind of weirdo decided that in
1038            a system dominated by 16 and 32 bit integers, they would use
1039            a just 12 bits ?
1040         */
1041         
1042         shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1043         
1044         /* Why is this nybblified, when the MSB is *always* zero ? 
1045            Anyway, we can't take address of bitfield, so make a
1046            good-faith guess at where it starts.
1047         */
1048         
1049         shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1050                              shptr, 2);
1051 
1052         if (snd_wavefront_cmd (dev, 
1053                            header->size ?
1054                            WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1055                            NULL, sample_hdr)) {
1056                 snd_printk ("sample %sdownload refused.\n",
1057                             header->size ? "" : "header ");
1058                 return -EIO;
1059         }
1060 
1061         if (header->size == 0) {
1062                 goto sent; /* Sorry. Just had to have one somewhere */
1063         }
1064     
1065         data_end = dataptr + length;
1066 
1067         /* Do any initial skip over an unused channel's data */
1068 
1069         dataptr += initial_skip;
1070     
1071         for (written = 0, blocknum = 0;
1072              written < length; written += max_blksize, blocknum++) {
1073         
1074                 if ((length - written) > max_blksize) {
1075                         blocksize = max_blksize;
1076                 } else {
1077                         /* round to nearest 16-byte value */
1078                         blocksize = ALIGN(length - written, 8);
1079                 }
1080 
1081                 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1082                         snd_printk ("download block "
1083                                     "request refused.\n");
1084                         return -EIO;
1085                 }
1086 
1087                 for (i = 0; i < blocksize; i++) {
1088 
1089                         if (dataptr < data_end) {
1090                 
1091                                 __get_user (sample_short, dataptr);
1092                                 dataptr += skip;
1093                 
1094                                 if (data_is_unsigned) { /* GUS ? */
1095 
1096                                         if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1097                         
1098                                                 /* 8 bit sample
1099                                                  resolution, sign
1100                                                  extend both bytes.
1101                                                 */
1102                         
1103                                                 ((unsigned char*)
1104                                                  &sample_short)[0] += 0x7f;
1105                                                 ((unsigned char*)
1106                                                  &sample_short)[1] += 0x7f;
1107                         
1108                                         } else {
1109                         
1110                                                 /* 16 bit sample
1111                                                  resolution, sign
1112                                                  extend the MSB.
1113                                                 */
1114                         
1115                                                 sample_short += 0x7fff;
1116                                         }
1117                                 }
1118 
1119                         } else {
1120 
1121                                 /* In padding section of final block:
1122 
1123                                    Don't fetch unsupplied data from
1124                                    user space, just continue with
1125                                    whatever the final value was.
1126                                 */
1127                         }
1128             
1129                         if (i < blocksize - 1) {
1130                                 outw (sample_short, dev->block_port);
1131                         } else {
1132                                 outw (sample_short, dev->last_block_port);
1133                         }
1134                 }
1135 
1136                 /* Get "DMA page acknowledge", even though its really
1137                    nothing to do with DMA at all.
1138                 */
1139         
1140                 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1141                         if (dma_ack == -1) {
1142                                 snd_printk ("upload sample "
1143                                             "DMA ack timeout\n");
1144                                 return -EIO;
1145                         } else {
1146                                 snd_printk ("upload sample "
1147                                             "DMA ack error 0x%x\n",
1148                                             dma_ack);
1149                                 return -EIO;
1150                         }
1151                 }
1152         }
1153 
1154         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1155 
1156         /* Note, label is here because sending the sample header shouldn't
1157            alter the sample_status info at all.
1158         */
1159 
1160  sent:
1161         return (0);
1162 }
1163 
1164 static int
1165 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1166 
1167 {
1168         unsigned char alias_hdr[WF_ALIAS_BYTES];
1169 
1170         DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1171                                       "alias for %d\n",
1172                                       header->number,
1173                                       header->hdr.a.OriginalSample);
1174     
1175         munge_int32 (header->number, &alias_hdr[0], 2);
1176         munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1177         munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1178                      &alias_hdr[4], 4);
1179         munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1180                      &alias_hdr[8], 4);
1181         munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1182                      &alias_hdr[12], 4);
1183         munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1184                      &alias_hdr[16], 4);
1185         munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1186         munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1187 
1188         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1189                 snd_printk ("download alias failed.\n");
1190                 return -EIO;
1191         }
1192 
1193         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1194 
1195         return (0);
1196 }
1197 
1198 static int
1199 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1200 {
1201         int i;
1202         int num_samples;
1203         unsigned char *msample_hdr;
1204 
1205         msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1206         if (! msample_hdr)
1207                 return -ENOMEM;
1208 
1209         munge_int32 (header->number, &msample_hdr[0], 2);
1210 
1211         /* You'll recall at this point that the "number of samples" value
1212            in a wavefront_multisample struct is actually the log2 of the
1213            real number of samples.
1214         */
1215 
1216         num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1217         msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1218 
1219         DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1220                                       header->number,
1221                                       header->hdr.ms.NumberOfSamples,
1222                                       num_samples);
1223 
1224         for (i = 0; i < num_samples; i++) {
1225                 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1226                        i, header->hdr.ms.SampleNumber[i]);
1227                 munge_int32 (header->hdr.ms.SampleNumber[i],
1228                      &msample_hdr[3+(i*2)], 2);
1229         }
1230     
1231         /* Need a hack here to pass in the number of bytes
1232            to be written to the synth. This is ugly, and perhaps
1233            one day, I'll fix it.
1234         */
1235 
1236         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE, 
1237                            (unsigned char *) (long) ((num_samples*2)+3),
1238                            msample_hdr)) {
1239                 snd_printk ("download of multisample failed.\n");
1240                 kfree(msample_hdr);
1241                 return -EIO;
1242         }
1243 
1244         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1245 
1246         kfree(msample_hdr);
1247         return (0);
1248 }
1249 
1250 static int
1251 wavefront_fetch_multisample (snd_wavefront_t *dev, 
1252                              wavefront_patch_info *header)
1253 {
1254         int i;
1255         unsigned char log_ns[1];
1256         unsigned char number[2];
1257         int num_samples;
1258 
1259         munge_int32 (header->number, number, 2);
1260     
1261         if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1262                 snd_printk ("upload multisample failed.\n");
1263                 return -EIO;
1264         }
1265     
1266         DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1267                                 header->number, log_ns[0]);
1268 
1269         header->hdr.ms.NumberOfSamples = log_ns[0];
1270 
1271         /* get the number of samples ... */
1272 
1273         num_samples = (1 << log_ns[0]);
1274     
1275         for (i = 0; i < num_samples; i++) {
1276                 char d[2];
1277                 int val;
1278         
1279                 if ((val = wavefront_read (dev)) == -1) {
1280                         snd_printk ("upload multisample failed "
1281                                     "during sample loop.\n");
1282                         return -EIO;
1283                 }
1284                 d[0] = val;
1285 
1286                 if ((val = wavefront_read (dev)) == -1) {
1287                         snd_printk ("upload multisample failed "
1288                                     "during sample loop.\n");
1289                         return -EIO;
1290                 }
1291                 d[1] = val;
1292         
1293                 header->hdr.ms.SampleNumber[i] =
1294                         demunge_int32 ((unsigned char *) d, 2);
1295         
1296                 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1297                                         i, header->hdr.ms.SampleNumber[i]);
1298         }
1299 
1300         return (0);
1301 }
1302 
1303 
1304 static int
1305 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1306 
1307 {
1308         unsigned char drumbuf[WF_DRUM_BYTES];
1309         wavefront_drum *drum = &header->hdr.d;
1310         int i;
1311 
1312         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1313                 "note %d, patch = %d\n", 
1314                 header->number, drum->PatchNumber);
1315 
1316         drumbuf[0] = header->number & 0x7f;
1317 
1318         for (i = 0; i < 4; i++) {
1319                 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1320         }
1321 
1322         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1323                 snd_printk ("download drum failed.\n");
1324                 return -EIO;
1325         }
1326 
1327         return (0);
1328 }
1329 
1330 static int 
1331 wavefront_find_free_sample (snd_wavefront_t *dev)
1332 
1333 {
1334         int i;
1335 
1336         for (i = 0; i < WF_MAX_SAMPLE; i++) {
1337                 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1338                         return i;
1339                 }
1340         }
1341         snd_printk ("no free sample slots!\n");
1342         return -1;
1343 }
1344 
1345 #if 0
1346 static int 
1347 wavefront_find_free_patch (snd_wavefront_t *dev)
1348 
1349 {
1350         int i;
1351 
1352         for (i = 0; i < WF_MAX_PATCH; i++) {
1353                 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1354                         return i;
1355                 }
1356         }
1357         snd_printk ("no free patch slots!\n");
1358         return -1;
1359 }
1360 #endif
1361 
1362 static int
1363 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1364 {
1365         wavefront_patch_info *header;
1366         int err;
1367         
1368         header = kmalloc(sizeof(*header), GFP_KERNEL);
1369         if (! header)
1370                 return -ENOMEM;
1371 
1372         if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1373                             sizeof(wavefront_any))) {
1374                 snd_printk ("bad address for load patch.\n");
1375                 err = -EFAULT;
1376                 goto __error;
1377         }
1378 
1379         DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1380                                       "Sample type: %d "
1381                                       "Sample number: %d "
1382                                       "Sample size: %d\n",
1383                                       header->subkey,
1384                                       header->number,
1385                                       header->size);
1386 
1387         switch (header->subkey) {
1388         case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */
1389 
1390                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1391                                     sizeof (wavefront_sample))) {
1392                         err = -EFAULT;
1393                         break;
1394                 }
1395 
1396                 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1397                 break;
1398 
1399         case WF_ST_MULTISAMPLE:
1400 
1401                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1402                                     sizeof (wavefront_multisample))) {
1403                         err = -EFAULT;
1404                         break;
1405                 }
1406 
1407                 err = wavefront_send_multisample (dev, header);
1408                 break;
1409 
1410         case WF_ST_ALIAS:
1411 
1412                 if (copy_from_user (&header->hdr.a, header->hdrptr,
1413                                     sizeof (wavefront_alias))) {
1414                         err = -EFAULT;
1415                         break;
1416                 }
1417 
1418                 err = wavefront_send_alias (dev, header);
1419                 break;
1420 
1421         case WF_ST_DRUM:
1422                 if (copy_from_user (&header->hdr.d, header->hdrptr,
1423                                     sizeof (wavefront_drum))) {
1424                         err = -EFAULT;
1425                         break;
1426                 }
1427 
1428                 err = wavefront_send_drum (dev, header);
1429                 break;
1430 
1431         case WF_ST_PATCH:
1432                 if (copy_from_user (&header->hdr.p, header->hdrptr,
1433                                     sizeof (wavefront_patch))) {
1434                         err = -EFAULT;
1435                         break;
1436                 }
1437                 
1438                 err = wavefront_send_patch (dev, header);
1439                 break;
1440 
1441         case WF_ST_PROGRAM:
1442                 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1443                                     sizeof (wavefront_program))) {
1444                         err = -EFAULT;
1445                         break;
1446                 }
1447 
1448                 err = wavefront_send_program (dev, header);
1449                 break;
1450 
1451         default:
1452                 snd_printk ("unknown patch type %d.\n",
1453                             header->subkey);
1454                 err = -EINVAL;
1455                 break;
1456         }
1457 
1458  __error:
1459         kfree(header);
1460         return err;
1461 }
1462 
1463 /***********************************************************************
1464 WaveFront: hardware-dependent interface
1465 ***********************************************************************/
1466 
1467 static void
1468 process_sample_hdr (u8 *buf)
1469 
1470 {
1471         wavefront_sample s;
1472         u8 *ptr;
1473 
1474         ptr = buf;
1475 
1476         /* The board doesn't send us an exact copy of a "wavefront_sample"
1477            in response to an Upload Sample Header command. Instead, we 
1478            have to convert the data format back into our data structure,
1479            just as in the Download Sample command, where we have to do
1480            something very similar in the reverse direction.
1481         */
1482 
1483         *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1484         *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1485         *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1486         *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1487         *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1488 
1489         s.SampleResolution = *ptr & 0x3;
1490         s.Loop = *ptr & 0x8;
1491         s.Bidirectional = *ptr & 0x10;
1492         s.Reverse = *ptr & 0x40;
1493 
1494         /* Now copy it back to where it came from */
1495 
1496         memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1497 }
1498 
1499 static int
1500 wavefront_synth_control (snd_wavefront_card_t *acard, 
1501                          wavefront_control *wc)
1502 
1503 {
1504         snd_wavefront_t *dev = &acard->wavefront;
1505         unsigned char patchnumbuf[2];
1506         int i;
1507 
1508         DPRINT (WF_DEBUG_CMD, "synth control with "
1509                 "cmd 0x%x\n", wc->cmd);
1510 
1511         /* Pre-handling of or for various commands */
1512 
1513         switch (wc->cmd) {
1514                 
1515         case WFC_DISABLE_INTERRUPTS:
1516                 snd_printk ("interrupts disabled.\n");
1517                 outb (0x80|0x20, dev->control_port);
1518                 dev->interrupts_are_midi = 1;
1519                 return 0;
1520 
1521         case WFC_ENABLE_INTERRUPTS:
1522                 snd_printk ("interrupts enabled.\n");
1523                 outb (0x80|0x40|0x20, dev->control_port);
1524                 dev->interrupts_are_midi = 1;
1525                 return 0;
1526 
1527         case WFC_INTERRUPT_STATUS:
1528                 wc->rbuf[0] = dev->interrupts_are_midi;
1529                 return 0;
1530 
1531         case WFC_ROMSAMPLES_RDONLY:
1532                 dev->rom_samples_rdonly = wc->wbuf[0];
1533                 wc->status = 0;
1534                 return 0;
1535 
1536         case WFC_IDENTIFY_SLOT_TYPE:
1537                 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1538                 if (i <0 || i >= WF_MAX_SAMPLE) {
1539                         snd_printk ("invalid slot ID %d\n",
1540                                 i);
1541                         wc->status = EINVAL;
1542                         return -EINVAL;
1543                 }
1544                 wc->rbuf[0] = dev->sample_status[i];
1545                 wc->status = 0;
1546                 return 0;
1547 
1548         case WFC_DEBUG_DRIVER:
1549                 dev->debug = wc->wbuf[0];
1550                 snd_printk ("debug = 0x%x\n", dev->debug);
1551                 return 0;
1552 
1553         case WFC_UPLOAD_PATCH:
1554                 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1555                 memcpy (wc->wbuf, patchnumbuf, 2);
1556                 break;
1557 
1558         case WFC_UPLOAD_MULTISAMPLE:
1559                 /* multisamples have to be handled differently, and
1560                    cannot be dealt with properly by snd_wavefront_cmd() alone.
1561                 */
1562                 wc->status = wavefront_fetch_multisample
1563                         (dev, (wavefront_patch_info *) wc->rbuf);
1564                 return 0;
1565 
1566         case WFC_UPLOAD_SAMPLE_ALIAS:
1567                 snd_printk ("support for sample alias upload "
1568                         "being considered.\n");
1569                 wc->status = EINVAL;
1570                 return -EINVAL;
1571         }
1572 
1573         wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1574 
1575         /* Post-handling of certain commands.
1576 
1577            In particular, if the command was an upload, demunge the data
1578            so that the user-level doesn't have to think about it.
1579         */
1580 
1581         if (wc->status == 0) {
1582                 switch (wc->cmd) {
1583                         /* intercept any freemem requests so that we know
1584                            we are always current with the user-level view
1585                            of things.
1586                         */
1587 
1588                 case WFC_REPORT_FREE_MEMORY:
1589                         dev->freemem = demunge_int32 (wc->rbuf, 4);
1590                         break;
1591 
1592                 case WFC_UPLOAD_PATCH:
1593                         demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1594                         break;
1595 
1596                 case WFC_UPLOAD_PROGRAM:
1597                         demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1598                         break;
1599 
1600                 case WFC_UPLOAD_EDRUM_PROGRAM:
1601                         demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1602                         break;
1603 
1604                 case WFC_UPLOAD_SAMPLE_HEADER:
1605                         process_sample_hdr (wc->rbuf);
1606                         break;
1607 
1608                 case WFC_UPLOAD_SAMPLE_ALIAS:
1609                         snd_printk ("support for "
1610                                     "sample aliases still "
1611                                     "being considered.\n");
1612                         break;
1613 
1614                 case WFC_VMIDI_OFF:
1615                         snd_wavefront_midi_disable_virtual (acard);
1616                         break;
1617 
1618                 case WFC_VMIDI_ON:
1619                         snd_wavefront_midi_enable_virtual (acard);
1620                         break;
1621                 }
1622         }
1623 
1624         return 0;
1625 }
1626 
1627 int 
1628 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1629 
1630 {
1631         if (!try_module_get(hw->card->module))
1632                 return -EFAULT;
1633         file->private_data = hw;
1634         return 0;
1635 }
1636 
1637 int 
1638 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1639 
1640 {
1641         module_put(hw->card->module);
1642         return 0;
1643 }
1644 
1645 int
1646 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1647                            unsigned int cmd, unsigned long arg)
1648 
1649 {
1650         struct snd_card *card;
1651         snd_wavefront_t *dev;
1652         snd_wavefront_card_t *acard;
1653         wavefront_control *wc;
1654         void __user *argp = (void __user *)arg;
1655         int err;
1656 
1657         card = (struct snd_card *) hw->card;
1658 
1659         if (snd_BUG_ON(!card))
1660                 return -ENODEV;
1661         if (snd_BUG_ON(!card->private_data))
1662                 return -ENODEV;
1663 
1664         acard = card->private_data;
1665         dev = &acard->wavefront;
1666         
1667         switch (cmd) {
1668         case WFCTL_LOAD_SPP:
1669                 if (wavefront_load_patch (dev, argp) != 0) {
1670                         return -EIO;
1671                 }
1672                 break;
1673 
1674         case WFCTL_WFCMD:
1675                 wc = memdup_user(argp, sizeof(*wc));
1676                 if (IS_ERR(wc))
1677                         return PTR_ERR(wc);
1678 
1679                 if (wavefront_synth_control (acard, wc) < 0)
1680                         err = -EIO;
1681                 else if (copy_to_user (argp, wc, sizeof (*wc)))
1682                         err = -EFAULT;
1683                 else
1684                         err = 0;
1685                 kfree(wc);
1686                 return err;
1687 
1688         default:
1689                 return -EINVAL;
1690         }
1691 
1692         return 0;
1693 }
1694 
1695 
1696 /***********************************************************************/
1697 /*  WaveFront: interface for card-level wavefront module               */
1698 /***********************************************************************/
1699 
1700 void
1701 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1702 {
1703         snd_wavefront_t *dev = &card->wavefront;
1704 
1705         /*
1706            Some comments on interrupts. I attempted a version of this
1707            driver that used interrupts throughout the code instead of
1708            doing busy and/or sleep-waiting. Alas, it appears that once
1709            the Motorola firmware is downloaded, the card *never*
1710            generates an RX interrupt. These are successfully generated
1711            during firmware loading, and after that wavefront_status()
1712            reports that an interrupt is pending on the card from time
1713            to time, but it never seems to be delivered to this
1714            driver. Note also that wavefront_status() continues to
1715            report that RX interrupts are enabled, suggesting that I
1716            didn't goof up and disable them by mistake.
1717 
1718            Thus, I stepped back to a prior version of
1719            wavefront_wait(), the only place where this really
1720            matters. Its sad, but I've looked through the code to check
1721            on things, and I really feel certain that the Motorola
1722            firmware prevents RX-ready interrupts.
1723         */
1724 
1725         if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1726                 return;
1727         }
1728 
1729         spin_lock(&dev->irq_lock);
1730         dev->irq_ok = 1;
1731         dev->irq_cnt++;
1732         spin_unlock(&dev->irq_lock);
1733         wake_up(&dev->interrupt_sleeper);
1734 }
1735 
1736 /* STATUS REGISTER 
1737 
1738 0 Host Rx Interrupt Enable (1=Enabled)
1739 1 Host Rx Register Full (1=Full)
1740 2 Host Rx Interrupt Pending (1=Interrupt)
1741 3 Unused
1742 4 Host Tx Interrupt (1=Enabled)
1743 5 Host Tx Register empty (1=Empty)
1744 6 Host Tx Interrupt Pending (1=Interrupt)
1745 7 Unused
1746 */
1747 
1748 static int
1749 snd_wavefront_interrupt_bits (int irq)
1750 
1751 {
1752         int bits;
1753 
1754         switch (irq) {
1755         case 9:
1756                 bits = 0x00;
1757                 break;
1758         case 5:
1759                 bits = 0x08;
1760                 break;
1761         case 12:
1762                 bits = 0x10;
1763                 break;
1764         case 15:
1765                 bits = 0x18;
1766                 break;
1767         
1768         default:
1769                 snd_printk ("invalid IRQ %d\n", irq);
1770                 bits = -1;
1771         }
1772 
1773         return bits;
1774 }
1775 
1776 static void
1777 wavefront_should_cause_interrupt (snd_wavefront_t *dev, 
1778                                   int val, int port, unsigned long timeout)
1779 
1780 {
1781         wait_queue_entry_t wait;
1782 
1783         init_waitqueue_entry(&wait, current);
1784         spin_lock_irq(&dev->irq_lock);
1785         add_wait_queue(&dev->interrupt_sleeper, &wait);
1786         dev->irq_ok = 0;
1787         outb (val,port);
1788         spin_unlock_irq(&dev->irq_lock);
1789         while (!dev->irq_ok && time_before(jiffies, timeout)) {
1790                 schedule_timeout_uninterruptible(1);
1791                 barrier();
1792         }
1793 }
1794 
1795 static int
1796 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1797 
1798 {
1799         int bits;
1800         int hwv[2];
1801 
1802         /* IRQ already checked */
1803 
1804         bits = snd_wavefront_interrupt_bits (dev->irq);
1805 
1806         /* try reset of port */
1807 
1808         outb (0x0, dev->control_port); 
1809   
1810         /* At this point, the board is in reset, and the H/W initialization
1811            register is accessed at the same address as the data port.
1812      
1813            Bit 7 - Enable IRQ Driver    
1814            0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1815            1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1816      
1817            Bit 6 - MIDI Interface Select
1818 
1819            0 - Use the MIDI Input from the 26-pin WaveBlaster
1820            compatible header as the serial MIDI source
1821            1 - Use the MIDI Input from the 9-pin D connector as the
1822            serial MIDI source.
1823      
1824            Bits 5:3 - IRQ Selection
1825            0 0 0 - IRQ 2/9
1826            0 0 1 - IRQ 5
1827            0 1 0 - IRQ 12
1828            0 1 1 - IRQ 15
1829            1 0 0 - Reserved
1830            1 0 1 - Reserved
1831            1 1 0 - Reserved
1832            1 1 1 - Reserved
1833      
1834            Bits 2:1 - Reserved
1835            Bit 0 - Disable Boot ROM
1836            0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1837            1 - memory accesses to 03FC30-03FFFFH are directed to external 
1838            storage.
1839      
1840         */
1841 
1842         /* configure hardware: IRQ, enable interrupts, 
1843            plus external 9-pin MIDI interface selected
1844         */
1845 
1846         outb (0x80 | 0x40 | bits, dev->data_port);      
1847   
1848         /* CONTROL REGISTER
1849 
1850            0 Host Rx Interrupt Enable (1=Enabled)      0x1
1851            1 Unused                                    0x2
1852            2 Unused                                    0x4
1853            3 Unused                                    0x8
1854            4 Host Tx Interrupt Enable                 0x10
1855            5 Mute (0=Mute; 1=Play)                    0x20
1856            6 Master Interrupt Enable (1=Enabled)      0x40
1857            7 Master Reset (0=Reset; 1=Run)            0x80
1858 
1859            Take us out of reset, mute output, master + TX + RX interrupts on.
1860            
1861            We'll get an interrupt presumably to tell us that the TX
1862            register is clear.
1863         */
1864 
1865         wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1866                                          dev->control_port,
1867                                          (reset_time*HZ)/100);
1868 
1869         /* Note: data port is now the data port, not the h/w initialization
1870            port.
1871          */
1872 
1873         if (!dev->irq_ok) {
1874                 snd_printk ("intr not received after h/w un-reset.\n");
1875                 goto gone_bad;
1876         } 
1877 
1878         /* Note: data port is now the data port, not the h/w initialization
1879            port.
1880 
1881            At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1882            will work. So, issue one of them, and wait for TX
1883            interrupt. This can take a *long* time after a cold boot,
1884            while the ISC ROM does its RAM test. The SDK says up to 4
1885            seconds - with 12MB of RAM on a Tropez+, it takes a lot
1886            longer than that (~16secs). Note that the card understands
1887            the difference between a warm and a cold boot, so
1888            subsequent ISC2115 reboots (say, caused by module
1889            reloading) will get through this much faster.
1890 
1891            XXX Interesting question: why is no RX interrupt received first ?
1892         */
1893 
1894         wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION, 
1895                                          dev->data_port, ramcheck_time*HZ);
1896 
1897         if (!dev->irq_ok) {
1898                 snd_printk ("post-RAM-check interrupt not received.\n");
1899                 goto gone_bad;
1900         } 
1901 
1902         if (!wavefront_wait (dev, STAT_CAN_READ)) {
1903                 snd_printk ("no response to HW version cmd.\n");
1904                 goto gone_bad;
1905         }
1906         
1907         if ((hwv[0] = wavefront_read (dev)) == -1) {
1908                 snd_printk ("board not responding correctly.\n");
1909                 goto gone_bad;
1910         }
1911 
1912         if (hwv[0] == 0xFF) { /* NAK */
1913 
1914                 /* Board's RAM test failed. Try to read error code,
1915                    and tell us about it either way.
1916                 */
1917                 
1918                 if ((hwv[0] = wavefront_read (dev)) == -1) {
1919                         snd_printk ("on-board RAM test failed "
1920                                     "(bad error code).\n");
1921                 } else {
1922                         snd_printk ("on-board RAM test failed "
1923                                     "(error code: 0x%x).\n",
1924                                 hwv[0]);
1925                 }
1926                 goto gone_bad;
1927         }
1928 
1929         /* We're OK, just get the next byte of the HW version response */
1930 
1931         if ((hwv[1] = wavefront_read (dev)) == -1) {
1932                 snd_printk ("incorrect h/w response.\n");
1933                 goto gone_bad;
1934         }
1935 
1936         snd_printk ("hardware version %d.%d\n",
1937                     hwv[0], hwv[1]);
1938 
1939         return 0;
1940 
1941 
1942      gone_bad:
1943         return (1);
1944 }
1945 
1946 static int
1947 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1948 
1949 {
1950         const unsigned char *buf;
1951         int len, err;
1952         int section_cnt_downloaded = 0;
1953         const struct firmware *firmware;
1954 
1955         err = request_firmware(&firmware, path, dev->card->dev);
1956         if (err < 0) {
1957                 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1958                 return 1;
1959         }
1960 
1961         len = 0;
1962         buf = firmware->data;
1963         for (;;) {
1964                 int section_length = *(signed char *)buf;
1965                 if (section_length == 0)
1966                         break;
1967                 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1968                         snd_printk(KERN_ERR
1969                                    "invalid firmware section length %d\n",
1970                                    section_length);
1971                         goto failure;
1972                 }
1973                 buf++;
1974                 len++;
1975 
1976                 if (firmware->size < len + section_length) {
1977                         snd_printk(KERN_ERR "firmware section read error.\n");
1978                         goto failure;
1979                 }
1980 
1981                 /* Send command */
1982                 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1983                         goto failure;
1984         
1985                 for (; section_length; section_length--) {
1986                         if (wavefront_write(dev, *buf))
1987                                 goto failure;
1988                         buf++;
1989                         len++;
1990                 }
1991         
1992                 /* get ACK */
1993                 if (!wavefront_wait(dev, STAT_CAN_READ)) {
1994                         snd_printk(KERN_ERR "time out for firmware ACK.\n");
1995                         goto failure;
1996                 }
1997                 err = inb(dev->data_port);
1998                 if (err != WF_ACK) {
1999                         snd_printk(KERN_ERR
2000                                    "download of section #%d not "
2001                                    "acknowledged, ack = 0x%x\n",
2002                                    section_cnt_downloaded + 1, err);
2003                         goto failure;
2004                 }
2005 
2006                 section_cnt_downloaded++;
2007         }
2008 
2009         release_firmware(firmware);
2010         return 0;
2011 
2012  failure:
2013         release_firmware(firmware);
2014         snd_printk(KERN_ERR "firmware download failed!!!\n");
2015         return 1;
2016 }
2017 
2018 
2019 static int
2020 wavefront_do_reset (snd_wavefront_t *dev)
2021 
2022 {
2023         char voices[1];
2024 
2025         if (wavefront_reset_to_cleanliness (dev)) {
2026                 snd_printk ("hw reset failed.\n");
2027                 goto gone_bad;
2028         }
2029 
2030         if (dev->israw) {
2031                 if (wavefront_download_firmware (dev, ospath)) {
2032                         goto gone_bad;
2033                 }
2034 
2035                 dev->israw = 0;
2036 
2037                 /* Wait for the OS to get running. The protocol for
2038                    this is non-obvious, and was determined by
2039                    using port-IO tracing in DOSemu and some
2040                    experimentation here.
2041                    
2042                    Rather than using timed waits, use interrupts creatively.
2043                 */
2044 
2045                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2046                                                   dev->data_port,
2047                                                   (osrun_time*HZ));
2048 
2049                 if (!dev->irq_ok) {
2050                         snd_printk ("no post-OS interrupt.\n");
2051                         goto gone_bad;
2052                 }
2053                 
2054                 /* Now, do it again ! */
2055                 
2056                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2057                                                   dev->data_port, (10*HZ));
2058                 
2059                 if (!dev->irq_ok) {
2060                         snd_printk ("no post-OS interrupt(2).\n");
2061                         goto gone_bad;
2062                 }
2063 
2064                 /* OK, no (RX/TX) interrupts any more, but leave mute
2065                    in effect. 
2066                 */
2067                 
2068                 outb (0x80|0x40, dev->control_port); 
2069         }
2070 
2071         /* SETUPSND.EXE asks for sample memory config here, but since i
2072            have no idea how to interpret the result, we'll forget
2073            about it.
2074         */
2075         
2076         if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2077                 goto gone_bad;
2078         }
2079                 
2080         snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2081 
2082         if (wavefront_write (dev, 0xf0) ||
2083             wavefront_write (dev, 1) ||
2084             (wavefront_read (dev) < 0)) {
2085                 dev->debug = 0;
2086                 snd_printk ("MPU emulation mode not set.\n");
2087                 goto gone_bad;
2088         }
2089 
2090         voices[0] = 32;
2091 
2092         if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2093                 snd_printk ("cannot set number of voices to 32.\n");
2094                 goto gone_bad;
2095         }
2096 
2097 
2098         return 0;
2099 
2100  gone_bad:
2101         /* reset that sucker so that it doesn't bother us. */
2102 
2103         outb (0x0, dev->control_port);
2104         dev->interrupts_are_midi = 0;
2105         return 1;
2106 }
2107 
2108 int
2109 snd_wavefront_start (snd_wavefront_t *dev)
2110 
2111 {
2112         int samples_are_from_rom;
2113 
2114         /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2115            wavefront_reset_to_cleanliness() has already been called 
2116         */
2117 
2118         if (dev->israw) {
2119                 samples_are_from_rom = 1;
2120         } else {
2121                 /* XXX is this always true ? */
2122                 samples_are_from_rom = 0;
2123         }
2124 
2125         if (dev->israw || fx_raw) {
2126                 if (wavefront_do_reset (dev)) {
2127                         return -1;
2128                 }
2129         }
2130         /* Check for FX device, present only on Tropez+ */
2131 
2132         dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2133 
2134         if (dev->has_fx && fx_raw) {
2135                 snd_wavefront_fx_start (dev);
2136         }
2137 
2138         wavefront_get_sample_status (dev, samples_are_from_rom);
2139         wavefront_get_program_status (dev);
2140         wavefront_get_patch_status (dev);
2141 
2142         /* Start normal operation: unreset, master interrupt enabled, no mute
2143         */
2144 
2145         outb (0x80|0x40|0x20, dev->control_port); 
2146 
2147         return (0);
2148 }
2149 
2150 int
2151 snd_wavefront_detect (snd_wavefront_card_t *card)
2152 
2153 {
2154         unsigned char   rbuf[4], wbuf[4];
2155         snd_wavefront_t *dev = &card->wavefront;
2156         
2157         /* returns zero if a WaveFront card is successfully detected.
2158            negative otherwise.
2159         */
2160 
2161         dev->israw = 0;
2162         dev->has_fx = 0;
2163         dev->debug = debug_default;
2164         dev->interrupts_are_midi = 0;
2165         dev->irq_cnt = 0;
2166         dev->rom_samples_rdonly = 1;
2167 
2168         if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2169 
2170                 dev->fw_version[0] = rbuf[0];
2171                 dev->fw_version[1] = rbuf[1];
2172 
2173                 snd_printk ("firmware %d.%d already loaded.\n",
2174                             rbuf[0], rbuf[1]);
2175 
2176                 /* check that a command actually works */
2177       
2178                 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2179                                        rbuf, wbuf) == 0) {
2180                         dev->hw_version[0] = rbuf[0];
2181                         dev->hw_version[1] = rbuf[1];
2182                 } else {
2183                         snd_printk ("not raw, but no "
2184                                     "hardware version!\n");
2185                         return -1;
2186                 }
2187 
2188                 if (!wf_raw) {
2189                         return 0;
2190                 } else {
2191                         snd_printk ("reloading firmware as you requested.\n");
2192                         dev->israw = 1;
2193                 }
2194 
2195         } else {
2196 
2197                 dev->israw = 1;
2198                 snd_printk ("no response to firmware probe, assume raw.\n");
2199 
2200         }
2201 
2202         return 0;
2203 }
2204 
2205 MODULE_FIRMWARE(DEFAULT_OSPATH);
/* [<][>][^][v][top][bottom][index][help] */
root/sound/isa/wavefront/wavefront_synth.c

DEFINITIONS
