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