sound/isa/wavefront/wavefront_synth.c

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