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