You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
635 lines
20 KiB
635 lines
20 KiB
20 years ago
|
/*
|
||
|
|
* Routines for Gravis UltraSound soundcards - Simple instrument handlers
|
||
|
|
* Copyright (c) by Jaroslav Kysela <perex@suse.cz>
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* 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 <sound/driver.h>
|
||
|
|
#include <linux/time.h>
|
||
|
|
#include <sound/core.h>
|
||
|
|
#include <sound/gus.h>
|
||
|
|
#include "gus_tables.h"
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void interrupt_wave(snd_gus_card_t *gus, snd_gus_voice_t *voice);
|
||
|
|
static void interrupt_volume(snd_gus_card_t *gus, snd_gus_voice_t *voice);
|
||
|
|
static void interrupt_effect(snd_gus_card_t *gus, snd_gus_voice_t *voice);
|
||
|
|
|
||
|
|
static void sample_start(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_position_t position);
|
||
|
|
static void sample_stop(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_stop_mode_t mode);
|
||
|
|
static void sample_freq(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_frequency_t freq);
|
||
|
|
static void sample_volume(snd_gus_card_t *card, snd_gus_voice_t *voice, snd_seq_ev_volume_t *volume);
|
||
|
|
static void sample_loop(snd_gus_card_t *card, snd_gus_voice_t *voice, snd_seq_ev_loop_t *loop);
|
||
|
|
static void sample_pos(snd_gus_card_t *card, snd_gus_voice_t *voice, snd_seq_position_t position);
|
||
|
|
static void sample_private1(snd_gus_card_t *card, snd_gus_voice_t *voice, unsigned char *data);
|
||
|
|
|
||
|
|
static snd_gus_sample_ops_t sample_ops = {
|
||
|
|
sample_start,
|
||
|
|
sample_stop,
|
||
|
|
sample_freq,
|
||
|
|
sample_volume,
|
||
|
|
sample_loop,
|
||
|
|
sample_pos,
|
||
|
|
sample_private1
|
||
|
|
};
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
|
||
|
|
static void note_stop(snd_gus_card_t *gus, snd_gus_voice_t *voice, int wait);
|
||
|
|
static void note_wait(snd_gus_card_t *gus, snd_gus_voice_t *voice);
|
||
|
|
static void note_off(snd_gus_card_t *gus, snd_gus_voice_t *voice);
|
||
|
|
static void note_volume(snd_gus_card_t *card, snd_gus_voice_t *voice);
|
||
|
|
static void note_pitchbend(snd_gus_card_t *card, snd_gus_voice_t *voice);
|
||
|
|
static void note_vibrato(snd_gus_card_t *card, snd_gus_voice_t *voice);
|
||
|
|
static void note_tremolo(snd_gus_card_t *card, snd_gus_voice_t *voice);
|
||
|
|
|
||
|
|
static struct snd_gus_note_handlers note_commands = {
|
||
|
|
note_stop,
|
||
|
|
note_wait,
|
||
|
|
note_off,
|
||
|
|
note_volume,
|
||
|
|
note_pitchbend,
|
||
|
|
note_vibrato,
|
||
|
|
note_tremolo
|
||
|
|
};
|
||
|
|
|
||
|
|
static void chn_trigger_down(snd_gus_card_t *card, ultra_channel_t *channel, ultra_instrument_t *instrument, unsigned char note, unsigned char velocity, unsigned char priority );
|
||
|
|
static void chn_trigger_up( ultra_card_t *card, ultra_note_t *note );
|
||
|
|
static void chn_control( ultra_card_t *card, ultra_channel_t *channel, unsigned short p1, unsigned short p2 );
|
||
|
|
|
||
|
|
static struct ULTRA_STRU_INSTRUMENT_CHANNEL_COMMANDS channel_commands = {
|
||
|
|
chn_trigger_down,
|
||
|
|
chn_trigger_up,
|
||
|
|
chn_control
|
||
|
|
};
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
static void do_volume_envelope(snd_gus_card_t *card, snd_gus_voice_t *voice);
|
||
|
|
static void do_pan_envelope(snd_gus_card_t *card, snd_gus_voice_t *voice);
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void interrupt_wave(snd_gus_card_t *gus, snd_gus_voice_t *voice)
|
||
|
|
{
|
||
|
|
spin_lock(&gus->event_lock);
|
||
|
|
snd_gf1_stop_voice(gus, voice->number);
|
||
|
|
spin_lock(&gus->reg_lock);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_VOLUME, 0);
|
||
|
|
spin_unlock(&gus->reg_lock);
|
||
|
|
voice->flags &= ~SNDRV_GF1_VFLG_RUNNING;
|
||
|
|
spin_unlock(&gus->event_lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void interrupt_volume(snd_gus_card_t *gus, snd_gus_voice_t *voice)
|
||
|
|
{
|
||
|
|
spin_lock(&gus->event_lock);
|
||
|
|
if (voice->flags & SNDRV_GF1_VFLG_RUNNING)
|
||
|
|
do_volume_envelope(gus, voice);
|
||
|
|
else
|
||
|
|
snd_gf1_stop_voice(gus, voice->number);
|
||
|
|
spin_unlock(&gus->event_lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void interrupt_effect(snd_gus_card_t *gus, snd_gus_voice_t *voice)
|
||
|
|
{
|
||
|
|
spin_lock(&gus->event_lock);
|
||
|
|
if ((voice->flags & (SNDRV_GF1_VFLG_RUNNING|SNDRV_GF1_VFLG_EFFECT_TIMER1)) ==
|
||
|
|
(SNDRV_GF1_VFLG_RUNNING|SNDRV_GF1_VFLG_EFFECT_TIMER1))
|
||
|
|
do_pan_envelope(gus, voice);
|
||
|
|
spin_unlock(&gus->event_lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void do_volume_envelope(snd_gus_card_t *gus, snd_gus_voice_t *voice)
|
||
|
|
{
|
||
|
|
unsigned short next, rate, old_volume;
|
||
|
|
int program_next_ramp;
|
||
|
|
unsigned long flags;
|
||
|
|
|
||
|
|
if (!gus->gf1.volume_ramp) {
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_ctrl_stop(gus, SNDRV_GF1_VB_VOLUME_CONTROL);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_VOLUME, voice->gf1_volume);
|
||
|
|
printk("gf1_volume = 0x%x\n", voice->gf1_volume);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
program_next_ramp = 0;
|
||
|
|
rate = next = 0;
|
||
|
|
while (1) {
|
||
|
|
program_next_ramp = 0;
|
||
|
|
rate = next = 0;
|
||
|
|
switch (voice->venv_state) {
|
||
|
|
case VENV_BEFORE:
|
||
|
|
voice->venv_state = VENV_ATTACK;
|
||
|
|
voice->venv_value_next = 0;
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_ctrl_stop(gus, SNDRV_GF1_VB_VOLUME_CONTROL);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_VOLUME, SNDRV_GF1_MIN_VOLUME);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
break;
|
||
|
|
case VENV_ATTACK:
|
||
|
|
voice->venv_state = VENV_SUSTAIN;
|
||
|
|
program_next_ramp++;
|
||
|
|
next = 255;
|
||
|
|
rate = gus->gf1.volume_ramp;
|
||
|
|
break;
|
||
|
|
case VENV_SUSTAIN:
|
||
|
|
voice->venv_state = VENV_RELEASE;
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_ctrl_stop(gus, SNDRV_GF1_VB_VOLUME_CONTROL);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_VOLUME, ((int)voice->gf1_volume * (int)voice->venv_value_next) / 255);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
return;
|
||
|
|
case VENV_RELEASE:
|
||
|
|
voice->venv_state = VENV_DONE;
|
||
|
|
program_next_ramp++;
|
||
|
|
next = 0;
|
||
|
|
rate = gus->gf1.volume_ramp;
|
||
|
|
break;
|
||
|
|
case VENV_DONE:
|
||
|
|
snd_gf1_stop_voice(gus, voice->number);
|
||
|
|
voice->flags &= ~SNDRV_GF1_VFLG_RUNNING;
|
||
|
|
return;
|
||
|
|
case VENV_VOLUME:
|
||
|
|
program_next_ramp++;
|
||
|
|
next = voice->venv_value_next;
|
||
|
|
rate = gus->gf1.volume_ramp;
|
||
|
|
voice->venv_state = voice->venv_state_prev;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
voice->venv_value_next = next;
|
||
|
|
if (!program_next_ramp)
|
||
|
|
continue;
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_ctrl_stop(gus, SNDRV_GF1_VB_VOLUME_CONTROL);
|
||
|
|
old_volume = snd_gf1_read16(gus, SNDRV_GF1_VW_VOLUME) >> 8;
|
||
|
|
if (!rate) {
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
next = (((int)voice->gf1_volume * (int)next) / 255) >> 8;
|
||
|
|
if (old_volume < SNDRV_GF1_MIN_OFFSET)
|
||
|
|
old_volume = SNDRV_GF1_MIN_OFFSET;
|
||
|
|
if (next < SNDRV_GF1_MIN_OFFSET)
|
||
|
|
next = SNDRV_GF1_MIN_OFFSET;
|
||
|
|
if (next > SNDRV_GF1_MAX_OFFSET)
|
||
|
|
next = SNDRV_GF1_MAX_OFFSET;
|
||
|
|
if (old_volume == next) {
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
voice->volume_control &= ~0xc3;
|
||
|
|
voice->volume_control |= 0x20;
|
||
|
|
if (old_volume > next) {
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_VOLUME_START, next);
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_VOLUME_END, old_volume);
|
||
|
|
voice->volume_control |= 0x40;
|
||
|
|
} else {
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_VOLUME_START, old_volume);
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_VOLUME_END, next);
|
||
|
|
}
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_VOLUME_RATE, rate);
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_VOLUME_CONTROL, voice->volume_control);
|
||
|
|
if (!gus->gf1.enh_mode) {
|
||
|
|
snd_gf1_delay(gus);
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_VOLUME_CONTROL, voice->volume_control);
|
||
|
|
}
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void do_pan_envelope(snd_gus_card_t *gus, snd_gus_voice_t *voice)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
unsigned char old_pan;
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
printk(" -%i- do_pan_envelope - flags = 0x%x (0x%x -> 0x%x)\n",
|
||
|
|
voice->number,
|
||
|
|
voice->flags,
|
||
|
|
voice->gf1_pan,
|
||
|
|
snd_gf1_i_read8(gus, SNDRV_GF1_VB_PAN) & 0x0f);
|
||
|
|
#endif
|
||
|
|
if (gus->gf1.enh_mode) {
|
||
|
|
voice->flags &= ~(SNDRV_GF1_VFLG_EFFECT_TIMER1|SNDRV_GF1_VFLG_PAN);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!gus->gf1.smooth_pan) {
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_PAN, voice->gf1_pan);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!(voice->flags & SNDRV_GF1_VFLG_PAN)) /* before */
|
||
|
|
voice->flags |= SNDRV_GF1_VFLG_EFFECT_TIMER1|SNDRV_GF1_VFLG_PAN;
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
old_pan = snd_gf1_read8(gus, SNDRV_GF1_VB_PAN) & 0x0f;
|
||
|
|
if (old_pan > voice->gf1_pan )
|
||
|
|
old_pan--;
|
||
|
|
if (old_pan < voice->gf1_pan)
|
||
|
|
old_pan++;
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_PAN, old_pan);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
if (old_pan == voice->gf1_pan) /* the goal was reached */
|
||
|
|
voice->flags &= ~(SNDRV_GF1_VFLG_EFFECT_TIMER1|SNDRV_GF1_VFLG_PAN);
|
||
|
|
#if 0
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
printk(" -%i- (1) do_pan_envelope - flags = 0x%x (0x%x -> 0x%x)\n",
|
||
|
|
voice->number,
|
||
|
|
voice->flags,
|
||
|
|
voice->gf1_pan,
|
||
|
|
snd_gf1_i_read8(gus, GF1_VB_PAN) & 0x0f);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
static void set_enhanced_pan(snd_gus_card_t *gus, snd_gus_voice_t *voice, unsigned short pan)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
unsigned short vlo, vro;
|
||
|
|
|
||
|
|
vlo = SNDRV_GF1_ATTEN((SNDRV_GF1_ATTEN_TABLE_SIZE-1) - pan);
|
||
|
|
vro = SNDRV_GF1_ATTEN(pan);
|
||
|
|
if (pan != SNDRV_GF1_ATTEN_TABLE_SIZE - 1 && pan != 0) {
|
||
|
|
vlo >>= 1;
|
||
|
|
vro >>= 1;
|
||
|
|
}
|
||
|
|
vlo <<= 4;
|
||
|
|
vro <<= 4;
|
||
|
|
#if 0
|
||
|
|
printk("vlo = 0x%x (0x%x), vro = 0x%x (0x%x)\n",
|
||
|
|
vlo, snd_gf1_i_read16(gus, GF1_VW_OFFSET_LEFT),
|
||
|
|
vro, snd_gf1_i_read16(gus, GF1_VW_OFFSET_RIGHT));
|
||
|
|
#endif
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_OFFSET_LEFT_FINAL, vlo);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_OFFSET_RIGHT_FINAL, vro);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
voice->vlo = vlo;
|
||
|
|
voice->vro = vro;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void sample_start(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_position_t position)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
unsigned int begin, addr, addr_end, addr_start;
|
||
|
|
int w_16;
|
||
|
|
simple_instrument_t *simple;
|
||
|
|
snd_seq_kinstr_t *instr;
|
||
|
|
|
||
|
|
instr = snd_seq_instr_find(gus->gf1.ilist, &voice->instr, 0, 1);
|
||
|
|
if (instr == NULL)
|
||
|
|
return;
|
||
|
|
voice->instr = instr->instr; /* copy ID to speedup aliases */
|
||
|
|
simple = KINSTR_DATA(instr);
|
||
|
|
begin = simple->address.memory << 4;
|
||
|
|
w_16 = simple->format & SIMPLE_WAVE_16BIT ? 0x04 : 0;
|
||
|
|
addr_start = simple->loop_start;
|
||
|
|
if (simple->format & SIMPLE_WAVE_LOOP) {
|
||
|
|
addr_end = simple->loop_end;
|
||
|
|
} else {
|
||
|
|
addr_end = (simple->size << 4) - (w_16 ? 40 : 24);
|
||
|
|
}
|
||
|
|
if (simple->format & SIMPLE_WAVE_BACKWARD) {
|
||
|
|
addr = simple->loop_end;
|
||
|
|
if (position < simple->loop_end)
|
||
|
|
addr -= position;
|
||
|
|
} else {
|
||
|
|
addr = position;
|
||
|
|
}
|
||
|
|
voice->control = 0x00;
|
||
|
|
voice->mode = 0x20; /* enable offset registers */
|
||
|
|
if (simple->format & SIMPLE_WAVE_16BIT)
|
||
|
|
voice->control |= 0x04;
|
||
|
|
if (simple->format & SIMPLE_WAVE_BACKWARD)
|
||
|
|
voice->control |= 0x40;
|
||
|
|
if (simple->format & SIMPLE_WAVE_LOOP) {
|
||
|
|
voice->control |= 0x08;
|
||
|
|
} else {
|
||
|
|
voice->control |= 0x20;
|
||
|
|
}
|
||
|
|
if (simple->format & SIMPLE_WAVE_BIDIR)
|
||
|
|
voice->control |= 0x10;
|
||
|
|
if (simple->format & SIMPLE_WAVE_ULAW)
|
||
|
|
voice->mode |= 0x40;
|
||
|
|
if (w_16) {
|
||
|
|
addr = ((addr << 1) & ~0x1f) | (addr & 0x0f);
|
||
|
|
addr_start = ((addr_start << 1) & ~0x1f) | (addr_start & 0x0f);
|
||
|
|
addr_end = ((addr_end << 1) & ~0x1f) | (addr_end & 0x0f);
|
||
|
|
}
|
||
|
|
addr += begin;
|
||
|
|
addr_start += begin;
|
||
|
|
addr_end += begin;
|
||
|
|
snd_gf1_stop_voice(gus, voice->number);
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_FREQUENCY, voice->fc_register + voice->fc_lfo);
|
||
|
|
voice->venv_state = VENV_BEFORE;
|
||
|
|
voice->volume_control = 0x03;
|
||
|
|
snd_gf1_write_addr(gus, SNDRV_GF1_VA_START, addr_start, w_16);
|
||
|
|
snd_gf1_write_addr(gus, SNDRV_GF1_VA_END, addr_end, w_16);
|
||
|
|
snd_gf1_write_addr(gus, SNDRV_GF1_VA_CURRENT, addr, w_16);
|
||
|
|
if (!gus->gf1.enh_mode) {
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_PAN, voice->gf1_pan);
|
||
|
|
} else {
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_OFFSET_LEFT, voice->vlo);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_OFFSET_LEFT_FINAL, voice->vlo);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_OFFSET_RIGHT, voice->vro);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_OFFSET_RIGHT_FINAL, voice->vro);
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_ACCUMULATOR, voice->effect_accumulator);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_EFFECT_VOLUME, voice->gf1_effect_volume);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_EFFECT_VOLUME_FINAL, voice->gf1_effect_volume);
|
||
|
|
}
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
do_volume_envelope(gus, voice);
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
if (gus->gf1.enh_mode)
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_MODE, voice->mode);
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_ADDRESS_CONTROL, voice->control);
|
||
|
|
if (!gus->gf1.enh_mode) {
|
||
|
|
snd_gf1_delay(gus);
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_ADDRESS_CONTROL, voice->control );
|
||
|
|
}
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
#if 0
|
||
|
|
snd_gf1_print_voice_registers(gus);
|
||
|
|
#endif
|
||
|
|
voice->flags |= SNDRV_GF1_VFLG_RUNNING;
|
||
|
|
snd_seq_instr_free_use(gus->gf1.ilist, instr);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sample_stop(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_stop_mode_t mode)
|
||
|
|
{
|
||
|
|
unsigned char control;
|
||
|
|
unsigned long flags;
|
||
|
|
|
||
|
|
if (!(voice->flags & SNDRV_GF1_VFLG_RUNNING))
|
||
|
|
return;
|
||
|
|
switch (mode) {
|
||
|
|
default:
|
||
|
|
if (gus->gf1.volume_ramp > 0) {
|
||
|
|
if (voice->venv_state < VENV_RELEASE) {
|
||
|
|
voice->venv_state = VENV_RELEASE;
|
||
|
|
do_volume_envelope(gus, voice);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (mode != SAMPLE_STOP_VENVELOPE) {
|
||
|
|
snd_gf1_stop_voice(gus, voice->number);
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_VOLUME, SNDRV_GF1_MIN_VOLUME);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
voice->flags &= ~SNDRV_GF1_VFLG_RUNNING;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SAMPLE_STOP_LOOP: /* disable loop only */
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
control = snd_gf1_read8(gus, SNDRV_GF1_VB_ADDRESS_CONTROL);
|
||
|
|
control &= ~(0x83 | 0x04);
|
||
|
|
control |= 0x20;
|
||
|
|
snd_gf1_write8(gus, SNDRV_GF1_VB_ADDRESS_CONTROL, control);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sample_freq(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_frequency_t freq)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
voice->fc_register = snd_gf1_translate_freq(gus, freq);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_write16(gus, SNDRV_GF1_VW_FREQUENCY, voice->fc_register + voice->fc_lfo);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sample_volume(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_ev_volume_t *volume)
|
||
|
|
{
|
||
|
|
if (volume->volume >= 0) {
|
||
|
|
volume->volume &= 0x3fff;
|
||
|
|
voice->gf1_volume = snd_gf1_lvol_to_gvol_raw(volume->volume << 2) << 4;
|
||
|
|
voice->venv_state_prev = VENV_SUSTAIN;
|
||
|
|
voice->venv_state = VENV_VOLUME;
|
||
|
|
do_volume_envelope(gus, voice);
|
||
|
|
}
|
||
|
|
if (volume->lr >= 0) {
|
||
|
|
volume->lr &= 0x3fff;
|
||
|
|
if (!gus->gf1.enh_mode) {
|
||
|
|
voice->gf1_pan = (volume->lr >> 10) & 15;
|
||
|
|
if (!gus->gf1.full_range_pan) {
|
||
|
|
if (voice->gf1_pan == 0)
|
||
|
|
voice->gf1_pan++;
|
||
|
|
if (voice->gf1_pan == 15)
|
||
|
|
voice->gf1_pan--;
|
||
|
|
}
|
||
|
|
voice->flags &= ~SNDRV_GF1_VFLG_PAN; /* before */
|
||
|
|
do_pan_envelope(gus, voice);
|
||
|
|
} else {
|
||
|
|
set_enhanced_pan(gus, voice, volume->lr >> 7);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sample_loop(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_ev_loop_t *loop)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
int w_16 = voice->control & 0x04;
|
||
|
|
unsigned int begin, addr_start, addr_end;
|
||
|
|
simple_instrument_t *simple;
|
||
|
|
snd_seq_kinstr_t *instr;
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
printk("voice_loop: start = 0x%x, end = 0x%x\n", loop->start, loop->end);
|
||
|
|
#endif
|
||
|
|
instr = snd_seq_instr_find(gus->gf1.ilist, &voice->instr, 0, 1);
|
||
|
|
if (instr == NULL)
|
||
|
|
return;
|
||
|
|
voice->instr = instr->instr; /* copy ID to speedup aliases */
|
||
|
|
simple = KINSTR_DATA(instr);
|
||
|
|
begin = simple->address.memory;
|
||
|
|
addr_start = loop->start;
|
||
|
|
addr_end = loop->end;
|
||
|
|
addr_start = (((addr_start << 1) & ~0x1f) | (addr_start & 0x0f)) + begin;
|
||
|
|
addr_end = (((addr_end << 1) & ~0x1f) | (addr_end & 0x0f)) + begin;
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_write_addr(gus, SNDRV_GF1_VA_START, addr_start, w_16);
|
||
|
|
snd_gf1_write_addr(gus, SNDRV_GF1_VA_END, addr_end, w_16);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
snd_seq_instr_free_use(gus->gf1.ilist, instr);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sample_pos(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_position_t position)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
int w_16 = voice->control & 0x04;
|
||
|
|
unsigned int begin, addr;
|
||
|
|
simple_instrument_t *simple;
|
||
|
|
snd_seq_kinstr_t *instr;
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
printk("voice_loop: start = 0x%x, end = 0x%x\n", loop->start, loop->end);
|
||
|
|
#endif
|
||
|
|
instr = snd_seq_instr_find(gus->gf1.ilist, &voice->instr, 0, 1);
|
||
|
|
if (instr == NULL)
|
||
|
|
return;
|
||
|
|
voice->instr = instr->instr; /* copy ID to speedup aliases */
|
||
|
|
simple = KINSTR_DATA(instr);
|
||
|
|
begin = simple->address.memory;
|
||
|
|
addr = (((position << 1) & ~0x1f) | (position & 0x0f)) + begin;
|
||
|
|
spin_lock_irqsave(&gus->reg_lock, flags);
|
||
|
|
snd_gf1_select_voice(gus, voice->number);
|
||
|
|
snd_gf1_write_addr(gus, SNDRV_GF1_VA_CURRENT, addr, w_16);
|
||
|
|
spin_unlock_irqrestore(&gus->reg_lock, flags);
|
||
|
|
snd_seq_instr_free_use(gus->gf1.ilist, instr);
|
||
|
|
}
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
|
||
|
|
static unsigned char get_effects_mask( ultra_card_t *card, int value )
|
||
|
|
{
|
||
|
|
if ( value > 7 ) return 0;
|
||
|
|
if ( card -> gf1.effects && card -> gf1.effects -> chip_type == ULTRA_EFFECT_CHIP_INTERWAVE )
|
||
|
|
return card -> gf1.effects -> chip.interwave.voice_output[ value ];
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
static void sample_private1(snd_gus_card_t *card, snd_gus_voice_t *voice, unsigned char *data)
|
||
|
|
{
|
||
|
|
#if 0
|
||
|
|
unsigned long flags;
|
||
|
|
unsigned char uc;
|
||
|
|
|
||
|
|
switch ( *data ) {
|
||
|
|
case ULTRA_PRIV1_IW_EFFECT:
|
||
|
|
uc = get_effects_mask( card, ultra_get_byte( data, 4 ) );
|
||
|
|
uc |= get_effects_mask( card, ultra_get_byte( data, 4 ) >> 4 );
|
||
|
|
uc |= get_effects_mask( card, ultra_get_byte( data, 5 ) );
|
||
|
|
uc |= get_effects_mask( card, ultra_get_byte( data, 5 ) >> 4 );
|
||
|
|
voice -> data.simple.effect_accumulator = uc;
|
||
|
|
voice -> data.simple.effect_volume = ultra_translate_voice_volume( card, ultra_get_word( data, 2 ) ) << 4;
|
||
|
|
if ( !card -> gf1.enh_mode ) return;
|
||
|
|
if ( voice -> flags & VFLG_WAIT_FOR_START ) return;
|
||
|
|
if ( voice -> flags & VFLG_RUNNING )
|
||
|
|
{
|
||
|
|
CLI( &flags );
|
||
|
|
gf1_select_voice( card, voice -> number );
|
||
|
|
ultra_write8( card, GF1_VB_ACCUMULATOR, voice -> data.simple.effect_accumulator );
|
||
|
|
ultra_write16( card, GF1_VW_EFFECT_VOLUME_FINAL, voice -> data.simple.effect_volume );
|
||
|
|
STI( &flags );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case ULTRA_PRIV1_IW_LFO:
|
||
|
|
ultra_lfo_command( card, voice -> number, data );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void note_stop( ultra_card_t *card, ultra_voice_t *voice, int wait )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static void note_wait( ultra_card_t *card, ultra_voice_t *voice )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static void note_off( ultra_card_t *card, ultra_voice_t *voice )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static void note_volume( ultra_card_t *card, ultra_voice_t *voice )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static void note_pitchbend( ultra_card_t *card, ultra_voice_t *voice )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static void note_vibrato( ultra_card_t *card, ultra_voice_t *voice )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static void note_tremolo( ultra_card_t *card, ultra_voice_t *voice )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void chn_trigger_down( ultra_card_t *card, ultra_channel_t *channel, ultra_instrument_t *instrument, unsigned char note, unsigned char velocity, unsigned char priority )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static void chn_trigger_up( ultra_card_t *card, ultra_note_t *note )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
static void chn_control( ultra_card_t *card, ultra_channel_t *channel, unsigned short p1, unsigned short p2 )
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
void snd_gf1_simple_init(snd_gus_voice_t *voice)
|
||
|
|
{
|
||
|
|
voice->handler_wave = interrupt_wave;
|
||
|
|
voice->handler_volume = interrupt_volume;
|
||
|
|
voice->handler_effect = interrupt_effect;
|
||
|
|
voice->volume_change = NULL;
|
||
|
|
voice->sample_ops = &sample_ops;
|
||
|
|
}
|