5f6a57e19b
$Id$ information, and other code to make sound driver compile and work correctly with FreeBSD. Integrate changes obtained from Sujal Patel. These changes are: o local.h: reverse option logic from EXCLUDE_* to AUDIO_* o pas2_mixer.c: small addition o ad1848.c: minor change with macro names o sequencer.c: minor change with note check o many spelling corrections in comments in about every other file
1225 lines
27 KiB
C
1225 lines
27 KiB
C
/*
|
|
* sound/opl3.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.
|
|
*
|
|
* opl3.c,v 1.7 1994/10/01 02:16:50 swallace Exp
|
|
*/
|
|
|
|
/*
|
|
* Major improvements to the FM handling 30AUG92 by Rob Hooft,
|
|
* hooft@chem.ruu.nl
|
|
*/
|
|
|
|
#include "sound_config.h"
|
|
|
|
#if defined(CONFIGURE_SOUNDCARD) && !defined(EXCLUDE_YM3812)
|
|
|
|
#include "opl3.h"
|
|
|
|
#define MAX_VOICE 18
|
|
#define OFFS_4OP 11 /*
|
|
* * * Definitions for the operators OP3 and
|
|
* * OP4 * * begin here */
|
|
|
|
static int opl3_enabled = 0;
|
|
static int left_address = 0x388, right_address = 0x388, both_address = 0;
|
|
|
|
static int nr_voices = 9;
|
|
static int logical_voices[MAX_VOICE] =
|
|
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
|
|
|
|
struct voice_info
|
|
{
|
|
unsigned char keyon_byte;
|
|
long bender;
|
|
long bender_range;
|
|
unsigned long orig_freq;
|
|
unsigned long current_freq;
|
|
int mode;
|
|
};
|
|
|
|
static struct voice_info voices[MAX_VOICE];
|
|
static struct voice_alloc_info *voice_alloc;
|
|
static struct channel_info *chn_info;
|
|
|
|
static struct sbi_instrument *instrmap;
|
|
static struct sbi_instrument *active_instrument[MAX_VOICE] =
|
|
{NULL};
|
|
|
|
static struct synth_info fm_info =
|
|
{"OPL-2", 0, SYNTH_TYPE_FM, FM_TYPE_ADLIB, 0, 9, 0, SBFM_MAXINSTR, 0};
|
|
|
|
static int already_initialized = 0;
|
|
|
|
static int opl3_ok = 0;
|
|
static int opl3_busy = 0;
|
|
static int fm_model = 0; /*
|
|
|
|
|
|
* * * * 0=no fm, 1=mono, 2=SB Pro 1, 3=SB
|
|
* Pro 2 * * */
|
|
|
|
static int store_instr (int instr_no, struct sbi_instrument *instr);
|
|
static void freq_to_fnum (int freq, int *block, int *fnum);
|
|
static void opl3_command (int io_addr, unsigned int addr, unsigned int val);
|
|
static int opl3_kill_note (int dev, int voice, int note, int velocity);
|
|
static unsigned char connection_mask = 0x00;
|
|
|
|
void
|
|
enable_opl3_mode (int left, int right, int both)
|
|
{
|
|
if (opl3_enabled)
|
|
return;
|
|
|
|
opl3_enabled = 1;
|
|
left_address = left;
|
|
right_address = right;
|
|
both_address = both;
|
|
fm_info.capabilities = SYNTH_CAP_OPL3;
|
|
fm_info.synth_subtype = FM_TYPE_OPL3;
|
|
}
|
|
|
|
static void
|
|
enter_4op_mode (void)
|
|
{
|
|
int i;
|
|
static int voices_4op[MAX_VOICE] =
|
|
{0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17};
|
|
|
|
connection_mask = 0x3f; /* Connect all possible 4 OP voices */
|
|
opl3_command (right_address, CONNECTION_SELECT_REGISTER, 0x3f);
|
|
|
|
for (i = 0; i < 3; i++)
|
|
physical_voices[i].voice_mode = 4;
|
|
for (i = 3; i < 6; i++)
|
|
physical_voices[i].voice_mode = 0;
|
|
|
|
for (i = 9; i < 12; i++)
|
|
physical_voices[i].voice_mode = 4;
|
|
for (i = 12; i < 15; i++)
|
|
physical_voices[i].voice_mode = 0;
|
|
|
|
for (i = 0; i < 12; i++)
|
|
logical_voices[i] = voices_4op[i];
|
|
voice_alloc->max_voice = nr_voices = 12;
|
|
}
|
|
|
|
static int
|
|
opl3_ioctl (int dev,
|
|
unsigned int cmd, unsigned int arg)
|
|
{
|
|
switch (cmd)
|
|
{
|
|
|
|
case SNDCTL_FM_LOAD_INSTR:
|
|
{
|
|
struct sbi_instrument ins;
|
|
|
|
IOCTL_FROM_USER ((char *) &ins, (char *) arg, 0, sizeof (ins));
|
|
|
|
if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
|
|
{
|
|
printk ("FM Error: Invalid instrument number %d\n", ins.channel);
|
|
return RET_ERROR (EINVAL);
|
|
}
|
|
|
|
pmgr_inform (dev, PM_E_PATCH_LOADED, ins.channel, 0, 0, 0);
|
|
return store_instr (ins.channel, &ins);
|
|
}
|
|
break;
|
|
|
|
case SNDCTL_SYNTH_INFO:
|
|
fm_info.nr_voices = (nr_voices == 12) ? 6 : nr_voices;
|
|
|
|
IOCTL_TO_USER ((char *) arg, 0, &fm_info, sizeof (fm_info));
|
|
return 0;
|
|
break;
|
|
|
|
case SNDCTL_SYNTH_MEMAVL:
|
|
return 0x7fffffff;
|
|
break;
|
|
|
|
case SNDCTL_FM_4OP_ENABLE:
|
|
if (opl3_enabled)
|
|
enter_4op_mode ();
|
|
return 0;
|
|
break;
|
|
|
|
default:
|
|
return RET_ERROR (EINVAL);
|
|
}
|
|
|
|
}
|
|
|
|
int
|
|
opl3_detect (int ioaddr)
|
|
{
|
|
/*
|
|
* This function returns 1 if the FM chicp is present at the given I/O port
|
|
* The detection algorithm plays with the timer built in the FM chip and
|
|
* looks for a change in the status register.
|
|
*
|
|
* Note! The timers of the FM chip are not connected to AdLib (and compatible)
|
|
* boards.
|
|
*
|
|
* Note2! The chip is initialized if detected.
|
|
*/
|
|
|
|
unsigned char stat1, stat2;
|
|
int i;
|
|
|
|
if (already_initialized)
|
|
{
|
|
return 0; /*
|
|
* Do avoid duplicate initializations
|
|
*/
|
|
}
|
|
|
|
if (opl3_enabled)
|
|
ioaddr = left_address;
|
|
|
|
opl3_command (ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK); /*
|
|
* Reset
|
|
* timers
|
|
* 1
|
|
* and
|
|
* 2
|
|
*/
|
|
opl3_command (ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET); /*
|
|
* Reset the
|
|
* IRQ of FM
|
|
* * chicp
|
|
*/
|
|
|
|
stat1 = INB (ioaddr); /*
|
|
* Read status register
|
|
*/
|
|
|
|
if ((stat1 & 0xE0) != 0x00)
|
|
{
|
|
return 0; /*
|
|
* Should be 0x00
|
|
*/
|
|
}
|
|
|
|
opl3_command (ioaddr, TIMER1_REGISTER, 0xff); /*
|
|
* Set timer 1 to
|
|
* 0xff
|
|
*/
|
|
opl3_command (ioaddr, TIMER_CONTROL_REGISTER,
|
|
TIMER2_MASK | TIMER1_START); /*
|
|
* Unmask and start timer 1
|
|
*/
|
|
|
|
/*
|
|
* Now we have to delay at least 80 msec
|
|
*/
|
|
|
|
for (i = 0; i < 50; i++)
|
|
tenmicrosec (); /*
|
|
* To be sure
|
|
*/
|
|
|
|
stat2 = INB (ioaddr); /*
|
|
* Read status after timers have expired
|
|
*/
|
|
|
|
/*
|
|
* Stop the timers
|
|
*/
|
|
|
|
opl3_command (ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK); /*
|
|
* Reset
|
|
* timers
|
|
* 1
|
|
* and
|
|
* 2
|
|
*/
|
|
opl3_command (ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET); /*
|
|
* Reset the
|
|
* IRQ of FM
|
|
* * chicp
|
|
*/
|
|
|
|
if ((stat2 & 0xE0) != 0xc0)
|
|
{
|
|
return 0; /*
|
|
* There is no YM3812
|
|
*/
|
|
}
|
|
|
|
/*
|
|
* There is a FM chicp in this address. Now set some default values.
|
|
*/
|
|
|
|
for (i = 0; i < 9; i++)
|
|
opl3_command (ioaddr, KEYON_BLOCK + i, 0); /*
|
|
* Note off
|
|
*/
|
|
|
|
opl3_command (ioaddr, TEST_REGISTER, ENABLE_WAVE_SELECT);
|
|
opl3_command (ioaddr, PERCUSSION_REGISTER, 0x00); /*
|
|
* Melodic mode.
|
|
*/
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
opl3_kill_note (int dev, int voice, int note, int velocity)
|
|
{
|
|
struct physical_voice_info *map;
|
|
|
|
if (voice < 0 || voice >= nr_voices)
|
|
return 0;
|
|
|
|
voice_alloc->map[voice] = 0;
|
|
|
|
map = &physical_voices[logical_voices[voice]];
|
|
|
|
DEB (printk ("Kill note %d\n", voice));
|
|
|
|
if (map->voice_mode == 0)
|
|
return 0;
|
|
|
|
opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, voices[voice].keyon_byte & ~0x20);
|
|
|
|
voices[voice].keyon_byte = 0;
|
|
voices[voice].bender = 0;
|
|
voices[voice].bender_range = 200; /*
|
|
* 200 cents = 2 semitones
|
|
*/
|
|
voices[voice].orig_freq = 0;
|
|
voices[voice].current_freq = 0;
|
|
voices[voice].mode = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define HIHAT 0
|
|
#define CYMBAL 1
|
|
#define TOMTOM 2
|
|
#define SNARE 3
|
|
#define BDRUM 4
|
|
#define UNDEFINED TOMTOM
|
|
#define DEFAULT TOMTOM
|
|
|
|
static int
|
|
store_instr (int instr_no, struct sbi_instrument *instr)
|
|
{
|
|
|
|
if (instr->key != FM_PATCH && (instr->key != OPL3_PATCH || !opl3_enabled))
|
|
printk ("FM warning: Invalid patch format field (key) 0x%x\n", instr->key);
|
|
memcpy ((char *) &(instrmap[instr_no]), (char *) instr, sizeof (*instr));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
opl3_set_instr (int dev, int voice, int instr_no)
|
|
{
|
|
if (voice < 0 || voice >= nr_voices)
|
|
return 0;
|
|
|
|
if (instr_no < 0 || instr_no >= SBFM_MAXINSTR)
|
|
return 0;
|
|
|
|
active_instrument[voice] = &instrmap[instr_no];
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* 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)
|
|
*/
|
|
char fm_volume_table[128] =
|
|
{-64, -48, -40, -35, -32, -29, -27, -26, /*
|
|
* 0 - 7
|
|
*/
|
|
-24, -23, -21, -20, -19, -18, -18, -17, /*
|
|
* 8 - 15
|
|
*/
|
|
-16, -15, -15, -14, -13, -13, -12, -12, /*
|
|
* 16 - 23
|
|
*/
|
|
-11, -11, -10, -10, -10, -9, -9, -8, /*
|
|
* 24 - 31
|
|
*/
|
|
-8, -8, -7, -7, -7, -6, -6, -6,/*
|
|
* 32 - 39
|
|
*/
|
|
-5, -5, -5, -5, -4, -4, -4, -4,/*
|
|
* 40 - 47
|
|
*/
|
|
-3, -3, -3, -3, -2, -2, -2, -2,/*
|
|
* 48 - 55
|
|
*/
|
|
-2, -1, -1, -1, -1, 0, 0, 0, /*
|
|
* 56 - 63
|
|
*/
|
|
0, 0, 0, 1, 1, 1, 1, 1, /*
|
|
* 64 - 71
|
|
*/
|
|
1, 2, 2, 2, 2, 2, 2, 2, /*
|
|
* 72 - 79
|
|
*/
|
|
3, 3, 3, 3, 3, 3, 3, 4, /*
|
|
* 80 - 87
|
|
*/
|
|
4, 4, 4, 4, 4, 4, 4, 5, /*
|
|
* 88 - 95
|
|
*/
|
|
5, 5, 5, 5, 5, 5, 5, 5, /*
|
|
* 96 - 103
|
|
*/
|
|
6, 6, 6, 6, 6, 6, 6, 6, /*
|
|
* 104 - 111
|
|
*/
|
|
6, 7, 7, 7, 7, 7, 7, 7, /*
|
|
* 112 - 119
|
|
*/
|
|
7, 7, 7, 8, 8, 8, 8, 8}; /*
|
|
|
|
|
|
* * * * 120 - 127 */
|
|
|
|
static void
|
|
calc_vol (unsigned char *regbyte, int volume)
|
|
{
|
|
int level = (~*regbyte & 0x3f);
|
|
|
|
if (level)
|
|
level += fm_volume_table[volume];
|
|
|
|
if (level > 0x3f)
|
|
level = 0x3f;
|
|
if (level < 0)
|
|
level = 0;
|
|
|
|
*regbyte = (*regbyte & 0xc0) | (~level & 0x3f);
|
|
}
|
|
|
|
static void
|
|
set_voice_volume (int voice, int volume)
|
|
{
|
|
unsigned char vol1, vol2, vol3, vol4;
|
|
struct sbi_instrument *instr;
|
|
struct physical_voice_info *map;
|
|
|
|
if (voice < 0 || voice >= nr_voices)
|
|
return;
|
|
|
|
map = &physical_voices[logical_voices[voice]];
|
|
|
|
instr = active_instrument[voice];
|
|
|
|
if (!instr)
|
|
instr = &instrmap[0];
|
|
|
|
if (instr->channel < 0)
|
|
return;
|
|
|
|
if (voices[voice].mode == 0)
|
|
return;
|
|
|
|
if (voices[voice].mode == 2)
|
|
{ /*
|
|
* 2 OP voice
|
|
*/
|
|
|
|
vol1 = instr->operators[2];
|
|
vol2 = instr->operators[3];
|
|
|
|
if ((instr->operators[10] & 0x01))
|
|
{ /*
|
|
* Additive synthesis
|
|
*/
|
|
calc_vol (&vol1, volume);
|
|
calc_vol (&vol2, volume);
|
|
}
|
|
else
|
|
{ /*
|
|
* FM synthesis
|
|
*/
|
|
calc_vol (&vol2, volume);
|
|
}
|
|
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[0], vol1); /*
|
|
* Modulator
|
|
* volume
|
|
*/
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[1], vol2); /*
|
|
* Carrier
|
|
* volume
|
|
*/
|
|
}
|
|
else
|
|
{ /*
|
|
* 4 OP voice
|
|
*/
|
|
int connection;
|
|
|
|
vol1 = instr->operators[2];
|
|
vol2 = instr->operators[3];
|
|
vol3 = instr->operators[OFFS_4OP + 2];
|
|
vol4 = instr->operators[OFFS_4OP + 3];
|
|
|
|
/*
|
|
* The connection method for 4 OP voices is defined by the rightmost
|
|
* bits at the offsets 10 and 10+OFFS_4OP
|
|
*/
|
|
|
|
connection = ((instr->operators[10] & 0x01) << 1) | (instr->operators[10 + OFFS_4OP] & 0x01);
|
|
|
|
switch (connection)
|
|
{
|
|
case 0:
|
|
calc_vol (&vol4, volume); /*
|
|
* Just the OP 4 is carrier
|
|
*/
|
|
break;
|
|
|
|
case 1:
|
|
calc_vol (&vol2, volume);
|
|
calc_vol (&vol4, volume);
|
|
break;
|
|
|
|
case 2:
|
|
calc_vol (&vol1, volume);
|
|
calc_vol (&vol4, volume);
|
|
break;
|
|
|
|
case 3:
|
|
calc_vol (&vol1, volume);
|
|
calc_vol (&vol3, volume);
|
|
calc_vol (&vol4, volume);
|
|
break;
|
|
|
|
default: /*
|
|
* Why ??
|
|
*/ ;
|
|
}
|
|
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[0], vol1);
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[1], vol2);
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[2], vol3);
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[3], vol4);
|
|
}
|
|
}
|
|
|
|
static int
|
|
opl3_start_note (int dev, int voice, int note, int volume)
|
|
{
|
|
unsigned char data, fpc;
|
|
int block, fnum, freq, voice_mode;
|
|
struct sbi_instrument *instr;
|
|
struct physical_voice_info *map;
|
|
|
|
if (voice < 0 || voice >= nr_voices)
|
|
return 0;
|
|
|
|
map = &physical_voices[logical_voices[voice]];
|
|
|
|
if (map->voice_mode == 0)
|
|
return 0;
|
|
|
|
if (note == 255) /*
|
|
* Just change the volume
|
|
*/
|
|
{
|
|
set_voice_volume (voice, volume);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Kill previous note before playing
|
|
*/
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[1], 0xff); /*
|
|
* Carrier
|
|
* volume to
|
|
* min
|
|
*/
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[0], 0xff); /*
|
|
* Modulator
|
|
* volume to
|
|
*/
|
|
|
|
if (map->voice_mode == 4)
|
|
{
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[2], 0xff);
|
|
opl3_command (map->ioaddr, KSL_LEVEL + map->op[3], 0xff);
|
|
}
|
|
|
|
opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, 0x00); /*
|
|
* Note
|
|
* off
|
|
*/
|
|
|
|
instr = active_instrument[voice];
|
|
|
|
if (!instr)
|
|
instr = &instrmap[0];
|
|
|
|
if (instr->channel < 0)
|
|
{
|
|
printk (
|
|
"OPL3: Initializing voice %d with undefined instrument\n",
|
|
voice);
|
|
return 0;
|
|
}
|
|
|
|
if (map->voice_mode == 2 && instr->key == OPL3_PATCH)
|
|
return 0; /*
|
|
* Cannot play
|
|
*/
|
|
|
|
voice_mode = map->voice_mode;
|
|
|
|
if (voice_mode == 4)
|
|
{
|
|
int voice_shift;
|
|
|
|
voice_shift = (map->ioaddr == left_address) ? 0 : 3;
|
|
voice_shift += map->voice_num;
|
|
|
|
if (instr->key != OPL3_PATCH) /*
|
|
* Just 2 OP patch
|
|
*/
|
|
{
|
|
voice_mode = 2;
|
|
connection_mask &= ~(1 << voice_shift);
|
|
}
|
|
else
|
|
{
|
|
connection_mask |= (1 << voice_shift);
|
|
}
|
|
|
|
opl3_command (right_address, CONNECTION_SELECT_REGISTER, connection_mask);
|
|
}
|
|
|
|
/*
|
|
* Set Sound Characteristics
|
|
*/
|
|
opl3_command (map->ioaddr, AM_VIB + map->op[0], instr->operators[0]);
|
|
opl3_command (map->ioaddr, AM_VIB + map->op[1], instr->operators[1]);
|
|
|
|
/*
|
|
* Set Attack/Decay
|
|
*/
|
|
opl3_command (map->ioaddr, ATTACK_DECAY + map->op[0], instr->operators[4]);
|
|
opl3_command (map->ioaddr, ATTACK_DECAY + map->op[1], instr->operators[5]);
|
|
|
|
/*
|
|
* Set Sustain/Release
|
|
*/
|
|
opl3_command (map->ioaddr, SUSTAIN_RELEASE + map->op[0], instr->operators[6]);
|
|
opl3_command (map->ioaddr, SUSTAIN_RELEASE + map->op[1], instr->operators[7]);
|
|
|
|
/*
|
|
* Set Wave Select
|
|
*/
|
|
opl3_command (map->ioaddr, WAVE_SELECT + map->op[0], instr->operators[8]);
|
|
opl3_command (map->ioaddr, WAVE_SELECT + map->op[1], instr->operators[9]);
|
|
|
|
/*
|
|
* Set Feedback/Connection
|
|
*/
|
|
fpc = instr->operators[10];
|
|
if (!(fpc & 0x30))
|
|
fpc |= 0x30; /*
|
|
* Ensure that at least one chn is enabled
|
|
*/
|
|
opl3_command (map->ioaddr, FEEDBACK_CONNECTION + map->voice_num,
|
|
fpc);
|
|
|
|
/*
|
|
* If the voice is a 4 OP one, initialize the operators 3 and 4 also
|
|
*/
|
|
|
|
if (voice_mode == 4)
|
|
{
|
|
|
|
/*
|
|
* Set Sound Characteristics
|
|
*/
|
|
opl3_command (map->ioaddr, AM_VIB + map->op[2], instr->operators[OFFS_4OP + 0]);
|
|
opl3_command (map->ioaddr, AM_VIB + map->op[3], instr->operators[OFFS_4OP + 1]);
|
|
|
|
/*
|
|
* Set Attack/Decay
|
|
*/
|
|
opl3_command (map->ioaddr, ATTACK_DECAY + map->op[2], instr->operators[OFFS_4OP + 4]);
|
|
opl3_command (map->ioaddr, ATTACK_DECAY + map->op[3], instr->operators[OFFS_4OP + 5]);
|
|
|
|
/*
|
|
* Set Sustain/Release
|
|
*/
|
|
opl3_command (map->ioaddr, SUSTAIN_RELEASE + map->op[2], instr->operators[OFFS_4OP + 6]);
|
|
opl3_command (map->ioaddr, SUSTAIN_RELEASE + map->op[3], instr->operators[OFFS_4OP + 7]);
|
|
|
|
/*
|
|
* Set Wave Select
|
|
*/
|
|
opl3_command (map->ioaddr, WAVE_SELECT + map->op[2], instr->operators[OFFS_4OP + 8]);
|
|
opl3_command (map->ioaddr, WAVE_SELECT + map->op[3], instr->operators[OFFS_4OP + 9]);
|
|
|
|
/*
|
|
* Set Feedback/Connection
|
|
*/
|
|
fpc = instr->operators[OFFS_4OP + 10];
|
|
if (!(fpc & 0x30))
|
|
fpc |= 0x30; /*
|
|
* Ensure that at least one chn is enabled
|
|
*/
|
|
opl3_command (map->ioaddr, FEEDBACK_CONNECTION + map->voice_num + 3, fpc);
|
|
}
|
|
|
|
voices[voice].mode = voice_mode;
|
|
|
|
set_voice_volume (voice, volume);
|
|
|
|
freq = voices[voice].orig_freq = note_to_freq (note) / 1000;
|
|
|
|
/*
|
|
* 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;
|
|
|
|
freq_to_fnum (freq, &block, &fnum);
|
|
|
|
/*
|
|
* Play note
|
|
*/
|
|
|
|
data = fnum & 0xff; /*
|
|
* Least significant bits of fnumber
|
|
*/
|
|
opl3_command (map->ioaddr, FNUM_LOW + map->voice_num, data);
|
|
|
|
data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
|
|
voices[voice].keyon_byte = data;
|
|
opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, data);
|
|
if (voice_mode == 4)
|
|
opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
freq_to_fnum (int freq, int *block, int *fnum)
|
|
{
|
|
int f, octave;
|
|
|
|
/*
|
|
* Converts the note frequency to block and fnum values for the FM chip
|
|
*/
|
|
/*
|
|
* First try to compute the block -value (octave) where the note belongs
|
|
*/
|
|
|
|
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 void
|
|
opl3_command (int io_addr, unsigned int addr, unsigned int val)
|
|
{
|
|
int i;
|
|
|
|
/*
|
|
* The original 2-OP synth requires a quite long delay after writing to a
|
|
* register. The OPL-3 survives with just two INBs
|
|
*/
|
|
|
|
OUTB ((unsigned char) (addr & 0xff), io_addr); /*
|
|
* Select register
|
|
*
|
|
*/
|
|
|
|
if (!opl3_enabled)
|
|
tenmicrosec ();
|
|
else
|
|
for (i = 0; i < 2; i++)
|
|
INB (io_addr);
|
|
|
|
OUTB ((unsigned char) (val & 0xff), io_addr + 1); /*
|
|
* Write to register
|
|
*
|
|
*/
|
|
|
|
if (!opl3_enabled)
|
|
{
|
|
tenmicrosec ();
|
|
tenmicrosec ();
|
|
tenmicrosec ();
|
|
}
|
|
else
|
|
for (i = 0; i < 2; i++)
|
|
INB (io_addr);
|
|
}
|
|
|
|
static void
|
|
opl3_reset (int dev)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < nr_voices; i++)
|
|
{
|
|
opl3_command (physical_voices[logical_voices[i]].ioaddr,
|
|
KSL_LEVEL + physical_voices[logical_voices[i]].op[0], 0xff);
|
|
|
|
opl3_command (physical_voices[logical_voices[i]].ioaddr,
|
|
KSL_LEVEL + physical_voices[logical_voices[i]].op[1], 0xff);
|
|
|
|
if (physical_voices[logical_voices[i]].voice_mode == 4)
|
|
{
|
|
opl3_command (physical_voices[logical_voices[i]].ioaddr,
|
|
KSL_LEVEL + physical_voices[logical_voices[i]].op[2], 0xff);
|
|
|
|
opl3_command (physical_voices[logical_voices[i]].ioaddr,
|
|
KSL_LEVEL + physical_voices[logical_voices[i]].op[3], 0xff);
|
|
}
|
|
|
|
opl3_kill_note (dev, i, 0, 64);
|
|
}
|
|
|
|
if (opl3_enabled)
|
|
{
|
|
voice_alloc->max_voice = nr_voices = 18;
|
|
|
|
for (i = 0; i < 18; i++)
|
|
logical_voices[i] = i;
|
|
|
|
for (i = 0; i < 18; i++)
|
|
physical_voices[i].voice_mode = 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static int
|
|
opl3_open (int dev, int mode)
|
|
{
|
|
if (!opl3_ok)
|
|
return RET_ERROR (ENXIO);
|
|
if (opl3_busy)
|
|
return RET_ERROR (EBUSY);
|
|
opl3_busy = 1;
|
|
|
|
connection_mask = 0x00; /*
|
|
* Just 2 OP voices
|
|
*/
|
|
if (opl3_enabled)
|
|
opl3_command (right_address, CONNECTION_SELECT_REGISTER, connection_mask);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
opl3_close (int dev)
|
|
{
|
|
opl3_busy = 0;
|
|
voice_alloc->max_voice = nr_voices = opl3_enabled ? 18 : 9;
|
|
fm_info.nr_drums = 0;
|
|
fm_info.perc_mode = 0;
|
|
|
|
opl3_reset (dev);
|
|
}
|
|
|
|
static void
|
|
opl3_hw_control (int dev, unsigned char *event)
|
|
{
|
|
}
|
|
|
|
static int
|
|
opl3_load_patch (int dev, int format, snd_rw_buf * addr,
|
|
int offs, int count, int pmgr_flag)
|
|
{
|
|
struct sbi_instrument ins;
|
|
|
|
if (count < sizeof (ins))
|
|
{
|
|
printk ("FM Error: Patch record too short\n");
|
|
return RET_ERROR (EINVAL);
|
|
}
|
|
|
|
COPY_FROM_USER (&((char *) &ins)[offs], (char *) addr, offs, sizeof (ins) - offs);
|
|
|
|
if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
|
|
{
|
|
printk ("FM Error: Invalid instrument number %d\n", ins.channel);
|
|
return RET_ERROR (EINVAL);
|
|
}
|
|
ins.key = format;
|
|
|
|
return store_instr (ins.channel, &ins);
|
|
}
|
|
|
|
static void
|
|
opl3_panning (int dev, int voice, int pressure)
|
|
{
|
|
}
|
|
|
|
static void
|
|
opl3_volume_method (int dev, int mode)
|
|
{
|
|
}
|
|
|
|
#define SET_VIBRATO(cell) { \
|
|
tmp = instr->operators[(cell-1)+(((cell-1)/2)*OFFS_4OP)]; \
|
|
if (pressure > 110) \
|
|
tmp |= 0x40; /* Vibrato on */ \
|
|
opl3_command (map->ioaddr, AM_VIB + map->op[cell-1], tmp);}
|
|
|
|
static void
|
|
opl3_aftertouch (int dev, int voice, int pressure)
|
|
{
|
|
int tmp;
|
|
struct sbi_instrument *instr;
|
|
struct physical_voice_info *map;
|
|
|
|
if (voice < 0 || voice >= nr_voices)
|
|
return;
|
|
|
|
map = &physical_voices[logical_voices[voice]];
|
|
|
|
DEB (printk ("Aftertouch %d\n", voice));
|
|
|
|
if (map->voice_mode == 0)
|
|
return;
|
|
|
|
/*
|
|
* Adjust the amount of vibrato depending the pressure
|
|
*/
|
|
|
|
instr = active_instrument[voice];
|
|
|
|
if (!instr)
|
|
instr = &instrmap[0];
|
|
|
|
if (voices[voice].mode == 4)
|
|
{
|
|
int 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;
|
|
|
|
}
|
|
/*
|
|
* Not implemented yet
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
SET_VIBRATO (1);
|
|
|
|
if ((instr->operators[10] & 0x01)) /*
|
|
* Additive synthesis
|
|
*/
|
|
SET_VIBRATO (2);
|
|
}
|
|
}
|
|
|
|
#undef SET_VIBRATO
|
|
|
|
static void
|
|
bend_pitch (int dev, int voice, int value)
|
|
{
|
|
unsigned char data;
|
|
int block, fnum, freq;
|
|
struct physical_voice_info *map;
|
|
|
|
map = &physical_voices[logical_voices[voice]];
|
|
|
|
if (map->voice_mode == 0)
|
|
return;
|
|
|
|
voices[voice].bender = value;
|
|
if (!value)
|
|
return;
|
|
if (!(voices[voice].keyon_byte & 0x20))
|
|
return; /*
|
|
* Not keyed on
|
|
*/
|
|
|
|
freq = compute_finetune (voices[voice].orig_freq, voices[voice].bender, voices[voice].bender_range);
|
|
voices[voice].current_freq = freq;
|
|
|
|
freq_to_fnum (freq, &block, &fnum);
|
|
|
|
data = fnum & 0xff; /*
|
|
* Least significant bits of fnumber
|
|
*/
|
|
opl3_command (map->ioaddr, FNUM_LOW + map->voice_num, data);
|
|
|
|
data = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3); /*
|
|
* *
|
|
* KEYON|OCTAVE|MS
|
|
*
|
|
* * bits * *
|
|
* of * f-num
|
|
*
|
|
*/
|
|
voices[voice].keyon_byte = data;
|
|
opl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, data);
|
|
}
|
|
|
|
static void
|
|
opl3_controller (int dev, int voice, int ctrl_num, int value)
|
|
{
|
|
if (voice < 0 || voice >= nr_voices)
|
|
return;
|
|
|
|
switch (ctrl_num)
|
|
{
|
|
case CTRL_PITCH_BENDER:
|
|
bend_pitch (dev, voice, value);
|
|
break;
|
|
|
|
case CTRL_PITCH_BENDER_RANGE:
|
|
voices[voice].bender_range = value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int
|
|
opl3_patchmgr (int dev, struct patmgr_info *rec)
|
|
{
|
|
return RET_ERROR (EINVAL);
|
|
}
|
|
|
|
static void
|
|
opl3_bender (int dev, int voice, int value)
|
|
{
|
|
if (voice < 0 || voice >= nr_voices)
|
|
return;
|
|
|
|
bend_pitch (dev, voice, value);
|
|
}
|
|
|
|
static int
|
|
opl3_alloc_voice (int dev, int chn, int note, struct voice_alloc_info *alloc)
|
|
{
|
|
int i, p, avail_voices;
|
|
struct sbi_instrument *instr;
|
|
int is4op;
|
|
int instr_no;
|
|
|
|
if (chn < 0 || chn > 15)
|
|
instr_no = 0;
|
|
else
|
|
instr_no = chn_info[chn].pgm_num;
|
|
|
|
instr = &instrmap[instr_no];
|
|
if (instr->channel < 0 || /* Instrument not loaded */
|
|
nr_voices != 12) /* Not in 4 OP mode */
|
|
is4op = 0;
|
|
else if (nr_voices == 12) /* 4 OP mode */
|
|
is4op = (instr->key == OPL3_PATCH);
|
|
else
|
|
is4op = 0;
|
|
|
|
if (is4op)
|
|
{
|
|
p = 0;
|
|
avail_voices = 6;
|
|
}
|
|
else
|
|
{
|
|
if (nr_voices == 12) /* 4 OP mode. Use the '2 OP only' voices first */
|
|
p = 6;
|
|
else
|
|
p = 0;
|
|
avail_voices = nr_voices;
|
|
}
|
|
|
|
/*
|
|
* Now try to find a free voice
|
|
*/
|
|
|
|
for (i = 0; i < avail_voices; i++)
|
|
{
|
|
if (alloc->map[p] == 0)
|
|
{
|
|
return p;
|
|
}
|
|
p = (p + 1) % nr_voices;
|
|
}
|
|
|
|
/*
|
|
* Insert some kind of priority mechanism here.
|
|
*/
|
|
|
|
printk ("OPL3: Out of free voices\n");
|
|
return 0; /* All voices in use. Select the first one. */
|
|
}
|
|
|
|
static struct synth_operations opl3_operations =
|
|
{
|
|
&fm_info,
|
|
0,
|
|
SYNTH_TYPE_FM,
|
|
FM_TYPE_ADLIB,
|
|
opl3_open,
|
|
opl3_close,
|
|
opl3_ioctl,
|
|
opl3_kill_note,
|
|
opl3_start_note,
|
|
opl3_set_instr,
|
|
opl3_reset,
|
|
opl3_hw_control,
|
|
opl3_load_patch,
|
|
opl3_aftertouch,
|
|
opl3_controller,
|
|
opl3_panning,
|
|
opl3_volume_method,
|
|
opl3_patchmgr,
|
|
opl3_bender,
|
|
opl3_alloc_voice
|
|
};
|
|
|
|
long
|
|
opl3_init (long mem_start)
|
|
{
|
|
int i;
|
|
|
|
PERMANENT_MALLOC (struct sbi_instrument *, instrmap,
|
|
SBFM_MAXINSTR * sizeof (*instrmap), mem_start);
|
|
|
|
if (num_synths >= MAX_SYNTH_DEV)
|
|
printk ("OPL3 Error: Too many synthesizers\n");
|
|
else
|
|
{
|
|
synth_devs[num_synths++] = &opl3_operations;
|
|
voice_alloc = &opl3_operations.alloc;
|
|
chn_info = &opl3_operations.chn_info[0];
|
|
}
|
|
|
|
fm_model = 0;
|
|
opl3_ok = 1;
|
|
if (opl3_enabled)
|
|
{
|
|
#ifdef __FreeBSD__
|
|
printk ("snd1: <Yamaha OPL-3 FM>");
|
|
#else
|
|
printk (" <Yamaha OPL-3 FM>");
|
|
#endif
|
|
fm_model = 2;
|
|
voice_alloc->max_voice = nr_voices = 18;
|
|
fm_info.nr_drums = 0;
|
|
fm_info.capabilities |= SYNTH_CAP_OPL3;
|
|
#ifndef SCO
|
|
strcpy (fm_info.name, "Yamaha OPL-3");
|
|
#endif
|
|
|
|
for (i = 0; i < 18; i++)
|
|
if (physical_voices[i].ioaddr == USE_LEFT)
|
|
physical_voices[i].ioaddr = left_address;
|
|
else
|
|
physical_voices[i].ioaddr = right_address;
|
|
|
|
/* Enable OPL-3 mode */
|
|
opl3_command (right_address, OPL3_MODE_REGISTER, OPL3_ENABLE);
|
|
|
|
/* Select all 2-OP voices */
|
|
opl3_command (right_address, CONNECTION_SELECT_REGISTER, 0x00);
|
|
}
|
|
else
|
|
{
|
|
#ifdef __FreeBSD__
|
|
printk ("snd1: <Yamaha 2-OP FM>");
|
|
#else
|
|
printk (" <Yamaha 2-OP FM>");
|
|
#endif
|
|
fm_model = 1;
|
|
voice_alloc->max_voice = nr_voices = 9;
|
|
fm_info.nr_drums = 0;
|
|
|
|
for (i = 0; i < 18; i++)
|
|
physical_voices[i].ioaddr = left_address;
|
|
};
|
|
|
|
already_initialized = 1;
|
|
for (i = 0; i < SBFM_MAXINSTR; i++)
|
|
instrmap[i].channel = -1;
|
|
|
|
return mem_start;
|
|
}
|
|
|
|
#endif
|