/*
 * sound/gus_wave.c
 * 
 * Driver for the Gravis UltraSound wave table synth.
 * 
 * Copyright by Hannu Savolainen 1993, 1994
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer. 2.
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * $FreeBSD: src/sys/i386/isa/sound/gus_wave.c,v 1.32 1999/12/20 18:05:00 eivind Exp $
 */

#include <stddef.h>

#include <i386/isa/sound/sound_config.h>
#include <i386/isa/sound/ultrasound.h>
#include <i386/isa/sound/gus_hw.h>
#include <i386/isa/sound/iwdefs.h>
#include <machine/clock.h>

/* PnP stuff */
#define GUS_PNP_ID 0x100561e

#define MAX_CARDS 8
#define MAX_GUS_PNP 12


/* Static ports */
#define PADDRESS	0x279
#define PWRITE_DATA	0xa79
#define SET_CSN			0x06
#define PSTATUS			0x05

/* PnP Registers.  Write to ADDRESS and then use WRITE/READ_DATA */
#define SET_RD_DATA		0x00
#define SERIAL_ISOLATION	0x01
#define WAKE			0x03

#if defined(CONFIG_GUS)

static IWAVE iw;
#define 	ENTER_CRITICAL

#define 	LEAVE_CRITICAL

#define MAX_SAMPLE	150
#define MAX_PATCH	256


static u_int gus_pnp_found[MAX_GUS_PNP] =
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

struct voice_info {
	u_long   orig_freq;
	u_long   current_freq;
	u_long   mode;
	int             bender;
	int             bender_range;
	int             panning;
	int             midi_volume;
	u_int    initial_volume;
	u_int    current_volume;
	int             loop_irq_mode, loop_irq_parm;
#define LMODE_FINISH		1
#define LMODE_PCM		2
#define LMODE_PCM_STOP		3
	int             volume_irq_mode, volume_irq_parm;
#define VMODE_HALT		1
#define VMODE_ENVELOPE		2
#define VMODE_START_NOTE	3

	int             env_phase;
	u_char   env_rate[6];
	u_char   env_offset[6];

	/*
	 * Volume computation parameters for gus_adagio_vol()
	 */
	int             main_vol, expression_vol, patch_vol;

	/* Variables for "Ultraclick" removal */
	int             dev_pending, note_pending, volume_pending, sample_pending;
	char            kill_pending;
	long            offset_pending;

};

static struct voice_alloc_info *voice_alloc;

extern int      gus_base;
extern int      gus_irq, gus_dma;
static int      gus_dma2 = -1;
static int      dual_dma_mode = 0;
static long     gus_mem_size = 0;
static long     free_mem_ptr = 0;
static int      gus_no_dma = 0;
static int      nr_voices = 0;
static int      gus_devnum = 0;
static int      volume_base, volume_scale, volume_method;
static int      gus_recmask = SOUND_MASK_MIC;
static int      recording_active = 0;
static int      only_read_access = 0;
static int      only_8_bits = 0;

int             gus_wave_volume = 60;
static int      gus_pcm_volume = 80;
int             have_gus_max = 0;
static int      gus_line_vol = 100, gus_mic_vol = 0;
static u_char mix_image = 0x00;

int             gus_timer_enabled = 0;
/*
 * Current version of this driver doesn't allow synth and PCM functions at
 * the same time. The active_device specifies the active driver
 */
static int      active_device = 0;

#define GUS_DEV_WAVE		1	/* Wave table synth */
#define GUS_DEV_PCM_DONE	2	/* PCM device, transfer done */
#define GUS_DEV_PCM_CONTINUE	3	/* PCM device, transfer done ch. 1/2 */

static int      gus_sampling_speed;
static int      gus_sampling_channels;
static int      gus_sampling_bits;

static int     *dram_sleeper = NULL;
static volatile struct snd_wait dram_sleep_flag =
{0};

/*
 * Variables and buffers for PCM output
 */
#define MAX_PCM_BUFFERS		(32*MAX_REALTIME_FACTOR)	/* Don't change */

static int      pcm_bsize, pcm_nblk, pcm_banksize;
static int      pcm_datasize[MAX_PCM_BUFFERS];
static volatile int pcm_head, pcm_tail, pcm_qlen;
static volatile int pcm_active;
static volatile int dma_active;
static int      pcm_opened = 0;
static int      pcm_current_dev;
static int      pcm_current_block;
static u_long pcm_current_buf;
static int      pcm_current_count;
static int      pcm_current_intrflag;

extern sound_os_info *gus_osp;

static struct voice_info voices[32];

static int      freq_div_table[] =
{
	44100,			/* 14 */
	41160,			/* 15 */
	38587,			/* 16 */
	36317,			/* 17 */
	34300,			/* 18 */
	32494,			/* 19 */
	30870,			/* 20 */
	29400,			/* 21 */
	28063,			/* 22 */
	26843,			/* 23 */
	25725,			/* 24 */
	24696,			/* 25 */
	23746,			/* 26 */
	22866,			/* 27 */
	22050,			/* 28 */
	21289,			/* 29 */
	20580,			/* 30 */
	19916,			/* 31 */
	19293			/* 32 */
};

static struct patch_info *samples;
static struct patch_info *dbg_samples;
static int                dbg_samplep;

static long     sample_ptrs[MAX_SAMPLE + 1];
static int      sample_map[32];
static int      free_sample;
static int      mixer_type = 0;


static int      patch_table[MAX_PATCH];
static int      patch_map[32];

static struct synth_info gus_info =
{"Gravis UltraSound", 0, SYNTH_TYPE_SAMPLE, SAMPLE_TYPE_GUS, 0, 16, 0, MAX_PATCH};

static void     gus_default_mixer_init(void);

static int      guswave_start_note2(int dev, int voice, int note_num, int volume);
static void     gus_poke(long addr, u_char data);
static void     compute_and_set_volume(int voice, int volume, int ramp_time);
extern u_short gus_adagio_vol(int vel, int mainv, int xpn, int voicev);
extern u_short gus_linear_vol(int vol, int mainvol);
static void     compute_volume(int voice, int volume);
static void     do_volume_irq(int voice);
static void     set_input_volumes(void);
static void     gus_tmr_install(int io_base);

static void     SEND(int d, int r);
static int      get_serial(int rd_port, u_char *data);
static void     send_Initiation_LFSR(void);
static int      isolation_protocol(int rd_port);


#define	INSTANT_RAMP		-1	/* Instant change. No ramping */
#define FAST_RAMP		0	/* Fastest possible ramp */


/* Crystal Select */
#define CODEC_XTAL2			0x01	/* 16.9344 crystal */
#define CODEC_XTAL1			0x00	/* 24.576 crystal */
/************************************************************************/

/************************************************************************/
/* Definitions for CONFIG_1 register                                    */
#define CODEC_CFIG1I_DEFAULT    0x03 | 0x8
#define CODEC_CAPTURE_PIO	0x80	/* Capture PIO enable */
#define CODEC_PLAYBACK_PIO	0x40	/* Playback PIO enable */
#define CODEC_AUTOCALIB		0x08	/* auto calibrate */
#define CODEC_SINGLE_DMA	0x04	/* Use single DMA channel */
#define CODEC_RE		0x02	/* Capture enable */
#define CODEC_PE		0x01	/* playback enable */
/************************************************************************/

/************************************************************************/
/* Definitions for CONFIG_2 register                                    */
#define CODEC_CFIG2I_DEFAULT    0x81
#define CODEC_OFVS 0x80		/* Output Full Scale Voltage */
#define CODEC_TE   0x40		/* Timer Enable */
#define CODEC_RSCD 0x20		/* Recors Sample Counter Disable */
#define CODEC_PSCD 0x10		/* Playback Sample Counter Disable */
#define CODEC_DAOF 0x01		/* D/A Ouput Force Enable */
/************************************************************************/

/************************************************************************/
/* Definitions for CONFIG_3 register                                    */
/* #define CODEC_CFIG3I_DEFAULT    0xe0  0x02 when synth DACs are working */

#define CODEC_CFIG3I_DEFAULT    0xc0	/* 0x02 when synth DACs are working */
#define CODEC_RPIE    0x80	/* Record FIFO IRQ Enable */
#define CODEC_PPIE    0x40	/* Playback FIFO IRQ Enable */
#define CODEC_FT_MASK 0x30	/* FIFO Threshold Select */
#define CODEC_PVFM    0x04	/* Playback Variable Frequency Mode */
#define CODEC_SYNA    0x02	/* AUX1/Synth Signal Select */
/************************************************************************/

/************************************************************************/
/* Definitions for EXTERNAL_CONTROL register                            */
#define CODEC_CEXTI_DEFAULT     0x00
#define CODEC_IRQ_ENABLE	0x02	/* interrupt enable */
#define CODEC_GPOUT1		0x80	/* external control #1 */
#define CODEC_GPOUT0		0x40	/* external control #0 */
/************************************************************************/

/************************************************************************/
/* Definitions for MODE_SELECT_ID register                              */
#define CODEC_MODE_DEFAULT 0x40
#define CODEC_MODE_MASK  0x60
#define CODEC_ID_BIT4    0x80
#define CODEC_ID_BIT3_0  0x0F
/************************************************************************/
#define CONFIG_1            0x09
#define EXTERNAL_CONTROL    0x0a/* Pin control */
#define STATUS_2            0x0b/* Test and initialization */
#define MODE_SELECT_ID      0x0c/* Miscellaneaous information */
#define LOOPBACK            0x0d/* Digital Mix */
#define UPPER_PLAY_COUNT    0x0e/* Playback Upper Base Count */
#define LOWER_PLAY_COUNT    0x0f/* Playback Lower Base Count */
#define CONFIG_2            0x10
#define CONFIG_3            0x11


#define IWL_CODEC_OUT(reg, val) \
    { outb(iwl_codec_base, reg); outb(iwl_codec_data, val); }

#define IWL_CODEC_IN(reg, val) \
    { outb(iwl_codec_base, reg); val = inb(iwl_codec_data); }


static u_char   gus_look8(int reg);

static void     gus_write16(int reg, u_int data);

static u_short  gus_read16(int reg);

static void     gus_write_addr(int reg, u_long address, int is16bit);
static void     IwaveLineLevel(char level, char index);
static void     IwaveInputSource(BYTE index, BYTE source);
static void     IwavePnpGetCfg(void);
static void     IwavePnpDevice(BYTE dev);
static void     IwavePnpSetCfg(void);
static void     IwavePnpKey(void);
static BYTE     IwavePnpIsol(PORT * pnpread);
static void     IwavePnpPeek(PORT pnprdp, WORD bytes, BYTE * data);
static void     IwavePnpActivate(BYTE dev, BYTE bool);
static void     IwavePnpWake(BYTE csn);
static BYTE     IwavePnpPing(DWORD VendorID);
static WORD     IwaveMemSize(void);
static BYTE     IwaveMemPeek(ADDRESS addr);
static void     IwaveMemPoke(ADDRESS addr, BYTE datum);
static void     IwaveMemCfg(DWORD * lpbanks);
static void     IwaveCodecIrq(BYTE mode);
static WORD     IwaveRegPeek(DWORD reg_mnem);
				
static void     IwaveRegPoke(DWORD reg_mnem, WORD datum);
static void     IwaveCodecMode(char mode);
static void     IwaveLineMute(BYTE mute, BYTE inx);
static void     Iwaveinitcodec(void);
int             IwaveOpen(char voices, char mode, struct address_info * hw);


static void
reset_sample_memory(void)
{
    int             i;

    for (i = 0; i <= MAX_SAMPLE; i++)
	sample_ptrs[i] = -1;
    for (i = 0; i < 32; i++)
	sample_map[i] = -1;
    for (i = 0; i < 32; i++)
	patch_map[i] = -1;

    gus_poke(0, 0);		/* Put a silent sample to the beginning */
    gus_poke(1, 0);
    free_mem_ptr = 2;

    free_sample = 0;

    for (i = 0; i < MAX_PATCH; i++)
	patch_table[i] = -1;
}

void
gus_delay(void)
{
    int             i;

    for (i = 0; i < 7; i++)
	inb(u_DRAMIO);
}

static void
gus_poke(long addr, u_char data)
{				/* Writes a byte to the DRAM */
    u_long   flags;

    flags = splhigh();
    outb(u_Command, 0x43);
    outb(u_DataLo, addr & 0xff);
    outb(u_DataHi, (addr >> 8) & 0xff);

    outb(u_Command, 0x44);
    outb(u_DataHi, (addr >> 16) & 0xff);
    outb(u_DRAMIO, data);
    splx(flags);
}

static u_char
gus_peek(long addr)
{				/* Reads a byte from the DRAM */
    u_long   flags;
    u_char   tmp;

    flags = splhigh();
    outb(u_Command, 0x43);
    outb(u_DataLo, addr & 0xff);
    outb(u_DataHi, (addr >> 8) & 0xff);

    outb(u_Command, 0x44);
    outb(u_DataHi, (addr >> 16) & 0xff);
    tmp = inb(u_DRAMIO);
    splx(flags);

    return tmp;
}

void
gus_write8(int reg, u_int data)
{				/* Writes to an indirect register (8 bit) */
    u_long   flags;

    flags = splhigh();
    outb(u_Command, reg);
    outb(u_DataHi, (u_char) (data & 0xff));
    splx(flags);
}

u_char
gus_read8(int reg)
{	/* Reads from an indirect register (8 bit). Offset 0x80. */
    u_long   flags;
    u_char   val;

    flags = splhigh();
    outb(u_Command, reg | 0x80);
    val = inb(u_DataHi);
    splx(flags);

    return val;
}

static u_char
gus_look8(int reg)
{	/* Reads from an indirect register (8 bit). No additional offset. */
    u_long   flags;
    u_char   val;

    flags = splhigh();
    outb(u_Command, reg);
    val = inb(u_DataHi);
    splx(flags);

    return val;
}

static void
gus_write16(int reg, u_int data)
{			/* Writes to an indirect register (16 bit) */
    u_long   flags;

    flags = splhigh();

    outb(u_Command, reg);

    outb(u_DataLo, (u_char) (data & 0xff));
    outb(u_DataHi, (u_char) ((data >> 8) & 0xff));

    splx(flags);
}

static u_short
gus_read16(int reg)
{		/* Reads from an indirect register (16 bit). Offset 0x80. */
    u_long   flags;
    u_char   hi, lo;

    flags = splhigh();

    outb(u_Command, reg | 0x80);

    lo = inb(u_DataLo);
    hi = inb(u_DataHi);

    splx(flags);

    return ((hi << 8) & 0xff00) | lo;
}

static void
gus_write_addr(int reg, u_long address, int is16bit)
{				/* Writes an 24 bit memory address */
    u_long   hold_address;
    u_long   flags;

    flags = splhigh();
    if (is16bit) {
	/*
	 * Special processing required for 16 bit patches
	 */

	hold_address = address;
	address = address >> 1;
	address &= 0x0001ffffL;
	address |= (hold_address & 0x000c0000L);
    }
    gus_write16(reg, (u_short) ((address >> 7) & 0xffff));
    gus_write16(reg + 1, (u_short) ((address << 9) & 0xffff));
    /*
     * Could writing twice fix problems with GUS_VOICE_POS() ? Lets try...
     */
    gus_delay();
    gus_write16(reg, (u_short) ((address >> 7) & 0xffff));
    gus_write16(reg + 1, (u_short) ((address << 9) & 0xffff));
    splx(flags);
}

static void
gus_select_voice(int voice)
{
    if (voice < 0 || voice > 31)
	return;

    outb(u_Voice, voice);
}

static void
gus_select_max_voices(int nvoices)
{
    if (nvoices < 14)
	nvoices = 14;
    if (nvoices > 32)
	nvoices = 32;

    voice_alloc->max_voice = nr_voices = nvoices;

    gus_write8(0x0e, (nvoices - 1) | 0xc0);
}

static void
gus_voice_on(u_int mode)
{
    gus_write8(0x00, (u_char) (mode & 0xfc));
    gus_delay();
    gus_write8(0x00, (u_char) (mode & 0xfc));
}

static void
gus_voice_off(void)
{
    gus_write8(0x00, gus_read8(0x00) | 0x03);
}

static void
gus_voice_mode(u_int m)
{
    u_char   mode = (u_char) (m & 0xff);

    gus_write8(0x00, (gus_read8(0x00) & 0x03) |
	   (mode & 0xfc));	/* Don't touch last two bits */
    gus_delay();
    gus_write8(0x00, (gus_read8(0x00) & 0x03) | (mode & 0xfc));
}

static void
gus_voice_freq(u_long freq)
{
    u_long   divisor = freq_div_table[nr_voices - 14];
    u_short  fc;

    fc = (u_short) (((freq << 9) + (divisor >> 1)) / divisor);
    fc = fc << 1;

    gus_write16(0x01, fc);
}

static void
gus_voice_volume(u_int vol)
{
	gus_write8(0x0d, 0x03);	/* Stop ramp before setting volume */
	gus_write16(0x09, (u_short) (vol << 4));
}

static void
gus_voice_balance(u_int balance)
{
	gus_write8(0x0c, (u_char) (balance & 0xff));
}

static void
gus_ramp_range(u_int low, u_int high)
{
	gus_write8(0x07, (u_char) ((low >> 4) & 0xff));
	gus_write8(0x08, (u_char) ((high >> 4) & 0xff));
}

static void
gus_ramp_rate(u_int scale, u_int rate)
{
	gus_write8(0x06, (u_char) (((scale & 0x03) << 6) | (rate & 0x3f)));
}

static void
gus_rampon(u_int m)
{
	u_char   mode = (u_char) (m & 0xff);

	gus_write8(0x0d, mode & 0xfc);
	gus_delay();
	gus_write8(0x0d, mode & 0xfc);
}

static void
gus_ramp_mode(u_int m)
{
	u_char   mode = (u_char) (m & 0xff);

	gus_write8(0x0d, (gus_read8(0x0d) & 0x03) |
		   (mode & 0xfc));	/* Leave the last 2 bits alone */
	gus_delay();
	gus_write8(0x0d, (gus_read8(0x0d) & 0x03) | (mode & 0xfc));
}

