sound/isa/wavefront/wavefront_synth.c

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