sound/isa/wavefront/wavefront_synth.c

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