freebsd-skq/sys/dev/sound/isa/opl.c

/*
 * A low level driver for Yamaha YM3812 and OPL-3 -chips
 * 
 * Copyright by Hannu Savolainen 1993
 * 
 * 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.
 * 
 */

/*
 * Major improvements to the FM handling 30AUG92 by Rob Hooft,
 */
/*
 * hooft@chem.ruu.nl
 */
/*
 *
 * Ported to the new Audio Driver by Luigi Rizzo:
 * (C) 1999 Seigo Tanimura
 *
 * This is the OPL2/3/4 chip driver for FreeBSD, based on the Luigi Sound Driver.
 * This handles io against /dev/midi, the midi {in, out}put event queues
 * and the event/message operation to the OPL chip.
 *
 * $FreeBSD$
 *
 */

#include <dev/sound/midi/midi.h>
#include <dev/sound/chip.h>

#include <isa/isavar.h>

static devclass_t midi_devclass;

#ifndef DDB
#undef DDB
#define DDB(x)
#endif /* DDB */

/*
 *	The OPL-3 mode is switched on by writing 0x01, to the offset 5
 *	of the right side.
 *
 *	Another special register at the right side is at offset 4. It contains
 *	a bit mask defining which voices are used as 4 OP voices.
 *
 *	The percussive mode is implemented in the left side only.
 *
 *	With the above exeptions the both sides can be operated independently.
 *	
 *	A 4 OP voice can be created by setting the corresponding
 *	bit at offset 4 of the right side.
 *
 *	For example setting the rightmost bit (0x01) changes the
 *	first voice on the right side to the 4 OP mode. The fourth
 *	voice is made inaccessible.
 *
 *	If a voice is set to the 2 OP mode, it works like 2 OP modes
 *	of the original YM3812 (AdLib). In addition the voice can 
 *	be connected the left, right or both stereo channels. It can
 *	even be left unconnected. This works with 4 OP voices also.
 *
 *	The stereo connection bits are located in the FEEDBACK_CONNECTION
 *	register of the voice (0xC0-0xC8). In 4 OP voices these bits are
 *	in the second half of the voice.
 */

/*
 *	Register numbers for the global registers
 */

#define TEST_REGISTER				0x01
#define   ENABLE_WAVE_SELECT		0x20

#define TIMER1_REGISTER				0x02
#define TIMER2_REGISTER				0x03
#define TIMER_CONTROL_REGISTER			0x04	/* Left side */
#define   IRQ_RESET			0x80
#define   TIMER1_MASK			0x40
#define   TIMER2_MASK			0x20
#define   TIMER1_START			0x01
#define   TIMER2_START			0x02

#define CONNECTION_SELECT_REGISTER		0x04	/* Right side */
#define   RIGHT_4OP_0			0x01
#define   RIGHT_4OP_1			0x02
#define   RIGHT_4OP_2			0x04
#define   LEFT_4OP_0			0x08
#define   LEFT_4OP_1			0x10
#define   LEFT_4OP_2			0x20

#define OPL3_MODE_REGISTER			0x05	/* Right side */
#define   OPL3_ENABLE			0x01
#define   OPL4_ENABLE			0x02

#define KBD_SPLIT_REGISTER			0x08	/* Left side */
#define   COMPOSITE_SINE_WAVE_MODE	0x80		/* Don't use with OPL-3? */
#define   KEYBOARD_SPLIT		0x40

#define PERCUSSION_REGISTER			0xbd	/* Left side only */
#define   TREMOLO_DEPTH			0x80
#define   VIBRATO_DEPTH			0x40
#define	  PERCUSSION_ENABLE		0x20
#define   BASSDRUM_ON			0x10
#define   SNAREDRUM_ON			0x08
#define   TOMTOM_ON			0x04
#define   CYMBAL_ON			0x02
#define   HIHAT_ON			0x01

/*
 *	Offsets to the register banks for operators. To get the
 *	register number just add the operator offset to the bank offset
 *
 *	AM/VIB/EG/KSR/Multiple (0x20 to 0x35)
 */
#define AM_VIB					0x20
#define   TREMOLO_ON			0x80
#define   VIBRATO_ON			0x40
#define   SUSTAIN_ON			0x20
#define   KSR				0x10 	/* Key scaling rate */
#define   MULTIPLE_MASK		0x0f	/* Frequency multiplier */

/*
 *	KSL/Total level (0x40 to 0x55)
 */
#define KSL_LEVEL				0x40
#define   KSL_MASK			0xc0	/* Envelope scaling bits */
#define   TOTAL_LEVEL_MASK		0x3f	/* Strength (volume) of OP */

/*
 *	Attack / Decay rate (0x60 to 0x75)
 */
#define ATTACK_DECAY				0x60
#define   ATTACK_MASK			0xf0
#define   DECAY_MASK			0x0f

/*
 * Sustain level / Release rate (0x80 to 0x95)
 */
#define SUSTAIN_RELEASE				0x80
#define   SUSTAIN_MASK			0xf0
#define   RELEASE_MASK			0x0f

/*
 * Wave select (0xE0 to 0xF5)
 */
#define WAVE_SELECT			0xe0

/*
 *	Offsets to the register banks for voices. Just add to the
 *	voice number to get the register number.
 *
 *	F-Number low bits (0xA0 to 0xA8).
 */
#define FNUM_LOW				0xa0

/*
 *	F-number high bits / Key on / Block (octave) (0xB0 to 0xB8)
 */
#define KEYON_BLOCK					0xb0
#define	  KEYON_BIT				0x20
#define	  BLOCKNUM_MASK				0x1c
#define   FNUM_HIGH_MASK			0x03

/*
 *	Feedback / Connection (0xc0 to 0xc8)
 *
 *	These registers have two new bits when the OPL-3 mode
 *	is selected. These bits controls connecting the voice
 *	to the stereo channels. For 4 OP voices this bit is
 *	defined in the second half of the voice (add 3 to the
 *	register offset).
 *
 *	For 4 OP voices the connection bit is used in the
 *	both halfs (gives 4 ways to connect the operators).
 */
#define FEEDBACK_CONNECTION				0xc0
#define   FEEDBACK_MASK				0x0e	/* Valid just for 1st OP of a voice */
#define   CONNECTION_BIT			0x01
/*
 *	In the 4 OP mode there is four possible configurations how the
 *	operators can be connected together (in 2 OP modes there is just
 *	AM or FM). The 4 OP connection mode is defined by the rightmost
 *	bit of the FEEDBACK_CONNECTION (0xC0-0xC8) on the both halfs.
 *
 *	First half	Second half	Mode
 *
 *					 +---+
 *					 v   |
 *	0		0		>+-1-+--2--3--4-->
 *
 *
 *					
 *					 +---+
 *					 |   |
 *	0		1		>+-1-+--2-+
 *						  |->
 *					>--3----4-+
 *					
 *					 +---+
 *					 |   |
 *	1		0		>+-1-+-----+
 *						   |->
 *					>--2--3--4-+
 *
 *					 +---+
 *					 |   |
 *	1		1		>+-1-+--+
 *						|
 *					>--2--3-+->
 *						|
 *					>--4----+
 */
#define   STEREO_BITS				0x30	/* OPL-3 only */
#define     VOICE_TO_LEFT		0x10
#define     VOICE_TO_RIGHT		0x20

/*
 * 	Definition table for the physical voices
 */

struct physical_voice_info {
	unsigned char voice_num;
	unsigned char voice_mode; /* 0=unavailable, 2=2 OP, 4=4 OP */
	int ch; /* channel (left=USE_LEFT, right=USE_RIGHT) */
	unsigned char op[4]; /* Operator offsets */
};

/*
 *	There is 18 possible 2 OP voices
 *	(9 in the left and 9 in the right).
 *	The first OP is the modulator and 2nd is the carrier.
 *
 *	The first three voices in the both sides may be connected
 *	with another voice to a 4 OP voice. For example voice 0
 *	can be connected with voice 3. The operators of voice 3 are
 *	used as operators 3 and 4 of the new 4 OP voice.
 *	In this case the 2 OP voice number 0 is the 'first half' and
 *	voice 3 is the second.
 */