static void
gus_rampoff(void)
{
	gus_write8(0x0d, 0x03);
}

static void
gus_set_voice_pos(int voice, long position)
{
	int             sample_no;

	if ((sample_no = sample_map[voice]) != -1) {
		if (position < samples[sample_no].len) {
			if (voices[voice].volume_irq_mode == VMODE_START_NOTE)
				voices[voice].offset_pending = position;
			else
				gus_write_addr(0x0a, sample_ptrs[sample_no] + position,
				    samples[sample_no].mode & WAVE_16_BITS);
		}
	}
}

static void
gus_voice_init(int voice)
{
	u_long   flags;

	flags = splhigh();
	gus_select_voice(voice);
	gus_voice_volume(0);
	gus_voice_off();
	gus_write_addr(0x0a, 0, 0);	/* Set current position to 0 */
	gus_write8(0x00, 0x03);	/* Voice off */
	gus_write8(0x0d, 0x03);	/* Ramping off */
	voice_alloc->map[voice] = 0;
	voice_alloc->alloc_times[voice] = 0;
	splx(flags);

}

static void
gus_voice_init2(int voice)
{
	voices[voice].panning = 0;
	voices[voice].mode = 0;
	voices[voice].orig_freq = 20000;
	voices[voice].current_freq = 20000;
	voices[voice].bender = 0;
	voices[voice].bender_range = 200;
	voices[voice].initial_volume = 0;
	voices[voice].current_volume = 0;
	voices[voice].loop_irq_mode = 0;
	voices[voice].loop_irq_parm = 0;
	voices[voice].volume_irq_mode = 0;
	voices[voice].volume_irq_parm = 0;
	voices[voice].env_phase = 0;
	voices[voice].main_vol = 127;
	voices[voice].patch_vol = 127;
	voices[voice].expression_vol = 127;
	voices[voice].sample_pending = -1;
}

static void
step_envelope(int voice)
{
    u_int        vol, prev_vol, phase;
    u_char   rate;
    long int        flags;

    if (voices[voice].mode & WAVE_SUSTAIN_ON && voices[voice].env_phase == 2) {
	flags = splhigh();
	gus_select_voice(voice);
	gus_rampoff();
	splx(flags);
	return;
	/*
	 * Sustain phase begins. Continue envelope after receiving
	 * note off.
	 */
    }
    if (voices[voice].env_phase >= 5) {	/* Envelope finished. Shoot
					 * the voice down */
	gus_voice_init(voice);
	return;
    }
    prev_vol = voices[voice].current_volume;
    phase = ++voices[voice].env_phase;
    compute_volume(voice, voices[voice].midi_volume);
    vol = voices[voice].initial_volume * voices[voice].env_offset[phase] / 255;
    rate = voices[voice].env_rate[phase];

    flags = splhigh();
    gus_select_voice(voice);
    gus_voice_volume(prev_vol);
    gus_write8(0x06, rate);	/* Ramping rate */

    voices[voice].volume_irq_mode = VMODE_ENVELOPE;

    if (((vol - prev_vol) / 64) == 0) {	/* No significant volume
					 * change */
	splx(flags);
	step_envelope(voice);	/* Continue the envelope on the next
				 * step */
	return;
    }
    if (vol > prev_vol) {
	if (vol >= (4096 - 64))
	    vol = 4096 - 65;
	gus_ramp_range(0, vol);
	gus_rampon(0x20);	/* Increasing volume, with IRQ */
    } else {
	if (vol <= 64)
	    vol = 65;
	gus_ramp_range(vol, 4030);
	gus_rampon(0x60);	/* Decreasing volume, with IRQ */
    }
    voices[voice].current_volume = vol;
    splx(flags);
}

static void
init_envelope(int voice)
{
    voices[voice].env_phase = -1;
    voices[voice].current_volume = 64;

    step_envelope(voice);
}

static void
start_release(int voice, long int flags)
{
    if (gus_read8(0x00) & 0x03)
	return;		/* Voice already stopped */

    voices[voice].env_phase = 2;	/* Will be incremented by
				     * step_envelope */

    voices[voice].current_volume =
    voices[voice].initial_volume =
	gus_read16(0x09) >> 4;	/* Get current volume */

    voices[voice].mode &= ~WAVE_SUSTAIN_ON;
    gus_rampoff();
    splx(flags);
    step_envelope(voice);
}

static void
gus_voice_fade(int voice)
{
    int             instr_no = sample_map[voice], is16bits;
    long int        flags;

    flags = splhigh();
    gus_select_voice(voice);

    if (instr_no < 0 || instr_no > MAX_SAMPLE) {
	gus_write8(0x00, 0x03);	/* Hard stop */
	voice_alloc->map[voice] = 0;
	splx(flags);
	return;
    }
    is16bits = (samples[instr_no].mode & WAVE_16_BITS) ? 1 : 0;	/* 8 or 16 bits */

    if (voices[voice].mode & WAVE_ENVELOPES) {
	start_release(voice, flags);
	return;
    }
    /*
     * Ramp the volume down but not too quickly.
     */
    if ((int) (gus_read16(0x09) >> 4) < 100) {	/* Get current volume */
	gus_voice_off();
	gus_rampoff();
	gus_voice_init(voice);
	return;
    }
    gus_ramp_range(65, 4030);
    gus_ramp_rate(2, 4);
    gus_rampon(0x40 | 0x20);/* Down, once, with IRQ */
    voices[voice].volume_irq_mode = VMODE_HALT;
    splx(flags);
}

static void
gus_reset(void)
{
    int             i;

    gus_select_max_voices(24);
    volume_base = 3071;
    volume_scale = 4;
    volume_method = VOL_METHOD_ADAGIO;

    for (i = 0; i < 32; i++) {
	gus_voice_init(i);	/* Turn voice off */
	gus_voice_init2(i);
    }

    inb(u_Status);		/* Touch the status register */

    gus_look8(0x41);	/* Clear any pending DMA IRQs */
    gus_look8(0x49);	/* Clear any pending sample IRQs */

    gus_read8(0x0f);	/* Clear pending IRQs */

}

static void
gus_initialize(void)
{
    u_long   flags;
    u_char   dma_image, irq_image, tmp;

    static u_char gus_irq_map[16] =
	{0, 0, 0, 3, 0, 2, 0, 4, 0, 1, 0, 5, 6, 0, 0, 7};

    static u_char gus_dma_map[8] =
	{0, 1, 0, 2, 0, 3, 4, 5};

    flags = splhigh();
    gus_write8(0x4c, 0);	/* Reset GF1 */
    gus_delay();
    gus_delay();

    gus_write8(0x4c, 1);	/* Release Reset */
    gus_delay();
    gus_delay();

    /*
     * Clear all interrupts
     */

    gus_write8(0x41, 0);	/* DMA control */
    gus_write8(0x45, 0);	/* Timer control */
    gus_write8(0x49, 0);	/* Sample control */

    gus_select_max_voices(24);

    inb(u_Status);		/* Touch the status register */

    gus_look8(0x41);	/* Clear any pending DMA IRQs */
    gus_look8(0x49);	/* Clear any pending sample IRQs */
    gus_read8(0x0f);	/* Clear pending IRQs */

    gus_reset();		/* Resets all voices */

    gus_look8(0x41);	/* Clear any pending DMA IRQs */
    gus_look8(0x49);	/* Clear any pending sample IRQs */
    gus_read8(0x0f);	/* Clear pending IRQs */

    gus_write8(0x4c, 7);	/* Master reset | DAC enable | IRQ enable */

    /*
     * Set up for Digital ASIC
     */

    outb(gus_base + 0x0f, 0x05);

    mix_image |= 0x02;	/* Disable line out (for a moment) */
    outb(u_Mixer, mix_image);

    outb(u_IRQDMAControl, 0x00);

    outb(gus_base + 0x0f, 0x00);

    /*
     * Now set up the DMA and IRQ interface
     * 
     * The GUS supports two IRQs and two DMAs.
     * 
     * Just one DMA channel is used. This prevents simultaneous ADC and DAC.
     * Adding this support requires significant changes to the dmabuf.c,
     * dsp.c and audio.c also.
     */

    irq_image = 0;
    tmp = gus_irq_map[gus_irq];
    if (!tmp)
	printf("Warning! GUS IRQ not selected\n");
    irq_image |= tmp;
    irq_image |= 0x40;	/* Combine IRQ1 (GF1) and IRQ2 (Midi) */

    dual_dma_mode = 1;
    if (gus_dma2 == gus_dma || gus_dma2 == -1) {
	dual_dma_mode = 0;
	dma_image = 0x40;	/* Combine DMA1 (DRAM) and IRQ2 (ADC) */

	tmp = gus_dma_map[gus_dma];
	if (!tmp)
	    printf("Warning! GUS DMA not selected\n");

	dma_image |= tmp;
    } else
	/* Setup dual DMA channel mode for GUS MAX */
    {
	dma_image = gus_dma_map[gus_dma];
	if (!dma_image)
	    printf("Warning! GUS DMA not selected\n");

	tmp = gus_dma_map[gus_dma2] << 3;
	if (!tmp) {
	    printf("Warning! Invalid GUS MAX DMA\n");
	    tmp = 0x40;	/* Combine DMA channels */
	    dual_dma_mode = 0;
	}
	dma_image |= tmp;
    }

    /*
     * For some reason the IRQ and DMA addresses must be written twice
     */

    /*
     * Doing it first time
     */

    outb(u_Mixer, mix_image);	/* Select DMA control */
    outb(u_IRQDMAControl, dma_image | 0x80);	/* Set DMA address */

    outb(u_Mixer, mix_image | 0x40);	/* Select IRQ control */
    outb(u_IRQDMAControl, irq_image);	/* Set IRQ address */

    /*
     * Doing it second time
     */

    outb(u_Mixer, mix_image);	/* Select DMA control */
    outb(u_IRQDMAControl, dma_image);	/* Set DMA address */

    outb(u_Mixer, mix_image | 0x40);	/* Select IRQ control */
    outb(u_IRQDMAControl, irq_image);	/* Set IRQ address */

    gus_select_voice(0);	/* This disables writes to IRQ/DMA reg */

    mix_image &= ~0x02;	/* Enable line out */
    mix_image |= 0x08;	/* Enable IRQ */
    outb(u_Mixer, mix_image);	/* Turn mixer channels on Note! Mic
				 * in is left off. */

    gus_select_voice(0);	/* This disables writes to IRQ/DMA reg */

    gusintr(0);		/* Serve pending interrupts */
    splx(flags);
}

int
gus_wave_detect(int baseaddr)
{
	u_long   i;
	u_long   loc;
	gus_base = baseaddr;

	gus_write8(0x4c, 0);	/* Reset GF1 */
	gus_delay();
	gus_delay();

	gus_write8(0x4c, 1);	/* Release Reset */
	gus_delay();
	gus_delay();

	/* See if there is first block there.... */
	gus_poke(0L, 0xaa);
	if (gus_peek(0L) != 0xaa)
		return (0);

	/* Now zero it out so that I can check for mirroring .. */
	gus_poke(0L, 0x00);
	for (i = 1L; i < 1024L; i++) {
		int             n, failed;

		/* check for mirroring ... */
		if (gus_peek(0L) != 0)
			break;
		loc = i << 10;

		for (n = loc - 1, failed = 0; n <= loc; n++) {
			gus_poke(loc, 0xaa);
			if (gus_peek(loc) != 0xaa)
				failed = 1;

			gus_poke(loc, 0x55);
			if (gus_peek(loc) != 0x55)
				failed = 1;
		}

		if (failed)
			break;
	}
	gus_mem_size = i << 10;
	return 1;
}

static int
guswave_ioctl(int dev,
	      u_int cmd, ioctl_arg arg)
{

    switch (cmd) {
    case SNDCTL_SYNTH_INFO:
	gus_info.nr_voices = nr_voices;
	bcopy(&gus_info, &(((char *) arg)[0]), sizeof(gus_info));
	return 0;
	break;

    case SNDCTL_SEQ_RESETSAMPLES:
	reset_sample_memory();
	return 0;
	break;

    case SNDCTL_SEQ_PERCMODE:
	return 0;
	break;

    case SNDCTL_SYNTH_MEMAVL:
	return gus_mem_size - free_mem_ptr - 32;

    default:
	return -(EINVAL);
    }
}

static int
guswave_set_instr(int dev, int voice, int instr_no)
{
	int             sample_no;

	if (instr_no < 0 || instr_no > MAX_PATCH)
		return -(EINVAL);

	if (voice < 0 || voice > 31)
		return -(EINVAL);

	if (voices[voice].volume_irq_mode == VMODE_START_NOTE) {
		voices[voice].sample_pending = instr_no;
		return 0;
	}
	sample_no = patch_table[instr_no];
	patch_map[voice] = -1;

	if (sample_no < 0) {
		printf("GUS: Undefined patch %d for voice %d\n", instr_no, voice);
		return -(EINVAL);	/* Patch not defined */
	}
	if (sample_ptrs[sample_no] == -1) {	/* Sample not loaded */
		printf("GUS: Sample #%d not loaded for patch %d (voice %d)\n",
		       sample_no, instr_no, voice);
		return -(EINVAL);
	}
	sample_map[voice] = sample_no;
	patch_map[voice] = instr_no;
	return 0;
}

static int
guswave_kill_note(int dev, int voice, int note, int velocity)
{
    u_long   flags;

    flags = splhigh();
    /* voice_alloc->map[voice] = 0xffff; */
    if (voices[voice].volume_irq_mode == VMODE_START_NOTE) {
	voices[voice].kill_pending = 1;
	splx(flags);
    } else {
	splx(flags);
	gus_voice_fade(voice);
    }

    splx(flags);
    return 0;
}

static void
guswave_aftertouch(int dev, int voice, int pressure)
{
}

static void
guswave_panning(int dev, int voice, int value)
{
    if (voice >= 0 || voice < 32)
	voices[voice].panning = value;
}

static void
guswave_volume_method(int dev, int mode)
{
    if (mode == VOL_METHOD_LINEAR || mode == VOL_METHOD_ADAGIO)
	volume_method = mode;
}

static void
compute_volume(int voice, int volume)
{
    if (volume < 128)
	voices[voice].midi_volume = volume;

    switch (volume_method) {
    case VOL_METHOD_ADAGIO:
	voices[voice].initial_volume =
	    gus_adagio_vol(voices[voice].midi_volume, voices[voice].main_vol,
		   voices[voice].expression_vol, voices[voice].patch_vol);
	break;

    case VOL_METHOD_LINEAR:/* Totally ignores patch-volume and expression */
	voices[voice].initial_volume =
	    gus_linear_vol(volume, voices[voice].main_vol);
	break;

    default:
	voices[voice].initial_volume = volume_base +
	    (voices[voice].midi_volume * volume_scale);
    }

    if (voices[voice].initial_volume > 4030)
	voices[voice].initial_volume = 4030;
}

static void
compute_and_set_volume(int voice, int volume, int ramp_time)
{
    int             curr, target, rate;
    u_long   flags;

    compute_volume(voice, volume);
    voices[voice].current_volume = voices[voice].initial_volume;

    flags = splhigh();
    /*
     * CAUTION! Interrupts disabled. Enable them before returning
     */

    gus_select_voice(voice);

    curr = gus_read16(0x09) >> 4;
    target = voices[voice].initial_volume;

    if (ramp_time == INSTANT_RAMP) {
	gus_rampoff();
	gus_voice_volume(target);
	splx(flags);
	return;
    }
    if (ramp_time == FAST_RAMP)
	rate = 63;
    else
	rate = 16;
    gus_ramp_rate(0, rate);

    if ((target - curr) / 64 == 0) {	/* Close enough to target. */
	gus_rampoff();
	gus_voice_volume(target);
	splx(flags);
	return;
    }
    if (target > curr) {
	if (target > (4095 - 65))
	    target = 4095 - 65;
	gus_ramp_range(curr, target);
	gus_rampon(0x00);	/* Ramp up, once, no IRQ */
    } else {
	if (target < 65)
	    target = 65;

	gus_ramp_range(target, curr);
	gus_rampon(0x40);	/* Ramp down, once, no irq */
    }
    splx(flags);
}

static void
dynamic_volume_change(int voice)
{
	u_char   status;
	u_long   flags;

	flags = splhigh();
	gus_select_voice(voice);
	status = gus_read8(0x00);	/* Get voice status */
	splx(flags);

	if (status & 0x03)
		return;		/* Voice was not running */

	if (!(voices[voice].mode & WAVE_ENVELOPES)) {
		compute_and_set_volume(voice, voices[voice].midi_volume, 1);
		return;
	}
	/*
	 * Voice is running and has envelopes.
	 */

	flags = splhigh();
	gus_select_voice(voice);
	status = gus_read8(0x0d);	/* Ramping status */
	splx(flags);

	if (status & 0x03) {	/* Sustain phase? */
		compute_and_set_volume(voice, voices[voice].midi_volume, 1);
		return;
	}
	if (voices[voice].env_phase < 0)
		return;

	compute_volume(voice, voices[voice].midi_volume);

}

static void
guswave_controller(int dev, int voice, int ctrl_num, int value)
{
	u_long   flags;
	u_long   freq;

	if (voice < 0 || voice > 31)
		return;

	switch (ctrl_num) {
	case CTRL_PITCH_BENDER:
		voices[voice].bender = value;

		if (voices[voice].volume_irq_mode != VMODE_START_NOTE) {
			freq = compute_finetune(voices[voice].orig_freq, value,
						voices[voice].bender_range);
			voices[voice].current_freq = freq;

			flags = splhigh();
			gus_select_voice(voice);
			gus_voice_freq(freq);
			splx(flags);
		}
		break;

	case CTRL_PITCH_BENDER_RANGE:
		voices[voice].bender_range = value;
		break;
	case CTL_EXPRESSION:
		value /= 128;
	case CTRL_EXPRESSION:
		if (volume_method == VOL_METHOD_ADAGIO) {
			voices[voice].expression_vol = value;
			if (voices[voice].volume_irq_mode != VMODE_START_NOTE)
				dynamic_volume_change(voice);
		}
		break;

	case CTL_PAN:
		voices[voice].panning = (value * 2) - 128;
		break;

	case CTL_MAIN_VOLUME:
		value = (value * 100) / 16383;

	case CTRL_MAIN_VOLUME:
		voices[voice].main_vol = value;
		if (voices[voice].volume_irq_mode != VMODE_START_NOTE)
			dynamic_volume_change(voice);
		break;

	default:
		break;
	}
}

