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