#define USE_LEFT	0
#define USE_RIGHT	1

static struct physical_voice_info pv_map[18] =
{
/*       No Mode Side		OP1	OP2	OP3   OP4	*/
/*	---------------------------------------------------	*/
	{ 0,  2, USE_LEFT,	{0x00,	0x03,	0x08, 0x0b}},
	{ 1,  2, USE_LEFT,	{0x01,	0x04,	0x09, 0x0c}},
	{ 2,  2, USE_LEFT,	{0x02,	0x05,	0x0a, 0x0d}},

	{ 3,  2, USE_LEFT,	{0x08,	0x0b,	0x00, 0x00}},
	{ 4,  2, USE_LEFT,	{0x09,	0x0c,	0x00, 0x00}},
	{ 5,  2, USE_LEFT,	{0x0a,	0x0d,	0x00, 0x00}},

	{ 6,  2, USE_LEFT,	{0x10,	0x13,	0x00, 0x00}}, /* Used by percussive voices */
	{ 7,  2, USE_LEFT,	{0x11,	0x14,	0x00, 0x00}}, /* if the percussive mode */
	{ 8,  2, USE_LEFT,	{0x12,	0x15,	0x00, 0x00}}, /* is selected */

	{ 0,  2, USE_RIGHT,	{0x00,	0x03,	0x08, 0x0b}},
	{ 1,  2, USE_RIGHT,	{0x01,	0x04,	0x09, 0x0c}},
	{ 2,  2, USE_RIGHT,	{0x02,	0x05,	0x0a, 0x0d}},

	{ 3,  2, USE_RIGHT,	{0x08,	0x0b,	0x00, 0x00}},
	{ 4,  2, USE_RIGHT,	{0x09,	0x0c,	0x00, 0x00}},
	{ 5,  2, USE_RIGHT,	{0x0a,	0x0d,	0x00, 0x00}},

	{ 6,  2, USE_RIGHT,	{0x10,	0x13,	0x00, 0x00}},
	{ 7,  2, USE_RIGHT,	{0x11,	0x14,	0x00, 0x00}},
	{ 8,  2, USE_RIGHT,	{0x12,	0x15,	0x00, 0x00}}
};

/* These are the tuning parameters. */
static unsigned short semitone_tuning[24] = 
{
/*   0 */ 10000, 10595, 11225, 11892, 12599, 13348, 14142, 14983, 
/*   8 */ 15874, 16818, 17818, 18877, 20000, 21189, 22449, 23784, 
/*  16 */ 25198, 26697, 28284, 29966, 31748, 33636, 35636, 37755
};

static unsigned short cent_tuning[100] =
{
/*   0 */ 10000, 10006, 10012, 10017, 10023, 10029, 10035, 10041, 
/*   8 */ 10046, 10052, 10058, 10064, 10070, 10075, 10081, 10087, 
/*  16 */ 10093, 10099, 10105, 10110, 10116, 10122, 10128, 10134, 
/*  24 */ 10140, 10145, 10151, 10157, 10163, 10169, 10175, 10181, 
/*  32 */ 10187, 10192, 10198, 10204, 10210, 10216, 10222, 10228, 
/*  40 */ 10234, 10240, 10246, 10251, 10257, 10263, 10269, 10275, 
/*  48 */ 10281, 10287, 10293, 10299, 10305, 10311, 10317, 10323, 
/*  56 */ 10329, 10335, 10341, 10347, 10353, 10359, 10365, 10371, 
/*  64 */ 10377, 10383, 10389, 10395, 10401, 10407, 10413, 10419, 
/*  72 */ 10425, 10431, 10437, 10443, 10449, 10455, 10461, 10467, 
/*  80 */ 10473, 10479, 10485, 10491, 10497, 10503, 10509, 10515, 
/*  88 */ 10521, 10528, 10534, 10540, 10546, 10552, 10558, 10564, 
/*  96 */ 10570, 10576, 10582, 10589
};

/*
 * The next table looks magical, but it certainly is not. Its values have
 * been calculated as table[i]=8*log(i/64)/log(2) with an obvious exception
 * for i=0. This log-table converts a linear volume-scaling (0..127) to a
 * logarithmic scaling as present in the FM-synthesizer chips. so :    Volume
 * 64 =  0 db = relative volume  0 and:    Volume 32 = -6 db = relative
 * volume -8 it was implemented as a table because it is only 128 bytes and
 * it saves a lot of log() calculations. (RH)
 */
static char         opl_volumetable[128] =
{
	-64, -48, -40, -35, -32, -29, -27, -26,
	-24, -23, -21, -20, -19, -18, -18, -17,
	-16, -15, -15, -14, -13, -13, -12, -12,
	-11, -11, -10, -10, -10, -9, -9, -8,
	-8, -8, -7, -7, -7, -6, -6, -6,
	-5, -5, -5, -5, -4, -4, -4, -4,
	-3, -3, -3, -3, -2, -2, -2, -2,
	-2, -1, -1, -1, -1, 0, 0, 0,
	0, 0, 0, 1, 1, 1, 1, 1,
	1, 2, 2, 2, 2, 2, 2, 2,
	3, 3, 3, 3, 3, 3, 3, 4,
	4, 4, 4, 4, 4, 4, 4, 5,
	5, 5, 5, 5, 5, 5, 5, 5,
	6, 6, 6, 6, 6, 6, 6, 6,
	6, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 8, 8, 8, 8, 8};

#define MAX_VOICE 18
#define OFFS_4OP 11
#define SBFM_MAXINSTR 256

/* These are the OPL Models. */
#define MODEL_NONE 0
#define MODEL_OPL2 2
#define MODEL_OPL3 3
#define MODEL_OPL4 4

/* These are the OPL Voice modes. */
#define VOICE_NONE 0
#define VOICE_2OP 2
#define VOICE_4OP 4

/* PnP IDs */
static struct isa_pnp_id opl_ids[] = {
	{0x01200001, "@H@2001 FM Synthesizer"},	/* @H@2001 */
	{0x01100001, "@H@1001 FM Synthesizer"},	/* @H@1001 */
#if notdef
	/* TODO: write bridge drivers for these devices. */
	{0x0000630e, "CSC0000 FM Synthesizer"},	/* CSC0000 */
	{0x68187316, "ESS1868 FM Synthesizer"},	/* ESS1868 */
	{0x79187316, "ESS1879 FM Synthesizer"},	/* ESS1879 */
	{0x2100a865, "YMH0021 FM Synthesizer"},	/* YMH0021 */
	{0x80719304, "ADS7180 FM Synthesizer"},	/* ADS7180 */
	{0x0300561e, "GRV0003 FM Synthesizer"},	/* GRV0003 */
#endif /* notdef */
};

/* These are the default io bases. */
static int opl_defaultiobase[] = {
	0x388,
	0x380,
};

/* These are the per-voice information. */
struct voice_info {
	u_char   keyon_byte;
	long            bender;
	long            bender_range;
	u_long   orig_freq;
	u_long   current_freq;
	int             volume;
	int             mode;
};

/* These are the synthesizer and the midi device information. */
static struct synth_info opl_synthinfo = {
	"OPL FM Synthesizer",
	0,
	SYNTH_TYPE_FM,
	FM_TYPE_ADLIB,
	0,
	9,
	0,
	SBFM_MAXINSTR,
	0,
};

static struct midi_info opl_midiinfo = {
	"OPL FM Synthesizer",
	0,
	0,
	0,
};

/*
 * These functions goes into oplsynthdev_op_desc.
 */
