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