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