static mdsy_killnote_t opl_killnote;
static mdsy_setinstr_t opl_setinstr;
static mdsy_startnote_t opl_startnote;
static mdsy_reset_t opl_reset;
static mdsy_hwcontrol_t opl_hwcontrol;
static mdsy_loadpatch_t opl_loadpatch;
static mdsy_panning_t opl_panning;
static mdsy_aftertouch_t opl_aftertouch;
static mdsy_controller_t opl_controller;
static mdsy_patchmgr_t opl_patchmgr;
static mdsy_bender_t opl_bender;
static mdsy_allocvoice_t opl_allocvoice;
static mdsy_setupvoice_t opl_setupvoice;
static mdsy_sendsysex_t opl_sendsysex;
static mdsy_prefixcmd_t opl_prefixcmd;
static mdsy_volumemethod_t opl_volumemethod;

/*
 * This is the synthdev_info for an OPL3 chip.
 */
static synthdev_info oplsynth_op_desc = {
	opl_killnote,
	opl_setinstr,
	opl_startnote,
	opl_reset,
	opl_hwcontrol,
	opl_loadpatch,
	opl_panning,
	opl_aftertouch,
	opl_controller,
	opl_patchmgr,
	opl_bender,
	opl_allocvoice,
	opl_setupvoice,
	opl_sendsysex,
	opl_prefixcmd,
	opl_volumemethod,
};

/* Here is the parameter structure per a device. */
struct opl_softc {
	device_t dev; /* device information */
	mididev_info *devinfo; /* midi device information */

	struct mtx mtx; /* Mutex to protect the device. */

	struct resource *io; /* Base of io port */
	int io_rid; /* Io resource ID */

	int model; /* OPL model */
	struct synth_info synthinfo; /* Synthesizer information */

	struct sbi_instrument i_map[SBFM_MAXINSTR]; /* Instrument map */
	struct sbi_instrument *act_i[SBFM_MAXINSTR]; /* Active instruments */
	struct physical_voice_info pv_map[MAX_VOICE]; /* Physical voice map */
	int cmask; /* Connection mask */
	int lv_map[MAX_VOICE]; /* Level map */
	struct voice_info voc[MAX_VOICE]; /* Voice information */
};

typedef struct opl_softc *sc_p;

/*
 * These functions goes into opl_op_desc to get called
 * from sound.c.
 */

static int opl_probe(device_t dev);
static int opl_probe1(sc_p scp);
static int opl_attach(device_t dev);
static int oplsbc_probe(device_t dev);
static int oplsbc_attach(device_t dev);

static d_open_t opl_open;
static d_close_t opl_close;
static d_ioctl_t opl_ioctl;
static midi_callback_t opl_callback;

/* These go to snddev_info. */
static mdsy_readraw_t opl_readraw;
static mdsy_writeraw_t opl_writeraw;

/* These functions are local. */
static void opl_command(sc_p scp, int ch, int addr, u_int val);
static int opl_status(sc_p scp);
static void opl_enter4opmode(sc_p scp);
static void opl_storeinstr(sc_p scp, int instr_no, struct sbi_instrument *instr);
static void opl_calcvol(u_char *regbyte, int volume, int main_vol);
static void opl_setvoicevolume(sc_p scp, int voice, int volume, int main_vol);
static void opl_freqtofnum(int freq, int *block, int *fnum);
static int opl_bendpitch(sc_p scp, int voice, int val);
static int opl_notetofreq(int note_num);
static u_long opl_computefinetune(u_long base_freq, int bend, int range);
static int opl_allocres(sc_p scp, device_t dev);
static void opl_releaseres(sc_p scp, device_t dev);

/*
 * This is the device descriptor for the midi device.
 */
static mididev_info opl_op_desc = {
	"OPL FM Synthesizer",

	SNDCARD_OPL,

	opl_open,
	opl_close,
	opl_ioctl,

	opl_callback,

	MIDI_BUFFSIZE, /* Queue Length */

	0, /* XXX This is not an *audio* device! */
};

/*
 * Here are the main functions to interact to the user process.
 */

static int
opl_probe(device_t dev)
{
	sc_p scp;
	int unit, i;

	/* Check isapnp ids */
	if (isa_get_logicalid(dev) != 0)
		return (ISA_PNP_PROBE(device_get_parent(dev), dev, opl_ids));

	scp = device_get_softc(dev);
	unit = device_get_unit(dev);

	device_set_desc(dev, opl_op_desc.name);
	bzero(scp, sizeof(*scp));

	MIDI_DEBUG(printf("opl%d: probing.\n", unit));

	scp->io_rid = 0;
	scp->io = bus_alloc_resource(dev, SYS_RES_IOPORT, &scp->io_rid, 0, ~0, 4, RF_ACTIVE);
	if (opl_allocres(scp, dev)) {
		/* We try the defaults in opl_defaultiobase. */
		MIDI_DEBUG(printf("opl%d: port is omitted, trying the defaults.\n", unit));
		for (i = 0 ; i < sizeof(opl_defaultiobase) / sizeof(*opl_defaultiobase) ; i++) {
			scp->io_rid = 0;
			scp->io = bus_alloc_resource(dev, SYS_RES_IOPORT, &scp->io_rid, opl_defaultiobase[i], opl_defaultiobase[i] + 1, 4, RF_ACTIVE);
			if (scp->io != NULL) {
				if (opl_probe1(scp))
					opl_releaseres(scp, dev);
				else
					break;
			}
		}
		if (scp->io == NULL)
			return (ENXIO);
	} else if(opl_probe1(scp)) {
		opl_releaseres(scp, dev);
		return (ENXIO);
	}

	/* We now have some kind of OPL. */

	MIDI_DEBUG(printf("opl%d: probed.\n", unit));

	return (0);
}