static int
guswave_start_note2(int dev, int voice, int note_num, int volume)
{
    int             sample, best_sample, best_delta, delta_freq;
    int             is16bits, samplep, patch, pan;
    u_long   note_freq, base_note, freq, flags;
    u_char   mode = 0;

    if (voice < 0 || voice > 31) {
	printf("GUS: Invalid voice\n");
	return -(EINVAL);
    }
    if (note_num == 255) {
	if (voices[voice].mode & WAVE_ENVELOPES) {
	    voices[voice].midi_volume = volume;
	    dynamic_volume_change(voice);
	    return 0;
	}
	compute_and_set_volume(voice, volume, 1);
	return 0;
    }
    if ((patch = patch_map[voice]) == -1)
	return -(EINVAL);
    if ((samplep = patch_table[patch]) == -1)
	return -(EINVAL);
    note_freq = note_to_freq(note_num);

    /*
     * Find a sample within a patch so that the note_freq is between
     * low_note and high_note.
     */
    sample = -1;

    best_sample = samplep;
    best_delta = 1000000;
    while (samplep >= 0 && sample == -1) {
	dbg_samples = samples;
	dbg_samplep = samplep;

	delta_freq = note_freq - samples[samplep].base_note;
	if (delta_freq < 0)
	    delta_freq = -delta_freq;
	if (delta_freq < best_delta) {
	    best_sample = samplep;
	    best_delta = delta_freq;
	}
	if (samples[samplep].low_note <= note_freq &&
		note_freq <= samples[samplep].high_note)
	    sample = samplep;
	else
	    samplep = samples[samplep].key;	/* Follow link */
    }
    if (sample == -1)
	sample = best_sample;

    if (sample == -1) {
	printf("GUS: Patch %d not defined for note %d\n", patch, note_num);
	return 0;	/* Should play default patch ??? */
    }
    is16bits = (samples[sample].mode & WAVE_16_BITS) ? 1 : 0;
    voices[voice].mode = samples[sample].mode;
    voices[voice].patch_vol = samples[sample].volume;

    if (voices[voice].mode & WAVE_ENVELOPES) {
	int             i;

	for (i = 0; i < 6; i++) {
	    voices[voice].env_rate[i] = samples[sample].env_rate[i];
	    voices[voice].env_offset[i] = samples[sample].env_offset[i];
	}
    }
    sample_map[voice] = sample;

    base_note = samples[sample].base_note / 100; /* Try to avoid overflows */
    note_freq /= 100;

    freq = samples[sample].base_freq * note_freq / base_note;

    voices[voice].orig_freq = freq;

    /*
     * Since the pitch bender may have been set before playing the note,
     * we have to calculate the bending now.
     */

    freq = compute_finetune(voices[voice].orig_freq, voices[voice].bender,
			    voices[voice].bender_range);
    voices[voice].current_freq = freq;

    pan = (samples[sample].panning + voices[voice].panning) / 32;
    pan += 7;
    if (pan < 0)
	pan = 0;
    if (pan > 15)
	pan = 15;

    if (samples[sample].mode & WAVE_16_BITS) {
	mode |= 0x04;	/* 16 bits */
	if ((sample_ptrs[sample] >> 18) !=
		((sample_ptrs[sample] + samples[sample].len) >> 18))
	    printf("GUS: Sample address error\n");
    }
    /*
     *    CAUTION!        Interrupts disabled. Don't return before enabling
     */

    flags = splhigh();
    gus_select_voice(voice);
    gus_voice_off();
    gus_rampoff();

    splx(flags);

    if (voices[voice].mode & WAVE_ENVELOPES) {
	compute_volume(voice, volume);
	init_envelope(voice);
    } else {
	compute_and_set_volume(voice, volume, 0);
    }

    flags = splhigh();
    gus_select_voice(voice);

    if (samples[sample].mode & WAVE_LOOP_BACK)
	gus_write_addr(0x0a, sample_ptrs[sample] + samples[sample].len -
		   voices[voice].offset_pending, is16bits);	/* start=end */
    else
	gus_write_addr(0x0a, sample_ptrs[sample] + voices[voice].offset_pending,
		       is16bits);	/* Sample start=begin */

    if (samples[sample].mode & WAVE_LOOPING) {
	mode |= 0x08;

	if (samples[sample].mode & WAVE_BIDIR_LOOP)
	    mode |= 0x10;

	if (samples[sample].mode & WAVE_LOOP_BACK) {
	    gus_write_addr(0x0a,
		    sample_ptrs[sample] + samples[sample].loop_end -
		    voices[voice].offset_pending, is16bits);
	    mode |= 0x40;
	}
	gus_write_addr(0x02, sample_ptrs[sample] + samples[sample].loop_start,
		       is16bits);	/* Loop start location */
	gus_write_addr(0x04, sample_ptrs[sample] + samples[sample].loop_end,
		       is16bits);	/* Loop end location */
    } else {
	mode |= 0x20;	/* Loop IRQ at the end */
	voices[voice].loop_irq_mode = LMODE_FINISH; /* Ramp down at the end */
	voices[voice].loop_irq_parm = 1;
	gus_write_addr(0x02, sample_ptrs[sample],
		       is16bits);	/* Loop start location */
	gus_write_addr(0x04, sample_ptrs[sample] + samples[sample].len - 1,
		       is16bits);	/* Loop end location */
    }
    gus_voice_freq(freq);
    gus_voice_balance(pan);
    gus_voice_on(mode);
    splx(flags);

    return 0;
}

/*
 * New guswave_start_note by Andrew J. Robinson attempts to minimize clicking
 * when the note playing on the voice is changed.  It uses volume ramping.
 */

static int
guswave_start_note(int dev, int voice, int note_num, int volume)
{
    long int        flags;
    int             mode;
    int             ret_val = 0;

    flags = splhigh();
    if (note_num == 255) {
	if (voices[voice].volume_irq_mode == VMODE_START_NOTE) {
	    voices[voice].volume_pending = volume;
	} else {
	    ret_val = guswave_start_note2(dev, voice, note_num, volume);
	}
    } else {
	gus_select_voice(voice);
	mode = gus_read8(0x00);
	if (mode & 0x20)
	    gus_write8(0x00, mode & 0xdf);	/* No interrupt! */

	voices[voice].offset_pending = 0;
	voices[voice].kill_pending = 0;
	voices[voice].volume_irq_mode = 0;
	voices[voice].loop_irq_mode = 0;

	if (voices[voice].sample_pending >= 0) {
	    splx(flags);	/* Run temporarily with interrupts
				 * enabled */
	    guswave_set_instr(voices[voice].dev_pending, voice,
			      voices[voice].sample_pending);
	    voices[voice].sample_pending = -1;
	    flags = splhigh();
	    gus_select_voice(voice);	/* Reselect the voice
					 * (just to be sure) */
	}
	if ((mode & 0x01) || (int) ((gus_read16(0x09) >> 4) < 2065)) {
	    ret_val = guswave_start_note2(dev, voice, note_num, volume);
	} else {
	    voices[voice].dev_pending = dev;
	    voices[voice].note_pending = note_num;
	    voices[voice].volume_pending = volume;
	    voices[voice].volume_irq_mode = VMODE_START_NOTE;

	    gus_rampoff();
	    gus_ramp_range(2000, 4065);
	    gus_ramp_rate(0, 63);	/* Fastest possible rate */
	    gus_rampon(0x20 | 0x40);	/* Ramp down, once, irq */
	}
    }
    splx(flags);
    return ret_val;
}

static void
guswave_reset(int dev)
{
    int             i;

    for (i = 0; i < 32; i++) {
	gus_voice_init(i);
	gus_voice_init2(i);
    }
}

static int
guswave_open(int dev, int mode)
{
    int             err;
    int             otherside = audio_devs[dev]->otherside;

    if (otherside != -1) {
	if (audio_devs[otherside]->busy)
	    return -(EBUSY);
    }
    if (audio_devs[dev]->busy)
	return -(EBUSY);

    gus_initialize();
    voice_alloc->timestamp = 0;

    if ((err = DMAbuf_open_dma(gus_devnum)) < 0) {
	printf("GUS: Loading saples without DMA\n");
	gus_no_dma = 1;	/* Upload samples using PIO */
    } else
	gus_no_dma = 0;

    dram_sleep_flag.aborting = 0;
    dram_sleep_flag.mode = WK_NONE;
    active_device = GUS_DEV_WAVE;

    audio_devs[dev]->busy = 1;
    gus_reset();

    return 0;
}

static void
guswave_close(int dev)
{
    int             otherside = audio_devs[dev]->otherside;

    if (otherside != -1) {
	if (audio_devs[otherside]->busy)
	    return;
    }
    audio_devs[dev]->busy = 0;

    active_device = 0;
    gus_reset();

    if (!gus_no_dma)
	DMAbuf_close_dma(gus_devnum);
}

static int
guswave_load_patch(int dev, int format, snd_rw_buf * addr,
		   int offs, int count, int pmgr_flag)
{
    struct patch_info patch;
    int             instr;
    long            sizeof_patch;

    u_long   blk_size, blk_end, left, src_offs, target;

    sizeof_patch = offsetof(struct patch_info, data); /* Header size */

    if (format != GUS_PATCH) {
	printf("GUS Error: Invalid patch format (key) 0x%x\n", format);
	return -(EINVAL);
    }
    if (count < sizeof_patch) {
	printf("GUS Error: Patch header too short\n");
	return -(EINVAL);
    }
    count -= sizeof_patch;

    if (free_sample >= MAX_SAMPLE) {
	printf("GUS: Sample table full\n");
	return -(ENOSPC);
    }
    /*
     * Copy the header from user space but ignore the first bytes which
     * have been transferred already.
     */

    if (uiomove(&((char *) &patch)[offs], sizeof_patch - offs, addr)) {
	printf("audio: Bad copyin()!\n");
    };

    instr = patch.instr_no;

    if (instr < 0 || instr > MAX_PATCH) {
	printf("GUS: Invalid patch number %d\n", instr);
	return -(EINVAL);
    }
    if (count < patch.len) {
	printf("GUS Warning: Patch record too short (%d<%d)\n",
	       count, (int) patch.len);
	patch.len = count;
    }
    if (patch.len <= 0 || patch.len > gus_mem_size) {
	printf("GUS: Invalid sample length %d\n", (int) patch.len);
	return -(EINVAL);
    }
    if (patch.mode & WAVE_LOOPING) {
	if (patch.loop_start < 0 || patch.loop_start >= patch.len) {
	    printf("GUS: Invalid loop start\n");
	    return -(EINVAL);
	}
	if (patch.loop_end < patch.loop_start || patch.loop_end > patch.len) {
	    printf("GUS: Invalid loop end\n");
	    return -(EINVAL);
	}
    }
    free_mem_ptr = (free_mem_ptr + 31) & ~31;	/* 32 byte alignment */

#define GUS_BANK_SIZE (256*1024)

    if (patch.mode & WAVE_16_BITS) {
	/*
	 * 16 bit samples must fit one 256k bank.
	 */
	if (patch.len >= GUS_BANK_SIZE) {
	    printf("GUS: Sample (16 bit) too long %d\n", (int) patch.len);
	    return -(ENOSPC);
	}
	if ((free_mem_ptr / GUS_BANK_SIZE) !=
		((free_mem_ptr + patch.len) / GUS_BANK_SIZE)) {
	    u_long   tmp_mem =	/* Aligning to 256K */
		    ((free_mem_ptr / GUS_BANK_SIZE) + 1) * GUS_BANK_SIZE;

	    if ((tmp_mem + patch.len) > gus_mem_size)
		return -(ENOSPC);

	    free_mem_ptr = tmp_mem;	/* This leaves unusable memory */
	}
    }
    if ((free_mem_ptr + patch.len) > gus_mem_size)
	return -(ENOSPC);

    sample_ptrs[free_sample] = free_mem_ptr;

    /*
     * Tremolo is not possible with envelopes
     */

    if (patch.mode & WAVE_ENVELOPES)
	patch.mode &= ~WAVE_TREMOLO;

    bcopy(&patch, (char *) &samples[free_sample], sizeof_patch);

    /*
     * Link this_one sample to the list of samples for patch 'instr'.
     */

    samples[free_sample].key = patch_table[instr];
    patch_table[instr] = free_sample;

    /*
     * Use DMA to transfer the wave data to the DRAM
     */

    left = patch.len;
    src_offs = 0;
    target = free_mem_ptr;

    while (left) {		/* Not completely transferred yet */
	/* blk_size = audio_devs[gus_devnum]->buffsize; */
	blk_size = audio_devs[gus_devnum]->dmap_out->bytes_in_use;
	if (blk_size > left)
	    blk_size = left;

	/*
	 * DMA cannot cross 256k bank boundaries. Check for that.
	 */
	blk_end = target + blk_size;

	if ((target >> 18) != (blk_end >> 18)) {	/* Split the block */
	    blk_end &= ~(256 * 1024 - 1);
	    blk_size = blk_end - target;
	}
	if (gus_no_dma) {
	    /*
	     * For some reason the DMA is not possible. We have
	     * to use PIO.
	     */
	    long            i;
	    u_char   data;

	    for (i = 0; i < blk_size; i++) {
		uiomove((char *) &(data), 1, addr);
		if (patch.mode & WAVE_UNSIGNED)
		    if (!(patch.mode & WAVE_16_BITS) || (i & 0x01))
			data ^= 0x80;	/* Convert to signed */
		gus_poke(target + i, data);
	    }
	} else {
	    u_long   address, hold_address;
	    u_char   dma_command;
	    u_long   flags;

	    /*
	     * OK, move now. First in and then out.
	     */

	    if (uiomove(audio_devs[gus_devnum]->dmap_out->raw_buf, blk_size, addr)) {
		printf("audio: Bad copyin()!\n");
	    };

	    flags = splhigh();
	    /******** INTERRUPTS DISABLED NOW ********/
	    gus_write8(0x41, 0);	/* Disable GF1 DMA */
	    DMAbuf_start_dma(gus_devnum,
			 audio_devs[gus_devnum]->dmap_out->raw_buf_phys,
			 blk_size, 1);

	    /*
	     * Set the DRAM address for the wave data
	     */

	    address = target;

	    if (audio_devs[gus_devnum]->dmachan1 > 3) {
		hold_address = address;
		address = address >> 1;
		address &= 0x0001ffffL;
		address |= (hold_address & 0x000c0000L);
	    }
	    gus_write16(0x42, (address >> 4) & 0xffff);	/* DRAM DMA address */

	    /*
	     * Start the DMA transfer
	     */

	    dma_command = 0x21;	/* IRQ enable, DMA start */
	    if (patch.mode & WAVE_UNSIGNED)
		dma_command |= 0x80;	/* Invert MSB */
	    if (patch.mode & WAVE_16_BITS)
		dma_command |= 0x40;	/* 16 bit _DATA_ */
	    if (audio_devs[gus_devnum]->dmachan1 > 3)
		dma_command |= 0x04;	/* 16 bit DMA _channel_ */

	    gus_write8(0x41, dma_command);	/* Lets bo luteet (=bugs) */

	    /*
	     * Sleep here until the DRAM DMA done interrupt is
	     * served
	     */
	    active_device = GUS_DEV_WAVE;


	    {
		int   chn;

		dram_sleep_flag.mode = WK_SLEEP;
		dram_sleeper = &chn;
		DO_SLEEP(chn, dram_sleep_flag, hz);

	    };
	    if ((dram_sleep_flag.mode & WK_TIMEOUT))
		printf("GUS: DMA Transfer timed out\n");
	    splx(flags);
	}

	/*
	 * Now the next part
	 */

	left -= blk_size;
	src_offs += blk_size;
	target += blk_size;

	gus_write8(0x41, 0);	/* Stop DMA */
    }

    free_mem_ptr += patch.len;

    if (!pmgr_flag)
	pmgr_inform(dev, PM_E_PATCH_LOADED, instr, free_sample, 0, 0);
    free_sample++;
    return 0;
}

