sound/isa/wavefront/wavefront_synth.c

   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         wfcmd = wavefront_get_command(cmd);
 343         if (!wfcmd) {
 344                 snd_printk ("command 0x%x not supported.\n",
 345                         cmd);
 346                 return 1;
 347         }
 348
 349         /* Hack to handle the one variable-size write command. See
 350            wavefront_send_multisample() for the other half of this
 351            gross and ugly strategy.
 352         */
 353
 354         if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
 355                 wfcmd->write_cnt = (unsigned long) rbuf;
 356                 rbuf = NULL;
 357         }
 358
 359         DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
 360                                cmd, wfcmd->action, wfcmd->read_cnt,
 361                                wfcmd->write_cnt, wfcmd->need_ack);
 362
 363         if (wavefront_write (dev, cmd)) {
 364                 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
 365                                                      "0x%x [%s].\n",
 366                                                      cmd, wfcmd->action);
 367                 return 1;
 368         }
 369
 370         if (wfcmd->write_cnt > 0) {
 371                 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
 372                                         "for 0x%x\n",
 373                                         wfcmd->write_cnt, cmd);
 374
 375                 for (i = 0; i < wfcmd->write_cnt; i++) {
 376                         if (wavefront_write (dev, wbuf[i])) {
 377                                 DPRINT (WF_DEBUG_IO, "bad write for byte "
 378                                                       "%d of 0x%x [%s].\n",
 379                                                       i, cmd, wfcmd->action);
 380                                 return 1;
 381                         }
 382
 383                         DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
 384                                                 i, wbuf[i]);
 385                 }
 386         }
 387
 388         if (wfcmd->read_cnt > 0) {
 389                 DPRINT (WF_DEBUG_DATA, "reading %d ints "
 390                                         "for 0x%x\n",
 391                                         wfcmd->read_cnt, cmd);
 392
 393                 for (i = 0; i < wfcmd->read_cnt; i++) {
 394
 395                         c = wavefront_read(dev);
 396                         if (c == -1) {
 397                                 DPRINT (WF_DEBUG_IO, "bad read for byte "
 398                                                       "%d of 0x%x [%s].\n",
 399                                                       i, cmd, wfcmd->action);
 400                                 return 1;
 401                         }
 402
 403                         /* Now handle errors. Lots of special cases here */
 404
 405                         if (c == 0xff) {
 406                                 c = wavefront_read(dev);
 407                                 if (c == -1) {
 408                                         DPRINT (WF_DEBUG_IO, "bad read for "
 409                                                               "error byte at "
 410                                                               "read byte %d "
 411                                                               "of 0x%x [%s].\n",
 412                                                               i, cmd,
 413                                                               wfcmd->action);
 414                                         return 1;
 415                                 }
 416
 417                                 /* Can you believe this madness ? */
 418
 419                                 if (c == 1 &&
 420                                     wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
 421                                         rbuf[0] = WF_ST_EMPTY;
 422                                         return (0);
 423
 424                                 } else if (c == 3 &&
 425                                            wfcmd->cmd == WFC_UPLOAD_PATCH) {
 426
 427                                         return 3;
 428
 429                                 } else if (c == 1 &&
 430                                            wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
 431
 432                                         return 1;
 433
 434                                 } else {
 435
 436                                         DPRINT (WF_DEBUG_IO, "error %d (%s) "
 437                                                               "during "
 438                                                               "read for byte "
 439                                                               "%d of 0x%x "
 440                                                               "[%s].\n",
 441                                                               c,
 442                                                               wavefront_errorstr (c),
 443                                                               i, cmd,
 444                                                               wfcmd->action);
 445                                         return 1;
 446
 447                                 }
 448
 449                 } else {
 450                                 rbuf[i] = c;
 451                         }
 452
 453                         DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
 454                 }
 455         }
 456
 457         if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
 458
 459                 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
 460
 461                 /* Some commands need an ACK, but return zero instead
 462                    of the standard value.
 463                 */
 464
 465                 ack = wavefront_read(dev);
 466                 if (ack == 0)
 467                         ack = WF_ACK;
 468
 469                 if (ack != WF_ACK) {
 470                         if (ack == -1) {
 471                                 DPRINT (WF_DEBUG_IO, "cannot read ack for "
 472                                                       "0x%x [%s].\n",
 473                                                       cmd, wfcmd->action);
 474                                 return 1;
 475
 476                         } else {
 477                                 int err = -1; /* something unknown */
 478
 479                                 if (ack == 0xff) { /* explicit error */
 480
 481                                         err = wavefront_read(dev);
 482                                         if (err == -1) {
 483                                                 DPRINT (WF_DEBUG_DATA,
 484                                                         "cannot read err "
 485                                                         "for 0x%x [%s].\n",
 486                                                         cmd, wfcmd->action);
 487                                         }
 488                                 }
 489
 490                                 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
 491                                         "failed (0x%x, 0x%x, %s)\n",
 492                                         cmd, wfcmd->action, ack, err,
 493                                         wavefront_errorstr (err));
 494
 495                                 return -err;
 496                         }
 497                 }
 498
 499                 DPRINT (WF_DEBUG_DATA, "ack received "
 500                                         "for 0x%x [%s]\n",
 501                                         cmd, wfcmd->action);
 502         } else {
 503
 504                 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
 505                                        "ACK (%d,%d,%d)\n",
 506                                        cmd, wfcmd->action, wfcmd->read_cnt,
 507                                        wfcmd->write_cnt, wfcmd->need_ack);
 508         }
 509
 510         return 0;
 511
 512 }
 513 \f
 514 /***********************************************************************
 515 WaveFront data munging
 516
 517 Things here are weird. All data written to the board cannot
 518 have its most significant bit set. Any data item with values
 519 potentially > 0x7F (127) must be split across multiple bytes.
 520
 521 Sometimes, we need to munge numeric values that are represented on
 522 the x86 side as 8-32 bit values. Sometimes, we need to munge data
 523 that is represented on the x86 side as an array of bytes. The most
 524 efficient approach to handling both cases seems to be to use 2
 525 different functions for munging and 2 for de-munging. This avoids
 526 weird casting and worrying about bit-level offsets.
 527
 528 **********************************************************************/
 529
 530 static unsigned char *
 531 munge_int32 (unsigned int src,
 532              unsigned char *dst,
 533              unsigned int dst_size)
 534 {
 535         unsigned int i;
 536
 537         for (i = 0; i < dst_size; i++) {
 538                 *dst = src & 0x7F;  /* Mask high bit of LSB */
 539                 src = src >> 7;     /* Rotate Right 7 bits  */
 540                                     /* Note: we leave the upper bits in place */
 541
 542                 dst++;
 543         }
 544         return dst;
 545 };
 546
 547 static int
 548 demunge_int32 (unsigned char* src, int src_size)
 549
 550 {
 551         int i;
 552         int outval = 0;
 553
 554         for (i = src_size - 1; i >= 0; i--) {
 555                 outval=(outval<<7)+src[i];
 556         }
 557
 558         return outval;
 559 };
 560
 561 static
 562 unsigned char *
 563 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
 564
 565 {
 566         unsigned int i;
 567         unsigned int last = dst_size / 2;
 568
 569         for (i = 0; i < last; i++) {
 570                 *dst++ = src[i] & 0x7f;
 571                 *dst++ = src[i] >> 7;
 572         }
 573         return dst;
 574 }
 575
 576 static
 577 unsigned char *
 578 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
 579
 580 {
 581         int i;
 582         unsigned char *end = src + src_bytes;
 583
 584         /* NOTE: src and dst *CAN* point to the same address */
 585
 586         for (i = 0; src != end; i++) {
 587                 dst[i] = *src++;
 588                 dst[i] |= (*src++)<<7;
 589         }
 590
 591         return dst;
 592 }
 593 \f
 594 /***********************************************************************
 595 WaveFront: sample, patch and program management.
 596 ***********************************************************************/
 597
 598 static int
 599 wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
 600
 601 {
 602         unsigned char wbuf[2];
 603         int x;
 604
 605         wbuf[0] = sample_num & 0x7f;
 606         wbuf[1] = sample_num >> 7;
 607
 608         x = snd_wavefront_cmd(dev, WFC_DELETE_SAMPLE, NULL, wbuf);
 609         if (!x)
 610                 dev->sample_status[sample_num] = WF_ST_EMPTY;
 611
 612         return x;
 613 }
 614
 615 static int
 616 wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
 617
 618 {
 619         int i;
 620         unsigned char rbuf[32], wbuf[32];
 621         unsigned int    sc_real, sc_alias, sc_multi;
 622
 623         /* check sample status */
 624
 625         if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
 626                 snd_printk ("cannot request sample count.\n");
 627                 return -1;
 628         }
 629
 630         sc_real = sc_alias = sc_multi = dev->samples_used = 0;
 631
 632         for (i = 0; i < WF_MAX_SAMPLE; i++) {
 633
 634                 wbuf[0] = i & 0x7f;
 635                 wbuf[1] = i >> 7;
 636
 637                 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
 638                         snd_printk(KERN_WARNING "cannot identify sample "
 639                                    "type of slot %d\n", i);
 640                         dev->sample_status[i] = WF_ST_EMPTY;
 641                         continue;
 642                 }
 643
 644                 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
 645
 646                 if (assume_rom) {
 647                         dev->sample_status[i] |= WF_SLOT_ROM;
 648                 }
 649
 650                 switch (rbuf[0] & WF_ST_MASK) {
 651                 case WF_ST_SAMPLE:
 652                         sc_real++;
 653                         break;
 654                 case WF_ST_MULTISAMPLE:
 655                         sc_multi++;
 656                         break;
 657                 case WF_ST_ALIAS:
 658                         sc_alias++;
 659                         break;
 660                 case WF_ST_EMPTY:
 661                         break;
 662
 663                 default:
 664                         snd_printk ("unknown sample type for "
 665                                     "slot %d (0x%x)\n",
 666                                     i, rbuf[0]);
 667                 }
 668
 669                 if (rbuf[0] != WF_ST_EMPTY) {
 670                         dev->samples_used++;
 671                 }
 672         }
 673
 674         snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
 675                     "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
 676                     WF_MAX_SAMPLE - dev->samples_used);
 677
 678
 679         return (0);
 680
 681 }
 682
 683 static int
 684 wavefront_get_patch_status (snd_wavefront_t *dev)
 685
 686 {
 687         unsigned char patchbuf[WF_PATCH_BYTES];
 688         unsigned char patchnum[2];
 689         wavefront_patch *p;
 690         int i, x, cnt, cnt2;
 691
 692         for (i = 0; i < WF_MAX_PATCH; i++) {
 693                 patchnum[0] = i & 0x7f;
 694                 patchnum[1] = i >> 7;
 695
 696                 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PATCH, patchbuf,
 697                                       patchnum);
 698                 if (x == 0) {
 699
 700                         dev->patch_status[i] |= WF_SLOT_FILLED;
 701                         p = (wavefront_patch *) patchbuf;
 702                         dev->sample_status
 703                                 [p->sample_number|(p->sample_msb<<7)] |=
 704                                 WF_SLOT_USED;
 705
 706                 } else if (x == 3) { /* Bad patch number */
 707                         dev->patch_status[i] = 0;
 708                 } else {
 709                         snd_printk ("upload patch "
 710                                     "error 0x%x\n", x);
 711                         dev->patch_status[i] = 0;
 712                         return 1;
 713                 }
 714         }
 715
 716         /* program status has already filled in slot_used bits */
 717
 718         for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
 719                 if (dev->patch_status[i] & WF_SLOT_FILLED) {
 720                         cnt++;
 721                 }
 722                 if (dev->patch_status[i] & WF_SLOT_USED) {
 723                         cnt2++;
 724                 }
 725
 726         }
 727         snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
 728
 729         return (0);
 730 }
 731
 732 static int
 733 wavefront_get_program_status (snd_wavefront_t *dev)
 734
 735 {
 736         unsigned char progbuf[WF_PROGRAM_BYTES];
 737         wavefront_program prog;
 738         unsigned char prognum;
 739         int i, x, l, cnt;
 740
 741         for (i = 0; i < WF_MAX_PROGRAM; i++) {
 742                 prognum = i;
 743
 744                 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PROGRAM, progbuf,
 745                                       &prognum);
 746                 if (x == 0) {
 747
 748                         dev->prog_status[i] |= WF_SLOT_USED;
 749
 750                         demunge_buf (progbuf, (unsigned char *) &prog,
 751                                      WF_PROGRAM_BYTES);
 752
 753                         for (l = 0; l < WF_NUM_LAYERS; l++) {
 754                                 if (prog.layer[l].mute) {
 755                                         dev->patch_status
 756                                                 [prog.layer[l].patch_number] |=
 757                                                 WF_SLOT_USED;
 758                                 }
 759                         }
 760                 } else if (x == 1) { /* Bad program number */
 761                         dev->prog_status[i] = 0;
 762                 } else {
 763                         snd_printk ("upload program "
 764                                     "error 0x%x\n", x);
 765                         dev->prog_status[i] = 0;
 766                 }
 767         }
 768
 769         for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
 770                 if (dev->prog_status[i]) {
 771                         cnt++;
 772                 }
 773         }
 774
 775         snd_printk ("%d programs slots in use\n", cnt);
 776
 777         return (0);
 778 }
 779
 780 static int
 781 wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
 782
 783 {
 784         unsigned char buf[WF_PATCH_BYTES+2];
 785         unsigned char *bptr;
 786
 787         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
 788                                       header->number);
 789
 790         if (header->number >= ARRAY_SIZE(dev->patch_status))
 791                 return -EINVAL;
 792
 793         dev->patch_status[header->number] |= WF_SLOT_FILLED;
 794
 795         bptr = munge_int32 (header->number, buf, 2);
 796         munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
 797
 798         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
 799                 snd_printk ("download patch failed\n");
 800                 return -EIO;
 801         }
 802
 803         return (0);
 804 }
 805
 806 static int
 807 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
 808
 809 {
 810         unsigned char buf[WF_PROGRAM_BYTES+1];
 811         int i;
 812
 813         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
 814                 header->number);
 815
 816         if (header->number >= ARRAY_SIZE(dev->prog_status))
 817                 return -EINVAL;
 818
 819         dev->prog_status[header->number] = WF_SLOT_USED;
 820
 821         /* XXX need to zero existing SLOT_USED bit for program_status[i]
 822            where `i' is the program that's being (potentially) overwritten.
 823         */
 824
 825         for (i = 0; i < WF_NUM_LAYERS; i++) {
 826                 if (header->hdr.pr.layer[i].mute) {
 827                         dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
 828                                 WF_SLOT_USED;
 829
 830                         /* XXX need to mark SLOT_USED for sample used by
 831                            patch_number, but this means we have to load it. Ick.
 832                         */
 833                 }
 834         }
 835
 836         buf[0] = header->number;
 837         munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
 838
 839         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
 840                 snd_printk ("download patch failed\n");
 841                 return -EIO;
 842         }
 843
 844         return (0);
 845 }
 846
 847 static int
 848 wavefront_freemem (snd_wavefront_t *dev)
 849
 850 {
 851         char rbuf[8];
 852
 853         if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
 854                 snd_printk ("can't get memory stats.\n");
 855                 return -1;
 856         } else {
 857                 return demunge_int32 (rbuf, 4);
 858         }
 859 }
 860
 861 static int
 862 wavefront_send_sample (snd_wavefront_t *dev,
 863                        wavefront_patch_info *header,
 864                        u16 __user *dataptr,
 865                        int data_is_unsigned)
 866
 867 {
 868         /* samples are downloaded via a 16-bit wide i/o port
 869            (you could think of it as 2 adjacent 8-bit wide ports
 870            but its less efficient that way). therefore, all
 871            the blocksizes and so forth listed in the documentation,
 872            and used conventionally to refer to sample sizes,
 873            which are given in 8-bit units (bytes), need to be
 874            divided by 2.
 875         */
 876
 877         u16 sample_short = 0;
 878         u32 length;
 879         u16 __user *data_end = NULL;
 880         unsigned int i;
 881         const unsigned int max_blksize = 4096/2;
 882         unsigned int written;
 883         unsigned int blocksize;
 884         int dma_ack;
 885         int blocknum;
 886         unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
 887         unsigned char *shptr;
 888         int skip = 0;
 889         int initial_skip = 0;
 890
 891         DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
 892                                       "type %d, %d bytes from 0x%lx\n",
 893                                       header->size ? "" : "header ",
 894                                       header->number, header->subkey,
 895                                       header->size,
 896                                       (unsigned long) header->dataptr);
 897
 898         if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
 899                 int x;
 900
 901                 x = wavefront_find_free_sample(dev);
 902                 if (x < 0)
 903                         return -ENOMEM;
 904                 snd_printk ("unspecified sample => %d\n", x);
 905                 header->number = x;
 906         }
 907
 908         if (header->number >= WF_MAX_SAMPLE)
 909                 return -EINVAL;
 910
 911         if (header->size) {
 912
 913                 /* XXX it's a debatable point whether or not RDONLY semantics
 914                    on the ROM samples should cover just the sample data or
 915                    the sample header. For now, it only covers the sample data,
 916                    so anyone is free at all times to rewrite sample headers.
 917
 918                    My reason for this is that we have the sample headers
 919                    available in the WFB file for General MIDI, and so these
 920                    can always be reset if needed. The sample data, however,
 921                    cannot be recovered without a complete reset and firmware
 922                    reload of the ICS2115, which is a very expensive operation.
 923
 924                    So, doing things this way allows us to honor the notion of
 925                    "RESETSAMPLES" reasonably cheaply. Note however, that this
 926                    is done purely at user level: there is no WFB parser in
 927                    this driver, and so a complete reset (back to General MIDI,
 928                    or theoretically some other configuration) is the
 929                    responsibility of the user level library.
 930
 931                    To try to do this in the kernel would be a little
 932                    crazy: we'd need 158K of kernel space just to hold
 933                    a copy of the patch/program/sample header data.
 934                 */
 935
 936                 if (dev->rom_samples_rdonly) {
 937                         if (dev->sample_status[header->number] & WF_SLOT_ROM) {
 938                                 snd_printk ("sample slot %d "
 939                                             "write protected\n",
 940                                             header->number);
 941                                 return -EACCES;
 942                         }
 943                 }
 944
 945                 wavefront_delete_sample (dev, header->number);
 946         }
 947
 948         if (header->size) {
 949                 dev->freemem = wavefront_freemem (dev);
 950
 951                 if (dev->freemem < (int)header->size) {
 952                         snd_printk ("insufficient memory to "
 953                                     "load %d byte sample.\n",
 954                                     header->size);
 955                         return -ENOMEM;
 956                 }
 957
 958         }
 959
 960         skip = WF_GET_CHANNEL(&header->hdr.s);
 961
 962         if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
 963                 snd_printk ("channel selection only "
 964                             "possible on 16-bit samples");
 965                 return -EINVAL;
 966         }
 967
 968         switch (skip) {
 969         case 0:
 970                 initial_skip = 0;
 971                 skip = 1;
 972                 break;
 973         case 1:
 974                 initial_skip = 0;
 975                 skip = 2;
 976                 break;
 977         case 2:
 978                 initial_skip = 1;
 979                 skip = 2;
 980                 break;
 981         case 3:
 982                 initial_skip = 2;
 983                 skip = 3;
 984                 break;
 985         case 4:
 986                 initial_skip = 3;
 987                 skip = 4;
 988                 break;
 989         case 5:
 990                 initial_skip = 4;
 991                 skip = 5;
 992                 break;
 993         case 6:
 994                 initial_skip = 5;
 995                 skip = 6;
 996                 break;
 997         }
 998
 999         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 \f
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 \f
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);