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