static void
guswave_hw_control(int dev, u_char *event)
{
	int             voice, cmd;
	u_short  p1, p2;
	u_long   plong, flags;

	cmd = event[2];
	voice = event[3];
	p1 = *(u_short *) &event[4];
	p2 = *(u_short *) &event[6];
	plong = *(u_long *) &event[4];

	if ((voices[voice].volume_irq_mode == VMODE_START_NOTE) &&
	    (cmd != _GUS_VOICESAMPLE) && (cmd != _GUS_VOICE_POS))
		do_volume_irq(voice);

	switch (cmd) {

	case _GUS_NUMVOICES:
		flags = splhigh();
		gus_select_voice(voice);
		gus_select_max_voices(p1);
		splx(flags);
		break;

	case _GUS_VOICESAMPLE:
		guswave_set_instr(dev, voice, p1);
		break;

	case _GUS_VOICEON:
		flags = splhigh();
		gus_select_voice(voice);
		p1 &= ~0x20;	/* Don't allow interrupts */
		gus_voice_on(p1);
		splx(flags);
		break;

	case _GUS_VOICEOFF:
		flags = splhigh();
		gus_select_voice(voice);
		gus_voice_off();
		splx(flags);
		break;

	case _GUS_VOICEFADE:
		gus_voice_fade(voice);
		break;

	case _GUS_VOICEMODE:
		flags = splhigh();
		gus_select_voice(voice);
		p1 &= ~0x20;	/* Don't allow interrupts */
		gus_voice_mode(p1);
		splx(flags);
		break;

	case _GUS_VOICEBALA:
		flags = splhigh();
		gus_select_voice(voice);
		gus_voice_balance(p1);
		splx(flags);
		break;

	case _GUS_VOICEFREQ:
		flags = splhigh();
		gus_select_voice(voice);
		gus_voice_freq(plong);
		splx(flags);
		break;

	case _GUS_VOICEVOL:
		flags = splhigh();
		gus_select_voice(voice);
		gus_voice_volume(p1);
		splx(flags);
		break;

	case _GUS_VOICEVOL2:	/* Just update the software voice level */
		voices[voice].initial_volume =
			voices[voice].current_volume = p1;
		break;

	case _GUS_RAMPRANGE:
		if (voices[voice].mode & WAVE_ENVELOPES)
			break;	/* NO-NO */
		flags = splhigh();
		gus_select_voice(voice);
		gus_ramp_range(p1, p2);
		splx(flags);
		break;

	case _GUS_RAMPRATE:
		if (voices[voice].mode & WAVE_ENVELOPES)
			break;	/* NJET-NJET */
		flags = splhigh();
		gus_select_voice(voice);
		gus_ramp_rate(p1, p2);
		splx(flags);
		break;

	case _GUS_RAMPMODE:
		if (voices[voice].mode & WAVE_ENVELOPES)
			break;	/* NO-NO */
		flags = splhigh();
		gus_select_voice(voice);
		p1 &= ~0x20;	/* Don't allow interrupts */
		gus_ramp_mode(p1);
		splx(flags);
		break;

	case _GUS_RAMPON:
		if (voices[voice].mode & WAVE_ENVELOPES)
			break;	/* EI-EI */
		flags = splhigh();
		gus_select_voice(voice);
		p1 &= ~0x20;	/* Don't allow interrupts */
		gus_rampon(p1);
		splx(flags);
		break;

	case _GUS_RAMPOFF:
		if (voices[voice].mode & WAVE_ENVELOPES)
			break;	/* NEJ-NEJ */
		flags = splhigh();
		gus_select_voice(voice);
		gus_rampoff();
		splx(flags);
		break;

	case _GUS_VOLUME_SCALE:
		volume_base = p1;
		volume_scale = p2;
		break;

	case _GUS_VOICE_POS:
		flags = splhigh();
		gus_select_voice(voice);
		gus_set_voice_pos(voice, plong);
		splx(flags);
		break;

	default:;
	}
}

static int
gus_sampling_set_speed(int speed)
{

	if (speed <= 0)
		speed = gus_sampling_speed;

	RANGE(speed, 4000, 44100);
	gus_sampling_speed = speed;

	if (only_read_access) {
		/* Compute nearest valid recording speed  and return it */

		speed = (9878400 / (gus_sampling_speed + 2)) / 16;
		speed = (9878400 / (speed * 16)) - 2;
	}
	return speed;
}

static int
gus_sampling_set_channels(int channels)
{
	if (!channels)
		return gus_sampling_channels;
	RANGE(channels, 1, 2);
	gus_sampling_channels = channels;
	return channels;
}

static int
gus_sampling_set_bits(int bits)
{
	if (!bits)
		return gus_sampling_bits;

	if (bits != 8 && bits != 16)
		bits = 8;

	if (only_8_bits)
		bits = 8;

	gus_sampling_bits = bits;
	return bits;
}

static int
gus_sampling_ioctl(int dev, u_int cmd, ioctl_arg arg, int local)
{
	switch (cmd) {
		case SOUND_PCM_WRITE_RATE:
		if (local)
			return gus_sampling_set_speed((int) arg);
		return *(int *) arg = gus_sampling_set_speed((*(int *) arg));
		break;

	case SOUND_PCM_READ_RATE:
		if (local)
			return gus_sampling_speed;
		return *(int *) arg = gus_sampling_speed;
		break;

	case SNDCTL_DSP_STEREO:
		if (local)
			return gus_sampling_set_channels((int) arg + 1) - 1;
		return *(int *) arg = gus_sampling_set_channels((*(int *) arg) + 1) - 1;
		break;

	case SOUND_PCM_WRITE_CHANNELS:
		if (local)
			return gus_sampling_set_channels((int) arg);
		return *(int *) arg = gus_sampling_set_channels((*(int *) arg));
		break;

	case SOUND_PCM_READ_CHANNELS:
		if (local)
			return gus_sampling_channels;
		return *(int *) arg = gus_sampling_channels;
		break;

	case SNDCTL_DSP_SETFMT:
		if (local)
			return gus_sampling_set_bits((int) arg);
		return *(int *) arg = gus_sampling_set_bits((*(int *) arg));
		break;

	case SOUND_PCM_READ_BITS:
		if (local)
			return gus_sampling_bits;
		return *(int *) arg = gus_sampling_bits;

	case SOUND_PCM_WRITE_FILTER:	/* NOT POSSIBLE */
		return *(int *) arg = -(EINVAL);
		break;

	case SOUND_PCM_READ_FILTER:
		return *(int *) arg = -(EINVAL);
		break;

	}
	return -(EINVAL);
}

static void
gus_sampling_reset(int dev)
{
	if (recording_active) {
		gus_write8(0x49, 0x00);	/* Halt recording */
		set_input_volumes();
	}
}

static int
gus_sampling_open(int dev, int mode)
{

    int             otherside = audio_devs[dev]->otherside;
    if (otherside != -1) {
	if (audio_devs[otherside]->busy)
	    return -(EBUSY);
    }
    if (audio_devs[dev]->busy)
	return -(EBUSY);


    gus_initialize();

    active_device = 0;

    gus_reset();
    reset_sample_memory();
    gus_select_max_voices(14);

    pcm_active = 0;
    dma_active = 0;
    pcm_opened = 1;
    audio_devs[dev]->busy = 1;

    if (mode & OPEN_READ) {
	recording_active = 1;
	set_input_volumes();
    }
    only_read_access = !(mode & OPEN_WRITE);
    only_8_bits = mode & OPEN_READ;
    if (only_8_bits)
	audio_devs[dev]->format_mask = AFMT_U8;
    else
	audio_devs[dev]->format_mask = AFMT_U8 | AFMT_S16_LE;

    return 0;
}

static void
gus_sampling_close(int dev)
{
	int             otherside = audio_devs[dev]->otherside;
	audio_devs[dev]->busy = 0;

	if (otherside != -1) {
		if (audio_devs[otherside]->busy)
			return;
	}
	gus_reset();

	pcm_opened = 0;
	active_device = 0;

	if (recording_active) {
		gus_write8(0x49, 0x00);	/* Halt recording */
		set_input_volumes();
	}
	recording_active = 0;
}

static void
gus_sampling_update_volume(void)
{
    u_long   flags;
    int             voice;

    if (pcm_active && pcm_opened)
	for (voice = 0; voice < gus_sampling_channels; voice++) {
	    flags = splhigh();
	    gus_select_voice(voice);
	    gus_rampoff();
	    gus_voice_volume(1530 + (25 * gus_pcm_volume));
	    gus_ramp_range(65, 1530 + (25 * gus_pcm_volume));
	    splx(flags);
	}
}

static void
play_next_pcm_block(void)
{
    u_long   flags;
    int             speed = gus_sampling_speed;
    int             this_one, is16bits, chn;
    u_long   dram_loc;
    u_char   mode[2], ramp_mode[2];

    if (!pcm_qlen)
	return;

    this_one = pcm_head;

    for (chn = 0; chn < gus_sampling_channels; chn++) {
	mode[chn] = 0x00;
	ramp_mode[chn] = 0x03;	/* Ramping and rollover off */

	if (chn == 0) {
	    mode[chn] |= 0x20;	/* Loop IRQ */
	    voices[chn].loop_irq_mode = LMODE_PCM;
	}
	if (gus_sampling_bits != 8) {
	    is16bits = 1;
	    mode[chn] |= 0x04;	/* 16 bit data */
	} else
	    is16bits = 0;

	dram_loc = this_one * pcm_bsize;
	dram_loc += chn * pcm_banksize;

	if (this_one == (pcm_nblk - 1)) {	/* Last fragment of the
						 * DRAM buffer */
	    mode[chn] |= 0x08;	/* Enable loop */
	    ramp_mode[chn] = 0x03;	/* Disable rollover bit */
	} else {
	    if (chn == 0)
		ramp_mode[chn] = 0x04;	/* Enable rollover bit */
	}

	flags = splhigh();
	gus_select_voice(chn);
	gus_voice_freq(speed);

	if (gus_sampling_channels == 1)
	    gus_voice_balance(7);	/* mono */
	else if (chn == 0)
	    gus_voice_balance(0);	/* left */
	else
	    gus_voice_balance(15);	/* right */

	if (!pcm_active) {	/* Playback not already active */
	    /*
	     * The playback was not started yet (or there has
	     * been a pause). Start the voice (again) and ask for
	     * a rollover irq at the end of this_one block. If
	     * this_one one is last of the buffers, use just the
	     * normal loop with irq.
	     */

	    gus_voice_off();
	    gus_rampoff();
	    gus_voice_volume(1530 + (25 * gus_pcm_volume));
	    gus_ramp_range(65, 1530 + (25 * gus_pcm_volume));

	    gus_write_addr(0x0a, dram_loc, is16bits);	/* Starting position */
	    gus_write_addr(0x02, chn * pcm_banksize, is16bits);	/* Loop start */

	    if (chn != 0)
		gus_write_addr(0x04, pcm_banksize + (pcm_bsize * pcm_nblk) - 1,
			   is16bits);	/* Loop end location */
	}
	if (chn == 0)
	    gus_write_addr(0x04, dram_loc + pcm_datasize[this_one] - 1,
			       is16bits);	/* Loop end location */
	else
	    mode[chn] |= 0x08;	/* Enable looping */

	if (pcm_datasize[this_one] != pcm_bsize) {
	    /*
	     * Incompletely filled block. Possibly the last one.
	     */
	    if (chn == 0) {
		mode[chn] &= ~0x08;	/* Disable looping */
		mode[chn] |= 0x20;	/* Enable IRQ at the end */
		voices[0].loop_irq_mode = LMODE_PCM_STOP;
		ramp_mode[chn] = 0x03;	/* No rollover bit */
	    } else {
		gus_write_addr(0x04, dram_loc + pcm_datasize[this_one],
			       is16bits);	/* Loop end location */
		mode[chn] &= ~0x08;	/* Disable looping */
	    }
	}
	splx(flags);
    }

    for (chn = 0; chn < gus_sampling_channels; chn++) {
	flags = splhigh();
	gus_select_voice(chn);
	gus_write8(0x0d, ramp_mode[chn]);
	gus_voice_on(mode[chn]);
	splx(flags);
    }

    pcm_active = 1;
}

static void
gus_transfer_output_block(int dev, u_long buf,
			  int total_count, int intrflag, int chn)
{
	/*
	 * This routine transfers one block of audio data to the DRAM. In
	 * mono mode it's called just once. When in stereo mode, this_one
	 * routine is called once for both channels.
	 * 
	 * The left/mono channel data is transferred to the beginning of dram
	 * and the right data to the area pointed by gus_page_size.
	 */

	int             this_one, count;
	u_long   flags;
	u_char   dma_command;
	u_long   address, hold_address;

	flags = splhigh();

	count = total_count / gus_sampling_channels;

	if (chn == 0) {
		if (pcm_qlen >= pcm_nblk)
			printf("GUS Warning: PCM buffers out of sync\n");

		this_one = pcm_current_block = pcm_tail;
		pcm_qlen++;
		pcm_tail = (pcm_tail + 1) % pcm_nblk;
		pcm_datasize[this_one] = count;
	} else
		this_one = pcm_current_block;

	gus_write8(0x41, 0);	/* Disable GF1 DMA */
	DMAbuf_start_dma(dev, buf + (chn * count), count, 1);

	address = this_one * pcm_bsize;
	address += chn * pcm_banksize;

	if (audio_devs[dev]->dmachan1 > 3) {
		hold_address = address;
		address = address >> 1;
		address &= 0x0001ffffL;
		address |= (hold_address & 0x000c0000L);
	}
	gus_write16(0x42, (address >> 4) & 0xffff);	/* DRAM DMA address */

	dma_command = 0x21;	/* IRQ enable, DMA start */

	if (gus_sampling_bits != 8)
		dma_command |= 0x40;	/* 16 bit _DATA_ */
	else
		dma_command |= 0x80;	/* Invert MSB */

	if (audio_devs[dev]->dmachan1 > 3)
		dma_command |= 0x04;	/* 16 bit DMA channel */

	gus_write8(0x41, dma_command);	/* Kickstart */

	if (chn == (gus_sampling_channels - 1)) {	/* Last channel */
		/*
		 * Last (right or mono) channel data
		 */
		dma_active = 1;	/* DMA started. There is a unacknowledged
				 * buffer */
		active_device = GUS_DEV_PCM_DONE;
		if (!pcm_active && (pcm_qlen > 0 || count < pcm_bsize)) {
			play_next_pcm_block();
		}
	} else {
		/*
		 * Left channel data. The right channel is transferred after
		 * DMA interrupt
		 */
		active_device = GUS_DEV_PCM_CONTINUE;
	}

	splx(flags);
}

static void
gus_sampling_output_block(int dev, u_long buf, int total_count,
			  int intrflag, int restart_dma)
{
	pcm_current_buf = buf;
	pcm_current_count = total_count;
	pcm_current_intrflag = intrflag;
	pcm_current_dev = dev;
	gus_transfer_output_block(dev, buf, total_count, intrflag, 0);
}

static void
gus_sampling_start_input(int dev, u_long buf, int count,
			 int intrflag, int restart_dma)
{
	u_long   flags;
	u_char   mode;

	flags = splhigh();

	DMAbuf_start_dma(dev, buf, count, 0);

	mode = 0xa0;		/* DMA IRQ enabled, invert MSB */

	if (audio_devs[dev]->dmachan2 > 3)
		mode |= 0x04;	/* 16 bit DMA channel */
	if (gus_sampling_channels > 1)
		mode |= 0x02;	/* Stereo */
	mode |= 0x01;		/* DMA enable */

	gus_write8(0x49, mode);

	splx(flags);
}

static int
gus_sampling_prepare_for_input(int dev, int bsize, int bcount)
{
    u_int    rate;

    rate = (9878400 / (gus_sampling_speed + 2)) / 16;

    gus_write8(0x48, rate & 0xff);	/* Set sampling rate */

    if (gus_sampling_bits != 8) {
	printf("GUS Error: 16 bit recording not supported\n");
	return -(EINVAL);
    }
    return 0;
}

static int
gus_sampling_prepare_for_output(int dev, int bsize, int bcount)
{
	int             i;

	long            mem_ptr, mem_size;

	mem_ptr = 0;
	mem_size = gus_mem_size / gus_sampling_channels;

	if (mem_size > (256 * 1024))
		mem_size = 256 * 1024;

	pcm_bsize = bsize / gus_sampling_channels;
	pcm_head = pcm_tail = pcm_qlen = 0;

	pcm_nblk = MAX_PCM_BUFFERS;
	if ((pcm_bsize * pcm_nblk) > mem_size)
		pcm_nblk = mem_size / pcm_bsize;

	for (i = 0; i < pcm_nblk; i++)
		pcm_datasize[i] = 0;

	pcm_banksize = pcm_nblk * pcm_bsize;

	if (gus_sampling_bits != 8 && pcm_banksize == (256 * 1024))
		pcm_nblk--;

	return 0;
}

static int
gus_local_qlen(int dev)
{
	return pcm_qlen;
}

static void
gus_copy_from_user(int dev, char *localbuf, int localoffs,
		   snd_rw_buf * userbuf, int useroffs, int len)
{
	if (gus_sampling_channels == 1) {

		if (uiomove(&localbuf[localoffs], len, userbuf)) {
			printf("audio: Bad copyin()!\n");
		};
	} else if (gus_sampling_bits == 8) {
		int             in_left = useroffs;
		int             in_right = useroffs + 1;
		char           *out_left, *out_right;
		int             i;

		len /= 2;
		localoffs /= 2;
		out_left = &localbuf[localoffs];
		out_right = out_left + pcm_bsize;

		for (i = 0; i < len; i++) {
			uiomove((char *) &(*out_left++), 1, userbuf);
			in_left += 2;
			uiomove((char *) &(*out_right++), 1, userbuf);
			in_right += 2;
		}
	} else {
		int             in_left = useroffs;
		int             in_right = useroffs + 2;
		short          *out_left, *out_right;
		int             i;

		len /= 4;
		localoffs /= 2;

		out_left = (short *) &localbuf[localoffs];
		out_right = out_left + (pcm_bsize / 2);

		for (i = 0; i < len; i++) {
			uiomove((char *) &(*out_left++), 2, userbuf);
			in_left += 2;
			uiomove((char *) &(*out_right++), 2, userbuf);
			in_right += 2;
		}
	}
}

static struct audio_operations gus_sampling_operations =
{
	"Gravis UltraSound",
	NEEDS_RESTART,
	AFMT_U8 | AFMT_S16_LE,
	NULL,
	gus_sampling_open,
	gus_sampling_close,
	gus_sampling_output_block,
	gus_sampling_start_input,
	gus_sampling_ioctl,
	gus_sampling_prepare_for_input,
	gus_sampling_prepare_for_output,
	gus_sampling_reset,
	gus_sampling_reset,
	gus_local_qlen,
	gus_copy_from_user
};

static void
guswave_setup_voice(int dev, int voice, int chn)
{
	struct channel_info *info =
	&synth_devs[dev]->chn_info[chn];

	guswave_set_instr(dev, voice, info->pgm_num);

	voices[voice].expression_vol =
		info->controllers[CTL_EXPRESSION];	/* Just msb */
	voices[voice].main_vol =
		(info->controllers[CTL_MAIN_VOLUME] * 100) / 128;
	voices[voice].panning =
		(info->controllers[CTL_PAN] * 2) - 128;
	voices[voice].bender = info->bender_value;
}

