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