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