static void
guswave_bender(int dev, int voice, int value)
{
	int             freq;
	u_long   flags;

	voices[voice].bender = value - 8192;
	freq = compute_finetune(voices[voice].orig_freq, value - 8192,
				voices[voice].bender_range);
	voices[voice].current_freq = freq;

	flags = splhigh();
	gus_select_voice(voice);
	gus_voice_freq(freq);
	splx(flags);
}

static int
guswave_patchmgr(int dev, struct patmgr_info * rec)
{
	int             i, n;

	switch (rec->command) {
	case PM_GET_DEVTYPE:
		rec->parm1 = PMTYPE_WAVE;
		return 0;
		break;

	case PM_GET_NRPGM:
		rec->parm1 = MAX_PATCH;
		return 0;
		break;

	case PM_GET_PGMMAP:
		rec->parm1 = MAX_PATCH;

		for (i = 0; i < MAX_PATCH; i++) {
			int             ptr = patch_table[i];

			rec->data.data8[i] = 0;

			while (ptr >= 0 && ptr < free_sample) {
				rec->data.data8[i]++;
				ptr = samples[ptr].key;	/* Follow link */
			}
		}
		return 0;
		break;

	case PM_GET_PGM_PATCHES:
		{
			int             ptr = patch_table[rec->parm1];

			n = 0;

			while (ptr >= 0 && ptr < free_sample) {
				rec->data.data32[n++] = ptr;
				ptr = samples[ptr].key;	/* Follow link */
			}
		}
		rec->parm1 = n;
		return 0;
		break;

	case PM_GET_PATCH:
		{
			int             ptr = rec->parm1;
			struct patch_info *pat;

			if (ptr < 0 || ptr >= free_sample)
				return -(EINVAL);

			bcopy((char *) &samples[ptr], rec->data.data8, sizeof(struct patch_info));

			pat = (struct patch_info *) rec->data.data8;

			pat->key = GUS_PATCH;	/* Restore patch type */
			rec->parm1 = sample_ptrs[ptr];	/* DRAM location */
			rec->parm2 = sizeof(struct patch_info);
		}
		return 0;
		break;

	case PM_SET_PATCH:
		{
			int             ptr = rec->parm1;
			struct patch_info *pat;

			if (ptr < 0 || ptr >= free_sample)
				return -(EINVAL);

			pat = (struct patch_info *) rec->data.data8;

			if (pat->len > samples[ptr].len)	/* Cannot expand sample */
				return -(EINVAL);

			pat->key = samples[ptr].key;	/* Ensure the link is
							 * correct */

			bcopy(rec->data.data8, (char *) &samples[ptr], sizeof(struct patch_info));

			pat->key = GUS_PATCH;
		}
		return 0;
		break;

	case PM_READ_PATCH:	/* Returns a block of wave data from the DRAM */
		{
			int             sample = rec->parm1;
			int             n;
			long            offs = rec->parm2;
			int             l = rec->parm3;

			if (sample < 0 || sample >= free_sample)
				return -(EINVAL);

			if (offs < 0 || offs >= samples[sample].len)
				return -(EINVAL);	/* Invalid offset */

			n = samples[sample].len - offs;	/* Num of bytes left */

			if (l > n)
				l = n;

			if (l > sizeof(rec->data.data8))
				l = sizeof(rec->data.data8);

			if (l <= 0)
				return -(EINVAL);	/* Was there a bug? */

			offs += sample_ptrs[sample];	/* Begin offsess +
							 * offset to DRAM */

			for (n = 0; n < l; n++)
				rec->data.data8[n] = gus_peek(offs++);
			rec->parm1 = n;	/* Nr of bytes copied */
		}
		return 0;
		break;

	case PM_WRITE_PATCH:	/* Writes a block of wave data to the DRAM */
		{
			int             sample = rec->parm1;
			int             n;
			long            offs = rec->parm2;
			int             l = rec->parm3;

			if (sample < 0 || sample >= free_sample)
				return -(EINVAL);

			if (offs < 0 || offs >= samples[sample].len)
				return -(EINVAL);	/* Invalid offset */

			n = samples[sample].len - offs;	/* Nr of bytes left */

			if (l > n)
				l = n;

			if (l > sizeof(rec->data.data8))
				l = sizeof(rec->data.data8);

			if (l <= 0)
				return -(EINVAL);	/* Was there a bug? */

			offs += sample_ptrs[sample];	/* Begin offsess +
							 * offset to DRAM */

			for (n = 0; n < l; n++)
				gus_poke(offs++, rec->data.data8[n]);
			rec->parm1 = n;	/* Nr of bytes copied */
		}
		return 0;
		break;

	default:
		return -(EINVAL);
	}
}

static int
guswave_alloc(int dev, int chn, int note, struct voice_alloc_info * alloc)
{
	int             i, p, best = -1, best_time = 0x7fffffff;

	p = alloc->ptr;
	/*
	 * First look for a completely stopped voice
	 */

	for (i = 0; i < alloc->max_voice; i++) {
		if (alloc->map[p] == 0) {
			alloc->ptr = p;
			return p;
		}
		if (alloc->alloc_times[p] < best_time) {
			best = p;
			best_time = alloc->alloc_times[p];
		}
		p = (p + 1) % alloc->max_voice;
	}

	/*
	 * Then look for a releasing voice
	 */

	for (i = 0; i < alloc->max_voice; i++) {
		if (alloc->map[p] == 0xffff) {
			alloc->ptr = p;
			return p;
		}
		p = (p + 1) % alloc->max_voice;
	}

	if (best >= 0)
		p = best;

	alloc->ptr = p;
	return p;
}

static struct synth_operations guswave_operations =
{
	&gus_info,
	0,
	SYNTH_TYPE_SAMPLE,
	SAMPLE_TYPE_GUS,
	guswave_open,
	guswave_close,
	guswave_ioctl,
	guswave_kill_note,
	guswave_start_note,
	guswave_set_instr,
	guswave_reset,
	guswave_hw_control,
	guswave_load_patch,
	guswave_aftertouch,
	guswave_controller,
	guswave_panning,
	guswave_volume_method,
	guswave_patchmgr,
	guswave_bender,
	guswave_alloc,
	guswave_setup_voice
};

static void
set_input_volumes(void)
{
	u_long   flags;
	u_char   mask = 0xff & ~0x06;	/* Just line out enabled */

	if (have_gus_max)	/* Don't disturb GUS MAX */
		return;

	flags = splhigh();

	/*
	 * Enable channels having vol > 10% Note! bit 0x01 means the line in
	 * DISABLED while 0x04 means the mic in ENABLED.
	 */
	if (gus_line_vol > 10)
		mask &= ~0x01;
	if (gus_mic_vol > 10)
		mask |= 0x04;

	if (recording_active) {
		/*
		 * Disable channel, if not selected for recording
		 */
		if (!(gus_recmask & SOUND_MASK_LINE))
			mask |= 0x01;
		if (!(gus_recmask & SOUND_MASK_MIC))
			mask &= ~0x04;
	}
	mix_image &= ~0x07;
	mix_image |= mask & 0x07;
	outb(u_Mixer, mix_image);

	splx(flags);
}

int
gus_default_mixer_ioctl(int dev, u_int cmd, ioctl_arg arg)
{

#define MIX_DEVS	(SOUND_MASK_MIC|SOUND_MASK_LINE| \
			 SOUND_MASK_SYNTH|SOUND_MASK_PCM)

    if (((cmd >> 8) & 0xff) == 'M') {
	if (cmd & IOC_IN)
	    switch (cmd & 0xff) {
	    case SOUND_MIXER_RECSRC:
		gus_recmask = (*(int *) arg) & MIX_DEVS;
		if (!(gus_recmask & (SOUND_MASK_MIC | SOUND_MASK_LINE)))
		    gus_recmask = SOUND_MASK_MIC;
		/*
		 * Note! Input volumes are updated during
		 * next open for recording
		 */
		return *(int *) arg = gus_recmask;
		break;

	    case SOUND_MIXER_MIC:
		{
		    int             vol = (*(int *) arg) & 0xff;

		    if (vol < 0)
			vol = 0;
		    if (vol > 100)
			vol = 100;
		    gus_mic_vol = vol;
		    set_input_volumes();
		    return *(int *) arg = vol | (vol << 8);
		}
		break;

	    case SOUND_MIXER_LINE:
		{
		    int             vol = (*(int *) arg) & 0xff;

		    if (vol < 0)
			vol = 0;
		    if (vol > 100)
			vol = 100;
		    gus_line_vol = vol;
		    set_input_volumes();
		    return *(int *) arg = vol | (vol << 8);
		}
		break;

	    case SOUND_MIXER_PCM:
		    gus_pcm_volume = (*(int *) arg) & 0xff;
		    RANGE (gus_pcm_volume, 0, 100);
		    gus_sampling_update_volume();
		    return *(int *) arg = gus_pcm_volume | (gus_pcm_volume << 8);
		    break;

	    case SOUND_MIXER_SYNTH:
		    {
			    int             voice;

			    gus_wave_volume = (*(int *) arg) & 0xff;

			    RANGE (gus_wave_volume , 0, 100);

			    if (active_device == GUS_DEV_WAVE)
				    for (voice = 0; voice < nr_voices; voice++)
					    dynamic_volume_change(voice);	/* Apply the new vol */

			    return *(int *) arg = gus_wave_volume | (gus_wave_volume << 8);
		    }
		    break;

	    default:
		    return -(EINVAL);
	    }
    else
	    switch (cmd & 0xff) {	/* Return parameters */

	    case SOUND_MIXER_RECSRC:
		    return *(int *) arg = gus_recmask;
		    break;

	    case SOUND_MIXER_DEVMASK:
		    return *(int *) arg = MIX_DEVS;
		    break;

	    case SOUND_MIXER_STEREODEVS:
		    return *(int *) arg = 0;
		    break;

	    case SOUND_MIXER_RECMASK:
		    return *(int *) arg = SOUND_MASK_MIC | SOUND_MASK_LINE;
		    break;

	    case SOUND_MIXER_CAPS:
		    return *(int *) arg = 0;
		    break;

	    case SOUND_MIXER_MIC:
		    return *(int *) arg = gus_mic_vol | (gus_mic_vol << 8);
		    break;

	    case SOUND_MIXER_LINE:
		    return *(int *) arg = gus_line_vol | (gus_line_vol << 8);
		    break;

	    case SOUND_MIXER_PCM:
		    return *(int *) arg = gus_pcm_volume | (gus_pcm_volume << 8);
		    break;

	    case SOUND_MIXER_SYNTH:
		    return *(int *) arg = gus_wave_volume | (gus_wave_volume << 8);
		    break;

	    default:
		    return -(EINVAL);
	    }
} else
    return -(EINVAL);
}

static struct mixer_operations gus_mixer_operations = {"Gravis Ultrasound", gus_default_mixer_ioctl};

static void
gus_default_mixer_init()
{
if (num_mixers < MAX_MIXER_DEV)	/* Don't install if there is another
			     * mixer */
    mixer_devs[num_mixers++] = &gus_mixer_operations;

if (have_gus_max) {
    /*
     * Enable all mixer channels on the GF1 side. Otherwise
     * recording will not be possible using GUS MAX.
     */
    mix_image &= ~0x07;
    mix_image |= 0x04;	/* All channels enabled */
    outb(u_Mixer, mix_image);
}
}

/* start of pnp code */

static void 
SEND(int d, int r)
{
outb(PADDRESS, d);
outb(PWRITE_DATA, r);
}




/*
 * Get the device's serial number.  Returns 1 if the serial is valid.
 */
static int
get_serial(int rd_port, u_char *data)
{
	int             i, bit, valid = 0, sum = 0x6a;

	bzero(data, sizeof(char) * 9);

	for (i = 0; i < 72; i++) {
		bit = inb((rd_port << 2) | 0x3) == 0x55;
		DELAY(250);	/* Delay 250 usec */

		/* Can't Short Circuit the next evaluation, so 'and' is last */
		bit = (inb((rd_port << 2) | 0x3) == 0xaa) && bit;
		DELAY(250);	/* Delay 250 usec */

		valid = valid || bit;

		if (i < 64)
			sum = (sum >> 1) |
				(((sum ^ (sum >> 1) ^ bit) << 7) & 0xff);

		data[i / 8] = (data[i / 8] >> 1) | (bit ? 0x80 : 0);
	}
	valid = valid && (data[8] == sum);

	return valid;
}

static void
send_Initiation_LFSR()
{
	int             cur, i;

	/* Reset the LSFR */
	outb(PADDRESS, 0);
	outb(PADDRESS, 0);

	cur = 0x6a;
	outb(PADDRESS, cur);

	for (i = 1; i < 32; i++) {
		cur = (cur >> 1) | (((cur ^ (cur >> 1)) << 7) & 0xff);
		outb(PADDRESS, cur);
	}
}



static int 
isolation_protocol(int rd_port)
{
	int             csn;
	u_char   data[9];

	send_Initiation_LFSR();

	/* Reset CSN for All Cards */
	SEND(0x02, 0x04);

	for (csn = 1; (csn < MAX_CARDS); csn++) {
		/* Wake up cards without a CSN */

		SEND(WAKE, 0);
		SEND(SET_RD_DATA, rd_port);
		outb(PADDRESS, SERIAL_ISOLATION);
		DELAY(1000);	/* Delay 1 msec */
		if (get_serial(rd_port, data)) {
			printf("Board Vendor ID: %c%c%c%02x%02x",
			       ((data[0] & 0x7c) >> 2) + 64,
			       (((data[0] & 0x03) << 3) | ((data[1] & 0xe0) >> 5)) + 64,
			       (data[1] & 0x1f) + 64, data[2], data[3]);
			printf("     Board Serial Number: %08x\n", *(int *) &(data[4]));

			SEND(SET_CSN, csn);	/* Move this out of this
						 * function XXX */
			outb(PADDRESS, PSTATUS);


			return rd_port;
		} else
			break;
	}

	return 0;
}



/*
 * ########################################################################
 * 
 * FUNCTION : IwaveInputSource
 * 
 * PROFILE: This function allows the calling program to select among any of
 * several possible sources to the ADC's. The possible input sources and
 * their corresponding symbolic constants are: - Line        (LINE_IN) - Aux1
 * (AUX1_IN) - Microphone  (MIC_IN) - Mixer       (MIX_IN)
 * 
 * Set the first argument to either LEFT_SOURCE or RIGHT_SOURCE. Always use the
 * symbolic contants for the arguments.
 * 
 * ########################################################################
 */
static void 
IwaveInputSource(BYTE index, BYTE source)
{
	BYTE            reg;

	ENTER_CRITICAL;
	reg = inb(iw.pcodar) & 0xE0;
	outb(iw.pcodar, reg | index);	/* select register CLICI or CRICI */
	reg = inb(iw.cdatap) & ~MIX_IN;
	source &= MIX_IN;
	outb(iw.cdatap, (BYTE) (reg | source));
	LEAVE_CRITICAL;
}
static void 
IwavePnpGetCfg(void)
{
	WORD            val;


	ENTER_CRITICAL;
	IwavePnpDevice(AUDIO);
	outb(_PIDXR, 0x60);	/* select P2X0HI */
	val = ((WORD) inb(iw.pnprdp)) << 8;	/* get P2XR[9:8] */
	outb(_PIDXR, 0x61);	/* select P2XRLI */
	iw.p2xr = val + (WORD) inb(iw.pnprdp);	/* get P2XR[7:4] */

	outb(_PIDXR, 0x62);	/* select P3X0HI */
	val = ((WORD) inb(iw.pnprdp)) << 8;	/* get P3XR[9:8] */
	outb(_PIDXR, 0x63);	/* select P3X0LI */
	iw.p3xr = val + (WORD) inb(iw.pnprdp);	/* get P3XR[7:3] */

	outb(_PIDXR, 0x64);	/* select PHCAI */
	val = ((WORD) inb(iw.pnprdp)) << 8;	/* get PCODAR[9:8] */
	outb(_PIDXR, 0x65);	/* select PLCAI */
	iw.pcodar = val + (WORD) inb(iw.pnprdp);	/* get PCODAR[7:2] */

	outb(_PIDXR, 0x70);	/* select PUI1SI */
	iw.synth_irq = (WORD) (inb(iw.pnprdp) & 0x0F);	/* Synth IRQ number */

	outb(_PIDXR, 0x72);	/* select PUI2SI */
	iw.midi_irq = (WORD) (inb(iw.pnprdp) & 0x0F);	/* MIDI IRQ number */

	outb(_PIDXR, 0x74);	/* select PUD1SI */
	iw.dma1_chan = inb(iw.pnprdp) & 0x07;	/* DMA1 chan (LMC/Codec Rec) */

	outb(_PIDXR, 0x75);	/* select PUD2SI */
	iw.dma2_chan = inb(iw.pnprdp) & 0x07;	/* DMA2 chan (codec play) */


	IwavePnpDevice(EXT);	/* select external device */
	outb(_PIDXR, 0x60);	/* select PRAHI */
	val = ((WORD) inb(iw.pnprdp)) << 8;	/* get PCDRAR[9:8] */
	outb(_PIDXR, 0x61);	/* select PRALI */
	iw.pcdrar = val + (WORD) inb(iw.pnprdp);	/* get PCDRAR[7:4] */
	outb(_PIDXR, 0x62);	/* select PATAHI */
	val = ((WORD) inb(iw.pnprdp)) << 8;	/* get PATAAR[9:8] */
	outb(_PIDXR, 0x63);	/* select PATALI */
	iw.pataar = val + (WORD) inb(iw.pnprdp);	/* get PATAAR[7:1] */

	outb(_PIDXR, 0x70);	/* select PRISI */
	iw.ext_irq = (WORD) (inb(iw.pnprdp) & 0x0F);	/* Ext Dev IRQ number */

	outb(_PIDXR, 0x74);	/* select PRDSI */
	iw.ext_chan = inb(iw.pnprdp) & 0x07;	/* Ext Dev DMA channel */

	IwavePnpDevice(MPU401);	/* Select MPU401 Device */
	outb(_PIDXR, 0x60);	/* select P401HI */
	val = ((WORD) inb(iw.pnprdp)) << 8;	/* get P401AR[9:8] */
	outb(_PIDXR, 0x61);	/* select P401LI */
	iw.p401ar = val + (WORD) inb(iw.pnprdp);	/* get P401AR[7:1] */

	outb(_PIDXR, 0x70);	/* select PMISI */
	iw.mpu_irq = (WORD) (inb(iw.pnprdp) & 0x0F);	/* MPU401 Dev IRQ number */

	IwavePnpDevice(GAME);	/* Select GAME logical Device */
	outb(_PIDXR, 0x60);	/* select P201HI */
	val = ((WORD) inb(iw.pnprdp)) << 8;	/* get P201AR[9:8] */
	outb(_PIDXR, 0x61);	/* select P201LI */
	iw.p201ar = val + (WORD) inb(iw.pnprdp);	/* get P201AR[7:6] */

	IwavePnpDevice(EMULATION);	/* Select SB and ADLIB Device */
	outb(_PIDXR, 0x60);	/* select P388HI */
	val = ((WORD) inb(iw.pnprdp)) << 8;	/* get P388AR[9:8] */
	outb(_PIDXR, 0x61);	/* select P388LI */
	iw.p388ar = val + inb(iw.pnprdp);	/* get P388AR[7:6] */
	outb(_PIDXR, 0x70);	/* select PSBISI */
	iw.emul_irq = (WORD) (inb(iw.pnprdp) & 0x0F);	/* emulation Dev IRQ
							 * number */
	LEAVE_CRITICAL;
}

