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