/* We do probe in this function. */
static int
opl_probe1(sc_p scp)
{
	u_char stat1, stat2;

	/* Reset the timers and the interrupt. */
	opl_command(scp, USE_LEFT, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
	opl_command(scp, USE_LEFT, TIMER_CONTROL_REGISTER, IRQ_RESET);

	/* Read the status. */
	stat1 = opl_status(scp);
	if ((stat1 & 0xe0) != 0)
		return (1);

	/* Try firing the timer1. */
	opl_command(scp, USE_LEFT, TIMER1_REGISTER, 0xff); /* Set the timer value. */
	opl_command(scp, USE_LEFT, TIMER_CONTROL_REGISTER, TIMER1_START | TIMER2_MASK); /* Start the timer. */
	DELAY(150); /* Wait for the timer. */

	/* Read the status. */
	stat2 = opl_status(scp);

	/* Reset the timers and the interrupt. */
	opl_command(scp, USE_LEFT, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
	opl_command(scp, USE_LEFT, TIMER_CONTROL_REGISTER, IRQ_RESET);

	if ((stat2 & 0xe0) != 0xc0)
		return (1);

	return (0);
}

static int
oplsbc_probe(device_t dev)
{
	char *s;
	sc_p scp;
	struct sndcard_func *func;

	/* The parent device has already been probed. */

	func = device_get_ivars(dev);
	if (func == NULL || func->func != SCF_SYNTH)
		return (ENXIO);

	s = "SB OPL FM Synthesizer";

	scp = device_get_softc(dev);
	bzero(scp, sizeof(*scp));
	scp->io_rid = 2;
	device_set_desc(dev, s);
	return (0);
}

static int
opl_attach(device_t dev)
{
	sc_p scp;
	mididev_info *devinfo;
	int i, opl4_io, opl4_id;
	struct resource *opl4;
	u_char signature, tmp;

	scp = device_get_softc(dev);

	MIDI_DEBUG(printf("opl: attaching.\n"));

	/* Fill the softc for this unit. */
	scp->dev = dev;

	/* Allocate other resources. */
	if (opl_allocres(scp, dev)) {
		opl_releaseres(scp, dev);
		return (ENXIO);
	}

	/* Detect the OPL type. */
	signature = opl_status(scp);
	if (signature == 0x06)
		scp->model = MODEL_OPL2;
	else {
		/* OPL3 or later, might be OPL4. */

		/* Enable OPL3 and OPL4. */
		opl_command(scp, USE_RIGHT, OPL3_MODE_REGISTER, 0);
		opl_command(scp, USE_RIGHT, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);

		tmp = opl_status(scp);
		if (tmp != 0x02)
			scp->model = MODEL_OPL3;
#if notdef
		else {
#endif /* notdef */
			/* Alloc OPL4 ID register. */
			opl4_id = 2;
			opl4_io = rman_get_start(scp->io) - 8;
			opl4 = bus_alloc_resource(dev, SYS_RES_IOPORT, &opl4_id, opl4_io, opl4_io + 1, 2, RF_ACTIVE);
			if (opl4 != NULL) {
				/* Select OPL4 ID register. */
				bus_space_write_1(rman_get_bustag(opl4), rman_get_bushandle(opl4), 0, 0x02);
				DELAY(10);
				tmp = bus_space_read_1(rman_get_bustag(opl4), rman_get_bushandle(opl4), 1);
				DELAY(10);

				if (tmp != 0x20)
					scp->model = MODEL_OPL3;
				else {
					scp->model = MODEL_OPL4;

					/* Select back OPL4 FM mixer control. */
					bus_space_write_1(rman_get_bustag(opl4), rman_get_bushandle(opl4), 0, 0xf8);
					DELAY(10);
					bus_space_write_1(rman_get_bustag(opl4), rman_get_bushandle(opl4), 1, 0x1b);
					DELAY(10);
				}
				bus_release_resource(dev, SYS_RES_IOPORT, opl4_id, opl4);
			}
#if notdef
		}
#endif /* notdef */
		opl_command(scp, USE_RIGHT, OPL3_MODE_REGISTER, 0);
	}

	/* Kill any previous notes. */
	for (i = 0 ; i < 9 ; i++)
		opl_command(scp, USE_RIGHT, KEYON_BLOCK + i, 0);

	/* Select melodic mode. */
	opl_command(scp, USE_LEFT, TEST_REGISTER, ENABLE_WAVE_SELECT);
	opl_command(scp, USE_LEFT, PERCUSSION_REGISTER, 0);

	for (i = 0 ; i < SBFM_MAXINSTR ; i++)
		scp->i_map[i].channel = -1;

	/* Fill the softc. */
	bcopy(&opl_synthinfo, &scp->synthinfo, sizeof(opl_synthinfo));
	snprintf(scp->synthinfo.name, 64, "Yamaha OPL%d FM", scp->model);
	mtx_init(&scp->mtx, "oplmid", NULL, MTX_DEF);
	bcopy(pv_map, scp->pv_map, sizeof(pv_map));
	if (scp->model < MODEL_OPL3) { /* OPL2. */
		scp->synthinfo.nr_voices = 9;
		scp->synthinfo.nr_drums = 0;
		for (i = 0 ; i < MAX_VOICE ; i++)
			scp->pv_map[i].ch = USE_LEFT;
	} else { /* OPL3 or later. */
		scp->synthinfo.capabilities |= SYNTH_CAP_OPL3;
		scp->synthinfo.nr_voices = 18;
		scp->synthinfo.nr_drums = 0;
#if notdef
		for (i = 0 ; i < MAX_VOICE ; i++) {
			if (scp->pv_map[i].ch == USE_LEFT)
				scp->pv_map[i].ch = USE_LEFT;
			else
				scp->pv_map[i].ch = USE_RIGHT;
		}
#endif /* notdef */
		opl_command(scp, USE_RIGHT, OPL3_MODE_REGISTER, OPL3_ENABLE);
		opl_command(scp, USE_RIGHT, CONNECTION_SELECT_REGISTER, 0);
	}

	scp->devinfo = devinfo = create_mididev_info_unit(MDT_SYNTH, &opl_op_desc, &oplsynth_op_desc);

	/* Fill the midi info. */
	devinfo->synth.readraw = opl_readraw;
	devinfo->synth.writeraw = opl_writeraw;
	devinfo->synth.alloc.max_voice = scp->synthinfo.nr_voices;
	strcpy(devinfo->name, scp->synthinfo.name);
	snprintf(devinfo->midistat, sizeof(devinfo->midistat), "at 0x%x", (u_int)rman_get_start(scp->io));

	midiinit(devinfo, dev);

	MIDI_DEBUG(printf("opl: attached.\n"));
	MIDI_DEBUG(printf("opl: the chip is OPL%d.\n", scp->model));

	return (0);
}

static int
oplsbc_attach(device_t dev)
{
	return (opl_attach(dev));
}

static int
opl_open(dev_t i_dev, int flags, int mode, struct thread *td)
{
	sc_p scp;
	mididev_info *devinfo;
	int unit, i;

	unit = MIDIUNIT(i_dev);

	MIDI_DEBUG(printf("opl%d: opening.\n", unit));

	devinfo = get_mididev_info(i_dev, &unit);
	if (devinfo == NULL) {
		MIDI_DEBUG(printf("opl_open: unit %d is not configured.\n", unit));
		return (ENXIO);
	}
	scp = devinfo->softc;

	mtx_lock(&devinfo->synth.vc_mtx);
	if (scp->model < MODEL_OPL3)
		devinfo->synth.alloc.max_voice = 9;
	else
		devinfo->synth.alloc.max_voice = 18;
	devinfo->synth.alloc.timestamp = 0;
	for (i = 0 ; i < MAX_VOICE ; i++) {
		devinfo->synth.alloc.map[i] = 0;
		devinfo->synth.alloc.alloc_times[i] = 0;
	}
	mtx_unlock(&devinfo->synth.vc_mtx);
	scp->cmask = 0; /* We are in 2 OP mode initially. */
	if (scp->model >= MODEL_OPL3) {
		mtx_lock(&scp->mtx);
		opl_command(scp, USE_RIGHT, CONNECTION_SELECT_REGISTER, scp->cmask);
		mtx_unlock(&scp->mtx);
	}

	MIDI_DEBUG(printf("opl%d: opened.\n", unit));

	return (0);
}

static int
opl_close(dev_t i_dev, int flags, int mode, struct thread *td)
{
	sc_p scp;
	mididev_info *devinfo;
	int unit;

	unit = MIDIUNIT(i_dev);

	MIDI_DEBUG(printf("opl%d: closing.\n", unit));

	devinfo = get_mididev_info(i_dev, &unit);
	if (devinfo == NULL) {
		MIDI_DEBUG(printf("opl_close: unit %d is not configured.\n", unit));
		return (ENXIO);
	}
	scp = devinfo->softc;

	mtx_lock(&devinfo->synth.vc_mtx);
	if (scp->model < MODEL_OPL3)
		devinfo->synth.alloc.max_voice = 9;
	else
		devinfo->synth.alloc.max_voice = 18;
	mtx_unlock(&devinfo->synth.vc_mtx);

	/* Stop the OPL. */
	opl_reset(scp->devinfo);

	MIDI_DEBUG(printf("opl%d: closed.\n", unit));

	return (0);
}

static int
opl_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td)
{
	sc_p scp;
	mididev_info *devinfo;
	int unit;
	struct synth_info *synthinfo;
	struct midi_info *midiinfo;
	struct sbi_instrument *ins;

	unit = MIDIUNIT(i_dev);

	MIDI_DEBUG(printf("opl_ioctl: unit %d, cmd %s.\n", unit, midi_cmdname(cmd, cmdtab_midiioctl)));

	devinfo = get_mididev_info(i_dev, &unit);
	if (devinfo == NULL) {
		MIDI_DEBUG(printf("opl_ioctl: unit %d is not configured.\n", unit));
		return (ENXIO);
	}
	scp = devinfo->softc;

	switch (cmd) {
	case SNDCTL_SYNTH_INFO:
		synthinfo = (struct synth_info *)arg;
		if (synthinfo->device != unit)
			return (ENXIO);
		bcopy(&scp->synthinfo, synthinfo, sizeof(scp->synthinfo));
		synthinfo->device = unit;
		synthinfo->nr_voices = devinfo->synth.alloc.max_voice;
		if (synthinfo->nr_voices == 12)
			synthinfo->nr_voices = 6;
		return (0);
		break;
	case SNDCTL_MIDI_INFO:
		midiinfo = (struct midi_info *)arg;
		if (midiinfo->device != unit)
			return (ENXIO);
		bcopy(&opl_midiinfo, midiinfo, sizeof(opl_midiinfo));
		strcpy(midiinfo->name, scp->synthinfo.name);
		midiinfo->device = unit;
		return (0);
		break;
	case SNDCTL_FM_LOAD_INSTR:
		ins = (struct sbi_instrument *)arg;
		if (ins->channel < 0 || ins->channel >= SBFM_MAXINSTR) {
			printf("opl_ioctl: Instrument number %d is not valid.\n", ins->channel);
			return (EINVAL);
		}
#if notyet
		pmgr_inform(scp, PM_E_PATCH_LOADED, inc->channel, 0, 0, 0);
#endif /* notyet */
		opl_storeinstr(scp, ins->channel, ins);
		return (0);
		break;
	case SNDCTL_SYNTH_MEMAVL:
		*(int *)arg = 0x7fffffff;
		return (0);
		break;
	case SNDCTL_FM_4OP_ENABLE:
		if (scp->model >= MODEL_OPL3)
			opl_enter4opmode(scp);
		return (0);
		break;
	default:
		return (ENOSYS);
	}
	/* NOTREACHED */
	return (EINVAL);
}

static int
opl_callback(void *d, int reason)
{
	int unit;
	sc_p scp;
	mididev_info *devinfo;

	devinfo = (mididev_info *)d;

	mtx_assert(&devinfo->flagqueue_mtx, MA_OWNED);

	if (devinfo == NULL) {
		MIDI_DEBUG(printf("opl_callback: device not configured.\n"));
		return (ENXIO);
	}

	unit = devinfo->unit;
	scp = devinfo->softc;

	MIDI_DEBUG(printf("opl%d: callback, reason 0x%x.\n", unit, reason));

	switch (reason & MIDI_CB_REASON_MASK) {
	case MIDI_CB_START:
		if ((reason & MIDI_CB_RD) != 0 && (devinfo->flags & MIDI_F_READING) == 0)
			/* Begin recording. */
			devinfo->flags |= MIDI_F_READING;
		if ((reason & MIDI_CB_WR) != 0 && (devinfo->flags & MIDI_F_WRITING) == 0)
			/* Start playing. */
			devinfo->flags |= MIDI_F_WRITING;
		break;
	case MIDI_CB_STOP:
	case MIDI_CB_ABORT:
		if ((reason & MIDI_CB_RD) != 0 && (devinfo->flags & MIDI_F_READING) != 0)
			/* Stop recording. */
			devinfo->flags &= ~MIDI_F_READING;
		if ((reason & MIDI_CB_WR) != 0 && (devinfo->flags & MIDI_F_WRITING) != 0)
			/* Stop Playing. */
			devinfo->flags &= ~MIDI_F_WRITING;
		break;
	}

	return (0);
}

static int
opl_readraw(mididev_info *md, u_char *buf, int len, int *lenr, int nonblock)
{
	sc_p scp;
	int unit;

	if (md == NULL)
		return (ENXIO);
	if (lenr == NULL)
		return (EINVAL);

	unit = md->unit;
	scp = md->softc;
	if ((md->fflags & FREAD) == 0) {
		MIDI_DEBUG(printf("opl_readraw: unit %d is not for reading.\n", unit));
		return (EIO);
	}

	/* NOP. */
	*lenr = 0;

	return (0);
}

static int
opl_writeraw(mididev_info *md, u_char *buf, int len, int *lenw, int nonblock)
{
	sc_p scp;
	int unit;

	if (md == NULL)
		return (ENXIO);
	if (lenw == NULL)
		return (EINVAL);

	unit = md->unit;
	scp = md->softc;
	if ((md->fflags & FWRITE) == 0) {
		MIDI_DEBUG(printf("opl_writeraw: unit %d is not for writing.\n", unit));
		return (EIO);
	}

	/* NOP. */
	*lenw = 0;

	return (0);
}

/* The functions below here are the synthesizer interfaces. */

static int
opl_killnote(mididev_info *md, int voice, int note, int vel)
{
	int unit;
	sc_p scp;
	struct physical_voice_info *map;

	scp = md->softc;
	unit = md->unit;

	MIDI_DEBUG(printf("opl%d: killing a note, voice %d, note %d, vel %d.\n", unit, voice, note, vel));

	if (voice < 0 || voice >= md->synth.alloc.max_voice)
		return (0);

	mtx_lock(&md->synth.vc_mtx);

	md->synth.alloc.map[voice] = 0;
	mtx_lock(&scp->mtx);
	map = &scp->pv_map[scp->lv_map[voice]];

	if (map->voice_mode != VOICE_NONE) {
		opl_command(scp, map->ch, KEYON_BLOCK + map->voice_num, scp->voc[voice].keyon_byte & ~0x20);

		scp->voc[voice].keyon_byte = 0;
		scp->voc[voice].bender = 0;
		scp->voc[voice].volume = 64;
		scp->voc[voice].bender_range = 200;
		scp->voc[voice].orig_freq = 0;
		scp->voc[voice].current_freq = 0;
		scp->voc[voice].mode = 0;
	}

	mtx_unlock(&scp->mtx);
	mtx_unlock(&md->synth.vc_mtx);

	return (0);
}

static int
opl_setinstr(mididev_info *md, int voice, int instr_no)
{
	int unit;
	sc_p scp;

	scp = md->softc;
	unit = md->unit;

	MIDI_DEBUG(printf("opl%d: setting an instrument, voice %d, instr_no %d.\n", unit, voice, instr_no));


	if (voice < 0 || voice >= md->synth.alloc.max_voice || instr_no < 0 || instr_no >= SBFM_MAXINSTR)
		return (0);

	mtx_lock(&scp->mtx);
	scp->act_i[voice] = &scp->i_map[instr_no];
	mtx_unlock(&scp->mtx);

	return (0);
}

static int
opl_startnote(mididev_info *md, int voice, int note, int volume)
{
	u_char fpc;
	int unit, block, fnum, freq, voice_mode, voice_shift;
	struct sbi_instrument *instr;
	struct physical_voice_info *map;
	sc_p scp;

	scp = md->softc;
	unit = md->unit;

	MIDI_DEBUG(printf("opl%d: starting a note, voice %d, note %d, volume %d.\n", unit, voice, note, volume));

	if (voice < 0 || voice >= md->synth.alloc.max_voice)
		return (0);

	mtx_lock(&scp->mtx);
	map = &scp->pv_map[scp->lv_map[voice]];
	if (map->voice_mode == VOICE_NONE) {
		mtx_unlock(&scp->mtx);
		return (0);
	}

	if (note == 255) {
		/* Change the volume. */
		opl_setvoicevolume(scp, voice, volume, scp->voc[voice].volume);
		mtx_unlock(&scp->mtx);
		return (0);
	}

	/* Kill the previous note. */
	opl_command(scp, map->ch, KSL_LEVEL + map->op[1], 0xff); /* Carrier volume */
	opl_command(scp, map->ch, KSL_LEVEL + map->op[0], 0xff); /* Modulator volume */
	if (map->voice_mode == VOICE_4OP) {
		opl_command(scp, map->ch, KSL_LEVEL + map->op[3], 0xff); /* Carrier volume */
		opl_command(scp, map->ch, KSL_LEVEL + map->op[2], 0xff); /* Modulator volume */
	}
	opl_command(scp, map->ch, KEYON_BLOCK + map->voice_num, 0); /* Note off. */

	instr = scp->act_i[voice];
	if (instr == NULL)
		instr = &scp->i_map[0];
	if (instr->channel < 0) {
		mtx_unlock(&scp->mtx);
		printf("opl_startnote: the instrument for voice %d is undefined.\n", voice);
		return (0);
	}
	if (map->voice_mode == VOICE_2OP && instr->key == OPL3_PATCH) {
		mtx_unlock(&scp->mtx);
		printf("opl_startnote: the voice mode %d mismatches the key 0x%x.\n", map->voice_mode, instr->key);
		return (0);
	}

	voice_mode = map->voice_mode;
	if (voice_mode == VOICE_4OP) {
		if (map->ch == USE_LEFT)
			voice_shift = 0;
		else
			voice_shift = 3;
		voice_shift += map->voice_num;
		if (instr->key != OPL3_PATCH) {
			voice_mode = VOICE_2OP;
			scp->cmask &= ~(1 << voice_shift);
		} else
			scp->cmask |= 1 << voice_shift;

		opl_command(scp, USE_RIGHT, CONNECTION_SELECT_REGISTER, scp->cmask);
	}

	/* Set the sound characteristics, attack, decay, sustain, release, wave select, feedback, connection. */
	opl_command(scp, map->ch, AM_VIB + map->op[0], instr->operators[0]); /* Sound characteristics. */
	opl_command(scp, map->ch, AM_VIB + map->op[1], instr->operators[1]);
	opl_command(scp, map->ch, ATTACK_DECAY + map->op[0], instr->operators[4]); /* Attack and decay. */
	opl_command(scp, map->ch, ATTACK_DECAY + map->op[1], instr->operators[5]);
	opl_command(scp, map->ch, SUSTAIN_RELEASE + map->op[0], instr->operators[6]); /* Sustain and release. */
	opl_command(scp, map->ch, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
	opl_command(scp, map->ch, WAVE_SELECT + map->op[0], instr->operators[8]); /* Wave select. */
	opl_command(scp, map->ch, WAVE_SELECT + map->op[1], instr->operators[9]);
	fpc = instr->operators[10];
	if ((fpc & 0x30) == 0)
		fpc |= 0x30; /* So that at least one channel is enabled. */
	opl_command(scp, map->ch, FEEDBACK_CONNECTION + map->voice_num, fpc); /* Feedback and connection. */

	if (voice_mode == VOICE_4OP) {
		/* Do not forget the operators 3 and 4. */
		opl_command(scp, map->ch, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]); /* Sound characteristics. */
		opl_command(scp, map->ch, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
		opl_command(scp, map->ch, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]); /* Attack and decay. */
		opl_command(scp, map->ch, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
		opl_command(scp, map->ch, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]); /* Sustain and release. */
		opl_command(scp, map->ch, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
		opl_command(scp, map->ch, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]); /* Wave select. */
		opl_command(scp, map->ch, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
		fpc = instr->operators[OFFS_4OP + 10];
		if ((fpc & 0x30) == 0)
			fpc |= 0x30; /* So that at least one channel is enabled. */
		opl_command(scp, map->ch, FEEDBACK_CONNECTION + map->voice_num + 3, fpc); /* Feedback and connection. */
	}
	scp->voc[voice].mode = voice_mode;

	opl_setvoicevolume(scp, voice, volume, scp->voc[voice].volume);

	/* Calcurate the frequency. */
	scp->voc[voice].orig_freq = opl_notetofreq(note) / 1000;
	/* Tune for the pitch bend. */
	freq = scp->voc[voice].current_freq = opl_computefinetune(scp->voc[voice].orig_freq, scp->voc[voice].bender, scp->voc[voice].bender_range);
	opl_freqtofnum(freq, &block, &fnum);

	/* Now we can play the note. */
	opl_command(scp, map->ch, FNUM_LOW + map->voice_num, fnum & 0xff);
	scp->voc[voice].keyon_byte = 0x20 | ((block & 0x07) << 2) | ((fnum >> 8) & 0x03);
	opl_command(scp, map->ch, KEYON_BLOCK + map->voice_num, scp->voc[voice].keyon_byte);
	if (voice_mode == VOICE_4OP)
		opl_command(scp, map->ch, KEYON_BLOCK + map->voice_num + 3, scp->voc[voice].keyon_byte);

	mtx_unlock(&scp->mtx);

	return (0);
}

static int
opl_reset(mididev_info *md)
{
	int unit, i;
	sc_p scp;
	struct physical_voice_info *map;

	scp = md->softc;
	unit = md->unit;

	MIDI_DEBUG(printf("opl%d: resetting.\n", unit));

	mtx_lock(&md->synth.vc_mtx);
	mtx_lock(&scp->mtx);

	for (i = 0 ; i < MAX_VOICE ; i++)
		scp->lv_map[i] = i;

	for (i = 0 ; i < md->synth.alloc.max_voice ; i++) {
		opl_command(scp, scp->pv_map[scp->lv_map[i]].ch, KSL_LEVEL + scp->pv_map[scp->lv_map[i]].op[0], 0xff);
		opl_command(scp, scp->pv_map[scp->lv_map[i]].ch, KSL_LEVEL + scp->pv_map[scp->lv_map[i]].op[1], 0xff);
		if (scp->pv_map[scp->lv_map[i]].voice_mode == VOICE_4OP) {
			opl_command(scp, scp->pv_map[scp->lv_map[i]].ch, KSL_LEVEL + scp->pv_map[scp->lv_map[i]].op[2], 0xff);
			opl_command(scp, scp->pv_map[scp->lv_map[i]].ch, KSL_LEVEL + scp->pv_map[scp->lv_map[i]].op[3], 0xff);
		}
		/*
		 * opl_killnote(md, i, 0, 64) inline-expanded to avoid
		 * unlocking and relocking mutex unnecessarily.
		 */
		md->synth.alloc.map[i] = 0;
		map = &scp->pv_map[scp->lv_map[i]];

		if (map->voice_mode != VOICE_NONE) {
			opl_command(scp, map->ch, KEYON_BLOCK + map->voice_num, scp->voc[i].keyon_byte & ~0x20);
			
			scp->voc[i].keyon_byte = 0;
			scp->voc[i].bender = 0;
			scp->voc[i].volume = 64;
			scp->voc[i].bender_range = 200;
			scp->voc[i].orig_freq = 0;
			scp->voc[i].current_freq = 0;
			scp->voc[i].mode = 0;
		}
	}

	if (scp->model >= MODEL_OPL3) {
		md->synth.alloc.max_voice = 18;
		for (i = 0 ; i < MAX_VOICE ; i++)
			scp->pv_map[i].voice_mode = VOICE_2OP;
	}

	mtx_unlock(&md->synth.vc_mtx);
	mtx_unlock(&scp->mtx);

	return (0);
}

static int
opl_hwcontrol(mididev_info *md, u_char *event)
{
	/* NOP. */
	return (0);
}

static int
opl_loadpatch(mididev_info *md, int format, struct uio *buf, int offs, int count, int pmgr_flag)
{
	int unit;
	struct sbi_instrument ins;
	sc_p scp;

	scp = md->softc;
	unit = md->unit;

	if (count < sizeof(ins)) {
		printf("opl_loadpatch: The patch record is too short.\n");
		return (EINVAL);
	}
	if (uiomove(&((char *)&ins)[offs], sizeof(ins) - offs, buf) != 0)
		printf("opl_loadpatch: User memory mangled?\n");
	if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR) {
		printf("opl_loadpatch: Instrument number %d is not valid.\n", ins.channel);
		return (EINVAL);
	}
	ins.key = format;

	opl_storeinstr(scp, ins.channel, &ins);
	return (0);
}

static int
opl_panning(mididev_info *md, int chn, int pan)
{
	/* NOP. */
	return (0);
}

#define SET_VIBRATO(cell) do { \
	int tmp; \
	tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
	if (press > 110) \
		tmp |= 0x40;	/* Vibrato on */ \
	opl_command(scp, map->ch, AM_VIB + map->op[cell-1], tmp);} while(0);

