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