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 *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 *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 *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 ((unsigned char *) &header.hdr.s,
1381                                     (unsigned char *) header.hdrptr,
1382                                     sizeof (wavefront_sample)))
1383                         return -EFAULT;
1384
1385                 return wavefront_send_sample (dev, &header, header.dataptr, 0);
1386
1387         case WF_ST_MULTISAMPLE:
1388
1389                 if (copy_from_user ((unsigned char *) &header.hdr.s,
1390                                     (unsigned char *) header.hdrptr,
1391                                     sizeof (wavefront_multisample)))
1392                         return -EFAULT;
1393
1394                 return wavefront_send_multisample (dev, &header);
1395
1396
1397         case WF_ST_ALIAS:
1398
1399                 if (copy_from_user ((unsigned char *) &header.hdr.a,
1400                                     (unsigned char *) header.hdrptr,
1401                                     sizeof (wavefront_alias)))
1402                         return -EFAULT;
1403
1404                 return wavefront_send_alias (dev, &header);
1405
1406         case WF_ST_DRUM:
1407                 if (copy_from_user ((unsigned char *) &header.hdr.d,
1408                                     (unsigned char *) header.hdrptr,
1409                                     sizeof (wavefront_drum)))
1410                         return -EFAULT;
1411
1412                 return wavefront_send_drum (dev, &header);
1413
1414         case WF_ST_PATCH:
1415                 if (copy_from_user ((unsigned char *) &header.hdr.p,
1416                                     (unsigned char *) header.hdrptr,
1417                                     sizeof (wavefront_patch)))
1418                         return -EFAULT;
1419
1420                 return wavefront_send_patch (dev, &header);
1421
1422         case WF_ST_PROGRAM:
1423                 if (copy_from_user ((unsigned char *) &header.hdr.pr,
1424                                     (unsigned char *) header.hdrptr,
1425                                     sizeof (wavefront_program)))
1426                         return -EFAULT;
1427
1428                 return wavefront_send_program (dev, &header);
1429
1430         default:
1431                 snd_printk ("unknown patch type %d.\n",
1432                             header.subkey);
1433                 return -(EINVAL);
1434         }
1435
1436         return 0;
1437 }
1438 \f
1439 /***********************************************************************
1440 WaveFront: hardware-dependent interface
1441 ***********************************************************************/
1442
1443 static void
1444 process_sample_hdr (u8 *buf)
1445
1446 {
1447         wavefront_sample s;
1448         u8 *ptr;
1449
1450         ptr = buf;
1451
1452         /* The board doesn't send us an exact copy of a "wavefront_sample"
1453            in response to an Upload Sample Header command. Instead, we
1454            have to convert the data format back into our data structure,
1455            just as in the Download Sample command, where we have to do
1456            something very similar in the reverse direction.
1457         */
1458
1459         *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1460         *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1461         *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1462         *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1463         *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1464
1465         s.SampleResolution = *ptr & 0x3;
1466         s.Loop = *ptr & 0x8;
1467         s.Bidirectional = *ptr & 0x10;
1468         s.Reverse = *ptr & 0x40;
1469
1470         /* Now copy it back to where it came from */
1471
1472         memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1473 }
1474
1475 static int
1476 wavefront_synth_control (snd_wavefront_card_t *acard,
1477                          wavefront_control *wc)
1478
1479 {
1480         snd_wavefront_t *dev = &acard->wavefront;
1481         unsigned char patchnumbuf[2];
1482         int i;
1483
1484         DPRINT (WF_DEBUG_CMD, "synth control with "
1485                 "cmd 0x%x\n", wc->cmd);
1486
1487         /* Pre-handling of or for various commands */
1488
1489         switch (wc->cmd) {
1490
1491         case WFC_DISABLE_INTERRUPTS:
1492                 snd_printk ("interrupts disabled.\n");
1493                 outb (0x80|0x20, dev->control_port);
1494                 dev->interrupts_are_midi = 1;
1495                 return 0;
1496
1497         case WFC_ENABLE_INTERRUPTS:
1498                 snd_printk ("interrupts enabled.\n");
1499                 outb (0x80|0x40|0x20, dev->control_port);
1500                 dev->interrupts_are_midi = 1;
1501                 return 0;
1502
1503         case WFC_INTERRUPT_STATUS:
1504                 wc->rbuf[0] = dev->interrupts_are_midi;
1505                 return 0;
1506
1507         case WFC_ROMSAMPLES_RDONLY:
1508                 dev->rom_samples_rdonly = wc->wbuf[0];
1509                 wc->status = 0;
1510                 return 0;
1511
1512         case WFC_IDENTIFY_SLOT_TYPE:
1513                 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1514                 if (i <0 || i >= WF_MAX_SAMPLE) {
1515                         snd_printk ("invalid slot ID %d\n",
1516                                 i);
1517                         wc->status = EINVAL;
1518                         return -EINVAL;
1519                 }
1520                 wc->rbuf[0] = dev->sample_status[i];
1521                 wc->status = 0;
1522                 return 0;
1523
1524         case WFC_DEBUG_DRIVER:
1525                 dev->debug = wc->wbuf[0];
1526                 snd_printk ("debug = 0x%x\n", dev->debug);
1527                 return 0;
1528
1529         case WFC_UPLOAD_PATCH:
1530                 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1531                 memcpy (wc->wbuf, patchnumbuf, 2);
1532                 break;
1533
1534         case WFC_UPLOAD_MULTISAMPLE:
1535                 /* multisamples have to be handled differently, and
1536                    cannot be dealt with properly by snd_wavefront_cmd() alone.
1537                 */
1538                 wc->status = wavefront_fetch_multisample
1539                         (dev, (wavefront_patch_info *) wc->rbuf);
1540                 return 0;
1541
1542         case WFC_UPLOAD_SAMPLE_ALIAS:
1543                 snd_printk ("support for sample alias upload "
1544                         "being considered.\n");
1545                 wc->status = EINVAL;
1546                 return -EINVAL;
1547         }
1548
1549         wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1550
1551         /* Post-handling of certain commands.
1552
1553            In particular, if the command was an upload, demunge the data
1554            so that the user-level doesn't have to think about it.
1555         */
1556
1557         if (wc->status == 0) {
1558                 switch (wc->cmd) {
1559                         /* intercept any freemem requests so that we know
1560                            we are always current with the user-level view
1561                            of things.
1562                         */
1563
1564                 case WFC_REPORT_FREE_MEMORY:
1565                         dev->freemem = demunge_int32 (wc->rbuf, 4);
1566                         break;
1567
1568                 case WFC_UPLOAD_PATCH:
1569                         demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1570                         break;
1571
1572                 case WFC_UPLOAD_PROGRAM:
1573                         demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1574                         break;
1575
1576                 case WFC_UPLOAD_EDRUM_PROGRAM:
1577                         demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1578                         break;
1579
1580                 case WFC_UPLOAD_SAMPLE_HEADER:
1581                         process_sample_hdr (wc->rbuf);
1582                         break;
1583
1584                 case WFC_UPLOAD_SAMPLE_ALIAS:
1585                         snd_printk ("support for "
1586                                     "sample aliases still "
1587                                     "being considered.\n");
1588                         break;
1589
1590                 case WFC_VMIDI_OFF:
1591                         snd_wavefront_midi_disable_virtual (acard);
1592                         break;
1593
1594                 case WFC_VMIDI_ON:
1595                         snd_wavefront_midi_enable_virtual (acard);
1596                         break;
1597                 }
1598         }
1599
1600         return 0;
1601 }
1602
1603 int
1604 snd_wavefront_synth_open (snd_hwdep_t *hw, struct file *file)
1605
1606 {
1607         if (!try_module_get(hw->card->module))
1608                 return -EFAULT;
1609         file->private_data = hw;
1610         return 0;
1611 }
1612
1613 int
1614 snd_wavefront_synth_release (snd_hwdep_t *hw, struct file *file)
1615
1616 {
1617         module_put(hw->card->module);
1618         return 0;
1619 }
1620
1621 int
1622 snd_wavefront_synth_ioctl (snd_hwdep_t *hw, struct file *file,
1623                            unsigned int cmd, unsigned long arg)
1624
1625 {
1626         snd_card_t *card;
1627         snd_wavefront_t *dev;
1628         snd_wavefront_card_t *acard;
1629         wavefront_control wc;
1630
1631         card = (snd_card_t *) hw->card;
1632
1633         snd_assert(card != NULL, return -ENODEV);
1634
1635         snd_assert(card->private_data != NULL, return -ENODEV);
1636
1637         acard = card->private_data;
1638         dev = &acard->wavefront;
1639
1640         switch (cmd) {
1641         case WFCTL_LOAD_SPP:
1642                 if (wavefront_load_patch (dev, (char *) arg) != 0) {
1643                         return -EIO;
1644                 }
1645                 break;
1646
1647         case WFCTL_WFCMD:
1648                 if (copy_from_user (&wc, (void *) arg, sizeof (wc)))
1649                         return -EFAULT;
1650                 if (wavefront_synth_control (acard, &wc) < 0) {
1651                         return -EIO;
1652                 }
1653                 if (copy_to_user ((void *) arg, &wc, sizeof (wc)))
1654                         return -EFAULT;
1655                 break;
1656
1657         default:
1658                 return -EINVAL;
1659         }
1660
1661         return 0;
1662 }
1663
1664 \f
1665 /***********************************************************************/
1666 /*  WaveFront: interface for card-level wavefront module               */
1667 /***********************************************************************/
1668
1669 void
1670 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1671 {
1672         snd_wavefront_t *dev = &card->wavefront;
1673
1674         /*
1675            Some comments on interrupts. I attempted a version of this
1676            driver that used interrupts throughout the code instead of
1677            doing busy and/or sleep-waiting. Alas, it appears that once
1678            the Motorola firmware is downloaded, the card *never*
1679            generates an RX interrupt. These are successfully generated
1680            during firmware loading, and after that wavefront_status()
1681            reports that an interrupt is pending on the card from time
1682            to time, but it never seems to be delivered to this
1683            driver. Note also that wavefront_status() continues to
1684            report that RX interrupts are enabled, suggesting that I
1685            didn't goof up and disable them by mistake.
1686
1687            Thus, I stepped back to a prior version of
1688            wavefront_wait(), the only place where this really
1689            matters. Its sad, but I've looked through the code to check
1690            on things, and I really feel certain that the Motorola
1691            firmware prevents RX-ready interrupts.
1692         */
1693
1694         if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1695                 return;
1696         }
1697
1698         spin_lock(&dev->irq_lock);
1699         dev->irq_ok = 1;
1700         dev->irq_cnt++;
1701         spin_unlock(&dev->irq_lock);
1702         wake_up(&dev->interrupt_sleeper);
1703 }
1704
1705 /* STATUS REGISTER
1706
1707 0 Host Rx Interrupt Enable (1=Enabled)
1708 1 Host Rx Register Full (1=Full)
1709 2 Host Rx Interrupt Pending (1=Interrupt)
1710 3 Unused
1711 4 Host Tx Interrupt (1=Enabled)
1712 5 Host Tx Register empty (1=Empty)
1713 6 Host Tx Interrupt Pending (1=Interrupt)
1714 7 Unused
1715 */
1716
1717 int __init
1718 snd_wavefront_interrupt_bits (int irq)
1719
1720 {
1721         int bits;
1722
1723         switch (irq) {
1724         case 9:
1725                 bits = 0x00;
1726                 break;
1727         case 5:
1728                 bits = 0x08;
1729                 break;
1730         case 12:
1731                 bits = 0x10;
1732                 break;
1733         case 15:
1734                 bits = 0x18;
1735                 break;
1736
1737         default:
1738                 snd_printk ("invalid IRQ %d\n", irq);
1739                 bits = -1;
1740         }
1741
1742         return bits;
1743 }
1744
1745 static void __init
1746 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1747                                   int val, int port, int timeout)
1748
1749 {
1750         wait_queue_t wait;
1751
1752         init_waitqueue_entry(&wait, current);
1753         spin_lock_irq(&dev->irq_lock);
1754         add_wait_queue(&dev->interrupt_sleeper, &wait);
1755         dev->irq_ok = 0;
1756         outb (val,port);
1757         spin_unlock_irq(&dev->irq_lock);
1758         while (1) {
1759                 if ((timeout = schedule_timeout(timeout)) == 0)
1760                         return;
1761                 if (dev->irq_ok)
1762                         return;
1763         }
1764 }
1765
1766 static int __init
1767 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1768
1769 {
1770         int bits;
1771         int hwv[2];
1772
1773         /* IRQ already checked */
1774
1775         bits = snd_wavefront_interrupt_bits (dev->irq);
1776
1777         /* try reset of port */
1778
1779         outb (0x0, dev->control_port);
1780
1781         /* At this point, the board is in reset, and the H/W initialization
1782            register is accessed at the same address as the data port.
1783
1784            Bit 7 - Enable IRQ Driver
1785            0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1786            1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1787
1788            Bit 6 - MIDI Interface Select
1789
1790            0 - Use the MIDI Input from the 26-pin WaveBlaster
1791            compatible header as the serial MIDI source
1792            1 - Use the MIDI Input from the 9-pin D connector as the
1793            serial MIDI source.
1794
1795            Bits 5:3 - IRQ Selection
1796            0 0 0 - IRQ 2/9
1797            0 0 1 - IRQ 5
1798            0 1 0 - IRQ 12
1799            0 1 1 - IRQ 15
1800            1 0 0 - Reserved
1801            1 0 1 - Reserved
1802            1 1 0 - Reserved
1803            1 1 1 - Reserved
1804
1805            Bits 2:1 - Reserved
1806            Bit 0 - Disable Boot ROM
1807            0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1808            1 - memory accesses to 03FC30-03FFFFH are directed to external
1809            storage.
1810
1811         */
1812
1813         /* configure hardware: IRQ, enable interrupts,
1814            plus external 9-pin MIDI interface selected
1815         */
1816
1817         outb (0x80 | 0x40 | bits, dev->data_port);
1818
1819         /* CONTROL REGISTER
1820
1821            0 Host Rx Interrupt Enable (1=Enabled)      0x1
1822            1 Unused                                    0x2
1823            2 Unused                                    0x4
1824            3 Unused                                    0x8
1825            4 Host Tx Interrupt Enable                 0x10
1826            5 Mute (0=Mute; 1=Play)                    0x20
1827            6 Master Interrupt Enable (1=Enabled)      0x40
1828            7 Master Reset (0=Reset; 1=Run)            0x80
1829
1830            Take us out of reset, mute output, master + TX + RX interrupts on.
1831
1832            We'll get an interrupt presumably to tell us that the TX
1833            register is clear.
1834         */
1835
1836         wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1837                                          dev->control_port,
1838                                          (reset_time*HZ)/100);
1839
1840         /* Note: data port is now the data port, not the h/w initialization
1841            port.
1842          */
1843
1844         if (!dev->irq_ok) {
1845                 snd_printk ("intr not received after h/w un-reset.\n");
1846                 goto gone_bad;
1847         }
1848
1849         /* Note: data port is now the data port, not the h/w initialization
1850            port.
1851
1852            At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1853            will work. So, issue one of them, and wait for TX
1854            interrupt. This can take a *long* time after a cold boot,
1855            while the ISC ROM does its RAM test. The SDK says up to 4
1856            seconds - with 12MB of RAM on a Tropez+, it takes a lot
1857            longer than that (~16secs). Note that the card understands
1858            the difference between a warm and a cold boot, so
1859            subsequent ISC2115 reboots (say, caused by module
1860            reloading) will get through this much faster.
1861
1862            XXX Interesting question: why is no RX interrupt received first ?
1863         */
1864
1865         wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1866                                          dev->data_port, ramcheck_time*HZ);
1867
1868         if (!dev->irq_ok) {
1869                 snd_printk ("post-RAM-check interrupt not received.\n");
1870                 goto gone_bad;
1871         }
1872
1873         if (!wavefront_wait (dev, STAT_CAN_READ)) {
1874                 snd_printk ("no response to HW version cmd.\n");
1875                 goto gone_bad;
1876         }
1877
1878         if ((hwv[0] = wavefront_read (dev)) == -1) {
1879                 snd_printk ("board not responding correctly.\n");
1880                 goto gone_bad;
1881         }
1882
1883         if (hwv[0] == 0xFF) { /* NAK */
1884
1885                 /* Board's RAM test failed. Try to read error code,
1886                    and tell us about it either way.
1887                 */
1888
1889                 if ((hwv[0] = wavefront_read (dev)) == -1) {
1890                         snd_printk ("on-board RAM test failed "
1891                                     "(bad error code).\n");
1892                 } else {
1893                         snd_printk ("on-board RAM test failed "
1894                                     "(error code: 0x%x).\n",
1895                                 hwv[0]);
1896                 }
1897                 goto gone_bad;
1898         }
1899
1900         /* We're OK, just get the next byte of the HW version response */
1901
1902         if ((hwv[1] = wavefront_read (dev)) == -1) {
1903                 snd_printk ("incorrect h/w response.\n");
1904                 goto gone_bad;
1905         }
1906
1907         snd_printk ("hardware version %d.%d\n",
1908                     hwv[0], hwv[1]);
1909
1910         return 0;
1911
1912
1913      gone_bad:
1914         return (1);
1915 }
1916
1917 #include <linux/fs.h>
1918 #include <linux/mm.h>
1919 #include <linux/slab.h>
1920 #include <linux/unistd.h>
1921 #include <linux/syscalls.h>
1922 #include <asm/uaccess.h>
1923
1924
1925 static int __init
1926 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1927
1928 {
1929         unsigned char section[WF_SECTION_MAX];
1930         char section_length; /* yes, just a char; max value is WF_SECTION_MAX */
1931         int section_cnt_downloaded = 0;
1932         int fd;
1933         int c;
1934         int i;
1935         mm_segment_t fs;
1936
1937         /* This tries to be a bit cleverer than the stuff Alan Cox did for
1938            the generic sound firmware, in that it actually knows
1939            something about the structure of the Motorola firmware. In
1940            particular, it uses a version that has been stripped of the
1941            20K of useless header information, and had section lengths
1942            added, making it possible to load the entire OS without any
1943            [kv]malloc() activity, since the longest entity we ever read is
1944            42 bytes (well, WF_SECTION_MAX) long.
1945         */
1946
1947         fs = get_fs();
1948         set_fs (get_ds());
1949
1950         if ((fd = sys_open (path, 0, 0)) < 0) {
1951                 snd_printk ("Unable to load \"%s\".\n",
1952                         path);
1953                 return 1;
1954         }
1955
1956         while (1) {
1957                 int x;
1958
1959                 if ((x = sys_read (fd, &section_length, sizeof (section_length))) !=
1960                     sizeof (section_length)) {
1961                         snd_printk ("firmware read error.\n");
1962                         goto failure;
1963                 }
1964
1965                 if (section_length == 0) {
1966                         break;
1967                 }
1968
1969                 if (sys_read (fd, section, section_length) != section_length) {
1970                         snd_printk ("firmware section "
1971                                 "read error.\n");
1972                         goto failure;
1973                 }
1974
1975                 /* Send command */
1976
1977                 if (wavefront_write (dev, WFC_DOWNLOAD_OS)) {
1978                         goto failure;
1979                 }
1980
1981                 for (i = 0; i < section_length; i++) {
1982                         if (wavefront_write (dev, section[i])) {
1983                                 goto failure;
1984                         }
1985                 }
1986
1987                 /* get ACK */
1988
1989                 if (wavefront_wait (dev, STAT_CAN_READ)) {
1990
1991                         if ((c = inb (dev->data_port)) != WF_ACK) {
1992
1993                                 snd_printk ("download "
1994                                             "of section #%d not "
1995                                             "acknowledged, ack = 0x%x\n",
1996                                             section_cnt_downloaded + 1, c);
1997                                 goto failure;
1998
1999                         }
2000
2001                 } else {
2002                         snd_printk ("time out for firmware ACK.\n");
2003                         goto failure;
2004                 }
2005
2006         }
2007
2008         sys_close (fd);
2009         set_fs (fs);
2010         return 0;
2011
2012  failure:
2013         sys_close (fd);
2014         set_fs (fs);
2015         snd_printk ("firmware download failed!!!\n");
2016         return 1;
2017 }
2018
2019
2020 static int __init
2021 wavefront_do_reset (snd_wavefront_t *dev)
2022
2023 {
2024         char voices[1];
2025
2026         if (wavefront_reset_to_cleanliness (dev)) {
2027                 snd_printk ("hw reset failed.\n");
2028                 goto gone_bad;
2029         }
2030
2031         if (dev->israw) {
2032                 if (wavefront_download_firmware (dev, ospath)) {
2033                         goto gone_bad;
2034                 }
2035
2036                 dev->israw = 0;
2037
2038                 /* Wait for the OS to get running. The protocol for
2039                    this is non-obvious, and was determined by
2040                    using port-IO tracing in DOSemu and some
2041                    experimentation here.
2042
2043                    Rather than using timed waits, use interrupts creatively.
2044                 */
2045
2046                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2047                                                   dev->data_port,
2048                                                   (osrun_time*HZ));
2049
2050                 if (!dev->irq_ok) {
2051                         snd_printk ("no post-OS interrupt.\n");
2052                         goto gone_bad;
2053                 }
2054
2055                 /* Now, do it again ! */
2056
2057                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2058                                                   dev->data_port, (10*HZ));
2059
2060                 if (!dev->irq_ok) {
2061                         snd_printk ("no post-OS interrupt(2).\n");
2062                         goto gone_bad;
2063                 }
2064
2065                 /* OK, no (RX/TX) interrupts any more, but leave mute
2066                    in effect.
2067                 */
2068
2069                 outb (0x80|0x40, dev->control_port);
2070         }
2071
2072         /* SETUPSND.EXE asks for sample memory config here, but since i
2073            have no idea how to interpret the result, we'll forget
2074            about it.
2075         */
2076
2077         if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2078                 goto gone_bad;
2079         }
2080
2081         snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2082
2083         if (wavefront_write (dev, 0xf0) ||
2084             wavefront_write (dev, 1) ||
2085             (wavefront_read (dev) < 0)) {
2086                 dev->debug = 0;
2087                 snd_printk ("MPU emulation mode not set.\n");
2088                 goto gone_bad;
2089         }
2090
2091         voices[0] = 32;
2092
2093         if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, 0, voices)) {
2094                 snd_printk ("cannot set number of voices to 32.\n");
2095                 goto gone_bad;
2096         }
2097
2098
2099         return 0;
2100
2101  gone_bad:
2102         /* reset that sucker so that it doesn't bother us. */
2103
2104         outb (0x0, dev->control_port);
2105         dev->interrupts_are_midi = 0;
2106         return 1;
2107 }
2108
2109 int __init
2110 snd_wavefront_start (snd_wavefront_t *dev)
2111
2112 {
2113         int samples_are_from_rom;
2114
2115         /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2116            wavefront_reset_to_cleanliness() has already been called
2117         */
2118
2119         if (dev->israw) {
2120                 samples_are_from_rom = 1;
2121         } else {
2122                 /* XXX is this always true ? */
2123                 samples_are_from_rom = 0;
2124         }
2125
2126         if (dev->israw || fx_raw) {
2127                 if (wavefront_do_reset (dev)) {
2128                         return -1;
2129                 }
2130         }
2131         /* Check for FX device, present only on Tropez+ */
2132
2133         dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2134
2135         if (dev->has_fx && fx_raw) {
2136                 snd_wavefront_fx_start (dev);
2137         }
2138
2139         wavefront_get_sample_status (dev, samples_are_from_rom);
2140         wavefront_get_program_status (dev);
2141         wavefront_get_patch_status (dev);
2142
2143         /* Start normal operation: unreset, master interrupt enabled, no mute
2144         */
2145
2146         outb (0x80|0x40|0x20, dev->control_port);
2147
2148         return (0);
2149 }
2150
2151 int __init
2152 snd_wavefront_detect (snd_wavefront_card_t *card)
2153
2154 {
2155         unsigned char   rbuf[4], wbuf[4];
2156         snd_wavefront_t *dev = &card->wavefront;
2157
2158         /* returns zero if a WaveFront card is successfully detected.
2159            negative otherwise.
2160         */
2161
2162         dev->israw = 0;
2163         dev->has_fx = 0;
2164         dev->debug = debug_default;
2165         dev->interrupts_are_midi = 0;
2166         dev->irq_cnt = 0;
2167         dev->rom_samples_rdonly = 1;
2168
2169         if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2170
2171                 dev->fw_version[0] = rbuf[0];
2172                 dev->fw_version[1] = rbuf[1];
2173
2174                 snd_printk ("firmware %d.%d already loaded.\n",
2175                             rbuf[0], rbuf[1]);
2176
2177                 /* check that a command actually works */
2178
2179                 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2180                                        rbuf, wbuf) == 0) {
2181                         dev->hw_version[0] = rbuf[0];
2182                         dev->hw_version[1] = rbuf[1];
2183                 } else {
2184                         snd_printk ("not raw, but no "
2185                                     "hardware version!\n");
2186                         return -1;
2187                 }
2188
2189                 if (!wf_raw) {
2190                         return 0;
2191                 } else {
2192                         snd_printk ("reloading firmware as you requested.\n");
2193                         dev->israw = 1;
2194                 }
2195
2196         } else {
2197
2198                 dev->israw = 1;
2199                 snd_printk ("no response to firmware probe, assume raw.\n");
2200
2201         }
2202
2203         return 0;
2204 }