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