sound/isa/wavefront/wavefront_synth.c

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