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 	if (header->number >= WF_MAX_SAMPLE)
1176 		return -EINVAL;
1177 
1178 	munge_int32 (header->number, &alias_hdr[0], 2);
1179 	munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1180 	munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1181 		     &alias_hdr[4], 4);
1182 	munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1183 		     &alias_hdr[8], 4);
1184 	munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1185 		     &alias_hdr[12], 4);
1186 	munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1187 		     &alias_hdr[16], 4);
1188 	munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1189 	munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1190 
1191 	if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1192 		snd_printk ("download alias failed.\n");
1193 		return -EIO;
1194 	}
1195 
1196 	dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1197 
1198 	return (0);
1199 }
1200 
1201 static int
1202 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1203 {
1204 	int i;
1205 	int num_samples;
1206 	unsigned char *msample_hdr;
1207 
1208 	if (header->number >= WF_MAX_SAMPLE)
1209 		return -EINVAL;
1210 
1211 	msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1212 	if (! msample_hdr)
1213 		return -ENOMEM;
1214 
1215 	munge_int32 (header->number, &msample_hdr[0], 2);
1216 
1217 	/* You'll recall at this point that the "number of samples" value
1218 	   in a wavefront_multisample struct is actually the log2 of the
1219 	   real number of samples.
1220 	*/
1221 
1222 	num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1223 	msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1224 
1225 	DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1226 				      header->number,
1227 				      header->hdr.ms.NumberOfSamples,
1228 				      num_samples);
1229 
1230 	for (i = 0; i < num_samples; i++) {
1231 		DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1232 		       i, header->hdr.ms.SampleNumber[i]);
1233 		munge_int32 (header->hdr.ms.SampleNumber[i],
1234 		     &msample_hdr[3+(i*2)], 2);
1235 	}
1236 
1237 	/* Need a hack here to pass in the number of bytes
1238 	   to be written to the synth. This is ugly, and perhaps
1239 	   one day, I'll fix it.
1240 	*/
1241 
1242 	if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1243 			   (unsigned char *) (long) ((num_samples*2)+3),
1244 			   msample_hdr)) {
1245 		snd_printk ("download of multisample failed.\n");
1246 		kfree(msample_hdr);
1247 		return -EIO;
1248 	}
1249 
1250 	dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1251 
1252 	kfree(msample_hdr);
1253 	return (0);
1254 }
1255 
1256 static int
1257 wavefront_fetch_multisample (snd_wavefront_t *dev,
1258 			     wavefront_patch_info *header)
1259 {
1260 	int i;
1261 	unsigned char log_ns[1];
1262 	unsigned char number[2];
1263 	int num_samples;
1264 
1265 	munge_int32 (header->number, number, 2);
1266 
1267 	if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1268 		snd_printk ("upload multisample failed.\n");
1269 		return -EIO;
1270 	}
1271 
1272 	DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1273 				header->number, log_ns[0]);
1274 
1275 	header->hdr.ms.NumberOfSamples = log_ns[0];
1276 
1277 	/* get the number of samples ... */
1278 
1279 	num_samples = (1 << log_ns[0]);
1280 
1281 	for (i = 0; i < num_samples; i++) {
1282 		char d[2];
1283 		int val;
1284 
1285 		if ((val = wavefront_read (dev)) == -1) {
1286 			snd_printk ("upload multisample failed "
1287 				    "during sample loop.\n");
1288 			return -EIO;
1289 		}
1290 		d[0] = val;
1291 
1292 		if ((val = wavefront_read (dev)) == -1) {
1293 			snd_printk ("upload multisample failed "
1294 				    "during sample loop.\n");
1295 			return -EIO;
1296 		}
1297 		d[1] = val;
1298 
1299 		header->hdr.ms.SampleNumber[i] =
1300 			demunge_int32 ((unsigned char *) d, 2);
1301 
1302 		DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1303 					i, header->hdr.ms.SampleNumber[i]);
1304 	}
1305 
1306 	return (0);
1307 }
1308 
1309 
1310 static int
1311 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1312 
1313 {
1314 	unsigned char drumbuf[WF_DRUM_BYTES];
1315 	wavefront_drum *drum = &header->hdr.d;
1316 	int i;
1317 
1318 	DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1319 		"note %d, patch = %d\n",
1320 		header->number, drum->PatchNumber);
1321 
1322 	drumbuf[0] = header->number & 0x7f;
1323 
1324 	for (i = 0; i < 4; i++) {
1325 		munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1326 	}
1327 
1328 	if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1329 		snd_printk ("download drum failed.\n");
1330 		return -EIO;
1331 	}
1332 
1333 	return (0);
1334 }
1335 
1336 static int
1337 wavefront_find_free_sample (snd_wavefront_t *dev)
1338 
1339 {
1340 	int i;
1341 
1342 	for (i = 0; i < WF_MAX_SAMPLE; i++) {
1343 		if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1344 			return i;
1345 		}
1346 	}
1347 	snd_printk ("no free sample slots!\n");
1348 	return -1;
1349 }
1350 
1351 #if 0
1352 static int
1353 wavefront_find_free_patch (snd_wavefront_t *dev)
1354 
1355 {
1356 	int i;
1357 
1358 	for (i = 0; i < WF_MAX_PATCH; i++) {
1359 		if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1360 			return i;
1361 		}
1362 	}
1363 	snd_printk ("no free patch slots!\n");
1364 	return -1;
1365 }
1366 #endif
1367 
1368 static int
1369 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1370 {
1371 	wavefront_patch_info *header;
1372 	int err;
1373 
1374 	header = kmalloc(sizeof(*header), GFP_KERNEL);
1375 	if (! header)
1376 		return -ENOMEM;
1377 
1378 	if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1379 			    sizeof(wavefront_any))) {
1380 		snd_printk ("bad address for load patch.\n");
1381 		err = -EFAULT;
1382 		goto __error;
1383 	}
1384 
1385 	DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1386 				      "Sample type: %d "
1387 				      "Sample number: %d "
1388 				      "Sample size: %d\n",
1389 				      header->subkey,
1390 				      header->number,
1391 				      header->size);
1392 
1393 	switch (header->subkey) {
1394 	case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */
1395 
1396 		if (copy_from_user (&header->hdr.s, header->hdrptr,
1397 				    sizeof (wavefront_sample))) {
1398 			err = -EFAULT;
1399 			break;
1400 		}
1401 
1402 		err = wavefront_send_sample (dev, header, header->dataptr, 0);
1403 		break;
1404 
1405 	case WF_ST_MULTISAMPLE:
1406 
1407 		if (copy_from_user (&header->hdr.s, header->hdrptr,
1408 				    sizeof (wavefront_multisample))) {
1409 			err = -EFAULT;
1410 			break;
1411 		}
1412 
1413 		err = wavefront_send_multisample (dev, header);
1414 		break;
1415 
1416 	case WF_ST_ALIAS:
1417 
1418 		if (copy_from_user (&header->hdr.a, header->hdrptr,
1419 				    sizeof (wavefront_alias))) {
1420 			err = -EFAULT;
1421 			break;
1422 		}
1423 
1424 		err = wavefront_send_alias (dev, header);
1425 		break;
1426 
1427 	case WF_ST_DRUM:
1428 		if (copy_from_user (&header->hdr.d, header->hdrptr,
1429 				    sizeof (wavefront_drum))) {
1430 			err = -EFAULT;
1431 			break;
1432 		}
1433 
1434 		err = wavefront_send_drum (dev, header);
1435 		break;
1436 
1437 	case WF_ST_PATCH:
1438 		if (copy_from_user (&header->hdr.p, header->hdrptr,
1439 				    sizeof (wavefront_patch))) {
1440 			err = -EFAULT;
1441 			break;
1442 		}
1443 
1444 		err = wavefront_send_patch (dev, header);
1445 		break;
1446 
1447 	case WF_ST_PROGRAM:
1448 		if (copy_from_user (&header->hdr.pr, header->hdrptr,
1449 				    sizeof (wavefront_program))) {
1450 			err = -EFAULT;
1451 			break;
1452 		}
1453 
1454 		err = wavefront_send_program (dev, header);
1455 		break;
1456 
1457 	default:
1458 		snd_printk ("unknown patch type %d.\n",
1459 			    header->subkey);
1460 		err = -EINVAL;
1461 		break;
1462 	}
1463 
1464  __error:
1465 	kfree(header);
1466 	return err;
1467 }
1468 
1469 /***********************************************************************
1470 WaveFront: hardware-dependent interface
1471 ***********************************************************************/
1472 
1473 static void
1474 process_sample_hdr (u8 *buf)
1475 
1476 {
1477 	wavefront_sample s;
1478 	u8 *ptr;
1479 
1480 	ptr = buf;
1481 
1482 	/* The board doesn't send us an exact copy of a "wavefront_sample"
1483 	   in response to an Upload Sample Header command. Instead, we
1484 	   have to convert the data format back into our data structure,
1485 	   just as in the Download Sample command, where we have to do
1486 	   something very similar in the reverse direction.
1487 	*/
1488 
1489 	*((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1490 	*((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1491 	*((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1492 	*((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1493 	*((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1494 
1495 	s.SampleResolution = *ptr & 0x3;
1496 	s.Loop = *ptr & 0x8;
1497 	s.Bidirectional = *ptr & 0x10;
1498 	s.Reverse = *ptr & 0x40;
1499 
1500 	/* Now copy it back to where it came from */
1501 
1502 	memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1503 }
1504 
1505 static int
1506 wavefront_synth_control (snd_wavefront_card_t *acard,
1507 			 wavefront_control *wc)
1508 
1509 {
1510 	snd_wavefront_t *dev = &acard->wavefront;
1511 	unsigned char patchnumbuf[2];
1512 	int i;
1513 
1514 	DPRINT (WF_DEBUG_CMD, "synth control with "
1515 		"cmd 0x%x\n", wc->cmd);
1516 
1517 	/* Pre-handling of or for various commands */
1518 
1519 	switch (wc->cmd) {
1520 
1521 	case WFC_DISABLE_INTERRUPTS:
1522 		snd_printk ("interrupts disabled.\n");
1523 		outb (0x80|0x20, dev->control_port);
1524 		dev->interrupts_are_midi = 1;
1525 		return 0;
1526 
1527 	case WFC_ENABLE_INTERRUPTS:
1528 		snd_printk ("interrupts enabled.\n");
1529 		outb (0x80|0x40|0x20, dev->control_port);
1530 		dev->interrupts_are_midi = 1;
1531 		return 0;
1532 
1533 	case WFC_INTERRUPT_STATUS:
1534 		wc->rbuf[0] = dev->interrupts_are_midi;
1535 		return 0;
1536 
1537 	case WFC_ROMSAMPLES_RDONLY:
1538 		dev->rom_samples_rdonly = wc->wbuf[0];
1539 		wc->status = 0;
1540 		return 0;
1541 
1542 	case WFC_IDENTIFY_SLOT_TYPE:
1543 		i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1544 		if (i <0 || i >= WF_MAX_SAMPLE) {
1545 			snd_printk ("invalid slot ID %d\n",
1546 				i);
1547 			wc->status = EINVAL;
1548 			return -EINVAL;
1549 		}
1550 		wc->rbuf[0] = dev->sample_status[i];
1551 		wc->status = 0;
1552 		return 0;
1553 
1554 	case WFC_DEBUG_DRIVER:
1555 		dev->debug = wc->wbuf[0];
1556 		snd_printk ("debug = 0x%x\n", dev->debug);
1557 		return 0;
1558 
1559 	case WFC_UPLOAD_PATCH:
1560 		munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1561 		memcpy (wc->wbuf, patchnumbuf, 2);
1562 		break;
1563 
1564 	case WFC_UPLOAD_MULTISAMPLE:
1565 		/* multisamples have to be handled differently, and
1566 		   cannot be dealt with properly by snd_wavefront_cmd() alone.
1567 		*/
1568 		wc->status = wavefront_fetch_multisample
1569 			(dev, (wavefront_patch_info *) wc->rbuf);
1570 		return 0;
1571 
1572 	case WFC_UPLOAD_SAMPLE_ALIAS:
1573 		snd_printk ("support for sample alias upload "
1574 			"being considered.\n");
1575 		wc->status = EINVAL;
1576 		return -EINVAL;
1577 	}
1578 
1579 	wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1580 
1581 	/* Post-handling of certain commands.
1582 
1583 	   In particular, if the command was an upload, demunge the data
1584 	   so that the user-level doesn't have to think about it.
1585 	*/
1586 
1587 	if (wc->status == 0) {
1588 		switch (wc->cmd) {
1589 			/* intercept any freemem requests so that we know
1590 			   we are always current with the user-level view
1591 			   of things.
1592 			*/
1593 
1594 		case WFC_REPORT_FREE_MEMORY:
1595 			dev->freemem = demunge_int32 (wc->rbuf, 4);
1596 			break;
1597 
1598 		case WFC_UPLOAD_PATCH:
1599 			demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1600 			break;
1601 
1602 		case WFC_UPLOAD_PROGRAM:
1603 			demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1604 			break;
1605 
1606 		case WFC_UPLOAD_EDRUM_PROGRAM:
1607 			demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1608 			break;
1609 
1610 		case WFC_UPLOAD_SAMPLE_HEADER:
1611 			process_sample_hdr (wc->rbuf);
1612 			break;
1613 
1614 		case WFC_UPLOAD_SAMPLE_ALIAS:
1615 			snd_printk ("support for "
1616 				    "sample aliases still "
1617 				    "being considered.\n");
1618 			break;
1619 
1620 		case WFC_VMIDI_OFF:
1621 			snd_wavefront_midi_disable_virtual (acard);
1622 			break;
1623 
1624 		case WFC_VMIDI_ON:
1625 			snd_wavefront_midi_enable_virtual (acard);
1626 			break;
1627 		}
1628 	}
1629 
1630 	return 0;
1631 }
1632 
1633 int
1634 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1635 
1636 {
1637 	if (!try_module_get(hw->card->module))
1638 		return -EFAULT;
1639 	file->private_data = hw;
1640 	return 0;
1641 }
1642 
1643 int
1644 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1645 
1646 {
1647 	module_put(hw->card->module);
1648 	return 0;
1649 }
1650 
1651 int
1652 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1653 			   unsigned int cmd, unsigned long arg)
1654 
1655 {
1656 	struct snd_card *card;
1657 	snd_wavefront_t *dev;
1658 	snd_wavefront_card_t *acard;
1659 	wavefront_control *wc;
1660 	void __user *argp = (void __user *)arg;
1661 	int err;
1662 
1663 	card = (struct snd_card *) hw->card;
1664 
1665 	if (snd_BUG_ON(!card))
1666 		return -ENODEV;
1667 	if (snd_BUG_ON(!card->private_data))
1668 		return -ENODEV;
1669 
1670 	acard = card->private_data;
1671 	dev = &acard->wavefront;
1672 
1673 	switch (cmd) {
1674 	case WFCTL_LOAD_SPP:
1675 		if (wavefront_load_patch (dev, argp) != 0) {
1676 			return -EIO;
1677 		}
1678 		break;
1679 
1680 	case WFCTL_WFCMD:
1681 		wc = memdup_user(argp, sizeof(*wc));
1682 		if (IS_ERR(wc))
1683 			return PTR_ERR(wc);
1684 
1685 		if (wavefront_synth_control (acard, wc) < 0)
1686 			err = -EIO;
1687 		else if (copy_to_user (argp, wc, sizeof (*wc)))
1688 			err = -EFAULT;
1689 		else
1690 			err = 0;
1691 		kfree(wc);
1692 		return err;
1693 
1694 	default:
1695 		return -EINVAL;
1696 	}
1697 
1698 	return 0;
1699 }
1700 
1701 
1702 /***********************************************************************/
1703 /*  WaveFront: interface for card-level wavefront module               */
1704 /***********************************************************************/
1705 
1706 void
1707 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1708 {
1709 	snd_wavefront_t *dev = &card->wavefront;
1710 
1711 	/*
1712 	   Some comments on interrupts. I attempted a version of this
1713 	   driver that used interrupts throughout the code instead of
1714 	   doing busy and/or sleep-waiting. Alas, it appears that once
1715 	   the Motorola firmware is downloaded, the card *never*
1716 	   generates an RX interrupt. These are successfully generated
1717 	   during firmware loading, and after that wavefront_status()
1718 	   reports that an interrupt is pending on the card from time
1719 	   to time, but it never seems to be delivered to this
1720 	   driver. Note also that wavefront_status() continues to
1721 	   report that RX interrupts are enabled, suggesting that I
1722 	   didn't goof up and disable them by mistake.
1723 
1724 	   Thus, I stepped back to a prior version of
1725 	   wavefront_wait(), the only place where this really
1726 	   matters. Its sad, but I've looked through the code to check
1727 	   on things, and I really feel certain that the Motorola
1728 	   firmware prevents RX-ready interrupts.
1729 	*/
1730 
1731 	if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1732 		return;
1733 	}
1734 
1735 	spin_lock(&dev->irq_lock);
1736 	dev->irq_ok = 1;
1737 	dev->irq_cnt++;
1738 	spin_unlock(&dev->irq_lock);
1739 	wake_up(&dev->interrupt_sleeper);
1740 }
1741 
1742 /* STATUS REGISTER
1743 
1744 0 Host Rx Interrupt Enable (1=Enabled)
1745 1 Host Rx Register Full (1=Full)
1746 2 Host Rx Interrupt Pending (1=Interrupt)
1747 3 Unused
1748 4 Host Tx Interrupt (1=Enabled)
1749 5 Host Tx Register empty (1=Empty)
1750 6 Host Tx Interrupt Pending (1=Interrupt)
1751 7 Unused
1752 */
1753 
1754 static int
1755 snd_wavefront_interrupt_bits (int irq)
1756 
1757 {
1758 	int bits;
1759 
1760 	switch (irq) {
1761 	case 9:
1762 		bits = 0x00;
1763 		break;
1764 	case 5:
1765 		bits = 0x08;
1766 		break;
1767 	case 12:
1768 		bits = 0x10;
1769 		break;
1770 	case 15:
1771 		bits = 0x18;
1772 		break;
1773 
1774 	default:
1775 		snd_printk ("invalid IRQ %d\n", irq);
1776 		bits = -1;
1777 	}
1778 
1779 	return bits;
1780 }
1781 
1782 static void
1783 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1784 				  int val, int port, unsigned long timeout)
1785 
1786 {
1787 	wait_queue_entry_t wait;
1788 
1789 	init_waitqueue_entry(&wait, current);
1790 	spin_lock_irq(&dev->irq_lock);
1791 	add_wait_queue(&dev->interrupt_sleeper, &wait);
1792 	dev->irq_ok = 0;
1793 	outb (val,port);
1794 	spin_unlock_irq(&dev->irq_lock);
1795 	while (!dev->irq_ok && time_before(jiffies, timeout)) {
1796 		schedule_timeout_uninterruptible(1);
1797 		barrier();
1798 	}
1799 }
1800 
1801 static int
1802 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1803 
1804 {
1805 	int bits;
1806 	int hwv[2];
1807 
1808 	/* IRQ already checked */
1809 
1810 	bits = snd_wavefront_interrupt_bits (dev->irq);
1811 
1812 	/* try reset of port */
1813 
1814 	outb (0x0, dev->control_port);
1815 
1816 	/* At this point, the board is in reset, and the H/W initialization
1817 	   register is accessed at the same address as the data port.
1818 
1819 	   Bit 7 - Enable IRQ Driver
1820 	   0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1821 	   1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1822 
1823 	   Bit 6 - MIDI Interface Select
1824 
1825 	   0 - Use the MIDI Input from the 26-pin WaveBlaster
1826 	   compatible header as the serial MIDI source
1827 	   1 - Use the MIDI Input from the 9-pin D connector as the
1828 	   serial MIDI source.
1829 
1830 	   Bits 5:3 - IRQ Selection
1831 	   0 0 0 - IRQ 2/9
1832 	   0 0 1 - IRQ 5
1833 	   0 1 0 - IRQ 12
1834 	   0 1 1 - IRQ 15
1835 	   1 0 0 - Reserved
1836 	   1 0 1 - Reserved
1837 	   1 1 0 - Reserved
1838 	   1 1 1 - Reserved
1839 
1840 	   Bits 2:1 - Reserved
1841 	   Bit 0 - Disable Boot ROM
1842 	   0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1843 	   1 - memory accesses to 03FC30-03FFFFH are directed to external
1844 	   storage.
1845 
1846 	*/
1847 
1848 	/* configure hardware: IRQ, enable interrupts,
1849 	   plus external 9-pin MIDI interface selected
1850 	*/
1851 
1852 	outb (0x80 | 0x40 | bits, dev->data_port);
1853 
1854 	/* CONTROL REGISTER
1855 
1856 	   0 Host Rx Interrupt Enable (1=Enabled)      0x1
1857 	   1 Unused                                    0x2
1858 	   2 Unused                                    0x4
1859 	   3 Unused                                    0x8
1860 	   4 Host Tx Interrupt Enable                 0x10
1861 	   5 Mute (0=Mute; 1=Play)                    0x20
1862 	   6 Master Interrupt Enable (1=Enabled)      0x40
1863 	   7 Master Reset (0=Reset; 1=Run)            0x80
1864 
1865 	   Take us out of reset, mute output, master + TX + RX interrupts on.
1866 
1867 	   We'll get an interrupt presumably to tell us that the TX
1868 	   register is clear.
1869 	*/
1870 
1871 	wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1872 					 dev->control_port,
1873 					 (reset_time*HZ)/100);
1874 
1875 	/* Note: data port is now the data port, not the h/w initialization
1876 	   port.
1877 	 */
1878 
1879 	if (!dev->irq_ok) {
1880 		snd_printk ("intr not received after h/w un-reset.\n");
1881 		goto gone_bad;
1882 	}
1883 
1884 	/* Note: data port is now the data port, not the h/w initialization
1885 	   port.
1886 
1887 	   At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1888 	   will work. So, issue one of them, and wait for TX
1889 	   interrupt. This can take a *long* time after a cold boot,
1890 	   while the ISC ROM does its RAM test. The SDK says up to 4
1891 	   seconds - with 12MB of RAM on a Tropez+, it takes a lot
1892 	   longer than that (~16secs). Note that the card understands
1893 	   the difference between a warm and a cold boot, so
1894 	   subsequent ISC2115 reboots (say, caused by module
1895 	   reloading) will get through this much faster.
1896 
1897 	   XXX Interesting question: why is no RX interrupt received first ?
1898 	*/
1899 
1900 	wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1901 					 dev->data_port, ramcheck_time*HZ);
1902 
1903 	if (!dev->irq_ok) {
1904 		snd_printk ("post-RAM-check interrupt not received.\n");
1905 		goto gone_bad;
1906 	}
1907 
1908 	if (!wavefront_wait (dev, STAT_CAN_READ)) {
1909 		snd_printk ("no response to HW version cmd.\n");
1910 		goto gone_bad;
1911 	}
1912 
1913 	if ((hwv[0] = wavefront_read (dev)) == -1) {
1914 		snd_printk ("board not responding correctly.\n");
1915 		goto gone_bad;
1916 	}
1917 
1918 	if (hwv[0] == 0xFF) { /* NAK */
1919 
1920 		/* Board's RAM test failed. Try to read error code,
1921 		   and tell us about it either way.
1922 		*/
1923 
1924 		if ((hwv[0] = wavefront_read (dev)) == -1) {
1925 			snd_printk ("on-board RAM test failed "
1926 				    "(bad error code).\n");
1927 		} else {
1928 			snd_printk ("on-board RAM test failed "
1929 				    "(error code: 0x%x).\n",
1930 				hwv[0]);
1931 		}
1932 		goto gone_bad;
1933 	}
1934 
1935 	/* We're OK, just get the next byte of the HW version response */
1936 
1937 	if ((hwv[1] = wavefront_read (dev)) == -1) {
1938 		snd_printk ("incorrect h/w response.\n");
1939 		goto gone_bad;
1940 	}
1941 
1942 	snd_printk ("hardware version %d.%d\n",
1943 		    hwv[0], hwv[1]);
1944 
1945 	return 0;
1946 
1947 
1948      gone_bad:
1949 	return (1);
1950 }
1951 
1952 static int
1953 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1954 
1955 {
1956 	const unsigned char *buf;
1957 	int len, err;
1958 	int section_cnt_downloaded = 0;
1959 	const struct firmware *firmware;
1960 
1961 	err = request_firmware(&firmware, path, dev->card->dev);
1962 	if (err < 0) {
1963 		snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1964 		return 1;
1965 	}
1966 
1967 	len = 0;
1968 	buf = firmware->data;
1969 	for (;;) {
1970 		int section_length = *(signed char *)buf;
1971 		if (section_length == 0)
1972 			break;
1973 		if (section_length < 0 || section_length > WF_SECTION_MAX) {
1974 			snd_printk(KERN_ERR
1975 				   "invalid firmware section length %d\n",
1976 				   section_length);
1977 			goto failure;
1978 		}
1979 		buf++;
1980 		len++;
1981 
1982 		if (firmware->size < len + section_length) {
1983 			snd_printk(KERN_ERR "firmware section read error.\n");
1984 			goto failure;
1985 		}
1986 
1987 		/* Send command */
1988 		if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1989 			goto failure;
1990 
1991 		for (; section_length; section_length--) {
1992 			if (wavefront_write(dev, *buf))
1993 				goto failure;
1994 			buf++;
1995 			len++;
1996 		}
1997 
1998 		/* get ACK */
1999 		if (!wavefront_wait(dev, STAT_CAN_READ)) {
2000 			snd_printk(KERN_ERR "time out for firmware ACK.\n");
2001 			goto failure;
2002 		}
2003 		err = inb(dev->data_port);
2004 		if (err != WF_ACK) {
2005 			snd_printk(KERN_ERR
2006 				   "download of section #%d not "
2007 				   "acknowledged, ack = 0x%x\n",
2008 				   section_cnt_downloaded + 1, err);
2009 			goto failure;
2010 		}
2011 
2012 		section_cnt_downloaded++;
2013 	}
2014 
2015 	release_firmware(firmware);
2016 	return 0;
2017 
2018  failure:
2019 	release_firmware(firmware);
2020 	snd_printk(KERN_ERR "firmware download failed!!!\n");
2021 	return 1;
2022 }
2023 
2024 
2025 static int
2026 wavefront_do_reset (snd_wavefront_t *dev)
2027 
2028 {
2029 	char voices[1];
2030 
2031 	if (wavefront_reset_to_cleanliness (dev)) {
2032 		snd_printk ("hw reset failed.\n");
2033 		goto gone_bad;
2034 	}
2035 
2036 	if (dev->israw) {
2037 		if (wavefront_download_firmware (dev, ospath)) {
2038 			goto gone_bad;
2039 		}
2040 
2041 		dev->israw = 0;
2042 
2043 		/* Wait for the OS to get running. The protocol for
2044 		   this is non-obvious, and was determined by
2045 		   using port-IO tracing in DOSemu and some
2046 		   experimentation here.
2047 
2048 		   Rather than using timed waits, use interrupts creatively.
2049 		*/
2050 
2051 		wavefront_should_cause_interrupt (dev, WFC_NOOP,
2052 						  dev->data_port,
2053 						  (osrun_time*HZ));
2054 
2055 		if (!dev->irq_ok) {
2056 			snd_printk ("no post-OS interrupt.\n");
2057 			goto gone_bad;
2058 		}
2059 
2060 		/* Now, do it again ! */
2061 
2062 		wavefront_should_cause_interrupt (dev, WFC_NOOP,
2063 						  dev->data_port, (10*HZ));
2064 
2065 		if (!dev->irq_ok) {
2066 			snd_printk ("no post-OS interrupt(2).\n");
2067 			goto gone_bad;
2068 		}
2069 
2070 		/* OK, no (RX/TX) interrupts any more, but leave mute
2071 		   in effect.
2072 		*/
2073 
2074 		outb (0x80|0x40, dev->control_port);
2075 	}
2076 
2077 	/* SETUPSND.EXE asks for sample memory config here, but since i
2078 	   have no idea how to interpret the result, we'll forget
2079 	   about it.
2080 	*/
2081 
2082 	if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2083 		goto gone_bad;
2084 	}
2085 
2086 	snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2087 
2088 	if (wavefront_write (dev, 0xf0) ||
2089 	    wavefront_write (dev, 1) ||
2090 	    (wavefront_read (dev) < 0)) {
2091 		dev->debug = 0;
2092 		snd_printk ("MPU emulation mode not set.\n");
2093 		goto gone_bad;
2094 	}
2095 
2096 	voices[0] = 32;
2097 
2098 	if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2099 		snd_printk ("cannot set number of voices to 32.\n");
2100 		goto gone_bad;
2101 	}
2102 
2103 
2104 	return 0;
2105 
2106  gone_bad:
2107 	/* reset that sucker so that it doesn't bother us. */
2108 
2109 	outb (0x0, dev->control_port);
2110 	dev->interrupts_are_midi = 0;
2111 	return 1;
2112 }
2113 
2114 int
2115 snd_wavefront_start (snd_wavefront_t *dev)
2116 
2117 {
2118 	int samples_are_from_rom;
2119 
2120 	/* IMPORTANT: assumes that snd_wavefront_detect() and/or
2121 	   wavefront_reset_to_cleanliness() has already been called
2122 	*/
2123 
2124 	if (dev->israw) {
2125 		samples_are_from_rom = 1;
2126 	} else {
2127 		/* XXX is this always true ? */
2128 		samples_are_from_rom = 0;
2129 	}
2130 
2131 	if (dev->israw || fx_raw) {
2132 		if (wavefront_do_reset (dev)) {
2133 			return -1;
2134 		}
2135 	}
2136 	/* Check for FX device, present only on Tropez+ */
2137 
2138 	dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2139 
2140 	if (dev->has_fx && fx_raw) {
2141 		snd_wavefront_fx_start (dev);
2142 	}
2143 
2144 	wavefront_get_sample_status (dev, samples_are_from_rom);
2145 	wavefront_get_program_status (dev);
2146 	wavefront_get_patch_status (dev);
2147 
2148 	/* Start normal operation: unreset, master interrupt enabled, no mute
2149 	*/
2150 
2151 	outb (0x80|0x40|0x20, dev->control_port);
2152 
2153 	return (0);
2154 }
2155 
2156 int
2157 snd_wavefront_detect (snd_wavefront_card_t *card)
2158 
2159 {
2160 	unsigned char   rbuf[4], wbuf[4];
2161 	snd_wavefront_t *dev = &card->wavefront;
2162 
2163 	/* returns zero if a WaveFront card is successfully detected.
2164 	   negative otherwise.
2165 	*/
2166 
2167 	dev->israw = 0;
2168 	dev->has_fx = 0;
2169 	dev->debug = debug_default;
2170 	dev->interrupts_are_midi = 0;
2171 	dev->irq_cnt = 0;
2172 	dev->rom_samples_rdonly = 1;
2173 
2174 	if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2175 
2176 		dev->fw_version[0] = rbuf[0];
2177 		dev->fw_version[1] = rbuf[1];
2178 
2179 		snd_printk ("firmware %d.%d already loaded.\n",
2180 			    rbuf[0], rbuf[1]);
2181 
2182 		/* check that a command actually works */
2183 
2184 		if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2185 				       rbuf, wbuf) == 0) {
2186 			dev->hw_version[0] = rbuf[0];
2187 			dev->hw_version[1] = rbuf[1];
2188 		} else {
2189 			snd_printk ("not raw, but no "
2190 				    "hardware version!\n");
2191 			return -1;
2192 		}
2193 
2194 		if (!wf_raw) {
2195 			return 0;
2196 		} else {
2197 			snd_printk ("reloading firmware as you requested.\n");
2198 			dev->israw = 1;
2199 		}
2200 
2201 	} else {
2202 
2203 		dev->israw = 1;
2204 		snd_printk ("no response to firmware probe, assume raw.\n");
2205 
2206 	}
2207 
2208 	return 0;
2209 }
2210 
2211 MODULE_FIRMWARE(DEFAULT_OSPATH);
2212