static void 
IwavePnpSetCfg(void)
{
	ENTER_CRITICAL;
	IwavePnpDevice(AUDIO);	/* select audio device */
	outb(_PIDXR, 0x60);	/* select P2X0HI */
	outb(_PNPWRP, (BYTE) (iw.p2xr >> 8));	/* set P2XR[9:8] */
	outb(_PIDXR, 0x61);	/* select P2X0LI */
	outb(_PNPWRP, (BYTE) iw.p2xr);	/* set P2XR[7:4] */
	/* P2XR[3:0]=0   */
	outb(_PIDXR, 0x62);	/* select P3X0HI */
	outb(_PNPWRP, (BYTE) (iw.p3xr >> 8));	/* set P3XR[9:8] */
	outb(_PIDXR, 0x63);	/* select P3X0LI */
	outb(_PNPWRP, (BYTE) (iw.p3xr));	/* set P3XR[7:3] */
	/* P3XR[2:0]=0   */
	outb(_PIDXR, 0x64);	/* select PHCAI */
	outb(_PNPWRP, (BYTE) (iw.pcodar >> 8));	/* set PCODAR[9:8] */
	outb(_PIDXR, 0x65);	/* select PLCAI */
	outb(_PNPWRP, (BYTE) iw.pcodar);	/* set PCODAR[7:2] */

	outb(_PIDXR, 0x70);	/* select PUI1SI */
	outb(_PNPWRP, (BYTE) (iw.synth_irq & 0x0F));	/* Synth IRQ number */
	outb(_PIDXR, 0x72);	/* select PUI2SI */
	outb(_PNPWRP, (BYTE) (iw.midi_irq & 0x0F));	/* MIDI IRQ number */

	outb(_PIDXR, 0x74);	/* select PUD1SI */
	outb(_PNPWRP, (BYTE) (iw.dma1_chan & 0x07));	/* DMA channel 1 */
	outb(_PIDXR, 0x75);	/* select PUD2SI */
	outb(_PNPWRP, (BYTE) (iw.dma2_chan & 0x07));	/* DMA channel 2 */

	IwavePnpDevice(EXT);
	outb(_PIDXR, 0x60);	/* select PRAHI */
	outb(_PNPWRP, (BYTE) (iw.pcdrar >> 8));	/* set PCDRAR[9:8] */
	outb(_PIDXR, 0x61);	/* select PRALI */
	outb(_PNPWRP, (BYTE) iw.pcdrar);	/* set PCDRAR[7:3] */
	/* PCDRAR[2:0]=0 */
	outb(_PIDXR, 0x62);	/* select PATAHI */
	outb(_PNPWRP, (BYTE) (iw.pataar >> 8));	/* set PATAAR[9:8] */
	outb(_PIDXR, 0x63);	/* select PATALI */
	outb(_PNPWRP, (BYTE) iw.pataar);	/* set PATAAR[7:1] */
	/* PATAAR[0]=0 */
	outb(_PIDXR, 0x70);	/* select PRISI */
	outb(_PNPWRP, (BYTE) (iw.ext_irq & 0x0F));	/* Ext Dev IRQ number */
	outb(_PIDXR, 0x74);	/* select PRDSI */
	outb(_PNPWRP, (BYTE) (iw.ext_chan & 0x07));	/* Ext Dev DMA channel */

	IwavePnpDevice(GAME);
	outb(_PIDXR, 0x60);	/* select P201HI */
	outb(_PNPWRP, (BYTE) (iw.p201ar >> 8));	/* set P201RAR[9:8] */
	outb(_PIDXR, 0x61);	/* select P201LI */
	outb(_PNPWRP, (BYTE) iw.p201ar);	/* set P201AR[7:6] */

	IwavePnpDevice(EMULATION);
	outb(_PIDXR, 0x60);	/* select P388HI */
	outb(_PNPWRP, (BYTE) (iw.p388ar >> 8));	/* set P388AR[9:8] */
	outb(_PIDXR, 0x61);	/* select P388LI */
	outb(_PNPWRP, (BYTE) iw.p388ar);	/* set P388AR[7:6] */

	outb(_PIDXR, 0x70);	/* select PSBISI */
	outb(_PNPWRP, (BYTE) (iw.emul_irq & 0x0F));	/* emulation IRQ number */

	IwavePnpDevice(MPU401);
	outb(_PIDXR, 0x60);	/* select P401HI */
	outb(_PNPWRP, (BYTE) (iw.p401ar >> 8));	/* set P401AR[9:8] */
	outb(_PIDXR, 0x61);	/* select P401LI */
	outb(_PNPWRP, (BYTE) iw.p401ar);	/* set P401AR[7:1] */

	outb(_PIDXR, 0x70);	/* select PMISI */
	outb(_PNPWRP, (BYTE) (iw.mpu_irq & 0x0F));	/* MPU emulation IRQ
							 * number */
	LEAVE_CRITICAL;
}

/* ######################################################################## */
/* FILE: iwpnp.c */
/* */
/* REMARKS: This file contains the definitions for the InterWave's DDK */
/* functions dedicated to the configuration of the InterWave */
/* PNP logic. */
/* */
/* UPDATE: 4/07/95 */
/* ######################################################################## */
/* */
/* FUNCTION: IwavePnpKey */
/* */
/* PROFILE: This function issues the initiation key that places the PNP */
/* logic into configuration mode. The PNP logic is quiescent at */
/* power up and must be enabled by software. This function will */
/* do 32 I/O writes to the PIDXR (0x0279). The function will */
/* first reset the LFSR to its initial value by a sequence of two */
/* write cycles of 0x00 to PIDXR before issuing the key. */
/* */
/* ######################################################################## */
static void 
IwavePnpKey(void)
{
	/* send_Initiation_LFSR(); */

	BYTE            code = 0x6A;
	BYTE            msb;
	BYTE            i;

	/* ############################################### */
	/* Reset Linear Feedback Shift Reg. */
	/* ############################################### */
	outb(0x279, 0x00);
	outb(0x279, 0x00);

	outb(0x279, code);	/* Initial value */

	for (i = 1; i < 32; i++) {
		msb = ((code & 0x01) ^ ((code & 0x02) >> 1)) << 7;
		code = (code >> 1) | msb;
		outb(0x279, code);
	}

}

static BYTE 
IwavePnpIsol(PORT * pnpread)
{
	int             num_pnp_devs;
	int             rd_port = 0;
	printf("Checking for GUS Plug-n-Play ...\n");

	/* Try various READ_DATA ports from 0x203-0x3ff */
	for (rd_port = 0x80; (rd_port < 0xff); rd_port += 0x10) {
		if (0)
			printf("Trying Read_Port at %x\n",
			       (rd_port << 2) | 0x3);

		num_pnp_devs = isolation_protocol(rd_port);
		if (num_pnp_devs) {
			*pnpread = rd_port << 2 | 0x3;
			break;
		}
	}
	if (!num_pnp_devs) {
		printf("No Plug-n-Play devices were found\n");
		return 0;
	}
	return 1;
}

/* ######################################################################## */
/* */
/* FUNCTION: IwavePnpPeek */
/* */
/* PROFILE: This function will return the number of specified bytes of */
/* resource data from the serial EEPROM. The function will NOT */
/* reset the serial EEPROM logic to allow reading the entire */
/* EEPROM by issuing repeated calls. The caller must supply a */
/* pointer to where the data are to be stored. */
/* It is assumed that the InterWave is not in either "sleep" */
/* or "wait for key" states. Note that on the first call, if */
/* the caller means to read from the beggining of data the */
/* serial EEPROM logic must be reset. For this, the caller */
/* should issue a WAKE[CSN] command */
/* */
/* ######################################################################## */
static void 
IwavePnpPeek(PORT pnprdp, WORD bytes, BYTE * data)
{
	WORD            i;
	BYTE            datum;

	for (i = 1; i <= bytes; i++) {
		outb(_PIDXR, 0x05);	/* select PRESSI */

		while (TRUE) {	/* wait til new data byte is ready */
			if (inb(pnprdp) & PNP_DATA_RDY)
				break;	/* new resource byte ready */
		}
		outb(_PIDXR, 0x04);	/* select PRESDI */
		datum = inb(pnprdp);	/* read resource byte */
		if (data != NULL)
			*(data++) = datum;	/* store it */
	}
}
/* ######################################################################## */
/* */
/* FUNCTION: IwavePnpActivate */
/* */
/* PROFILE: This function will activate or de-activate the audio device */
/* or the external device on the InterWave. Set the "dev" arg */
/* to AUDIO for the audio device or EXT for the external device. */
/* Set "bool" to ON or OFF to turn the device on or off the ISA */
/* bus. Notice that for a logical device to work, it must be */
/* activated. */
/* */
/* ######################################################################## */
static void 
IwavePnpActivate(BYTE dev, BYTE bool)
{
	IwavePnpDevice(dev);	/* select audio device */
	ENTER_CRITICAL;
	outb(_PIDXR, ACTIVATE_DEV);	/* select Activate Register */
	outb(_PNPWRP, bool);	/* write register */
	LEAVE_CRITICAL;

}
/* ######################################################################## */
/* */
/* FUNCTION: IwavePnpDevice */
/* */
/* PROFILE: This function allows the caller to select between five */
/* logical devices available on the InterWave.It is assumed */
/* that the PNP state machine is in configuration mode. */
/* */
/* ######################################################################## */
static void 
IwavePnpDevice(BYTE dev)
{
	ENTER_CRITICAL;
	outb(_PIDXR, _PLDNI);	/* select PLDNI */
	outb(_PNPWRP, dev);	/* write PLDNI */
	LEAVE_CRITICAL;
}
/* ######################################################################## */
/* */
/* FUNCTION: IwavePnpWake */
/* */
/* PROFILE: This function issues a WAKE[CSN] command to the InterWave. If */
/* the CSN matches the PNP state machine will enter the */
/* configuration state. Otherwise it will enter the sleep mode. */
/* */
/* It is assumed that the PNP state machine is not in the */
/* "wait for key" state. */
/* */
/* ######################################################################## */
static void 
IwavePnpWake(BYTE csn)
{
	ENTER_CRITICAL;
	outb(_PIDXR, _PWAKEI);	/* select PWAKEI */
	outb(_PNPWRP, csn);	/* write csn */
	LEAVE_CRITICAL;
}
/* ######################################################################## */
/* */
/*
 * FUNCTION: IwavePnpPing
 */
/* */
/* PROFILE: This function allows the caller to detect an InterWave based */
/* adapter board and will return its asigned CSN so that an */
/* an application can access its PnP interface and determine the */
/* borad's current configuration. In conducting its search for */
/* the InterWave IC, the function will use the first 32 bits of */
/* the Serial Identifier called the vendor ID in the PnP ISA */
/* spec. The last 4 bits in the Vendor ID represent a revision */
/* number for the particular product and will not be included */
/* in the search. The function will return the Vendor ID and the */
/* calling application should check the revision bits to make */
/* sure they are compatible with the board. */
/* */
/* ######################################################################## */
static BYTE 
IwavePnpPing(DWORD VendorID)
{
	BYTE            csn;

	VendorID &= (0xFFFFFFF0);	/* reset 4 least significant bits */
	IwavePnpKey();		/* Key to access PnP Interface */
	while (iw.pnprdp <= 0x23F) {
		for (csn = 1; csn <= 10; csn++) {
			IwavePnpWake(csn);	/* Select card */
			IwavePnpPeek(iw.pnprdp, 4, (BYTE *) & iw.vendor);	/* get vendor ID */


			if (((iw.vendor) & 0xFFFFFFF0) == VendorID) {	/* If IDs match,
									 * InterWave is found */

				outb(_PIDXR, 0x02);	/* Place all cards in
							 * wait-for-key state */
				outb(0x0A79, 0x02);
				return (csn);
			}
		}
		iw.pnprdp += 0x04;
	}
	outb(_PIDXR, 0x02);	/* Place all cards in wait-for-key state */
	outb(0x0A79, 0x02);
	return (FALSE);		/* InterWave IC not found */
}

/* end of pnp code */

static WORD 
IwaveMemSize(void)
{
	BYTE            datum = 0x55;
	ADDRESS         local = 0L;

	outb(iw.igidxr, _LMCI);
	outb(iw.i8dp, inb(iw.i8dp) & 0xFD);	/* DRAM I/O cycles selected */

	while (TRUE) {
		IwaveMemPoke(local, datum);
		IwaveMemPoke(local + 1L, datum + 1);
		if (IwaveMemPeek(local) != datum || IwaveMemPeek(local + 1L) != (datum + 1) || IwaveMemPeek(0L) != 0x55)
			break;
		local += RAM_STEP;
		datum++;
	}
	return ((WORD) (local >> 10));
}

static BYTE 
IwaveMemPeek(ADDRESS addr)
{
	PORT            p3xr;

	p3xr = iw.p3xr;


	outb(iw.igidxr, 0x43);	/* Select LMALI */
	outw(iw.i16dp, (WORD) addr);	/* Lower 16 bits of LM */
	outb(iw.igidxr, 0x44);	/* Select LMAHI */
	outb(iw.i8dp, (BYTE) (addr >> 16));	/* Upper 8 bits of LM */
	return (inb(iw.lmbdr));	/* return byte from LMBDR */
}


static void 
IwaveMemPoke(ADDRESS addr, BYTE datum)
{
	PORT            p3xr;
	p3xr = iw.p3xr;


	outb(iw.igidxr, 0x43);	/* Select LMALI */
	outw(iw.i16dp, (WORD) addr);	/* Lower 16 bits of LM */
	outb(iw.igidxr, 0x44);	/* Select LMAHI */
	outb(iw.i8dp, (BYTE) (addr >> 16));	/* Upper 8 bits of LM */
	outb(iw.lmbdr, datum);	/* Write byte to LMBDR */
}

