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