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  "/*(DEBLOBBED)*/"
  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 \f
 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 \f
 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                                 if (get_user(sample_short, dataptr))
1092                                         return -EFAULT;
1093                                 dataptr += skip;
1094
1095                                 if (data_is_unsigned) { /* GUS ? */
1096
1097                                         if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1098
1099                                                 /* 8 bit sample
1100                                                  resolution, sign
1101                                                  extend both bytes.
1102                                                 */
1103
1104                                                 ((unsigned char*)
1105                                                  &sample_short)[0] += 0x7f;
1106                                                 ((unsigned char*)
1107                                                  &sample_short)[1] += 0x7f;
1108
1109                                         } else {
1110
1111                                                 /* 16 bit sample
1112                                                  resolution, sign
1113                                                  extend the MSB.
1114                                                 */
1115
1116                                                 sample_short += 0x7fff;
1117                                         }
1118                                 }
1119
1120                         } else {
1121
1122                                 /* In padding section of final block:
1123
1124                                    Don't fetch unsupplied data from
1125                                    user space, just continue with
1126                                    whatever the final value was.
1127                                 */
1128                         }
1129
1130                         if (i < blocksize - 1) {
1131                                 outw (sample_short, dev->block_port);
1132                         } else {
1133                                 outw (sample_short, dev->last_block_port);
1134                         }
1135                 }
1136
1137                 /* Get "DMA page acknowledge", even though its really
1138                    nothing to do with DMA at all.
1139                 */
1140
1141                 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1142                         if (dma_ack == -1) {
1143                                 snd_printk ("upload sample "
1144                                             "DMA ack timeout\n");
1145                                 return -EIO;
1146                         } else {
1147                                 snd_printk ("upload sample "
1148                                             "DMA ack error 0x%x\n",
1149                                             dma_ack);
1150                                 return -EIO;
1151                         }
1152                 }
1153         }
1154
1155         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1156
1157         /* Note, label is here because sending the sample header shouldn't
1158            alter the sample_status info at all.
1159         */
1160
1161  sent:
1162         return (0);
1163 }
1164
1165 static int
1166 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1167
1168 {
1169         unsigned char alias_hdr[WF_ALIAS_BYTES];
1170
1171         DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1172                                       "alias for %d\n",
1173                                       header->number,
1174                                       header->hdr.a.OriginalSample);
1175
1176         if (header->number >= WF_MAX_SAMPLE)
1177                 return -EINVAL;
1178
1179         munge_int32 (header->number, &alias_hdr[0], 2);
1180         munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1181         munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1182                      &alias_hdr[4], 4);
1183         munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1184                      &alias_hdr[8], 4);
1185         munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1186                      &alias_hdr[12], 4);
1187         munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1188                      &alias_hdr[16], 4);
1189         munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1190         munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1191
1192         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1193                 snd_printk ("download alias failed.\n");
1194                 return -EIO;
1195         }
1196
1197         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1198
1199         return (0);
1200 }
1201
1202 static int
1203 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1204 {
1205         int i;
1206         int num_samples;
1207         unsigned char *msample_hdr;
1208
1209         if (header->number >= WF_MAX_SAMPLE)
1210                 return -EINVAL;
1211
1212         msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1213         if (! msample_hdr)
1214                 return -ENOMEM;
1215
1216         munge_int32 (header->number, &msample_hdr[0], 2);
1217
1218         /* You'll recall at this point that the "number of samples" value
1219            in a wavefront_multisample struct is actually the log2 of the
1220            real number of samples.
1221         */
1222
1223         num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1224         msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1225
1226         DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1227                                       header->number,
1228                                       header->hdr.ms.NumberOfSamples,
1229                                       num_samples);
1230
1231         for (i = 0; i < num_samples; i++) {
1232                 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1233                        i, header->hdr.ms.SampleNumber[i]);
1234                 munge_int32 (header->hdr.ms.SampleNumber[i],
1235                      &msample_hdr[3+(i*2)], 2);
1236         }
1237
1238         /* Need a hack here to pass in the number of bytes
1239            to be written to the synth. This is ugly, and perhaps
1240            one day, I'll fix it.
1241         */
1242
1243         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1244                            (unsigned char *) (long) ((num_samples*2)+3),
1245                            msample_hdr)) {
1246                 snd_printk ("download of multisample failed.\n");
1247                 kfree(msample_hdr);
1248                 return -EIO;
1249         }
1250
1251         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1252
1253         kfree(msample_hdr);
1254         return (0);
1255 }
1256
1257 static int
1258 wavefront_fetch_multisample (snd_wavefront_t *dev,
1259                              wavefront_patch_info *header)
1260 {
1261         int i;
1262         unsigned char log_ns[1];
1263         unsigned char number[2];
1264         int num_samples;
1265
1266         munge_int32 (header->number, number, 2);
1267
1268         if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1269                 snd_printk ("upload multisample failed.\n");
1270                 return -EIO;
1271         }
1272
1273         DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1274                                 header->number, log_ns[0]);
1275
1276         header->hdr.ms.NumberOfSamples = log_ns[0];
1277
1278         /* get the number of samples ... */
1279
1280         num_samples = (1 << log_ns[0]);
1281
1282         for (i = 0; i < num_samples; i++) {
1283                 char d[2];
1284                 int 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[0] = val;
1292
1293                 if ((val = wavefront_read (dev)) == -1) {
1294                         snd_printk ("upload multisample failed "
1295                                     "during sample loop.\n");
1296                         return -EIO;
1297                 }
1298                 d[1] = val;
1299
1300                 header->hdr.ms.SampleNumber[i] =
1301                         demunge_int32 ((unsigned char *) d, 2);
1302
1303                 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1304                                         i, header->hdr.ms.SampleNumber[i]);
1305         }
1306
1307         return (0);
1308 }
1309
1310
1311 static int
1312 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1313
1314 {
1315         unsigned char drumbuf[WF_DRUM_BYTES];
1316         wavefront_drum *drum = &header->hdr.d;
1317         int i;
1318
1319         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1320                 "note %d, patch = %d\n",
1321                 header->number, drum->PatchNumber);
1322
1323         drumbuf[0] = header->number & 0x7f;
1324
1325         for (i = 0; i < 4; i++) {
1326                 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1327         }
1328
1329         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1330                 snd_printk ("download drum failed.\n");
1331                 return -EIO;
1332         }
1333
1334         return (0);
1335 }
1336
1337 static int
1338 wavefront_find_free_sample (snd_wavefront_t *dev)
1339
1340 {
1341         int i;
1342
1343         for (i = 0; i < WF_MAX_SAMPLE; i++) {
1344                 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1345                         return i;
1346                 }
1347         }
1348         snd_printk ("no free sample slots!\n");
1349         return -1;
1350 }
1351
1352 #if 0
1353 static int
1354 wavefront_find_free_patch (snd_wavefront_t *dev)
1355
1356 {
1357         int i;
1358
1359         for (i = 0; i < WF_MAX_PATCH; i++) {
1360                 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1361                         return i;
1362                 }
1363         }
1364         snd_printk ("no free patch slots!\n");
1365         return -1;
1366 }
1367 #endif
1368
1369 static int
1370 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1371 {
1372         wavefront_patch_info *header;
1373         int err;
1374
1375         header = kmalloc(sizeof(*header), GFP_KERNEL);
1376         if (! header)
1377                 return -ENOMEM;
1378
1379         if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1380                             sizeof(wavefront_any))) {
1381                 snd_printk ("bad address for load patch.\n");
1382                 err = -EFAULT;
1383                 goto __error;
1384         }
1385
1386         DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1387                                       "Sample type: %d "
1388                                       "Sample number: %d "
1389                                       "Sample size: %d\n",
1390                                       header->subkey,
1391                                       header->number,
1392                                       header->size);
1393
1394         switch (header->subkey) {
1395         case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */
1396
1397                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1398                                     sizeof (wavefront_sample))) {
1399                         err = -EFAULT;
1400                         break;
1401                 }
1402
1403                 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1404                 break;
1405
1406         case WF_ST_MULTISAMPLE:
1407
1408                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1409                                     sizeof (wavefront_multisample))) {
1410                         err = -EFAULT;
1411                         break;
1412                 }
1413
1414                 err = wavefront_send_multisample (dev, header);
1415                 break;
1416
1417         case WF_ST_ALIAS:
1418
1419                 if (copy_from_user (&header->hdr.a, header->hdrptr,
1420                                     sizeof (wavefront_alias))) {
1421                         err = -EFAULT;
1422                         break;
1423                 }
1424
1425                 err = wavefront_send_alias (dev, header);
1426                 break;
1427
1428         case WF_ST_DRUM:
1429                 if (copy_from_user (&header->hdr.d, header->hdrptr,
1430                                     sizeof (wavefront_drum))) {
1431                         err = -EFAULT;
1432                         break;
1433                 }
1434
1435                 err = wavefront_send_drum (dev, header);
1436                 break;
1437
1438         case WF_ST_PATCH:
1439                 if (copy_from_user (&header->hdr.p, header->hdrptr,
1440                                     sizeof (wavefront_patch))) {
1441                         err = -EFAULT;
1442                         break;
1443                 }
1444
1445                 err = wavefront_send_patch (dev, header);
1446                 break;
1447
1448         case WF_ST_PROGRAM:
1449                 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1450                                     sizeof (wavefront_program))) {
1451                         err = -EFAULT;
1452                         break;
1453                 }
1454
1455                 err = wavefront_send_program (dev, header);
1456                 break;
1457
1458         default:
1459                 snd_printk ("unknown patch type %d.\n",
1460                             header->subkey);
1461                 err = -EINVAL;
1462                 break;
1463         }
1464
1465  __error:
1466         kfree(header);
1467         return err;
1468 }
1469 \f
1470 /***********************************************************************
1471 WaveFront: hardware-dependent interface
1472 ***********************************************************************/
1473
1474 static void
1475 process_sample_hdr (u8 *buf)
1476
1477 {
1478         wavefront_sample s;
1479         u8 *ptr;
1480
1481         ptr = buf;
1482
1483         /* The board doesn't send us an exact copy of a "wavefront_sample"
1484            in response to an Upload Sample Header command. Instead, we
1485            have to convert the data format back into our data structure,
1486            just as in the Download Sample command, where we have to do
1487            something very similar in the reverse direction.
1488         */
1489
1490         *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1491         *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1492         *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1493         *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1494         *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1495
1496         s.SampleResolution = *ptr & 0x3;
1497         s.Loop = *ptr & 0x8;
1498         s.Bidirectional = *ptr & 0x10;
1499         s.Reverse = *ptr & 0x40;
1500
1501         /* Now copy it back to where it came from */
1502
1503         memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1504 }
1505
1506 static int
1507 wavefront_synth_control (snd_wavefront_card_t *acard,
1508                          wavefront_control *wc)
1509
1510 {
1511         snd_wavefront_t *dev = &acard->wavefront;
1512         unsigned char patchnumbuf[2];
1513         int i;
1514
1515         DPRINT (WF_DEBUG_CMD, "synth control with "
1516                 "cmd 0x%x\n", wc->cmd);
1517
1518         /* Pre-handling of or for various commands */
1519
1520         switch (wc->cmd) {
1521
1522         case WFC_DISABLE_INTERRUPTS:
1523                 snd_printk ("interrupts disabled.\n");
1524                 outb (0x80|0x20, dev->control_port);
1525                 dev->interrupts_are_midi = 1;
1526                 return 0;
1527
1528         case WFC_ENABLE_INTERRUPTS:
1529                 snd_printk ("interrupts enabled.\n");
1530                 outb (0x80|0x40|0x20, dev->control_port);
1531                 dev->interrupts_are_midi = 1;
1532                 return 0;
1533
1534         case WFC_INTERRUPT_STATUS:
1535                 wc->rbuf[0] = dev->interrupts_are_midi;
1536                 return 0;
1537
1538         case WFC_ROMSAMPLES_RDONLY:
1539                 dev->rom_samples_rdonly = wc->wbuf[0];
1540                 wc->status = 0;
1541                 return 0;
1542
1543         case WFC_IDENTIFY_SLOT_TYPE:
1544                 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1545                 if (i <0 || i >= WF_MAX_SAMPLE) {
1546                         snd_printk ("invalid slot ID %d\n",
1547                                 i);
1548                         wc->status = EINVAL;
1549                         return -EINVAL;
1550                 }
1551                 wc->rbuf[0] = dev->sample_status[i];
1552                 wc->status = 0;
1553                 return 0;
1554
1555         case WFC_DEBUG_DRIVER:
1556                 dev->debug = wc->wbuf[0];
1557                 snd_printk ("debug = 0x%x\n", dev->debug);
1558                 return 0;
1559
1560         case WFC_UPLOAD_PATCH:
1561                 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1562                 memcpy (wc->wbuf, patchnumbuf, 2);
1563                 break;
1564
1565         case WFC_UPLOAD_MULTISAMPLE:
1566                 /* multisamples have to be handled differently, and
1567                    cannot be dealt with properly by snd_wavefront_cmd() alone.
1568                 */
1569                 wc->status = wavefront_fetch_multisample
1570                         (dev, (wavefront_patch_info *) wc->rbuf);
1571                 return 0;
1572
1573         case WFC_UPLOAD_SAMPLE_ALIAS:
1574                 snd_printk ("support for sample alias upload "
1575                         "being considered.\n");
1576                 wc->status = EINVAL;
1577                 return -EINVAL;
1578         }
1579
1580         wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1581
1582         /* Post-handling of certain commands.
1583
1584            In particular, if the command was an upload, demunge the data
1585            so that the user-level doesn't have to think about it.
1586         */
1587
1588         if (wc->status == 0) {
1589                 switch (wc->cmd) {
1590                         /* intercept any freemem requests so that we know
1591                            we are always current with the user-level view
1592                            of things.
1593                         */
1594
1595                 case WFC_REPORT_FREE_MEMORY:
1596                         dev->freemem = demunge_int32 (wc->rbuf, 4);
1597                         break;
1598
1599                 case WFC_UPLOAD_PATCH:
1600                         demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1601                         break;
1602
1603                 case WFC_UPLOAD_PROGRAM:
1604                         demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1605                         break;
1606
1607                 case WFC_UPLOAD_EDRUM_PROGRAM:
1608                         demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1609                         break;
1610
1611                 case WFC_UPLOAD_SAMPLE_HEADER:
1612                         process_sample_hdr (wc->rbuf);
1613                         break;
1614
1615                 case WFC_UPLOAD_SAMPLE_ALIAS:
1616                         snd_printk ("support for "
1617                                     "sample aliases still "
1618                                     "being considered.\n");
1619                         break;
1620
1621                 case WFC_VMIDI_OFF:
1622                         snd_wavefront_midi_disable_virtual (acard);
1623                         break;
1624
1625                 case WFC_VMIDI_ON:
1626                         snd_wavefront_midi_enable_virtual (acard);
1627                         break;
1628                 }
1629         }
1630
1631         return 0;
1632 }
1633
1634 int
1635 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1636
1637 {
1638         if (!try_module_get(hw->card->module))
1639                 return -EFAULT;
1640         file->private_data = hw;
1641         return 0;
1642 }
1643
1644 int
1645 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1646
1647 {
1648         module_put(hw->card->module);
1649         return 0;
1650 }
1651
1652 int
1653 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1654                            unsigned int cmd, unsigned long arg)
1655
1656 {
1657         struct snd_card *card;
1658         snd_wavefront_t *dev;
1659         snd_wavefront_card_t *acard;
1660         wavefront_control *wc;
1661         void __user *argp = (void __user *)arg;
1662         int err;
1663
1664         card = (struct snd_card *) hw->card;
1665
1666         if (snd_BUG_ON(!card))
1667                 return -ENODEV;
1668         if (snd_BUG_ON(!card->private_data))
1669                 return -ENODEV;
1670
1671         acard = card->private_data;
1672         dev = &acard->wavefront;
1673
1674         switch (cmd) {
1675         case WFCTL_LOAD_SPP:
1676                 if (wavefront_load_patch (dev, argp) != 0) {
1677                         return -EIO;
1678                 }
1679                 break;
1680
1681         case WFCTL_WFCMD:
1682                 wc = memdup_user(argp, sizeof(*wc));
1683                 if (IS_ERR(wc))
1684                         return PTR_ERR(wc);
1685
1686                 if (wavefront_synth_control (acard, wc) < 0)
1687                         err = -EIO;
1688                 else if (copy_to_user (argp, wc, sizeof (*wc)))
1689                         err = -EFAULT;
1690                 else
1691                         err = 0;
1692                 kfree(wc);
1693                 return err;
1694
1695         default:
1696                 return -EINVAL;
1697         }
1698
1699         return 0;
1700 }
1701
1702 \f
1703 /***********************************************************************/
1704 /*  WaveFront: interface for card-level wavefront module               */
1705 /***********************************************************************/
1706
1707 void
1708 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1709 {
1710         snd_wavefront_t *dev = &card->wavefront;
1711
1712         /*
1713            Some comments on interrupts. I attempted a version of this
1714            driver that used interrupts throughout the code instead of
1715            doing busy and/or sleep-waiting. Alas, it appears that once
1716            the Motorola firmware is downloaded, the card *never*
1717            generates an RX interrupt. These are successfully generated
1718            during firmware loading, and after that wavefront_status()
1719            reports that an interrupt is pending on the card from time
1720            to time, but it never seems to be delivered to this
1721            driver. Note also that wavefront_status() continues to
1722            report that RX interrupts are enabled, suggesting that I
1723            didn't goof up and disable them by mistake.
1724
1725            Thus, I stepped back to a prior version of
1726            wavefront_wait(), the only place where this really
1727            matters. Its sad, but I've looked through the code to check
1728            on things, and I really feel certain that the Motorola
1729            firmware prevents RX-ready interrupts.
1730         */
1731
1732         if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1733                 return;
1734         }
1735
1736         spin_lock(&dev->irq_lock);
1737         dev->irq_ok = 1;
1738         dev->irq_cnt++;
1739         spin_unlock(&dev->irq_lock);
1740         wake_up(&dev->interrupt_sleeper);
1741 }
1742
1743 /* STATUS REGISTER
1744
1745 0 Host Rx Interrupt Enable (1=Enabled)
1746 1 Host Rx Register Full (1=Full)
1747 2 Host Rx Interrupt Pending (1=Interrupt)
1748 3 Unused
1749 4 Host Tx Interrupt (1=Enabled)
1750 5 Host Tx Register empty (1=Empty)
1751 6 Host Tx Interrupt Pending (1=Interrupt)
1752 7 Unused
1753 */
1754
1755 static int
1756 snd_wavefront_interrupt_bits (int irq)
1757
1758 {
1759         int bits;
1760
1761         switch (irq) {
1762         case 9:
1763                 bits = 0x00;
1764                 break;
1765         case 5:
1766                 bits = 0x08;
1767                 break;
1768         case 12:
1769                 bits = 0x10;
1770                 break;
1771         case 15:
1772                 bits = 0x18;
1773                 break;
1774
1775         default:
1776                 snd_printk ("invalid IRQ %d\n", irq);
1777                 bits = -1;
1778         }
1779
1780         return bits;
1781 }
1782
1783 static void
1784 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1785                                   int val, int port, unsigned long timeout)
1786
1787 {
1788         wait_queue_entry_t wait;
1789
1790         init_waitqueue_entry(&wait, current);
1791         spin_lock_irq(&dev->irq_lock);
1792         add_wait_queue(&dev->interrupt_sleeper, &wait);
1793         dev->irq_ok = 0;
1794         outb (val,port);
1795         spin_unlock_irq(&dev->irq_lock);
1796         while (!dev->irq_ok && time_before(jiffies, timeout)) {
1797                 schedule_timeout_uninterruptible(1);
1798                 barrier();
1799         }
1800 }
1801
1802 static int
1803 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1804
1805 {
1806         int bits;
1807         int hwv[2];
1808
1809         /* IRQ already checked */
1810
1811         bits = snd_wavefront_interrupt_bits (dev->irq);
1812
1813         /* try reset of port */
1814
1815         outb (0x0, dev->control_port);
1816
1817         /* At this point, the board is in reset, and the H/W initialization
1818            register is accessed at the same address as the data port.
1819
1820            Bit 7 - Enable IRQ Driver
1821            0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1822            1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1823
1824            Bit 6 - MIDI Interface Select
1825
1826            0 - Use the MIDI Input from the 26-pin WaveBlaster
1827            compatible header as the serial MIDI source
1828            1 - Use the MIDI Input from the 9-pin D connector as the
1829            serial MIDI source.
1830
1831            Bits 5:3 - IRQ Selection
1832            0 0 0 - IRQ 2/9
1833            0 0 1 - IRQ 5
1834            0 1 0 - IRQ 12
1835            0 1 1 - IRQ 15
1836            1 0 0 - Reserved
1837            1 0 1 - Reserved
1838            1 1 0 - Reserved
1839            1 1 1 - Reserved
1840
1841            Bits 2:1 - Reserved
1842            Bit 0 - Disable Boot ROM
1843            0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1844            1 - memory accesses to 03FC30-03FFFFH are directed to external
1845            storage.
1846
1847         */
1848
1849         /* configure hardware: IRQ, enable interrupts,
1850            plus external 9-pin MIDI interface selected
1851         */
1852
1853         outb (0x80 | 0x40 | bits, dev->data_port);
1854
1855         /* CONTROL REGISTER
1856
1857            0 Host Rx Interrupt Enable (1=Enabled)      0x1
1858            1 Unused                                    0x2
1859            2 Unused                                    0x4
1860            3 Unused                                    0x8
1861            4 Host Tx Interrupt Enable                 0x10
1862            5 Mute (0=Mute; 1=Play)                    0x20
1863            6 Master Interrupt Enable (1=Enabled)      0x40
1864            7 Master Reset (0=Reset; 1=Run)            0x80
1865
1866            Take us out of reset, mute output, master + TX + RX interrupts on.
1867
1868            We'll get an interrupt presumably to tell us that the TX
1869            register is clear.
1870         */
1871
1872         wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1873                                          dev->control_port,
1874                                          (reset_time*HZ)/100);
1875
1876         /* Note: data port is now the data port, not the h/w initialization
1877            port.
1878          */
1879
1880         if (!dev->irq_ok) {
1881                 snd_printk ("intr not received after h/w un-reset.\n");
1882                 goto gone_bad;
1883         }
1884
1885         /* Note: data port is now the data port, not the h/w initialization
1886            port.
1887
1888            At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1889            will work. So, issue one of them, and wait for TX
1890            interrupt. This can take a *long* time after a cold boot,
1891            while the ISC ROM does its RAM test. The SDK says up to 4
1892            seconds - with 12MB of RAM on a Tropez+, it takes a lot
1893            longer than that (~16secs). Note that the card understands
1894            the difference between a warm and a cold boot, so
1895            subsequent ISC2115 reboots (say, caused by module
1896            reloading) will get through this much faster.
1897
1898            XXX Interesting question: why is no RX interrupt received first ?
1899         */
1900
1901         wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1902                                          dev->data_port, ramcheck_time*HZ);
1903
1904         if (!dev->irq_ok) {
1905                 snd_printk ("post-RAM-check interrupt not received.\n");
1906                 goto gone_bad;
1907         }
1908
1909         if (!wavefront_wait (dev, STAT_CAN_READ)) {
1910                 snd_printk ("no response to HW version cmd.\n");
1911                 goto gone_bad;
1912         }
1913
1914         if ((hwv[0] = wavefront_read (dev)) == -1) {
1915                 snd_printk ("board not responding correctly.\n");
1916                 goto gone_bad;
1917         }
1918
1919         if (hwv[0] == 0xFF) { /* NAK */
1920
1921                 /* Board's RAM test failed. Try to read error code,
1922                    and tell us about it either way.
1923                 */
1924
1925                 if ((hwv[0] = wavefront_read (dev)) == -1) {
1926                         snd_printk ("on-board RAM test failed "
1927                                     "(bad error code).\n");
1928                 } else {
1929                         snd_printk ("on-board RAM test failed "
1930                                     "(error code: 0x%x).\n",
1931                                 hwv[0]);
1932                 }
1933                 goto gone_bad;
1934         }
1935
1936         /* We're OK, just get the next byte of the HW version response */
1937
1938         if ((hwv[1] = wavefront_read (dev)) == -1) {
1939                 snd_printk ("incorrect h/w response.\n");
1940                 goto gone_bad;
1941         }
1942
1943         snd_printk ("hardware version %d.%d\n",
1944                     hwv[0], hwv[1]);
1945
1946         return 0;
1947
1948
1949      gone_bad:
1950         return (1);
1951 }
1952
1953 static int
1954 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1955
1956 {
1957         const unsigned char *buf;
1958         int len, err;
1959         int section_cnt_downloaded = 0;
1960         const struct firmware *firmware;
1961
1962         err = reject_firmware(&firmware, path, dev->card->dev);
1963         if (err < 0) {
1964                 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1965                 return 1;
1966         }
1967
1968         len = 0;
1969         buf = firmware->data;
1970         for (;;) {
1971                 int section_length = *(signed char *)buf;
1972                 if (section_length == 0)
1973                         break;
1974                 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1975                         snd_printk(KERN_ERR
1976                                    "invalid firmware section length %d\n",
1977                                    section_length);
1978                         goto failure;
1979                 }
1980                 buf++;
1981                 len++;
1982
1983                 if (firmware->size < len + section_length) {
1984                         snd_printk(KERN_ERR "firmware section read error.\n");
1985                         goto failure;
1986                 }
1987
1988                 /* Send command */
1989                 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1990                         goto failure;
1991
1992                 for (; section_length; section_length--) {
1993                         if (wavefront_write(dev, *buf))
1994                                 goto failure;
1995                         buf++;
1996                         len++;
1997                 }
1998
1999                 /* get ACK */
2000                 if (!wavefront_wait(dev, STAT_CAN_READ)) {
2001                         snd_printk(KERN_ERR "time out for firmware ACK.\n");
2002                         goto failure;
2003                 }
2004                 err = inb(dev->data_port);
2005                 if (err != WF_ACK) {
2006                         snd_printk(KERN_ERR
2007                                    "download of section #%d not "
2008                                    "acknowledged, ack = 0x%x\n",
2009                                    section_cnt_downloaded + 1, err);
2010                         goto failure;
2011                 }
2012
2013                 section_cnt_downloaded++;
2014         }
2015
2016         release_firmware(firmware);
2017         return 0;
2018
2019  failure:
2020         release_firmware(firmware);
2021         snd_printk(KERN_ERR "firmware download failed!!!\n");
2022         return 1;
2023 }
2024
2025
2026 static int
2027 wavefront_do_reset (snd_wavefront_t *dev)
2028
2029 {
2030         char voices[1];
2031
2032         if (wavefront_reset_to_cleanliness (dev)) {
2033                 snd_printk ("hw reset failed.\n");
2034                 goto gone_bad;
2035         }
2036
2037         if (dev->israw) {
2038                 if (wavefront_download_firmware (dev, ospath)) {
2039                         goto gone_bad;
2040                 }
2041
2042                 dev->israw = 0;
2043
2044                 /* Wait for the OS to get running. The protocol for
2045                    this is non-obvious, and was determined by
2046                    using port-IO tracing in DOSemu and some
2047                    experimentation here.
2048
2049                    Rather than using timed waits, use interrupts creatively.
2050                 */
2051
2052                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2053                                                   dev->data_port,
2054                                                   (osrun_time*HZ));
2055
2056                 if (!dev->irq_ok) {
2057                         snd_printk ("no post-OS interrupt.\n");
2058                         goto gone_bad;
2059                 }
2060
2061                 /* Now, do it again ! */
2062
2063                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2064                                                   dev->data_port, (10*HZ));
2065
2066                 if (!dev->irq_ok) {
2067                         snd_printk ("no post-OS interrupt(2).\n");
2068                         goto gone_bad;
2069                 }
2070
2071                 /* OK, no (RX/TX) interrupts any more, but leave mute
2072                    in effect.
2073                 */
2074
2075                 outb (0x80|0x40, dev->control_port);
2076         }
2077
2078         /* SETUPSND.EXE asks for sample memory config here, but since i
2079            have no idea how to interpret the result, we'll forget
2080            about it.
2081         */
2082
2083         if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2084                 goto gone_bad;
2085         }
2086
2087         snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2088
2089         if (wavefront_write (dev, 0xf0) ||
2090             wavefront_write (dev, 1) ||
2091             (wavefront_read (dev) < 0)) {
2092                 dev->debug = 0;
2093                 snd_printk ("MPU emulation mode not set.\n");
2094                 goto gone_bad;
2095         }
2096
2097         voices[0] = 32;
2098
2099         if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2100                 snd_printk ("cannot set number of voices to 32.\n");
2101                 goto gone_bad;
2102         }
2103
2104
2105         return 0;
2106
2107  gone_bad:
2108         /* reset that sucker so that it doesn't bother us. */
2109
2110         outb (0x0, dev->control_port);
2111         dev->interrupts_are_midi = 0;
2112         return 1;
2113 }
2114
2115 int
2116 snd_wavefront_start (snd_wavefront_t *dev)
2117
2118 {
2119         int samples_are_from_rom;
2120
2121         /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2122            wavefront_reset_to_cleanliness() has already been called
2123         */
2124
2125         if (dev->israw) {
2126                 samples_are_from_rom = 1;
2127         } else {
2128                 /* XXX is this always true ? */
2129                 samples_are_from_rom = 0;
2130         }
2131
2132         if (dev->israw || fx_raw) {
2133                 if (wavefront_do_reset (dev)) {
2134                         return -1;
2135                 }
2136         }
2137         /* Check for FX device, present only on Tropez+ */
2138
2139         dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2140
2141         if (dev->has_fx && fx_raw) {
2142                 snd_wavefront_fx_start (dev);
2143         }
2144
2145         wavefront_get_sample_status (dev, samples_are_from_rom);
2146         wavefront_get_program_status (dev);
2147         wavefront_get_patch_status (dev);
2148
2149         /* Start normal operation: unreset, master interrupt enabled, no mute
2150         */
2151
2152         outb (0x80|0x40|0x20, dev->control_port);
2153
2154         return (0);
2155 }
2156
2157 int
2158 snd_wavefront_detect (snd_wavefront_card_t *card)
2159
2160 {
2161         unsigned char   rbuf[4], wbuf[4];
2162         snd_wavefront_t *dev = &card->wavefront;
2163
2164         /* returns zero if a WaveFront card is successfully detected.
2165            negative otherwise.
2166         */
2167
2168         dev->israw = 0;
2169         dev->has_fx = 0;
2170         dev->debug = debug_default;
2171         dev->interrupts_are_midi = 0;
2172         dev->irq_cnt = 0;
2173         dev->rom_samples_rdonly = 1;
2174
2175         if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2176
2177                 dev->fw_version[0] = rbuf[0];
2178                 dev->fw_version[1] = rbuf[1];
2179
2180                 snd_printk ("firmware %d.%d already loaded.\n",
2181                             rbuf[0], rbuf[1]);
2182
2183                 /* check that a command actually works */
2184
2185                 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2186                                        rbuf, wbuf) == 0) {
2187                         dev->hw_version[0] = rbuf[0];
2188                         dev->hw_version[1] = rbuf[1];
2189                 } else {
2190                         snd_printk ("not raw, but no "
2191                                     "hardware version!\n");
2192                         return -1;
2193                 }
2194
2195                 if (!wf_raw) {
2196                         return 0;
2197                 } else {
2198                         snd_printk ("reloading firmware as you requested.\n");
2199                         dev->israw = 1;
2200                 }
2201
2202         } else {
2203
2204                 dev->israw = 1;
2205                 snd_printk ("no response to firmware probe, assume raw.\n");
2206
2207         }
2208
2209         return 0;
2210 }
2211
2212 /*(DEBLOBBED)*/