1da177e4c3
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
543 lines
13 KiB
C
543 lines
13 KiB
C
/*
|
|
* synth callback routines for the emu8000 (AWE32/64)
|
|
*
|
|
* Copyright (C) 1999 Steve Ratcliffe
|
|
* Copyright (C) 1999-2000 Takashi Iwai <tiwai@suse.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "emu8000_local.h"
|
|
#include <sound/asoundef.h>
|
|
|
|
/*
|
|
* prototypes
|
|
*/
|
|
static snd_emux_voice_t *get_voice(snd_emux_t *emu, snd_emux_port_t *port);
|
|
static int start_voice(snd_emux_voice_t *vp);
|
|
static void trigger_voice(snd_emux_voice_t *vp);
|
|
static void release_voice(snd_emux_voice_t *vp);
|
|
static void update_voice(snd_emux_voice_t *vp, int update);
|
|
static void reset_voice(snd_emux_t *emu, int ch);
|
|
static void terminate_voice(snd_emux_voice_t *vp);
|
|
static void sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset);
|
|
#ifdef CONFIG_SND_SEQUENCER_OSS
|
|
static int oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2);
|
|
#endif
|
|
static int load_fx(snd_emux_t *emu, int type, int mode, const void __user *buf, long len);
|
|
|
|
static void set_pitch(emu8000_t *hw, snd_emux_voice_t *vp);
|
|
static void set_volume(emu8000_t *hw, snd_emux_voice_t *vp);
|
|
static void set_pan(emu8000_t *hw, snd_emux_voice_t *vp);
|
|
static void set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp);
|
|
static void set_tremfreq(emu8000_t *hw, snd_emux_voice_t *vp);
|
|
static void set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp);
|
|
static void set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp);
|
|
static void snd_emu8000_tweak_voice(emu8000_t *emu, int ch);
|
|
|
|
/*
|
|
* Ensure a value is between two points
|
|
* macro evaluates its args more than once, so changed to upper-case.
|
|
*/
|
|
#define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)
|
|
#define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)
|
|
|
|
|
|
/*
|
|
* set up operators
|
|
*/
|
|
static snd_emux_operators_t emu8000_ops = {
|
|
.owner = THIS_MODULE,
|
|
.get_voice = get_voice,
|
|
.prepare = start_voice,
|
|
.trigger = trigger_voice,
|
|
.release = release_voice,
|
|
.update = update_voice,
|
|
.terminate = terminate_voice,
|
|
.reset = reset_voice,
|
|
.sample_new = snd_emu8000_sample_new,
|
|
.sample_free = snd_emu8000_sample_free,
|
|
.sample_reset = snd_emu8000_sample_reset,
|
|
.load_fx = load_fx,
|
|
.sysex = sysex,
|
|
#ifdef CONFIG_SND_SEQUENCER_OSS
|
|
.oss_ioctl = oss_ioctl,
|
|
#endif
|
|
};
|
|
|
|
void
|
|
snd_emu8000_ops_setup(emu8000_t *hw)
|
|
{
|
|
hw->emu->ops = emu8000_ops;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Terminate a voice
|
|
*/
|
|
static void
|
|
release_voice(snd_emux_voice_t *vp)
|
|
{
|
|
int dcysusv;
|
|
emu8000_t *hw;
|
|
|
|
hw = vp->hw;
|
|
dcysusv = 0x8000 | (unsigned char)vp->reg.parm.modrelease;
|
|
EMU8000_DCYSUS_WRITE(hw, vp->ch, dcysusv);
|
|
dcysusv = 0x8000 | (unsigned char)vp->reg.parm.volrelease;
|
|
EMU8000_DCYSUSV_WRITE(hw, vp->ch, dcysusv);
|
|
}
|
|
|
|
|
|
/*
|
|
*/
|
|
static void
|
|
terminate_voice(snd_emux_voice_t *vp)
|
|
{
|
|
emu8000_t *hw;
|
|
|
|
hw = vp->hw;
|
|
EMU8000_DCYSUSV_WRITE(hw, vp->ch, 0x807F);
|
|
}
|
|
|
|
|
|
/*
|
|
*/
|
|
static void
|
|
update_voice(snd_emux_voice_t *vp, int update)
|
|
{
|
|
emu8000_t *hw;
|
|
|
|
hw = vp->hw;
|
|
if (update & SNDRV_EMUX_UPDATE_VOLUME)
|
|
set_volume(hw, vp);
|
|
if (update & SNDRV_EMUX_UPDATE_PITCH)
|
|
set_pitch(hw, vp);
|
|
if ((update & SNDRV_EMUX_UPDATE_PAN) &&
|
|
vp->port->ctrls[EMUX_MD_REALTIME_PAN])
|
|
set_pan(hw, vp);
|
|
if (update & SNDRV_EMUX_UPDATE_FMMOD)
|
|
set_fmmod(hw, vp);
|
|
if (update & SNDRV_EMUX_UPDATE_TREMFREQ)
|
|
set_tremfreq(hw, vp);
|
|
if (update & SNDRV_EMUX_UPDATE_FM2FRQ2)
|
|
set_fm2frq2(hw, vp);
|
|
if (update & SNDRV_EMUX_UPDATE_Q)
|
|
set_filterQ(hw, vp);
|
|
}
|
|
|
|
|
|
/*
|
|
* Find a channel (voice) within the EMU that is not in use or at least
|
|
* less in use than other channels. Always returns a valid pointer
|
|
* no matter what. If there is a real shortage of voices then one
|
|
* will be cut. Such is life.
|
|
*
|
|
* The channel index (vp->ch) must be initialized in this routine.
|
|
* In Emu8k, it is identical with the array index.
|
|
*/
|
|
static snd_emux_voice_t *
|
|
get_voice(snd_emux_t *emu, snd_emux_port_t *port)
|
|
{
|
|
int i;
|
|
snd_emux_voice_t *vp;
|
|
emu8000_t *hw;
|
|
|
|
/* what we are looking for, in order of preference */
|
|
enum {
|
|
OFF=0, RELEASED, PLAYING, END
|
|
};
|
|
|
|
/* Keeps track of what we are finding */
|
|
struct best {
|
|
unsigned int time;
|
|
int voice;
|
|
} best[END];
|
|
struct best *bp;
|
|
|
|
hw = emu->hw;
|
|
|
|
for (i = 0; i < END; i++) {
|
|
best[i].time = (unsigned int)(-1); /* XXX MAX_?INT really */;
|
|
best[i].voice = -1;
|
|
}
|
|
|
|
/*
|
|
* Go through them all and get a best one to use.
|
|
*/
|
|
for (i = 0; i < emu->max_voices; i++) {
|
|
int state, val;
|
|
|
|
vp = &emu->voices[i];
|
|
state = vp->state;
|
|
|
|
if (state == SNDRV_EMUX_ST_OFF)
|
|
bp = best + OFF;
|
|
else if (state == SNDRV_EMUX_ST_RELEASED ||
|
|
state == SNDRV_EMUX_ST_PENDING) {
|
|
bp = best + RELEASED;
|
|
val = (EMU8000_CVCF_READ(hw, vp->ch) >> 16) & 0xffff;
|
|
if (! val)
|
|
bp = best + OFF;
|
|
}
|
|
else if (state & SNDRV_EMUX_ST_ON)
|
|
bp = best + PLAYING;
|
|
else
|
|
continue;
|
|
|
|
/* check if sample is finished playing (non-looping only) */
|
|
if (state != SNDRV_EMUX_ST_OFF &&
|
|
(vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_SINGLESHOT)) {
|
|
val = EMU8000_CCCA_READ(hw, vp->ch) & 0xffffff;
|
|
if (val >= vp->reg.loopstart)
|
|
bp = best + OFF;
|
|
}
|
|
|
|
if (vp->time < bp->time) {
|
|
bp->time = vp->time;
|
|
bp->voice = i;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < END; i++) {
|
|
if (best[i].voice >= 0) {
|
|
vp = &emu->voices[best[i].voice];
|
|
vp->ch = best[i].voice;
|
|
return vp;
|
|
}
|
|
}
|
|
|
|
/* not found */
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
*/
|
|
static int
|
|
start_voice(snd_emux_voice_t *vp)
|
|
{
|
|
unsigned int temp;
|
|
int ch;
|
|
int addr;
|
|
snd_midi_channel_t *chan;
|
|
emu8000_t *hw;
|
|
|
|
hw = vp->hw;
|
|
ch = vp->ch;
|
|
chan = vp->chan;
|
|
|
|
/* channel to be silent and idle */
|
|
EMU8000_DCYSUSV_WRITE(hw, ch, 0x0080);
|
|
EMU8000_VTFT_WRITE(hw, ch, 0x0000FFFF);
|
|
EMU8000_CVCF_WRITE(hw, ch, 0x0000FFFF);
|
|
EMU8000_PTRX_WRITE(hw, ch, 0);
|
|
EMU8000_CPF_WRITE(hw, ch, 0);
|
|
|
|
/* set pitch offset */
|
|
set_pitch(hw, vp);
|
|
|
|
/* set envelope parameters */
|
|
EMU8000_ENVVAL_WRITE(hw, ch, vp->reg.parm.moddelay);
|
|
EMU8000_ATKHLD_WRITE(hw, ch, vp->reg.parm.modatkhld);
|
|
EMU8000_DCYSUS_WRITE(hw, ch, vp->reg.parm.moddcysus);
|
|
EMU8000_ENVVOL_WRITE(hw, ch, vp->reg.parm.voldelay);
|
|
EMU8000_ATKHLDV_WRITE(hw, ch, vp->reg.parm.volatkhld);
|
|
/* decay/sustain parameter for volume envelope is used
|
|
for triggerg the voice */
|
|
|
|
/* cutoff and volume */
|
|
set_volume(hw, vp);
|
|
|
|
/* modulation envelope heights */
|
|
EMU8000_PEFE_WRITE(hw, ch, vp->reg.parm.pefe);
|
|
|
|
/* lfo1/2 delay */
|
|
EMU8000_LFO1VAL_WRITE(hw, ch, vp->reg.parm.lfo1delay);
|
|
EMU8000_LFO2VAL_WRITE(hw, ch, vp->reg.parm.lfo2delay);
|
|
|
|
/* lfo1 pitch & cutoff shift */
|
|
set_fmmod(hw, vp);
|
|
/* lfo1 volume & freq */
|
|
set_tremfreq(hw, vp);
|
|
/* lfo2 pitch & freq */
|
|
set_fm2frq2(hw, vp);
|
|
/* pan & loop start */
|
|
set_pan(hw, vp);
|
|
|
|
/* chorus & loop end (chorus 8bit, MSB) */
|
|
addr = vp->reg.loopend - 1;
|
|
temp = vp->reg.parm.chorus;
|
|
temp += (int)chan->control[MIDI_CTL_E3_CHORUS_DEPTH] * 9 / 10;
|
|
LIMITMAX(temp, 255);
|
|
temp = (temp <<24) | (unsigned int)addr;
|
|
EMU8000_CSL_WRITE(hw, ch, temp);
|
|
|
|
/* Q & current address (Q 4bit value, MSB) */
|
|
addr = vp->reg.start - 1;
|
|
temp = vp->reg.parm.filterQ;
|
|
temp = (temp<<28) | (unsigned int)addr;
|
|
EMU8000_CCCA_WRITE(hw, ch, temp);
|
|
|
|
/* clear unknown registers */
|
|
EMU8000_00A0_WRITE(hw, ch, 0);
|
|
EMU8000_0080_WRITE(hw, ch, 0);
|
|
|
|
/* reset volume */
|
|
temp = vp->vtarget << 16;
|
|
EMU8000_VTFT_WRITE(hw, ch, temp | vp->ftarget);
|
|
EMU8000_CVCF_WRITE(hw, ch, temp | 0xff00);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Start envelope
|
|
*/
|
|
static void
|
|
trigger_voice(snd_emux_voice_t *vp)
|
|
{
|
|
int ch = vp->ch;
|
|
unsigned int temp;
|
|
emu8000_t *hw;
|
|
|
|
hw = vp->hw;
|
|
|
|
/* set reverb and pitch target */
|
|
temp = vp->reg.parm.reverb;
|
|
temp += (int)vp->chan->control[MIDI_CTL_E1_REVERB_DEPTH] * 9 / 10;
|
|
LIMITMAX(temp, 255);
|
|
temp = (temp << 8) | (vp->ptarget << 16) | vp->aaux;
|
|
EMU8000_PTRX_WRITE(hw, ch, temp);
|
|
EMU8000_CPF_WRITE(hw, ch, vp->ptarget << 16);
|
|
EMU8000_DCYSUSV_WRITE(hw, ch, vp->reg.parm.voldcysus);
|
|
}
|
|
|
|
/*
|
|
* reset voice parameters
|
|
*/
|
|
static void
|
|
reset_voice(snd_emux_t *emu, int ch)
|
|
{
|
|
emu8000_t *hw;
|
|
|
|
hw = emu->hw;
|
|
EMU8000_DCYSUSV_WRITE(hw, ch, 0x807F);
|
|
snd_emu8000_tweak_voice(hw, ch);
|
|
}
|
|
|
|
/*
|
|
* Set the pitch of a possibly playing note.
|
|
*/
|
|
static void
|
|
set_pitch(emu8000_t *hw, snd_emux_voice_t *vp)
|
|
{
|
|
EMU8000_IP_WRITE(hw, vp->ch, vp->apitch);
|
|
}
|
|
|
|
/*
|
|
* Set the volume of a possibly already playing note
|
|
*/
|
|
static void
|
|
set_volume(emu8000_t *hw, snd_emux_voice_t *vp)
|
|
{
|
|
int ifatn;
|
|
|
|
ifatn = (unsigned char)vp->acutoff;
|
|
ifatn = (ifatn << 8);
|
|
ifatn |= (unsigned char)vp->avol;
|
|
EMU8000_IFATN_WRITE(hw, vp->ch, ifatn);
|
|
}
|
|
|
|
/*
|
|
* Set pan and loop start address.
|
|
*/
|
|
static void
|
|
set_pan(emu8000_t *hw, snd_emux_voice_t *vp)
|
|
{
|
|
unsigned int temp;
|
|
|
|
temp = ((unsigned int)vp->apan<<24) | ((unsigned int)vp->reg.loopstart - 1);
|
|
EMU8000_PSST_WRITE(hw, vp->ch, temp);
|
|
}
|
|
|
|
#define MOD_SENSE 18
|
|
|
|
static void
|
|
set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp)
|
|
{
|
|
unsigned short fmmod;
|
|
short pitch;
|
|
unsigned char cutoff;
|
|
int modulation;
|
|
|
|
pitch = (char)(vp->reg.parm.fmmod>>8);
|
|
cutoff = (vp->reg.parm.fmmod & 0xff);
|
|
modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
|
|
pitch += (MOD_SENSE * modulation) / 1200;
|
|
LIMITVALUE(pitch, -128, 127);
|
|
fmmod = ((unsigned char)pitch<<8) | cutoff;
|
|
EMU8000_FMMOD_WRITE(hw, vp->ch, fmmod);
|
|
}
|
|
|
|
/* set tremolo (lfo1) volume & frequency */
|
|
static void
|
|
set_tremfreq(emu8000_t *hw, snd_emux_voice_t *vp)
|
|
{
|
|
EMU8000_TREMFRQ_WRITE(hw, vp->ch, vp->reg.parm.tremfrq);
|
|
}
|
|
|
|
/* set lfo2 pitch & frequency */
|
|
static void
|
|
set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp)
|
|
{
|
|
unsigned short fm2frq2;
|
|
short pitch;
|
|
unsigned char freq;
|
|
int modulation;
|
|
|
|
pitch = (char)(vp->reg.parm.fm2frq2>>8);
|
|
freq = vp->reg.parm.fm2frq2 & 0xff;
|
|
modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
|
|
pitch += (MOD_SENSE * modulation) / 1200;
|
|
LIMITVALUE(pitch, -128, 127);
|
|
fm2frq2 = ((unsigned char)pitch<<8) | freq;
|
|
EMU8000_FM2FRQ2_WRITE(hw, vp->ch, fm2frq2);
|
|
}
|
|
|
|
/* set filterQ */
|
|
static void
|
|
set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp)
|
|
{
|
|
unsigned int addr;
|
|
addr = EMU8000_CCCA_READ(hw, vp->ch) & 0xffffff;
|
|
addr |= (vp->reg.parm.filterQ << 28);
|
|
EMU8000_CCCA_WRITE(hw, vp->ch, addr);
|
|
}
|
|
|
|
/*
|
|
* set the envelope & LFO parameters to the default values
|
|
*/
|
|
static void
|
|
snd_emu8000_tweak_voice(emu8000_t *emu, int i)
|
|
{
|
|
/* set all mod/vol envelope shape to minimum */
|
|
EMU8000_ENVVOL_WRITE(emu, i, 0x8000);
|
|
EMU8000_ENVVAL_WRITE(emu, i, 0x8000);
|
|
EMU8000_DCYSUS_WRITE(emu, i, 0x7F7F);
|
|
EMU8000_ATKHLDV_WRITE(emu, i, 0x7F7F);
|
|
EMU8000_ATKHLD_WRITE(emu, i, 0x7F7F);
|
|
EMU8000_PEFE_WRITE(emu, i, 0); /* mod envelope height to zero */
|
|
EMU8000_LFO1VAL_WRITE(emu, i, 0x8000); /* no delay for LFO1 */
|
|
EMU8000_LFO2VAL_WRITE(emu, i, 0x8000);
|
|
EMU8000_IP_WRITE(emu, i, 0xE000); /* no pitch shift */
|
|
EMU8000_IFATN_WRITE(emu, i, 0xFF00); /* volume to minimum */
|
|
EMU8000_FMMOD_WRITE(emu, i, 0);
|
|
EMU8000_TREMFRQ_WRITE(emu, i, 0);
|
|
EMU8000_FM2FRQ2_WRITE(emu, i, 0);
|
|
}
|
|
|
|
/*
|
|
* sysex callback
|
|
*/
|
|
static void
|
|
sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset)
|
|
{
|
|
emu8000_t *hw;
|
|
|
|
hw = emu->hw;
|
|
|
|
switch (parsed) {
|
|
case SNDRV_MIDI_SYSEX_GS_CHORUS_MODE:
|
|
hw->chorus_mode = chset->gs_chorus_mode;
|
|
snd_emu8000_update_chorus_mode(hw);
|
|
break;
|
|
|
|
case SNDRV_MIDI_SYSEX_GS_REVERB_MODE:
|
|
hw->reverb_mode = chset->gs_reverb_mode;
|
|
snd_emu8000_update_reverb_mode(hw);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef CONFIG_SND_SEQUENCER_OSS
|
|
/*
|
|
* OSS ioctl callback
|
|
*/
|
|
static int
|
|
oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2)
|
|
{
|
|
emu8000_t *hw;
|
|
|
|
hw = emu->hw;
|
|
|
|
switch (cmd) {
|
|
case _EMUX_OSS_REVERB_MODE:
|
|
hw->reverb_mode = p1;
|
|
snd_emu8000_update_reverb_mode(hw);
|
|
break;
|
|
|
|
case _EMUX_OSS_CHORUS_MODE:
|
|
hw->chorus_mode = p1;
|
|
snd_emu8000_update_chorus_mode(hw);
|
|
break;
|
|
|
|
case _EMUX_OSS_INITIALIZE_CHIP:
|
|
/* snd_emu8000_init(hw); */ /*ignored*/
|
|
break;
|
|
|
|
case _EMUX_OSS_EQUALIZER:
|
|
hw->bass_level = p1;
|
|
hw->treble_level = p2;
|
|
snd_emu8000_update_equalizer(hw);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
* additional patch keys
|
|
*/
|
|
|
|
#define SNDRV_EMU8000_LOAD_CHORUS_FX 0x10 /* optarg=mode */
|
|
#define SNDRV_EMU8000_LOAD_REVERB_FX 0x11 /* optarg=mode */
|
|
|
|
|
|
/*
|
|
* callback routine
|
|
*/
|
|
|
|
static int
|
|
load_fx(snd_emux_t *emu, int type, int mode, const void __user *buf, long len)
|
|
{
|
|
emu8000_t *hw;
|
|
hw = emu->hw;
|
|
|
|
/* skip header */
|
|
buf += 16;
|
|
len -= 16;
|
|
|
|
switch (type) {
|
|
case SNDRV_EMU8000_LOAD_CHORUS_FX:
|
|
return snd_emu8000_load_chorus_fx(hw, mode, buf, len);
|
|
case SNDRV_EMU8000_LOAD_REVERB_FX:
|
|
return snd_emu8000_load_reverb_fx(hw, mode, buf, len);
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|