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 <linux/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         if (header->number >= ARRAY_SIZE(dev->patch_status))
 789                 return -EINVAL;
 790
 791         dev->patch_status[header->number] |= WF_SLOT_FILLED;
 792
 793         bptr = buf;
 794         bptr = munge_int32 (header->number, buf, 2);
 795         munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
 796
 797         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
 798                 snd_printk ("download patch failed\n");
 799                 return -EIO;
 800         }
 801
 802         return (0);
 803 }
 804
 805 static int
 806 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
 807
 808 {
 809         unsigned char buf[WF_PROGRAM_BYTES+1];
 810         int i;
 811
 812         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
 813                 header->number);
 814
 815         if (header->number >= ARRAY_SIZE(dev->prog_status))
 816                 return -EINVAL;
 817
 818         dev->prog_status[header->number] = WF_SLOT_USED;
 819
 820         /* XXX need to zero existing SLOT_USED bit for program_status[i]
 821            where `i' is the program that's being (potentially) overwritten.
 822         */
 823
 824         for (i = 0; i < WF_NUM_LAYERS; i++) {
 825                 if (header->hdr.pr.layer[i].mute) {
 826                         dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
 827                                 WF_SLOT_USED;
 828
 829                         /* XXX need to mark SLOT_USED for sample used by
 830                            patch_number, but this means we have to load it. Ick.
 831                         */
 832                 }
 833         }
 834
 835         buf[0] = header->number;
 836         munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
 837
 838         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
 839                 snd_printk ("download patch failed\n");
 840                 return -EIO;
 841         }
 842
 843         return (0);
 844 }
 845
 846 static int
 847 wavefront_freemem (snd_wavefront_t *dev)
 848
 849 {
 850         char rbuf[8];
 851
 852         if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
 853                 snd_printk ("can't get memory stats.\n");
 854                 return -1;
 855         } else {
 856                 return demunge_int32 (rbuf, 4);
 857         }
 858 }
 859
 860 static int
 861 wavefront_send_sample (snd_wavefront_t *dev,
 862                        wavefront_patch_info *header,
 863                        u16 __user *dataptr,
 864                        int data_is_unsigned)
 865
 866 {
 867         /* samples are downloaded via a 16-bit wide i/o port
 868            (you could think of it as 2 adjacent 8-bit wide ports
 869            but its less efficient that way). therefore, all
 870            the blocksizes and so forth listed in the documentation,
 871            and used conventionally to refer to sample sizes,
 872            which are given in 8-bit units (bytes), need to be
 873            divided by 2.
 874         */
 875
 876         u16 sample_short = 0;
 877         u32 length;
 878         u16 __user *data_end = NULL;
 879         unsigned int i;
 880         const unsigned int max_blksize = 4096/2;
 881         unsigned int written;
 882         unsigned int blocksize;
 883         int dma_ack;
 884         int blocknum;
 885         unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
 886         unsigned char *shptr;
 887         int skip = 0;
 888         int initial_skip = 0;
 889
 890         DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
 891                                       "type %d, %d bytes from 0x%lx\n",
 892                                       header->size ? "" : "header ",
 893                                       header->number, header->subkey,
 894                                       header->size,
 895                                       (unsigned long) header->dataptr);
 896
 897         if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
 898                 int x;
 899
 900                 if ((x = wavefront_find_free_sample (dev)) < 0) {
 901                         return -ENOMEM;
 902                 }
 903                 snd_printk ("unspecified sample => %d\n", x);
 904                 header->number = x;
 905         }
 906
 907         if (header->number >= WF_MAX_SAMPLE)
 908                 return -EINVAL;
 909
 910         if (header->size) {
 911
 912                 /* XXX it's a debatable point whether or not RDONLY semantics
 913                    on the ROM samples should cover just the sample data or
 914                    the sample header. For now, it only covers the sample data,
 915                    so anyone is free at all times to rewrite sample headers.
 916
 917                    My reason for this is that we have the sample headers
 918                    available in the WFB file for General MIDI, and so these
 919                    can always be reset if needed. The sample data, however,
 920                    cannot be recovered without a complete reset and firmware
 921                    reload of the ICS2115, which is a very expensive operation.
 922
 923                    So, doing things this way allows us to honor the notion of
 924                    "RESETSAMPLES" reasonably cheaply. Note however, that this
 925                    is done purely at user level: there is no WFB parser in
 926                    this driver, and so a complete reset (back to General MIDI,
 927                    or theoretically some other configuration) is the
 928                    responsibility of the user level library.
 929
 930                    To try to do this in the kernel would be a little
 931                    crazy: we'd need 158K of kernel space just to hold
 932                    a copy of the patch/program/sample header data.
 933                 */
 934
 935                 if (dev->rom_samples_rdonly) {
 936                         if (dev->sample_status[header->number] & WF_SLOT_ROM) {
 937                                 snd_printk ("sample slot %d "
 938                                             "write protected\n",
 939                                             header->number);
 940                                 return -EACCES;
 941                         }
 942                 }
 943
 944                 wavefront_delete_sample (dev, header->number);
 945         }
 946
 947         if (header->size) {
 948                 dev->freemem = wavefront_freemem (dev);
 949
 950                 if (dev->freemem < (int)header->size) {
 951                         snd_printk ("insufficient memory to "
 952                                     "load %d byte sample.\n",
 953                                     header->size);
 954                         return -ENOMEM;
 955                 }
 956
 957         }
 958
 959         skip = WF_GET_CHANNEL(&header->hdr.s);
 960
 961         if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
 962                 snd_printk ("channel selection only "
 963                             "possible on 16-bit samples");
 964                 return -EINVAL;
 965         }
 966
 967         switch (skip) {
 968         case 0:
 969                 initial_skip = 0;
 970                 skip = 1;
 971                 break;
 972         case 1:
 973                 initial_skip = 0;
 974                 skip = 2;
 975                 break;
 976         case 2:
 977                 initial_skip = 1;
 978                 skip = 2;
 979                 break;
 980         case 3:
 981                 initial_skip = 2;
 982                 skip = 3;
 983                 break;
 984         case 4:
 985                 initial_skip = 3;
 986                 skip = 4;
 987                 break;
 988         case 5:
 989                 initial_skip = 4;
 990                 skip = 5;
 991                 break;
 992         case 6:
 993                 initial_skip = 5;
 994                 skip = 6;
 995                 break;
 996         }
 997
 998         DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
 999                                       "initial skip = %d, skip = %d\n",
