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