sound/isa/wavefront/wavefront_synth.c

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