/* ######################################################################## */
/* */
/* FUNCTION: IwaveMemCfg */
/* */
/* PROFILE : This function determines the amount of DRAM from its */
/* configuration accross all banks. It sets the configuration */
/* into register LMCFI and stores the total amount of DRAM */
/* into iw.size_mem (Kbytes). */
/* */
/* The function first places the IC in enhanced mode to allow */
/* full access to all DRAM locations. Then it selects full */
/* addressing span (LMCFI[3:0]=0x0C). Finally, it determines */
/* the amount of DRAM in each bank and from this the actual */
/* configuration. */
/* */
/* Note that if a configuration other than one indicated in */
/* the manual is implemented, this function will select */
/* full addressing span (LMCFI[3:0]=0xC). */
/* */
/* ######################################################################## */
static void 
IwaveMemCfg(DWORD * lpbanks)
{
	DWORD           bank[4] = {0L, 0L, 0L, 0L};
	DWORD           addr = 0L, base = 0L, cnt = 0L;
	BYTE            i, reg, ram = FALSE;
	WORD            lmcfi;
	/* */
	ENTER_CRITICAL;
	outb(iw.igidxr, 0x99);
	reg = inb(iw.i8dp);	/* image of sgmi */
	outb(iw.igidxr, 0x19);
	outb(iw.i8dp, (BYTE) (reg | 0x01));	/* enable enhaced mode */
	outb(iw.igidxr, _LMCFI);/* select LM Conf Reg */
	lmcfi = inw(iw.i16dp) & 0xFFF0;
	outw(iw.i16dp, lmcfi | 0x000C);	/* max addr span */
	/* */
	/* Clear every RAM_STEPth location */
	/* */
	while (addr < RAM_MAX) {
		IwaveMemPoke(addr, 0x00);
		addr += RAM_STEP;
	}
	/* */
	/* Determine amount of RAM in each bank */
	/* */
	for (i = 0; i < 4; i++) {
		IwaveMemPoke(base, 0xAA);	/* mark start of bank */
		IwaveMemPoke(base + 1L, 0x55);
		if ((IwaveMemPeek(base) == 0xAA) && (IwaveMemPeek(base + 1L) == 0x55))
			ram = TRUE;
		if (ram) {
			while (cnt < BANK_MAX) {
				bank[i] += RAM_STEP;
				cnt += RAM_STEP;
				addr = base + cnt;
				if (IwaveMemPeek(addr) == 0xAA)
					break;
			}
		}
		if (lpbanks != NULL) {
			*lpbanks = bank[i];
			lpbanks++;
		}
		bank[i] = bank[i] >> 10;
		base += BANK_MAX;
		cnt = 0L;
		ram = FALSE;
	}
	/* */
	iw.flags &= ~DRAM_HOLES;
	outb(iw.igidxr, _LMCFI);
	if (bank[0] == 256 && bank[1] == 0 && bank[2] == 0 && bank[3] == 0)
		outw(iw.i16dp, lmcfi);
	else if (bank[0] == 256 && bank[1] == 256 && bank[2] == 0 && bank[3] == 0)
		outw(iw.i16dp, lmcfi | 0x01);
	else if (bank[0] == 256 && bank[1] == 256 && bank[2] == 256 && bank[3] == 256)
		outw(iw.i16dp, lmcfi | 0x02);
	else if (bank[0] == 256 && bank[1] == 1024 && bank[2] == 0 && bank[3] == 0)
		outw(iw.i16dp, lmcfi | 0x03);
	else if (bank[0] == 256 && bank[1] == 1024 && bank[2] == 1024 && bank[3] == 1024)
		outw(iw.i16dp, lmcfi | 0x04);
	else if (bank[0] == 256 && bank[1] == 256 && bank[2] == 1024 && bank[3] == 0)
		outw(iw.i16dp, lmcfi | 0x05);
	else if (bank[0] == 256 && bank[1] == 256 && bank[2] == 1024 && bank[3] == 1024)
		outw(iw.i16dp, lmcfi | 0x06);
	else if (bank[0] == 1024 && bank[1] == 0 && bank[2] == 0 && bank[3] == 0)
		outw(iw.i16dp, lmcfi | 0x07);
	else if (bank[0] == 1024 && bank[1] == 1024 && bank[2] == 0 && bank[3] == 0)
		outw(iw.i16dp, lmcfi | 0x08);
	else if (bank[0] == 1024 && bank[1] == 1024 && bank[2] == 1024 && bank[3] == 1024)
		outw(iw.i16dp, lmcfi | 0x09);
	else if (bank[0] == 4096 && bank[1] == 0 && bank[2] == 0 && bank[3] == 0)
		outw(iw.i16dp, lmcfi | 0x0A);
	else if (bank[0] == 4096 && bank[1] == 4096 && bank[2] == 0 && bank[3] == 0)
		outw(iw.i16dp, lmcfi | 0x0B);
	else			/* Flag the non-contiguous config of memory */
		iw.flags |= DRAM_HOLES;
	/* */
	outb(iw.igidxr, 0x19);	/* restore sgmi */
	outb(iw.i8dp, reg);
	LEAVE_CRITICAL;
}


/* ######################################################################## */
/**/
/* FUNCTION: IwaveCodecIrq */
/**/
/* PROFILE: This function disables or enables the Codec Interrupts. To */
/* enable interrupts set CEXTI[2] high thus causing all interrupt */
/* sources (CSR3I[6:4]) to pass onto the IRQ pin. To disable */
/* interrupts set CEXTI[1]=0. To enable Code IRQs issue this call: */
/**/
/* IwaveCodecIrq(CODEC_IRQ_ENABLE). To disable IRQs issue the call */
/**/
/* IwaveCodeIrq(~CODEC_IRQ_ENABLE). */
/**/
/* ######################################################################## */
static void 
IwaveCodecIrq(BYTE mode)
{
	BYTE            reg;

	ENTER_CRITICAL;
	reg = inb(iw.pcodar) & 0xE0;
	outb(iw.pcodar, reg | _CSR3I);	/* select CSR3I */
	outb(iw.cdatap, 0x00);	/* clear all interrupts */
	outb(iw.pcodar + 0x02, 0x00);	/* clear CSR1R */
	outb(iw.pcodar, reg | _CEXTI);	/* select CEXTI */
	reg = inb(iw.cdatap);
	if (mode == CODEC_IRQ_ENABLE)	/* enable Codec Irqs */
		outb(iw.cdatap, (BYTE) (reg | CODEC_IRQ_ENABLE));
	else			/* disable Codec Irqs */
		outb(iw.cdatap, (BYTE) (reg & ~CODEC_IRQ_ENABLE));
	LEAVE_CRITICAL;
}


/* ######################################################################### */
/**/
/* FUNCTION: IwaveRegPeek */
/**/
/* PROFILE : This function returns the value stored in any readable */
/* InterWave register. It takes as input a pointer to a */
/* structure containing the addresses of the relocatable I/O */
/* space as well as a register mnemonic. To correctly use this */
/* function, the programmer must use the mnemonics defined in */
/* "iwdefs.h". These mnemonics contain coded information used */
/* by the function to properly access the desired register. */
/**/
/* An attempt to read from a write-only register will return */
/* meaningless data. */
/**/
/* ######################################################################### */
static WORD 
IwaveRegPeek(DWORD reg_mnem)
{
	BYTE            index, val;
	WORD            reg_id, offset;

	offset = (WORD) ((BYTE) reg_mnem);
	reg_id = (WORD) (reg_mnem >> 16);
	index = (BYTE) (reg_mnem >> 8);

	/* ################################################### */
	/* Logic to read registers in P2XR block & GMCR */
	/* ################################################### */

	if (reg_id >= 0x0001 && reg_id <= 0x001A) {	/* UMCR to GMCR */
		if (reg_id <= 0x000E)	/* UMCR to USRR */
			return ((WORD) inb(iw.p2xr + offset));

		if (reg_id == 0x0019)
			return ((WORD) inb(iw.p201ar));

		else {		/* GUS Hidden registers or GMCR */
			BYTE            iveri;

			outb(iw.igidxr, 0x5B);	/* select IVERI */
			iveri = inb(iw.i8dp);	/* read IVERI */
			outb(iw.i8dp, (BYTE) (iveri | 0x09));	/* set IVERI[3,0] */
			if (reg_id == 0x001A) {	/* GMCR */
				val = inb(iw.p3xr);
				outb(iw.i8dp, iveri);	/* restore IVERI */
				return ((WORD) val);
			}
			val = inb(iw.p2xr + 0x0F);	/* read URCR */
			val = (val & 0xF8) | index;	/* value for URCR[2:0] */
			outb(iw.p2xr + 0x0F, val);	/* set URCR[2:0] */

			if (reg_mnem == UDCI || reg_mnem == UICI) {
				val = inb(iw.p2xr);
				if (reg_mnem == UDCI)
					outb(iw.p2xr, (BYTE) (val & 0xBF));
				else
					outb(iw.p2xr, (BYTE) (val | 0x40));
			}
			val = inb(iw.p2xr + 0x0B);
			outb(iw.igidxr, 0x5B);	/* select IVERI */
			outb(iw.i8dp, iveri);	/* restore IVERI */
			return ((WORD) val);	/* read register */
		}
	}
	/* ################################################### */
	/* Logic to read registers in P3XR block */
	/* ################################################### */

	if (reg_id >= 0x001B && reg_id <= 0x005C) {	/* GMSR to LMBDR */
		if (reg_id == 0x005C)	/* LMBDR */
			return ((WORD) inb(iw.lmbdr));

		if (reg_id >= 0x001B && reg_id <= 0x0021)	/* GMSR to I8DP */
			if (offset == 0x04)
				return (inw(iw.i16dp));
			else
				return ((WORD) inb(iw.p3xr + offset));
		else {		/* indexed registers */

			if (reg_id <= 0x003F)
				index |= 0x80;	/* adjust for reading */

			outb(iw.igidxr, index);	/* select register */

			if (offset == 0x04)
				return (inw(iw.i16dp));
			else
				return ((WORD) inb(iw.i8dp));
		}
	}
	/* #################################################### */
	/* Logic to read registers in PCODAR block */
	/* #################################################### */

	if (reg_id >= 0x005D && reg_id <= 0x0081) {	/* CIDXR to CLRCTI */
		if (reg_id <= 0x0061)
			return ((WORD) inb(iw.pcodar + offset));	/* CRDR */

		else {		/* indexed registers */
			BYTE            cidxr;

			cidxr = inb(iw.pcodar);
			cidxr = (cidxr & 0xE0) + index;
			outb(iw.pcodar, cidxr);	/* select register */
			return ((WORD) inb(iw.cdatap));
		}
	}
	/* ##################################################### */
	/* Logic to read the PnP registers */
	/* ##################################################### */
	if (reg_id >= 0x0082 && reg_id <= 0x00B7) {	/* PCSNBR to PMITI */
		if (reg_id == 0x0085)
			return ((WORD) inb(iw.pnprdp));

		if (reg_id < 0x0085)
			return ((WORD) inb((WORD) reg_mnem));

		else {		/* indexed registers */
			if (reg_id >= 0x008E && reg_id <= 0x00B7) {
				outb(0x0279, 0x07);	/* select PLDNI */
				outb(0xA79, (BYTE) offset);	/* select logical dev */
			}
			outb(0x0279, index);	/* select the register */
			return ((WORD) inb(iw.pnprdp));
		}
	}
	return 0;
}
/* ######################################################################### */
/**/
/* FUNCTION: IwaveRegPoke */
/**/
/* PROFILE : This function writes a value to any writable */
/* InterWave register. It takes as input a pointer to a */
/* structure containing the addresses of the relocatable I/O */
/* space as well as a register mnemonic. To correctly use this */
/* function, the programmer must use the mnemonics defined in */
/* "iwdefs.h". These mnemonics contain coded information used */
/* by the function to properly access the desired register. */
/**/
/* This function does not guard against writing to read-only */
/* registers. It is the programmer's responsibility to ensure */
/* that the writes are to valid registers. */
/**/
/* ######################################################################### */
static void 
IwaveRegPoke(DWORD reg_mnem, WORD datum)
{
	BYTE            index;
	BYTE            val;
	WORD            reg_id;
	WORD            offset;

	offset = (WORD) ((BYTE) reg_mnem);
	reg_id = (WORD) (reg_mnem >> 16);
	index = (BYTE) (reg_mnem >> 8);


	/* ####################################################### */
	/* Logic to write to registers in P2XR block */
	/* ####################################################### */
	if (reg_id >= 0x0001 && reg_id <= 0x0019) {	/* UMCR to GGCR */
		if (reg_id <= 0x000E) {	/* UMCR to USRR */
			outb(iw.p2xr + offset, (BYTE) datum);
			return;
		}
		if (reg_id == 0x0019) {
			outb(iw.p201ar, (BYTE) datum);
			return;
		} else {	/* GUS Hidden registers */

			BYTE            iveri;

			outb(iw.igidxr, 0x5B);	/* select IVERI */
			iveri = inb(iw.i8dp);	/* read IVERI */
			outb(iw.i8dp, (BYTE) (iveri | 0x09));	/* set IVERI[3,0] */
			val = inb(iw.p2xr + 0x0F);	/* read URCR */
			val = (val & 0xF8) | index;	/* value for URCR[2:0] */
			outb(iw.p2xr + 0x0F, val);	/* set URCR[2:0] */

			if (reg_mnem == UDCI || reg_mnem == UICI) {
				val = inb(iw.p2xr);	/* read UMCR */
				if (reg_mnem == UDCI)
					outb(iw.p2xr, (BYTE) (val & 0xBF));	/* set UMCR[6]=0 */
				else
					outb(iw.p2xr, (BYTE) (val | 0x40));	/* set UMCR[6]=1 */
			}
			outb(iw.p2xr + 0x0B, (BYTE) datum);	/* write register */
			outb(iw.igidxr, 0x5B);	/* select IVERI */
			outb(iw.i8dp, iveri);	/* restore IVERI */
			return;
		}
	}
	/* ############################################################# */
	/* Logic to write to registers in P3XR block */
	/* ############################################################# */

	if (reg_id >= 0x001A && reg_id <= 0x005C) {	/* GMCR to LMBDR */

		if (reg_id == 0x005C) {	/* LMBDR */
			outb(iw.lmbdr, (BYTE) datum);
			return;
		}
		if (reg_id == 0x001B)	/* GMSR */
			return;

		if (reg_id >= 0x001A && reg_id <= 0x0021)	/* GMCR to I8DP */
			if (offset == 0x04)
				outw(iw.i16dp, datum);
			else
				outb(iw.p3xr + offset, (BYTE) datum);
		else {		/* indexed registers */
			outb(iw.igidxr, index);	/* select register */

			if (offset == 0x04)
				outw(iw.i16dp, datum);
			else
				outb(iw.i8dp, (BYTE) datum);
		}
	}
	/* /################################################### */
	/* Logic to write to registers in PCODAR block */
	/* ################################################### */

	if (reg_id >= 0x005C && reg_id <= 0x0081) {	/* CIDXR to CLRCTI */
		if (reg_id <= 0x0061)
			outb(iw.pcodar + offset, (BYTE) datum);

		else {		/* one of the indexed registers */
			BYTE            cidxr;

			cidxr = inb(iw.pcodar);
			cidxr = (cidxr & 0xE0) + index;
			outb(iw.pcodar, cidxr);	/* select register */
			outb(iw.cdatap, (BYTE) datum);
		}
	}
	/* ###################################################### */
	/* Logic to write to the PnP registers */
	/* ###################################################### */
	if (reg_id >= 0x0082 && reg_id <= 0x00B7) {
		if (reg_id == 0x0085) {
			outb(iw.pnprdp, (BYTE) datum);
			return;
		}
		if (reg_id < 0x0085)
			outb((WORD) reg_mnem, (BYTE) datum);

		else {		/* one of the indexed registers */
			if (reg_id >= 0x008E && reg_id <= 0x00B7) {
				outb(0x0279, 0x07);	/* select PLDNI */
				outb(0xA79, (BYTE) offset);	/* select logical dev */
			}
			outb(0x0279, index);	/* select the register */
			outb(0xA79, (BYTE) datum);
		}
	}
}


static void 
IwaveLineLevel(char level, char index)
{
	char            reg;

	level &= 0x1F;

	ENTER_CRITICAL;
	reg = inb(iw.pcodar) & 0xE0;
	outb(iw.pcodar, reg | index);	/* select register */
	outb(iw.cdatap, (BYTE) ((inb(iw.cdatap) & 0x80) | level));	/* set level */
	LEAVE_CRITICAL;
}

static void 
IwaveCodecMode(char mode)
{
    char            reg;

    ENTER_CRITICAL;
    reg = inb(iw.pcodar) & 0xE0;
    outb(iw.pcodar, reg | _CMODEI);	/* select CMODEI */
    outb(iw.cdatap, mode);
    LEAVE_CRITICAL;
    iw.cmode = mode;
}

static void 
IwaveLineMute(BYTE mute, BYTE inx)
{
    BYTE            reg;

    ENTER_CRITICAL;
    reg = inb(iw.pcodar) & 0xE0;
    outb(iw.pcodar, reg | inx);	/* select register */
    if (mute == ON)
	outb(iw.cdatap, (BYTE) (inb(iw.cdatap) | 0x80));	/* mute */
    else
	outb(iw.cdatap, (BYTE) (inb(iw.cdatap) & 0x7F));	/* unmute */
    LEAVE_CRITICAL;
}

static void 
Iwaveinitcodec()
{

	u_short  iwl_codec_base = iw.pcodar;
	u_short  iwl_codec_data = iw.pcodar + 1;
	u_short  foo;



	/*
	 * Set the CEXTI register foo = CODEC_CEXTI_DEFAULT;
	 * IWL_CODEC_OUT(EXTERNAL_CONTROL, foo);
	 */
	/*
	 * Disable Interrupts iwl_codec_disable_irqs();
	 */

	/* Set the CODEC to Operate in Mode 3 */
	IWL_CODEC_OUT(MODE_SELECT_ID, 0x6C);
	foo = inb(iwl_codec_data);

	/* Set the configuration registers to their default values */
	foo = CODEC_CFIG1I_DEFAULT;
	IWL_CODEC_OUT(CONFIG_1 | CODEC_MCE, foo);
	outb(iwl_codec_base, CONFIG_1);
	foo = CODEC_CFIG2I_DEFAULT;
	IWL_CODEC_OUT(CONFIG_2, foo);

	foo = CODEC_CFIG3I_DEFAULT;
	IWL_CODEC_OUT(CONFIG_3, foo);

}



