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