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