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 static 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 static 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 static 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 static char *ospath = "/etc/sound/wavefront.os"; /* where to find a processed
  57                                                     version of the WaveFront OS
  58                                                  */
  59
  60 static 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 static int sleep_interval = 100;   /* HZ/sleep_interval seconds per sleep */
  74 static int sleep_tries = 50;       /* number of times we'll try to sleep */
  75
  76 static int reset_time = 2;        /* hundreths of a second we wait after a HW
  77                                      reset for the expected interrupt.
  78                                   */
  79
  80 static int ramcheck_time = 20;    /* time in seconds to wait while ROM code
  81                                      checks on-board RAM.
  82                                   */
  83
  84 static 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 }
 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 = NULL;
 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, NULL, 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, NULL, 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, 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;
 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->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                            NULL, 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, NULL, NULL)) {
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, NULL, 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;
1205
1206         msample_hdr = kmalloc(sizeof(WF_MSAMPLE_BYTES), GFP_KERNEL);
1207         if (! msample_hdr)
1208                 return -ENOMEM;
1209
1210         munge_int32 (header->number, &msample_hdr[0], 2);
1211
1212         /* You'll recall at this point that the "number of samples" value
1213            in a wavefront_multisample struct is actually the log2 of the
1214            real number of samples.
1215         */
1216
1217         num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1218         msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1219
1220         DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1221                                       header->number,
1222                                       header->hdr.ms.NumberOfSamples,
1223                                       num_samples);
1224
1225         for (i = 0; i < num_samples; i++) {
1226                 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1227                        i, header->hdr.ms.SampleNumber[i]);
1228                 munge_int32 (header->hdr.ms.SampleNumber[i],
1229                      &msample_hdr[3+(i*2)], 2);
1230         }
1231
1232         /* Need a hack here to pass in the number of bytes
1233            to be written to the synth. This is ugly, and perhaps
1234            one day, I'll fix it.
1235         */
1236
1237         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1238                            (unsigned char *) (long) ((num_samples*2)+3),
1239                            msample_hdr)) {
1240                 snd_printk ("download of multisample failed.\n");
1241                 kfree(msample_hdr);
1242                 return -(EIO);
1243         }
1244
1245         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1246
1247         kfree(msample_hdr);
1248         return (0);
1249 }
1250
1251 static int
1252 wavefront_fetch_multisample (snd_wavefront_t *dev,
1253                              wavefront_patch_info *header)
1254 {
1255         int i;
1256         unsigned char log_ns[1];
1257         unsigned char number[2];
1258         int num_samples;
1259
1260         munge_int32 (header->number, number, 2);
1261
1262         if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1263                 snd_printk ("upload multisample failed.\n");
1264                 return -(EIO);
1265         }
1266
1267         DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1268                                 header->number, log_ns[0]);
1269
1270         header->hdr.ms.NumberOfSamples = log_ns[0];
1271
1272         /* get the number of samples ... */
1273
1274         num_samples = (1 << log_ns[0]);
1275
1276         for (i = 0; i < num_samples; i++) {
1277                 char d[2];
1278                 int val;
1279
1280                 if ((val = wavefront_read (dev)) == -1) {
1281                         snd_printk ("upload multisample failed "
1282                                     "during sample loop.\n");
1283                         return -(EIO);
1284                 }
1285                 d[0] = val;
1286
1287                 if ((val = wavefront_read (dev)) == -1) {
1288                         snd_printk ("upload multisample failed "
1289                                     "during sample loop.\n");
1290                         return -(EIO);
1291                 }
1292                 d[1] = val;
1293
1294                 header->hdr.ms.SampleNumber[i] =
1295                         demunge_int32 ((unsigned char *) d, 2);
1296
1297                 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1298                                         i, header->hdr.ms.SampleNumber[i]);
1299         }
1300
1301         return (0);
1302 }
1303
1304
1305 static int
1306 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1307
1308 {
1309         unsigned char drumbuf[WF_DRUM_BYTES];
1310         wavefront_drum *drum = &header->hdr.d;
1311         int i;
1312
1313         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1314                 "note %d, patch = %d\n",
1315                 header->number, drum->PatchNumber);
1316
1317         drumbuf[0] = header->number & 0x7f;
1318
1319         for (i = 0; i < 4; i++) {
1320                 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1321         }
1322
1323         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1324                 snd_printk ("download drum failed.\n");
1325                 return -(EIO);
1326         }
1327
1328         return (0);
1329 }
1330
1331 static int
1332 wavefront_find_free_sample (snd_wavefront_t *dev)
1333
1334 {
1335         int i;
1336
1337         for (i = 0; i < WF_MAX_SAMPLE; i++) {
1338                 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1339                         return i;
1340                 }
1341         }
1342         snd_printk ("no free sample slots!\n");
1343         return -1;
1344 }
1345
1346 #if 0
1347 static int
1348 wavefront_find_free_patch (snd_wavefront_t *dev)
1349
1350 {
1351         int i;
1352
1353         for (i = 0; i < WF_MAX_PATCH; i++) {
1354                 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1355                         return i;
1356                 }
1357         }
1358         snd_printk ("no free patch slots!\n");
1359         return -1;
1360 }
1361 #endif
1362
1363 static int
1364 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1365 {
1366         wavefront_patch_info *header;
1367         int err;
1368
1369         header = kmalloc(sizeof(*header), GFP_KERNEL);
1370         if (! header)
1371                 return -ENOMEM;
1372
1373         if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1374                             sizeof(wavefront_any))) {
1375                 snd_printk ("bad address for load patch.\n");
1376                 err = -EFAULT;
1377                 goto __error;
1378         }
1379
1380         DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1381                                       "Sample type: %d "
1382                                       "Sample number: %d "
1383                                       "Sample size: %d\n",
1384                                       header->subkey,
1385                                       header->number,
1386                                       header->size);
1387
1388         switch (header->subkey) {
1389         case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */
1390
1391                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1392                                     sizeof (wavefront_sample))) {
1393                         err = -EFAULT;
1394                         break;
1395                 }
1396
1397                 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1398                 break;
1399
1400         case WF_ST_MULTISAMPLE:
1401
1402                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1403                                     sizeof (wavefront_multisample))) {
1404                         err = -EFAULT;
1405                         break;
1406                 }
1407
1408                 err = wavefront_send_multisample (dev, header);
1409                 break;
1410
1411         case WF_ST_ALIAS:
1412
1413                 if (copy_from_user (&header->hdr.a, header->hdrptr,
1414                                     sizeof (wavefront_alias))) {
1415                         err = -EFAULT;
1416                         break;
1417                 }
1418
1419                 err = wavefront_send_alias (dev, header);
1420                 break;
1421
1422         case WF_ST_DRUM:
1423                 if (copy_from_user (&header->hdr.d, header->hdrptr,
1424                                     sizeof (wavefront_drum))) {
1425                         err = -EFAULT;
1426                         break;
1427                 }
1428
1429                 err = wavefront_send_drum (dev, header);
1430                 break;
1431
1432         case WF_ST_PATCH:
1433                 if (copy_from_user (&header->hdr.p, header->hdrptr,
1434                                     sizeof (wavefront_patch))) {
1435                         err = -EFAULT;
1436                         break;
1437                 }
1438
1439                 err = wavefront_send_patch (dev, header);
1440                 break;
1441
1442         case WF_ST_PROGRAM:
1443                 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1444                                     sizeof (wavefront_program))) {
1445                         err = -EFAULT;
1446                         break;
1447                 }
1448
1449                 err = wavefront_send_program (dev, header);
1450                 break;
1451
1452         default:
1453                 snd_printk ("unknown patch type %d.\n",
1454                             header->subkey);
1455                 err = -EINVAL;
1456                 break;
1457         }
1458
1459  __error:
1460         kfree(header);
1461         return err;
1462 }
1463 \f
1464 /***********************************************************************
1465 WaveFront: hardware-dependent interface
1466 ***********************************************************************/
1467
1468 static void
1469 process_sample_hdr (u8 *buf)
1470
1471 {
1472         wavefront_sample s;
1473         u8 *ptr;
1474
1475         ptr = buf;
1476
1477         /* The board doesn't send us an exact copy of a "wavefront_sample"
1478            in response to an Upload Sample Header command. Instead, we
1479            have to convert the data format back into our data structure,
1480            just as in the Download Sample command, where we have to do
1481            something very similar in the reverse direction.
1482         */
1483
1484         *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1485         *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1486         *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1487         *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1488         *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1489
1490         s.SampleResolution = *ptr & 0x3;
1491         s.Loop = *ptr & 0x8;
1492         s.Bidirectional = *ptr & 0x10;
1493         s.Reverse = *ptr & 0x40;
1494
1495         /* Now copy it back to where it came from */
1496
1497         memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1498 }
1499
1500 static int
1501 wavefront_synth_control (snd_wavefront_card_t *acard,
1502                          wavefront_control *wc)
1503
1504 {
1505         snd_wavefront_t *dev = &acard->wavefront;
1506         unsigned char patchnumbuf[2];
1507         int i;
1508
1509         DPRINT (WF_DEBUG_CMD, "synth control with "
1510                 "cmd 0x%x\n", wc->cmd);
1511
1512         /* Pre-handling of or for various commands */
1513
1514         switch (wc->cmd) {
1515
1516         case WFC_DISABLE_INTERRUPTS:
1517                 snd_printk ("interrupts disabled.\n");
1518                 outb (0x80|0x20, dev->control_port);
1519                 dev->interrupts_are_midi = 1;
1520                 return 0;
1521
1522         case WFC_ENABLE_INTERRUPTS:
1523                 snd_printk ("interrupts enabled.\n");
1524                 outb (0x80|0x40|0x20, dev->control_port);
1525                 dev->interrupts_are_midi = 1;
1526                 return 0;
1527
1528         case WFC_INTERRUPT_STATUS:
1529                 wc->rbuf[0] = dev->interrupts_are_midi;
1530                 return 0;
1531
1532         case WFC_ROMSAMPLES_RDONLY:
1533                 dev->rom_samples_rdonly = wc->wbuf[0];
1534                 wc->status = 0;
1535                 return 0;
1536
1537         case WFC_IDENTIFY_SLOT_TYPE:
1538                 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1539                 if (i <0 || i >= WF_MAX_SAMPLE) {
1540                         snd_printk ("invalid slot ID %d\n",
1541                                 i);
1542                         wc->status = EINVAL;
1543                         return -EINVAL;
1544                 }
1545                 wc->rbuf[0] = dev->sample_status[i];
1546                 wc->status = 0;
1547                 return 0;
1548
1549         case WFC_DEBUG_DRIVER:
1550                 dev->debug = wc->wbuf[0];
1551                 snd_printk ("debug = 0x%x\n", dev->debug);
1552                 return 0;
1553
1554         case WFC_UPLOAD_PATCH:
1555                 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1556                 memcpy (wc->wbuf, patchnumbuf, 2);
1557                 break;
1558
1559         case WFC_UPLOAD_MULTISAMPLE:
1560                 /* multisamples have to be handled differently, and
1561                    cannot be dealt with properly by snd_wavefront_cmd() alone.
1562                 */
1563                 wc->status = wavefront_fetch_multisample
1564                         (dev, (wavefront_patch_info *) wc->rbuf);
1565                 return 0;
1566
1567         case WFC_UPLOAD_SAMPLE_ALIAS:
1568                 snd_printk ("support for sample alias upload "
1569                         "being considered.\n");
1570                 wc->status = EINVAL;
1571                 return -EINVAL;
1572         }
1573
1574         wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1575
1576         /* Post-handling of certain commands.
1577
1578            In particular, if the command was an upload, demunge the data
1579            so that the user-level doesn't have to think about it.
1580         */
1581
1582         if (wc->status == 0) {
1583                 switch (wc->cmd) {
1584                         /* intercept any freemem requests so that we know
1585                            we are always current with the user-level view
1586                            of things.
1587                         */
1588
1589                 case WFC_REPORT_FREE_MEMORY:
1590                         dev->freemem = demunge_int32 (wc->rbuf, 4);
1591                         break;
1592
1593                 case WFC_UPLOAD_PATCH:
1594                         demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1595                         break;
1596
1597                 case WFC_UPLOAD_PROGRAM:
1598                         demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1599                         break;
1600
1601                 case WFC_UPLOAD_EDRUM_PROGRAM:
1602                         demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1603                         break;
1604
1605                 case WFC_UPLOAD_SAMPLE_HEADER:
1606                         process_sample_hdr (wc->rbuf);
1607                         break;
1608
1609                 case WFC_UPLOAD_SAMPLE_ALIAS:
1610                         snd_printk ("support for "
1611                                     "sample aliases still "
1612                                     "being considered.\n");
1613                         break;
1614
1615                 case WFC_VMIDI_OFF:
1616                         snd_wavefront_midi_disable_virtual (acard);
1617                         break;
1618
1619                 case WFC_VMIDI_ON:
1620                         snd_wavefront_midi_enable_virtual (acard);
1621                         break;
1622                 }
1623         }
1624
1625         return 0;
1626 }
1627
1628 int
1629 snd_wavefront_synth_open (snd_hwdep_t *hw, struct file *file)
1630
1631 {
1632         if (!try_module_get(hw->card->module))
1633                 return -EFAULT;
1634         file->private_data = hw;
1635         return 0;
1636 }
1637
1638 int
1639 snd_wavefront_synth_release (snd_hwdep_t *hw, struct file *file)
1640
1641 {
1642         module_put(hw->card->module);
1643         return 0;
1644 }
1645
1646 int
1647 snd_wavefront_synth_ioctl (snd_hwdep_t *hw, struct file *file,
1648                            unsigned int cmd, unsigned long arg)
1649
1650 {
1651         snd_card_t *card;
1652         snd_wavefront_t *dev;
1653         snd_wavefront_card_t *acard;
1654         wavefront_control *wc;
1655         void __user *argp = (void __user *)arg;
1656         int err;
1657
1658         card = (snd_card_t *) hw->card;
1659
1660         snd_assert(card != NULL, return -ENODEV);
1661
1662         snd_assert(card->private_data != NULL, return -ENODEV);
1663
1664         acard = card->private_data;
1665         dev = &acard->wavefront;
1666
1667         switch (cmd) {
1668         case WFCTL_LOAD_SPP:
1669                 if (wavefront_load_patch (dev, argp) != 0) {
1670                         return -EIO;
1671                 }
1672                 break;
1673
1674         case WFCTL_WFCMD:
1675                 wc = kmalloc(sizeof(*wc), GFP_KERNEL);
1676                 if (! wc)
1677                         return -ENOMEM;
1678                 if (copy_from_user (wc, argp, sizeof (*wc)))
1679                         err = -EFAULT;
1680                 else if (wavefront_synth_control (acard, wc) < 0)
1681                         err = -EIO;
1682                 else if (copy_to_user (argp, wc, sizeof (*wc)))
1683                         err = -EFAULT;
1684                 else
1685                         err = 0;
1686                 kfree(wc);
1687                 return err;
1688
1689         default:
1690                 return -EINVAL;
1691         }
1692
1693         return 0;
1694 }
1695
1696 \f
1697 /***********************************************************************/
1698 /*  WaveFront: interface for card-level wavefront module               */
1699 /***********************************************************************/
1700
1701 void
1702 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1703 {
1704         snd_wavefront_t *dev = &card->wavefront;
1705
1706         /*
1707            Some comments on interrupts. I attempted a version of this
1708            driver that used interrupts throughout the code instead of
1709            doing busy and/or sleep-waiting. Alas, it appears that once
1710            the Motorola firmware is downloaded, the card *never*
1711            generates an RX interrupt. These are successfully generated
1712            during firmware loading, and after that wavefront_status()
1713            reports that an interrupt is pending on the card from time
1714            to time, but it never seems to be delivered to this
1715            driver. Note also that wavefront_status() continues to
1716            report that RX interrupts are enabled, suggesting that I
1717            didn't goof up and disable them by mistake.
1718
1719            Thus, I stepped back to a prior version of
1720            wavefront_wait(), the only place where this really
1721            matters. Its sad, but I've looked through the code to check
1722            on things, and I really feel certain that the Motorola
1723            firmware prevents RX-ready interrupts.
1724         */
1725
1726         if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1727                 return;
1728         }
1729
1730         spin_lock(&dev->irq_lock);
1731         dev->irq_ok = 1;
1732         dev->irq_cnt++;
1733         spin_unlock(&dev->irq_lock);
1734         wake_up(&dev->interrupt_sleeper);
1735 }
1736
1737 /* STATUS REGISTER
1738
1739 0 Host Rx Interrupt Enable (1=Enabled)
1740 1 Host Rx Register Full (1=Full)
1741 2 Host Rx Interrupt Pending (1=Interrupt)
1742 3 Unused
1743 4 Host Tx Interrupt (1=Enabled)
1744 5 Host Tx Register empty (1=Empty)
1745 6 Host Tx Interrupt Pending (1=Interrupt)
1746 7 Unused
1747 */
1748
1749 static int __init
1750 snd_wavefront_interrupt_bits (int irq)
1751
1752 {
1753         int bits;
1754
1755         switch (irq) {
1756         case 9:
1757                 bits = 0x00;
1758                 break;
1759         case 5:
1760                 bits = 0x08;
1761                 break;
1762         case 12:
1763                 bits = 0x10;
1764                 break;
1765         case 15:
1766                 bits = 0x18;
1767                 break;
1768
1769         default:
1770                 snd_printk ("invalid IRQ %d\n", irq);
1771                 bits = -1;
1772         }
1773
1774         return bits;
1775 }
1776
1777 static void __init
1778 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1779                                   int val, int port, int timeout)
1780
1781 {
1782         wait_queue_t wait;
1783
1784         init_waitqueue_entry(&wait, current);
1785         spin_lock_irq(&dev->irq_lock);
1786         add_wait_queue(&dev->interrupt_sleeper, &wait);
1787         dev->irq_ok = 0;
1788         outb (val,port);
1789         spin_unlock_irq(&dev->irq_lock);
1790         while (1) {
1791                 set_current_state(TASK_INTERRUPTIBLE);
1792                 if ((timeout = schedule_timeout(timeout)) == 0)
1793                         return;
1794                 if (dev->irq_ok)
1795                         return;
1796         }
1797 }
1798
1799 static int __init
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 #include <linux/fs.h>
1951 #include <linux/mm.h>
1952 #include <linux/slab.h>
1953 #include <linux/unistd.h>
1954 #include <linux/syscalls.h>
1955 #include <asm/uaccess.h>
1956
1957
1958 static int __init
1959 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1960
1961 {
1962         unsigned char section[WF_SECTION_MAX];
1963         signed char section_length; /* yes, just a char; max value is WF_SECTION_MAX */
1964         int section_cnt_downloaded = 0;
1965         int fd;
1966         int c;
1967         int i;
1968         mm_segment_t fs;
1969
1970         /* This tries to be a bit cleverer than the stuff Alan Cox did for
1971            the generic sound firmware, in that it actually knows
1972            something about the structure of the Motorola firmware. In
1973            particular, it uses a version that has been stripped of the
1974            20K of useless header information, and had section lengths
1975            added, making it possible to load the entire OS without any
1976            [kv]malloc() activity, since the longest entity we ever read is
1977            42 bytes (well, WF_SECTION_MAX) long.
1978         */
1979
1980         fs = get_fs();
1981         set_fs (get_ds());
1982
1983         if ((fd = sys_open ((char __user *) path, 0, 0)) < 0) {
1984                 snd_printk ("Unable to load \"%s\".\n",
1985                         path);
1986                 return 1;
1987         }
1988
1989         while (1) {
1990                 int x;
1991
1992                 if ((x = sys_read (fd, (char __user *) &section_length, sizeof (section_length))) !=
1993                     sizeof (section_length)) {
1994                         snd_printk ("firmware read error.\n");
1995                         goto failure;
1996                 }
1997
1998                 if (section_length == 0) {
1999                         break;
2000                 }
2001
2002                 if (section_length < 0 || section_length > WF_SECTION_MAX) {
2003                         snd_printk ("invalid firmware section length %d\n",
2004                                     section_length);
2005                         goto failure;
2006                 }
2007
2008                 if (sys_read (fd, (char __user *) section, section_length) != section_length) {
2009                         snd_printk ("firmware section "
2010                                 "read error.\n");
2011                         goto failure;
2012                 }
2013
2014                 /* Send command */
2015
2016                 if (wavefront_write (dev, WFC_DOWNLOAD_OS)) {
2017                         goto failure;
2018                 }
2019
2020                 for (i = 0; i < section_length; i++) {
2021                         if (wavefront_write (dev, section[i])) {
2022                                 goto failure;
2023                         }
2024                 }
2025
2026                 /* get ACK */
2027
2028                 if (wavefront_wait (dev, STAT_CAN_READ)) {
2029
2030                         if ((c = inb (dev->data_port)) != WF_ACK) {
2031
2032                                 snd_printk ("download "
2033                                             "of section #%d not "
2034                                             "acknowledged, ack = 0x%x\n",
2035                                             section_cnt_downloaded + 1, c);
2036                                 goto failure;
2037
2038                         }
2039
2040                 } else {
2041                         snd_printk ("time out for firmware ACK.\n");
2042                         goto failure;
2043                 }
2044
2045         }
2046
2047         sys_close (fd);
2048         set_fs (fs);
2049         return 0;
2050
2051  failure:
2052         sys_close (fd);
2053         set_fs (fs);
2054         snd_printk ("firmware download failed!!!\n");
2055         return 1;
2056 }
2057
2058
2059 static int __init
2060 wavefront_do_reset (snd_wavefront_t *dev)
2061
2062 {
2063         char voices[1];
2064
2065         if (wavefront_reset_to_cleanliness (dev)) {
2066                 snd_printk ("hw reset failed.\n");
2067                 goto gone_bad;
2068         }
2069
2070         if (dev->israw) {
2071                 if (wavefront_download_firmware (dev, ospath)) {
2072                         goto gone_bad;
2073                 }
2074
2075                 dev->israw = 0;
2076
2077                 /* Wait for the OS to get running. The protocol for
2078                    this is non-obvious, and was determined by
2079                    using port-IO tracing in DOSemu and some
2080                    experimentation here.
2081
2082                    Rather than using timed waits, use interrupts creatively.
2083                 */
2084
2085                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2086                                                   dev->data_port,
2087                                                   (osrun_time*HZ));
2088
2089                 if (!dev->irq_ok) {
2090                         snd_printk ("no post-OS interrupt.\n");
2091                         goto gone_bad;
2092                 }
2093
2094                 /* Now, do it again ! */
2095
2096                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2097                                                   dev->data_port, (10*HZ));
2098
2099                 if (!dev->irq_ok) {
2100                         snd_printk ("no post-OS interrupt(2).\n");
2101                         goto gone_bad;
2102                 }
2103
2104                 /* OK, no (RX/TX) interrupts any more, but leave mute
2105                    in effect.
2106                 */
2107
2108                 outb (0x80|0x40, dev->control_port);
2109         }
2110
2111         /* SETUPSND.EXE asks for sample memory config here, but since i
2112            have no idea how to interpret the result, we'll forget
2113            about it.
2114         */
2115
2116         if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2117                 goto gone_bad;
2118         }
2119
2120         snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2121
2122         if (wavefront_write (dev, 0xf0) ||
2123             wavefront_write (dev, 1) ||
2124             (wavefront_read (dev) < 0)) {
2125                 dev->debug = 0;
2126                 snd_printk ("MPU emulation mode not set.\n");
2127                 goto gone_bad;
2128         }
2129
2130         voices[0] = 32;
2131
2132         if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2133                 snd_printk ("cannot set number of voices to 32.\n");
2134                 goto gone_bad;
2135         }
2136
2137
2138         return 0;
2139
2140  gone_bad:
2141         /* reset that sucker so that it doesn't bother us. */
2142
2143         outb (0x0, dev->control_port);
2144         dev->interrupts_are_midi = 0;
2145         return 1;
2146 }
2147
2148 int __init
2149 snd_wavefront_start (snd_wavefront_t *dev)
2150
2151 {
2152         int samples_are_from_rom;
2153
2154         /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2155            wavefront_reset_to_cleanliness() has already been called
2156         */
2157
2158         if (dev->israw) {
2159                 samples_are_from_rom = 1;
2160         } else {
2161                 /* XXX is this always true ? */
2162                 samples_are_from_rom = 0;
2163         }
2164
2165         if (dev->israw || fx_raw) {
2166                 if (wavefront_do_reset (dev)) {
2167                         return -1;
2168                 }
2169         }
2170         /* Check for FX device, present only on Tropez+ */
2171
2172         dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2173
2174         if (dev->has_fx && fx_raw) {
2175                 snd_wavefront_fx_start (dev);
2176         }
2177
2178         wavefront_get_sample_status (dev, samples_are_from_rom);
2179         wavefront_get_program_status (dev);
2180         wavefront_get_patch_status (dev);
2181
2182         /* Start normal operation: unreset, master interrupt enabled, no mute
2183         */
2184
2185         outb (0x80|0x40|0x20, dev->control_port);
2186
2187         return (0);
2188 }
2189
2190 int __init
2191 snd_wavefront_detect (snd_wavefront_card_t *card)
2192
2193 {
2194         unsigned char   rbuf[4], wbuf[4];
2195         snd_wavefront_t *dev = &card->wavefront;
2196
2197         /* returns zero if a WaveFront card is successfully detected.
2198            negative otherwise.
2199         */
2200
2201         dev->israw = 0;
2202         dev->has_fx = 0;
2203         dev->debug = debug_default;
2204         dev->interrupts_are_midi = 0;
2205         dev->irq_cnt = 0;
2206         dev->rom_samples_rdonly = 1;
2207
2208         if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2209
2210                 dev->fw_version[0] = rbuf[0];
2211                 dev->fw_version[1] = rbuf[1];
2212
2213                 snd_printk ("firmware %d.%d already loaded.\n",
2214                             rbuf[0], rbuf[1]);
2215
2216                 /* check that a command actually works */
2217
2218                 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2219                                        rbuf, wbuf) == 0) {
2220                         dev->hw_version[0] = rbuf[0];
2221                         dev->hw_version[1] = rbuf[1];
2222                 } else {
2223                         snd_printk ("not raw, but no "
2224                                     "hardware version!\n");
2225                         return -1;
2226                 }
2227
2228                 if (!wf_raw) {
2229                         return 0;
2230                 } else {
2231                         snd_printk ("reloading firmware as you requested.\n");
2232                         dev->israw = 1;
2233                 }
2234
2235         } else {
2236
2237                 dev->israw = 1;
2238                 snd_printk ("no response to firmware probe, assume raw.\n");
2239
2240         }
2241
2242         return 0;
2243 }