static int
opl_aftertouch(mididev_info *md, int voice, int press)
{
	int unit, connection;
	struct sbi_instrument *instr;
	struct physical_voice_info *map;
	sc_p scp;

	scp = md->softc;
	unit = md->unit;

	MIDI_DEBUG(printf("opl%d: setting the aftertouch, voice %d, press %d.\n", unit, voice, press));

	if (voice < 0 || voice >= md->synth.alloc.max_voice)
		return (0);

	mtx_lock(&scp->mtx);

	map = &scp->pv_map[scp->lv_map[voice]];
	if (map->voice_mode == VOICE_NONE) {
		mtx_unlock(&scp->mtx);
		return (0);
	}

	/* Adjust the vibrato. */
	instr = scp->act_i[voice];
	if (instr == NULL)
		instr = &scp->i_map[0];

	if (scp->voc[voice].mode == VOICE_4OP) {
		connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
		switch (connection) {
		case 0:
			SET_VIBRATO(4);
			break;
		case 1:
			SET_VIBRATO(2);
			SET_VIBRATO(4);
			break;
		case 2:
			SET_VIBRATO(1);
			SET_VIBRATO(4);
			break;
		case 3:
			SET_VIBRATO(1);
			SET_VIBRATO(3);
			SET_VIBRATO(4);
			break;
		}
	} else {
		SET_VIBRATO(1);
		if ((instr->operators[10] & 0x01))
			SET_VIBRATO(2);
	}

	mtx_unlock(&scp->mtx);

	return (0);
}

