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