| /* |
| * sound/awe_wave.c |
| * |
| * The low level driver for the AWE32/SB32/AWE64 wave table synth. |
| * version 0.4.4; Jan. 4, 2000 |
| * |
| * Copyright (C) 1996-2000 Takashi Iwai |
| * |
| * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| */ |
| |
| /* |
| * Changelog: |
| * Aug 18, 2003, Adam Belay <ambx1@neo.rr.com> |
| * - detection code rewrite |
| */ |
| |
| #include <linux/awe_voice.h> |
| #include <linux/config.h> |
| #include <linux/init.h> |
| #include <linux/module.h> |
| #include <linux/string.h> |
| #include <linux/pnp.h> |
| |
| #include "sound_config.h" |
| |
| #include "awe_wave.h" |
| #include "awe_hw.h" |
| |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| #include "tuning.h" |
| #include <linux/ultrasound.h> |
| #endif |
| |
| /* |
| * debug message |
| */ |
| |
| #ifdef AWE_DEBUG_ON |
| #define DEBUG(LVL,XXX) {if (ctrls[AWE_MD_DEBUG_MODE] > LVL) { XXX; }} |
| #define ERRMSG(XXX) {if (ctrls[AWE_MD_DEBUG_MODE]) { XXX; }} |
| #define FATALERR(XXX) XXX |
| #else |
| #define DEBUG(LVL,XXX) /**/ |
| #define ERRMSG(XXX) XXX |
| #define FATALERR(XXX) XXX |
| #endif |
| |
| /* |
| * bank and voice record |
| */ |
| |
| typedef struct _sf_list sf_list; |
| typedef struct _awe_voice_list awe_voice_list; |
| typedef struct _awe_sample_list awe_sample_list; |
| |
| /* soundfont record */ |
| struct _sf_list { |
| unsigned short sf_id; /* id number */ |
| unsigned short type; /* lock & shared flags */ |
| int num_info; /* current info table index */ |
| int num_sample; /* current sample table index */ |
| int mem_ptr; /* current word byte pointer */ |
| awe_voice_list *infos, *last_infos; /* instruments */ |
| awe_sample_list *samples, *last_samples; /* samples */ |
| #ifdef AWE_ALLOW_SAMPLE_SHARING |
| sf_list *shared; /* shared list */ |
| unsigned char name[AWE_PATCH_NAME_LEN]; /* sharing id */ |
| #endif |
| sf_list *next, *prev; |
| }; |
| |
| /* instrument list */ |
| struct _awe_voice_list { |
| awe_voice_info v; /* instrument information */ |
| sf_list *holder; /* parent sf_list of this record */ |
| unsigned char bank, instr; /* preset number information */ |
| char type, disabled; /* type=normal/mapped, disabled=boolean */ |
| awe_voice_list *next; /* linked list with same sf_id */ |
| awe_voice_list *next_instr; /* instrument list */ |
| awe_voice_list *next_bank; /* hash table list */ |
| }; |
| |
| /* voice list type */ |
| #define V_ST_NORMAL 0 |
| #define V_ST_MAPPED 1 |
| |
| /* sample list */ |
| struct _awe_sample_list { |
| awe_sample_info v; /* sample information */ |
| sf_list *holder; /* parent sf_list of this record */ |
| awe_sample_list *next; /* linked list with same sf_id */ |
| }; |
| |
| /* sample and information table */ |
| static int current_sf_id; /* current number of fonts */ |
| static int locked_sf_id; /* locked position */ |
| static sf_list *sfhead, *sftail; /* linked-lists */ |
| |
| #define awe_free_mem_ptr() (sftail ? sftail->mem_ptr : 0) |
| #define awe_free_info() (sftail ? sftail->num_info : 0) |
| #define awe_free_sample() (sftail ? sftail->num_sample : 0) |
| |
| #define AWE_MAX_PRESETS 256 |
| #define AWE_DEFAULT_PRESET 0 |
| #define AWE_DEFAULT_BANK 0 |
| #define AWE_DEFAULT_DRUM 0 |
| #define AWE_DRUM_BANK 128 |
| |
| #define MAX_LAYERS AWE_MAX_VOICES |
| |
| /* preset table index */ |
| static awe_voice_list *preset_table[AWE_MAX_PRESETS]; |
| |
| /* |
| * voice table |
| */ |
| |
| /* effects table */ |
| typedef struct FX_Rec { /* channel effects */ |
| unsigned char flags[AWE_FX_END]; |
| short val[AWE_FX_END]; |
| } FX_Rec; |
| |
| |
| /* channel parameters */ |
| typedef struct _awe_chan_info { |
| int channel; /* channel number */ |
| int bank; /* current tone bank */ |
| int instr; /* current program */ |
| int bender; /* midi pitchbend (-8192 - 8192) */ |
| int bender_range; /* midi bender range (x100) */ |
| int panning; /* panning (0-127) */ |
| int main_vol; /* channel volume (0-127) */ |
| int expression_vol; /* midi expression (0-127) */ |
| int chan_press; /* channel pressure */ |
| int sustained; /* sustain status in MIDI */ |
| FX_Rec fx; /* effects */ |
| FX_Rec fx_layer[MAX_LAYERS]; /* layer effects */ |
| } awe_chan_info; |
| |
| /* voice parameters */ |
| typedef struct _voice_info { |
| int state; |
| #define AWE_ST_OFF (1<<0) /* no sound */ |
| #define AWE_ST_ON (1<<1) /* playing */ |
| #define AWE_ST_STANDBY (1<<2) /* stand by for playing */ |
| #define AWE_ST_SUSTAINED (1<<3) /* sustained */ |
| #define AWE_ST_MARK (1<<4) /* marked for allocation */ |
| #define AWE_ST_DRAM (1<<5) /* DRAM read/write */ |
| #define AWE_ST_FM (1<<6) /* reserved for FM */ |
| #define AWE_ST_RELEASED (1<<7) /* released */ |
| |
| int ch; /* midi channel */ |
| int key; /* internal key for search */ |
| int layer; /* layer number (for channel mode only) */ |
| int time; /* allocated time */ |
| awe_chan_info *cinfo; /* channel info */ |
| |
| int note; /* midi key (0-127) */ |
| int velocity; /* midi velocity (0-127) */ |
| int sostenuto; /* sostenuto on/off */ |
| awe_voice_info *sample; /* assigned voice */ |
| |
| /* EMU8000 parameters */ |
| int apitch; /* pitch parameter */ |
| int avol; /* volume parameter */ |
| int apan; /* panning parameter */ |
| int acutoff; /* cutoff parameter */ |
| short aaux; /* aux word */ |
| } voice_info; |
| |
| /* voice information */ |
| static voice_info voices[AWE_MAX_VOICES]; |
| |
| #define IS_NO_SOUND(v) (voices[v].state & (AWE_ST_OFF|AWE_ST_RELEASED|AWE_ST_STANDBY|AWE_ST_SUSTAINED)) |
| #define IS_NO_EFFECT(v) (voices[v].state != AWE_ST_ON) |
| #define IS_PLAYING(v) (voices[v].state & (AWE_ST_ON|AWE_ST_SUSTAINED|AWE_ST_RELEASED)) |
| #define IS_EMPTY(v) (voices[v].state & (AWE_ST_OFF|AWE_ST_MARK|AWE_ST_DRAM|AWE_ST_FM)) |
| |
| |
| /* MIDI channel effects information (for hw control) */ |
| static awe_chan_info channels[AWE_MAX_CHANNELS]; |
| |
| |
| /* |
| * global variables |
| */ |
| |
| #ifndef AWE_DEFAULT_BASE_ADDR |
| #define AWE_DEFAULT_BASE_ADDR 0 /* autodetect */ |
| #endif |
| |
| #ifndef AWE_DEFAULT_MEM_SIZE |
| #define AWE_DEFAULT_MEM_SIZE -1 /* autodetect */ |
| #endif |
| |
| static int io = AWE_DEFAULT_BASE_ADDR; /* Emu8000 base address */ |
| static int memsize = AWE_DEFAULT_MEM_SIZE; /* memory size in Kbytes */ |
| #ifdef CONFIG_PNP |
| static int isapnp = -1; |
| #else |
| static int isapnp; |
| #endif |
| |
| MODULE_AUTHOR("Takashi Iwai <iwai@ww.uni-erlangen.de>"); |
| MODULE_DESCRIPTION("SB AWE32/64 WaveTable driver"); |
| MODULE_LICENSE("GPL"); |
| |
| module_param(io, int, 0); |
| MODULE_PARM_DESC(io, "base i/o port of Emu8000"); |
| module_param(memsize, int, 0); |
| MODULE_PARM_DESC(memsize, "onboard DRAM size in Kbytes"); |
| module_param(isapnp, bool, 0); |
| MODULE_PARM_DESC(isapnp, "use ISAPnP detection"); |
| |
| /* DRAM start offset */ |
| static int awe_mem_start = AWE_DRAM_OFFSET; |
| |
| /* maximum channels for playing */ |
| static int awe_max_voices = AWE_MAX_VOICES; |
| |
| static int patch_opened; /* sample already loaded? */ |
| |
| static char atten_relative = FALSE; |
| static short atten_offset; |
| |
| static int awe_present = FALSE; /* awe device present? */ |
| static int awe_busy = FALSE; /* awe device opened? */ |
| |
| static int my_dev = -1; |
| |
| #define DEFAULT_DRUM_FLAGS ((1 << 9) | (1 << 25)) |
| #define IS_DRUM_CHANNEL(c) (drum_flags & (1 << (c))) |
| #define DRUM_CHANNEL_ON(c) (drum_flags |= (1 << (c))) |
| #define DRUM_CHANNEL_OFF(c) (drum_flags &= ~(1 << (c))) |
| static unsigned int drum_flags = DEFAULT_DRUM_FLAGS; /* channel flags */ |
| |
| static int playing_mode = AWE_PLAY_INDIRECT; |
| #define SINGLE_LAYER_MODE() (playing_mode == AWE_PLAY_INDIRECT || playing_mode == AWE_PLAY_DIRECT) |
| #define MULTI_LAYER_MODE() (playing_mode == AWE_PLAY_MULTI || playing_mode == AWE_PLAY_MULTI2) |
| |
| static int current_alloc_time; /* voice allocation index for channel mode */ |
| |
| static struct synth_info awe_info = { |
| "AWE32 Synth", /* name */ |
| 0, /* device */ |
| SYNTH_TYPE_SAMPLE, /* synth_type */ |
| SAMPLE_TYPE_AWE32, /* synth_subtype */ |
| 0, /* perc_mode (obsolete) */ |
| AWE_MAX_VOICES, /* nr_voices */ |
| 0, /* nr_drums (obsolete) */ |
| 400 /* instr_bank_size */ |
| }; |
| |
| |
| static struct voice_alloc_info *voice_alloc; /* set at initialization */ |
| |
| |
| /* |
| * function prototypes |
| */ |
| |
| static int awe_request_region(void); |
| static void awe_release_region(void); |
| |
| static void awe_reset_samples(void); |
| /* emu8000 chip i/o access */ |
| static void setup_ports(int p1, int p2, int p3); |
| static void awe_poke(unsigned short cmd, unsigned short port, unsigned short data); |
| static void awe_poke_dw(unsigned short cmd, unsigned short port, unsigned int data); |
| static unsigned short awe_peek(unsigned short cmd, unsigned short port); |
| static unsigned int awe_peek_dw(unsigned short cmd, unsigned short port); |
| static void awe_wait(unsigned short delay); |
| |
| /* initialize emu8000 chip */ |
| static void awe_initialize(void); |
| |
| /* set voice parameters */ |
| static void awe_init_ctrl_parms(int init_all); |
| static void awe_init_voice_info(awe_voice_info *vp); |
| static void awe_init_voice_parm(awe_voice_parm *pp); |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| static int freq_to_note(int freq); |
| static int calc_rate_offset(int Hz); |
| /*static int calc_parm_delay(int msec);*/ |
| static int calc_parm_hold(int msec); |
| static int calc_parm_attack(int msec); |
| static int calc_parm_decay(int msec); |
| static int calc_parm_search(int msec, short *table); |
| #endif /* gus compat */ |
| |
| /* turn on/off note */ |
| static void awe_note_on(int voice); |
| static void awe_note_off(int voice); |
| static void awe_terminate(int voice); |
| static void awe_exclusive_off(int voice); |
| static void awe_note_off_all(int do_sustain); |
| |
| /* calculate voice parameters */ |
| typedef void (*fx_affect_func)(int voice, int forced); |
| static void awe_set_pitch(int voice, int forced); |
| static void awe_set_voice_pitch(int voice, int forced); |
| static void awe_set_volume(int voice, int forced); |
| static void awe_set_voice_vol(int voice, int forced); |
| static void awe_set_pan(int voice, int forced); |
| static void awe_fx_fmmod(int voice, int forced); |
| static void awe_fx_tremfrq(int voice, int forced); |
| static void awe_fx_fm2frq2(int voice, int forced); |
| static void awe_fx_filterQ(int voice, int forced); |
| static void awe_calc_pitch(int voice); |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| static void awe_calc_pitch_from_freq(int voice, int freq); |
| #endif |
| static void awe_calc_volume(int voice); |
| static void awe_update_volume(void); |
| static void awe_change_master_volume(short val); |
| static void awe_voice_init(int voice, int init_all); |
| static void awe_channel_init(int ch, int init_all); |
| static void awe_fx_init(int ch); |
| static void awe_send_effect(int voice, int layer, int type, int val); |
| static void awe_modwheel_change(int voice, int value); |
| |
| /* sequencer interface */ |
| static int awe_open(int dev, int mode); |
| static void awe_close(int dev); |
| static int awe_ioctl(int dev, unsigned int cmd, void __user * arg); |
| static int awe_kill_note(int dev, int voice, int note, int velocity); |
| static int awe_start_note(int dev, int v, int note_num, int volume); |
| static int awe_set_instr(int dev, int voice, int instr_no); |
| static int awe_set_instr_2(int dev, int voice, int instr_no); |
| static void awe_reset(int dev); |
| static void awe_hw_control(int dev, unsigned char *event); |
| static int awe_load_patch(int dev, int format, const char __user *addr, |
| int offs, int count, int pmgr_flag); |
| static void awe_aftertouch(int dev, int voice, int pressure); |
| static void awe_controller(int dev, int voice, int ctrl_num, int value); |
| static void awe_panning(int dev, int voice, int value); |
| static void awe_volume_method(int dev, int mode); |
| static void awe_bender(int dev, int voice, int value); |
| static int awe_alloc(int dev, int chn, int note, struct voice_alloc_info *alloc); |
| static void awe_setup_voice(int dev, int voice, int chn); |
| |
| #define awe_key_pressure(dev,voice,key,press) awe_start_note(dev,voice,(key)+128,press) |
| |
| /* hardware controls */ |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| static void awe_hw_gus_control(int dev, int cmd, unsigned char *event); |
| #endif |
| static void awe_hw_awe_control(int dev, int cmd, unsigned char *event); |
| static void awe_voice_change(int voice, fx_affect_func func); |
| static void awe_sostenuto_on(int voice, int forced); |
| static void awe_sustain_off(int voice, int forced); |
| static void awe_terminate_and_init(int voice, int forced); |
| |
| /* voice search */ |
| static int awe_search_key(int bank, int preset, int note); |
| static awe_voice_list *awe_search_instr(int bank, int preset, int note); |
| static int awe_search_multi_voices(awe_voice_list *rec, int note, int velocity, awe_voice_info **vlist); |
| static void awe_alloc_multi_voices(int ch, int note, int velocity, int key); |
| static void awe_alloc_one_voice(int voice, int note, int velocity); |
| static int awe_clear_voice(void); |
| |
| /* load / remove patches */ |
| static int awe_open_patch(awe_patch_info *patch, const char __user *addr, int count); |
| static int awe_close_patch(awe_patch_info *patch, const char __user *addr, int count); |
| static int awe_unload_patch(awe_patch_info *patch, const char __user *addr, int count); |
| static int awe_load_info(awe_patch_info *patch, const char __user *addr, int count); |
| static int awe_remove_info(awe_patch_info *patch, const char __user *addr, int count); |
| static int awe_load_data(awe_patch_info *patch, const char __user *addr, int count); |
| static int awe_replace_data(awe_patch_info *patch, const char __user *addr, int count); |
| static int awe_load_map(awe_patch_info *patch, const char __user *addr, int count); |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| static int awe_load_guspatch(const char __user *addr, int offs, int size, int pmgr_flag); |
| #endif |
| /*static int awe_probe_info(awe_patch_info *patch, const char __user *addr, int count);*/ |
| static int awe_probe_data(awe_patch_info *patch, const char __user *addr, int count); |
| static sf_list *check_patch_opened(int type, char *name); |
| static int awe_write_wave_data(const char __user *addr, int offset, awe_sample_list *sp, int channels); |
| static int awe_create_sf(int type, char *name); |
| static void awe_free_sf(sf_list *sf); |
| static void add_sf_info(sf_list *sf, awe_voice_list *rec); |
| static void add_sf_sample(sf_list *sf, awe_sample_list *smp); |
| static void purge_old_list(awe_voice_list *rec, awe_voice_list *next); |
| static void add_info_list(awe_voice_list *rec); |
| static void awe_remove_samples(int sf_id); |
| static void rebuild_preset_list(void); |
| static short awe_set_sample(awe_voice_list *rec); |
| static awe_sample_list *search_sample_index(sf_list *sf, int sample); |
| |
| static int is_identical_holder(sf_list *sf1, sf_list *sf2); |
| #ifdef AWE_ALLOW_SAMPLE_SHARING |
| static int is_identical_name(unsigned char *name, sf_list *p); |
| static int is_shared_sf(unsigned char *name); |
| static int info_duplicated(sf_list *sf, awe_voice_list *rec); |
| #endif /* allow sharing */ |
| |
| /* lowlevel functions */ |
| static void awe_init_audio(void); |
| static void awe_init_dma(void); |
| static void awe_init_array(void); |
| static void awe_send_array(unsigned short *data); |
| static void awe_tweak_voice(int voice); |
| static void awe_tweak(void); |
| static void awe_init_fm(void); |
| static int awe_open_dram_for_write(int offset, int channels); |
| static void awe_open_dram_for_check(void); |
| static void awe_close_dram(void); |
| /*static void awe_write_dram(unsigned short c);*/ |
| static int awe_detect_base(int addr); |
| static int awe_detect(void); |
| static void awe_check_dram(void); |
| static int awe_load_chorus_fx(awe_patch_info *patch, const char __user *addr, int count); |
| static void awe_set_chorus_mode(int mode); |
| static void awe_update_chorus_mode(void); |
| static int awe_load_reverb_fx(awe_patch_info *patch, const char __user *addr, int count); |
| static void awe_set_reverb_mode(int mode); |
| static void awe_update_reverb_mode(void); |
| static void awe_equalizer(int bass, int treble); |
| static void awe_update_equalizer(void); |
| |
| #ifdef CONFIG_AWE32_MIXER |
| static void attach_mixer(void); |
| static void unload_mixer(void); |
| #endif |
| |
| #ifdef CONFIG_AWE32_MIDIEMU |
| static void attach_midiemu(void); |
| static void unload_midiemu(void); |
| #endif |
| |
| #define limitvalue(x, a, b) if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b) |
| |
| /* |
| * control parameters |
| */ |
| |
| |
| #ifdef AWE_USE_NEW_VOLUME_CALC |
| #define DEF_VOLUME_CALC TRUE |
| #else |
| #define DEF_VOLUME_CALC FALSE |
| #endif /* new volume */ |
| |
| #define DEF_ZERO_ATTEN 32 /* 12dB below */ |
| #define DEF_MOD_SENSE 18 |
| #define DEF_CHORUS_MODE 2 |
| #define DEF_REVERB_MODE 4 |
| #define DEF_BASS_LEVEL 5 |
| #define DEF_TREBLE_LEVEL 9 |
| |
| static struct CtrlParmsDef { |
| int value; |
| int init_each_time; |
| void (*update)(void); |
| } ctrl_parms[AWE_MD_END] = { |
| {0,0, NULL}, {0,0, NULL}, /* <-- not used */ |
| {AWE_VERSION_NUMBER, FALSE, NULL}, |
| {TRUE, FALSE, NULL}, /* exclusive */ |
| {TRUE, FALSE, NULL}, /* realpan */ |
| {AWE_DEFAULT_BANK, FALSE, NULL}, /* gusbank */ |
| {FALSE, TRUE, NULL}, /* keep effect */ |
| {DEF_ZERO_ATTEN, FALSE, awe_update_volume}, /* zero_atten */ |
| {FALSE, FALSE, NULL}, /* chn_prior */ |
| {DEF_MOD_SENSE, FALSE, NULL}, /* modwheel sense */ |
| {AWE_DEFAULT_PRESET, FALSE, NULL}, /* def_preset */ |
| {AWE_DEFAULT_BANK, FALSE, NULL}, /* def_bank */ |
| {AWE_DEFAULT_DRUM, FALSE, NULL}, /* def_drum */ |
| {FALSE, FALSE, NULL}, /* toggle_drum_bank */ |
| {DEF_VOLUME_CALC, FALSE, awe_update_volume}, /* new_volume_calc */ |
| {DEF_CHORUS_MODE, FALSE, awe_update_chorus_mode}, /* chorus mode */ |
| {DEF_REVERB_MODE, FALSE, awe_update_reverb_mode}, /* reverb mode */ |
| {DEF_BASS_LEVEL, FALSE, awe_update_equalizer}, /* bass level */ |
| {DEF_TREBLE_LEVEL, FALSE, awe_update_equalizer}, /* treble level */ |
| {0, FALSE, NULL}, /* debug mode */ |
| {FALSE, FALSE, NULL}, /* pan exchange */ |
| }; |
| |
| static int ctrls[AWE_MD_END]; |
| |
| |
| /* |
| * synth operation table |
| */ |
| |
| static struct synth_operations awe_operations = |
| { |
| .owner = THIS_MODULE, |
| .id = "EMU8K", |
| .info = &awe_info, |
| .midi_dev = 0, |
| .synth_type = SYNTH_TYPE_SAMPLE, |
| .synth_subtype = SAMPLE_TYPE_AWE32, |
| .open = awe_open, |
| .close = awe_close, |
| .ioctl = awe_ioctl, |
| .kill_note = awe_kill_note, |
| .start_note = awe_start_note, |
| .set_instr = awe_set_instr_2, |
| .reset = awe_reset, |
| .hw_control = awe_hw_control, |
| .load_patch = awe_load_patch, |
| .aftertouch = awe_aftertouch, |
| .controller = awe_controller, |
| .panning = awe_panning, |
| .volume_method = awe_volume_method, |
| .bender = awe_bender, |
| .alloc_voice = awe_alloc, |
| .setup_voice = awe_setup_voice |
| }; |
| |
| static void free_tables(void) |
| { |
| if (sftail) { |
| sf_list *p, *prev; |
| for (p = sftail; p; p = prev) { |
| prev = p->prev; |
| awe_free_sf(p); |
| } |
| } |
| sfhead = sftail = NULL; |
| } |
| |
| /* |
| * clear sample tables |
| */ |
| |
| static void |
| awe_reset_samples(void) |
| { |
| /* free all bank tables */ |
| memset(preset_table, 0, sizeof(preset_table)); |
| free_tables(); |
| |
| current_sf_id = 0; |
| locked_sf_id = 0; |
| patch_opened = 0; |
| } |
| |
| |
| /* |
| * EMU register access |
| */ |
| |
| /* select a given AWE32 pointer */ |
| static int awe_ports[5]; |
| static int port_setuped = FALSE; |
| static int awe_cur_cmd = -1; |
| #define awe_set_cmd(cmd) \ |
| if (awe_cur_cmd != cmd) { outw(cmd, awe_ports[Pointer]); awe_cur_cmd = cmd; } |
| |
| /* write 16bit data */ |
| static void |
| awe_poke(unsigned short cmd, unsigned short port, unsigned short data) |
| { |
| awe_set_cmd(cmd); |
| outw(data, awe_ports[port]); |
| } |
| |
| /* write 32bit data */ |
| static void |
| awe_poke_dw(unsigned short cmd, unsigned short port, unsigned int data) |
| { |
| unsigned short addr = awe_ports[port]; |
| awe_set_cmd(cmd); |
| outw(data, addr); /* write lower 16 bits */ |
| outw(data >> 16, addr + 2); /* write higher 16 bits */ |
| } |
| |
| /* read 16bit data */ |
| static unsigned short |
| awe_peek(unsigned short cmd, unsigned short port) |
| { |
| unsigned short k; |
| awe_set_cmd(cmd); |
| k = inw(awe_ports[port]); |
| return k; |
| } |
| |
| /* read 32bit data */ |
| static unsigned int |
| awe_peek_dw(unsigned short cmd, unsigned short port) |
| { |
| unsigned int k1, k2; |
| unsigned short addr = awe_ports[port]; |
| awe_set_cmd(cmd); |
| k1 = inw(addr); |
| k2 = inw(addr + 2); |
| k1 |= k2 << 16; |
| return k1; |
| } |
| |
| /* wait delay number of AWE32 44100Hz clocks */ |
| #ifdef WAIT_BY_LOOP /* wait by loop -- that's not good.. */ |
| static void |
| awe_wait(unsigned short delay) |
| { |
| unsigned short clock, target; |
| unsigned short port = awe_ports[AWE_WC_Port]; |
| int counter; |
| |
| /* sample counter */ |
| awe_set_cmd(AWE_WC_Cmd); |
| clock = (unsigned short)inw(port); |
| target = clock + delay; |
| counter = 0; |
| if (target < clock) { |
| for (; (unsigned short)inw(port) > target; counter++) |
| if (counter > 65536) |
| break; |
| } |
| for (; (unsigned short)inw(port) < target; counter++) |
| if (counter > 65536) |
| break; |
| } |
| #else |
| |
| static void awe_wait(unsigned short delay) |
| { |
| current->state = TASK_INTERRUPTIBLE; |
| schedule_timeout((HZ*(unsigned long)delay + 44099)/44100); |
| } |
| /* |
| static void awe_wait(unsigned short delay) |
| { |
| udelay(((unsigned long)delay * 1000000L + 44099) / 44100); |
| } |
| */ |
| #endif /* wait by loop */ |
| |
| /* write a word data */ |
| #define awe_write_dram(c) awe_poke(AWE_SMLD, c) |
| |
| /* |
| * AWE32 voice parameters |
| */ |
| |
| /* initialize voice_info record */ |
| static void |
| awe_init_voice_info(awe_voice_info *vp) |
| { |
| vp->sample = 0; |
| vp->rate_offset = 0; |
| |
| vp->start = 0; |
| vp->end = 0; |
| vp->loopstart = 0; |
| vp->loopend = 0; |
| vp->mode = 0; |
| vp->root = 60; |
| vp->tune = 0; |
| vp->low = 0; |
| vp->high = 127; |
| vp->vellow = 0; |
| vp->velhigh = 127; |
| |
| vp->fixkey = -1; |
| vp->fixvel = -1; |
| vp->fixpan = -1; |
| vp->pan = -1; |
| |
| vp->exclusiveClass = 0; |
| vp->amplitude = 127; |
| vp->attenuation = 0; |
| vp->scaleTuning = 100; |
| |
| awe_init_voice_parm(&vp->parm); |
| } |
| |
| /* initialize voice_parm record: |
| * Env1/2: delay=0, attack=0, hold=0, sustain=0, decay=0, release=0. |
| * Vibrato and Tremolo effects are zero. |
| * Cutoff is maximum. |
| * Chorus and Reverb effects are zero. |
| */ |
| static void |
| awe_init_voice_parm(awe_voice_parm *pp) |
| { |
| pp->moddelay = 0x8000; |
| pp->modatkhld = 0x7f7f; |
| pp->moddcysus = 0x7f7f; |
| pp->modrelease = 0x807f; |
| pp->modkeyhold = 0; |
| pp->modkeydecay = 0; |
| |
| pp->voldelay = 0x8000; |
| pp->volatkhld = 0x7f7f; |
| pp->voldcysus = 0x7f7f; |
| pp->volrelease = 0x807f; |
| pp->volkeyhold = 0; |
| pp->volkeydecay = 0; |
| |
| pp->lfo1delay = 0x8000; |
| pp->lfo2delay = 0x8000; |
| pp->pefe = 0; |
| |
| pp->fmmod = 0; |
| pp->tremfrq = 0; |
| pp->fm2frq2 = 0; |
| |
| pp->cutoff = 0xff; |
| pp->filterQ = 0; |
| |
| pp->chorus = 0; |
| pp->reverb = 0; |
| } |
| |
| |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| |
| /* convert frequency mHz to abstract cents (= midi key * 100) */ |
| static int |
| freq_to_note(int mHz) |
| { |
| /* abscents = log(mHz/8176) / log(2) * 1200 */ |
| unsigned int max_val = (unsigned int)0xffffffff / 10000; |
| int i, times; |
| unsigned int base; |
| unsigned int freq; |
| int note, tune; |
| |
| if (mHz == 0) |
| return 0; |
| if (mHz < 0) |
| return 12799; /* maximum */ |
| |
| freq = mHz; |
| note = 0; |
| for (base = 8176 * 2; freq >= base; base *= 2) { |
| note += 12; |
| if (note >= 128) /* over maximum */ |
| return 12799; |
| } |
| base /= 2; |
| |
| /* to avoid overflow... */ |
| times = 10000; |
| while (freq > max_val) { |
| max_val *= 10; |
| times /= 10; |
| base /= 10; |
| } |
| |
| freq = freq * times / base; |
| for (i = 0; i < 12; i++) { |
| if (freq < semitone_tuning[i+1]) |
| break; |
| note++; |
| } |
| |
| tune = 0; |
| freq = freq * 10000 / semitone_tuning[i]; |
| for (i = 0; i < 100; i++) { |
| if (freq < cent_tuning[i+1]) |
| break; |
| tune++; |
| } |
| |
| return note * 100 + tune; |
| } |
| |
| |
| /* convert Hz to AWE32 rate offset: |
| * sample pitch offset for the specified sample rate |
| * rate=44100 is no offset, each 4096 is 1 octave (twice). |
| * eg, when rate is 22050, this offset becomes -4096. |
| */ |
| static int |
| calc_rate_offset(int Hz) |
| { |
| /* offset = log(Hz / 44100) / log(2) * 4096 */ |
| int freq, base, i; |
| |
| /* maybe smaller than max (44100Hz) */ |
| if (Hz <= 0 || Hz >= 44100) return 0; |
| |
| base = 0; |
| for (freq = Hz * 2; freq < 44100; freq *= 2) |
| base++; |
| base *= 1200; |
| |
| freq = 44100 * 10000 / (freq/2); |
| for (i = 0; i < 12; i++) { |
| if (freq < semitone_tuning[i+1]) |
| break; |
| base += 100; |
| } |
| freq = freq * 10000 / semitone_tuning[i]; |
| for (i = 0; i < 100; i++) { |
| if (freq < cent_tuning[i+1]) |
| break; |
| base++; |
| } |
| return -base * 4096 / 1200; |
| } |
| |
| |
| /* |
| * convert envelope time parameter to AWE32 raw parameter |
| */ |
| |
| /* attack & decay/release time table (msec) */ |
| static short attack_time_tbl[128] = { |
| 32767, 32767, 5989, 4235, 2994, 2518, 2117, 1780, 1497, 1373, 1259, 1154, 1058, 970, 890, 816, |
| 707, 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, |
| 361, 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, |
| 180, 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, |
| 90, 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, |
| 45, 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, |
| 22, 21, 20, 19, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12, |
| 11, 11, 10, 10, 10, 9, 9, 8, 8, 8, 8, 7, 7, 7, 6, 0, |
| }; |
| |
| static short decay_time_tbl[128] = { |
| 32767, 32767, 22614, 15990, 11307, 9508, 7995, 6723, 5653, 5184, 4754, 4359, 3997, 3665, 3361, 3082, |
| 2828, 2765, 2648, 2535, 2428, 2325, 2226, 2132, 2042, 1955, 1872, 1793, 1717, 1644, 1574, 1507, |
| 1443, 1382, 1324, 1267, 1214, 1162, 1113, 1066, 978, 936, 897, 859, 822, 787, 754, 722, |
| 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, 361, |
| 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, 180, |
| 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, 90, |
| 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, 45, |
| 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, 22, |
| }; |
| |
| #define calc_parm_delay(msec) (0x8000 - (msec) * 1000 / 725); |
| |
| /* delay time = 0x8000 - msec/92 */ |
| static int |
| calc_parm_hold(int msec) |
| { |
| int val = (0x7f * 92 - msec) / 92; |
| if (val < 1) val = 1; |
| if (val > 127) val = 127; |
| return val; |
| } |
| |
| /* attack time: search from time table */ |
| static int |
| calc_parm_attack(int msec) |
| { |
| return calc_parm_search(msec, attack_time_tbl); |
| } |
| |
| /* decay/release time: search from time table */ |
| static int |
| calc_parm_decay(int msec) |
| { |
| return calc_parm_search(msec, decay_time_tbl); |
| } |
| |
| /* search an index for specified time from given time table */ |
| static int |
| calc_parm_search(int msec, short *table) |
| { |
| int left = 1, right = 127, mid; |
| while (left < right) { |
| mid = (left + right) / 2; |
| if (msec < (int)table[mid]) |
| left = mid + 1; |
| else |
| right = mid; |
| } |
| return left; |
| } |
| #endif /* AWE_HAS_GUS_COMPATIBILITY */ |
| |
| |
| /* |
| * effects table |
| */ |
| |
| /* set an effect value */ |
| #define FX_FLAG_OFF 0 |
| #define FX_FLAG_SET 1 |
| #define FX_FLAG_ADD 2 |
| |
| #define FX_SET(rec,type,value) \ |
| ((rec)->flags[type] = FX_FLAG_SET, (rec)->val[type] = (value)) |
| #define FX_ADD(rec,type,value) \ |
| ((rec)->flags[type] = FX_FLAG_ADD, (rec)->val[type] = (value)) |
| #define FX_UNSET(rec,type) \ |
| ((rec)->flags[type] = FX_FLAG_OFF, (rec)->val[type] = 0) |
| |
| /* check the effect value is set */ |
| #define FX_ON(rec,type) ((rec)->flags[type]) |
| |
| #define PARM_BYTE 0 |
| #define PARM_WORD 1 |
| #define PARM_SIGN 2 |
| |
| static struct PARM_DEFS { |
| int type; /* byte or word */ |
| int low, high; /* value range */ |
| fx_affect_func realtime; /* realtime paramater change */ |
| } parm_defs[] = { |
| {PARM_WORD, 0, 0x8000, NULL}, /* env1 delay */ |
| {PARM_BYTE, 1, 0x7f, NULL}, /* env1 attack */ |
| {PARM_BYTE, 0, 0x7e, NULL}, /* env1 hold */ |
| {PARM_BYTE, 1, 0x7f, NULL}, /* env1 decay */ |
| {PARM_BYTE, 1, 0x7f, NULL}, /* env1 release */ |
| {PARM_BYTE, 0, 0x7f, NULL}, /* env1 sustain */ |
| {PARM_BYTE, 0, 0xff, NULL}, /* env1 pitch */ |
| {PARM_BYTE, 0, 0xff, NULL}, /* env1 cutoff */ |
| |
| {PARM_WORD, 0, 0x8000, NULL}, /* env2 delay */ |
| {PARM_BYTE, 1, 0x7f, NULL}, /* env2 attack */ |
| {PARM_BYTE, 0, 0x7e, NULL}, /* env2 hold */ |
| {PARM_BYTE, 1, 0x7f, NULL}, /* env2 decay */ |
| {PARM_BYTE, 1, 0x7f, NULL}, /* env2 release */ |
| {PARM_BYTE, 0, 0x7f, NULL}, /* env2 sustain */ |
| |
| {PARM_WORD, 0, 0x8000, NULL}, /* lfo1 delay */ |
| {PARM_BYTE, 0, 0xff, awe_fx_tremfrq}, /* lfo1 freq */ |
| {PARM_SIGN, -128, 127, awe_fx_tremfrq}, /* lfo1 volume */ |
| {PARM_SIGN, -128, 127, awe_fx_fmmod}, /* lfo1 pitch */ |
| {PARM_BYTE, 0, 0xff, awe_fx_fmmod}, /* lfo1 cutoff */ |
| |
| {PARM_WORD, 0, 0x8000, NULL}, /* lfo2 delay */ |
| {PARM_BYTE, 0, 0xff, awe_fx_fm2frq2}, /* lfo2 freq */ |
| {PARM_SIGN, -128, 127, awe_fx_fm2frq2}, /* lfo2 pitch */ |
| |
| {PARM_WORD, 0, 0xffff, awe_set_voice_pitch}, /* initial pitch */ |
| {PARM_BYTE, 0, 0xff, NULL}, /* chorus */ |
| {PARM_BYTE, 0, 0xff, NULL}, /* reverb */ |
| {PARM_BYTE, 0, 0xff, awe_set_volume}, /* initial cutoff */ |
| {PARM_BYTE, 0, 15, awe_fx_filterQ}, /* initial resonance */ |
| |
| {PARM_WORD, 0, 0xffff, NULL}, /* sample start */ |
| {PARM_WORD, 0, 0xffff, NULL}, /* loop start */ |
| {PARM_WORD, 0, 0xffff, NULL}, /* loop end */ |
| {PARM_WORD, 0, 0xffff, NULL}, /* coarse sample start */ |
| {PARM_WORD, 0, 0xffff, NULL}, /* coarse loop start */ |
| {PARM_WORD, 0, 0xffff, NULL}, /* coarse loop end */ |
| {PARM_BYTE, 0, 0xff, awe_set_volume}, /* initial attenuation */ |
| }; |
| |
| |
| static unsigned char |
| FX_BYTE(FX_Rec *rec, FX_Rec *lay, int type, unsigned char value) |
| { |
| int effect = 0; |
| int on = 0; |
| if (lay && (on = FX_ON(lay, type)) != 0) |
| effect = lay->val[type]; |
| if (!on && (on = FX_ON(rec, type)) != 0) |
| effect = rec->val[type]; |
| if (on == FX_FLAG_ADD) { |
| if (parm_defs[type].type == PARM_SIGN) { |
| if (value > 0x7f) |
| effect += (int)value - 0x100; |
| else |
| effect += (int)value; |
| } else { |
| effect += (int)value; |
| } |
| } |
| if (on) { |
| if (effect < parm_defs[type].low) |
| effect = parm_defs[type].low; |
| else if (effect > parm_defs[type].high) |
| effect = parm_defs[type].high; |
| return (unsigned char)effect; |
| } |
| return value; |
| } |
| |
| /* get word effect value */ |
| static unsigned short |
| FX_WORD(FX_Rec *rec, FX_Rec *lay, int type, unsigned short value) |
| { |
| int effect = 0; |
| int on = 0; |
| if (lay && (on = FX_ON(lay, type)) != 0) |
| effect = lay->val[type]; |
| if (!on && (on = FX_ON(rec, type)) != 0) |
| effect = rec->val[type]; |
| if (on == FX_FLAG_ADD) |
| effect += (int)value; |
| if (on) { |
| if (effect < parm_defs[type].low) |
| effect = parm_defs[type].low; |
| else if (effect > parm_defs[type].high) |
| effect = parm_defs[type].high; |
| return (unsigned short)effect; |
| } |
| return value; |
| } |
| |
| /* get word (upper=type1/lower=type2) effect value */ |
| static unsigned short |
| FX_COMB(FX_Rec *rec, FX_Rec *lay, int type1, int type2, unsigned short value) |
| { |
| unsigned short tmp; |
| tmp = FX_BYTE(rec, lay, type1, (unsigned char)(value >> 8)); |
| tmp <<= 8; |
| tmp |= FX_BYTE(rec, lay, type2, (unsigned char)(value & 0xff)); |
| return tmp; |
| } |
| |
| /* address offset */ |
| static int |
| FX_OFFSET(FX_Rec *rec, FX_Rec *lay, int lo, int hi, int mode) |
| { |
| int addr = 0; |
| if (lay && FX_ON(lay, hi)) |
| addr = (short)lay->val[hi]; |
| else if (FX_ON(rec, hi)) |
| addr = (short)rec->val[hi]; |
| addr = addr << 15; |
| if (lay && FX_ON(lay, lo)) |
| addr += (short)lay->val[lo]; |
| else if (FX_ON(rec, lo)) |
| addr += (short)rec->val[lo]; |
| if (!(mode & AWE_SAMPLE_8BITS)) |
| addr /= 2; |
| return addr; |
| } |
| |
| |
| /* |
| * turn on/off sample |
| */ |
| |
| /* table for volume target calculation */ |
| static unsigned short voltarget[16] = { |
| 0xEAC0, 0XE0C8, 0XD740, 0XCE20, 0XC560, 0XBD08, 0XB500, 0XAD58, |
| 0XA5F8, 0X9EF0, 0X9830, 0X91C0, 0X8B90, 0X85A8, 0X8000, 0X7A90 |
| }; |
| |
| static void |
| awe_note_on(int voice) |
| { |
| unsigned int temp; |
| int addr; |
| int vtarget, ftarget, ptarget, pitch; |
| awe_voice_info *vp; |
| awe_voice_parm_block *parm; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| /* A voice sample must assigned before calling */ |
| if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| return; |
| |
| parm = (awe_voice_parm_block*)&vp->parm; |
| |
| /* channel to be silent and idle */ |
| awe_poke(AWE_DCYSUSV(voice), 0x0080); |
| awe_poke(AWE_VTFT(voice), 0x0000FFFF); |
| awe_poke(AWE_CVCF(voice), 0x0000FFFF); |
| awe_poke(AWE_PTRX(voice), 0); |
| awe_poke(AWE_CPF(voice), 0); |
| |
| /* set pitch offset */ |
| awe_set_pitch(voice, TRUE); |
| |
| /* modulation & volume envelope */ |
| if (parm->modatk >= 0x80 && parm->moddelay >= 0x8000) { |
| awe_poke(AWE_ENVVAL(voice), 0xBFFF); |
| pitch = (parm->env1pit<<4) + voices[voice].apitch; |
| if (pitch > 0xffff) pitch = 0xffff; |
| /* calculate filter target */ |
| ftarget = parm->cutoff + parm->env1fc; |
| limitvalue(ftarget, 0, 255); |
| ftarget <<= 8; |
| } else { |
| awe_poke(AWE_ENVVAL(voice), |
| FX_WORD(fx, fx_lay, AWE_FX_ENV1_DELAY, parm->moddelay)); |
| ftarget = parm->cutoff; |
| ftarget <<= 8; |
| pitch = voices[voice].apitch; |
| } |
| |
| /* calcualte pitch target */ |
| if (pitch != 0xffff) { |
| ptarget = 1 << (pitch >> 12); |
| if (pitch & 0x800) ptarget += (ptarget*0x102e)/0x2710; |
| if (pitch & 0x400) ptarget += (ptarget*0x764)/0x2710; |
| if (pitch & 0x200) ptarget += (ptarget*0x389)/0x2710; |
| ptarget += (ptarget>>1); |
| if (ptarget > 0xffff) ptarget = 0xffff; |
| |
| } else ptarget = 0xffff; |
| if (parm->modatk >= 0x80) |
| awe_poke(AWE_ATKHLD(voice), |
| FX_BYTE(fx, fx_lay, AWE_FX_ENV1_HOLD, parm->modhld) << 8 | 0x7f); |
| else |
| awe_poke(AWE_ATKHLD(voice), |
| FX_COMB(fx, fx_lay, AWE_FX_ENV1_HOLD, AWE_FX_ENV1_ATTACK, |
| vp->parm.modatkhld)); |
| awe_poke(AWE_DCYSUS(voice), |
| FX_COMB(fx, fx_lay, AWE_FX_ENV1_SUSTAIN, AWE_FX_ENV1_DECAY, |
| vp->parm.moddcysus)); |
| |
| if (parm->volatk >= 0x80 && parm->voldelay >= 0x8000) { |
| awe_poke(AWE_ENVVOL(voice), 0xBFFF); |
| vtarget = voltarget[voices[voice].avol%0x10]>>(voices[voice].avol>>4); |
| } else { |
| awe_poke(AWE_ENVVOL(voice), |
| FX_WORD(fx, fx_lay, AWE_FX_ENV2_DELAY, vp->parm.voldelay)); |
| vtarget = 0; |
| } |
| if (parm->volatk >= 0x80) |
| awe_poke(AWE_ATKHLDV(voice), |
| FX_BYTE(fx, fx_lay, AWE_FX_ENV2_HOLD, parm->volhld) << 8 | 0x7f); |
| else |
| awe_poke(AWE_ATKHLDV(voice), |
| FX_COMB(fx, fx_lay, AWE_FX_ENV2_HOLD, AWE_FX_ENV2_ATTACK, |
| vp->parm.volatkhld)); |
| /* decay/sustain parameter for volume envelope must be set at last */ |
| |
| /* cutoff and volume */ |
| awe_set_volume(voice, TRUE); |
| |
| /* modulation envelope heights */ |
| awe_poke(AWE_PEFE(voice), |
| FX_COMB(fx, fx_lay, AWE_FX_ENV1_PITCH, AWE_FX_ENV1_CUTOFF, |
| vp->parm.pefe)); |
| |
| /* lfo1/2 delay */ |
| awe_poke(AWE_LFO1VAL(voice), |
| FX_WORD(fx, fx_lay, AWE_FX_LFO1_DELAY, vp->parm.lfo1delay)); |
| awe_poke(AWE_LFO2VAL(voice), |
| FX_WORD(fx, fx_lay, AWE_FX_LFO2_DELAY, vp->parm.lfo2delay)); |
| |
| /* lfo1 pitch & cutoff shift */ |
| awe_fx_fmmod(voice, TRUE); |
| /* lfo1 volume & freq */ |
| awe_fx_tremfrq(voice, TRUE); |
| /* lfo2 pitch & freq */ |
| awe_fx_fm2frq2(voice, TRUE); |
| /* pan & loop start */ |
| awe_set_pan(voice, TRUE); |
| |
| /* chorus & loop end (chorus 8bit, MSB) */ |
| addr = vp->loopend - 1; |
| addr += FX_OFFSET(fx, fx_lay, AWE_FX_LOOP_END, |
| AWE_FX_COARSE_LOOP_END, vp->mode); |
| temp = FX_BYTE(fx, fx_lay, AWE_FX_CHORUS, vp->parm.chorus); |
| temp = (temp <<24) | (unsigned int)addr; |
| awe_poke_dw(AWE_CSL(voice), temp); |
| DEBUG(4,printk("AWE32: [-- loopend=%x/%x]\n", vp->loopend, addr)); |
| |
| /* Q & current address (Q 4bit value, MSB) */ |
| addr = vp->start - 1; |
| addr += FX_OFFSET(fx, fx_lay, AWE_FX_SAMPLE_START, |
| AWE_FX_COARSE_SAMPLE_START, vp->mode); |
| temp = FX_BYTE(fx, fx_lay, AWE_FX_FILTERQ, vp->parm.filterQ); |
| temp = (temp<<28) | (unsigned int)addr; |
| awe_poke_dw(AWE_CCCA(voice), temp); |
| DEBUG(4,printk("AWE32: [-- startaddr=%x/%x]\n", vp->start, addr)); |
| |
| /* clear unknown registers */ |
| awe_poke_dw(AWE_00A0(voice), 0); |
| awe_poke_dw(AWE_0080(voice), 0); |
| |
| /* reset volume */ |
| awe_poke_dw(AWE_VTFT(voice), (vtarget<<16)|ftarget); |
| awe_poke_dw(AWE_CVCF(voice), (vtarget<<16)|ftarget); |
| |
| /* set reverb */ |
| temp = FX_BYTE(fx, fx_lay, AWE_FX_REVERB, vp->parm.reverb); |
| temp = (temp << 8) | (ptarget << 16) | voices[voice].aaux; |
| awe_poke_dw(AWE_PTRX(voice), temp); |
| awe_poke_dw(AWE_CPF(voice), ptarget << 16); |
| /* turn on envelope */ |
| awe_poke(AWE_DCYSUSV(voice), |
| FX_COMB(fx, fx_lay, AWE_FX_ENV2_SUSTAIN, AWE_FX_ENV2_DECAY, |
| vp->parm.voldcysus)); |
| |
| voices[voice].state = AWE_ST_ON; |
| |
| /* clear voice position for the next note on this channel */ |
| if (SINGLE_LAYER_MODE()) { |
| FX_UNSET(fx, AWE_FX_SAMPLE_START); |
| FX_UNSET(fx, AWE_FX_COARSE_SAMPLE_START); |
| } |
| } |
| |
| |
| /* turn off the voice */ |
| static void |
| awe_note_off(int voice) |
| { |
| awe_voice_info *vp; |
| unsigned short tmp; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| if ((vp = voices[voice].sample) == NULL) { |
| voices[voice].state = AWE_ST_OFF; |
| return; |
| } |
| |
| tmp = 0x8000 | FX_BYTE(fx, fx_lay, AWE_FX_ENV1_RELEASE, |
| (unsigned char)vp->parm.modrelease); |
| awe_poke(AWE_DCYSUS(voice), tmp); |
| tmp = 0x8000 | FX_BYTE(fx, fx_lay, AWE_FX_ENV2_RELEASE, |
| (unsigned char)vp->parm.volrelease); |
| awe_poke(AWE_DCYSUSV(voice), tmp); |
| voices[voice].state = AWE_ST_RELEASED; |
| } |
| |
| /* force to terminate the voice (no releasing echo) */ |
| static void |
| awe_terminate(int voice) |
| { |
| awe_poke(AWE_DCYSUSV(voice), 0x807F); |
| awe_tweak_voice(voice); |
| voices[voice].state = AWE_ST_OFF; |
| } |
| |
| /* turn off other voices with the same exclusive class (for drums) */ |
| static void |
| awe_exclusive_off(int voice) |
| { |
| int i, exclass; |
| |
| if (voices[voice].sample == NULL) |
| return; |
| if ((exclass = voices[voice].sample->exclusiveClass) == 0) |
| return; /* not exclusive */ |
| |
| /* turn off voices with the same class */ |
| for (i = 0; i < awe_max_voices; i++) { |
| if (i != voice && IS_PLAYING(i) && |
| voices[i].sample && voices[i].ch == voices[voice].ch && |
| voices[i].sample->exclusiveClass == exclass) { |
| DEBUG(4,printk("AWE32: [exoff(%d)]\n", i)); |
| awe_terminate(i); |
| awe_voice_init(i, TRUE); |
| } |
| } |
| } |
| |
| |
| /* |
| * change the parameters of an audible voice |
| */ |
| |
| /* change pitch */ |
| static void |
| awe_set_pitch(int voice, int forced) |
| { |
| if (IS_NO_EFFECT(voice) && !forced) return; |
| awe_poke(AWE_IP(voice), voices[voice].apitch); |
| DEBUG(3,printk("AWE32: [-- pitch=%x]\n", voices[voice].apitch)); |
| } |
| |
| /* calculate & change pitch */ |
| static void |
| awe_set_voice_pitch(int voice, int forced) |
| { |
| awe_calc_pitch(voice); |
| awe_set_pitch(voice, forced); |
| } |
| |
| /* change volume & cutoff */ |
| static void |
| awe_set_volume(int voice, int forced) |
| { |
| awe_voice_info *vp; |
| unsigned short tmp2; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| if (!IS_PLAYING(voice) && !forced) return; |
| if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| return; |
| |
| tmp2 = FX_BYTE(fx, fx_lay, AWE_FX_CUTOFF, |
| (unsigned char)voices[voice].acutoff); |
| tmp2 = (tmp2 << 8); |
| tmp2 |= FX_BYTE(fx, fx_lay, AWE_FX_ATTEN, |
| (unsigned char)voices[voice].avol); |
| awe_poke(AWE_IFATN(voice), tmp2); |
| } |
| |
| /* calculate & change volume */ |
| static void |
| awe_set_voice_vol(int voice, int forced) |
| { |
| if (IS_EMPTY(voice)) |
| return; |
| awe_calc_volume(voice); |
| awe_set_volume(voice, forced); |
| } |
| |
| |
| /* change pan; this could make a click noise.. */ |
| static void |
| awe_set_pan(int voice, int forced) |
| { |
| unsigned int temp; |
| int addr; |
| awe_voice_info *vp; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| if (IS_NO_EFFECT(voice) && !forced) return; |
| if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| return; |
| |
| /* pan & loop start (pan 8bit, MSB, 0:right, 0xff:left) */ |
| if (vp->fixpan > 0) /* 0-127 */ |
| temp = 255 - (int)vp->fixpan * 2; |
| else { |
| int pos = 0; |
| if (vp->pan >= 0) /* 0-127 */ |
| pos = (int)vp->pan * 2 - 128; |
| pos += voices[voice].cinfo->panning; /* -128 - 127 */ |
| temp = 127 - pos; |
| } |
| limitvalue(temp, 0, 255); |
| if (ctrls[AWE_MD_PAN_EXCHANGE]) { |
| temp = 255 - temp; |
| } |
| if (forced || temp != voices[voice].apan) { |
| voices[voice].apan = temp; |
| if (temp == 0) |
| voices[voice].aaux = 0xff; |
| else |
| voices[voice].aaux = (-temp) & 0xff; |
| addr = vp->loopstart - 1; |
| addr += FX_OFFSET(fx, fx_lay, AWE_FX_LOOP_START, |
| AWE_FX_COARSE_LOOP_START, vp->mode); |
| temp = (temp<<24) | (unsigned int)addr; |
| awe_poke_dw(AWE_PSST(voice), temp); |
| DEBUG(4,printk("AWE32: [-- loopstart=%x/%x]\n", vp->loopstart, addr)); |
| } |
| } |
| |
| /* effects change during playing */ |
| static void |
| awe_fx_fmmod(int voice, int forced) |
| { |
| awe_voice_info *vp; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| if (IS_NO_EFFECT(voice) && !forced) return; |
| if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| return; |
| awe_poke(AWE_FMMOD(voice), |
| FX_COMB(fx, fx_lay, AWE_FX_LFO1_PITCH, AWE_FX_LFO1_CUTOFF, |
| vp->parm.fmmod)); |
| } |
| |
| /* set tremolo (lfo1) volume & frequency */ |
| static void |
| awe_fx_tremfrq(int voice, int forced) |
| { |
| awe_voice_info *vp; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| if (IS_NO_EFFECT(voice) && !forced) return; |
| if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| return; |
| awe_poke(AWE_TREMFRQ(voice), |
| FX_COMB(fx, fx_lay, AWE_FX_LFO1_VOLUME, AWE_FX_LFO1_FREQ, |
| vp->parm.tremfrq)); |
| } |
| |
| /* set lfo2 pitch & frequency */ |
| static void |
| awe_fx_fm2frq2(int voice, int forced) |
| { |
| awe_voice_info *vp; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| if (IS_NO_EFFECT(voice) && !forced) return; |
| if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| return; |
| awe_poke(AWE_FM2FRQ2(voice), |
| FX_COMB(fx, fx_lay, AWE_FX_LFO2_PITCH, AWE_FX_LFO2_FREQ, |
| vp->parm.fm2frq2)); |
| } |
| |
| |
| /* Q & current address (Q 4bit value, MSB) */ |
| static void |
| awe_fx_filterQ(int voice, int forced) |
| { |
| unsigned int addr; |
| awe_voice_info *vp; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| if (IS_NO_EFFECT(voice) && !forced) return; |
| if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| return; |
| |
| addr = awe_peek_dw(AWE_CCCA(voice)) & 0xffffff; |
| addr |= (FX_BYTE(fx, fx_lay, AWE_FX_FILTERQ, vp->parm.filterQ) << 28); |
| awe_poke_dw(AWE_CCCA(voice), addr); |
| } |
| |
| /* |
| * calculate pitch offset |
| * |
| * 0xE000 is no pitch offset at 44100Hz sample. |
| * Every 4096 is one octave. |
| */ |
| |
| static void |
| awe_calc_pitch(int voice) |
| { |
| voice_info *vp = &voices[voice]; |
| awe_voice_info *ap; |
| awe_chan_info *cp = voices[voice].cinfo; |
| int offset; |
| |
| /* search voice information */ |
| if ((ap = vp->sample) == NULL) |
| return; |
| if (ap->index == 0) { |
| DEBUG(3,printk("AWE32: set sample (%d)\n", ap->sample)); |
| if (awe_set_sample((awe_voice_list*)ap) == 0) |
| return; |
| } |
| |
| /* calculate offset */ |
| if (ap->fixkey >= 0) { |
| DEBUG(3,printk("AWE32: p-> fixkey(%d) tune(%d)\n", ap->fixkey, ap->tune)); |
| offset = (ap->fixkey - ap->root) * 4096 / 12; |
| } else { |
| DEBUG(3,printk("AWE32: p(%d)-> root(%d) tune(%d)\n", vp->note, ap->root, ap->tune)); |
| offset = (vp->note - ap->root) * 4096 / 12; |
| DEBUG(4,printk("AWE32: p-> ofs=%d\n", offset)); |
| } |
| offset = (offset * ap->scaleTuning) / 100; |
| DEBUG(4,printk("AWE32: p-> scale* ofs=%d\n", offset)); |
| offset += ap->tune * 4096 / 1200; |
| DEBUG(4,printk("AWE32: p-> tune+ ofs=%d\n", offset)); |
| if (cp->bender != 0) { |
| DEBUG(3,printk("AWE32: p-> bend(%d) %d\n", voice, cp->bender)); |
| /* (819200: 1 semitone) ==> (4096: 12 semitones) */ |
| offset += cp->bender * cp->bender_range / 2400; |
| } |
| |
| /* add initial pitch correction */ |
| if (FX_ON(&cp->fx_layer[vp->layer], AWE_FX_INIT_PITCH)) |
| offset += cp->fx_layer[vp->layer].val[AWE_FX_INIT_PITCH]; |
| else if (FX_ON(&cp->fx, AWE_FX_INIT_PITCH)) |
| offset += cp->fx.val[AWE_FX_INIT_PITCH]; |
| |
| /* 0xe000: root pitch */ |
| vp->apitch = 0xe000 + ap->rate_offset + offset; |
| DEBUG(4,printk("AWE32: p-> sum aofs=%x, rate_ofs=%d\n", vp->apitch, ap->rate_offset)); |
| if (vp->apitch > 0xffff) |
| vp->apitch = 0xffff; |
| if (vp->apitch < 0) |
| vp->apitch = 0; |
| } |
| |
| |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| /* calculate MIDI key and semitone from the specified frequency */ |
| static void |
| awe_calc_pitch_from_freq(int voice, int freq) |
| { |
| voice_info *vp = &voices[voice]; |
| awe_voice_info *ap; |
| FX_Rec *fx = &voices[voice].cinfo->fx; |
| FX_Rec *fx_lay = NULL; |
| int offset; |
| int note; |
| |
| if (voices[voice].layer < MAX_LAYERS) |
| fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| |
| /* search voice information */ |
| if ((ap = vp->sample) == NULL) |
| return; |
| if (ap->index == 0) { |
| DEBUG(3,printk("AWE32: set sample (%d)\n", ap->sample)); |
| if (awe_set_sample((awe_voice_list*)ap) == 0) |
| return; |
| } |
| note = freq_to_note(freq); |
| offset = (note - ap->root * 100 + ap->tune) * 4096 / 1200; |
| offset = (offset * ap->scaleTuning) / 100; |
| if (fx_lay && FX_ON(fx_lay, AWE_FX_INIT_PITCH)) |
| offset += fx_lay->val[AWE_FX_INIT_PITCH]; |
| else if (FX_ON(fx, AWE_FX_INIT_PITCH)) |
| offset += fx->val[AWE_FX_INIT_PITCH]; |
| vp->apitch = 0xe000 + ap->rate_offset + offset; |
| if (vp->apitch > 0xffff) |
| vp->apitch = 0xffff; |
| if (vp->apitch < 0) |
| vp->apitch = 0; |
| } |
| #endif /* AWE_HAS_GUS_COMPATIBILITY */ |
| |
| |
| /* |
| * calculate volume attenuation |
| * |
| * Voice volume is controlled by volume attenuation parameter. |
| * So volume becomes maximum when avol is 0 (no attenuation), and |
| * minimum when 255 (-96dB or silence). |
| */ |
| |
| static int vol_table[128] = { |
| 255,111,95,86,79,74,70,66,63,61,58,56,54,52,50,49, |
| 47,46,45,43,42,41,40,39,38,37,36,35,34,34,33,32, |
| 31,31,30,29,29,28,27,27,26,26,25,24,24,23,23,22, |
| 22,21,21,21,20,20,19,19,18,18,18,17,17,16,16,16, |
| 15,15,15,14,14,14,13,13,13,12,12,12,11,11,11,10, |
| 10,10,10,9,9,9,8,8,8,8,7,7,7,7,6,6, |
| 6,6,5,5,5,5,5,4,4,4,4,3,3,3,3,3, |
| 2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,0, |
| }; |
| |
| /* tables for volume->attenuation calculation */ |
| static unsigned char voltab1[128] = { |
| 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, |
| 0x63, 0x2b, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, |
| 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, |
| 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, |
| 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, |
| 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, |
| 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, |
| 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, |
| 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, |
| 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, |
| 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, |
| 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, |
| 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }; |
| |
| static unsigned char voltab2[128] = { |
| 0x32, 0x31, 0x30, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x2a, |
| 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21, |
| 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, |
| 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x16, 0x16, 0x15, 0x15, |
| 0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x10, |
| 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, |
| 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, |
| 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, |
| 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, |
| 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, |
| 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, |
| 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, |
| 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }; |
| |
| static unsigned char expressiontab[128] = { |
| 0x7f, 0x6c, 0x62, 0x5a, 0x54, 0x50, 0x4b, 0x48, 0x45, 0x42, |
| 0x40, 0x3d, 0x3b, 0x39, 0x38, 0x36, 0x34, 0x33, 0x31, 0x30, |
| 0x2f, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25, |
| 0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x20, 0x1f, 0x1e, 0x1e, |
| 0x1d, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x18, |
| 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13, |
| 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f, |
| 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, |
| 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, |
| 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, |
| 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, |
| 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, |
| 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| }; |
| |
| static void |
| awe_calc_volume(int voice) |
| { |
| voice_info *vp = &voices[voice]; |
| awe_voice_info *ap; |
| awe_chan_info *cp = voices[voice].cinfo; |
| int vol; |
| |
| /* search voice information */ |
| if ((ap = vp->sample) == NULL) |
| return; |
| |
| ap = vp->sample; |
| if (ap->index == 0) { |
| DEBUG(3,printk("AWE32: set sample (%d)\n", ap->sample)); |
| if (awe_set_sample((awe_voice_list*)ap) == 0) |
| return; |
| } |
| |
| if (ctrls[AWE_MD_NEW_VOLUME_CALC]) { |
| int main_vol = cp->main_vol * ap->amplitude / 127; |
| limitvalue(vp->velocity, 0, 127); |
| limitvalue(main_vol, 0, 127); |
| limitvalue(cp->expression_vol, 0, 127); |
| |
| vol = voltab1[main_vol] + voltab2[vp->velocity]; |
| vol = (vol * 8) / 3; |
| vol += ap->attenuation; |
| if (cp->expression_vol < 127) |
| vol += ((0x100 - vol) * expressiontab[cp->expression_vol])/128; |
| vol += atten_offset; |
| if (atten_relative) |
| vol += ctrls[AWE_MD_ZERO_ATTEN]; |
| limitvalue(vol, 0, 255); |
| vp->avol = vol; |
| |
| } else { |
| /* 0 - 127 */ |
| vol = (vp->velocity * cp->main_vol * cp->expression_vol) / (127*127); |
| vol = vol * ap->amplitude / 127; |
| |
| if (vol < 0) vol = 0; |
| if (vol > 127) vol = 127; |
| |
| /* calc to attenuation */ |
| vol = vol_table[vol]; |
| vol += (int)ap->attenuation; |
| vol += atten_offset; |
| if (atten_relative) |
| vol += ctrls[AWE_MD_ZERO_ATTEN]; |
| if (vol > 255) vol = 255; |
| |
| vp->avol = vol; |
| } |
| if (cp->bank != AWE_DRUM_BANK && ((awe_voice_parm_block*)(&ap->parm))->volatk < 0x7d) { |
| int atten; |
| if (vp->velocity < 70) atten = 70; |
| else atten = vp->velocity; |
| vp->acutoff = (atten * ap->parm.cutoff + 0xa0) >> 7; |
| } else { |
| vp->acutoff = ap->parm.cutoff; |
| } |
| DEBUG(3,printk("AWE32: [-- voice(%d) vol=%x]\n", voice, vol)); |
| } |
| |
| /* change master volume */ |
| static void |
| awe_change_master_volume(short val) |
| { |
| limitvalue(val, 0, 127); |
| atten_offset = vol_table[val]; |
| atten_relative = TRUE; |
| awe_update_volume(); |
| } |
| |
| /* update volumes of all available channels */ |
| static void awe_update_volume(void) |
| { |
| int i; |
| for (i = 0; i < awe_max_voices; i++) |
| awe_set_voice_vol(i, TRUE); |
| } |
| |
| /* set sostenuto on */ |
| static void awe_sostenuto_on(int voice, int forced) |
| { |
| if (IS_NO_EFFECT(voice) && !forced) return; |
| voices[voice].sostenuto = 127; |
| } |
| |
| |
| /* drop sustain */ |
| static void awe_sustain_off(int voice, int forced) |
| { |
| if (voices[voice].state == AWE_ST_SUSTAINED) { |
| awe_note_off(voice); |
| awe_fx_init(voices[voice].ch); |
| awe_voice_init(voice, FALSE); |
| } |
| } |
| |
| |
| /* terminate and initialize voice */ |
| static void awe_terminate_and_init(int voice, int forced) |
| { |
| awe_terminate(voice); |
| awe_fx_init(voices[voice].ch); |
| awe_voice_init(voice, TRUE); |
| } |
| |
| |
| /* |
| * synth operation routines |
| */ |
| |
| #define AWE_VOICE_KEY(v) (0x8000 | (v)) |
| #define AWE_CHAN_KEY(c,n) (((c) << 8) | ((n) + 1)) |
| #define KEY_CHAN_MATCH(key,c) (((key) >> 8) == (c)) |
| |
| /* initialize the voice */ |
| static void |
| awe_voice_init(int voice, int init_all) |
| { |
| voice_info *vp = &voices[voice]; |
| |
| /* reset voice search key */ |
| if (playing_mode == AWE_PLAY_DIRECT) |
| vp->key = AWE_VOICE_KEY(voice); |
| else |
| vp->key = 0; |
| |
| /* clear voice mapping */ |
| voice_alloc->map[voice] = 0; |
| |
| /* touch the timing flag */ |
| vp->time = current_alloc_time; |
| |
| /* initialize other parameters if necessary */ |
| if (init_all) { |
| vp->note = -1; |
| vp->velocity = 0; |
| vp->sostenuto = 0; |
| |
| vp->sample = NULL; |
| vp->cinfo = &channels[voice]; |
| vp->ch = voice; |
| vp->state = AWE_ST_OFF; |
| |
| /* emu8000 parameters */ |
| vp->apitch = 0; |
| vp->avol = 255; |
| vp->apan = -1; |
| } |
| } |
| |
| /* clear effects */ |
| static void awe_fx_init(int ch) |
| { |
| if (SINGLE_LAYER_MODE() && !ctrls[AWE_MD_KEEP_EFFECT]) { |
| memset(&channels[ch].fx, 0, sizeof(channels[ch].fx)); |
| memset(&channels[ch].fx_layer, 0, sizeof(&channels[ch].fx_layer)); |
| } |
| } |
| |
| /* initialize channel info */ |
| static void awe_channel_init(int ch, int init_all) |
| { |
| awe_chan_info *cp = &channels[ch]; |
| cp->channel = ch; |
| if (init_all) { |
| cp->panning = 0; /* zero center */ |
| cp->bender_range = 200; /* sense * 100 */ |
| cp->main_vol = 127; |
| if (MULTI_LAYER_MODE() && IS_DRUM_CHANNEL(ch)) { |
| cp->instr = ctrls[AWE_MD_DEF_DRUM]; |
| cp->bank = AWE_DRUM_BANK; |
| } else { |
| cp->instr = ctrls[AWE_MD_DEF_PRESET]; |
| cp->bank = ctrls[AWE_MD_DEF_BANK]; |
| } |
| } |
| |
| cp->bender = 0; /* zero tune skew */ |
| cp->expression_vol = 127; |
| cp->chan_press = 0; |
| cp->sustained = 0; |
| |
| if (! ctrls[AWE_MD_KEEP_EFFECT]) { |
| memset(&cp->fx, 0, sizeof(cp->fx)); |
| memset(&cp->fx_layer, 0, sizeof(cp->fx_layer)); |
| } |
| } |
| |
| |
| /* change the voice parameters; voice = channel */ |
| static void awe_voice_change(int voice, fx_affect_func func) |
| { |
| int i; |
| switch (playing_mode) { |
| case AWE_PLAY_DIRECT: |
| func(voice, FALSE); |
| break; |
| case AWE_PLAY_INDIRECT: |
| for (i = 0; i < awe_max_voices; i++) |
| if (voices[i].key == AWE_VOICE_KEY(voice)) |
| func(i, FALSE); |
| break; |
| default: |
| for (i = 0; i < awe_max_voices; i++) |
| if (KEY_CHAN_MATCH(voices[i].key, voice)) |
| func(i, FALSE); |
| break; |
| } |
| } |
| |
| |
| /* |
| * device open / close |
| */ |
| |
| /* open device: |
| * reset status of all voices, and clear sample position flag |
| */ |
| static int |
| awe_open(int dev, int mode) |
| { |
| if (awe_busy) |
| return -EBUSY; |
| |
| awe_busy = TRUE; |
| |
| /* set default mode */ |
| awe_init_ctrl_parms(FALSE); |
| atten_relative = TRUE; |
| atten_offset = 0; |
| drum_flags = DEFAULT_DRUM_FLAGS; |
| playing_mode = AWE_PLAY_INDIRECT; |
| |
| /* reset voices & channels */ |
| awe_reset(dev); |
| |
| patch_opened = 0; |
| |
| return 0; |
| } |
| |
| |
| /* close device: |
| * reset all voices again (terminate sounds) |
| */ |
| static void |
| awe_close(int dev) |
| { |
| awe_reset(dev); |
| awe_busy = FALSE; |
| } |
| |
| |
| /* set miscellaneous mode parameters |
| */ |
| static void |
| awe_init_ctrl_parms(int init_all) |
| { |
| int i; |
| for (i = 0; i < AWE_MD_END; i++) { |
| if (init_all || ctrl_parms[i].init_each_time) |
| ctrls[i] = ctrl_parms[i].value; |
| } |
| } |
| |
| |
| /* sequencer I/O control: |
| */ |
| static int |
| awe_ioctl(int dev, unsigned int cmd, void __user *arg) |
| { |
| switch (cmd) { |
| case SNDCTL_SYNTH_INFO: |
| if (playing_mode == AWE_PLAY_DIRECT) |
| awe_info.nr_voices = awe_max_voices; |
| else |
| awe_info.nr_voices = AWE_MAX_CHANNELS; |
| if (copy_to_user(arg, &awe_info, sizeof(awe_info))) |
| return -EFAULT; |
| return 0; |
| break; |
| |
| case SNDCTL_SEQ_RESETSAMPLES: |
| awe_reset(dev); |
| awe_reset_samples(); |
| return 0; |
| break; |
| |
| case SNDCTL_SEQ_PERCMODE: |
| /* what's this? */ |
| return 0; |
| break; |
| |
| case SNDCTL_SYNTH_MEMAVL: |
| return memsize - awe_free_mem_ptr() * 2; |
| break; |
| |
| default: |
| printk(KERN_WARNING "AWE32: unsupported ioctl %d\n", cmd); |
| return -EINVAL; |
| break; |
| } |
| } |
| |
| |
| static int voice_in_range(int voice) |
| { |
| if (playing_mode == AWE_PLAY_DIRECT) { |
| if (voice < 0 || voice >= awe_max_voices) |
| return FALSE; |
| } else { |
| if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| static void release_voice(int voice, int do_sustain) |
| { |
| if (IS_NO_SOUND(voice)) |
| return; |
| if (do_sustain && (voices[voice].cinfo->sustained == 127 || |
| voices[voice].sostenuto == 127)) |
| voices[voice].state = AWE_ST_SUSTAINED; |
| else { |
| awe_note_off(voice); |
| awe_fx_init(voices[voice].ch); |
| awe_voice_init(voice, FALSE); |
| } |
| } |
| |
| /* release all notes */ |
| static void awe_note_off_all(int do_sustain) |
| { |
| int i; |
| for (i = 0; i < awe_max_voices; i++) |
| release_voice(i, do_sustain); |
| } |
| |
| /* kill a voice: |
| * not terminate, just release the voice. |
| */ |
| static int |
| awe_kill_note(int dev, int voice, int note, int velocity) |
| { |
| int i, v2, key; |
| |
| DEBUG(2,printk("AWE32: [off(%d) nt=%d vl=%d]\n", voice, note, velocity)); |
| if (! voice_in_range(voice)) |
| return -EINVAL; |
| |
| switch (playing_mode) { |
| case AWE_PLAY_DIRECT: |
| case AWE_PLAY_INDIRECT: |
| key = AWE_VOICE_KEY(voice); |
| break; |
| |
| case AWE_PLAY_MULTI2: |
| v2 = voice_alloc->map[voice] >> 8; |
| voice_alloc->map[voice] = 0; |
| voice = v2; |
| if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| return -EINVAL; |
| /* continue to below */ |
| default: |
| key = AWE_CHAN_KEY(voice, note); |
| break; |
| } |
| |
| for (i = 0; i < awe_max_voices; i++) { |
| if (voices[i].key == key) |
| release_voice(i, TRUE); |
| } |
| return 0; |
| } |
| |
| |
| static void start_or_volume_change(int voice, int velocity) |
| { |
| voices[voice].velocity = velocity; |
| awe_calc_volume(voice); |
| if (voices[voice].state == AWE_ST_STANDBY) |
| awe_note_on(voice); |
| else if (voices[voice].state == AWE_ST_ON) |
| awe_set_volume(voice, FALSE); |
| } |
| |
| static void set_and_start_voice(int voice, int state) |
| { |
| /* calculate pitch & volume parameters */ |
| voices[voice].state = state; |
| awe_calc_pitch(voice); |
| awe_calc_volume(voice); |
| if (state == AWE_ST_ON) |
| awe_note_on(voice); |
| } |
| |
| /* start a voice: |
| * if note is 255, identical with aftertouch function. |
| * Otherwise, start a voice with specified not and volume. |
| */ |
| static int |
| awe_start_note(int dev, int voice, int note, int velocity) |
| { |
| int i, key, state, volonly; |
| |
| DEBUG(2,printk("AWE32: [on(%d) nt=%d vl=%d]\n", voice, note, velocity)); |
| if (! voice_in_range(voice)) |
| return -EINVAL; |
| |
| if (velocity == 0) |
| state = AWE_ST_STANDBY; /* stand by for playing */ |
| else |
| state = AWE_ST_ON; /* really play */ |
| volonly = FALSE; |
| |
| switch (playing_mode) { |
| case AWE_PLAY_DIRECT: |
| case AWE_PLAY_INDIRECT: |
| key = AWE_VOICE_KEY(voice); |
| if (note == 255) |
| volonly = TRUE; |
| break; |
| |
| case AWE_PLAY_MULTI2: |
| voice = voice_alloc->map[voice] >> 8; |
| if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| return -EINVAL; |
| /* continue to below */ |
| default: |
| if (note >= 128) { /* key volume mode */ |
| note -= 128; |
| volonly = TRUE; |
| } |
| key = AWE_CHAN_KEY(voice, note); |
| break; |
| } |
| |
| /* dynamic volume change */ |
| if (volonly) { |
| for (i = 0; i < awe_max_voices; i++) { |
| if (voices[i].key == key) |
| start_or_volume_change(i, velocity); |
| } |
| return 0; |
| } |
| |
| /* if the same note still playing, stop it */ |
| if (playing_mode != AWE_PLAY_DIRECT || ctrls[AWE_MD_EXCLUSIVE_SOUND]) { |
| for (i = 0; i < awe_max_voices; i++) |
| if (voices[i].key == key) { |
| if (voices[i].state == AWE_ST_ON) { |
| awe_note_off(i); |
| awe_voice_init(i, FALSE); |
| } else if (voices[i].state == AWE_ST_STANDBY) |
| awe_voice_init(i, TRUE); |
| } |
| } |
| |
| /* allocate voices */ |
| if (playing_mode == AWE_PLAY_DIRECT) |
| awe_alloc_one_voice(voice, note, velocity); |
| else |
| awe_alloc_multi_voices(voice, note, velocity, key); |
| |
| /* turn off other voices exlusively (for drums) */ |
| for (i = 0; i < awe_max_voices; i++) |
| if (voices[i].key == key) |
| awe_exclusive_off(i); |
| |
| /* set up pitch and volume parameters */ |
| for (i = 0; i < awe_max_voices; i++) { |
| if (voices[i].key == key && voices[i].state == AWE_ST_OFF) |
| set_and_start_voice(i, state); |
| } |
| |
| return 0; |
| } |
| |
| |
| /* calculate hash key */ |
| static int |
| awe_search_key(int bank, int preset, int note) |
| { |
| unsigned int key; |
| |
| #if 1 /* new hash table */ |
| if (bank == AWE_DRUM_BANK) |
| key = preset + note + 128; |
| else |
| key = bank + preset; |
| #else |
| key = preset; |
| #endif |
| key %= AWE_MAX_PRESETS; |
| |
| return (int)key; |
| } |
| |
| |
| /* search instrument from hash table */ |
| static awe_voice_list * |
| awe_search_instr(int bank, int preset, int note) |
| { |
| awe_voice_list *p; |
| int key, key2; |
| |
| key = awe_search_key(bank, preset, note); |
| for (p = preset_table[key]; p; p = p->next_bank) { |
| if (p->instr == preset && p->bank == bank) |
| return p; |
| } |
| key2 = awe_search_key(bank, preset, 0); /* search default */ |
| if (key == key2) |
| return NULL; |
| for (p = preset_table[key2]; p; p = p->next_bank) { |
| if (p->instr == preset && p->bank == bank) |
| return p; |
| } |
| return NULL; |
| } |
| |
| |
| /* assign the instrument to a voice */ |
| static int |
| awe_set_instr_2(int dev, int voice, int instr_no) |
| { |
| if (playing_mode == AWE_PLAY_MULTI2) { |
| voice = voice_alloc->map[voice] >> 8; |
| if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| return -EINVAL; |
| } |
| return awe_set_instr(dev, voice, instr_no); |
| } |
| |
| /* assign the instrument to a channel; voice is the channel number */ |
| static int |
| awe_set_instr(int dev, int voice, int instr_no) |
| { |
| awe_chan_info *cinfo; |
| |
| if (! voice_in_range(voice)) |
| return -EINVAL; |
| |
| if (instr_no < 0 || instr_no >= AWE_MAX_PRESETS) |
| return -EINVAL; |
| |
| cinfo = &channels[voice]; |
| cinfo->instr = instr_no; |
| DEBUG(2,printk("AWE32: [program(%d) %d]\n", voice, instr_no)); |
| |
| return 0; |
| } |
| |
| |
| /* reset all voices; terminate sounds and initialize parameters */ |
| static void |
| awe_reset(int dev) |
| { |
| int i; |
| current_alloc_time = 0; |
| /* don't turn off voice 31 and 32. they are used also for FM voices */ |
| for (i = 0; i < awe_max_voices; i++) { |
| awe_terminate(i); |
| awe_voice_init(i, TRUE); |
| } |
| for (i = 0; i < AWE_MAX_CHANNELS; i++) |
| awe_channel_init(i, TRUE); |
| for (i = 0; i < 16; i++) { |
| awe_operations.chn_info[i].controllers[CTL_MAIN_VOLUME] = 127; |
| awe_operations.chn_info[i].controllers[CTL_EXPRESSION] = 127; |
| } |
| awe_init_fm(); |
| awe_tweak(); |
| } |
| |
| |
| /* hardware specific control: |
| * GUS specific and AWE32 specific controls are available. |
| */ |
| static void |
| awe_hw_control(int dev, unsigned char *event) |
| { |
| int cmd = event[2]; |
| if (cmd & _AWE_MODE_FLAG) |
| awe_hw_awe_control(dev, cmd & _AWE_MODE_VALUE_MASK, event); |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| else |
| awe_hw_gus_control(dev, cmd & _AWE_MODE_VALUE_MASK, event); |
| #endif |
| } |
| |
| |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| |
| /* GUS compatible controls */ |
| static void |
| awe_hw_gus_control(int dev, int cmd, unsigned char *event) |
| { |
| int voice, i, key; |
| unsigned short p1; |
| short p2; |
| int plong; |
| |
| if (MULTI_LAYER_MODE()) |
| return; |
| if (cmd == _GUS_NUMVOICES) |
| return; |
| |
| voice = event[3]; |
| if (! voice_in_range(voice)) |
| return; |
| |
| p1 = *(unsigned short *) &event[4]; |
| p2 = *(short *) &event[6]; |
| plong = *(int*) &event[4]; |
| |
| switch (cmd) { |
| case _GUS_VOICESAMPLE: |
| awe_set_instr(dev, voice, p1); |
| return; |
| |
| case _GUS_VOICEBALA: |
| /* 0 to 15 --> -128 to 127 */ |
| awe_panning(dev, voice, ((int)p1 << 4) - 128); |
| return; |
| |
| case _GUS_VOICEVOL: |
| case _GUS_VOICEVOL2: |
| /* not supported yet */ |
| return; |
| |
| case _GUS_RAMPRANGE: |
| case _GUS_RAMPRATE: |
| case _GUS_RAMPMODE: |
| case _GUS_RAMPON: |
| case _GUS_RAMPOFF: |
| /* volume ramping not supported */ |
| return; |
| |
| case _GUS_VOLUME_SCALE: |
| return; |
| |
| case _GUS_VOICE_POS: |
| FX_SET(&channels[voice].fx, AWE_FX_SAMPLE_START, |
| (short)(plong & 0x7fff)); |
| FX_SET(&channels[voice].fx, AWE_FX_COARSE_SAMPLE_START, |
| (plong >> 15) & 0xffff); |
| return; |
| } |
| |
| key = AWE_VOICE_KEY(voice); |
| for (i = 0; i < awe_max_voices; i++) { |
| if (voices[i].key == key) { |
| switch (cmd) { |
| case _GUS_VOICEON: |
| awe_note_on(i); |
| break; |
| |
| case _GUS_VOICEOFF: |
| awe_terminate(i); |
| awe_fx_init(voices[i].ch); |
| awe_voice_init(i, TRUE); |
| break; |
| |
| case _GUS_VOICEFADE: |
| awe_note_off(i); |
| awe_fx_init(voices[i].ch); |
| awe_voice_init(i, FALSE); |
| break; |
| |
| case _GUS_VOICEFREQ: |
| awe_calc_pitch_from_freq(i, plong); |
| break; |
| } |
| } |
| } |
| } |
| |
| #endif /* gus_compat */ |
| |
| |
| /* AWE32 specific controls */ |
| static void |
| awe_hw_awe_control(int dev, int cmd, unsigned char *event) |
| { |
| int voice; |
| unsigned short p1; |
| short p2; |
| int i; |
| |
| voice = event[3]; |
| if (! voice_in_range(voice)) |
| return; |
| |
| if (playing_mode == AWE_PLAY_MULTI2) { |
| voice = voice_alloc->map[voice] >> 8; |
| if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| return; |
| } |
| |
| p1 = *(unsigned short *) &event[4]; |
| p2 = *(short *) &event[6]; |
| |
| switch (cmd) { |
| case _AWE_DEBUG_MODE: |
| ctrls[AWE_MD_DEBUG_MODE] = p1; |
| printk(KERN_DEBUG "AWE32: debug mode = %d\n", ctrls[AWE_MD_DEBUG_MODE]); |
| break; |
| case _AWE_REVERB_MODE: |
| ctrls[AWE_MD_REVERB_MODE] = p1; |
| awe_update_reverb_mode(); |
| break; |
| |
| case _AWE_CHORUS_MODE: |
| ctrls[AWE_MD_CHORUS_MODE] = p1; |
| awe_update_chorus_mode(); |
| break; |
| |
| case _AWE_REMOVE_LAST_SAMPLES: |
| DEBUG(0,printk("AWE32: remove last samples\n")); |
| awe_reset(0); |
| if (locked_sf_id > 0) |
| awe_remove_samples(locked_sf_id); |
| break; |
| |
| case _AWE_INITIALIZE_CHIP: |
| awe_initialize(); |
| break; |
| |
| case _AWE_SEND_EFFECT: |
| i = -1; |
| if (p1 >= 0x100) { |
| i = (p1 >> 8); |
| if (i < 0 || i >= MAX_LAYERS) |
| break; |
| } |
| awe_send_effect(voice, i, p1, p2); |
| break; |
| |
| case _AWE_RESET_CHANNEL: |
| awe_channel_init(voice, !p1); |
| break; |
| |
| case _AWE_TERMINATE_ALL: |
| awe_reset(0); |
| break; |
| |
| case _AWE_TERMINATE_CHANNEL: |
| awe_voice_change(voice, awe_terminate_and_init); |
| break; |
| |
| case _AWE_RELEASE_ALL: |
| awe_note_off_all(FALSE); |
| break; |
| case _AWE_NOTEOFF_ALL: |
| awe_note_off_all(TRUE); |
| break; |
| |
| case _AWE_INITIAL_VOLUME: |
| DEBUG(0,printk("AWE32: init attenuation %d\n", p1)); |
| atten_relative = (char)p2; |
| atten_offset = (short)p1; |
| awe_update_volume(); |
| break; |
| |
| case _AWE_CHN_PRESSURE: |
| channels[voice].chan_press = p1; |
| awe_modwheel_change(voice, p1); |
| break; |
| |
| case _AWE_CHANNEL_MODE: |
| DEBUG(0,printk("AWE32: channel mode = %d\n", p1)); |
| playing_mode = p1; |
| awe_reset(0); |
| break; |
| |
| case _AWE_DRUM_CHANNELS: |
| DEBUG(0,printk("AWE32: drum flags = %x\n", p1)); |
| drum_flags = *(unsigned int*)&event[4]; |
| break; |
| |
| case _AWE_MISC_MODE: |
| DEBUG(0,printk("AWE32: ctrl parms = %d %d\n", p1, p2)); |
| if (p1 > AWE_MD_VERSION && p1 < AWE_MD_END) { |
| ctrls[p1] = p2; |
| if (ctrl_parms[p1].update) |
| ctrl_parms[p1].update(); |
| } |
| break; |
| |
| case _AWE_EQUALIZER: |
| ctrls[AWE_MD_BASS_LEVEL] = p1; |
| ctrls[AWE_MD_TREBLE_LEVEL] = p2; |
| awe_update_equalizer(); |
| break; |
| |
| default: |
| DEBUG(0,printk("AWE32: hw control cmd=%d voice=%d\n", cmd, voice)); |
| break; |
| } |
| } |
| |
| |
| /* change effects */ |
| static void |
| awe_send_effect(int voice, int layer, int type, int val) |
| { |
| awe_chan_info *cinfo; |
| FX_Rec *fx; |
| int mode; |
| |
| cinfo = &channels[voice]; |
| if (layer >= 0 && layer < MAX_LAYERS) |
| fx = &cinfo->fx_layer[layer]; |
| else |
| fx = &cinfo->fx; |
| |
| if (type & 0x40) |
| mode = FX_FLAG_OFF; |
| else if (type & 0x80) |
| mode = FX_FLAG_ADD; |
| else |
| mode = FX_FLAG_SET; |
| type &= 0x3f; |
| |
| if (type >= 0 && type < AWE_FX_END) { |
| DEBUG(2,printk("AWE32: effects (%d) %d %d\n", voice, type, val)); |
| if (mode == FX_FLAG_SET) |
| FX_SET(fx, type, val); |
| else if (mode == FX_FLAG_ADD) |
| FX_ADD(fx, type, val); |
| else |
| FX_UNSET(fx, type); |
| if (mode != FX_FLAG_OFF && parm_defs[type].realtime) { |
| DEBUG(2,printk("AWE32: fx_realtime (%d)\n", voice)); |
| awe_voice_change(voice, parm_defs[type].realtime); |
| } |
| } |
| } |
| |
| |
| /* change modulation wheel; voice is already mapped on multi2 mode */ |
| static void |
| awe_modwheel_change(int voice, int value) |
| { |
| int i; |
| awe_chan_info *cinfo; |
| |
| cinfo = &channels[voice]; |
| i = value * ctrls[AWE_MD_MOD_SENSE] / 1200; |
| FX_ADD(&cinfo->fx, AWE_FX_LFO1_PITCH, i); |
| awe_voice_change(voice, awe_fx_fmmod); |
| FX_ADD(&cinfo->fx, AWE_FX_LFO2_PITCH, i); |
| awe_voice_change(voice, awe_fx_fm2frq2); |
| } |
| |
| |
| /* voice pressure change */ |
| static void |
| awe_aftertouch(int dev, int voice, int pressure) |
| { |
| int note; |
| |
| DEBUG(2,printk("AWE32: [after(%d) %d]\n", voice, pressure)); |
| if (! voice_in_range(voice)) |
| return; |
| |
| switch (playing_mode) { |
| case AWE_PLAY_DIRECT: |
| case AWE_PLAY_INDIRECT: |
| awe_start_note(dev, voice, 255, pressure); |
| break; |
| case AWE_PLAY_MULTI2: |
| note = (voice_alloc->map[voice] & 0xff) - 1; |
| awe_key_pressure(dev, voice, note + 0x80, pressure); |
| break; |
| } |
| } |
| |
| |
| /* voice control change */ |
| static void |
| awe_controller(int dev, int voice, int ctrl_num, int value) |
| { |
| awe_chan_info *cinfo; |
| |
| if (! voice_in_range(voice)) |
| return; |
| |
| if (playing_mode == AWE_PLAY_MULTI2) { |
| voice = voice_alloc->map[voice] >> 8; |
| if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| return; |
| } |
| |
| cinfo = &channels[voice]; |
| |
| switch (ctrl_num) { |
| case CTL_BANK_SELECT: /* MIDI control #0 */ |
| DEBUG(2,printk("AWE32: [bank(%d) %d]\n", voice, value)); |
| if (MULTI_LAYER_MODE() && IS_DRUM_CHANNEL(voice) && |
| !ctrls[AWE_MD_TOGGLE_DRUM_BANK]) |
| break; |
| if (value < 0 || value > 255) |
| break; |
| cinfo->bank = value; |
| if (cinfo->bank == AWE_DRUM_BANK) |
| DRUM_CHANNEL_ON(cinfo->channel); |
| else |
| DRUM_CHANNEL_OFF(cinfo->channel); |
| awe_set_instr(dev, voice, cinfo->instr); |
| break; |
| |
| case CTL_MODWHEEL: /* MIDI control #1 */ |
| DEBUG(2,printk("AWE32: [modwheel(%d) %d]\n", voice, value)); |
| awe_modwheel_change(voice, value); |
| break; |
| |
| case CTRL_PITCH_BENDER: /* SEQ1 V2 contorl */ |
| DEBUG(2,printk("AWE32: [bend(%d) %d]\n", voice, value)); |
| /* zero centered */ |
| cinfo->bender = value; |
| awe_voice_change(voice, awe_set_voice_pitch); |
| break; |
| |
| case CTRL_PITCH_BENDER_RANGE: /* SEQ1 V2 control */ |
| DEBUG(2,printk("AWE32: [range(%d) %d]\n", voice, value)); |
| /* value = sense x 100 */ |
| cinfo->bender_range = value; |
| /* no audible pitch change yet.. */ |
| break; |
| |
| case CTL_EXPRESSION: /* MIDI control #11 */ |
| if (SINGLE_LAYER_MODE()) |
| value /= 128; |
| case CTRL_EXPRESSION: /* SEQ1 V2 control */ |
| DEBUG(2,printk("AWE32: [expr(%d) %d]\n", voice, value)); |
| /* 0 - 127 */ |
| cinfo->expression_vol = value; |
| awe_voice_change(voice, awe_set_voice_vol); |
| break; |
| |
| case CTL_PAN: /* MIDI control #10 */ |
| DEBUG(2,printk("AWE32: [pan(%d) %d]\n", voice, value)); |
| /* (0-127) -> signed 8bit */ |
| cinfo->panning = value * 2 - 128; |
| if (ctrls[AWE_MD_REALTIME_PAN]) |
| awe_voice_change(voice, awe_set_pan); |
| break; |
| |
| case CTL_MAIN_VOLUME: /* MIDI control #7 */ |
| if (SINGLE_LAYER_MODE()) |
| value = (value * 100) / 16383; |
| case CTRL_MAIN_VOLUME: /* SEQ1 V2 control */ |
| DEBUG(2,printk("AWE32: [mainvol(%d) %d]\n", voice, value)); |
| /* 0 - 127 */ |
| cinfo->main_vol = value; |
| awe_voice_change(voice, awe_set_voice_vol); |
| break; |
| |
| case CTL_EXT_EFF_DEPTH: /* reverb effects: 0-127 */ |
| DEBUG(2,printk("AWE32: [reverb(%d) %d]\n", voice, value)); |
| FX_SET(&cinfo->fx, AWE_FX_REVERB, value * 2); |
| break; |
| |
| case CTL_CHORUS_DEPTH: /* chorus effects: 0-127 */ |
| DEBUG(2,printk("AWE32: [chorus(%d) %d]\n", voice, value)); |
| FX_SET(&cinfo->fx, AWE_FX_CHORUS, value * 2); |
| break; |
| |
| case 120: /* all sounds off */ |
| awe_note_off_all(FALSE); |
| break; |
| case 123: /* all notes off */ |
| awe_note_off_all(TRUE); |
| break; |
| |
| case CTL_SUSTAIN: /* MIDI control #64 */ |
| cinfo->sustained = value; |
| if (value != 127) |
| awe_voice_change(voice, awe_sustain_off); |
| break; |
| |
| case CTL_SOSTENUTO: /* MIDI control #66 */ |
| if (value == 127) |
| awe_voice_change(voice, awe_sostenuto_on); |
| else |
| awe_voice_change(voice, awe_sustain_off); |
| break; |
| |
| default: |
| DEBUG(0,printk("AWE32: [control(%d) ctrl=%d val=%d]\n", |
| voice, ctrl_num, value)); |
| break; |
| } |
| } |
| |
| |
| /* voice pan change (value = -128 - 127) */ |
| static void |
| awe_panning(int dev, int voice, int value) |
| { |
| awe_chan_info *cinfo; |
| |
| if (! voice_in_range(voice)) |
| return; |
| |
| if (playing_mode == AWE_PLAY_MULTI2) { |
| voice = voice_alloc->map[voice] >> 8; |
| if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| return; |
| } |
| |
| cinfo = &channels[voice]; |
| cinfo->panning = value; |
| DEBUG(2,printk("AWE32: [pan(%d) %d]\n", voice, cinfo->panning)); |
| if (ctrls[AWE_MD_REALTIME_PAN]) |
| awe_voice_change(voice, awe_set_pan); |
| } |
| |
| |
| /* volume mode change */ |
| static void |
| awe_volume_method(int dev, int mode) |
| { |
| /* not impremented */ |
| DEBUG(0,printk("AWE32: [volmethod mode=%d]\n", mode)); |
| } |
| |
| |
| /* pitch wheel change: 0-16384 */ |
| static void |
| awe_bender(int dev, int voice, int value) |
| { |
| awe_chan_info *cinfo; |
| |
| if (! voice_in_range(voice)) |
| return; |
| |
| if (playing_mode == AWE_PLAY_MULTI2) { |
| voice = voice_alloc->map[voice] >> 8; |
| if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| return; |
| } |
| |
| /* convert to zero centered value */ |
| cinfo = &channels[voice]; |
| cinfo->bender = value - 8192; |
| DEBUG(2,printk("AWE32: [bend(%d) %d]\n", voice, cinfo->bender)); |
| awe_voice_change(voice, awe_set_voice_pitch); |
| } |
| |
| |
| /* |
| * load a sound patch: |
| * three types of patches are accepted: AWE, GUS, and SYSEX. |
| */ |
| |
| static int |
| awe_load_patch(int dev, int format, const char __user *addr, |
| int offs, int count, int pmgr_flag) |
| { |
| awe_patch_info patch; |
| int rc = 0; |
| |
| #ifdef AWE_HAS_GUS_COMPATIBILITY |
| if (format == GUS_PATCH) { |
| return awe_load_guspatch(addr, offs, count, pmgr_flag); |
| } else |
| #endif |
| if (format == SYSEX_PATCH) { |
| /* no system exclusive message supported yet */ |
| return 0; |
| } else if (format != AWE_PATCH) { |
| printk(KERN_WARNING "AWE32 Error: Invalid patch format (key) 0x%x\n", format); |
| return -EINVAL; |
| } |
| |
| if (count < AWE_PATCH_INFO_SIZE) { |
| printk(KERN_WARNING "AWE32 Error: Patch header too short\n"); |
| return -EINVAL; |
| } |
| if (copy_from_user(((char*)&patch) + offs, addr + offs, |
| AWE_PATCH_INFO_SIZE - offs)) |
| return -EFAULT; |
| |
| count -= AWE_PATCH_INFO_SIZE; |
| if (count < patch.len) { |
| printk(KERN_WARNING "AWE32: sample: Patch record too short (%d<%d)\n", |
| count, patch.len); |
| return -EINVAL; |
| } |
| |
| switch (patch.type) { |
| case AWE_LOAD_INFO: |
| rc = awe_load_info(&patch, addr, count); |
| break; |
| case AWE_LOAD_DATA: |
| rc = awe_load_data(&patch, addr, count); |
| break; |
| case AWE_OPEN_PATCH: |
| rc = awe_open_patch(&patch, addr, count); |
| break; |
| case AWE_CLOSE_PATCH: |
| rc = awe_close_patch(&patch, addr, count); |
| break; |
| case AWE_UNLOAD_PATCH: |
| rc = awe_unload_patch(&patch, addr, count); |
| break; |
| case AWE_REPLACE_DATA: |
| rc = awe_replace_data(&patch, addr, count); |
| break; |
| case AWE_MAP_PRESET: |
| rc = awe_load_map(&patch, addr, count); |
| break; |
| /* case AWE_PROBE_INFO: |
| rc = awe_probe_info(&patch, addr, count); |
| break;*/ |
| case AWE_PROBE_DATA: |
| rc = awe_probe_data(&patch, addr, count); |
| break; |
| case AWE_REMOVE_INFO: |
| rc = awe_remove_info(&patch, addr, count); |
| break; |
| case AWE_LOAD_CHORUS_FX: |
| rc = awe_load_chorus_fx(&patch, addr, count); |
| break; |
| case AWE_LOAD_REVERB_FX: |
| rc = awe_load_reverb_fx(&patch, addr, count); |
| break; |
| |
| default: |
| printk(KERN_WARNING "AWE32 Error: unknown patch format type %d\n", |
| patch.type); |
| rc = -EINVAL; |
| } |
| |
| return rc; |
| } |
| |
| |
| /* create an sf list record */ |
| static int |
| awe_create_sf(int type, char *name) |
| { |
| sf_list *rec; |
| |
| /* terminate sounds */ |
| awe_reset(0); |
| rec = (sf_list *)kmalloc(sizeof(*rec), GFP_KERNEL); |
| if (rec == NULL) |
| return 1; /* no memory */ |
| rec->sf_id = current_sf_id + 1; |
| rec->type = type; |
| if (/*current_sf_id == 0 ||*/ (type & AWE_PAT_LOCKED) != 0) |
| locked_sf_id = current_sf_id + 1; |
| rec->num_info = awe_free_info(); |
| rec->num_sample = awe_free_sample(); |
| rec->mem_ptr = awe_free_mem_ptr(); |
| rec->infos = rec->last_infos = NULL; |
| rec->samples = rec->last_samples = NULL; |
| |
| /* add to linked-list */ |
| rec->next = NULL; |
| rec->prev = sftail; |
| if (sftail) |
| sftail->next = rec; |
| else |
| sfhead = rec; |
| sftail = rec; |
| current_sf_id++; |
| |
| #ifdef AWE_ALLOW_SAMPLE_SHARING |
| rec->shared = NULL; |
| if (name) |
| memcpy |