static int
opl_bendpitch(sc_p scp, int voice, int value)
{
	int unit, block, fnum, freq;
	struct physical_voice_info *map;
	mididev_info *md;

	md = scp->devinfo;
	unit = md->unit;

	MIDI_DEBUG(printf("opl%d: setting the pitch bend, voice %d, value %d.\n", unit, voice, value));

	mtx_lock(&scp->mtx);

	map = &scp->pv_map[scp->lv_map[voice]];
	if (map->voice_mode == 0) {
		mtx_unlock(&scp->mtx);
		return (0);
	}
	scp->voc[voice].bender = value;
	if (value == 0 || (scp->voc[voice].keyon_byte & 0x20) == 0) {
		mtx_unlock(&scp->mtx);
		return (0);
	}

	freq = opl_computefinetune(scp->voc[voice].orig_freq, scp->voc[voice].bender, scp->voc[voice].bender_range);
	scp->voc[voice].current_freq = freq;

	opl_freqtofnum(freq, &block, &fnum);

	opl_command(scp, map->ch, FNUM_LOW + map->voice_num, fnum & 0xff);
	scp->voc[voice].keyon_byte = 0x20 | ((block & 0x07) << 2) | ((fnum >> 8) & 0x03);
	opl_command(scp, map->ch, KEYON_BLOCK + map->voice_num, scp->voc[voice].keyon_byte);
	if (map->voice_mode == VOICE_4OP)
		opl_command(scp, map->ch, KEYON_BLOCK + map->voice_num + 3, scp->voc[voice].keyon_byte);

	mtx_unlock(&scp->mtx);

	return (0);
}

