mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-16 16:54:20 +08:00
4d00135a68
User-controllable indexes for voice and channel values may cause reading and writing beyond the bounds of their respective arrays, leading to potentially exploitable memory corruption. Validate these indexes. Signed-off-by: Dan Rosenberg <drosenberg@vsecurity.com> Cc: stable@kernel.org Signed-off-by: Takashi Iwai <tiwai@suse.de>
1259 lines
27 KiB
C
1259 lines
27 KiB
C
/*
|
|
* sound/oss/opl3.c
|
|
*
|
|
* A low level driver for Yamaha YM3812 and OPL-3 -chips
|
|
*
|
|
*
|
|
* Copyright (C) by Hannu Savolainen 1993-1997
|
|
*
|
|
* OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
|
|
* Version 2 (June 1991). See the "COPYING" file distributed with this software
|
|
* for more info.
|
|
*
|
|
*
|
|
* Changes
|
|
* Thomas Sailer ioctl code reworked (vmalloc/vfree removed)
|
|
* Alan Cox modularisation, fixed sound_mem allocs.
|
|
* Christoph Hellwig Adapted to module_init/module_exit
|
|
* Arnaldo C. de Melo get rid of check_region, use request_region for
|
|
* OPL4, release it on exit, some cleanups.
|
|
*
|
|
* Status
|
|
* Believed to work. Badly needs rewriting a bit to support multiple
|
|
* OPL3 devices.
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/module.h>
|
|
#include <linux/delay.h>
|
|
|
|
/*
|
|
* Major improvements to the FM handling 30AUG92 by Rob Hooft,
|
|
* hooft@chem.ruu.nl
|
|
*/
|
|
|
|
#include "sound_config.h"
|
|
|
|
#include "opl3_hw.h"
|
|
|
|
#define MAX_VOICE 18
|
|
#define OFFS_4OP 11
|
|
|
|
struct voice_info
|
|
{
|
|
unsigned char keyon_byte;
|
|
long bender;
|
|
long bender_range;
|
|
unsigned long orig_freq;
|
|
unsigned long current_freq;
|
|
int volume;
|
|
int mode;
|
|
int panning; /* 0xffff means not set */
|
|
};
|
|
|
|
typedef struct opl_devinfo
|
|
{
|
|
int base;
|
|
int left_io, right_io;
|
|
int nr_voice;
|
|
int lv_map[MAX_VOICE];
|
|
|
|
struct voice_info voc[MAX_VOICE];
|
|
struct voice_alloc_info *v_alloc;
|
|
struct channel_info *chn_info;
|
|
|
|
struct sbi_instrument i_map[SBFM_MAXINSTR];
|
|
struct sbi_instrument *act_i[MAX_VOICE];
|
|
|
|
struct synth_info fm_info;
|
|
|
|
int busy;
|
|
int model;
|
|
unsigned char cmask;
|
|
|
|
int is_opl4;
|
|
} opl_devinfo;
|
|
|
|
static struct opl_devinfo *devc = NULL;
|
|
|
|
static int detected_model;
|
|
|
|
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 void enter_4op_mode(void)
|
|
{
|
|
int i;
|
|
static int v4op[MAX_VOICE] = {
|
|
0, 1, 2, 9, 10, 11, 6, 7, 8, 15, 16, 17
|
|
};
|
|
|
|
devc->cmask = 0x3f; /* Connect all possible 4 OP voice operators */
|
|
opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x3f);
|
|
|
|
for (i = 0; i < 3; i++)
|
|
pv_map[i].voice_mode = 4;
|
|
for (i = 3; i < 6; i++)
|
|
pv_map[i].voice_mode = 0;
|
|
|
|
for (i = 9; i < 12; i++)
|
|
pv_map[i].voice_mode = 4;
|
|
for (i = 12; i < 15; i++)
|
|
pv_map[i].voice_mode = 0;
|
|
|
|
for (i = 0; i < 12; i++)
|
|
devc->lv_map[i] = v4op[i];
|
|
devc->v_alloc->max_voice = devc->nr_voice = 12;
|
|
}
|
|
|
|
static int opl3_ioctl(int dev, unsigned int cmd, void __user * arg)
|
|
{
|
|
struct sbi_instrument ins;
|
|
|
|
switch (cmd) {
|
|
case SNDCTL_FM_LOAD_INSTR:
|
|
printk(KERN_WARNING "Warning: Obsolete ioctl(SNDCTL_FM_LOAD_INSTR) used. Fix the program.\n");
|
|
if (copy_from_user(&ins, arg, sizeof(ins)))
|
|
return -EFAULT;
|
|
if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR) {
|
|
printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
|
|
return -EINVAL;
|
|
}
|
|
return store_instr(ins.channel, &ins);
|
|
|
|
case SNDCTL_SYNTH_INFO:
|
|
devc->fm_info.nr_voices = (devc->nr_voice == 12) ? 6 : devc->nr_voice;
|
|
if (copy_to_user(arg, &devc->fm_info, sizeof(devc->fm_info)))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
case SNDCTL_SYNTH_MEMAVL:
|
|
return 0x7fffffff;
|
|
|
|
case SNDCTL_FM_4OP_ENABLE:
|
|
if (devc->model == 2)
|
|
enter_4op_mode();
|
|
return 0;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
static int opl3_detect(int ioaddr)
|
|
{
|
|
/*
|
|
* This function returns 1 if the FM chip 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, signature;
|
|
int i;
|
|
|
|
if (devc != NULL)
|
|
{
|
|
printk(KERN_ERR "opl3: Only one OPL3 supported.\n");
|
|
return 0;
|
|
}
|
|
|
|
devc = kzalloc(sizeof(*devc), GFP_KERNEL);
|
|
|
|
if (devc == NULL)
|
|
{
|
|
printk(KERN_ERR "opl3: Can't allocate memory for the device control "
|
|
"structure \n ");
|
|
return 0;
|
|
}
|
|
|
|
strcpy(devc->fm_info.name, "OPL2");
|
|
|
|
if (!request_region(ioaddr, 4, devc->fm_info.name)) {
|
|
printk(KERN_WARNING "opl3: I/O port 0x%x already in use\n", ioaddr);
|
|
goto cleanup_devc;
|
|
}
|
|
|
|
devc->base = ioaddr;
|
|
|
|
/* Reset timers 1 and 2 */
|
|
opl3_command(ioaddr, TIMER_CONTROL_REGISTER, TIMER1_MASK | TIMER2_MASK);
|
|
|
|
/* Reset the IRQ of the FM chip */
|
|
opl3_command(ioaddr, TIMER_CONTROL_REGISTER, IRQ_RESET);
|
|
|
|
signature = stat1 = inb(ioaddr); /* Status register */
|
|
|
|
if (signature != 0x00 && signature != 0x06 && signature != 0x02 &&
|
|
signature != 0x0f)
|
|
{
|
|
MDB(printk(KERN_INFO "OPL3 not detected %x\n", signature));
|
|
goto cleanup_region;
|
|
}
|
|
|
|
if (signature == 0x06) /* OPL2 */
|
|
{
|
|
detected_model = 2;
|
|
}
|
|
else if (signature == 0x00 || signature == 0x0f) /* OPL3 or OPL4 */
|
|
{
|
|
unsigned char tmp;
|
|
|
|
detected_model = 3;
|
|
|
|
/*
|
|
* Detect availability of OPL4 (_experimental_). Works probably
|
|
* only after a cold boot. In addition the OPL4 port
|
|
* of the chip may not be connected to the PC bus at all.
|
|
*/
|
|
|
|
opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0x00);
|
|
opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, OPL3_ENABLE | OPL4_ENABLE);
|
|
|
|
if ((tmp = inb(ioaddr)) == 0x02) /* Have a OPL4 */
|
|
{
|
|
detected_model = 4;
|
|
}
|
|
|
|
if (request_region(ioaddr - 8, 2, "OPL4")) /* OPL4 port was free */
|
|
{
|
|
int tmp;
|
|
|
|
outb((0x02), ioaddr - 8); /* Select OPL4 ID register */
|
|
udelay(10);
|
|
tmp = inb(ioaddr - 7); /* Read it */
|
|
udelay(10);
|
|
|
|
if (tmp == 0x20) /* OPL4 should return 0x20 here */
|
|
{
|
|
detected_model = 4;
|
|
outb((0xF8), ioaddr - 8); /* Select OPL4 FM mixer control */
|
|
udelay(10);
|
|
outb((0x1B), ioaddr - 7); /* Write value */
|
|
udelay(10);
|
|
}
|
|
else
|
|
{ /* release OPL4 port */
|
|
release_region(ioaddr - 8, 2);
|
|
detected_model = 3;
|
|
}
|
|
}
|
|
opl3_command(ioaddr + 2, OPL3_MODE_REGISTER, 0);
|
|
}
|
|
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, PERCOSSION_REGISTER, 0x00); /*
|
|
* Melodic mode.
|
|
*/
|
|
return 1;
|
|
cleanup_region:
|
|
release_region(ioaddr, 4);
|
|
cleanup_devc:
|
|
kfree(devc);
|
|
devc = NULL;
|
|
return 0;
|
|
}
|
|
|
|
static int opl3_kill_note (int devno, int voice, int note, int velocity)
|
|
{
|
|
struct physical_voice_info *map;
|
|
|
|
if (voice < 0 || voice >= devc->nr_voice)
|
|
return 0;
|
|
|
|
devc->v_alloc->map[voice] = 0;
|
|
|
|
map = &pv_map[devc->lv_map[voice]];
|
|
DEB(printk("Kill note %d\n", voice));
|
|
|
|
if (map->voice_mode == 0)
|
|
return 0;
|
|
|
|
opl3_command(map->ioaddr, KEYON_BLOCK + map->voice_num, devc->voc[voice].keyon_byte & ~0x20);
|
|
devc->voc[voice].keyon_byte = 0;
|
|
devc->voc[voice].bender = 0;
|
|
devc->voc[voice].volume = 64;
|
|
devc->voc[voice].panning = 0xffff; /* Not set */
|
|
devc->voc[voice].bender_range = 200;
|
|
devc->voc[voice].orig_freq = 0;
|
|
devc->voc[voice].current_freq = 0;
|
|
devc->voc[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 || devc->model != 2))
|
|
printk(KERN_WARNING "FM warning: Invalid patch format field (key) 0x%x\n", instr->key);
|
|
memcpy((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof(*instr));
|
|
return 0;
|
|
}
|
|
|
|
static int opl3_set_instr (int dev, int voice, int instr_no)
|
|
{
|
|
if (voice < 0 || voice >= devc->nr_voice)
|
|
return 0;
|
|
if (instr_no < 0 || instr_no >= SBFM_MAXINSTR)
|
|
instr_no = 0; /* Acoustic piano (usually) */
|
|
|
|
devc->act_i[voice] = &devc->i_map[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)
|
|
*/
|
|
|
|
static char fm_volume_table[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
|
|
};
|
|
|
|
static void calc_vol(unsigned char *regbyte, int volume, int main_vol)
|
|
{
|
|
int level = (~*regbyte & 0x3f);
|
|
|
|
if (main_vol > 127)
|
|
main_vol = 127;
|
|
volume = (volume * main_vol) / 127;
|
|
|
|
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, int main_vol)
|
|
{
|
|
unsigned char vol1, vol2, vol3, vol4;
|
|
struct sbi_instrument *instr;
|
|
struct physical_voice_info *map;
|
|
|
|
if (voice < 0 || voice >= devc->nr_voice)
|
|
return;
|
|
|
|
map = &pv_map[devc->lv_map[voice]];
|
|
instr = devc->act_i[voice];
|
|
|
|
if (!instr)
|
|
instr = &devc->i_map[0];
|
|
|
|
if (instr->channel < 0)
|
|
return;
|
|
|
|
if (devc->voc[voice].mode == 0)
|
|
return;
|
|
|
|
if (devc->voc[voice].mode == 2)
|
|
{
|
|
vol1 = instr->operators[2];
|
|
vol2 = instr->operators[3];
|
|
if ((instr->operators[10] & 0x01))
|
|
{
|
|
calc_vol(&vol1, volume, main_vol);
|
|
calc_vol(&vol2, volume, main_vol);
|
|
}
|
|
else
|
|
{
|
|
calc_vol(&vol2, volume, main_vol);
|
|
}
|
|
opl3_command(map->ioaddr, KSL_LEVEL + map->op[0], vol1);
|
|
opl3_command(map->ioaddr, KSL_LEVEL + map->op[1], vol2);
|
|
}
|
|
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 devc->voc 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, main_vol);
|
|
break;
|
|
|
|
case 1:
|
|
calc_vol(&vol2, volume, main_vol);
|
|
calc_vol(&vol4, volume, main_vol);
|
|
break;
|
|
|
|
case 2:
|
|
calc_vol(&vol1, volume, main_vol);
|
|
calc_vol(&vol4, volume, main_vol);
|
|
break;
|
|
|
|
case 3:
|
|
calc_vol(&vol1, volume, main_vol);
|
|
calc_vol(&vol3, volume, main_vol);
|
|
calc_vol(&vol4, volume, main_vol);
|
|
break;
|
|
|
|
default:
|
|
;
|
|
}
|
|
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, pan;
|
|
struct sbi_instrument *instr;
|
|
struct physical_voice_info *map;
|
|
|
|
if (voice < 0 || voice >= devc->nr_voice)
|
|
return 0;
|
|
|
|
map = &pv_map[devc->lv_map[voice]];
|
|
pan = devc->voc[voice].panning;
|
|
|
|
if (map->voice_mode == 0)
|
|
return 0;
|
|
|
|
if (note == 255) /*
|
|
* Just change the volume
|
|
*/
|
|
{
|
|
set_voice_volume(voice, volume, devc->voc[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 = devc->act_i[voice];
|
|
|
|
if (!instr)
|
|
instr = &devc->i_map[0];
|
|
|
|
if (instr->channel < 0)
|
|
{
|
|
printk(KERN_WARNING "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 == devc->left_io) ? 0 : 3;
|
|
voice_shift += map->voice_num;
|
|
|
|
if (instr->key != OPL3_PATCH) /*
|
|
* Just 2 OP patch
|
|
*/
|
|
{
|
|
voice_mode = 2;
|
|
devc->cmask &= ~(1 << voice_shift);
|
|
}
|
|
else
|
|
{
|
|
devc->cmask |= (1 << voice_shift);
|
|
}
|
|
|
|
opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
|
|
}
|
|
|
|
/*
|
|
* 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 (pan != 0xffff)
|
|
{
|
|
fpc &= ~STEREO_BITS;
|
|
if (pan < -64)
|
|
fpc |= VOICE_TO_LEFT;
|
|
else
|
|
if (pan > 64)
|
|
fpc |= VOICE_TO_RIGHT;
|
|
else
|
|
fpc |= (VOICE_TO_LEFT | VOICE_TO_RIGHT);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
devc->voc[voice].mode = voice_mode;
|
|
set_voice_volume(voice, volume, devc->voc[voice].volume);
|
|
|
|
freq = devc->voc[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(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
|
|
devc->voc[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);
|
|
devc->voc[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);
|
|
|
|
if (devc->model != 2)
|
|
udelay(10);
|
|
else
|
|
for (i = 0; i < 2; i++)
|
|
inb(io_addr);
|
|
|
|
outb(((unsigned char) (val & 0xff)), io_addr + 1);
|
|
|
|
if (devc->model != 2)
|
|
udelay(30);
|
|
else
|
|
for (i = 0; i < 2; i++)
|
|
inb(io_addr);
|
|
}
|
|
|
|
static void opl3_reset(int devno)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 18; i++)
|
|
devc->lv_map[i] = i;
|
|
|
|
for (i = 0; i < devc->nr_voice; i++)
|
|
{
|
|
opl3_command(pv_map[devc->lv_map[i]].ioaddr,
|
|
KSL_LEVEL + pv_map[devc->lv_map[i]].op[0], 0xff);
|
|
|
|
opl3_command(pv_map[devc->lv_map[i]].ioaddr,
|
|
KSL_LEVEL + pv_map[devc->lv_map[i]].op[1], 0xff);
|
|
|
|
if (pv_map[devc->lv_map[i]].voice_mode == 4)
|
|
{
|
|
opl3_command(pv_map[devc->lv_map[i]].ioaddr,
|
|
KSL_LEVEL + pv_map[devc->lv_map[i]].op[2], 0xff);
|
|
|
|
opl3_command(pv_map[devc->lv_map[i]].ioaddr,
|
|
KSL_LEVEL + pv_map[devc->lv_map[i]].op[3], 0xff);
|
|
}
|
|
|
|
opl3_kill_note(devno, i, 0, 64);
|
|
}
|
|
|
|
if (devc->model == 2)
|
|
{
|
|
devc->v_alloc->max_voice = devc->nr_voice = 18;
|
|
|
|
for (i = 0; i < 18; i++)
|
|
pv_map[i].voice_mode = 2;
|
|
|
|
}
|
|
}
|
|
|
|
static int opl3_open(int dev, int mode)
|
|
{
|
|
int i;
|
|
|
|
if (devc->busy)
|
|
return -EBUSY;
|
|
devc->busy = 1;
|
|
|
|
devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
|
|
devc->v_alloc->timestamp = 0;
|
|
|
|
for (i = 0; i < 18; i++)
|
|
{
|
|
devc->v_alloc->map[i] = 0;
|
|
devc->v_alloc->alloc_times[i] = 0;
|
|
}
|
|
|
|
devc->cmask = 0x00; /*
|
|
* Just 2 OP mode
|
|
*/
|
|
if (devc->model == 2)
|
|
opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, devc->cmask);
|
|
return 0;
|
|
}
|
|
|
|
static void opl3_close(int dev)
|
|
{
|
|
devc->busy = 0;
|
|
devc->v_alloc->max_voice = devc->nr_voice = (devc->model == 2) ? 18 : 9;
|
|
|
|
devc->fm_info.nr_drums = 0;
|
|
devc->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, const char __user *addr,
|
|
int count, int pmgr_flag)
|
|
{
|
|
struct sbi_instrument ins;
|
|
|
|
if (count <sizeof(ins))
|
|
{
|
|
printk(KERN_WARNING "FM Error: Patch record too short\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (copy_from_user(&ins, addr, sizeof(ins)))
|
|
return -EFAULT;
|
|
|
|
if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
|
|
{
|
|
printk(KERN_WARNING "FM Error: Invalid instrument number %d\n", ins.channel);
|
|
return -EINVAL;
|
|
}
|
|
ins.key = format;
|
|
|
|
return store_instr(ins.channel, &ins);
|
|
}
|
|
|
|
static void opl3_panning(int dev, int voice, int value)
|
|
{
|
|
|
|
if (voice < 0 || voice >= devc->nr_voice)
|
|
return;
|
|
|
|
devc->voc[voice].panning = value;
|
|
}
|
|
|
|
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 >= devc->nr_voice)
|
|
return;
|
|
|
|
map = &pv_map[devc->lv_map[voice]];
|
|
|
|
DEB(printk("Aftertouch %d\n", voice));
|
|
|
|
if (map->voice_mode == 0)
|
|
return;
|
|
|
|
/*
|
|
* Adjust the amount of vibrato depending the pressure
|
|
*/
|
|
|
|
instr = devc->act_i[voice];
|
|
|
|
if (!instr)
|
|
instr = &devc->i_map[0];
|
|
|
|
if (devc->voc[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 = &pv_map[devc->lv_map[voice]];
|
|
|
|
if (map->voice_mode == 0)
|
|
return;
|
|
|
|
devc->voc[voice].bender = value;
|
|
if (!value)
|
|
return;
|
|
if (!(devc->voc[voice].keyon_byte & 0x20))
|
|
return; /*
|
|
* Not keyed on
|
|
*/
|
|
|
|
freq = compute_finetune(devc->voc[voice].orig_freq, devc->voc[voice].bender, devc->voc[voice].bender_range, 0);
|
|
devc->voc[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);
|
|
devc->voc[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 >= devc->nr_voice)
|
|
return;
|
|
|
|
switch (ctrl_num)
|
|
{
|
|
case CTRL_PITCH_BENDER:
|
|
bend_pitch(dev, voice, value);
|
|
break;
|
|
|
|
case CTRL_PITCH_BENDER_RANGE:
|
|
devc->voc[voice].bender_range = value;
|
|
break;
|
|
|
|
case CTL_MAIN_VOLUME:
|
|
devc->voc[voice].volume = value / 128;
|
|
break;
|
|
|
|
case CTL_PAN:
|
|
devc->voc[voice].panning = (value * 2) - 128;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void opl3_bender(int dev, int voice, int value)
|
|
{
|
|
if (voice < 0 || voice >= devc->nr_voice)
|
|
return;
|
|
|
|
bend_pitch(dev, voice, value - 8192);
|
|
}
|
|
|
|
static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info *alloc)
|
|
{
|
|
int i, p, best, first, avail, best_time = 0x7fffffff;
|
|
struct sbi_instrument *instr;
|
|
int is4op;
|
|
int instr_no;
|
|
|
|
if (chn < 0 || chn > 15)
|
|
instr_no = 0;
|
|
else
|
|
instr_no = devc->chn_info[chn].pgm_num;
|
|
|
|
instr = &devc->i_map[instr_no];
|
|
if (instr->channel < 0 || /* Instrument not loaded */
|
|
devc->nr_voice != 12) /* Not in 4 OP mode */
|
|
is4op = 0;
|
|
else if (devc->nr_voice == 12) /* 4 OP mode */
|
|
is4op = (instr->key == OPL3_PATCH);
|
|
else
|
|
is4op = 0;
|
|
|
|
if (is4op)
|
|
{
|
|
first = p = 0;
|
|
avail = 6;
|
|
}
|
|
else
|
|
{
|
|
if (devc->nr_voice == 12) /* 4 OP mode. Use the '2 OP only' operators first */
|
|
first = p = 6;
|
|
else
|
|
first = p = 0;
|
|
avail = devc->nr_voice;
|
|
}
|
|
|
|
/*
|
|
* Now try to find 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) /* Find oldest playing note */
|
|
{
|
|
best_time = alloc->alloc_times[p];
|
|
best = p;
|
|
}
|
|
p = (p + 1) % avail;
|
|
}
|
|
|
|
/*
|
|
* Insert some kind of priority mechanism here.
|
|
*/
|
|
|
|
if (best < 0)
|
|
best = 0;
|
|
if (best > devc->nr_voice)
|
|
best -= devc->nr_voice;
|
|
|
|
return best; /* All devc->voc in use. Select the first one. */
|
|
}
|
|
|
|
static void opl3_setup_voice(int dev, int voice, int chn)
|
|
{
|
|
struct channel_info *info;
|
|
|
|
if (voice < 0 || voice >= devc->nr_voice)
|
|
return;
|
|
|
|
if (chn < 0 || chn > 15)
|
|
return;
|
|
|
|
info = &synth_devs[dev]->chn_info[chn];
|
|
|
|
opl3_set_instr(dev, voice, info->pgm_num);
|
|
|
|
devc->voc[voice].bender = 0;
|
|
devc->voc[voice].bender_range = info->bender_range;
|
|
devc->voc[voice].volume = info->controllers[CTL_MAIN_VOLUME];
|
|
devc->voc[voice].panning = (info->controllers[CTL_PAN] * 2) - 128;
|
|
}
|
|
|
|
static struct synth_operations opl3_operations =
|
|
{
|
|
.owner = THIS_MODULE,
|
|
.id = "OPL",
|
|
.info = NULL,
|
|
.midi_dev = 0,
|
|
.synth_type = SYNTH_TYPE_FM,
|
|
.synth_subtype = FM_TYPE_ADLIB,
|
|
.open = opl3_open,
|
|
.close = opl3_close,
|
|
.ioctl = opl3_ioctl,
|
|
.kill_note = opl3_kill_note,
|
|
.start_note = opl3_start_note,
|
|
.set_instr = opl3_set_instr,
|
|
.reset = opl3_reset,
|
|
.hw_control = opl3_hw_control,
|
|
.load_patch = opl3_load_patch,
|
|
.aftertouch = opl3_aftertouch,
|
|
.controller = opl3_controller,
|
|
.panning = opl3_panning,
|
|
.volume_method = opl3_volume_method,
|
|
.bender = opl3_bender,
|
|
.alloc_voice = opl3_alloc_voice,
|
|
.setup_voice = opl3_setup_voice
|
|
};
|
|
|
|
static int opl3_init(int ioaddr, struct module *owner)
|
|
{
|
|
int i;
|
|
int me;
|
|
|
|
if (devc == NULL)
|
|
{
|
|
printk(KERN_ERR "opl3: Device control structure not initialized.\n");
|
|
return -1;
|
|
}
|
|
|
|
if ((me = sound_alloc_synthdev()) == -1)
|
|
{
|
|
printk(KERN_WARNING "opl3: Too many synthesizers\n");
|
|
return -1;
|
|
}
|
|
|
|
devc->nr_voice = 9;
|
|
|
|
devc->fm_info.device = 0;
|
|
devc->fm_info.synth_type = SYNTH_TYPE_FM;
|
|
devc->fm_info.synth_subtype = FM_TYPE_ADLIB;
|
|
devc->fm_info.perc_mode = 0;
|
|
devc->fm_info.nr_voices = 9;
|
|
devc->fm_info.nr_drums = 0;
|
|
devc->fm_info.instr_bank_size = SBFM_MAXINSTR;
|
|
devc->fm_info.capabilities = 0;
|
|
devc->left_io = ioaddr;
|
|
devc->right_io = ioaddr + 2;
|
|
|
|
if (detected_model <= 2)
|
|
devc->model = 1;
|
|
else
|
|
{
|
|
devc->model = 2;
|
|
if (detected_model == 4)
|
|
devc->is_opl4 = 1;
|
|
}
|
|
|
|
opl3_operations.info = &devc->fm_info;
|
|
|
|
synth_devs[me] = &opl3_operations;
|
|
|
|
if (owner)
|
|
synth_devs[me]->owner = owner;
|
|
|
|
sequencer_init();
|
|
devc->v_alloc = &opl3_operations.alloc;
|
|
devc->chn_info = &opl3_operations.chn_info[0];
|
|
|
|
if (devc->model == 2)
|
|
{
|
|
if (devc->is_opl4)
|
|
strcpy(devc->fm_info.name, "Yamaha OPL4/OPL3 FM");
|
|
else
|
|
strcpy(devc->fm_info.name, "Yamaha OPL3");
|
|
|
|
devc->v_alloc->max_voice = devc->nr_voice = 18;
|
|
devc->fm_info.nr_drums = 0;
|
|
devc->fm_info.synth_subtype = FM_TYPE_OPL3;
|
|
devc->fm_info.capabilities |= SYNTH_CAP_OPL3;
|
|
|
|
for (i = 0; i < 18; i++)
|
|
{
|
|
if (pv_map[i].ioaddr == USE_LEFT)
|
|
pv_map[i].ioaddr = devc->left_io;
|
|
else
|
|
pv_map[i].ioaddr = devc->right_io;
|
|
}
|
|
opl3_command(devc->right_io, OPL3_MODE_REGISTER, OPL3_ENABLE);
|
|
opl3_command(devc->right_io, CONNECTION_SELECT_REGISTER, 0x00);
|
|
}
|
|
else
|
|
{
|
|
strcpy(devc->fm_info.name, "Yamaha OPL2");
|
|
devc->v_alloc->max_voice = devc->nr_voice = 9;
|
|
devc->fm_info.nr_drums = 0;
|
|
|
|
for (i = 0; i < 18; i++)
|
|
pv_map[i].ioaddr = devc->left_io;
|
|
};
|
|
conf_printf2(devc->fm_info.name, ioaddr, 0, -1, -1);
|
|
|
|
for (i = 0; i < SBFM_MAXINSTR; i++)
|
|
devc->i_map[i].channel = -1;
|
|
|
|
return me;
|
|
}
|
|
|
|
static int me;
|
|
|
|
static int io = -1;
|
|
|
|
module_param(io, int, 0);
|
|
|
|
static int __init init_opl3 (void)
|
|
{
|
|
printk(KERN_INFO "YM3812 and OPL-3 driver Copyright (C) by Hannu Savolainen, Rob Hooft 1993-1996\n");
|
|
|
|
if (io != -1) /* User loading pure OPL3 module */
|
|
{
|
|
if (!opl3_detect(io))
|
|
{
|
|
return -ENODEV;
|
|
}
|
|
|
|
me = opl3_init(io, THIS_MODULE);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __exit cleanup_opl3(void)
|
|
{
|
|
if (devc && io != -1)
|
|
{
|
|
if (devc->base) {
|
|
release_region(devc->base,4);
|
|
if (devc->is_opl4)
|
|
release_region(devc->base - 8, 2);
|
|
}
|
|
kfree(devc);
|
|
devc = NULL;
|
|
sound_unload_synthdev(me);
|
|
}
|
|
}
|
|
|
|
module_init(init_opl3);
|
|
module_exit(cleanup_opl3);
|
|
|
|
#ifndef MODULE
|
|
static int __init setup_opl3(char *str)
|
|
{
|
|
/* io */
|
|
int ints[2];
|
|
|
|
str = get_options(str, ARRAY_SIZE(ints), ints);
|
|
|
|
io = ints[1];
|
|
|
|
return 1;
|
|
}
|
|
|
|
__setup("opl3=", setup_opl3);
|
|
#endif
|
|
MODULE_LICENSE("GPL");
|