sound/isa/wavefront/wavefront_synth.c

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