static int
opl_controller(mididev_info *md, int voice, int ctrlnum, int val)
{
	int unit;
	sc_p scp;

	scp = md->softc;
	unit = md->unit;

	MIDI_DEBUG(printf("opl%d: setting the controller, voice %d, ctrlnum %d, val %d.\n", unit, voice, ctrlnum, val));

	if (voice < 0 || voice >= md->synth.alloc.max_voice)
		return (0);

	switch (ctrlnum) {
	case CTRL_PITCH_BENDER:
		opl_bendpitch(scp, voice, val);
		break;
	case CTRL_PITCH_BENDER_RANGE:
		mtx_lock(&scp->mtx);
		scp->voc[voice].bender_range = val;
		mtx_unlock(&scp->mtx);
		break;
	case CTRL_MAIN_VOLUME:
		mtx_lock(&scp->mtx);
		scp->voc[voice].volume = val / 128;
		mtx_unlock(&scp->mtx);
		break;
	}

	return (0);
}

static int
opl_patchmgr(mididev_info *md, struct patmgr_info *rec)
{
	return (EINVAL);
}

static int
opl_bender(mididev_info *md, int voice, int val)
{
	sc_p scp;

	scp = md->softc;

	if (voice < 0 || voice >= md->synth.alloc.max_voice)
		return (0);

	return opl_bendpitch(scp, voice, val - 8192);
}

static int
opl_allocvoice(mididev_info *md, int chn, int note, struct voice_alloc_info *alloc)
{
	int i, p, best, first, avail, best_time, is4op, instr_no;
	struct sbi_instrument *instr;
	sc_p scp;

	scp = md->softc;

	MIDI_DEBUG(printf("opl%d: allocating a voice, chn %d, note %d.\n", md->unit, chn, note));

	best_time = 0x7fffffff;

	mtx_lock(&md->synth.vc_mtx);

	if (chn < 0 || chn >= 15)
		instr_no = 0;
	else
		instr_no = md->synth.chn_info[chn].pgm_num;

	mtx_lock(&scp->mtx);

	instr = &scp->i_map[instr_no];
	if (instr->channel < 0 || md->synth.alloc.max_voice != 12)
		is4op = 0;
	else if (md->synth.alloc.max_voice == 12) {
		if (instr->key == OPL3_PATCH)
			is4op = 1;
		else
			is4op = 0;
	} else
		is4op = 0;

	if (is4op) {
		first = p = 0;
		avail = 6;
	} else {
		if (md->synth.alloc.max_voice == 12)
			first = p = 6;
		else
			first = p = 0;
		avail = md->synth.alloc.max_voice;
	}

	/* Look up a free voice. */
	best = first;

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

	if (best < 0)
		best = 0;
	else if (best > md->synth.alloc.max_voice)
		best -= md->synth.alloc.max_voice;

	mtx_unlock(&scp->mtx);
	mtx_unlock(&md->synth.vc_mtx);

	return best;
}

static int
opl_setupvoice(mididev_info *md, int voice, int chn)
{
	struct channel_info *info;
	sc_p scp;

	scp = md->softc;

	MIDI_DEBUG(printf("opl%d: setting up a voice, voice %d, chn %d.\n", md->unit, voice, chn));

	mtx_lock(&md->synth.vc_mtx);

	info = &md->synth.chn_info[chn];

	opl_setinstr(md, voice, info->pgm_num);
	mtx_lock(&scp->mtx);
	scp->voc[voice].bender = info->bender_value;
	scp->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME];
	mtx_unlock(&scp->mtx);

	mtx_lock(&md->synth.vc_mtx);

	return (0);
}

static int
opl_sendsysex(mididev_info *md, u_char *sysex, int len)
{
	/* NOP. */
	return (0);
}

static int
opl_prefixcmd(mididev_info *md, int status)
{
	/* NOP. */
	return (0);
}

static int
opl_volumemethod(mididev_info *md, int mode)
{
	/* NOP. */
	return (0);
}

/*
 * The functions below here are the libraries for the above ones.
 */

/* Writes a command to the OPL chip. */
static void
opl_command(sc_p scp, int ch, int addr, u_int val)
{
	int model;

	MIDI_DEBUG(printf("opl%d: sending a command, addr 0x%x, val 0x%x.\n", scp->devinfo->unit, addr, val));

	model = scp->model;

	/* Write the addr first. */
	bus_space_write_1(rman_get_bustag(scp->io), rman_get_bushandle(scp->io), ch * 2, (u_char)(addr & 0xff));
	if (model < MODEL_OPL3)
		DELAY(10);
	else {
		bus_space_read_1(rman_get_bustag(scp->io), rman_get_bushandle(scp->io), ch * 2);
		bus_space_read_1(rman_get_bustag(scp->io), rman_get_bushandle(scp->io), ch * 2);
	}

	/* Next write the value. */
	bus_space_write_1(rman_get_bustag(scp->io), rman_get_bushandle(scp->io), ch * 2 + 1, (u_char)(val & 0xff));
	if (model < MODEL_OPL3)
		DELAY(30);
	else {
		bus_space_read_1(rman_get_bustag(scp->io), rman_get_bushandle(scp->io), ch * 2);
		bus_space_read_1(rman_get_bustag(scp->io), rman_get_bushandle(scp->io), ch * 2);
	}
}

/* Reads the status of the OPL chip. */
static int
opl_status(sc_p scp)
{
	MIDI_DEBUG(printf("opl%d: reading the status.\n", scp->devinfo->unit));

	return bus_space_read_1(rman_get_bustag(scp->io), rman_get_bushandle(scp->io), 0);
}