int 
IwaveOpen(char voices, char mode, struct address_info * hw)
{

	u_long   flags;
	u_char   tmp;

	flags = splhigh();

	iw.pnprdp = 0;
	if (IwavePnpIsol(&iw.pnprdp)) {

		iw.vendor = GUS_PNP_ID;

		iw.csn = IwavePnpPing(iw.vendor);

		IwavePnpKey();

		IwavePnpWake(iw.csn);

		IwavePnpGetCfg();
		IwavePnpKey();

		IwavePnpWake(iw.csn);
	}
	if (hw->irq > 0) {
		/* I see the user wants to set the GUS PnP */
		/* Okay lets do it */
		iw.csn = 1;
		iw.p2xr = hw->io_base;
		iw.p3xr = hw->io_base + 0x100;
		iw.pcodar = hw->io_base + 0x10c;

		iw.synth_irq = hw->irq;

		iw.midi_irq = hw->irq;

		iw.dma1_chan = hw->dma;

		if (hw->dma2 == -1) {
			iw.dma2_chan = hw->dma;
		} else {
			iw.dma2_chan = hw->dma2;
		}


	} else {

		/* tell the os what we are doing 8) */
		hw->io_base = iw.p2xr;
		hw->irq = iw.synth_irq;
		/*
		 * iw.dma1_chan = 1; iw.dma2_chan = 3 ;
		 */
		hw->dma = iw.dma1_chan;
		hw->dma2 = iw.dma2_chan;


	}

	if (iw.csn > 0 && iw.csn < MAX_GUS_PNP) {
		gus_pnp_found[iw.csn] = hw->io_base;

	}
	iw.cdatap = iw.pcodar + 1;
	iw.csr1r = iw.pcodar + 2;
	iw.cxdr = iw.pcodar + 3;/* CPDR or CRDR */
	iw.gmxr = iw.p3xr;
	iw.gmxdr = iw.p3xr + 1;	/* GMTDR or GMRDR */
	iw.svsr = iw.p3xr + 2;
	iw.igidxr = iw.p3xr + 3;
	iw.i16dp = iw.p3xr + 4;
	iw.i8dp = iw.p3xr + 5;
	iw.lmbdr = iw.p3xr + 7;
	iw.voices = voices;

	if (iw.pnprdp > 0 && iw.csn > 0) {
		IwavePnpSetCfg();
		IwavePnpActivate(AUDIO, ON);
		IwavePnpActivate(EXT, ON);
	}
	/* IwavePnpActivate(EMULATION,ON); */


	/* reset */
	outb(iw.igidxr, _URSTI);/* Pull reset */
	outb(iw.i8dp, 0x00);
	DELAY(1000 * 30);

	outb(iw.i8dp, 0x01);	/* Release reset */
	DELAY(1000 * 30);

	/* end of reset */


	IwaveMemCfg(NULL);


	tmp = IwaveRegPeek(IDECI);

	IwaveRegPoke(IDECI, tmp | 0x18);

	IwaveCodecMode(CODEC_MODE2);	/* Default codec mode  */
	IwaveRegPoke(ICMPTI, 0);

	outb(iw.igidxr, 0x99);
	tmp = inb(iw.i8dp);
	outb(iw.igidxr, 0x19);
	outb(iw.i8dp, tmp);



	IwaveCodecIrq(~CODEC_IRQ_ENABLE);

	Iwaveinitcodec();

	outb(iw.p2xr, 0x0c);	/* Disable line in, mic and line out */

	IwaveRegPoke(CLCI, 0x3f << 2);

	IwaveLineLevel(0, _CLOAI);
	IwaveLineLevel(0, _CROAI);

	IwaveLineMute(OFF, _CLOAI);
	IwaveLineMute(OFF, _CROAI);

	IwaveLineLevel(0, _CLLICI);
	IwaveLineLevel(0, _CRLICI);
	IwaveLineMute(OFF, _CLLICI);
	IwaveLineMute(OFF, _CRLICI);

	IwaveLineLevel(0, _CLDACI);
	IwaveLineLevel(0, _CRDACI);
	IwaveLineMute(ON, _CLDACI);
	IwaveLineMute(ON, _CRDACI);

	IwaveLineLevel(0, _CLLICI);
	IwaveLineLevel(0, _CRLICI);
	IwaveLineMute(ON, _CLLICI);
	IwaveLineMute(ON, _CRLICI);


	IwaveInputSource(LEFT_SOURCE, MIC_IN);
	IwaveInputSource(RIGHT_SOURCE, MIC_IN);

	outb(iw.pcodar, 0x9 | 0x40);
	outb(iw.cdatap, 0);
	IwaveCodecIrq(CODEC_IRQ_ENABLE);
	outb(iw.pcodar, _CFIG3I | 0x20);


	outb(iw.cdatap, 0xC2);	/* Enable Mode 3 IRQs & Synth  */

	outb(iw.igidxr, _URSTI);
	outb(iw.i8dp, GF1_SET | GF1_OUT_ENABLE | GF1_IRQ_ENABLE);
	DELAY(1000 * 30);
	iw.size_mem = IwaveMemSize();	/* Bytes of RAM in this mode */
	outb(iw.p2xr, 0xc);	/* enable output */
	IwaveRegPoke(CLCI, 0x3f << 2);

	IwaveCodecIrq(CODEC_IRQ_ENABLE);
	splx(flags);

	DELAY(1000 * 100);
	IwaveRegPoke(CPDFI, 0);

	return (TRUE);
}


void
gus_wave_init(struct address_info * hw_config)
{
    u_long   flags;
    u_char   val, gus_pnp_seen = 0;
    char           *model_num = "2.4";
    int             gus_type = 0x24;	/* 2.4 */
    int irq = hw_config->irq, dma = hw_config->dma, dma2 = hw_config->dma2;
    int otherside = -1, i;

    if (irq < 0 || irq > 15) {
	printf("ERROR! Invalid IRQ#%d. GUS Disabled", irq);
	return;
    }
    if (dma < 0 || dma > 7) {
	printf("ERROR! Invalid DMA#%d. GUS Disabled", dma);
	return;
    }
    for (i = 0; i < MAX_GUS_PNP; i++) {
	if (gus_pnp_found[i] != 0 && gus_pnp_found[i] == hw_config->io_base)
	    gus_pnp_seen = 1;
    }
#ifdef NOGUSPNP
    gus_pnp_seen = 0;
#endif

    gus_irq = irq;
    gus_dma = dma;
    gus_dma2 = dma2;

    if (gus_dma2 == -1)
	gus_dma2 = dma;

    /*
     * Try to identify the GUS model.
     * 
     * Versions < 3.6 don't have the digital ASIC. Try to probe it first.
     */

    flags = splhigh();
    outb(gus_base + 0x0f, 0x20);
    val = inb(gus_base + 0x0f);
    splx(flags);

    if (val != 0xff && (val & 0x06)) {	/* Should be 0x02?? */
	/*
	 * It has the digital ASIC so the card is at least v3.4. Next
	 * try to detect the true model.
	 */

	val = inb(u_MixSelect);

	/*
	 * Value 255 means pre-3.7 which don't have mixer. Values 5
	 * thru 9 mean v3.7 which has a ICS2101 mixer. 10 and above
	 * is GUS MAX which has the CS4231 codec/mixer.
	 * 
	 */

	if (gus_pnp_seen)
	    val = 66;

	if (val == 255 || val < 5) {
	    model_num = "3.4";
	    gus_type = 0x34;
	} else if (val < 10) {
	    model_num = "3.7";
	    gus_type = 0x37;
	    mixer_type = ICS2101;
	} else {
	    if (gus_pnp_seen)
		model_num = "PNP";
	    else
		model_num = "MAX";

	    gus_type = 0x40;
	    mixer_type = CS4231;
#ifdef CONFIG_GUSMAX
	    {
		u_char   max_config = 0x40;	/* Codec enable */

		if (gus_dma2 == -1)
		    gus_dma2 = gus_dma;

		if (gus_dma > 3)
		    max_config |= 0x10;	/* 16 bit capture DMA */

		if (gus_dma2 > 3)
		    max_config |= 0x20;	/* 16 bit playback DMA */

		max_config |= (gus_base >> 4) & 0x0f;	/* Extract the X from
							 * 2X0 */

		outb(gus_base + 0x106, max_config);	/* UltraMax control */
	    }

	    if (ad1848_detect(gus_base + 0x10c, NULL, hw_config->osp)) {

		gus_mic_vol = gus_line_vol = gus_pcm_volume = 100;
		gus_wave_volume = 90;
		have_gus_max = 1;
		if (gus_pnp_seen) {

		    ad1848_init("GUS PNP", gus_base + 0x10c,
				-irq,
				gus_dma2,	/* Playback DMA */
				gus_dma,	/* Capture DMA */
				1,	/* Share DMA channels with GF1 */
				hw_config->osp);


		} else {
		    ad1848_init("GUS MAX", gus_base + 0x10c,
				-irq,
				gus_dma2,	/* Playback DMA */
				gus_dma,	/* Capture DMA */
				1,	/* Share DMA channels with GF1 */
				hw_config->osp);
		}
		otherside = num_audiodevs - 1;

	    } else
		printf("[Where's the CS4231?]");
#else
	    printf("\n\n\nGUS MAX support was not compiled in!!!\n\n\n\n");
#endif
	}
    } else {
	/*
	 * ASIC not detected so the card must be 2.2 or 2.4. There
	 * could still be the 16-bit/mixer daughter card.
	 */
    }

    if (gus_pnp_seen) {
	snprintf(gus_info.name, sizeof(gus_info.name),
	    "Gravis %s (%dk)", model_num, (int) gus_mem_size / 1024);
    } else {
	snprintf(gus_info.name, sizeof(gus_info.name),
	    "Gravis UltraSound %s (%dk)", model_num, (int) gus_mem_size / 1024);
    }
    conf_printf(gus_info.name, hw_config);

    if (num_synths >= MAX_SYNTH_DEV)
	printf("GUS Error: Too many synthesizers\n");
    else {
	voice_alloc = &guswave_operations.alloc;
	synth_devs[num_synths++] = &guswave_operations;
#ifdef CONFIG_SEQUENCER
	gus_tmr_install(gus_base + 8);
#endif
    }
    samples = (struct patch_info *) malloc((MAX_SAMPLE + 1) * sizeof(*samples), M_DEVBUF, M_NOWAIT);
    if (!samples)
	panic("SOUND: Cannot allocate memory\n");

    reset_sample_memory();

    gus_initialize();

    if (num_audiodevs < MAX_AUDIO_DEV) {
	audio_devs[gus_devnum = num_audiodevs++] = &gus_sampling_operations;
	audio_devs[gus_devnum]->otherside = otherside;
	audio_devs[gus_devnum]->dmachan1 = dma;
	audio_devs[gus_devnum]->dmachan2 = dma2;
	audio_devs[gus_devnum]->buffsize = DSP_BUFFSIZE;
	if (otherside != -1) {
	    /*
	     * glue logic to prevent people from opening the gus
	     * max via the gf1 and the cs4231 side . Only the gf1
	     * or the cs4231 are allowed to be open
	     */

	    audio_devs[otherside]->otherside = gus_devnum;
	}
	if (dma2 != dma && dma2 != -1)
	    audio_devs[gus_devnum]->flags |= DMA_DUPLEX;
    } else
	printf("GUS: Too many PCM devices available\n");

    /*
     * Mixer dependent initialization.
     */

    switch (mixer_type) {
    case ICS2101:
	gus_mic_vol = gus_line_vol = gus_pcm_volume = 100;
	gus_wave_volume = 90;
	ics2101_mixer_init();
	return;

    case CS4231:
	/* Initialized elsewhere (ad1848.c) */
    default:
	gus_default_mixer_init();
	return;
    }
}

static void
do_loop_irq(int voice)
{
	u_char   tmp;
	int             mode, parm;
	u_long   flags;

	flags = splhigh();
	gus_select_voice(voice);

	tmp = gus_read8(0x00);
	tmp &= ~0x20;		/* Disable wave IRQ for this_one voice */
	gus_write8(0x00, tmp);

	if (tmp & 0x03)		/* Voice stopped */
		voice_alloc->map[voice] = 0;

	mode = voices[voice].loop_irq_mode;
	voices[voice].loop_irq_mode = 0;
	parm = voices[voice].loop_irq_parm;

	switch (mode) {

	case LMODE_FINISH:	/* Final loop finished, shoot volume down */

		if ((int) (gus_read16(0x09) >> 4) < 100) {	/* Get current volume */
			gus_voice_off();
			gus_rampoff();
			gus_voice_init(voice);
			break;
		}
		gus_ramp_range(65, 4065);
		gus_ramp_rate(0, 63);	/* Fastest possible rate */
		gus_rampon(0x20 | 0x40);	/* Ramp down, once, irq */
		voices[voice].volume_irq_mode = VMODE_HALT;
		break;

	case LMODE_PCM_STOP:
		pcm_active = 0;	/* Signal to the play_next_pcm_block routine */
	case LMODE_PCM:
		{
			int             flag;	/* 0 or 2 */

			pcm_qlen--;
			pcm_head = (pcm_head + 1) % pcm_nblk;
			if (pcm_qlen && pcm_active) {
				play_next_pcm_block();
			} else {/* Underrun. Just stop the voice */
				gus_select_voice(0);	/* Left channel */
				gus_voice_off();
				gus_rampoff();
				gus_select_voice(1);	/* Right channel */
				gus_voice_off();
				gus_rampoff();
				pcm_active = 0;
			}

			/*
			 * If the queue was full before this interrupt, the
			 * DMA transfer was suspended. Let it continue now.
			 */
			if (dma_active) {
				if (pcm_qlen == 0)
					flag = 1;	/* Underflow */
				else
					flag = 0;
				dma_active = 0;
			} else
				flag = 2;	/* Just notify the dmabuf.c */
			DMAbuf_outputintr(gus_devnum, flag);
		}
		break;

	default:;
	}
	splx(flags);
}

static void
do_volume_irq(int voice)
{
	u_char   tmp;
	int             mode, parm;
	u_long   flags;

	flags = splhigh();

	gus_select_voice(voice);

	tmp = gus_read8(0x0d);
	tmp &= ~0x20;		/* Disable volume ramp IRQ */
	gus_write8(0x0d, tmp);

	mode = voices[voice].volume_irq_mode;
	voices[voice].volume_irq_mode = 0;
	parm = voices[voice].volume_irq_parm;

	switch (mode) {
	case VMODE_HALT:	/* Decay phase finished */
		splx(flags);
		gus_voice_init(voice);
		break;

	case VMODE_ENVELOPE:
		gus_rampoff();
		splx(flags);
		step_envelope(voice);
		break;

	case VMODE_START_NOTE:
		splx(flags);
		guswave_start_note2(voices[voice].dev_pending, voice,
		  voices[voice].note_pending, voices[voice].volume_pending);
		if (voices[voice].kill_pending)
			guswave_kill_note(voices[voice].dev_pending, voice,
					  voices[voice].note_pending, 0);

		if (voices[voice].sample_pending >= 0) {
			guswave_set_instr(voices[voice].dev_pending, voice,
					  voices[voice].sample_pending);
			voices[voice].sample_pending = -1;
		}
		break;

	default:;
	}
}

void
gus_voice_irq(void)
{
	u_long   wave_ignore = 0, volume_ignore = 0;
	u_long   voice_bit;

	u_char   src, voice;

	while (1) {
		src = gus_read8(0x0f);	/* Get source info */
		voice = src & 0x1f;
		src &= 0xc0;

		if (src == (0x80 | 0x40))
			return;	/* No interrupt */

		voice_bit = 1 << voice;

		if (!(src & 0x80))	/* Wave IRQ pending */
			if (!(wave_ignore & voice_bit) && (int) voice < nr_voices) {	/* Not done yet */
				wave_ignore |= voice_bit;
				do_loop_irq(voice);
			}
		if (!(src & 0x40))	/* Volume IRQ pending */
			if (!(volume_ignore & voice_bit) && (int) voice < nr_voices) {	/* Not done yet */
				volume_ignore |= voice_bit;
				do_volume_irq(voice);
			}
	}
}

void
guswave_dma_irq(void)
{
    u_char   status;

    status = gus_look8(0x41);	/* Get DMA IRQ Status */
    if (status & 0x40)	/* DMA interrupt pending */
	switch (active_device) {
	case GUS_DEV_WAVE:
	    if ((dram_sleep_flag.mode & WK_SLEEP)) {
		dram_sleep_flag.mode = WK_WAKEUP;
		wakeup(dram_sleeper);
	    };
	    break;

	case GUS_DEV_PCM_CONTINUE:	/* Left channel data transferred */
	    gus_transfer_output_block(pcm_current_dev, pcm_current_buf,
			  pcm_current_count, pcm_current_intrflag, 1);
	    break;

	case GUS_DEV_PCM_DONE:	/* Right or mono channel data transferred */
	    if (pcm_qlen < pcm_nblk) {
		int             flag = (1 - dma_active) * 2;	/* 0 or 2 */

		if (pcm_qlen == 0)
		    flag = 1;	/* Underrun */
		dma_active = 0;
		DMAbuf_outputintr(gus_devnum, flag);
	    }
	    break;

		default:;
		}

	status = gus_look8(0x49);	/* Get Sampling IRQ Status */
	if (status & 0x40) {	/* Sampling Irq pending */
		DMAbuf_inputintr(gus_devnum);
	}
}

#ifdef CONFIG_SEQUENCER
/*
 * Timer stuff
 */

static volatile int select_addr, data_addr;
static volatile int curr_timer = 0;

void
gus_timer_command(u_int addr, u_int val)
{
    int             i;

    outb(select_addr, (u_char) (addr & 0xff));

    for (i = 0; i < 2; i++)
	inb(select_addr);

    outb(data_addr, (u_char) (val & 0xff));

    for (i = 0; i < 2; i++)
	inb(select_addr);
}

static void
arm_timer(int timer, u_int interval)
{
    curr_timer = timer;

    if (timer == 1) {
	gus_write8(0x46, 256 - interval);	/* Set counter for timer 1 */
	gus_write8(0x45, 0x04);	/* Enable timer 1 IRQ */
	gus_timer_command(0x04, 0x01);	/* Start timer 1 */
    } else {
	gus_write8(0x47, 256 - interval);	/* Set counter for timer 2 */
	gus_write8(0x45, 0x08);	/* Enable timer 2 IRQ */
	gus_timer_command(0x04, 0x02);	/* Start timer 2 */
    }

    gus_timer_enabled = 0;
}

static u_int
gus_tmr_start(int dev, u_int usecs_per_tick)
{
    int             timer_no, resolution;
    int             divisor;

    if (usecs_per_tick > (256 * 80)) {
	timer_no = 2;
	resolution = 320;	/* usec */
    } else {
	timer_no = 1;
	resolution = 80;/* usec */
    }

    divisor = (usecs_per_tick + (resolution / 2)) / resolution;

    arm_timer(timer_no, divisor);

    return divisor * resolution;
}

static void
gus_tmr_disable(int dev)
{
    gus_write8(0x45, 0);	/* Disable both timers */
    gus_timer_enabled = 0;
}

static void
gus_tmr_restart(int dev)
{
    if (curr_timer == 1)
	gus_write8(0x45, 0x04);	/* Start timer 1 again */
    else
	gus_write8(0x45, 0x08);	/* Start timer 2 again */
}

static struct sound_lowlev_timer gus_tmr =
{
	0,
	gus_tmr_start,
	gus_tmr_disable,
	gus_tmr_restart
};

static void
gus_tmr_install(int io_base)
{
    select_addr = io_base;
    data_addr = io_base + 1;

    sound_timer_init(&gus_tmr, "GUS");
}
#endif
#endif
