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                                 if (get_user(sample_short, dataptr))
1095                                         return -EFAULT;
1096                                 dataptr += skip;
1097
1098                                 if (data_is_unsigned) { /* GUS ? */
1099
1100                                         if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1101
1102                                                 /* 8 bit sample
1103                                                  resolution, sign
1104                                                  extend both bytes.
1105                                                 */
1106
1107                                                 ((unsigned char*)
1108                                                  &sample_short)[0] += 0x7f;
1109                                                 ((unsigned char*)
1110                                                  &sample_short)[1] += 0x7f;
1111
1112                                         } else {
1113
1114                                                 /* 16 bit sample
1115                                                  resolution, sign
1116                                                  extend the MSB.
1117                                                 */
1118
1119                                                 sample_short += 0x7fff;
1120                                         }
1121                                 }
1122
1123                         } else {
1124
1125                                 /* In padding section of final block:
1126
1127                                    Don't fetch unsupplied data from
1128                                    user space, just continue with
1129                                    whatever the final value was.
1130                                 */
1131                         }
1132
1133                         if (i < blocksize - 1) {
1134                                 outw (sample_short, dev->block_port);
1135                         } else {
1136                                 outw (sample_short, dev->last_block_port);
1137                         }
1138                 }
1139
1140                 /* Get "DMA page acknowledge", even though its really
1141                    nothing to do with DMA at all.
1142                 */
1143
1144                 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1145                         if (dma_ack == -1) {
1146                                 snd_printk ("upload sample "
1147                                             "DMA ack timeout\n");
1148                                 return -EIO;
1149                         } else {
1150                                 snd_printk ("upload sample "
1151                                             "DMA ack error 0x%x\n",
1152                                             dma_ack);
1153                                 return -EIO;
1154                         }
1155                 }
1156         }
1157
1158         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1159
1160         /* Note, label is here because sending the sample header shouldn't
1161            alter the sample_status info at all.
1162         */
1163
1164  sent:
1165         return (0);
1166 }
1167
1168 static int
1169 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1170
1171 {
1172         unsigned char alias_hdr[WF_ALIAS_BYTES];
1173
1174         DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1175                                       "alias for %d\n",
1176                                       header->number,
1177                                       header->hdr.a.OriginalSample);
1178
1179         if (header->number >= WF_MAX_SAMPLE)
1180                 return -EINVAL;
1181
1182         munge_int32 (header->number, &alias_hdr[0], 2);
1183         munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1184         munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1185                      &alias_hdr[4], 4);
1186         munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1187                      &alias_hdr[8], 4);
1188         munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1189                      &alias_hdr[12], 4);
1190         munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1191                      &alias_hdr[16], 4);
1192         munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1193         munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1194
1195         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1196                 snd_printk ("download alias failed.\n");
1197                 return -EIO;
1198         }
1199
1200         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1201
1202         return (0);
1203 }
1204
1205 static int
1206 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1207 {
1208         int i;
1209         int num_samples;
1210         unsigned char *msample_hdr;
1211
1212         if (header->number >= WF_MAX_SAMPLE)
1213                 return -EINVAL;
1214
1215         msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1216         if (! msample_hdr)
1217                 return -ENOMEM;
1218
1219         munge_int32 (header->number, &msample_hdr[0], 2);
1220
1221         /* You'll recall at this point that the "number of samples" value
1222            in a wavefront_multisample struct is actually the log2 of the
1223            real number of samples.
1224         */
1225
1226         num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1227         msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1228
1229         DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1230                                       header->number,
1231                                       header->hdr.ms.NumberOfSamples,
1232                                       num_samples);
1233
1234         for (i = 0; i < num_samples; i++) {
1235                 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1236                        i, header->hdr.ms.SampleNumber[i]);
1237                 munge_int32 (header->hdr.ms.SampleNumber[i],
1238                      &msample_hdr[3+(i*2)], 2);
1239         }
1240
1241         /* Need a hack here to pass in the number of bytes
1242            to be written to the synth. This is ugly, and perhaps
1243            one day, I'll fix it.
1244         */
1245
1246         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1247                            (unsigned char *) (long) ((num_samples*2)+3),
1248                            msample_hdr)) {
1249                 snd_printk ("download of multisample failed.\n");
1250                 kfree(msample_hdr);
1251                 return -EIO;
1252         }
1253
1254         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1255
1256         kfree(msample_hdr);
1257         return (0);
1258 }
1259
1260 static int
1261 wavefront_fetch_multisample (snd_wavefront_t *dev,
1262                              wavefront_patch_info *header)
1263 {
1264         int i;
1265         unsigned char log_ns[1];
1266         unsigned char number[2];
1267         int num_samples;
1268
1269         munge_int32 (header->number, number, 2);
1270
1271         if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1272                 snd_printk ("upload multisample failed.\n");
1273                 return -EIO;
1274         }
1275
1276         DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1277                                 header->number, log_ns[0]);
1278
1279         header->hdr.ms.NumberOfSamples = log_ns[0];
1280
1281         /* get the number of samples ... */
1282
1283         num_samples = (1 << log_ns[0]);
1284
1285         for (i = 0; i < num_samples; i++) {
1286                 char d[2];
1287                 int val;
1288
1289                 if ((val = wavefront_read (dev)) == -1) {
1290                         snd_printk ("upload multisample failed "
1291                                     "during sample loop.\n");
1292                         return -EIO;
1293                 }
1294                 d[0] = val;
1295
1296                 if ((val = wavefront_read (dev)) == -1) {
1297                         snd_printk ("upload multisample failed "
1298                                     "during sample loop.\n");
1299                         return -EIO;
1300                 }
1301                 d[1] = val;
1302
1303                 header->hdr.ms.SampleNumber[i] =
1304                         demunge_int32 ((unsigned char *) d, 2);
1305
1306                 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1307                                         i, header->hdr.ms.SampleNumber[i]);
1308         }
1309
1310         return (0);
1311 }
1312
1313
1314 static int
1315 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1316
1317 {
1318         unsigned char drumbuf[WF_DRUM_BYTES];
1319         wavefront_drum *drum = &header->hdr.d;
1320         int i;
1321
1322         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1323                 "note %d, patch = %d\n",
1324                 header->number, drum->PatchNumber);
1325
1326         drumbuf[0] = header->number & 0x7f;
1327
1328         for (i = 0; i < 4; i++) {
1329                 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1330         }
1331
1332         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1333                 snd_printk ("download drum failed.\n");
1334                 return -EIO;
1335         }
1336
1337         return (0);
1338 }
1339
1340 static int
1341 wavefront_find_free_sample (snd_wavefront_t *dev)
1342
1343 {
1344         int i;
1345
1346         for (i = 0; i < WF_MAX_SAMPLE; i++) {
1347                 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1348                         return i;
1349                 }
1350         }
1351         snd_printk ("no free sample slots!\n");
1352         return -1;
1353 }
1354
1355 #if 0
1356 static int
1357 wavefront_find_free_patch (snd_wavefront_t *dev)
1358
1359 {
1360         int i;
1361
1362         for (i = 0; i < WF_MAX_PATCH; i++) {
1363                 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1364                         return i;
1365                 }
1366         }
1367         snd_printk ("no free patch slots!\n");
1368         return -1;
1369 }
1370 #endif
1371
1372 static int
1373 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1374 {
1375         wavefront_patch_info *header;
1376         int err;
1377
1378         header = kmalloc(sizeof(*header), GFP_KERNEL);
1379         if (! header)
1380                 return -ENOMEM;
1381
1382         if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1383                             sizeof(wavefront_any))) {
1384                 snd_printk ("bad address for load patch.\n");
1385                 err = -EFAULT;
1386                 goto __error;
1387         }
1388
1389         DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1390                                       "Sample type: %d "
1391                                       "Sample number: %d "
1392                                       "Sample size: %d\n",
1393                                       header->subkey,
1394                                       header->number,
1395                                       header->size);
1396
1397         switch (header->subkey) {
1398         case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */
1399
1400                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1401                                     sizeof (wavefront_sample))) {
1402                         err = -EFAULT;
1403                         break;
1404                 }
1405
1406                 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1407                 break;
1408
1409         case WF_ST_MULTISAMPLE:
1410
1411                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1412                                     sizeof (wavefront_multisample))) {
1413                         err = -EFAULT;
1414                         break;
1415                 }
1416
1417                 err = wavefront_send_multisample (dev, header);
1418                 break;
1419
1420         case WF_ST_ALIAS:
1421
1422                 if (copy_from_user (&header->hdr.a, header->hdrptr,
1423                                     sizeof (wavefront_alias))) {
1424                         err = -EFAULT;
1425                         break;
1426                 }
1427
1428                 err = wavefront_send_alias (dev, header);
1429                 break;
1430
1431         case WF_ST_DRUM:
1432                 if (copy_from_user (&header->hdr.d, header->hdrptr,
1433                                     sizeof (wavefront_drum))) {
1434                         err = -EFAULT;
1435                         break;
1436                 }
1437
1438                 err = wavefront_send_drum (dev, header);
1439                 break;
1440
1441         case WF_ST_PATCH:
1442                 if (copy_from_user (&header->hdr.p, header->hdrptr,
1443                                     sizeof (wavefront_patch))) {
1444                         err = -EFAULT;
1445                         break;
1446                 }
1447
1448                 err = wavefront_send_patch (dev, header);
1449                 break;
1450
1451         case WF_ST_PROGRAM:
1452                 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1453                                     sizeof (wavefront_program))) {
1454                         err = -EFAULT;
1455                         break;
1456                 }
1457
1458                 err = wavefront_send_program (dev, header);
1459                 break;
1460
1461         default:
1462                 snd_printk ("unknown patch type %d.\n",
1463                             header->subkey);
1464                 err = -EINVAL;
1465                 break;
1466         }
1467
1468  __error:
1469         kfree(header);
1470         return err;
1471 }
1472 \f
1473 /***********************************************************************
1474 WaveFront: hardware-dependent interface
1475 ***********************************************************************/
1476
1477 static void
1478 process_sample_hdr (u8 *buf)
1479
1480 {
1481         wavefront_sample s;
1482         u8 *ptr;
1483
1484         ptr = buf;
1485
1486         /* The board doesn't send us an exact copy of a "wavefront_sample"
1487            in response to an Upload Sample Header command. Instead, we
1488            have to convert the data format back into our data structure,
1489            just as in the Download Sample command, where we have to do
1490            something very similar in the reverse direction.
1491         */
1492
1493         *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1494         *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1495         *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1496         *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1497         *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1498
1499         s.SampleResolution = *ptr & 0x3;
1500         s.Loop = *ptr & 0x8;
1501         s.Bidirectional = *ptr & 0x10;
1502         s.Reverse = *ptr & 0x40;
1503
1504         /* Now copy it back to where it came from */
1505
1506         memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1507 }
1508
1509 static int
1510 wavefront_synth_control (snd_wavefront_card_t *acard,
1511                          wavefront_control *wc)
1512
1513 {
1514         snd_wavefront_t *dev = &acard->wavefront;
1515         unsigned char patchnumbuf[2];
1516         int i;
1517
1518         DPRINT (WF_DEBUG_CMD, "synth control with "
1519                 "cmd 0x%x\n", wc->cmd);
1520
1521         /* Pre-handling of or for various commands */
1522
1523         switch (wc->cmd) {
1524
1525         case WFC_DISABLE_INTERRUPTS:
1526                 snd_printk ("interrupts disabled.\n");
1527                 outb (0x80|0x20, dev->control_port);
1528                 dev->interrupts_are_midi = 1;
1529                 return 0;
1530
1531         case WFC_ENABLE_INTERRUPTS:
1532                 snd_printk ("interrupts enabled.\n");
1533                 outb (0x80|0x40|0x20, dev->control_port);
1534                 dev->interrupts_are_midi = 1;
1535                 return 0;
1536
1537         case WFC_INTERRUPT_STATUS:
1538                 wc->rbuf[0] = dev->interrupts_are_midi;
1539                 return 0;
1540
1541         case WFC_ROMSAMPLES_RDONLY:
1542                 dev->rom_samples_rdonly = wc->wbuf[0];
1543                 wc->status = 0;
1544                 return 0;
1545
1546         case WFC_IDENTIFY_SLOT_TYPE:
1547                 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1548                 if (i <0 || i >= WF_MAX_SAMPLE) {
1549                         snd_printk ("invalid slot ID %d\n",
1550                                 i);
1551                         wc->status = EINVAL;
1552                         return -EINVAL;
1553                 }
1554                 wc->rbuf[0] = dev->sample_status[i];
1555                 wc->status = 0;
1556                 return 0;
1557
1558         case WFC_DEBUG_DRIVER:
1559                 dev->debug = wc->wbuf[0];
1560                 snd_printk ("debug = 0x%x\n", dev->debug);
1561                 return 0;
1562
1563         case WFC_UPLOAD_PATCH:
1564                 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1565                 memcpy (wc->wbuf, patchnumbuf, 2);
1566                 break;
1567
1568         case WFC_UPLOAD_MULTISAMPLE:
1569                 /* multisamples have to be handled differently, and
1570                    cannot be dealt with properly by snd_wavefront_cmd() alone.
1571                 */
1572                 wc->status = wavefront_fetch_multisample
1573                         (dev, (wavefront_patch_info *) wc->rbuf);
1574                 return 0;
1575
1576         case WFC_UPLOAD_SAMPLE_ALIAS:
1577                 snd_printk ("support for sample alias upload "
1578                         "being considered.\n");
1579                 wc->status = EINVAL;
1580                 return -EINVAL;
1581         }
1582
1583         wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1584
1585         /* Post-handling of certain commands.
1586
1587            In particular, if the command was an upload, demunge the data
1588            so that the user-level doesn't have to think about it.
1589         */
1590
1591         if (wc->status == 0) {
1592                 switch (wc->cmd) {
1593                         /* intercept any freemem requests so that we know
1594                            we are always current with the user-level view
1595                            of things.
1596                         */
1597
1598                 case WFC_REPORT_FREE_MEMORY:
1599                         dev->freemem = demunge_int32 (wc->rbuf, 4);
1600                         break;
1601
1602                 case WFC_UPLOAD_PATCH:
1603                         demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1604                         break;
1605
1606                 case WFC_UPLOAD_PROGRAM:
1607                         demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1608                         break;
1609
1610                 case WFC_UPLOAD_EDRUM_PROGRAM:
1611                         demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1612                         break;
1613
1614                 case WFC_UPLOAD_SAMPLE_HEADER:
1615                         process_sample_hdr (wc->rbuf);
1616                         break;
1617
1618                 case WFC_UPLOAD_SAMPLE_ALIAS:
1619                         snd_printk ("support for "
1620                                     "sample aliases still "
1621                                     "being considered.\n");
1622                         break;
1623
1624                 case WFC_VMIDI_OFF:
1625                         snd_wavefront_midi_disable_virtual (acard);
1626                         break;
1627
1628                 case WFC_VMIDI_ON:
1629                         snd_wavefront_midi_enable_virtual (acard);
1630                         break;
1631                 }
1632         }
1633
1634         return 0;
1635 }
1636
1637 int
1638 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1639
1640 {
1641         if (!try_module_get(hw->card->module))
1642                 return -EFAULT;
1643         file->private_data = hw;
1644         return 0;
1645 }
1646
1647 int
1648 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1649
1650 {
1651         module_put(hw->card->module);
1652         return 0;
1653 }
1654
1655 int
1656 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1657                            unsigned int cmd, unsigned long arg)
1658
1659 {
1660         struct snd_card *card;
1661         snd_wavefront_t *dev;
1662         snd_wavefront_card_t *acard;
1663         wavefront_control *wc;
1664         void __user *argp = (void __user *)arg;
1665         int err;
1666
1667         card = (struct snd_card *) hw->card;
1668
1669         if (snd_BUG_ON(!card))
1670                 return -ENODEV;
1671         if (snd_BUG_ON(!card->private_data))
1672                 return -ENODEV;
1673
1674         acard = card->private_data;
1675         dev = &acard->wavefront;
1676
1677         switch (cmd) {
1678         case WFCTL_LOAD_SPP:
1679                 if (wavefront_load_patch (dev, argp) != 0) {
1680                         return -EIO;
1681                 }
1682                 break;
1683
1684         case WFCTL_WFCMD:
1685                 wc = memdup_user(argp, sizeof(*wc));
1686                 if (IS_ERR(wc))
1687                         return PTR_ERR(wc);
1688
1689                 if (wavefront_synth_control (acard, wc) < 0)
1690                         err = -EIO;
1691                 else if (copy_to_user (argp, wc, sizeof (*wc)))
1692                         err = -EFAULT;
1693                 else
1694                         err = 0;
1695                 kfree(wc);
1696                 return err;
1697
1698         default:
1699                 return -EINVAL;
1700         }
1701
1702         return 0;
1703 }
1704
1705 \f
1706 /***********************************************************************/
1707 /*  WaveFront: interface for card-level wavefront module               */
1708 /***********************************************************************/
1709
1710 void
1711 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1712 {
1713         snd_wavefront_t *dev = &card->wavefront;
1714
1715         /*
1716            Some comments on interrupts. I attempted a version of this
1717            driver that used interrupts throughout the code instead of
1718            doing busy and/or sleep-waiting. Alas, it appears that once
1719            the Motorola firmware is downloaded, the card *never*
1720            generates an RX interrupt. These are successfully generated
1721            during firmware loading, and after that wavefront_status()
1722            reports that an interrupt is pending on the card from time
1723            to time, but it never seems to be delivered to this
1724            driver. Note also that wavefront_status() continues to
1725            report that RX interrupts are enabled, suggesting that I
1726            didn't goof up and disable them by mistake.
1727
1728            Thus, I stepped back to a prior version of
1729            wavefront_wait(), the only place where this really
1730            matters. Its sad, but I've looked through the code to check
1731            on things, and I really feel certain that the Motorola
1732            firmware prevents RX-ready interrupts.
1733         */
1734
1735         if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1736                 return;
1737         }
1738
1739         spin_lock(&dev->irq_lock);
1740         dev->irq_ok = 1;
1741         dev->irq_cnt++;
1742         spin_unlock(&dev->irq_lock);
1743         wake_up(&dev->interrupt_sleeper);
1744 }
1745
1746 /* STATUS REGISTER
1747
1748 0 Host Rx Interrupt Enable (1=Enabled)
1749 1 Host Rx Register Full (1=Full)
1750 2 Host Rx Interrupt Pending (1=Interrupt)
1751 3 Unused
1752 4 Host Tx Interrupt (1=Enabled)
1753 5 Host Tx Register empty (1=Empty)
1754 6 Host Tx Interrupt Pending (1=Interrupt)
1755 7 Unused
1756 */
1757
1758 static int
1759 snd_wavefront_interrupt_bits (int irq)
1760
1761 {
1762         int bits;
1763
1764         switch (irq) {
1765         case 9:
1766                 bits = 0x00;
1767                 break;
1768         case 5:
1769                 bits = 0x08;
1770                 break;
1771         case 12:
1772                 bits = 0x10;
1773                 break;
1774         case 15:
1775                 bits = 0x18;
1776                 break;
1777
1778         default:
1779                 snd_printk ("invalid IRQ %d\n", irq);
1780                 bits = -1;
1781         }
1782
1783         return bits;
1784 }
1785
1786 static void
1787 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1788                                   int val, int port, unsigned long timeout)
1789
1790 {
1791         wait_queue_t wait;
1792
1793         init_waitqueue_entry(&wait, current);
1794         spin_lock_irq(&dev->irq_lock);
1795         add_wait_queue(&dev->interrupt_sleeper, &wait);
1796         dev->irq_ok = 0;
1797         outb (val,port);
1798         spin_unlock_irq(&dev->irq_lock);
1799         while (!dev->irq_ok && time_before(jiffies, timeout)) {
1800                 schedule_timeout_uninterruptible(1);
1801                 barrier();
1802         }
1803 }
1804
1805 static int
1806 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1807
1808 {
1809         int bits;
1810         int hwv[2];
1811
1812         /* IRQ already checked */
1813
1814         bits = snd_wavefront_interrupt_bits (dev->irq);
1815
1816         /* try reset of port */
1817
1818         outb (0x0, dev->control_port);
1819
1820         /* At this point, the board is in reset, and the H/W initialization
1821            register is accessed at the same address as the data port.
1822
1823            Bit 7 - Enable IRQ Driver
1824            0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1825            1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1826
1827            Bit 6 - MIDI Interface Select
1828
1829            0 - Use the MIDI Input from the 26-pin WaveBlaster
1830            compatible header as the serial MIDI source
1831            1 - Use the MIDI Input from the 9-pin D connector as the
1832            serial MIDI source.
1833
1834            Bits 5:3 - IRQ Selection
1835            0 0 0 - IRQ 2/9
1836            0 0 1 - IRQ 5
1837            0 1 0 - IRQ 12
1838            0 1 1 - IRQ 15
1839            1 0 0 - Reserved
1840            1 0 1 - Reserved
1841            1 1 0 - Reserved
1842            1 1 1 - Reserved
1843
1844            Bits 2:1 - Reserved
1845            Bit 0 - Disable Boot ROM
1846            0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1847            1 - memory accesses to 03FC30-03FFFFH are directed to external
1848            storage.
1849
1850         */
1851
1852         /* configure hardware: IRQ, enable interrupts,
1853            plus external 9-pin MIDI interface selected
1854         */
1855
1856         outb (0x80 | 0x40 | bits, dev->data_port);
1857
1858         /* CONTROL REGISTER
1859
1860            0 Host Rx Interrupt Enable (1=Enabled)      0x1
1861            1 Unused                                    0x2
1862            2 Unused                                    0x4
1863            3 Unused                                    0x8
1864            4 Host Tx Interrupt Enable                 0x10
1865            5 Mute (0=Mute; 1=Play)                    0x20
1866            6 Master Interrupt Enable (1=Enabled)      0x40
1867            7 Master Reset (0=Reset; 1=Run)            0x80
1868
1869            Take us out of reset, mute output, master + TX + RX interrupts on.
1870
1871            We'll get an interrupt presumably to tell us that the TX
1872            register is clear.
1873         */
1874
1875         wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1876                                          dev->control_port,
1877                                          (reset_time*HZ)/100);
1878
1879         /* Note: data port is now the data port, not the h/w initialization
1880            port.
1881          */
1882
1883         if (!dev->irq_ok) {
1884                 snd_printk ("intr not received after h/w un-reset.\n");
1885                 goto gone_bad;
1886         }
1887
1888         /* Note: data port is now the data port, not the h/w initialization
1889            port.
1890
1891            At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1892            will work. So, issue one of them, and wait for TX
1893            interrupt. This can take a *long* time after a cold boot,
1894            while the ISC ROM does its RAM test. The SDK says up to 4
1895            seconds - with 12MB of RAM on a Tropez+, it takes a lot
1896            longer than that (~16secs). Note that the card understands
1897            the difference between a warm and a cold boot, so
1898            subsequent ISC2115 reboots (say, caused by module
1899            reloading) will get through this much faster.
1900
1901            XXX Interesting question: why is no RX interrupt received first ?
1902         */
1903
1904         wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1905                                          dev->data_port, ramcheck_time*HZ);
1906
1907         if (!dev->irq_ok) {
1908                 snd_printk ("post-RAM-check interrupt not received.\n");
1909                 goto gone_bad;
1910         }
1911
1912         if (!wavefront_wait (dev, STAT_CAN_READ)) {
1913                 snd_printk ("no response to HW version cmd.\n");
1914                 goto gone_bad;
1915         }
1916
1917         if ((hwv[0] = wavefront_read (dev)) == -1) {
1918                 snd_printk ("board not responding correctly.\n");
1919                 goto gone_bad;
1920         }
1921
1922         if (hwv[0] == 0xFF) { /* NAK */
1923
1924                 /* Board's RAM test failed. Try to read error code,
1925                    and tell us about it either way.
1926                 */
1927
1928                 if ((hwv[0] = wavefront_read (dev)) == -1) {
1929                         snd_printk ("on-board RAM test failed "
1930                                     "(bad error code).\n");
1931                 } else {
1932                         snd_printk ("on-board RAM test failed "
1933                                     "(error code: 0x%x).\n",
1934                                 hwv[0]);
1935                 }
1936                 goto gone_bad;
1937         }
1938
1939         /* We're OK, just get the next byte of the HW version response */
1940
1941         if ((hwv[1] = wavefront_read (dev)) == -1) {
1942                 snd_printk ("incorrect h/w response.\n");
1943                 goto gone_bad;
1944         }
1945
1946         snd_printk ("hardware version %d.%d\n",
1947                     hwv[0], hwv[1]);
1948
1949         return 0;
1950
1951
1952      gone_bad:
1953         return (1);
1954 }
1955
1956 static int
1957 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1958
1959 {
1960         const unsigned char *buf;
1961         int len, err;
1962         int section_cnt_downloaded = 0;
1963         const struct firmware *firmware;
1964
1965         err = reject_firmware(&firmware, path, dev->card->dev);
1966         if (err < 0) {
1967                 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1968                 return 1;
1969         }
1970
1971         len = 0;
1972         buf = firmware->data;
1973         for (;;) {
1974                 int section_length = *(signed char *)buf;
1975                 if (section_length == 0)
1976                         break;
1977                 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1978                         snd_printk(KERN_ERR
1979                                    "invalid firmware section length %d\n",
1980                                    section_length);
1981                         goto failure;
1982                 }
1983                 buf++;
1984                 len++;
1985
1986                 if (firmware->size < len + section_length) {
1987                         snd_printk(KERN_ERR "firmware section read error.\n");
1988                         goto failure;
1989                 }
1990
1991                 /* Send command */
1992                 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1993                         goto failure;
1994
1995                 for (; section_length; section_length--) {
1996                         if (wavefront_write(dev, *buf))
1997                                 goto failure;
1998                         buf++;
1999                         len++;
2000                 }
2001
2002                 /* get ACK */
2003                 if (!wavefront_wait(dev, STAT_CAN_READ)) {
2004                         snd_printk(KERN_ERR "time out for firmware ACK.\n");
2005                         goto failure;
2006                 }
2007                 err = inb(dev->data_port);
2008                 if (err != WF_ACK) {
2009                         snd_printk(KERN_ERR
2010                                    "download of section #%d not "
2011                                    "acknowledged, ack = 0x%x\n",
2012                                    section_cnt_downloaded + 1, err);
2013                         goto failure;
2014                 }
2015
2016                 section_cnt_downloaded++;
2017         }
2018
2019         release_firmware(firmware);
2020         return 0;
2021
2022  failure:
2023         release_firmware(firmware);
2024         snd_printk(KERN_ERR "firmware download failed!!!\n");
2025         return 1;
2026 }
2027
2028
2029 static int
2030 wavefront_do_reset (snd_wavefront_t *dev)
2031
2032 {
2033         char voices[1];
2034
2035         if (wavefront_reset_to_cleanliness (dev)) {
2036                 snd_printk ("hw reset failed.\n");
2037                 goto gone_bad;
2038         }
2039
2040         if (dev->israw) {
2041                 if (wavefront_download_firmware (dev, ospath)) {
2042                         goto gone_bad;
2043                 }
2044
2045                 dev->israw = 0;
2046
2047                 /* Wait for the OS to get running. The protocol for
2048                    this is non-obvious, and was determined by
2049                    using port-IO tracing in DOSemu and some
2050                    experimentation here.
2051
2052                    Rather than using timed waits, use interrupts creatively.
2053                 */
2054
2055                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2056                                                   dev->data_port,
2057                                                   (osrun_time*HZ));
2058
2059                 if (!dev->irq_ok) {
2060                         snd_printk ("no post-OS interrupt.\n");
2061                         goto gone_bad;
2062                 }
2063
2064                 /* Now, do it again ! */
2065
2066                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2067                                                   dev->data_port, (10*HZ));
2068
2069                 if (!dev->irq_ok) {
2070                         snd_printk ("no post-OS interrupt(2).\n");
2071                         goto gone_bad;
2072                 }
2073
2074                 /* OK, no (RX/TX) interrupts any more, but leave mute
2075                    in effect.
2076                 */
2077
2078                 outb (0x80|0x40, dev->control_port);
2079         }
2080
2081         /* SETUPSND.EXE asks for sample memory config here, but since i
2082            have no idea how to interpret the result, we'll forget
2083            about it.
2084         */
2085
2086         if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2087                 goto gone_bad;
2088         }
2089
2090         snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2091
2092         if (wavefront_write (dev, 0xf0) ||
2093             wavefront_write (dev, 1) ||
2094             (wavefront_read (dev) < 0)) {
2095                 dev->debug = 0;
2096                 snd_printk ("MPU emulation mode not set.\n");
2097                 goto gone_bad;
2098         }
2099
2100         voices[0] = 32;
2101
2102         if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2103                 snd_printk ("cannot set number of voices to 32.\n");
2104                 goto gone_bad;
2105         }
2106
2107
2108         return 0;
2109
2110  gone_bad:
2111         /* reset that sucker so that it doesn't bother us. */
2112
2113         outb (0x0, dev->control_port);
2114         dev->interrupts_are_midi = 0;
2115         return 1;
2116 }
2117
2118 int
2119 snd_wavefront_start (snd_wavefront_t *dev)
2120
2121 {
2122         int samples_are_from_rom;
2123
2124         /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2125            wavefront_reset_to_cleanliness() has already been called
2126         */
2127
2128         if (dev->israw) {
2129                 samples_are_from_rom = 1;
2130         } else {
2131                 /* XXX is this always true ? */
2132                 samples_are_from_rom = 0;
2133         }
2134
2135         if (dev->israw || fx_raw) {
2136                 if (wavefront_do_reset (dev)) {
2137                         return -1;
2138                 }
2139         }
2140         /* Check for FX device, present only on Tropez+ */
2141
2142         dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2143
2144         if (dev->has_fx && fx_raw) {
2145                 snd_wavefront_fx_start (dev);
2146         }
2147
2148         wavefront_get_sample_status (dev, samples_are_from_rom);
2149         wavefront_get_program_status (dev);
2150         wavefront_get_patch_status (dev);
2151
2152         /* Start normal operation: unreset, master interrupt enabled, no mute
2153         */
2154
2155         outb (0x80|0x40|0x20, dev->control_port);
2156
2157         return (0);
2158 }
2159
2160 int
2161 snd_wavefront_detect (snd_wavefront_card_t *card)
2162
2163 {
2164         unsigned char   rbuf[4], wbuf[4];
2165         snd_wavefront_t *dev = &card->wavefront;
2166
2167         /* returns zero if a WaveFront card is successfully detected.
2168            negative otherwise.
2169         */
2170
2171         dev->israw = 0;
2172         dev->has_fx = 0;
2173         dev->debug = debug_default;
2174         dev->interrupts_are_midi = 0;
2175         dev->irq_cnt = 0;
2176         dev->rom_samples_rdonly = 1;
2177
2178         if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2179
2180                 dev->fw_version[0] = rbuf[0];
2181                 dev->fw_version[1] = rbuf[1];
2182
2183                 snd_printk ("firmware %d.%d already loaded.\n",
2184                             rbuf[0], rbuf[1]);
2185
2186                 /* check that a command actually works */
2187
2188                 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2189                                        rbuf, wbuf) == 0) {
2190                         dev->hw_version[0] = rbuf[0];
2191                         dev->hw_version[1] = rbuf[1];
2192                 } else {
2193                         snd_printk ("not raw, but no "
2194                                     "hardware version!\n");
2195                         return -1;
2196                 }
2197
2198                 if (!wf_raw) {
2199                         return 0;
2200                 } else {
2201                         snd_printk ("reloading firmware as you requested.\n");
2202                         dev->israw = 1;
2203                 }
2204
2205         } else {
2206
2207                 dev->israw = 1;
2208                 snd_printk ("no response to firmware probe, assume raw.\n");
2209
2210         }
2211
2212         return 0;
2213 }
2214
2215 /*(DEBLOBBED)*/