static void
opl_enter4opmode(sc_p scp)
{
	int i;
	mididev_info *devinfo;
	static int v4op[MAX_VOICE] = {
		0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17,
	};

	devinfo = scp->devinfo;

	MIDI_DEBUG(printf("opl%d: entering 4 OP mode.\n", devinfo->unit));

	/* Connect all possible 4 OP voice operators. */
	mtx_lock(&devinfo->synth.vc_mtx);
	mtx_lock(&scp->mtx);
	scp->cmask = 0x3f;
	opl_command(scp, USE_RIGHT, CONNECTION_SELECT_REGISTER, scp->cmask);

	for (i = 0 ; i < 3 ; i++)
		scp->pv_map[i].voice_mode = VOICE_4OP;
	for (i = 3 ; i < 6 ; i++)
		scp->pv_map[i].voice_mode = VOICE_NONE;
	for (i = 9 ; i < 12 ; i++)
		scp->pv_map[i].voice_mode = VOICE_4OP;
	for (i = 12 ; i < 15 ; i++)
		scp->pv_map[i].voice_mode = VOICE_NONE;

	for (i = 0 ; i < 12 ; i++)
		scp->lv_map[i] = v4op[i];
	mtx_unlock(&scp->mtx);
	devinfo->synth.alloc.max_voice = 12;
	mtx_unlock(&devinfo->synth.vc_mtx);
}

static void
opl_storeinstr(sc_p scp, int instr_no, struct sbi_instrument *instr)
{
	if (instr->key != FM_PATCH && (instr->key != OPL3_PATCH || scp->model < MODEL_OPL3))
		printf("opl_storeinstr: The patch format field 0x%x is not valid.\n", instr->key);

	bcopy(instr, &scp->i_map[instr_no], sizeof(*instr));
}

static void
opl_calcvol(u_char *regbyte, int volume, int main_vol)
{
	int level;

	level = (~*regbyte & 0x3f);

	if (main_vol > 127)
		main_vol = 127;

	volume = (volume * main_vol) / 127;

	if (level > 0)
		level += opl_volumetable[volume];

	RANGE(level, 0, 0x3f);

	*regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
}

static void
opl_setvoicevolume(sc_p scp, int voice, int volume, int main_vol)
{
	u_char vol1, vol2, vol3, vol4;
	int connection;
	struct sbi_instrument *instr;
	struct physical_voice_info *map;
	mididev_info *devinfo;

	devinfo = scp->devinfo;

	if (voice < 0 || voice >= devinfo->synth.alloc.max_voice)
		return;

	map = &scp->pv_map[scp->lv_map[voice]];
	instr = scp->act_i[voice];
	if (instr == NULL)
		instr = &scp->i_map[0];

	if (instr->channel < 0)
		return;
	if (scp->voc[voice].mode == VOICE_NONE)
		return;
	if (scp->voc[voice].mode == VOICE_2OP) { /* 2 OP mode. */
		vol1 = instr->operators[2];
		vol2 = instr->operators[3];
		if ((instr->operators[10] & 0x01))
			opl_calcvol(&vol1, volume, main_vol);
		opl_calcvol(&vol2, volume, main_vol);
		opl_command(scp, map->ch, KSL_LEVEL + map->op[0], vol1);
		opl_command(scp, map->ch, KSL_LEVEL + map->op[1], vol2);
	} else { /* 4 OP mode. */
		vol1 = instr->operators[2];
		vol2 = instr->operators[3];
		vol3 = instr->operators[OFFS_4OP + 2];
		vol4 = instr->operators[OFFS_4OP + 3];
		connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
		switch(connection) {
		case 0:
			opl_calcvol(&vol4, volume, main_vol);
			break;
		case 1:
			opl_calcvol(&vol2, volume, main_vol);
			opl_calcvol(&vol4, volume, main_vol);
			break;
		case 2:
			opl_calcvol(&vol1, volume, main_vol);
			opl_calcvol(&vol4, volume, main_vol);
			break;
		case 3:
			opl_calcvol(&vol1, volume, main_vol);
			opl_calcvol(&vol3, volume, main_vol);
			opl_calcvol(&vol4, volume, main_vol);
			break;
		}
		opl_command(scp, map->ch, KSL_LEVEL + map->op[0], vol1);
		opl_command(scp, map->ch, KSL_LEVEL + map->op[1], vol2);
		opl_command(scp, map->ch, KSL_LEVEL + map->op[2], vol3);
		opl_command(scp, map->ch, KSL_LEVEL + map->op[3], vol4);
	}
}

static void
opl_freqtofnum(int freq, int *block, int *fnum)
{
	int f, octave;

	f = freq;
	octave = 5;

	if (f == 0)
		octave = 0;
	else if (f < 261) {
		while (f < 261) {
			octave--;
			f <<= 1;
		}
	} else if (f > 493) {
		while (f > 493) {
			octave++;
			f >>= 1;
		}
	}
	if (octave > 7)
		octave = 7;

	*fnum = freq * (1 << (20 - octave)) / 49716;
	*block = octave;
}

static int notes[] =
{
	261632,
	277189,
	293671,
	311132,
	329632,
	349232,
	369998,
	391998,
	415306,
	440000,
	466162,
	493880
};

#define BASE_OCTAVE 5

static int
opl_notetofreq(int note_num)
{
	int note, octave, note_freq;

	octave = note_num / 12;
	note = note_num % 12;

	note_freq = notes[note];

	if (octave < BASE_OCTAVE)
		note_freq >>= (BASE_OCTAVE - octave);
	else if (octave > BASE_OCTAVE)
		note_freq <<= (octave - BASE_OCTAVE);

	return (note_freq);
}

static u_long
opl_computefinetune(u_long base_freq, int bend, int range)
{
	u_long amount;
	int negative, semitones, cents, multiplier;

	if (bend == 0 || range == 0 || base_freq == 0)
		return (base_freq);

	multiplier = 1;

	if (range > 8192)
		range = 8192;

	bend = bend * range / 8192;
	if (bend == 0)
		return (base_freq);

	if (bend < 0) {
		negative = 1;
		bend = -bend;
	}
	else
		negative = 0;
	if (bend > range)
		bend = range;

	while (bend > 2399) {
		multiplier *= 4;
		bend -= 2400;
	}

	semitones = bend / 100;
	cents = bend % 100;

	amount = (u_long)(semitone_tuning[semitones] * multiplier * cent_tuning[cents]) / 10000;

	if (negative)
		return (base_freq * 10000) / amount;
	else
		return (base_freq * amount) / 10000;
}

/* Allocates resources other than IO ports. */
static int
opl_allocres(sc_p scp, device_t dev)
{
	if (scp->io == NULL) {
		scp->io = bus_alloc_resource(dev, SYS_RES_IOPORT, &scp->io_rid, 0, ~0, 4, RF_ACTIVE);
		if (scp->io == NULL)
			return (1);
	}

	return (0);
}

/* Releases resources. */
static void
opl_releaseres(sc_p scp, device_t dev)
{
	if (scp->io != NULL) {
		bus_release_resource(dev, SYS_RES_IOPORT, scp->io_rid, scp->io);
		scp->io = NULL;
	}
}

static device_method_t opl_methods[] = {
	/* Device interface */
	DEVMETHOD(device_probe , opl_probe ),
	DEVMETHOD(device_attach, opl_attach),

	{ 0, 0 },
};

static driver_t opl_driver = {
	"midi",
	opl_methods,
	sizeof(struct opl_softc),
};

DRIVER_MODULE(opl, isa, opl_driver, midi_devclass, 0, 0);

static device_method_t oplsbc_methods[] = {
	/* Device interface */
	DEVMETHOD(device_probe , oplsbc_probe ),
	DEVMETHOD(device_attach, oplsbc_attach),

	{ 0, 0 },
};

static driver_t oplsbc_driver = {
	"midi",
	oplsbc_methods,
	sizeof(struct opl_softc),
};

DRIVER_MODULE(oplsbc, sbc, oplsbc_driver, midi_devclass, 0, 0);