1000                                       WF_GET_CHANNEL (&header->hdr.s),
1001                                       initial_skip, skip);
1002
1003         /* Be safe, and zero the "Unused" bits ... */
1004
1005         WF_SET_CHANNEL(&header->hdr.s, 0);
1006
1007         /* adjust size for 16 bit samples by dividing by two.  We always
1008            send 16 bits per write, even for 8 bit samples, so the length
1009            is always half the size of the sample data in bytes.
1010         */
1011
1012         length = header->size / 2;
1013
1014         /* the data we're sent has not been munged, and in fact, the
1015            header we have to send isn't just a munged copy either.
1016            so, build the sample header right here.
1017         */
1018
1019         shptr = &sample_hdr[0];
1020
1021         shptr = munge_int32 (header->number, shptr, 2);
1022
1023         if (header->size) {
1024                 shptr = munge_int32 (length, shptr, 4);
1025         }
1026
1027         /* Yes, a 4 byte result doesn't contain all of the offset bits,
1028            but the offset only uses 24 bits.
1029         */
1030
1031         shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1032                              shptr, 4);
1033         shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1034                              shptr, 4);
1035         shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1036                              shptr, 4);
1037         shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1038                              shptr, 4);
1039
1040         /* This one is truly weird. What kind of weirdo decided that in
1041            a system dominated by 16 and 32 bit integers, they would use
1042            a just 12 bits ?
1043         */
1044
1045         shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1046
1047         /* Why is this nybblified, when the MSB is *always* zero ?
1048            Anyway, we can't take address of bitfield, so make a
1049            good-faith guess at where it starts.
1050         */
1051
1052         shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1053                              shptr, 2);
1054
1055         if (snd_wavefront_cmd (dev,
1056                            header->size ?
1057                            WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1058                            NULL, sample_hdr)) {
1059                 snd_printk ("sample %sdownload refused.\n",
1060                             header->size ? "" : "header ");
1061                 return -EIO;
1062         }
1063
1064         if (header->size == 0) {
1065                 goto sent; /* Sorry. Just had to have one somewhere */
1066         }
1067
1068         data_end = dataptr + length;
1069
1070         /* Do any initial skip over an unused channel's data */
1071
1072         dataptr += initial_skip;
1073
1074         for (written = 0, blocknum = 0;
1075              written < length; written += max_blksize, blocknum++) {
1076
1077                 if ((length - written) > max_blksize) {
1078                         blocksize = max_blksize;
1079                 } else {
1080                         /* round to nearest 16-byte value */
1081                         blocksize = ALIGN(length - written, 8);
1082                 }
1083
1084                 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1085                         snd_printk ("download block "
1086                                     "request refused.\n");
1087                         return -EIO;
1088                 }
1089
1090                 for (i = 0; i < blocksize; i++) {
1091
1092                         if (dataptr < data_end) {
1093
1094                                 __get_user (sample_short, dataptr);
1095                                 dataptr += skip;
1096
1097                                 if (data_is_unsigned) { /* GUS ? */
1098
1099                                         if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1100
1101                                                 /* 8 bit sample
1102                                                  resolution, sign
1103                                                  extend both bytes.
1104                                                 */
1105
1106                                                 ((unsigned char*)
1107                                                  &sample_short)[0] += 0x7f;
1108                                                 ((unsigned char*)
1109                                                  &sample_short)[1] += 0x7f;
1110
1111                                         } else {
1112
1113                                                 /* 16 bit sample
1114                                                  resolution, sign
1115                                                  extend the MSB.
1116                                                 */
1117
1118                                                 sample_short += 0x7fff;
1119                                         }
1120                                 }
1121
1122                         } else {
1123
1124                                 /* In padding section of final block:
1125
1126                                    Don't fetch unsupplied data from
1127                                    user space, just continue with
1128                                    whatever the final value was.
1129                                 */
1130                         }
1131
1132                         if (i < blocksize - 1) {
1133                                 outw (sample_short, dev->block_port);
1134                         } else {
1135                                 outw (sample_short, dev->last_block_port);
1136                         }
1137                 }
1138
1139                 /* Get "DMA page acknowledge", even though its really
1140                    nothing to do with DMA at all.
1141                 */
1142
1143                 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1144                         if (dma_ack == -1) {
1145                                 snd_printk ("upload sample "
1146                                             "DMA ack timeout\n");
1147                                 return -EIO;
1148                         } else {
1149                                 snd_printk ("upload sample "
1150                                             "DMA ack error 0x%x\n",
1151                                             dma_ack);
1152                                 return -EIO;
1153                         }
1154                 }
1155         }
1156
1157         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1158
1159         /* Note, label is here because sending the sample header shouldn't
1160            alter the sample_status info at all.
1161         */
1162
1163  sent:
1164         return (0);
1165 }
1166
1167 static int
1168 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1169
1170 {
1171         unsigned char alias_hdr[WF_ALIAS_BYTES];
1172
1173         DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1174                                       "alias for %d\n",
1175                                       header->number,
1176                                       header->hdr.a.OriginalSample);
1177
1178         munge_int32 (header->number, &alias_hdr[0], 2);
1179         munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1180         munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1181                      &alias_hdr[4], 4);
1182         munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1183                      &alias_hdr[8], 4);
1184         munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1185                      &alias_hdr[12], 4);
1186         munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1187                      &alias_hdr[16], 4);
1188         munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1189         munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1190
1191         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1192                 snd_printk ("download alias failed.\n");
1193                 return -EIO;
1194         }
1195
1196         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1197
1198         return (0);
1199 }
1200
1201 static int
1202 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1203 {
1204         int i;
1205         int num_samples;
1206         unsigned char *msample_hdr;
1207
1208         msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1209         if (! msample_hdr)
1210                 return -ENOMEM;
1211
1212         munge_int32 (header->number, &msample_hdr[0], 2);
1213
1214         /* You'll recall at this point that the "number of samples" value
1215            in a wavefront_multisample struct is actually the log2 of the
1216            real number of samples.
1217         */
1218
1219         num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1220         msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1221
1222         DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1223                                       header->number,
1224                                       header->hdr.ms.NumberOfSamples,
1225                                       num_samples);
1226
1227         for (i = 0; i < num_samples; i++) {
1228                 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1229                        i, header->hdr.ms.SampleNumber[i]);
1230                 munge_int32 (header->hdr.ms.SampleNumber[i],
1231                      &msample_hdr[3+(i*2)], 2);
1232         }
1233
1234         /* Need a hack here to pass in the number of bytes
1235            to be written to the synth. This is ugly, and perhaps
1236            one day, I'll fix it.
1237         */
1238
1239         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1240                            (unsigned char *) (long) ((num_samples*2)+3),
1241                            msample_hdr)) {
1242                 snd_printk ("download of multisample failed.\n");
1243                 kfree(msample_hdr);
1244                 return -EIO;
1245         }
1246
1247         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1248
1249         kfree(msample_hdr);
1250         return (0);
1251 }
1252
1253 static int
1254 wavefront_fetch_multisample (snd_wavefront_t *dev,
1255                              wavefront_patch_info *header)
1256 {
1257         int i;
1258         unsigned char log_ns[1];
1259         unsigned char number[2];
1260         int num_samples;
1261
1262         munge_int32 (header->number, number, 2);
1263
1264         if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1265                 snd_printk ("upload multisample failed.\n");
1266                 return -EIO;
1267         }
1268
1269         DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1270                                 header->number, log_ns[0]);
1271
1272         header->hdr.ms.NumberOfSamples = log_ns[0];
1273
1274         /* get the number of samples ... */
1275
1276         num_samples = (1 << log_ns[0]);
1277
1278         for (i = 0; i < num_samples; i++) {
1279                 char d[2];
1280                 int val;
1281
1282                 if ((val = wavefront_read (dev)) == -1) {
1283                         snd_printk ("upload multisample failed "
1284                                     "during sample loop.\n");
1285                         return -EIO;
1286                 }
1287                 d[0] = val;
1288
1289                 if ((val = wavefront_read (dev)) == -1) {
1290                         snd_printk ("upload multisample failed "
1291                                     "during sample loop.\n");
1292                         return -EIO;
1293                 }
1294                 d[1] = val;
1295
1296                 header->hdr.ms.SampleNumber[i] =
1297                         demunge_int32 ((unsigned char *) d, 2);
1298
1299                 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1300                                         i, header->hdr.ms.SampleNumber[i]);
1301         }
1302
1303         return (0);
1304 }
1305
1306
1307 static int
1308 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1309
1310 {
1311         unsigned char drumbuf[WF_DRUM_BYTES];
1312         wavefront_drum *drum = &header->hdr.d;
1313         int i;
1314
1315         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1316                 "note %d, patch = %d\n",
1317                 header->number, drum->PatchNumber);
1318
1319         drumbuf[0] = header->number & 0x7f;
1320
1321         for (i = 0; i < 4; i++) {
1322                 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1323         }
1324
1325         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1326                 snd_printk ("download drum failed.\n");
1327                 return -EIO;
1328         }
1329
1330         return (0);
1331 }
1332
1333 static int
1334 wavefront_find_free_sample (snd_wavefront_t *dev)
1335
1336 {
1337         int i;
1338
1339         for (i = 0; i < WF_MAX_SAMPLE; i++) {
1340                 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1341                         return i;
1342                 }
1343         }
1344         snd_printk ("no free sample slots!\n");
1345         return -1;
1346 }
1347
1348 #if 0
1349 static int
1350 wavefront_find_free_patch (snd_wavefront_t *dev)
1351
1352 {
1353         int i;
1354
1355         for (i = 0; i < WF_MAX_PATCH; i++) {
1356                 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1357                         return i;
1358                 }
1359         }
1360         snd_printk ("no free patch slots!\n");
1361         return -1;
1362 }
1363 #endif
1364
1365 static int
1366 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1367 {
1368         wavefront_patch_info *header;
1369         int err;
1370
1371         header = kmalloc(sizeof(*header), GFP_KERNEL);
1372         if (! header)
1373                 return -ENOMEM;
1374
1375         if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1376                             sizeof(wavefront_any))) {
1377                 snd_printk ("bad address for load patch.\n");
1378                 err = -EFAULT;
1379                 goto __error;
1380         }
1381
1382         DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1383                                       "Sample type: %d "
1384                                       "Sample number: %d "
1385                                       "Sample size: %d\n",
1386                                       header->subkey,
1387                                       header->number,
1388                                       header->size);
1389
1390         switch (header->subkey) {
1391         case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */
1392
1393                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1394                                     sizeof (wavefront_sample))) {
1395                         err = -EFAULT;
1396                         break;
1397                 }
1398
1399                 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1400                 break;
1401
1402         case WF_ST_MULTISAMPLE:
1403
1404                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1405                                     sizeof (wavefront_multisample))) {
1406                         err = -EFAULT;
1407                         break;
1408                 }
1409
1410                 err = wavefront_send_multisample (dev, header);
1411                 break;
1412
1413         case WF_ST_ALIAS:
1414
1415                 if (copy_from_user (&header->hdr.a, header->hdrptr,
1416                                     sizeof (wavefront_alias))) {
1417                         err = -EFAULT;
1418                         break;
1419                 }
1420
1421                 err = wavefront_send_alias (dev, header);
1422                 break;
1423
1424         case WF_ST_DRUM:
1425                 if (copy_from_user (&header->hdr.d, header->hdrptr,
1426                                     sizeof (wavefront_drum))) {
1427                         err = -EFAULT;
1428                         break;
1429                 }
1430
1431                 err = wavefront_send_drum (dev, header);
1432                 break;
1433
1434         case WF_ST_PATCH:
1435                 if (copy_from_user (&header->hdr.p, header->hdrptr,
1436                                     sizeof (wavefront_patch))) {
1437                         err = -EFAULT;
1438                         break;
1439                 }
1440
1441                 err = wavefront_send_patch (dev, header);
1442                 break;
1443
1444         case WF_ST_PROGRAM:
1445                 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1446                                     sizeof (wavefront_program))) {
1447                         err = -EFAULT;
1448                         break;
1449                 }
1450
1451                 err = wavefront_send_program (dev, header);
1452                 break;
1453
1454         default:
1455                 snd_printk ("unknown patch type %d.\n",
1456                             header->subkey);
1457                 err = -EINVAL;
1458                 break;
1459         }
1460
1461  __error:
1462         kfree(header);
1463         return err;
1464 }
1465 \f
1466 /***********************************************************************
1467 WaveFront: hardware-dependent interface
1468 ***********************************************************************/
1469
1470 static void
1471 process_sample_hdr (u8 *buf)
1472
1473 {
1474         wavefront_sample s;
1475         u8 *ptr;
1476
1477         ptr = buf;
1478
1479         /* The board doesn't send us an exact copy of a "wavefront_sample"
1480            in response to an Upload Sample Header command. Instead, we
1481            have to convert the data format back into our data structure,
1482            just as in the Download Sample command, where we have to do
1483            something very similar in the reverse direction.
1484         */
1485
1486         *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1487         *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1488         *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1489         *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1490         *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1491
1492         s.SampleResolution = *ptr & 0x3;
1493         s.Loop = *ptr & 0x8;
1494         s.Bidirectional = *ptr & 0x10;
1495         s.Reverse = *ptr & 0x40;
1496
1497         /* Now copy it back to where it came from */
1498
1499         memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1500 }
1501
1502 static int
1503 wavefront_synth_control (snd_wavefront_card_t *acard,
1504                          wavefront_control *wc)
1505
1506 {
1507         snd_wavefront_t *dev = &acard->wavefront;
1508         unsigned char patchnumbuf[2];
1509         int i;
1510
1511         DPRINT (WF_DEBUG_CMD, "synth control with "
1512                 "cmd 0x%x\n", wc->cmd);
1513
1514         /* Pre-handling of or for various commands */
1515
1516         switch (wc->cmd) {
1517
1518         case WFC_DISABLE_INTERRUPTS:
1519                 snd_printk ("interrupts disabled.\n");
1520                 outb (0x80|0x20, dev->control_port);
1521                 dev->interrupts_are_midi = 1;
1522                 return 0;
1523
1524         case WFC_ENABLE_INTERRUPTS:
1525                 snd_printk ("interrupts enabled.\n");
1526                 outb (0x80|0x40|0x20, dev->control_port);
1527                 dev->interrupts_are_midi = 1;
1528                 return 0;
1529
1530         case WFC_INTERRUPT_STATUS:
1531                 wc->rbuf[0] = dev->interrupts_are_midi;
1532                 return 0;
1533
1534         case WFC_ROMSAMPLES_RDONLY:
1535                 dev->rom_samples_rdonly = wc->wbuf[0];
1536                 wc->status = 0;
1537                 return 0;
1538
1539         case WFC_IDENTIFY_SLOT_TYPE:
1540                 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1541                 if (i <0 || i >= WF_MAX_SAMPLE) {
1542                         snd_printk ("invalid slot ID %d\n",
1543                                 i);
1544                         wc->status = EINVAL;
1545                         return -EINVAL;
1546                 }
1547                 wc->rbuf[0] = dev->sample_status[i];
1548                 wc->status = 0;
1549                 return 0;
1550
1551         case WFC_DEBUG_DRIVER:
1552                 dev->debug = wc->wbuf[0];
1553                 snd_printk ("debug = 0x%x\n", dev->debug);
1554                 return 0;
1555
1556         case WFC_UPLOAD_PATCH:
1557                 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1558                 memcpy (wc->wbuf, patchnumbuf, 2);
1559                 break;
1560
1561         case WFC_UPLOAD_MULTISAMPLE:
1562                 /* multisamples have to be handled differently, and
1563                    cannot be dealt with properly by snd_wavefront_cmd() alone.
1564                 */
1565                 wc->status = wavefront_fetch_multisample
1566                         (dev, (wavefront_patch_info *) wc->rbuf);
1567                 return 0;
1568
1569         case WFC_UPLOAD_SAMPLE_ALIAS:
1570                 snd_printk ("support for sample alias upload "
1571                         "being considered.\n");
1572                 wc->status = EINVAL;
1573                 return -EINVAL;
1574         }
1575
1576         wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1577
1578         /* Post-handling of certain commands.
1579
1580            In particular, if the command was an upload, demunge the data
1581            so that the user-level doesn't have to think about it.
1582         */
1583
1584         if (wc->status == 0) {
1585                 switch (wc->cmd) {
1586                         /* intercept any freemem requests so that we know
1587                            we are always current with the user-level view
1588                            of things.
1589                         */
1590
1591                 case WFC_REPORT_FREE_MEMORY:
1592                         dev->freemem = demunge_int32 (wc->rbuf, 4);
1593                         break;
1594
1595                 case WFC_UPLOAD_PATCH:
1596                         demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1597                         break;
1598
1599                 case WFC_UPLOAD_PROGRAM:
1600                         demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1601                         break;
1602
1603                 case WFC_UPLOAD_EDRUM_PROGRAM:
1604                         demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1605                         break;
1606
1607                 case WFC_UPLOAD_SAMPLE_HEADER:
1608                         process_sample_hdr (wc->rbuf);
1609                         break;
1610
1611                 case WFC_UPLOAD_SAMPLE_ALIAS:
1612                         snd_printk ("support for "
1613                                     "sample aliases still "
1614                                     "being considered.\n");
1615                         break;
1616
1617                 case WFC_VMIDI_OFF:
1618                         snd_wavefront_midi_disable_virtual (acard);
1619                         break;
1620
1621                 case WFC_VMIDI_ON:
1622                         snd_wavefront_midi_enable_virtual (acard);
1623                         break;
1624                 }
1625         }
1626
1627         return 0;
1628 }
1629
1630 int
1631 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1632
1633 {
1634         if (!try_module_get(hw->card->module))
1635                 return -EFAULT;
1636         file->private_data = hw;
1637         return 0;
1638 }
1639
1640 int
1641 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1642
1643 {
1644         module_put(hw->card->module);
1645         return 0;
1646 }
1647
1648 int
1649 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1650                            unsigned int cmd, unsigned long arg)
1651
1652 {
1653         struct snd_card *card;
1654         snd_wavefront_t *dev;
1655         snd_wavefront_card_t *acard;
1656         wavefront_control *wc;
1657         void __user *argp = (void __user *)arg;
1658         int err;
1659
1660         card = (struct snd_card *) hw->card;
1661
1662         if (snd_BUG_ON(!card))
1663                 return -ENODEV;
1664         if (snd_BUG_ON(!card->private_data))
1665                 return -ENODEV;
1666
1667         acard = card->private_data;
1668         dev = &acard->wavefront;
1669
1670         switch (cmd) {
1671         case WFCTL_LOAD_SPP:
1672                 if (wavefront_load_patch (dev, argp) != 0) {
1673                         return -EIO;
1674                 }
1675                 break;
1676
1677         case WFCTL_WFCMD:
1678                 wc = memdup_user(argp, sizeof(*wc));
1679                 if (IS_ERR(wc))
1680                         return PTR_ERR(wc);
1681
1682                 if (wavefront_synth_control (acard, wc) < 0)
1683                         err = -EIO;
1684                 else if (copy_to_user (argp, wc, sizeof (*wc)))
1685                         err = -EFAULT;
1686                 else
1687                         err = 0;
1688                 kfree(wc);
1689                 return err;
1690
1691         default:
1692                 return -EINVAL;
1693         }
1694
1695         return 0;
1696 }
1697
1698 \f
1699 /***********************************************************************/
1700 /*  WaveFront: interface for card-level wavefront module               */
1701 /***********************************************************************/
1702
1703 void
1704 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1705 {
1706         snd_wavefront_t *dev = &card->wavefront;
1707
1708         /*
1709            Some comments on interrupts. I attempted a version of this
1710            driver that used interrupts throughout the code instead of
1711            doing busy and/or sleep-waiting. Alas, it appears that once
1712            the Motorola firmware is downloaded, the card *never*
1713            generates an RX interrupt. These are successfully generated
1714            during firmware loading, and after that wavefront_status()
1715            reports that an interrupt is pending on the card from time
1716            to time, but it never seems to be delivered to this
1717            driver. Note also that wavefront_status() continues to
1718            report that RX interrupts are enabled, suggesting that I
1719            didn't goof up and disable them by mistake.
1720
1721            Thus, I stepped back to a prior version of
1722            wavefront_wait(), the only place where this really
1723            matters. Its sad, but I've looked through the code to check
1724            on things, and I really feel certain that the Motorola
1725            firmware prevents RX-ready interrupts.
1726         */
1727
1728         if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1729                 return;
1730         }
1731
1732         spin_lock(&dev->irq_lock);
1733         dev->irq_ok = 1;
1734         dev->irq_cnt++;
1735         spin_unlock(&dev->irq_lock);
1736         wake_up(&dev->interrupt_sleeper);
1737 }
1738
1739 /* STATUS REGISTER
1740
1741 0 Host Rx Interrupt Enable (1=Enabled)
1742 1 Host Rx Register Full (1=Full)
1743 2 Host Rx Interrupt Pending (1=Interrupt)
1744 3 Unused
1745 4 Host Tx Interrupt (1=Enabled)
1746 5 Host Tx Register empty (1=Empty)
1747 6 Host Tx Interrupt Pending (1=Interrupt)
1748 7 Unused
1749 */
1750
1751 static int
1752 snd_wavefront_interrupt_bits (int irq)
1753
1754 {
1755         int bits;
1756
1757         switch (irq) {
1758         case 9:
1759                 bits = 0x00;
1760                 break;
1761         case 5:
1762                 bits = 0x08;
1763                 break;
1764         case 12:
1765                 bits = 0x10;
1766                 break;
1767         case 15:
1768                 bits = 0x18;
1769                 break;
1770
1771         default:
1772                 snd_printk ("invalid IRQ %d\n", irq);
1773                 bits = -1;
1774         }
1775
1776         return bits;
1777 }
1778
1779 static void
1780 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1781                                   int val, int port, unsigned long timeout)
1782
1783 {
1784         wait_queue_t wait;
1785
1786         init_waitqueue_entry(&wait, current);
1787         spin_lock_irq(&dev->irq_lock);
1788         add_wait_queue(&dev->interrupt_sleeper, &wait);
1789         dev->irq_ok = 0;
1790         outb (val,port);
1791         spin_unlock_irq(&dev->irq_lock);
1792         while (!dev->irq_ok && time_before(jiffies, timeout)) {
1793                 schedule_timeout_uninterruptible(1);
1794                 barrier();
1795         }
1796 }
1797
1798 static int
1799 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1800
1801 {
1802         int bits;
1803         int hwv[2];
1804
1805         /* IRQ already checked */
1806
1807         bits = snd_wavefront_interrupt_bits (dev->irq);
1808
1809         /* try reset of port */
1810
1811         outb (0x0, dev->control_port);
1812
1813         /* At this point, the board is in reset, and the H/W initialization
1814            register is accessed at the same address as the data port.
1815
1816            Bit 7 - Enable IRQ Driver
1817            0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1818            1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1819
1820            Bit 6 - MIDI Interface Select
1821
1822            0 - Use the MIDI Input from the 26-pin WaveBlaster
1823            compatible header as the serial MIDI source
1824            1 - Use the MIDI Input from the 9-pin D connector as the
1825            serial MIDI source.
1826
1827            Bits 5:3 - IRQ Selection
1828            0 0 0 - IRQ 2/9
1829            0 0 1 - IRQ 5
1830            0 1 0 - IRQ 12
1831            0 1 1 - IRQ 15
1832            1 0 0 - Reserved
1833            1 0 1 - Reserved
1834            1 1 0 - Reserved
1835            1 1 1 - Reserved
1836
1837            Bits 2:1 - Reserved
1838            Bit 0 - Disable Boot ROM
1839            0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1840            1 - memory accesses to 03FC30-03FFFFH are directed to external
1841            storage.
1842
1843         */
1844
1845         /* configure hardware: IRQ, enable interrupts,
1846            plus external 9-pin MIDI interface selected
1847         */
1848
1849         outb (0x80 | 0x40 | bits, dev->data_port);
1850
1851         /* CONTROL REGISTER
1852
1853            0 Host Rx Interrupt Enable (1=Enabled)      0x1
1854            1 Unused                                    0x2
1855            2 Unused                                    0x4
1856            3 Unused                                    0x8
1857            4 Host Tx Interrupt Enable                 0x10
1858            5 Mute (0=Mute; 1=Play)                    0x20
1859            6 Master Interrupt Enable (1=Enabled)      0x40
1860            7 Master Reset (0=Reset; 1=Run)            0x80
1861
1862            Take us out of reset, mute output, master + TX + RX interrupts on.
1863
1864            We'll get an interrupt presumably to tell us that the TX
1865            register is clear.
1866         */
1867
1868         wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1869                                          dev->control_port,
1870                                          (reset_time*HZ)/100);
1871
1872         /* Note: data port is now the data port, not the h/w initialization
1873            port.
1874          */
1875
1876         if (!dev->irq_ok) {
1877                 snd_printk ("intr not received after h/w un-reset.\n");
1878                 goto gone_bad;
1879         }
1880
1881         /* Note: data port is now the data port, not the h/w initialization
1882            port.
1883
1884            At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1885            will work. So, issue one of them, and wait for TX
1886            interrupt. This can take a *long* time after a cold boot,
1887            while the ISC ROM does its RAM test. The SDK says up to 4
1888            seconds - with 12MB of RAM on a Tropez+, it takes a lot
1889            longer than that (~16secs). Note that the card understands
1890            the difference between a warm and a cold boot, so
1891            subsequent ISC2115 reboots (say, caused by module
1892            reloading) will get through this much faster.
1893
1894            XXX Interesting question: why is no RX interrupt received first ?
1895         */
1896
1897         wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1898                                          dev->data_port, ramcheck_time*HZ);
1899
1900         if (!dev->irq_ok) {
1901                 snd_printk ("post-RAM-check interrupt not received.\n");
1902                 goto gone_bad;
1903         }
1904
1905         if (!wavefront_wait (dev, STAT_CAN_READ)) {
1906                 snd_printk ("no response to HW version cmd.\n");
1907                 goto gone_bad;
1908         }
1909
1910         if ((hwv[0] = wavefront_read (dev)) == -1) {
1911                 snd_printk ("board not responding correctly.\n");
1912                 goto gone_bad;
1913         }
1914
1915         if (hwv[0] == 0xFF) { /* NAK */
1916
1917                 /* Board's RAM test failed. Try to read error code,
1918                    and tell us about it either way.
1919                 */
1920
1921                 if ((hwv[0] = wavefront_read (dev)) == -1) {
1922                         snd_printk ("on-board RAM test failed "
1923                                     "(bad error code).\n");
1924                 } else {
1925                         snd_printk ("on-board RAM test failed "
1926                                     "(error code: 0x%x).\n",
1927                                 hwv[0]);
1928                 }
1929                 goto gone_bad;
1930         }
1931
1932         /* We're OK, just get the next byte of the HW version response */
1933
1934         if ((hwv[1] = wavefront_read (dev)) == -1) {
1935                 snd_printk ("incorrect h/w response.\n");
1936                 goto gone_bad;
1937         }
1938
1939         snd_printk ("hardware version %d.%d\n",
1940                     hwv[0], hwv[1]);
1941
1942         return 0;
1943
1944
1945      gone_bad:
1946         return (1);
1947 }
1948
1949 static int
1950 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1951
1952 {
1953         const unsigned char *buf;
1954         int len, err;
1955         int section_cnt_downloaded = 0;
1956         const struct firmware *firmware;
1957
1958         err = request_firmware(&firmware, path, dev->card->dev);
1959         if (err < 0) {
1960                 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1961                 return 1;
1962         }
1963
1964         len = 0;
1965         buf = firmware->data;
1966         for (;;) {
1967                 int section_length = *(signed char *)buf;
1968                 if (section_length == 0)
1969                         break;
1970                 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1971                         snd_printk(KERN_ERR
1972                                    "invalid firmware section length %d\n",
1973                                    section_length);
1974                         goto failure;
1975                 }
1976                 buf++;
1977                 len++;
1978
1979                 if (firmware->size < len + section_length) {
1980                         snd_printk(KERN_ERR "firmware section read error.\n");
1981                         goto failure;
1982                 }
1983
1984                 /* Send command */
1985                 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1986                         goto failure;
1987
1988                 for (; section_length; section_length--) {
1989                         if (wavefront_write(dev, *buf))
1990                                 goto failure;
1991                         buf++;
1992                         len++;
1993                 }
1994
1995                 /* get ACK */
1996                 if (!wavefront_wait(dev, STAT_CAN_READ)) {
1997                         snd_printk(KERN_ERR "time out for firmware ACK.\n");
1998                         goto failure;
1999                 }
2000                 err = inb(dev->data_port);
2001                 if (err != WF_ACK) {
2002                         snd_printk(KERN_ERR
2003                                    "download of section #%d not "
2004                                    "acknowledged, ack = 0x%x\n",
2005                                    section_cnt_downloaded + 1, err);
2006                         goto failure;
2007                 }
2008
2009                 section_cnt_downloaded++;
2010         }
2011
2012         release_firmware(firmware);
2013         return 0;
2014
2015  failure:
2016         release_firmware(firmware);
2017         snd_printk(KERN_ERR "firmware download failed!!!\n");
2018         return 1;
2019 }
2020
2021
2022 static int
2023 wavefront_do_reset (snd_wavefront_t *dev)
2024
2025 {
2026         char voices[1];
2027
2028         if (wavefront_reset_to_cleanliness (dev)) {
2029                 snd_printk ("hw reset failed.\n");
2030                 goto gone_bad;
2031         }
2032
2033         if (dev->israw) {
2034                 if (wavefront_download_firmware (dev, ospath)) {
2035                         goto gone_bad;
2036                 }
2037
2038                 dev->israw = 0;
2039
2040                 /* Wait for the OS to get running. The protocol for
2041                    this is non-obvious, and was determined by
2042                    using port-IO tracing in DOSemu and some
2043                    experimentation here.
2044
2045                    Rather than using timed waits, use interrupts creatively.
2046                 */
2047
2048                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2049                                                   dev->data_port,
2050                                                   (osrun_time*HZ));
2051
2052                 if (!dev->irq_ok) {
2053                         snd_printk ("no post-OS interrupt.\n");
2054                         goto gone_bad;
2055                 }
2056
2057                 /* Now, do it again ! */
2058
2059                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2060                                                   dev->data_port, (10*HZ));
2061
2062                 if (!dev->irq_ok) {
2063                         snd_printk ("no post-OS interrupt(2).\n");
2064                         goto gone_bad;
2065                 }
2066
2067                 /* OK, no (RX/TX) interrupts any more, but leave mute
2068                    in effect.
2069                 */
2070
2071                 outb (0x80|0x40, dev->control_port);
2072         }
2073
2074         /* SETUPSND.EXE asks for sample memory config here, but since i
2075            have no idea how to interpret the result, we'll forget
2076            about it.
2077         */
2078
2079         if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2080                 goto gone_bad;
2081         }
2082
2083         snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2084
2085         if (wavefront_write (dev, 0xf0) ||
2086             wavefront_write (dev, 1) ||
2087             (wavefront_read (dev) < 0)) {
2088                 dev->debug = 0;
2089                 snd_printk ("MPU emulation mode not set.\n");
2090                 goto gone_bad;
2091         }
2092
2093         voices[0] = 32;
2094
2095         if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2096                 snd_printk ("cannot set number of voices to 32.\n");
2097                 goto gone_bad;
2098         }
2099
2100
2101         return 0;
2102
2103  gone_bad:
2104         /* reset that sucker so that it doesn't bother us. */
2105
2106         outb (0x0, dev->control_port);
2107         dev->interrupts_are_midi = 0;
2108         return 1;
2109 }
2110
2111 int
2112 snd_wavefront_start (snd_wavefront_t *dev)
2113
2114 {
2115         int samples_are_from_rom;
2116
2117         /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2118            wavefront_reset_to_cleanliness() has already been called
2119         */
2120
2121         if (dev->israw) {
2122                 samples_are_from_rom = 1;
2123         } else {
2124                 /* XXX is this always true ? */
2125                 samples_are_from_rom = 0;
2126         }
2127
2128         if (dev->israw || fx_raw) {
2129                 if (wavefront_do_reset (dev)) {
2130                         return -1;
2131                 }
2132         }
2133         /* Check for FX device, present only on Tropez+ */
2134
2135         dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2136
2137         if (dev->has_fx && fx_raw) {
2138                 snd_wavefront_fx_start (dev);
2139         }
2140
2141         wavefront_get_sample_status (dev, samples_are_from_rom);
2142         wavefront_get_program_status (dev);
2143         wavefront_get_patch_status (dev);
2144
2145         /* Start normal operation: unreset, master interrupt enabled, no mute
2146         */
2147
2148         outb (0x80|0x40|0x20, dev->control_port);
2149
2150         return (0);
2151 }
2152
2153 int
2154 snd_wavefront_detect (snd_wavefront_card_t *card)
2155
2156 {
2157         unsigned char   rbuf[4], wbuf[4];
2158         snd_wavefront_t *dev = &card->wavefront;
2159
2160         /* returns zero if a WaveFront card is successfully detected.
2161            negative otherwise.
2162         */
2163
2164         dev->israw = 0;
2165         dev->has_fx = 0;
2166         dev->debug = debug_default;
2167         dev->interrupts_are_midi = 0;
2168         dev->irq_cnt = 0;
2169         dev->rom_samples_rdonly = 1;
2170
2171         if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2172
2173                 dev->fw_version[0] = rbuf[0];
2174                 dev->fw_version[1] = rbuf[1];
2175
2176                 snd_printk ("firmware %d.%d already loaded.\n",
2177                             rbuf[0], rbuf[1]);
2178
2179                 /* check that a command actually works */
2180
2181                 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2182                                        rbuf, wbuf) == 0) {
2183                         dev->hw_version[0] = rbuf[0];
2184                         dev->hw_version[1] = rbuf[1];
2185                 } else {
2186                         snd_printk ("not raw, but no "
2187                                     "hardware version!\n");
2188                         return -1;
2189                 }
2190
2191                 if (!wf_raw) {
2192                         return 0;
2193                 } else {
2194                         snd_printk ("reloading firmware as you requested.\n");
2195                         dev->israw = 1;
2196                 }
2197
2198         } else {
2199
2200                 dev->israw = 1;
2201                 snd_printk ("no response to firmware probe, assume raw.\n");
2202
2203         }
2204
2205         return 0;
2206 }
2207
2208 MODULE_FIRMWARE(DEFAULT_OSPATH);