Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * sound/awe_wave.c |
| 3 | * |
| 4 | * The low level driver for the AWE32/SB32/AWE64 wave table synth. |
| 5 | * version 0.4.4; Jan. 4, 2000 |
| 6 | * |
| 7 | * Copyright (C) 1996-2000 Takashi Iwai |
| 8 | * |
| 9 | * This program is free software; you can redistribute it and/or modify |
| 10 | * it under the terms of the GNU General Public License as published by |
| 11 | * the Free Software Foundation; either version 2 of the License, or |
| 12 | * (at your option) any later version. |
| 13 | * |
| 14 | * This program is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 17 | * GNU General Public License for more details. |
| 18 | * |
| 19 | * You should have received a copy of the GNU General Public License |
| 20 | * along with this program; if not, write to the Free Software |
| 21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 22 | */ |
| 23 | |
| 24 | /* |
| 25 | * Changelog: |
| 26 | * Aug 18, 2003, Adam Belay <ambx1@neo.rr.com> |
| 27 | * - detection code rewrite |
| 28 | */ |
| 29 | |
| 30 | #include <linux/awe_voice.h> |
| 31 | #include <linux/config.h> |
| 32 | #include <linux/init.h> |
| 33 | #include <linux/module.h> |
| 34 | #include <linux/string.h> |
| 35 | #include <linux/pnp.h> |
| 36 | |
| 37 | #include "sound_config.h" |
| 38 | |
| 39 | #include "awe_wave.h" |
| 40 | #include "awe_hw.h" |
| 41 | |
| 42 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 43 | #include "tuning.h" |
| 44 | #include <linux/ultrasound.h> |
| 45 | #endif |
| 46 | |
| 47 | /* |
| 48 | * debug message |
| 49 | */ |
| 50 | |
| 51 | #ifdef AWE_DEBUG_ON |
| 52 | #define DEBUG(LVL,XXX) {if (ctrls[AWE_MD_DEBUG_MODE] > LVL) { XXX; }} |
| 53 | #define ERRMSG(XXX) {if (ctrls[AWE_MD_DEBUG_MODE]) { XXX; }} |
| 54 | #define FATALERR(XXX) XXX |
| 55 | #else |
| 56 | #define DEBUG(LVL,XXX) /**/ |
| 57 | #define ERRMSG(XXX) XXX |
| 58 | #define FATALERR(XXX) XXX |
| 59 | #endif |
| 60 | |
| 61 | /* |
| 62 | * bank and voice record |
| 63 | */ |
| 64 | |
| 65 | typedef struct _sf_list sf_list; |
| 66 | typedef struct _awe_voice_list awe_voice_list; |
| 67 | typedef struct _awe_sample_list awe_sample_list; |
| 68 | |
| 69 | /* soundfont record */ |
| 70 | struct _sf_list { |
| 71 | unsigned short sf_id; /* id number */ |
| 72 | unsigned short type; /* lock & shared flags */ |
| 73 | int num_info; /* current info table index */ |
| 74 | int num_sample; /* current sample table index */ |
| 75 | int mem_ptr; /* current word byte pointer */ |
| 76 | awe_voice_list *infos, *last_infos; /* instruments */ |
| 77 | awe_sample_list *samples, *last_samples; /* samples */ |
| 78 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 79 | sf_list *shared; /* shared list */ |
| 80 | unsigned char name[AWE_PATCH_NAME_LEN]; /* sharing id */ |
| 81 | #endif |
| 82 | sf_list *next, *prev; |
| 83 | }; |
| 84 | |
| 85 | /* instrument list */ |
| 86 | struct _awe_voice_list { |
| 87 | awe_voice_info v; /* instrument information */ |
| 88 | sf_list *holder; /* parent sf_list of this record */ |
| 89 | unsigned char bank, instr; /* preset number information */ |
| 90 | char type, disabled; /* type=normal/mapped, disabled=boolean */ |
| 91 | awe_voice_list *next; /* linked list with same sf_id */ |
| 92 | awe_voice_list *next_instr; /* instrument list */ |
| 93 | awe_voice_list *next_bank; /* hash table list */ |
| 94 | }; |
| 95 | |
| 96 | /* voice list type */ |
| 97 | #define V_ST_NORMAL 0 |
| 98 | #define V_ST_MAPPED 1 |
| 99 | |
| 100 | /* sample list */ |
| 101 | struct _awe_sample_list { |
| 102 | awe_sample_info v; /* sample information */ |
| 103 | sf_list *holder; /* parent sf_list of this record */ |
| 104 | awe_sample_list *next; /* linked list with same sf_id */ |
| 105 | }; |
| 106 | |
| 107 | /* sample and information table */ |
| 108 | static int current_sf_id; /* current number of fonts */ |
| 109 | static int locked_sf_id; /* locked position */ |
| 110 | static sf_list *sfhead, *sftail; /* linked-lists */ |
| 111 | |
| 112 | #define awe_free_mem_ptr() (sftail ? sftail->mem_ptr : 0) |
| 113 | #define awe_free_info() (sftail ? sftail->num_info : 0) |
| 114 | #define awe_free_sample() (sftail ? sftail->num_sample : 0) |
| 115 | |
| 116 | #define AWE_MAX_PRESETS 256 |
| 117 | #define AWE_DEFAULT_PRESET 0 |
| 118 | #define AWE_DEFAULT_BANK 0 |
| 119 | #define AWE_DEFAULT_DRUM 0 |
| 120 | #define AWE_DRUM_BANK 128 |
| 121 | |
| 122 | #define MAX_LAYERS AWE_MAX_VOICES |
| 123 | |
| 124 | /* preset table index */ |
| 125 | static awe_voice_list *preset_table[AWE_MAX_PRESETS]; |
| 126 | |
| 127 | /* |
| 128 | * voice table |
| 129 | */ |
| 130 | |
| 131 | /* effects table */ |
| 132 | typedef struct FX_Rec { /* channel effects */ |
| 133 | unsigned char flags[AWE_FX_END]; |
| 134 | short val[AWE_FX_END]; |
| 135 | } FX_Rec; |
| 136 | |
| 137 | |
| 138 | /* channel parameters */ |
| 139 | typedef struct _awe_chan_info { |
| 140 | int channel; /* channel number */ |
| 141 | int bank; /* current tone bank */ |
| 142 | int instr; /* current program */ |
| 143 | int bender; /* midi pitchbend (-8192 - 8192) */ |
| 144 | int bender_range; /* midi bender range (x100) */ |
| 145 | int panning; /* panning (0-127) */ |
| 146 | int main_vol; /* channel volume (0-127) */ |
| 147 | int expression_vol; /* midi expression (0-127) */ |
| 148 | int chan_press; /* channel pressure */ |
| 149 | int sustained; /* sustain status in MIDI */ |
| 150 | FX_Rec fx; /* effects */ |
| 151 | FX_Rec fx_layer[MAX_LAYERS]; /* layer effects */ |
| 152 | } awe_chan_info; |
| 153 | |
| 154 | /* voice parameters */ |
| 155 | typedef struct _voice_info { |
| 156 | int state; |
| 157 | #define AWE_ST_OFF (1<<0) /* no sound */ |
| 158 | #define AWE_ST_ON (1<<1) /* playing */ |
| 159 | #define AWE_ST_STANDBY (1<<2) /* stand by for playing */ |
| 160 | #define AWE_ST_SUSTAINED (1<<3) /* sustained */ |
| 161 | #define AWE_ST_MARK (1<<4) /* marked for allocation */ |
| 162 | #define AWE_ST_DRAM (1<<5) /* DRAM read/write */ |
| 163 | #define AWE_ST_FM (1<<6) /* reserved for FM */ |
| 164 | #define AWE_ST_RELEASED (1<<7) /* released */ |
| 165 | |
| 166 | int ch; /* midi channel */ |
| 167 | int key; /* internal key for search */ |
| 168 | int layer; /* layer number (for channel mode only) */ |
| 169 | int time; /* allocated time */ |
| 170 | awe_chan_info *cinfo; /* channel info */ |
| 171 | |
| 172 | int note; /* midi key (0-127) */ |
| 173 | int velocity; /* midi velocity (0-127) */ |
| 174 | int sostenuto; /* sostenuto on/off */ |
| 175 | awe_voice_info *sample; /* assigned voice */ |
| 176 | |
| 177 | /* EMU8000 parameters */ |
| 178 | int apitch; /* pitch parameter */ |
| 179 | int avol; /* volume parameter */ |
| 180 | int apan; /* panning parameter */ |
| 181 | int acutoff; /* cutoff parameter */ |
| 182 | short aaux; /* aux word */ |
| 183 | } voice_info; |
| 184 | |
| 185 | /* voice information */ |
| 186 | static voice_info voices[AWE_MAX_VOICES]; |
| 187 | |
| 188 | #define IS_NO_SOUND(v) (voices[v].state & (AWE_ST_OFF|AWE_ST_RELEASED|AWE_ST_STANDBY|AWE_ST_SUSTAINED)) |
| 189 | #define IS_NO_EFFECT(v) (voices[v].state != AWE_ST_ON) |
| 190 | #define IS_PLAYING(v) (voices[v].state & (AWE_ST_ON|AWE_ST_SUSTAINED|AWE_ST_RELEASED)) |
| 191 | #define IS_EMPTY(v) (voices[v].state & (AWE_ST_OFF|AWE_ST_MARK|AWE_ST_DRAM|AWE_ST_FM)) |
| 192 | |
| 193 | |
| 194 | /* MIDI channel effects information (for hw control) */ |
| 195 | static awe_chan_info channels[AWE_MAX_CHANNELS]; |
| 196 | |
| 197 | |
| 198 | /* |
| 199 | * global variables |
| 200 | */ |
| 201 | |
| 202 | #ifndef AWE_DEFAULT_BASE_ADDR |
| 203 | #define AWE_DEFAULT_BASE_ADDR 0 /* autodetect */ |
| 204 | #endif |
| 205 | |
| 206 | #ifndef AWE_DEFAULT_MEM_SIZE |
| 207 | #define AWE_DEFAULT_MEM_SIZE -1 /* autodetect */ |
| 208 | #endif |
| 209 | |
| 210 | static int io = AWE_DEFAULT_BASE_ADDR; /* Emu8000 base address */ |
| 211 | static int memsize = AWE_DEFAULT_MEM_SIZE; /* memory size in Kbytes */ |
| 212 | #ifdef CONFIG_PNP |
| 213 | static int isapnp = -1; |
| 214 | #else |
| 215 | static int isapnp; |
| 216 | #endif |
| 217 | |
| 218 | MODULE_AUTHOR("Takashi Iwai <iwai@ww.uni-erlangen.de>"); |
| 219 | MODULE_DESCRIPTION("SB AWE32/64 WaveTable driver"); |
| 220 | MODULE_LICENSE("GPL"); |
| 221 | |
| 222 | module_param(io, int, 0); |
| 223 | MODULE_PARM_DESC(io, "base i/o port of Emu8000"); |
| 224 | module_param(memsize, int, 0); |
| 225 | MODULE_PARM_DESC(memsize, "onboard DRAM size in Kbytes"); |
| 226 | module_param(isapnp, bool, 0); |
| 227 | MODULE_PARM_DESC(isapnp, "use ISAPnP detection"); |
| 228 | |
| 229 | /* DRAM start offset */ |
| 230 | static int awe_mem_start = AWE_DRAM_OFFSET; |
| 231 | |
| 232 | /* maximum channels for playing */ |
| 233 | static int awe_max_voices = AWE_MAX_VOICES; |
| 234 | |
| 235 | static int patch_opened; /* sample already loaded? */ |
| 236 | |
| 237 | static char atten_relative = FALSE; |
| 238 | static short atten_offset; |
| 239 | |
| 240 | static int awe_present = FALSE; /* awe device present? */ |
| 241 | static int awe_busy = FALSE; /* awe device opened? */ |
| 242 | |
| 243 | static int my_dev = -1; |
| 244 | |
| 245 | #define DEFAULT_DRUM_FLAGS ((1 << 9) | (1 << 25)) |
| 246 | #define IS_DRUM_CHANNEL(c) (drum_flags & (1 << (c))) |
| 247 | #define DRUM_CHANNEL_ON(c) (drum_flags |= (1 << (c))) |
| 248 | #define DRUM_CHANNEL_OFF(c) (drum_flags &= ~(1 << (c))) |
| 249 | static unsigned int drum_flags = DEFAULT_DRUM_FLAGS; /* channel flags */ |
| 250 | |
| 251 | static int playing_mode = AWE_PLAY_INDIRECT; |
| 252 | #define SINGLE_LAYER_MODE() (playing_mode == AWE_PLAY_INDIRECT || playing_mode == AWE_PLAY_DIRECT) |
| 253 | #define MULTI_LAYER_MODE() (playing_mode == AWE_PLAY_MULTI || playing_mode == AWE_PLAY_MULTI2) |
| 254 | |
| 255 | static int current_alloc_time; /* voice allocation index for channel mode */ |
| 256 | |
| 257 | static struct synth_info awe_info = { |
| 258 | "AWE32 Synth", /* name */ |
| 259 | 0, /* device */ |
| 260 | SYNTH_TYPE_SAMPLE, /* synth_type */ |
| 261 | SAMPLE_TYPE_AWE32, /* synth_subtype */ |
| 262 | 0, /* perc_mode (obsolete) */ |
| 263 | AWE_MAX_VOICES, /* nr_voices */ |
| 264 | 0, /* nr_drums (obsolete) */ |
| 265 | 400 /* instr_bank_size */ |
| 266 | }; |
| 267 | |
| 268 | |
| 269 | static struct voice_alloc_info *voice_alloc; /* set at initialization */ |
| 270 | |
| 271 | |
| 272 | /* |
| 273 | * function prototypes |
| 274 | */ |
| 275 | |
| 276 | static int awe_request_region(void); |
| 277 | static void awe_release_region(void); |
| 278 | |
| 279 | static void awe_reset_samples(void); |
| 280 | /* emu8000 chip i/o access */ |
| 281 | static void setup_ports(int p1, int p2, int p3); |
| 282 | static void awe_poke(unsigned short cmd, unsigned short port, unsigned short data); |
| 283 | static void awe_poke_dw(unsigned short cmd, unsigned short port, unsigned int data); |
| 284 | static unsigned short awe_peek(unsigned short cmd, unsigned short port); |
| 285 | static unsigned int awe_peek_dw(unsigned short cmd, unsigned short port); |
| 286 | static void awe_wait(unsigned short delay); |
| 287 | |
| 288 | /* initialize emu8000 chip */ |
| 289 | static void awe_initialize(void); |
| 290 | |
| 291 | /* set voice parameters */ |
| 292 | static void awe_init_ctrl_parms(int init_all); |
| 293 | static void awe_init_voice_info(awe_voice_info *vp); |
| 294 | static void awe_init_voice_parm(awe_voice_parm *pp); |
| 295 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 296 | static int freq_to_note(int freq); |
| 297 | static int calc_rate_offset(int Hz); |
| 298 | /*static int calc_parm_delay(int msec);*/ |
| 299 | static int calc_parm_hold(int msec); |
| 300 | static int calc_parm_attack(int msec); |
| 301 | static int calc_parm_decay(int msec); |
| 302 | static int calc_parm_search(int msec, short *table); |
| 303 | #endif /* gus compat */ |
| 304 | |
| 305 | /* turn on/off note */ |
| 306 | static void awe_note_on(int voice); |
| 307 | static void awe_note_off(int voice); |
| 308 | static void awe_terminate(int voice); |
| 309 | static void awe_exclusive_off(int voice); |
| 310 | static void awe_note_off_all(int do_sustain); |
| 311 | |
| 312 | /* calculate voice parameters */ |
| 313 | typedef void (*fx_affect_func)(int voice, int forced); |
| 314 | static void awe_set_pitch(int voice, int forced); |
| 315 | static void awe_set_voice_pitch(int voice, int forced); |
| 316 | static void awe_set_volume(int voice, int forced); |
| 317 | static void awe_set_voice_vol(int voice, int forced); |
| 318 | static void awe_set_pan(int voice, int forced); |
| 319 | static void awe_fx_fmmod(int voice, int forced); |
| 320 | static void awe_fx_tremfrq(int voice, int forced); |
| 321 | static void awe_fx_fm2frq2(int voice, int forced); |
| 322 | static void awe_fx_filterQ(int voice, int forced); |
| 323 | static void awe_calc_pitch(int voice); |
| 324 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 325 | static void awe_calc_pitch_from_freq(int voice, int freq); |
| 326 | #endif |
| 327 | static void awe_calc_volume(int voice); |
| 328 | static void awe_update_volume(void); |
| 329 | static void awe_change_master_volume(short val); |
| 330 | static void awe_voice_init(int voice, int init_all); |
| 331 | static void awe_channel_init(int ch, int init_all); |
| 332 | static void awe_fx_init(int ch); |
| 333 | static void awe_send_effect(int voice, int layer, int type, int val); |
| 334 | static void awe_modwheel_change(int voice, int value); |
| 335 | |
| 336 | /* sequencer interface */ |
| 337 | static int awe_open(int dev, int mode); |
| 338 | static void awe_close(int dev); |
| 339 | static int awe_ioctl(int dev, unsigned int cmd, void __user * arg); |
| 340 | static int awe_kill_note(int dev, int voice, int note, int velocity); |
| 341 | static int awe_start_note(int dev, int v, int note_num, int volume); |
| 342 | static int awe_set_instr(int dev, int voice, int instr_no); |
| 343 | static int awe_set_instr_2(int dev, int voice, int instr_no); |
| 344 | static void awe_reset(int dev); |
| 345 | static void awe_hw_control(int dev, unsigned char *event); |
| 346 | static int awe_load_patch(int dev, int format, const char __user *addr, |
| 347 | int offs, int count, int pmgr_flag); |
| 348 | static void awe_aftertouch(int dev, int voice, int pressure); |
| 349 | static void awe_controller(int dev, int voice, int ctrl_num, int value); |
| 350 | static void awe_panning(int dev, int voice, int value); |
| 351 | static void awe_volume_method(int dev, int mode); |
| 352 | static void awe_bender(int dev, int voice, int value); |
| 353 | static int awe_alloc(int dev, int chn, int note, struct voice_alloc_info *alloc); |
| 354 | static void awe_setup_voice(int dev, int voice, int chn); |
| 355 | |
| 356 | #define awe_key_pressure(dev,voice,key,press) awe_start_note(dev,voice,(key)+128,press) |
| 357 | |
| 358 | /* hardware controls */ |
| 359 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 360 | static void awe_hw_gus_control(int dev, int cmd, unsigned char *event); |
| 361 | #endif |
| 362 | static void awe_hw_awe_control(int dev, int cmd, unsigned char *event); |
| 363 | static void awe_voice_change(int voice, fx_affect_func func); |
| 364 | static void awe_sostenuto_on(int voice, int forced); |
| 365 | static void awe_sustain_off(int voice, int forced); |
| 366 | static void awe_terminate_and_init(int voice, int forced); |
| 367 | |
| 368 | /* voice search */ |
| 369 | static int awe_search_key(int bank, int preset, int note); |
| 370 | static awe_voice_list *awe_search_instr(int bank, int preset, int note); |
| 371 | static int awe_search_multi_voices(awe_voice_list *rec, int note, int velocity, awe_voice_info **vlist); |
| 372 | static void awe_alloc_multi_voices(int ch, int note, int velocity, int key); |
| 373 | static void awe_alloc_one_voice(int voice, int note, int velocity); |
| 374 | static int awe_clear_voice(void); |
| 375 | |
| 376 | /* load / remove patches */ |
| 377 | static int awe_open_patch(awe_patch_info *patch, const char __user *addr, int count); |
| 378 | static int awe_close_patch(awe_patch_info *patch, const char __user *addr, int count); |
| 379 | static int awe_unload_patch(awe_patch_info *patch, const char __user *addr, int count); |
| 380 | static int awe_load_info(awe_patch_info *patch, const char __user *addr, int count); |
| 381 | static int awe_remove_info(awe_patch_info *patch, const char __user *addr, int count); |
| 382 | static int awe_load_data(awe_patch_info *patch, const char __user *addr, int count); |
| 383 | static int awe_replace_data(awe_patch_info *patch, const char __user *addr, int count); |
| 384 | static int awe_load_map(awe_patch_info *patch, const char __user *addr, int count); |
| 385 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 386 | static int awe_load_guspatch(const char __user *addr, int offs, int size, int pmgr_flag); |
| 387 | #endif |
| 388 | /*static int awe_probe_info(awe_patch_info *patch, const char __user *addr, int count);*/ |
| 389 | static int awe_probe_data(awe_patch_info *patch, const char __user *addr, int count); |
| 390 | static sf_list *check_patch_opened(int type, char *name); |
| 391 | static int awe_write_wave_data(const char __user *addr, int offset, awe_sample_list *sp, int channels); |
| 392 | static int awe_create_sf(int type, char *name); |
| 393 | static void awe_free_sf(sf_list *sf); |
| 394 | static void add_sf_info(sf_list *sf, awe_voice_list *rec); |
| 395 | static void add_sf_sample(sf_list *sf, awe_sample_list *smp); |
| 396 | static void purge_old_list(awe_voice_list *rec, awe_voice_list *next); |
| 397 | static void add_info_list(awe_voice_list *rec); |
| 398 | static void awe_remove_samples(int sf_id); |
| 399 | static void rebuild_preset_list(void); |
| 400 | static short awe_set_sample(awe_voice_list *rec); |
| 401 | static awe_sample_list *search_sample_index(sf_list *sf, int sample); |
| 402 | |
| 403 | static int is_identical_holder(sf_list *sf1, sf_list *sf2); |
| 404 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 405 | static int is_identical_name(unsigned char *name, sf_list *p); |
| 406 | static int is_shared_sf(unsigned char *name); |
| 407 | static int info_duplicated(sf_list *sf, awe_voice_list *rec); |
| 408 | #endif /* allow sharing */ |
| 409 | |
| 410 | /* lowlevel functions */ |
| 411 | static void awe_init_audio(void); |
| 412 | static void awe_init_dma(void); |
| 413 | static void awe_init_array(void); |
| 414 | static void awe_send_array(unsigned short *data); |
| 415 | static void awe_tweak_voice(int voice); |
| 416 | static void awe_tweak(void); |
| 417 | static void awe_init_fm(void); |
| 418 | static int awe_open_dram_for_write(int offset, int channels); |
| 419 | static void awe_open_dram_for_check(void); |
| 420 | static void awe_close_dram(void); |
| 421 | /*static void awe_write_dram(unsigned short c);*/ |
| 422 | static int awe_detect_base(int addr); |
| 423 | static int awe_detect(void); |
| 424 | static void awe_check_dram(void); |
| 425 | static int awe_load_chorus_fx(awe_patch_info *patch, const char __user *addr, int count); |
| 426 | static void awe_set_chorus_mode(int mode); |
| 427 | static void awe_update_chorus_mode(void); |
| 428 | static int awe_load_reverb_fx(awe_patch_info *patch, const char __user *addr, int count); |
| 429 | static void awe_set_reverb_mode(int mode); |
| 430 | static void awe_update_reverb_mode(void); |
| 431 | static void awe_equalizer(int bass, int treble); |
| 432 | static void awe_update_equalizer(void); |
| 433 | |
| 434 | #ifdef CONFIG_AWE32_MIXER |
| 435 | static void attach_mixer(void); |
| 436 | static void unload_mixer(void); |
| 437 | #endif |
| 438 | |
| 439 | #ifdef CONFIG_AWE32_MIDIEMU |
| 440 | static void attach_midiemu(void); |
| 441 | static void unload_midiemu(void); |
| 442 | #endif |
| 443 | |
| 444 | #define limitvalue(x, a, b) if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b) |
| 445 | |
| 446 | /* |
| 447 | * control parameters |
| 448 | */ |
| 449 | |
| 450 | |
| 451 | #ifdef AWE_USE_NEW_VOLUME_CALC |
| 452 | #define DEF_VOLUME_CALC TRUE |
| 453 | #else |
| 454 | #define DEF_VOLUME_CALC FALSE |
| 455 | #endif /* new volume */ |
| 456 | |
| 457 | #define DEF_ZERO_ATTEN 32 /* 12dB below */ |
| 458 | #define DEF_MOD_SENSE 18 |
| 459 | #define DEF_CHORUS_MODE 2 |
| 460 | #define DEF_REVERB_MODE 4 |
| 461 | #define DEF_BASS_LEVEL 5 |
| 462 | #define DEF_TREBLE_LEVEL 9 |
| 463 | |
| 464 | static struct CtrlParmsDef { |
| 465 | int value; |
| 466 | int init_each_time; |
| 467 | void (*update)(void); |
| 468 | } ctrl_parms[AWE_MD_END] = { |
| 469 | {0,0, NULL}, {0,0, NULL}, /* <-- not used */ |
| 470 | {AWE_VERSION_NUMBER, FALSE, NULL}, |
| 471 | {TRUE, FALSE, NULL}, /* exclusive */ |
| 472 | {TRUE, FALSE, NULL}, /* realpan */ |
| 473 | {AWE_DEFAULT_BANK, FALSE, NULL}, /* gusbank */ |
| 474 | {FALSE, TRUE, NULL}, /* keep effect */ |
| 475 | {DEF_ZERO_ATTEN, FALSE, awe_update_volume}, /* zero_atten */ |
| 476 | {FALSE, FALSE, NULL}, /* chn_prior */ |
| 477 | {DEF_MOD_SENSE, FALSE, NULL}, /* modwheel sense */ |
| 478 | {AWE_DEFAULT_PRESET, FALSE, NULL}, /* def_preset */ |
| 479 | {AWE_DEFAULT_BANK, FALSE, NULL}, /* def_bank */ |
| 480 | {AWE_DEFAULT_DRUM, FALSE, NULL}, /* def_drum */ |
| 481 | {FALSE, FALSE, NULL}, /* toggle_drum_bank */ |
| 482 | {DEF_VOLUME_CALC, FALSE, awe_update_volume}, /* new_volume_calc */ |
| 483 | {DEF_CHORUS_MODE, FALSE, awe_update_chorus_mode}, /* chorus mode */ |
| 484 | {DEF_REVERB_MODE, FALSE, awe_update_reverb_mode}, /* reverb mode */ |
| 485 | {DEF_BASS_LEVEL, FALSE, awe_update_equalizer}, /* bass level */ |
| 486 | {DEF_TREBLE_LEVEL, FALSE, awe_update_equalizer}, /* treble level */ |
| 487 | {0, FALSE, NULL}, /* debug mode */ |
| 488 | {FALSE, FALSE, NULL}, /* pan exchange */ |
| 489 | }; |
| 490 | |
| 491 | static int ctrls[AWE_MD_END]; |
| 492 | |
| 493 | |
| 494 | /* |
| 495 | * synth operation table |
| 496 | */ |
| 497 | |
| 498 | static struct synth_operations awe_operations = |
| 499 | { |
| 500 | .owner = THIS_MODULE, |
| 501 | .id = "EMU8K", |
| 502 | .info = &awe_info, |
| 503 | .midi_dev = 0, |
| 504 | .synth_type = SYNTH_TYPE_SAMPLE, |
| 505 | .synth_subtype = SAMPLE_TYPE_AWE32, |
| 506 | .open = awe_open, |
| 507 | .close = awe_close, |
| 508 | .ioctl = awe_ioctl, |
| 509 | .kill_note = awe_kill_note, |
| 510 | .start_note = awe_start_note, |
| 511 | .set_instr = awe_set_instr_2, |
| 512 | .reset = awe_reset, |
| 513 | .hw_control = awe_hw_control, |
| 514 | .load_patch = awe_load_patch, |
| 515 | .aftertouch = awe_aftertouch, |
| 516 | .controller = awe_controller, |
| 517 | .panning = awe_panning, |
| 518 | .volume_method = awe_volume_method, |
| 519 | .bender = awe_bender, |
| 520 | .alloc_voice = awe_alloc, |
| 521 | .setup_voice = awe_setup_voice |
| 522 | }; |
| 523 | |
| 524 | static void free_tables(void) |
| 525 | { |
| 526 | if (sftail) { |
| 527 | sf_list *p, *prev; |
| 528 | for (p = sftail; p; p = prev) { |
| 529 | prev = p->prev; |
| 530 | awe_free_sf(p); |
| 531 | } |
| 532 | } |
| 533 | sfhead = sftail = NULL; |
| 534 | } |
| 535 | |
| 536 | /* |
| 537 | * clear sample tables |
| 538 | */ |
| 539 | |
| 540 | static void |
| 541 | awe_reset_samples(void) |
| 542 | { |
| 543 | /* free all bank tables */ |
| 544 | memset(preset_table, 0, sizeof(preset_table)); |
| 545 | free_tables(); |
| 546 | |
| 547 | current_sf_id = 0; |
| 548 | locked_sf_id = 0; |
| 549 | patch_opened = 0; |
| 550 | } |
| 551 | |
| 552 | |
| 553 | /* |
| 554 | * EMU register access |
| 555 | */ |
| 556 | |
| 557 | /* select a given AWE32 pointer */ |
| 558 | static int awe_ports[5]; |
| 559 | static int port_setuped = FALSE; |
| 560 | static int awe_cur_cmd = -1; |
| 561 | #define awe_set_cmd(cmd) \ |
| 562 | if (awe_cur_cmd != cmd) { outw(cmd, awe_ports[Pointer]); awe_cur_cmd = cmd; } |
| 563 | |
| 564 | /* write 16bit data */ |
| 565 | static void |
| 566 | awe_poke(unsigned short cmd, unsigned short port, unsigned short data) |
| 567 | { |
| 568 | awe_set_cmd(cmd); |
| 569 | outw(data, awe_ports[port]); |
| 570 | } |
| 571 | |
| 572 | /* write 32bit data */ |
| 573 | static void |
| 574 | awe_poke_dw(unsigned short cmd, unsigned short port, unsigned int data) |
| 575 | { |
| 576 | unsigned short addr = awe_ports[port]; |
| 577 | awe_set_cmd(cmd); |
| 578 | outw(data, addr); /* write lower 16 bits */ |
| 579 | outw(data >> 16, addr + 2); /* write higher 16 bits */ |
| 580 | } |
| 581 | |
| 582 | /* read 16bit data */ |
| 583 | static unsigned short |
| 584 | awe_peek(unsigned short cmd, unsigned short port) |
| 585 | { |
| 586 | unsigned short k; |
| 587 | awe_set_cmd(cmd); |
| 588 | k = inw(awe_ports[port]); |
| 589 | return k; |
| 590 | } |
| 591 | |
| 592 | /* read 32bit data */ |
| 593 | static unsigned int |
| 594 | awe_peek_dw(unsigned short cmd, unsigned short port) |
| 595 | { |
| 596 | unsigned int k1, k2; |
| 597 | unsigned short addr = awe_ports[port]; |
| 598 | awe_set_cmd(cmd); |
| 599 | k1 = inw(addr); |
| 600 | k2 = inw(addr + 2); |
| 601 | k1 |= k2 << 16; |
| 602 | return k1; |
| 603 | } |
| 604 | |
| 605 | /* wait delay number of AWE32 44100Hz clocks */ |
| 606 | #ifdef WAIT_BY_LOOP /* wait by loop -- that's not good.. */ |
| 607 | static void |
| 608 | awe_wait(unsigned short delay) |
| 609 | { |
| 610 | unsigned short clock, target; |
| 611 | unsigned short port = awe_ports[AWE_WC_Port]; |
| 612 | int counter; |
| 613 | |
| 614 | /* sample counter */ |
| 615 | awe_set_cmd(AWE_WC_Cmd); |
| 616 | clock = (unsigned short)inw(port); |
| 617 | target = clock + delay; |
| 618 | counter = 0; |
| 619 | if (target < clock) { |
| 620 | for (; (unsigned short)inw(port) > target; counter++) |
| 621 | if (counter > 65536) |
| 622 | break; |
| 623 | } |
| 624 | for (; (unsigned short)inw(port) < target; counter++) |
| 625 | if (counter > 65536) |
| 626 | break; |
| 627 | } |
| 628 | #else |
| 629 | |
| 630 | static void awe_wait(unsigned short delay) |
| 631 | { |
| 632 | current->state = TASK_INTERRUPTIBLE; |
| 633 | schedule_timeout((HZ*(unsigned long)delay + 44099)/44100); |
| 634 | } |
| 635 | /* |
| 636 | static void awe_wait(unsigned short delay) |
| 637 | { |
| 638 | udelay(((unsigned long)delay * 1000000L + 44099) / 44100); |
| 639 | } |
| 640 | */ |
| 641 | #endif /* wait by loop */ |
| 642 | |
| 643 | /* write a word data */ |
| 644 | #define awe_write_dram(c) awe_poke(AWE_SMLD, c) |
| 645 | |
| 646 | /* |
| 647 | * AWE32 voice parameters |
| 648 | */ |
| 649 | |
| 650 | /* initialize voice_info record */ |
| 651 | static void |
| 652 | awe_init_voice_info(awe_voice_info *vp) |
| 653 | { |
| 654 | vp->sample = 0; |
| 655 | vp->rate_offset = 0; |
| 656 | |
| 657 | vp->start = 0; |
| 658 | vp->end = 0; |
| 659 | vp->loopstart = 0; |
| 660 | vp->loopend = 0; |
| 661 | vp->mode = 0; |
| 662 | vp->root = 60; |
| 663 | vp->tune = 0; |
| 664 | vp->low = 0; |
| 665 | vp->high = 127; |
| 666 | vp->vellow = 0; |
| 667 | vp->velhigh = 127; |
| 668 | |
| 669 | vp->fixkey = -1; |
| 670 | vp->fixvel = -1; |
| 671 | vp->fixpan = -1; |
| 672 | vp->pan = -1; |
| 673 | |
| 674 | vp->exclusiveClass = 0; |
| 675 | vp->amplitude = 127; |
| 676 | vp->attenuation = 0; |
| 677 | vp->scaleTuning = 100; |
| 678 | |
| 679 | awe_init_voice_parm(&vp->parm); |
| 680 | } |
| 681 | |
| 682 | /* initialize voice_parm record: |
| 683 | * Env1/2: delay=0, attack=0, hold=0, sustain=0, decay=0, release=0. |
| 684 | * Vibrato and Tremolo effects are zero. |
| 685 | * Cutoff is maximum. |
| 686 | * Chorus and Reverb effects are zero. |
| 687 | */ |
| 688 | static void |
| 689 | awe_init_voice_parm(awe_voice_parm *pp) |
| 690 | { |
| 691 | pp->moddelay = 0x8000; |
| 692 | pp->modatkhld = 0x7f7f; |
| 693 | pp->moddcysus = 0x7f7f; |
| 694 | pp->modrelease = 0x807f; |
| 695 | pp->modkeyhold = 0; |
| 696 | pp->modkeydecay = 0; |
| 697 | |
| 698 | pp->voldelay = 0x8000; |
| 699 | pp->volatkhld = 0x7f7f; |
| 700 | pp->voldcysus = 0x7f7f; |
| 701 | pp->volrelease = 0x807f; |
| 702 | pp->volkeyhold = 0; |
| 703 | pp->volkeydecay = 0; |
| 704 | |
| 705 | pp->lfo1delay = 0x8000; |
| 706 | pp->lfo2delay = 0x8000; |
| 707 | pp->pefe = 0; |
| 708 | |
| 709 | pp->fmmod = 0; |
| 710 | pp->tremfrq = 0; |
| 711 | pp->fm2frq2 = 0; |
| 712 | |
| 713 | pp->cutoff = 0xff; |
| 714 | pp->filterQ = 0; |
| 715 | |
| 716 | pp->chorus = 0; |
| 717 | pp->reverb = 0; |
| 718 | } |
| 719 | |
| 720 | |
| 721 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 722 | |
| 723 | /* convert frequency mHz to abstract cents (= midi key * 100) */ |
| 724 | static int |
| 725 | freq_to_note(int mHz) |
| 726 | { |
| 727 | /* abscents = log(mHz/8176) / log(2) * 1200 */ |
| 728 | unsigned int max_val = (unsigned int)0xffffffff / 10000; |
| 729 | int i, times; |
| 730 | unsigned int base; |
| 731 | unsigned int freq; |
| 732 | int note, tune; |
| 733 | |
| 734 | if (mHz == 0) |
| 735 | return 0; |
| 736 | if (mHz < 0) |
| 737 | return 12799; /* maximum */ |
| 738 | |
| 739 | freq = mHz; |
| 740 | note = 0; |
| 741 | for (base = 8176 * 2; freq >= base; base *= 2) { |
| 742 | note += 12; |
| 743 | if (note >= 128) /* over maximum */ |
| 744 | return 12799; |
| 745 | } |
| 746 | base /= 2; |
| 747 | |
| 748 | /* to avoid overflow... */ |
| 749 | times = 10000; |
| 750 | while (freq > max_val) { |
| 751 | max_val *= 10; |
| 752 | times /= 10; |
| 753 | base /= 10; |
| 754 | } |
| 755 | |
| 756 | freq = freq * times / base; |
| 757 | for (i = 0; i < 12; i++) { |
| 758 | if (freq < semitone_tuning[i+1]) |
| 759 | break; |
| 760 | note++; |
| 761 | } |
| 762 | |
| 763 | tune = 0; |
| 764 | freq = freq * 10000 / semitone_tuning[i]; |
| 765 | for (i = 0; i < 100; i++) { |
| 766 | if (freq < cent_tuning[i+1]) |
| 767 | break; |
| 768 | tune++; |
| 769 | } |
| 770 | |
| 771 | return note * 100 + tune; |
| 772 | } |
| 773 | |
| 774 | |
| 775 | /* convert Hz to AWE32 rate offset: |
| 776 | * sample pitch offset for the specified sample rate |
| 777 | * rate=44100 is no offset, each 4096 is 1 octave (twice). |
| 778 | * eg, when rate is 22050, this offset becomes -4096. |
| 779 | */ |
| 780 | static int |
| 781 | calc_rate_offset(int Hz) |
| 782 | { |
| 783 | /* offset = log(Hz / 44100) / log(2) * 4096 */ |
| 784 | int freq, base, i; |
| 785 | |
| 786 | /* maybe smaller than max (44100Hz) */ |
| 787 | if (Hz <= 0 || Hz >= 44100) return 0; |
| 788 | |
| 789 | base = 0; |
| 790 | for (freq = Hz * 2; freq < 44100; freq *= 2) |
| 791 | base++; |
| 792 | base *= 1200; |
| 793 | |
| 794 | freq = 44100 * 10000 / (freq/2); |
| 795 | for (i = 0; i < 12; i++) { |
| 796 | if (freq < semitone_tuning[i+1]) |
| 797 | break; |
| 798 | base += 100; |
| 799 | } |
| 800 | freq = freq * 10000 / semitone_tuning[i]; |
| 801 | for (i = 0; i < 100; i++) { |
| 802 | if (freq < cent_tuning[i+1]) |
| 803 | break; |
| 804 | base++; |
| 805 | } |
| 806 | return -base * 4096 / 1200; |
| 807 | } |
| 808 | |
| 809 | |
| 810 | /* |
| 811 | * convert envelope time parameter to AWE32 raw parameter |
| 812 | */ |
| 813 | |
| 814 | /* attack & decay/release time table (msec) */ |
| 815 | static short attack_time_tbl[128] = { |
| 816 | 32767, 32767, 5989, 4235, 2994, 2518, 2117, 1780, 1497, 1373, 1259, 1154, 1058, 970, 890, 816, |
| 817 | 707, 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, |
| 818 | 361, 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, |
| 819 | 180, 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, |
| 820 | 90, 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, |
| 821 | 45, 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, |
| 822 | 22, 21, 20, 19, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12, |
| 823 | 11, 11, 10, 10, 10, 9, 9, 8, 8, 8, 8, 7, 7, 7, 6, 0, |
| 824 | }; |
| 825 | |
| 826 | static short decay_time_tbl[128] = { |
| 827 | 32767, 32767, 22614, 15990, 11307, 9508, 7995, 6723, 5653, 5184, 4754, 4359, 3997, 3665, 3361, 3082, |
| 828 | 2828, 2765, 2648, 2535, 2428, 2325, 2226, 2132, 2042, 1955, 1872, 1793, 1717, 1644, 1574, 1507, |
| 829 | 1443, 1382, 1324, 1267, 1214, 1162, 1113, 1066, 978, 936, 897, 859, 822, 787, 754, 722, |
| 830 | 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, 361, |
| 831 | 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, 180, |
| 832 | 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, 90, |
| 833 | 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, 45, |
| 834 | 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, 22, |
| 835 | }; |
| 836 | |
| 837 | #define calc_parm_delay(msec) (0x8000 - (msec) * 1000 / 725); |
| 838 | |
| 839 | /* delay time = 0x8000 - msec/92 */ |
| 840 | static int |
| 841 | calc_parm_hold(int msec) |
| 842 | { |
| 843 | int val = (0x7f * 92 - msec) / 92; |
| 844 | if (val < 1) val = 1; |
| 845 | if (val > 127) val = 127; |
| 846 | return val; |
| 847 | } |
| 848 | |
| 849 | /* attack time: search from time table */ |
| 850 | static int |
| 851 | calc_parm_attack(int msec) |
| 852 | { |
| 853 | return calc_parm_search(msec, attack_time_tbl); |
| 854 | } |
| 855 | |
| 856 | /* decay/release time: search from time table */ |
| 857 | static int |
| 858 | calc_parm_decay(int msec) |
| 859 | { |
| 860 | return calc_parm_search(msec, decay_time_tbl); |
| 861 | } |
| 862 | |
| 863 | /* search an index for specified time from given time table */ |
| 864 | static int |
| 865 | calc_parm_search(int msec, short *table) |
| 866 | { |
| 867 | int left = 1, right = 127, mid; |
| 868 | while (left < right) { |
| 869 | mid = (left + right) / 2; |
| 870 | if (msec < (int)table[mid]) |
| 871 | left = mid + 1; |
| 872 | else |
| 873 | right = mid; |
| 874 | } |
| 875 | return left; |
| 876 | } |
| 877 | #endif /* AWE_HAS_GUS_COMPATIBILITY */ |
| 878 | |
| 879 | |
| 880 | /* |
| 881 | * effects table |
| 882 | */ |
| 883 | |
| 884 | /* set an effect value */ |
| 885 | #define FX_FLAG_OFF 0 |
| 886 | #define FX_FLAG_SET 1 |
| 887 | #define FX_FLAG_ADD 2 |
| 888 | |
| 889 | #define FX_SET(rec,type,value) \ |
| 890 | ((rec)->flags[type] = FX_FLAG_SET, (rec)->val[type] = (value)) |
| 891 | #define FX_ADD(rec,type,value) \ |
| 892 | ((rec)->flags[type] = FX_FLAG_ADD, (rec)->val[type] = (value)) |
| 893 | #define FX_UNSET(rec,type) \ |
| 894 | ((rec)->flags[type] = FX_FLAG_OFF, (rec)->val[type] = 0) |
| 895 | |
| 896 | /* check the effect value is set */ |
| 897 | #define FX_ON(rec,type) ((rec)->flags[type]) |
| 898 | |
| 899 | #define PARM_BYTE 0 |
| 900 | #define PARM_WORD 1 |
| 901 | #define PARM_SIGN 2 |
| 902 | |
| 903 | static struct PARM_DEFS { |
| 904 | int type; /* byte or word */ |
| 905 | int low, high; /* value range */ |
| 906 | fx_affect_func realtime; /* realtime paramater change */ |
| 907 | } parm_defs[] = { |
| 908 | {PARM_WORD, 0, 0x8000, NULL}, /* env1 delay */ |
| 909 | {PARM_BYTE, 1, 0x7f, NULL}, /* env1 attack */ |
| 910 | {PARM_BYTE, 0, 0x7e, NULL}, /* env1 hold */ |
| 911 | {PARM_BYTE, 1, 0x7f, NULL}, /* env1 decay */ |
| 912 | {PARM_BYTE, 1, 0x7f, NULL}, /* env1 release */ |
| 913 | {PARM_BYTE, 0, 0x7f, NULL}, /* env1 sustain */ |
| 914 | {PARM_BYTE, 0, 0xff, NULL}, /* env1 pitch */ |
| 915 | {PARM_BYTE, 0, 0xff, NULL}, /* env1 cutoff */ |
| 916 | |
| 917 | {PARM_WORD, 0, 0x8000, NULL}, /* env2 delay */ |
| 918 | {PARM_BYTE, 1, 0x7f, NULL}, /* env2 attack */ |
| 919 | {PARM_BYTE, 0, 0x7e, NULL}, /* env2 hold */ |
| 920 | {PARM_BYTE, 1, 0x7f, NULL}, /* env2 decay */ |
| 921 | {PARM_BYTE, 1, 0x7f, NULL}, /* env2 release */ |
| 922 | {PARM_BYTE, 0, 0x7f, NULL}, /* env2 sustain */ |
| 923 | |
| 924 | {PARM_WORD, 0, 0x8000, NULL}, /* lfo1 delay */ |
| 925 | {PARM_BYTE, 0, 0xff, awe_fx_tremfrq}, /* lfo1 freq */ |
| 926 | {PARM_SIGN, -128, 127, awe_fx_tremfrq}, /* lfo1 volume */ |
| 927 | {PARM_SIGN, -128, 127, awe_fx_fmmod}, /* lfo1 pitch */ |
| 928 | {PARM_BYTE, 0, 0xff, awe_fx_fmmod}, /* lfo1 cutoff */ |
| 929 | |
| 930 | {PARM_WORD, 0, 0x8000, NULL}, /* lfo2 delay */ |
| 931 | {PARM_BYTE, 0, 0xff, awe_fx_fm2frq2}, /* lfo2 freq */ |
| 932 | {PARM_SIGN, -128, 127, awe_fx_fm2frq2}, /* lfo2 pitch */ |
| 933 | |
| 934 | {PARM_WORD, 0, 0xffff, awe_set_voice_pitch}, /* initial pitch */ |
| 935 | {PARM_BYTE, 0, 0xff, NULL}, /* chorus */ |
| 936 | {PARM_BYTE, 0, 0xff, NULL}, /* reverb */ |
| 937 | {PARM_BYTE, 0, 0xff, awe_set_volume}, /* initial cutoff */ |
| 938 | {PARM_BYTE, 0, 15, awe_fx_filterQ}, /* initial resonance */ |
| 939 | |
| 940 | {PARM_WORD, 0, 0xffff, NULL}, /* sample start */ |
| 941 | {PARM_WORD, 0, 0xffff, NULL}, /* loop start */ |
| 942 | {PARM_WORD, 0, 0xffff, NULL}, /* loop end */ |
| 943 | {PARM_WORD, 0, 0xffff, NULL}, /* coarse sample start */ |
| 944 | {PARM_WORD, 0, 0xffff, NULL}, /* coarse loop start */ |
| 945 | {PARM_WORD, 0, 0xffff, NULL}, /* coarse loop end */ |
| 946 | {PARM_BYTE, 0, 0xff, awe_set_volume}, /* initial attenuation */ |
| 947 | }; |
| 948 | |
| 949 | |
| 950 | static unsigned char |
| 951 | FX_BYTE(FX_Rec *rec, FX_Rec *lay, int type, unsigned char value) |
| 952 | { |
| 953 | int effect = 0; |
| 954 | int on = 0; |
| 955 | if (lay && (on = FX_ON(lay, type)) != 0) |
| 956 | effect = lay->val[type]; |
| 957 | if (!on && (on = FX_ON(rec, type)) != 0) |
| 958 | effect = rec->val[type]; |
| 959 | if (on == FX_FLAG_ADD) { |
| 960 | if (parm_defs[type].type == PARM_SIGN) { |
| 961 | if (value > 0x7f) |
| 962 | effect += (int)value - 0x100; |
| 963 | else |
| 964 | effect += (int)value; |
| 965 | } else { |
| 966 | effect += (int)value; |
| 967 | } |
| 968 | } |
| 969 | if (on) { |
| 970 | if (effect < parm_defs[type].low) |
| 971 | effect = parm_defs[type].low; |
| 972 | else if (effect > parm_defs[type].high) |
| 973 | effect = parm_defs[type].high; |
| 974 | return (unsigned char)effect; |
| 975 | } |
| 976 | return value; |
| 977 | } |
| 978 | |
| 979 | /* get word effect value */ |
| 980 | static unsigned short |
| 981 | FX_WORD(FX_Rec *rec, FX_Rec *lay, int type, unsigned short value) |
| 982 | { |
| 983 | int effect = 0; |
| 984 | int on = 0; |
| 985 | if (lay && (on = FX_ON(lay, type)) != 0) |
| 986 | effect = lay->val[type]; |
| 987 | if (!on && (on = FX_ON(rec, type)) != 0) |
| 988 | effect = rec->val[type]; |
| 989 | if (on == FX_FLAG_ADD) |
| 990 | effect += (int)value; |
| 991 | if (on) { |
| 992 | if (effect < parm_defs[type].low) |
| 993 | effect = parm_defs[type].low; |
| 994 | else if (effect > parm_defs[type].high) |
| 995 | effect = parm_defs[type].high; |
| 996 | return (unsigned short)effect; |
| 997 | } |
| 998 | return value; |
| 999 | } |
| 1000 | |
| 1001 | /* get word (upper=type1/lower=type2) effect value */ |
| 1002 | static unsigned short |
| 1003 | FX_COMB(FX_Rec *rec, FX_Rec *lay, int type1, int type2, unsigned short value) |
| 1004 | { |
| 1005 | unsigned short tmp; |
| 1006 | tmp = FX_BYTE(rec, lay, type1, (unsigned char)(value >> 8)); |
| 1007 | tmp <<= 8; |
| 1008 | tmp |= FX_BYTE(rec, lay, type2, (unsigned char)(value & 0xff)); |
| 1009 | return tmp; |
| 1010 | } |
| 1011 | |
| 1012 | /* address offset */ |
| 1013 | static int |
| 1014 | FX_OFFSET(FX_Rec *rec, FX_Rec *lay, int lo, int hi, int mode) |
| 1015 | { |
| 1016 | int addr = 0; |
| 1017 | if (lay && FX_ON(lay, hi)) |
| 1018 | addr = (short)lay->val[hi]; |
| 1019 | else if (FX_ON(rec, hi)) |
| 1020 | addr = (short)rec->val[hi]; |
| 1021 | addr = addr << 15; |
| 1022 | if (lay && FX_ON(lay, lo)) |
| 1023 | addr += (short)lay->val[lo]; |
| 1024 | else if (FX_ON(rec, lo)) |
| 1025 | addr += (short)rec->val[lo]; |
| 1026 | if (!(mode & AWE_SAMPLE_8BITS)) |
| 1027 | addr /= 2; |
| 1028 | return addr; |
| 1029 | } |
| 1030 | |
| 1031 | |
| 1032 | /* |
| 1033 | * turn on/off sample |
| 1034 | */ |
| 1035 | |
| 1036 | /* table for volume target calculation */ |
| 1037 | static unsigned short voltarget[16] = { |
| 1038 | 0xEAC0, 0XE0C8, 0XD740, 0XCE20, 0XC560, 0XBD08, 0XB500, 0XAD58, |
| 1039 | 0XA5F8, 0X9EF0, 0X9830, 0X91C0, 0X8B90, 0X85A8, 0X8000, 0X7A90 |
| 1040 | }; |
| 1041 | |
| 1042 | static void |
| 1043 | awe_note_on(int voice) |
| 1044 | { |
| 1045 | unsigned int temp; |
| 1046 | int addr; |
| 1047 | int vtarget, ftarget, ptarget, pitch; |
| 1048 | awe_voice_info *vp; |
| 1049 | awe_voice_parm_block *parm; |
| 1050 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1051 | FX_Rec *fx_lay = NULL; |
| 1052 | if (voices[voice].layer < MAX_LAYERS) |
| 1053 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1054 | |
| 1055 | /* A voice sample must assigned before calling */ |
| 1056 | if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| 1057 | return; |
| 1058 | |
| 1059 | parm = (awe_voice_parm_block*)&vp->parm; |
| 1060 | |
| 1061 | /* channel to be silent and idle */ |
| 1062 | awe_poke(AWE_DCYSUSV(voice), 0x0080); |
| 1063 | awe_poke(AWE_VTFT(voice), 0x0000FFFF); |
| 1064 | awe_poke(AWE_CVCF(voice), 0x0000FFFF); |
| 1065 | awe_poke(AWE_PTRX(voice), 0); |
| 1066 | awe_poke(AWE_CPF(voice), 0); |
| 1067 | |
| 1068 | /* set pitch offset */ |
| 1069 | awe_set_pitch(voice, TRUE); |
| 1070 | |
| 1071 | /* modulation & volume envelope */ |
| 1072 | if (parm->modatk >= 0x80 && parm->moddelay >= 0x8000) { |
| 1073 | awe_poke(AWE_ENVVAL(voice), 0xBFFF); |
| 1074 | pitch = (parm->env1pit<<4) + voices[voice].apitch; |
| 1075 | if (pitch > 0xffff) pitch = 0xffff; |
| 1076 | /* calculate filter target */ |
| 1077 | ftarget = parm->cutoff + parm->env1fc; |
| 1078 | limitvalue(ftarget, 0, 255); |
| 1079 | ftarget <<= 8; |
| 1080 | } else { |
| 1081 | awe_poke(AWE_ENVVAL(voice), |
| 1082 | FX_WORD(fx, fx_lay, AWE_FX_ENV1_DELAY, parm->moddelay)); |
| 1083 | ftarget = parm->cutoff; |
| 1084 | ftarget <<= 8; |
| 1085 | pitch = voices[voice].apitch; |
| 1086 | } |
| 1087 | |
| 1088 | /* calcualte pitch target */ |
| 1089 | if (pitch != 0xffff) { |
| 1090 | ptarget = 1 << (pitch >> 12); |
| 1091 | if (pitch & 0x800) ptarget += (ptarget*0x102e)/0x2710; |
| 1092 | if (pitch & 0x400) ptarget += (ptarget*0x764)/0x2710; |
| 1093 | if (pitch & 0x200) ptarget += (ptarget*0x389)/0x2710; |
| 1094 | ptarget += (ptarget>>1); |
| 1095 | if (ptarget > 0xffff) ptarget = 0xffff; |
| 1096 | |
| 1097 | } else ptarget = 0xffff; |
| 1098 | if (parm->modatk >= 0x80) |
| 1099 | awe_poke(AWE_ATKHLD(voice), |
| 1100 | FX_BYTE(fx, fx_lay, AWE_FX_ENV1_HOLD, parm->modhld) << 8 | 0x7f); |
| 1101 | else |
| 1102 | awe_poke(AWE_ATKHLD(voice), |
| 1103 | FX_COMB(fx, fx_lay, AWE_FX_ENV1_HOLD, AWE_FX_ENV1_ATTACK, |
| 1104 | vp->parm.modatkhld)); |
| 1105 | awe_poke(AWE_DCYSUS(voice), |
| 1106 | FX_COMB(fx, fx_lay, AWE_FX_ENV1_SUSTAIN, AWE_FX_ENV1_DECAY, |
| 1107 | vp->parm.moddcysus)); |
| 1108 | |
| 1109 | if (parm->volatk >= 0x80 && parm->voldelay >= 0x8000) { |
| 1110 | awe_poke(AWE_ENVVOL(voice), 0xBFFF); |
| 1111 | vtarget = voltarget[voices[voice].avol%0x10]>>(voices[voice].avol>>4); |
| 1112 | } else { |
| 1113 | awe_poke(AWE_ENVVOL(voice), |
| 1114 | FX_WORD(fx, fx_lay, AWE_FX_ENV2_DELAY, vp->parm.voldelay)); |
| 1115 | vtarget = 0; |
| 1116 | } |
| 1117 | if (parm->volatk >= 0x80) |
| 1118 | awe_poke(AWE_ATKHLDV(voice), |
| 1119 | FX_BYTE(fx, fx_lay, AWE_FX_ENV2_HOLD, parm->volhld) << 8 | 0x7f); |
| 1120 | else |
| 1121 | awe_poke(AWE_ATKHLDV(voice), |
| 1122 | FX_COMB(fx, fx_lay, AWE_FX_ENV2_HOLD, AWE_FX_ENV2_ATTACK, |
| 1123 | vp->parm.volatkhld)); |
| 1124 | /* decay/sustain parameter for volume envelope must be set at last */ |
| 1125 | |
| 1126 | /* cutoff and volume */ |
| 1127 | awe_set_volume(voice, TRUE); |
| 1128 | |
| 1129 | /* modulation envelope heights */ |
| 1130 | awe_poke(AWE_PEFE(voice), |
| 1131 | FX_COMB(fx, fx_lay, AWE_FX_ENV1_PITCH, AWE_FX_ENV1_CUTOFF, |
| 1132 | vp->parm.pefe)); |
| 1133 | |
| 1134 | /* lfo1/2 delay */ |
| 1135 | awe_poke(AWE_LFO1VAL(voice), |
| 1136 | FX_WORD(fx, fx_lay, AWE_FX_LFO1_DELAY, vp->parm.lfo1delay)); |
| 1137 | awe_poke(AWE_LFO2VAL(voice), |
| 1138 | FX_WORD(fx, fx_lay, AWE_FX_LFO2_DELAY, vp->parm.lfo2delay)); |
| 1139 | |
| 1140 | /* lfo1 pitch & cutoff shift */ |
| 1141 | awe_fx_fmmod(voice, TRUE); |
| 1142 | /* lfo1 volume & freq */ |
| 1143 | awe_fx_tremfrq(voice, TRUE); |
| 1144 | /* lfo2 pitch & freq */ |
| 1145 | awe_fx_fm2frq2(voice, TRUE); |
| 1146 | /* pan & loop start */ |
| 1147 | awe_set_pan(voice, TRUE); |
| 1148 | |
| 1149 | /* chorus & loop end (chorus 8bit, MSB) */ |
| 1150 | addr = vp->loopend - 1; |
| 1151 | addr += FX_OFFSET(fx, fx_lay, AWE_FX_LOOP_END, |
| 1152 | AWE_FX_COARSE_LOOP_END, vp->mode); |
| 1153 | temp = FX_BYTE(fx, fx_lay, AWE_FX_CHORUS, vp->parm.chorus); |
| 1154 | temp = (temp <<24) | (unsigned int)addr; |
| 1155 | awe_poke_dw(AWE_CSL(voice), temp); |
| 1156 | DEBUG(4,printk("AWE32: [-- loopend=%x/%x]\n", vp->loopend, addr)); |
| 1157 | |
| 1158 | /* Q & current address (Q 4bit value, MSB) */ |
| 1159 | addr = vp->start - 1; |
| 1160 | addr += FX_OFFSET(fx, fx_lay, AWE_FX_SAMPLE_START, |
| 1161 | AWE_FX_COARSE_SAMPLE_START, vp->mode); |
| 1162 | temp = FX_BYTE(fx, fx_lay, AWE_FX_FILTERQ, vp->parm.filterQ); |
| 1163 | temp = (temp<<28) | (unsigned int)addr; |
| 1164 | awe_poke_dw(AWE_CCCA(voice), temp); |
| 1165 | DEBUG(4,printk("AWE32: [-- startaddr=%x/%x]\n", vp->start, addr)); |
| 1166 | |
| 1167 | /* clear unknown registers */ |
| 1168 | awe_poke_dw(AWE_00A0(voice), 0); |
| 1169 | awe_poke_dw(AWE_0080(voice), 0); |
| 1170 | |
| 1171 | /* reset volume */ |
| 1172 | awe_poke_dw(AWE_VTFT(voice), (vtarget<<16)|ftarget); |
| 1173 | awe_poke_dw(AWE_CVCF(voice), (vtarget<<16)|ftarget); |
| 1174 | |
| 1175 | /* set reverb */ |
| 1176 | temp = FX_BYTE(fx, fx_lay, AWE_FX_REVERB, vp->parm.reverb); |
| 1177 | temp = (temp << 8) | (ptarget << 16) | voices[voice].aaux; |
| 1178 | awe_poke_dw(AWE_PTRX(voice), temp); |
| 1179 | awe_poke_dw(AWE_CPF(voice), ptarget << 16); |
| 1180 | /* turn on envelope */ |
| 1181 | awe_poke(AWE_DCYSUSV(voice), |
| 1182 | FX_COMB(fx, fx_lay, AWE_FX_ENV2_SUSTAIN, AWE_FX_ENV2_DECAY, |
| 1183 | vp->parm.voldcysus)); |
| 1184 | |
| 1185 | voices[voice].state = AWE_ST_ON; |
| 1186 | |
| 1187 | /* clear voice position for the next note on this channel */ |
| 1188 | if (SINGLE_LAYER_MODE()) { |
| 1189 | FX_UNSET(fx, AWE_FX_SAMPLE_START); |
| 1190 | FX_UNSET(fx, AWE_FX_COARSE_SAMPLE_START); |
| 1191 | } |
| 1192 | } |
| 1193 | |
| 1194 | |
| 1195 | /* turn off the voice */ |
| 1196 | static void |
| 1197 | awe_note_off(int voice) |
| 1198 | { |
| 1199 | awe_voice_info *vp; |
| 1200 | unsigned short tmp; |
| 1201 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1202 | FX_Rec *fx_lay = NULL; |
| 1203 | if (voices[voice].layer < MAX_LAYERS) |
| 1204 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1205 | |
| 1206 | if ((vp = voices[voice].sample) == NULL) { |
| 1207 | voices[voice].state = AWE_ST_OFF; |
| 1208 | return; |
| 1209 | } |
| 1210 | |
| 1211 | tmp = 0x8000 | FX_BYTE(fx, fx_lay, AWE_FX_ENV1_RELEASE, |
| 1212 | (unsigned char)vp->parm.modrelease); |
| 1213 | awe_poke(AWE_DCYSUS(voice), tmp); |
| 1214 | tmp = 0x8000 | FX_BYTE(fx, fx_lay, AWE_FX_ENV2_RELEASE, |
| 1215 | (unsigned char)vp->parm.volrelease); |
| 1216 | awe_poke(AWE_DCYSUSV(voice), tmp); |
| 1217 | voices[voice].state = AWE_ST_RELEASED; |
| 1218 | } |
| 1219 | |
| 1220 | /* force to terminate the voice (no releasing echo) */ |
| 1221 | static void |
| 1222 | awe_terminate(int voice) |
| 1223 | { |
| 1224 | awe_poke(AWE_DCYSUSV(voice), 0x807F); |
| 1225 | awe_tweak_voice(voice); |
| 1226 | voices[voice].state = AWE_ST_OFF; |
| 1227 | } |
| 1228 | |
| 1229 | /* turn off other voices with the same exclusive class (for drums) */ |
| 1230 | static void |
| 1231 | awe_exclusive_off(int voice) |
| 1232 | { |
| 1233 | int i, exclass; |
| 1234 | |
| 1235 | if (voices[voice].sample == NULL) |
| 1236 | return; |
| 1237 | if ((exclass = voices[voice].sample->exclusiveClass) == 0) |
| 1238 | return; /* not exclusive */ |
| 1239 | |
| 1240 | /* turn off voices with the same class */ |
| 1241 | for (i = 0; i < awe_max_voices; i++) { |
| 1242 | if (i != voice && IS_PLAYING(i) && |
| 1243 | voices[i].sample && voices[i].ch == voices[voice].ch && |
| 1244 | voices[i].sample->exclusiveClass == exclass) { |
| 1245 | DEBUG(4,printk("AWE32: [exoff(%d)]\n", i)); |
| 1246 | awe_terminate(i); |
| 1247 | awe_voice_init(i, TRUE); |
| 1248 | } |
| 1249 | } |
| 1250 | } |
| 1251 | |
| 1252 | |
| 1253 | /* |
| 1254 | * change the parameters of an audible voice |
| 1255 | */ |
| 1256 | |
| 1257 | /* change pitch */ |
| 1258 | static void |
| 1259 | awe_set_pitch(int voice, int forced) |
| 1260 | { |
| 1261 | if (IS_NO_EFFECT(voice) && !forced) return; |
| 1262 | awe_poke(AWE_IP(voice), voices[voice].apitch); |
| 1263 | DEBUG(3,printk("AWE32: [-- pitch=%x]\n", voices[voice].apitch)); |
| 1264 | } |
| 1265 | |
| 1266 | /* calculate & change pitch */ |
| 1267 | static void |
| 1268 | awe_set_voice_pitch(int voice, int forced) |
| 1269 | { |
| 1270 | awe_calc_pitch(voice); |
| 1271 | awe_set_pitch(voice, forced); |
| 1272 | } |
| 1273 | |
| 1274 | /* change volume & cutoff */ |
| 1275 | static void |
| 1276 | awe_set_volume(int voice, int forced) |
| 1277 | { |
| 1278 | awe_voice_info *vp; |
| 1279 | unsigned short tmp2; |
| 1280 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1281 | FX_Rec *fx_lay = NULL; |
| 1282 | if (voices[voice].layer < MAX_LAYERS) |
| 1283 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1284 | |
| 1285 | if (!IS_PLAYING(voice) && !forced) return; |
| 1286 | if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| 1287 | return; |
| 1288 | |
| 1289 | tmp2 = FX_BYTE(fx, fx_lay, AWE_FX_CUTOFF, |
| 1290 | (unsigned char)voices[voice].acutoff); |
| 1291 | tmp2 = (tmp2 << 8); |
| 1292 | tmp2 |= FX_BYTE(fx, fx_lay, AWE_FX_ATTEN, |
| 1293 | (unsigned char)voices[voice].avol); |
| 1294 | awe_poke(AWE_IFATN(voice), tmp2); |
| 1295 | } |
| 1296 | |
| 1297 | /* calculate & change volume */ |
| 1298 | static void |
| 1299 | awe_set_voice_vol(int voice, int forced) |
| 1300 | { |
| 1301 | if (IS_EMPTY(voice)) |
| 1302 | return; |
| 1303 | awe_calc_volume(voice); |
| 1304 | awe_set_volume(voice, forced); |
| 1305 | } |
| 1306 | |
| 1307 | |
| 1308 | /* change pan; this could make a click noise.. */ |
| 1309 | static void |
| 1310 | awe_set_pan(int voice, int forced) |
| 1311 | { |
| 1312 | unsigned int temp; |
| 1313 | int addr; |
| 1314 | awe_voice_info *vp; |
| 1315 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1316 | FX_Rec *fx_lay = NULL; |
| 1317 | if (voices[voice].layer < MAX_LAYERS) |
| 1318 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1319 | |
| 1320 | if (IS_NO_EFFECT(voice) && !forced) return; |
| 1321 | if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| 1322 | return; |
| 1323 | |
| 1324 | /* pan & loop start (pan 8bit, MSB, 0:right, 0xff:left) */ |
| 1325 | if (vp->fixpan > 0) /* 0-127 */ |
| 1326 | temp = 255 - (int)vp->fixpan * 2; |
| 1327 | else { |
| 1328 | int pos = 0; |
| 1329 | if (vp->pan >= 0) /* 0-127 */ |
| 1330 | pos = (int)vp->pan * 2 - 128; |
| 1331 | pos += voices[voice].cinfo->panning; /* -128 - 127 */ |
| 1332 | temp = 127 - pos; |
| 1333 | } |
| 1334 | limitvalue(temp, 0, 255); |
| 1335 | if (ctrls[AWE_MD_PAN_EXCHANGE]) { |
| 1336 | temp = 255 - temp; |
| 1337 | } |
| 1338 | if (forced || temp != voices[voice].apan) { |
| 1339 | voices[voice].apan = temp; |
| 1340 | if (temp == 0) |
| 1341 | voices[voice].aaux = 0xff; |
| 1342 | else |
| 1343 | voices[voice].aaux = (-temp) & 0xff; |
| 1344 | addr = vp->loopstart - 1; |
| 1345 | addr += FX_OFFSET(fx, fx_lay, AWE_FX_LOOP_START, |
| 1346 | AWE_FX_COARSE_LOOP_START, vp->mode); |
| 1347 | temp = (temp<<24) | (unsigned int)addr; |
| 1348 | awe_poke_dw(AWE_PSST(voice), temp); |
| 1349 | DEBUG(4,printk("AWE32: [-- loopstart=%x/%x]\n", vp->loopstart, addr)); |
| 1350 | } |
| 1351 | } |
| 1352 | |
| 1353 | /* effects change during playing */ |
| 1354 | static void |
| 1355 | awe_fx_fmmod(int voice, int forced) |
| 1356 | { |
| 1357 | awe_voice_info *vp; |
| 1358 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1359 | FX_Rec *fx_lay = NULL; |
| 1360 | if (voices[voice].layer < MAX_LAYERS) |
| 1361 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1362 | |
| 1363 | if (IS_NO_EFFECT(voice) && !forced) return; |
| 1364 | if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| 1365 | return; |
| 1366 | awe_poke(AWE_FMMOD(voice), |
| 1367 | FX_COMB(fx, fx_lay, AWE_FX_LFO1_PITCH, AWE_FX_LFO1_CUTOFF, |
| 1368 | vp->parm.fmmod)); |
| 1369 | } |
| 1370 | |
| 1371 | /* set tremolo (lfo1) volume & frequency */ |
| 1372 | static void |
| 1373 | awe_fx_tremfrq(int voice, int forced) |
| 1374 | { |
| 1375 | awe_voice_info *vp; |
| 1376 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1377 | FX_Rec *fx_lay = NULL; |
| 1378 | if (voices[voice].layer < MAX_LAYERS) |
| 1379 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1380 | |
| 1381 | if (IS_NO_EFFECT(voice) && !forced) return; |
| 1382 | if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| 1383 | return; |
| 1384 | awe_poke(AWE_TREMFRQ(voice), |
| 1385 | FX_COMB(fx, fx_lay, AWE_FX_LFO1_VOLUME, AWE_FX_LFO1_FREQ, |
| 1386 | vp->parm.tremfrq)); |
| 1387 | } |
| 1388 | |
| 1389 | /* set lfo2 pitch & frequency */ |
| 1390 | static void |
| 1391 | awe_fx_fm2frq2(int voice, int forced) |
| 1392 | { |
| 1393 | awe_voice_info *vp; |
| 1394 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1395 | FX_Rec *fx_lay = NULL; |
| 1396 | if (voices[voice].layer < MAX_LAYERS) |
| 1397 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1398 | |
| 1399 | if (IS_NO_EFFECT(voice) && !forced) return; |
| 1400 | if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| 1401 | return; |
| 1402 | awe_poke(AWE_FM2FRQ2(voice), |
| 1403 | FX_COMB(fx, fx_lay, AWE_FX_LFO2_PITCH, AWE_FX_LFO2_FREQ, |
| 1404 | vp->parm.fm2frq2)); |
| 1405 | } |
| 1406 | |
| 1407 | |
| 1408 | /* Q & current address (Q 4bit value, MSB) */ |
| 1409 | static void |
| 1410 | awe_fx_filterQ(int voice, int forced) |
| 1411 | { |
| 1412 | unsigned int addr; |
| 1413 | awe_voice_info *vp; |
| 1414 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1415 | FX_Rec *fx_lay = NULL; |
| 1416 | if (voices[voice].layer < MAX_LAYERS) |
| 1417 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1418 | |
| 1419 | if (IS_NO_EFFECT(voice) && !forced) return; |
| 1420 | if ((vp = voices[voice].sample) == NULL || vp->index == 0) |
| 1421 | return; |
| 1422 | |
| 1423 | addr = awe_peek_dw(AWE_CCCA(voice)) & 0xffffff; |
| 1424 | addr |= (FX_BYTE(fx, fx_lay, AWE_FX_FILTERQ, vp->parm.filterQ) << 28); |
| 1425 | awe_poke_dw(AWE_CCCA(voice), addr); |
| 1426 | } |
| 1427 | |
| 1428 | /* |
| 1429 | * calculate pitch offset |
| 1430 | * |
| 1431 | * 0xE000 is no pitch offset at 44100Hz sample. |
| 1432 | * Every 4096 is one octave. |
| 1433 | */ |
| 1434 | |
| 1435 | static void |
| 1436 | awe_calc_pitch(int voice) |
| 1437 | { |
| 1438 | voice_info *vp = &voices[voice]; |
| 1439 | awe_voice_info *ap; |
| 1440 | awe_chan_info *cp = voices[voice].cinfo; |
| 1441 | int offset; |
| 1442 | |
| 1443 | /* search voice information */ |
| 1444 | if ((ap = vp->sample) == NULL) |
| 1445 | return; |
| 1446 | if (ap->index == 0) { |
| 1447 | DEBUG(3,printk("AWE32: set sample (%d)\n", ap->sample)); |
| 1448 | if (awe_set_sample((awe_voice_list*)ap) == 0) |
| 1449 | return; |
| 1450 | } |
| 1451 | |
| 1452 | /* calculate offset */ |
| 1453 | if (ap->fixkey >= 0) { |
| 1454 | DEBUG(3,printk("AWE32: p-> fixkey(%d) tune(%d)\n", ap->fixkey, ap->tune)); |
| 1455 | offset = (ap->fixkey - ap->root) * 4096 / 12; |
| 1456 | } else { |
| 1457 | DEBUG(3,printk("AWE32: p(%d)-> root(%d) tune(%d)\n", vp->note, ap->root, ap->tune)); |
| 1458 | offset = (vp->note - ap->root) * 4096 / 12; |
| 1459 | DEBUG(4,printk("AWE32: p-> ofs=%d\n", offset)); |
| 1460 | } |
| 1461 | offset = (offset * ap->scaleTuning) / 100; |
| 1462 | DEBUG(4,printk("AWE32: p-> scale* ofs=%d\n", offset)); |
| 1463 | offset += ap->tune * 4096 / 1200; |
| 1464 | DEBUG(4,printk("AWE32: p-> tune+ ofs=%d\n", offset)); |
| 1465 | if (cp->bender != 0) { |
| 1466 | DEBUG(3,printk("AWE32: p-> bend(%d) %d\n", voice, cp->bender)); |
| 1467 | /* (819200: 1 semitone) ==> (4096: 12 semitones) */ |
| 1468 | offset += cp->bender * cp->bender_range / 2400; |
| 1469 | } |
| 1470 | |
| 1471 | /* add initial pitch correction */ |
| 1472 | if (FX_ON(&cp->fx_layer[vp->layer], AWE_FX_INIT_PITCH)) |
| 1473 | offset += cp->fx_layer[vp->layer].val[AWE_FX_INIT_PITCH]; |
| 1474 | else if (FX_ON(&cp->fx, AWE_FX_INIT_PITCH)) |
| 1475 | offset += cp->fx.val[AWE_FX_INIT_PITCH]; |
| 1476 | |
| 1477 | /* 0xe000: root pitch */ |
| 1478 | vp->apitch = 0xe000 + ap->rate_offset + offset; |
| 1479 | DEBUG(4,printk("AWE32: p-> sum aofs=%x, rate_ofs=%d\n", vp->apitch, ap->rate_offset)); |
| 1480 | if (vp->apitch > 0xffff) |
| 1481 | vp->apitch = 0xffff; |
| 1482 | if (vp->apitch < 0) |
| 1483 | vp->apitch = 0; |
| 1484 | } |
| 1485 | |
| 1486 | |
| 1487 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 1488 | /* calculate MIDI key and semitone from the specified frequency */ |
| 1489 | static void |
| 1490 | awe_calc_pitch_from_freq(int voice, int freq) |
| 1491 | { |
| 1492 | voice_info *vp = &voices[voice]; |
| 1493 | awe_voice_info *ap; |
| 1494 | FX_Rec *fx = &voices[voice].cinfo->fx; |
| 1495 | FX_Rec *fx_lay = NULL; |
| 1496 | int offset; |
| 1497 | int note; |
| 1498 | |
| 1499 | if (voices[voice].layer < MAX_LAYERS) |
| 1500 | fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer]; |
| 1501 | |
| 1502 | /* search voice information */ |
| 1503 | if ((ap = vp->sample) == NULL) |
| 1504 | return; |
| 1505 | if (ap->index == 0) { |
| 1506 | DEBUG(3,printk("AWE32: set sample (%d)\n", ap->sample)); |
| 1507 | if (awe_set_sample((awe_voice_list*)ap) == 0) |
| 1508 | return; |
| 1509 | } |
| 1510 | note = freq_to_note(freq); |
| 1511 | offset = (note - ap->root * 100 + ap->tune) * 4096 / 1200; |
| 1512 | offset = (offset * ap->scaleTuning) / 100; |
| 1513 | if (fx_lay && FX_ON(fx_lay, AWE_FX_INIT_PITCH)) |
| 1514 | offset += fx_lay->val[AWE_FX_INIT_PITCH]; |
| 1515 | else if (FX_ON(fx, AWE_FX_INIT_PITCH)) |
| 1516 | offset += fx->val[AWE_FX_INIT_PITCH]; |
| 1517 | vp->apitch = 0xe000 + ap->rate_offset + offset; |
| 1518 | if (vp->apitch > 0xffff) |
| 1519 | vp->apitch = 0xffff; |
| 1520 | if (vp->apitch < 0) |
| 1521 | vp->apitch = 0; |
| 1522 | } |
| 1523 | #endif /* AWE_HAS_GUS_COMPATIBILITY */ |
| 1524 | |
| 1525 | |
| 1526 | /* |
| 1527 | * calculate volume attenuation |
| 1528 | * |
| 1529 | * Voice volume is controlled by volume attenuation parameter. |
| 1530 | * So volume becomes maximum when avol is 0 (no attenuation), and |
| 1531 | * minimum when 255 (-96dB or silence). |
| 1532 | */ |
| 1533 | |
| 1534 | static int vol_table[128] = { |
| 1535 | 255,111,95,86,79,74,70,66,63,61,58,56,54,52,50,49, |
| 1536 | 47,46,45,43,42,41,40,39,38,37,36,35,34,34,33,32, |
| 1537 | 31,31,30,29,29,28,27,27,26,26,25,24,24,23,23,22, |
| 1538 | 22,21,21,21,20,20,19,19,18,18,18,17,17,16,16,16, |
| 1539 | 15,15,15,14,14,14,13,13,13,12,12,12,11,11,11,10, |
| 1540 | 10,10,10,9,9,9,8,8,8,8,7,7,7,7,6,6, |
| 1541 | 6,6,5,5,5,5,5,4,4,4,4,3,3,3,3,3, |
| 1542 | 2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,0, |
| 1543 | }; |
| 1544 | |
| 1545 | /* tables for volume->attenuation calculation */ |
| 1546 | static unsigned char voltab1[128] = { |
| 1547 | 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, |
| 1548 | 0x63, 0x2b, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, |
| 1549 | 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, |
| 1550 | 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, |
| 1551 | 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, |
| 1552 | 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, |
| 1553 | 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, |
| 1554 | 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, |
| 1555 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, |
| 1556 | 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, |
| 1557 | 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, |
| 1558 | 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, |
| 1559 | 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| 1560 | }; |
| 1561 | |
| 1562 | static unsigned char voltab2[128] = { |
| 1563 | 0x32, 0x31, 0x30, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x2a, |
| 1564 | 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21, |
| 1565 | 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, |
| 1566 | 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x16, 0x16, 0x15, 0x15, |
| 1567 | 0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x10, |
| 1568 | 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, |
| 1569 | 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, |
| 1570 | 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, |
| 1571 | 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, |
| 1572 | 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, |
| 1573 | 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, |
| 1574 | 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, |
| 1575 | 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 |
| 1576 | }; |
| 1577 | |
| 1578 | static unsigned char expressiontab[128] = { |
| 1579 | 0x7f, 0x6c, 0x62, 0x5a, 0x54, 0x50, 0x4b, 0x48, 0x45, 0x42, |
| 1580 | 0x40, 0x3d, 0x3b, 0x39, 0x38, 0x36, 0x34, 0x33, 0x31, 0x30, |
| 1581 | 0x2f, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25, |
| 1582 | 0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x20, 0x1f, 0x1e, 0x1e, |
| 1583 | 0x1d, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x18, |
| 1584 | 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13, |
| 1585 | 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f, |
| 1586 | 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, |
| 1587 | 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, |
| 1588 | 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, |
| 1589 | 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, |
| 1590 | 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, |
| 1591 | 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| 1592 | }; |
| 1593 | |
| 1594 | static void |
| 1595 | awe_calc_volume(int voice) |
| 1596 | { |
| 1597 | voice_info *vp = &voices[voice]; |
| 1598 | awe_voice_info *ap; |
| 1599 | awe_chan_info *cp = voices[voice].cinfo; |
| 1600 | int vol; |
| 1601 | |
| 1602 | /* search voice information */ |
| 1603 | if ((ap = vp->sample) == NULL) |
| 1604 | return; |
| 1605 | |
| 1606 | ap = vp->sample; |
| 1607 | if (ap->index == 0) { |
| 1608 | DEBUG(3,printk("AWE32: set sample (%d)\n", ap->sample)); |
| 1609 | if (awe_set_sample((awe_voice_list*)ap) == 0) |
| 1610 | return; |
| 1611 | } |
| 1612 | |
| 1613 | if (ctrls[AWE_MD_NEW_VOLUME_CALC]) { |
| 1614 | int main_vol = cp->main_vol * ap->amplitude / 127; |
| 1615 | limitvalue(vp->velocity, 0, 127); |
| 1616 | limitvalue(main_vol, 0, 127); |
| 1617 | limitvalue(cp->expression_vol, 0, 127); |
| 1618 | |
| 1619 | vol = voltab1[main_vol] + voltab2[vp->velocity]; |
| 1620 | vol = (vol * 8) / 3; |
| 1621 | vol += ap->attenuation; |
| 1622 | if (cp->expression_vol < 127) |
| 1623 | vol += ((0x100 - vol) * expressiontab[cp->expression_vol])/128; |
| 1624 | vol += atten_offset; |
| 1625 | if (atten_relative) |
| 1626 | vol += ctrls[AWE_MD_ZERO_ATTEN]; |
| 1627 | limitvalue(vol, 0, 255); |
| 1628 | vp->avol = vol; |
| 1629 | |
| 1630 | } else { |
| 1631 | /* 0 - 127 */ |
| 1632 | vol = (vp->velocity * cp->main_vol * cp->expression_vol) / (127*127); |
| 1633 | vol = vol * ap->amplitude / 127; |
| 1634 | |
| 1635 | if (vol < 0) vol = 0; |
| 1636 | if (vol > 127) vol = 127; |
| 1637 | |
| 1638 | /* calc to attenuation */ |
| 1639 | vol = vol_table[vol]; |
| 1640 | vol += (int)ap->attenuation; |
| 1641 | vol += atten_offset; |
| 1642 | if (atten_relative) |
| 1643 | vol += ctrls[AWE_MD_ZERO_ATTEN]; |
| 1644 | if (vol > 255) vol = 255; |
| 1645 | |
| 1646 | vp->avol = vol; |
| 1647 | } |
| 1648 | if (cp->bank != AWE_DRUM_BANK && ((awe_voice_parm_block*)(&ap->parm))->volatk < 0x7d) { |
| 1649 | int atten; |
| 1650 | if (vp->velocity < 70) atten = 70; |
| 1651 | else atten = vp->velocity; |
| 1652 | vp->acutoff = (atten * ap->parm.cutoff + 0xa0) >> 7; |
| 1653 | } else { |
| 1654 | vp->acutoff = ap->parm.cutoff; |
| 1655 | } |
| 1656 | DEBUG(3,printk("AWE32: [-- voice(%d) vol=%x]\n", voice, vol)); |
| 1657 | } |
| 1658 | |
| 1659 | /* change master volume */ |
| 1660 | static void |
| 1661 | awe_change_master_volume(short val) |
| 1662 | { |
| 1663 | limitvalue(val, 0, 127); |
| 1664 | atten_offset = vol_table[val]; |
| 1665 | atten_relative = TRUE; |
| 1666 | awe_update_volume(); |
| 1667 | } |
| 1668 | |
| 1669 | /* update volumes of all available channels */ |
| 1670 | static void awe_update_volume(void) |
| 1671 | { |
| 1672 | int i; |
| 1673 | for (i = 0; i < awe_max_voices; i++) |
| 1674 | awe_set_voice_vol(i, TRUE); |
| 1675 | } |
| 1676 | |
| 1677 | /* set sostenuto on */ |
| 1678 | static void awe_sostenuto_on(int voice, int forced) |
| 1679 | { |
| 1680 | if (IS_NO_EFFECT(voice) && !forced) return; |
| 1681 | voices[voice].sostenuto = 127; |
| 1682 | } |
| 1683 | |
| 1684 | |
| 1685 | /* drop sustain */ |
| 1686 | static void awe_sustain_off(int voice, int forced) |
| 1687 | { |
| 1688 | if (voices[voice].state == AWE_ST_SUSTAINED) { |
| 1689 | awe_note_off(voice); |
| 1690 | awe_fx_init(voices[voice].ch); |
| 1691 | awe_voice_init(voice, FALSE); |
| 1692 | } |
| 1693 | } |
| 1694 | |
| 1695 | |
| 1696 | /* terminate and initialize voice */ |
| 1697 | static void awe_terminate_and_init(int voice, int forced) |
| 1698 | { |
| 1699 | awe_terminate(voice); |
| 1700 | awe_fx_init(voices[voice].ch); |
| 1701 | awe_voice_init(voice, TRUE); |
| 1702 | } |
| 1703 | |
| 1704 | |
| 1705 | /* |
| 1706 | * synth operation routines |
| 1707 | */ |
| 1708 | |
| 1709 | #define AWE_VOICE_KEY(v) (0x8000 | (v)) |
| 1710 | #define AWE_CHAN_KEY(c,n) (((c) << 8) | ((n) + 1)) |
| 1711 | #define KEY_CHAN_MATCH(key,c) (((key) >> 8) == (c)) |
| 1712 | |
| 1713 | /* initialize the voice */ |
| 1714 | static void |
| 1715 | awe_voice_init(int voice, int init_all) |
| 1716 | { |
| 1717 | voice_info *vp = &voices[voice]; |
| 1718 | |
| 1719 | /* reset voice search key */ |
| 1720 | if (playing_mode == AWE_PLAY_DIRECT) |
| 1721 | vp->key = AWE_VOICE_KEY(voice); |
| 1722 | else |
| 1723 | vp->key = 0; |
| 1724 | |
| 1725 | /* clear voice mapping */ |
| 1726 | voice_alloc->map[voice] = 0; |
| 1727 | |
| 1728 | /* touch the timing flag */ |
| 1729 | vp->time = current_alloc_time; |
| 1730 | |
| 1731 | /* initialize other parameters if necessary */ |
| 1732 | if (init_all) { |
| 1733 | vp->note = -1; |
| 1734 | vp->velocity = 0; |
| 1735 | vp->sostenuto = 0; |
| 1736 | |
| 1737 | vp->sample = NULL; |
| 1738 | vp->cinfo = &channels[voice]; |
| 1739 | vp->ch = voice; |
| 1740 | vp->state = AWE_ST_OFF; |
| 1741 | |
| 1742 | /* emu8000 parameters */ |
| 1743 | vp->apitch = 0; |
| 1744 | vp->avol = 255; |
| 1745 | vp->apan = -1; |
| 1746 | } |
| 1747 | } |
| 1748 | |
| 1749 | /* clear effects */ |
| 1750 | static void awe_fx_init(int ch) |
| 1751 | { |
| 1752 | if (SINGLE_LAYER_MODE() && !ctrls[AWE_MD_KEEP_EFFECT]) { |
| 1753 | memset(&channels[ch].fx, 0, sizeof(channels[ch].fx)); |
| 1754 | memset(&channels[ch].fx_layer, 0, sizeof(&channels[ch].fx_layer)); |
| 1755 | } |
| 1756 | } |
| 1757 | |
| 1758 | /* initialize channel info */ |
| 1759 | static void awe_channel_init(int ch, int init_all) |
| 1760 | { |
| 1761 | awe_chan_info *cp = &channels[ch]; |
| 1762 | cp->channel = ch; |
| 1763 | if (init_all) { |
| 1764 | cp->panning = 0; /* zero center */ |
| 1765 | cp->bender_range = 200; /* sense * 100 */ |
| 1766 | cp->main_vol = 127; |
| 1767 | if (MULTI_LAYER_MODE() && IS_DRUM_CHANNEL(ch)) { |
| 1768 | cp->instr = ctrls[AWE_MD_DEF_DRUM]; |
| 1769 | cp->bank = AWE_DRUM_BANK; |
| 1770 | } else { |
| 1771 | cp->instr = ctrls[AWE_MD_DEF_PRESET]; |
| 1772 | cp->bank = ctrls[AWE_MD_DEF_BANK]; |
| 1773 | } |
| 1774 | } |
| 1775 | |
| 1776 | cp->bender = 0; /* zero tune skew */ |
| 1777 | cp->expression_vol = 127; |
| 1778 | cp->chan_press = 0; |
| 1779 | cp->sustained = 0; |
| 1780 | |
| 1781 | if (! ctrls[AWE_MD_KEEP_EFFECT]) { |
| 1782 | memset(&cp->fx, 0, sizeof(cp->fx)); |
| 1783 | memset(&cp->fx_layer, 0, sizeof(cp->fx_layer)); |
| 1784 | } |
| 1785 | } |
| 1786 | |
| 1787 | |
| 1788 | /* change the voice parameters; voice = channel */ |
| 1789 | static void awe_voice_change(int voice, fx_affect_func func) |
| 1790 | { |
| 1791 | int i; |
| 1792 | switch (playing_mode) { |
| 1793 | case AWE_PLAY_DIRECT: |
| 1794 | func(voice, FALSE); |
| 1795 | break; |
| 1796 | case AWE_PLAY_INDIRECT: |
| 1797 | for (i = 0; i < awe_max_voices; i++) |
| 1798 | if (voices[i].key == AWE_VOICE_KEY(voice)) |
| 1799 | func(i, FALSE); |
| 1800 | break; |
| 1801 | default: |
| 1802 | for (i = 0; i < awe_max_voices; i++) |
| 1803 | if (KEY_CHAN_MATCH(voices[i].key, voice)) |
| 1804 | func(i, FALSE); |
| 1805 | break; |
| 1806 | } |
| 1807 | } |
| 1808 | |
| 1809 | |
| 1810 | /* |
| 1811 | * device open / close |
| 1812 | */ |
| 1813 | |
| 1814 | /* open device: |
| 1815 | * reset status of all voices, and clear sample position flag |
| 1816 | */ |
| 1817 | static int |
| 1818 | awe_open(int dev, int mode) |
| 1819 | { |
| 1820 | if (awe_busy) |
| 1821 | return -EBUSY; |
| 1822 | |
| 1823 | awe_busy = TRUE; |
| 1824 | |
| 1825 | /* set default mode */ |
| 1826 | awe_init_ctrl_parms(FALSE); |
| 1827 | atten_relative = TRUE; |
| 1828 | atten_offset = 0; |
| 1829 | drum_flags = DEFAULT_DRUM_FLAGS; |
| 1830 | playing_mode = AWE_PLAY_INDIRECT; |
| 1831 | |
| 1832 | /* reset voices & channels */ |
| 1833 | awe_reset(dev); |
| 1834 | |
| 1835 | patch_opened = 0; |
| 1836 | |
| 1837 | return 0; |
| 1838 | } |
| 1839 | |
| 1840 | |
| 1841 | /* close device: |
| 1842 | * reset all voices again (terminate sounds) |
| 1843 | */ |
| 1844 | static void |
| 1845 | awe_close(int dev) |
| 1846 | { |
| 1847 | awe_reset(dev); |
| 1848 | awe_busy = FALSE; |
| 1849 | } |
| 1850 | |
| 1851 | |
| 1852 | /* set miscellaneous mode parameters |
| 1853 | */ |
| 1854 | static void |
| 1855 | awe_init_ctrl_parms(int init_all) |
| 1856 | { |
| 1857 | int i; |
| 1858 | for (i = 0; i < AWE_MD_END; i++) { |
| 1859 | if (init_all || ctrl_parms[i].init_each_time) |
| 1860 | ctrls[i] = ctrl_parms[i].value; |
| 1861 | } |
| 1862 | } |
| 1863 | |
| 1864 | |
| 1865 | /* sequencer I/O control: |
| 1866 | */ |
| 1867 | static int |
| 1868 | awe_ioctl(int dev, unsigned int cmd, void __user *arg) |
| 1869 | { |
| 1870 | switch (cmd) { |
| 1871 | case SNDCTL_SYNTH_INFO: |
| 1872 | if (playing_mode == AWE_PLAY_DIRECT) |
| 1873 | awe_info.nr_voices = awe_max_voices; |
| 1874 | else |
| 1875 | awe_info.nr_voices = AWE_MAX_CHANNELS; |
| 1876 | if (copy_to_user(arg, &awe_info, sizeof(awe_info))) |
| 1877 | return -EFAULT; |
| 1878 | return 0; |
| 1879 | break; |
| 1880 | |
| 1881 | case SNDCTL_SEQ_RESETSAMPLES: |
| 1882 | awe_reset(dev); |
| 1883 | awe_reset_samples(); |
| 1884 | return 0; |
| 1885 | break; |
| 1886 | |
| 1887 | case SNDCTL_SEQ_PERCMODE: |
| 1888 | /* what's this? */ |
| 1889 | return 0; |
| 1890 | break; |
| 1891 | |
| 1892 | case SNDCTL_SYNTH_MEMAVL: |
| 1893 | return memsize - awe_free_mem_ptr() * 2; |
| 1894 | break; |
| 1895 | |
| 1896 | default: |
| 1897 | printk(KERN_WARNING "AWE32: unsupported ioctl %d\n", cmd); |
| 1898 | return -EINVAL; |
| 1899 | break; |
| 1900 | } |
| 1901 | } |
| 1902 | |
| 1903 | |
| 1904 | static int voice_in_range(int voice) |
| 1905 | { |
| 1906 | if (playing_mode == AWE_PLAY_DIRECT) { |
| 1907 | if (voice < 0 || voice >= awe_max_voices) |
| 1908 | return FALSE; |
| 1909 | } else { |
| 1910 | if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| 1911 | return FALSE; |
| 1912 | } |
| 1913 | return TRUE; |
| 1914 | } |
| 1915 | |
| 1916 | static void release_voice(int voice, int do_sustain) |
| 1917 | { |
| 1918 | if (IS_NO_SOUND(voice)) |
| 1919 | return; |
| 1920 | if (do_sustain && (voices[voice].cinfo->sustained == 127 || |
| 1921 | voices[voice].sostenuto == 127)) |
| 1922 | voices[voice].state = AWE_ST_SUSTAINED; |
| 1923 | else { |
| 1924 | awe_note_off(voice); |
| 1925 | awe_fx_init(voices[voice].ch); |
| 1926 | awe_voice_init(voice, FALSE); |
| 1927 | } |
| 1928 | } |
| 1929 | |
| 1930 | /* release all notes */ |
| 1931 | static void awe_note_off_all(int do_sustain) |
| 1932 | { |
| 1933 | int i; |
| 1934 | for (i = 0; i < awe_max_voices; i++) |
| 1935 | release_voice(i, do_sustain); |
| 1936 | } |
| 1937 | |
| 1938 | /* kill a voice: |
| 1939 | * not terminate, just release the voice. |
| 1940 | */ |
| 1941 | static int |
| 1942 | awe_kill_note(int dev, int voice, int note, int velocity) |
| 1943 | { |
| 1944 | int i, v2, key; |
| 1945 | |
| 1946 | DEBUG(2,printk("AWE32: [off(%d) nt=%d vl=%d]\n", voice, note, velocity)); |
| 1947 | if (! voice_in_range(voice)) |
| 1948 | return -EINVAL; |
| 1949 | |
| 1950 | switch (playing_mode) { |
| 1951 | case AWE_PLAY_DIRECT: |
| 1952 | case AWE_PLAY_INDIRECT: |
| 1953 | key = AWE_VOICE_KEY(voice); |
| 1954 | break; |
| 1955 | |
| 1956 | case AWE_PLAY_MULTI2: |
| 1957 | v2 = voice_alloc->map[voice] >> 8; |
| 1958 | voice_alloc->map[voice] = 0; |
| 1959 | voice = v2; |
| 1960 | if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| 1961 | return -EINVAL; |
| 1962 | /* continue to below */ |
| 1963 | default: |
| 1964 | key = AWE_CHAN_KEY(voice, note); |
| 1965 | break; |
| 1966 | } |
| 1967 | |
| 1968 | for (i = 0; i < awe_max_voices; i++) { |
| 1969 | if (voices[i].key == key) |
| 1970 | release_voice(i, TRUE); |
| 1971 | } |
| 1972 | return 0; |
| 1973 | } |
| 1974 | |
| 1975 | |
| 1976 | static void start_or_volume_change(int voice, int velocity) |
| 1977 | { |
| 1978 | voices[voice].velocity = velocity; |
| 1979 | awe_calc_volume(voice); |
| 1980 | if (voices[voice].state == AWE_ST_STANDBY) |
| 1981 | awe_note_on(voice); |
| 1982 | else if (voices[voice].state == AWE_ST_ON) |
| 1983 | awe_set_volume(voice, FALSE); |
| 1984 | } |
| 1985 | |
| 1986 | static void set_and_start_voice(int voice, int state) |
| 1987 | { |
| 1988 | /* calculate pitch & volume parameters */ |
| 1989 | voices[voice].state = state; |
| 1990 | awe_calc_pitch(voice); |
| 1991 | awe_calc_volume(voice); |
| 1992 | if (state == AWE_ST_ON) |
| 1993 | awe_note_on(voice); |
| 1994 | } |
| 1995 | |
| 1996 | /* start a voice: |
| 1997 | * if note is 255, identical with aftertouch function. |
| 1998 | * Otherwise, start a voice with specified not and volume. |
| 1999 | */ |
| 2000 | static int |
| 2001 | awe_start_note(int dev, int voice, int note, int velocity) |
| 2002 | { |
| 2003 | int i, key, state, volonly; |
| 2004 | |
| 2005 | DEBUG(2,printk("AWE32: [on(%d) nt=%d vl=%d]\n", voice, note, velocity)); |
| 2006 | if (! voice_in_range(voice)) |
| 2007 | return -EINVAL; |
| 2008 | |
| 2009 | if (velocity == 0) |
| 2010 | state = AWE_ST_STANDBY; /* stand by for playing */ |
| 2011 | else |
| 2012 | state = AWE_ST_ON; /* really play */ |
| 2013 | volonly = FALSE; |
| 2014 | |
| 2015 | switch (playing_mode) { |
| 2016 | case AWE_PLAY_DIRECT: |
| 2017 | case AWE_PLAY_INDIRECT: |
| 2018 | key = AWE_VOICE_KEY(voice); |
| 2019 | if (note == 255) |
| 2020 | volonly = TRUE; |
| 2021 | break; |
| 2022 | |
| 2023 | case AWE_PLAY_MULTI2: |
| 2024 | voice = voice_alloc->map[voice] >> 8; |
| 2025 | if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| 2026 | return -EINVAL; |
| 2027 | /* continue to below */ |
| 2028 | default: |
| 2029 | if (note >= 128) { /* key volume mode */ |
| 2030 | note -= 128; |
| 2031 | volonly = TRUE; |
| 2032 | } |
| 2033 | key = AWE_CHAN_KEY(voice, note); |
| 2034 | break; |
| 2035 | } |
| 2036 | |
| 2037 | /* dynamic volume change */ |
| 2038 | if (volonly) { |
| 2039 | for (i = 0; i < awe_max_voices; i++) { |
| 2040 | if (voices[i].key == key) |
| 2041 | start_or_volume_change(i, velocity); |
| 2042 | } |
| 2043 | return 0; |
| 2044 | } |
| 2045 | |
| 2046 | /* if the same note still playing, stop it */ |
| 2047 | if (playing_mode != AWE_PLAY_DIRECT || ctrls[AWE_MD_EXCLUSIVE_SOUND]) { |
| 2048 | for (i = 0; i < awe_max_voices; i++) |
| 2049 | if (voices[i].key == key) { |
| 2050 | if (voices[i].state == AWE_ST_ON) { |
| 2051 | awe_note_off(i); |
| 2052 | awe_voice_init(i, FALSE); |
| 2053 | } else if (voices[i].state == AWE_ST_STANDBY) |
| 2054 | awe_voice_init(i, TRUE); |
| 2055 | } |
| 2056 | } |
| 2057 | |
| 2058 | /* allocate voices */ |
| 2059 | if (playing_mode == AWE_PLAY_DIRECT) |
| 2060 | awe_alloc_one_voice(voice, note, velocity); |
| 2061 | else |
| 2062 | awe_alloc_multi_voices(voice, note, velocity, key); |
| 2063 | |
| 2064 | /* turn off other voices exlusively (for drums) */ |
| 2065 | for (i = 0; i < awe_max_voices; i++) |
| 2066 | if (voices[i].key == key) |
| 2067 | awe_exclusive_off(i); |
| 2068 | |
| 2069 | /* set up pitch and volume parameters */ |
| 2070 | for (i = 0; i < awe_max_voices; i++) { |
| 2071 | if (voices[i].key == key && voices[i].state == AWE_ST_OFF) |
| 2072 | set_and_start_voice(i, state); |
| 2073 | } |
| 2074 | |
| 2075 | return 0; |
| 2076 | } |
| 2077 | |
| 2078 | |
| 2079 | /* calculate hash key */ |
| 2080 | static int |
| 2081 | awe_search_key(int bank, int preset, int note) |
| 2082 | { |
| 2083 | unsigned int key; |
| 2084 | |
| 2085 | #if 1 /* new hash table */ |
| 2086 | if (bank == AWE_DRUM_BANK) |
| 2087 | key = preset + note + 128; |
| 2088 | else |
| 2089 | key = bank + preset; |
| 2090 | #else |
| 2091 | key = preset; |
| 2092 | #endif |
| 2093 | key %= AWE_MAX_PRESETS; |
| 2094 | |
| 2095 | return (int)key; |
| 2096 | } |
| 2097 | |
| 2098 | |
| 2099 | /* search instrument from hash table */ |
| 2100 | static awe_voice_list * |
| 2101 | awe_search_instr(int bank, int preset, int note) |
| 2102 | { |
| 2103 | awe_voice_list *p; |
| 2104 | int key, key2; |
| 2105 | |
| 2106 | key = awe_search_key(bank, preset, note); |
| 2107 | for (p = preset_table[key]; p; p = p->next_bank) { |
| 2108 | if (p->instr == preset && p->bank == bank) |
| 2109 | return p; |
| 2110 | } |
| 2111 | key2 = awe_search_key(bank, preset, 0); /* search default */ |
| 2112 | if (key == key2) |
| 2113 | return NULL; |
| 2114 | for (p = preset_table[key2]; p; p = p->next_bank) { |
| 2115 | if (p->instr == preset && p->bank == bank) |
| 2116 | return p; |
| 2117 | } |
| 2118 | return NULL; |
| 2119 | } |
| 2120 | |
| 2121 | |
| 2122 | /* assign the instrument to a voice */ |
| 2123 | static int |
| 2124 | awe_set_instr_2(int dev, int voice, int instr_no) |
| 2125 | { |
| 2126 | if (playing_mode == AWE_PLAY_MULTI2) { |
| 2127 | voice = voice_alloc->map[voice] >> 8; |
| 2128 | if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| 2129 | return -EINVAL; |
| 2130 | } |
| 2131 | return awe_set_instr(dev, voice, instr_no); |
| 2132 | } |
| 2133 | |
| 2134 | /* assign the instrument to a channel; voice is the channel number */ |
| 2135 | static int |
| 2136 | awe_set_instr(int dev, int voice, int instr_no) |
| 2137 | { |
| 2138 | awe_chan_info *cinfo; |
| 2139 | |
| 2140 | if (! voice_in_range(voice)) |
| 2141 | return -EINVAL; |
| 2142 | |
| 2143 | if (instr_no < 0 || instr_no >= AWE_MAX_PRESETS) |
| 2144 | return -EINVAL; |
| 2145 | |
| 2146 | cinfo = &channels[voice]; |
| 2147 | cinfo->instr = instr_no; |
| 2148 | DEBUG(2,printk("AWE32: [program(%d) %d]\n", voice, instr_no)); |
| 2149 | |
| 2150 | return 0; |
| 2151 | } |
| 2152 | |
| 2153 | |
| 2154 | /* reset all voices; terminate sounds and initialize parameters */ |
| 2155 | static void |
| 2156 | awe_reset(int dev) |
| 2157 | { |
| 2158 | int i; |
| 2159 | current_alloc_time = 0; |
| 2160 | /* don't turn off voice 31 and 32. they are used also for FM voices */ |
| 2161 | for (i = 0; i < awe_max_voices; i++) { |
| 2162 | awe_terminate(i); |
| 2163 | awe_voice_init(i, TRUE); |
| 2164 | } |
| 2165 | for (i = 0; i < AWE_MAX_CHANNELS; i++) |
| 2166 | awe_channel_init(i, TRUE); |
| 2167 | for (i = 0; i < 16; i++) { |
| 2168 | awe_operations.chn_info[i].controllers[CTL_MAIN_VOLUME] = 127; |
| 2169 | awe_operations.chn_info[i].controllers[CTL_EXPRESSION] = 127; |
| 2170 | } |
| 2171 | awe_init_fm(); |
| 2172 | awe_tweak(); |
| 2173 | } |
| 2174 | |
| 2175 | |
| 2176 | /* hardware specific control: |
| 2177 | * GUS specific and AWE32 specific controls are available. |
| 2178 | */ |
| 2179 | static void |
| 2180 | awe_hw_control(int dev, unsigned char *event) |
| 2181 | { |
| 2182 | int cmd = event[2]; |
| 2183 | if (cmd & _AWE_MODE_FLAG) |
| 2184 | awe_hw_awe_control(dev, cmd & _AWE_MODE_VALUE_MASK, event); |
| 2185 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 2186 | else |
| 2187 | awe_hw_gus_control(dev, cmd & _AWE_MODE_VALUE_MASK, event); |
| 2188 | #endif |
| 2189 | } |
| 2190 | |
| 2191 | |
| 2192 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 2193 | |
| 2194 | /* GUS compatible controls */ |
| 2195 | static void |
| 2196 | awe_hw_gus_control(int dev, int cmd, unsigned char *event) |
| 2197 | { |
| 2198 | int voice, i, key; |
| 2199 | unsigned short p1; |
| 2200 | short p2; |
| 2201 | int plong; |
| 2202 | |
| 2203 | if (MULTI_LAYER_MODE()) |
| 2204 | return; |
| 2205 | if (cmd == _GUS_NUMVOICES) |
| 2206 | return; |
| 2207 | |
| 2208 | voice = event[3]; |
| 2209 | if (! voice_in_range(voice)) |
| 2210 | return; |
| 2211 | |
| 2212 | p1 = *(unsigned short *) &event[4]; |
| 2213 | p2 = *(short *) &event[6]; |
| 2214 | plong = *(int*) &event[4]; |
| 2215 | |
| 2216 | switch (cmd) { |
| 2217 | case _GUS_VOICESAMPLE: |
| 2218 | awe_set_instr(dev, voice, p1); |
| 2219 | return; |
| 2220 | |
| 2221 | case _GUS_VOICEBALA: |
| 2222 | /* 0 to 15 --> -128 to 127 */ |
| 2223 | awe_panning(dev, voice, ((int)p1 << 4) - 128); |
| 2224 | return; |
| 2225 | |
| 2226 | case _GUS_VOICEVOL: |
| 2227 | case _GUS_VOICEVOL2: |
| 2228 | /* not supported yet */ |
| 2229 | return; |
| 2230 | |
| 2231 | case _GUS_RAMPRANGE: |
| 2232 | case _GUS_RAMPRATE: |
| 2233 | case _GUS_RAMPMODE: |
| 2234 | case _GUS_RAMPON: |
| 2235 | case _GUS_RAMPOFF: |
| 2236 | /* volume ramping not supported */ |
| 2237 | return; |
| 2238 | |
| 2239 | case _GUS_VOLUME_SCALE: |
| 2240 | return; |
| 2241 | |
| 2242 | case _GUS_VOICE_POS: |
| 2243 | FX_SET(&channels[voice].fx, AWE_FX_SAMPLE_START, |
| 2244 | (short)(plong & 0x7fff)); |
| 2245 | FX_SET(&channels[voice].fx, AWE_FX_COARSE_SAMPLE_START, |
| 2246 | (plong >> 15) & 0xffff); |
| 2247 | return; |
| 2248 | } |
| 2249 | |
| 2250 | key = AWE_VOICE_KEY(voice); |
| 2251 | for (i = 0; i < awe_max_voices; i++) { |
| 2252 | if (voices[i].key == key) { |
| 2253 | switch (cmd) { |
| 2254 | case _GUS_VOICEON: |
| 2255 | awe_note_on(i); |
| 2256 | break; |
| 2257 | |
| 2258 | case _GUS_VOICEOFF: |
| 2259 | awe_terminate(i); |
| 2260 | awe_fx_init(voices[i].ch); |
| 2261 | awe_voice_init(i, TRUE); |
| 2262 | break; |
| 2263 | |
| 2264 | case _GUS_VOICEFADE: |
| 2265 | awe_note_off(i); |
| 2266 | awe_fx_init(voices[i].ch); |
| 2267 | awe_voice_init(i, FALSE); |
| 2268 | break; |
| 2269 | |
| 2270 | case _GUS_VOICEFREQ: |
| 2271 | awe_calc_pitch_from_freq(i, plong); |
| 2272 | break; |
| 2273 | } |
| 2274 | } |
| 2275 | } |
| 2276 | } |
| 2277 | |
| 2278 | #endif /* gus_compat */ |
| 2279 | |
| 2280 | |
| 2281 | /* AWE32 specific controls */ |
| 2282 | static void |
| 2283 | awe_hw_awe_control(int dev, int cmd, unsigned char *event) |
| 2284 | { |
| 2285 | int voice; |
| 2286 | unsigned short p1; |
| 2287 | short p2; |
| 2288 | int i; |
| 2289 | |
| 2290 | voice = event[3]; |
| 2291 | if (! voice_in_range(voice)) |
| 2292 | return; |
| 2293 | |
| 2294 | if (playing_mode == AWE_PLAY_MULTI2) { |
| 2295 | voice = voice_alloc->map[voice] >> 8; |
| 2296 | if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| 2297 | return; |
| 2298 | } |
| 2299 | |
| 2300 | p1 = *(unsigned short *) &event[4]; |
| 2301 | p2 = *(short *) &event[6]; |
| 2302 | |
| 2303 | switch (cmd) { |
| 2304 | case _AWE_DEBUG_MODE: |
| 2305 | ctrls[AWE_MD_DEBUG_MODE] = p1; |
| 2306 | printk(KERN_DEBUG "AWE32: debug mode = %d\n", ctrls[AWE_MD_DEBUG_MODE]); |
| 2307 | break; |
| 2308 | case _AWE_REVERB_MODE: |
| 2309 | ctrls[AWE_MD_REVERB_MODE] = p1; |
| 2310 | awe_update_reverb_mode(); |
| 2311 | break; |
| 2312 | |
| 2313 | case _AWE_CHORUS_MODE: |
| 2314 | ctrls[AWE_MD_CHORUS_MODE] = p1; |
| 2315 | awe_update_chorus_mode(); |
| 2316 | break; |
| 2317 | |
| 2318 | case _AWE_REMOVE_LAST_SAMPLES: |
| 2319 | DEBUG(0,printk("AWE32: remove last samples\n")); |
| 2320 | awe_reset(0); |
| 2321 | if (locked_sf_id > 0) |
| 2322 | awe_remove_samples(locked_sf_id); |
| 2323 | break; |
| 2324 | |
| 2325 | case _AWE_INITIALIZE_CHIP: |
| 2326 | awe_initialize(); |
| 2327 | break; |
| 2328 | |
| 2329 | case _AWE_SEND_EFFECT: |
| 2330 | i = -1; |
| 2331 | if (p1 >= 0x100) { |
| 2332 | i = (p1 >> 8); |
| 2333 | if (i < 0 || i >= MAX_LAYERS) |
| 2334 | break; |
| 2335 | } |
| 2336 | awe_send_effect(voice, i, p1, p2); |
| 2337 | break; |
| 2338 | |
| 2339 | case _AWE_RESET_CHANNEL: |
| 2340 | awe_channel_init(voice, !p1); |
| 2341 | break; |
| 2342 | |
| 2343 | case _AWE_TERMINATE_ALL: |
| 2344 | awe_reset(0); |
| 2345 | break; |
| 2346 | |
| 2347 | case _AWE_TERMINATE_CHANNEL: |
| 2348 | awe_voice_change(voice, awe_terminate_and_init); |
| 2349 | break; |
| 2350 | |
| 2351 | case _AWE_RELEASE_ALL: |
| 2352 | awe_note_off_all(FALSE); |
| 2353 | break; |
| 2354 | case _AWE_NOTEOFF_ALL: |
| 2355 | awe_note_off_all(TRUE); |
| 2356 | break; |
| 2357 | |
| 2358 | case _AWE_INITIAL_VOLUME: |
| 2359 | DEBUG(0,printk("AWE32: init attenuation %d\n", p1)); |
| 2360 | atten_relative = (char)p2; |
| 2361 | atten_offset = (short)p1; |
| 2362 | awe_update_volume(); |
| 2363 | break; |
| 2364 | |
| 2365 | case _AWE_CHN_PRESSURE: |
| 2366 | channels[voice].chan_press = p1; |
| 2367 | awe_modwheel_change(voice, p1); |
| 2368 | break; |
| 2369 | |
| 2370 | case _AWE_CHANNEL_MODE: |
| 2371 | DEBUG(0,printk("AWE32: channel mode = %d\n", p1)); |
| 2372 | playing_mode = p1; |
| 2373 | awe_reset(0); |
| 2374 | break; |
| 2375 | |
| 2376 | case _AWE_DRUM_CHANNELS: |
| 2377 | DEBUG(0,printk("AWE32: drum flags = %x\n", p1)); |
| 2378 | drum_flags = *(unsigned int*)&event[4]; |
| 2379 | break; |
| 2380 | |
| 2381 | case _AWE_MISC_MODE: |
| 2382 | DEBUG(0,printk("AWE32: ctrl parms = %d %d\n", p1, p2)); |
| 2383 | if (p1 > AWE_MD_VERSION && p1 < AWE_MD_END) { |
| 2384 | ctrls[p1] = p2; |
| 2385 | if (ctrl_parms[p1].update) |
| 2386 | ctrl_parms[p1].update(); |
| 2387 | } |
| 2388 | break; |
| 2389 | |
| 2390 | case _AWE_EQUALIZER: |
| 2391 | ctrls[AWE_MD_BASS_LEVEL] = p1; |
| 2392 | ctrls[AWE_MD_TREBLE_LEVEL] = p2; |
| 2393 | awe_update_equalizer(); |
| 2394 | break; |
| 2395 | |
| 2396 | default: |
| 2397 | DEBUG(0,printk("AWE32: hw control cmd=%d voice=%d\n", cmd, voice)); |
| 2398 | break; |
| 2399 | } |
| 2400 | } |
| 2401 | |
| 2402 | |
| 2403 | /* change effects */ |
| 2404 | static void |
| 2405 | awe_send_effect(int voice, int layer, int type, int val) |
| 2406 | { |
| 2407 | awe_chan_info *cinfo; |
| 2408 | FX_Rec *fx; |
| 2409 | int mode; |
| 2410 | |
| 2411 | cinfo = &channels[voice]; |
| 2412 | if (layer >= 0 && layer < MAX_LAYERS) |
| 2413 | fx = &cinfo->fx_layer[layer]; |
| 2414 | else |
| 2415 | fx = &cinfo->fx; |
| 2416 | |
| 2417 | if (type & 0x40) |
| 2418 | mode = FX_FLAG_OFF; |
| 2419 | else if (type & 0x80) |
| 2420 | mode = FX_FLAG_ADD; |
| 2421 | else |
| 2422 | mode = FX_FLAG_SET; |
| 2423 | type &= 0x3f; |
| 2424 | |
| 2425 | if (type >= 0 && type < AWE_FX_END) { |
| 2426 | DEBUG(2,printk("AWE32: effects (%d) %d %d\n", voice, type, val)); |
| 2427 | if (mode == FX_FLAG_SET) |
| 2428 | FX_SET(fx, type, val); |
| 2429 | else if (mode == FX_FLAG_ADD) |
| 2430 | FX_ADD(fx, type, val); |
| 2431 | else |
| 2432 | FX_UNSET(fx, type); |
| 2433 | if (mode != FX_FLAG_OFF && parm_defs[type].realtime) { |
| 2434 | DEBUG(2,printk("AWE32: fx_realtime (%d)\n", voice)); |
| 2435 | awe_voice_change(voice, parm_defs[type].realtime); |
| 2436 | } |
| 2437 | } |
| 2438 | } |
| 2439 | |
| 2440 | |
| 2441 | /* change modulation wheel; voice is already mapped on multi2 mode */ |
| 2442 | static void |
| 2443 | awe_modwheel_change(int voice, int value) |
| 2444 | { |
| 2445 | int i; |
| 2446 | awe_chan_info *cinfo; |
| 2447 | |
| 2448 | cinfo = &channels[voice]; |
| 2449 | i = value * ctrls[AWE_MD_MOD_SENSE] / 1200; |
| 2450 | FX_ADD(&cinfo->fx, AWE_FX_LFO1_PITCH, i); |
| 2451 | awe_voice_change(voice, awe_fx_fmmod); |
| 2452 | FX_ADD(&cinfo->fx, AWE_FX_LFO2_PITCH, i); |
| 2453 | awe_voice_change(voice, awe_fx_fm2frq2); |
| 2454 | } |
| 2455 | |
| 2456 | |
| 2457 | /* voice pressure change */ |
| 2458 | static void |
| 2459 | awe_aftertouch(int dev, int voice, int pressure) |
| 2460 | { |
| 2461 | int note; |
| 2462 | |
| 2463 | DEBUG(2,printk("AWE32: [after(%d) %d]\n", voice, pressure)); |
| 2464 | if (! voice_in_range(voice)) |
| 2465 | return; |
| 2466 | |
| 2467 | switch (playing_mode) { |
| 2468 | case AWE_PLAY_DIRECT: |
| 2469 | case AWE_PLAY_INDIRECT: |
| 2470 | awe_start_note(dev, voice, 255, pressure); |
| 2471 | break; |
| 2472 | case AWE_PLAY_MULTI2: |
| 2473 | note = (voice_alloc->map[voice] & 0xff) - 1; |
| 2474 | awe_key_pressure(dev, voice, note + 0x80, pressure); |
| 2475 | break; |
| 2476 | } |
| 2477 | } |
| 2478 | |
| 2479 | |
| 2480 | /* voice control change */ |
| 2481 | static void |
| 2482 | awe_controller(int dev, int voice, int ctrl_num, int value) |
| 2483 | { |
| 2484 | awe_chan_info *cinfo; |
| 2485 | |
| 2486 | if (! voice_in_range(voice)) |
| 2487 | return; |
| 2488 | |
| 2489 | if (playing_mode == AWE_PLAY_MULTI2) { |
| 2490 | voice = voice_alloc->map[voice] >> 8; |
| 2491 | if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| 2492 | return; |
| 2493 | } |
| 2494 | |
| 2495 | cinfo = &channels[voice]; |
| 2496 | |
| 2497 | switch (ctrl_num) { |
| 2498 | case CTL_BANK_SELECT: /* MIDI control #0 */ |
| 2499 | DEBUG(2,printk("AWE32: [bank(%d) %d]\n", voice, value)); |
| 2500 | if (MULTI_LAYER_MODE() && IS_DRUM_CHANNEL(voice) && |
| 2501 | !ctrls[AWE_MD_TOGGLE_DRUM_BANK]) |
| 2502 | break; |
| 2503 | if (value < 0 || value > 255) |
| 2504 | break; |
| 2505 | cinfo->bank = value; |
| 2506 | if (cinfo->bank == AWE_DRUM_BANK) |
| 2507 | DRUM_CHANNEL_ON(cinfo->channel); |
| 2508 | else |
| 2509 | DRUM_CHANNEL_OFF(cinfo->channel); |
| 2510 | awe_set_instr(dev, voice, cinfo->instr); |
| 2511 | break; |
| 2512 | |
| 2513 | case CTL_MODWHEEL: /* MIDI control #1 */ |
| 2514 | DEBUG(2,printk("AWE32: [modwheel(%d) %d]\n", voice, value)); |
| 2515 | awe_modwheel_change(voice, value); |
| 2516 | break; |
| 2517 | |
| 2518 | case CTRL_PITCH_BENDER: /* SEQ1 V2 contorl */ |
| 2519 | DEBUG(2,printk("AWE32: [bend(%d) %d]\n", voice, value)); |
| 2520 | /* zero centered */ |
| 2521 | cinfo->bender = value; |
| 2522 | awe_voice_change(voice, awe_set_voice_pitch); |
| 2523 | break; |
| 2524 | |
| 2525 | case CTRL_PITCH_BENDER_RANGE: /* SEQ1 V2 control */ |
| 2526 | DEBUG(2,printk("AWE32: [range(%d) %d]\n", voice, value)); |
| 2527 | /* value = sense x 100 */ |
| 2528 | cinfo->bender_range = value; |
| 2529 | /* no audible pitch change yet.. */ |
| 2530 | break; |
| 2531 | |
| 2532 | case CTL_EXPRESSION: /* MIDI control #11 */ |
| 2533 | if (SINGLE_LAYER_MODE()) |
| 2534 | value /= 128; |
| 2535 | case CTRL_EXPRESSION: /* SEQ1 V2 control */ |
| 2536 | DEBUG(2,printk("AWE32: [expr(%d) %d]\n", voice, value)); |
| 2537 | /* 0 - 127 */ |
| 2538 | cinfo->expression_vol = value; |
| 2539 | awe_voice_change(voice, awe_set_voice_vol); |
| 2540 | break; |
| 2541 | |
| 2542 | case CTL_PAN: /* MIDI control #10 */ |
| 2543 | DEBUG(2,printk("AWE32: [pan(%d) %d]\n", voice, value)); |
| 2544 | /* (0-127) -> signed 8bit */ |
| 2545 | cinfo->panning = value * 2 - 128; |
| 2546 | if (ctrls[AWE_MD_REALTIME_PAN]) |
| 2547 | awe_voice_change(voice, awe_set_pan); |
| 2548 | break; |
| 2549 | |
| 2550 | case CTL_MAIN_VOLUME: /* MIDI control #7 */ |
| 2551 | if (SINGLE_LAYER_MODE()) |
| 2552 | value = (value * 100) / 16383; |
| 2553 | case CTRL_MAIN_VOLUME: /* SEQ1 V2 control */ |
| 2554 | DEBUG(2,printk("AWE32: [mainvol(%d) %d]\n", voice, value)); |
| 2555 | /* 0 - 127 */ |
| 2556 | cinfo->main_vol = value; |
| 2557 | awe_voice_change(voice, awe_set_voice_vol); |
| 2558 | break; |
| 2559 | |
| 2560 | case CTL_EXT_EFF_DEPTH: /* reverb effects: 0-127 */ |
| 2561 | DEBUG(2,printk("AWE32: [reverb(%d) %d]\n", voice, value)); |
| 2562 | FX_SET(&cinfo->fx, AWE_FX_REVERB, value * 2); |
| 2563 | break; |
| 2564 | |
| 2565 | case CTL_CHORUS_DEPTH: /* chorus effects: 0-127 */ |
| 2566 | DEBUG(2,printk("AWE32: [chorus(%d) %d]\n", voice, value)); |
| 2567 | FX_SET(&cinfo->fx, AWE_FX_CHORUS, value * 2); |
| 2568 | break; |
| 2569 | |
| 2570 | case 120: /* all sounds off */ |
| 2571 | awe_note_off_all(FALSE); |
| 2572 | break; |
| 2573 | case 123: /* all notes off */ |
| 2574 | awe_note_off_all(TRUE); |
| 2575 | break; |
| 2576 | |
| 2577 | case CTL_SUSTAIN: /* MIDI control #64 */ |
| 2578 | cinfo->sustained = value; |
| 2579 | if (value != 127) |
| 2580 | awe_voice_change(voice, awe_sustain_off); |
| 2581 | break; |
| 2582 | |
| 2583 | case CTL_SOSTENUTO: /* MIDI control #66 */ |
| 2584 | if (value == 127) |
| 2585 | awe_voice_change(voice, awe_sostenuto_on); |
| 2586 | else |
| 2587 | awe_voice_change(voice, awe_sustain_off); |
| 2588 | break; |
| 2589 | |
| 2590 | default: |
| 2591 | DEBUG(0,printk("AWE32: [control(%d) ctrl=%d val=%d]\n", |
| 2592 | voice, ctrl_num, value)); |
| 2593 | break; |
| 2594 | } |
| 2595 | } |
| 2596 | |
| 2597 | |
| 2598 | /* voice pan change (value = -128 - 127) */ |
| 2599 | static void |
| 2600 | awe_panning(int dev, int voice, int value) |
| 2601 | { |
| 2602 | awe_chan_info *cinfo; |
| 2603 | |
| 2604 | if (! voice_in_range(voice)) |
| 2605 | return; |
| 2606 | |
| 2607 | if (playing_mode == AWE_PLAY_MULTI2) { |
| 2608 | voice = voice_alloc->map[voice] >> 8; |
| 2609 | if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| 2610 | return; |
| 2611 | } |
| 2612 | |
| 2613 | cinfo = &channels[voice]; |
| 2614 | cinfo->panning = value; |
| 2615 | DEBUG(2,printk("AWE32: [pan(%d) %d]\n", voice, cinfo->panning)); |
| 2616 | if (ctrls[AWE_MD_REALTIME_PAN]) |
| 2617 | awe_voice_change(voice, awe_set_pan); |
| 2618 | } |
| 2619 | |
| 2620 | |
| 2621 | /* volume mode change */ |
| 2622 | static void |
| 2623 | awe_volume_method(int dev, int mode) |
| 2624 | { |
| 2625 | /* not impremented */ |
| 2626 | DEBUG(0,printk("AWE32: [volmethod mode=%d]\n", mode)); |
| 2627 | } |
| 2628 | |
| 2629 | |
| 2630 | /* pitch wheel change: 0-16384 */ |
| 2631 | static void |
| 2632 | awe_bender(int dev, int voice, int value) |
| 2633 | { |
| 2634 | awe_chan_info *cinfo; |
| 2635 | |
| 2636 | if (! voice_in_range(voice)) |
| 2637 | return; |
| 2638 | |
| 2639 | if (playing_mode == AWE_PLAY_MULTI2) { |
| 2640 | voice = voice_alloc->map[voice] >> 8; |
| 2641 | if (voice < 0 || voice >= AWE_MAX_CHANNELS) |
| 2642 | return; |
| 2643 | } |
| 2644 | |
| 2645 | /* convert to zero centered value */ |
| 2646 | cinfo = &channels[voice]; |
| 2647 | cinfo->bender = value - 8192; |
| 2648 | DEBUG(2,printk("AWE32: [bend(%d) %d]\n", voice, cinfo->bender)); |
| 2649 | awe_voice_change(voice, awe_set_voice_pitch); |
| 2650 | } |
| 2651 | |
| 2652 | |
| 2653 | /* |
| 2654 | * load a sound patch: |
| 2655 | * three types of patches are accepted: AWE, GUS, and SYSEX. |
| 2656 | */ |
| 2657 | |
| 2658 | static int |
| 2659 | awe_load_patch(int dev, int format, const char __user *addr, |
| 2660 | int offs, int count, int pmgr_flag) |
| 2661 | { |
| 2662 | awe_patch_info patch; |
| 2663 | int rc = 0; |
| 2664 | |
| 2665 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 2666 | if (format == GUS_PATCH) { |
| 2667 | return awe_load_guspatch(addr, offs, count, pmgr_flag); |
| 2668 | } else |
| 2669 | #endif |
| 2670 | if (format == SYSEX_PATCH) { |
| 2671 | /* no system exclusive message supported yet */ |
| 2672 | return 0; |
| 2673 | } else if (format != AWE_PATCH) { |
| 2674 | printk(KERN_WARNING "AWE32 Error: Invalid patch format (key) 0x%x\n", format); |
| 2675 | return -EINVAL; |
| 2676 | } |
| 2677 | |
| 2678 | if (count < AWE_PATCH_INFO_SIZE) { |
| 2679 | printk(KERN_WARNING "AWE32 Error: Patch header too short\n"); |
| 2680 | return -EINVAL; |
| 2681 | } |
| 2682 | if (copy_from_user(((char*)&patch) + offs, addr + offs, |
| 2683 | AWE_PATCH_INFO_SIZE - offs)) |
| 2684 | return -EFAULT; |
| 2685 | |
| 2686 | count -= AWE_PATCH_INFO_SIZE; |
| 2687 | if (count < patch.len) { |
| 2688 | printk(KERN_WARNING "AWE32: sample: Patch record too short (%d<%d)\n", |
| 2689 | count, patch.len); |
| 2690 | return -EINVAL; |
| 2691 | } |
| 2692 | |
| 2693 | switch (patch.type) { |
| 2694 | case AWE_LOAD_INFO: |
| 2695 | rc = awe_load_info(&patch, addr, count); |
| 2696 | break; |
| 2697 | case AWE_LOAD_DATA: |
| 2698 | rc = awe_load_data(&patch, addr, count); |
| 2699 | break; |
| 2700 | case AWE_OPEN_PATCH: |
| 2701 | rc = awe_open_patch(&patch, addr, count); |
| 2702 | break; |
| 2703 | case AWE_CLOSE_PATCH: |
| 2704 | rc = awe_close_patch(&patch, addr, count); |
| 2705 | break; |
| 2706 | case AWE_UNLOAD_PATCH: |
| 2707 | rc = awe_unload_patch(&patch, addr, count); |
| 2708 | break; |
| 2709 | case AWE_REPLACE_DATA: |
| 2710 | rc = awe_replace_data(&patch, addr, count); |
| 2711 | break; |
| 2712 | case AWE_MAP_PRESET: |
| 2713 | rc = awe_load_map(&patch, addr, count); |
| 2714 | break; |
| 2715 | /* case AWE_PROBE_INFO: |
| 2716 | rc = awe_probe_info(&patch, addr, count); |
| 2717 | break;*/ |
| 2718 | case AWE_PROBE_DATA: |
| 2719 | rc = awe_probe_data(&patch, addr, count); |
| 2720 | break; |
| 2721 | case AWE_REMOVE_INFO: |
| 2722 | rc = awe_remove_info(&patch, addr, count); |
| 2723 | break; |
| 2724 | case AWE_LOAD_CHORUS_FX: |
| 2725 | rc = awe_load_chorus_fx(&patch, addr, count); |
| 2726 | break; |
| 2727 | case AWE_LOAD_REVERB_FX: |
| 2728 | rc = awe_load_reverb_fx(&patch, addr, count); |
| 2729 | break; |
| 2730 | |
| 2731 | default: |
| 2732 | printk(KERN_WARNING "AWE32 Error: unknown patch format type %d\n", |
| 2733 | patch.type); |
| 2734 | rc = -EINVAL; |
| 2735 | } |
| 2736 | |
| 2737 | return rc; |
| 2738 | } |
| 2739 | |
| 2740 | |
| 2741 | /* create an sf list record */ |
| 2742 | static int |
| 2743 | awe_create_sf(int type, char *name) |
| 2744 | { |
| 2745 | sf_list *rec; |
| 2746 | |
| 2747 | /* terminate sounds */ |
| 2748 | awe_reset(0); |
| 2749 | rec = (sf_list *)kmalloc(sizeof(*rec), GFP_KERNEL); |
| 2750 | if (rec == NULL) |
| 2751 | return 1; /* no memory */ |
| 2752 | rec->sf_id = current_sf_id + 1; |
| 2753 | rec->type = type; |
| 2754 | if (/*current_sf_id == 0 ||*/ (type & AWE_PAT_LOCKED) != 0) |
| 2755 | locked_sf_id = current_sf_id + 1; |
| 2756 | rec->num_info = awe_free_info(); |
| 2757 | rec->num_sample = awe_free_sample(); |
| 2758 | rec->mem_ptr = awe_free_mem_ptr(); |
| 2759 | rec->infos = rec->last_infos = NULL; |
| 2760 | rec->samples = rec->last_samples = NULL; |
| 2761 | |
| 2762 | /* add to linked-list */ |
| 2763 | rec->next = NULL; |
| 2764 | rec->prev = sftail; |
| 2765 | if (sftail) |
| 2766 | sftail->next = rec; |
| 2767 | else |
| 2768 | sfhead = rec; |
| 2769 | sftail = rec; |
| 2770 | current_sf_id++; |
| 2771 | |
| 2772 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 2773 | rec->shared = NULL; |
| 2774 | if (name) |
| 2775 | memcpy(rec->name, name, AWE_PATCH_NAME_LEN); |
| 2776 | else |
| 2777 | strcpy(rec->name, "*TEMPORARY*"); |
| 2778 | if (current_sf_id > 1 && name && (type & AWE_PAT_SHARED) != 0) { |
| 2779 | /* is the current font really a shared font? */ |
| 2780 | if (is_shared_sf(rec->name)) { |
| 2781 | /* check if the shared font is already installed */ |
| 2782 | sf_list *p; |
| 2783 | for (p = rec->prev; p; p = p->prev) { |
| 2784 | if (is_identical_name(rec->name, p)) { |
| 2785 | rec->shared = p; |
| 2786 | break; |
| 2787 | } |
| 2788 | } |
| 2789 | } |
| 2790 | } |
| 2791 | #endif /* allow sharing */ |
| 2792 | |
| 2793 | return 0; |
| 2794 | } |
| 2795 | |
| 2796 | |
| 2797 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 2798 | |
| 2799 | /* check if the given name is a valid shared name */ |
| 2800 | #define ASC_TO_KEY(c) ((c) - 'A' + 1) |
| 2801 | static int is_shared_sf(unsigned char *name) |
| 2802 | { |
| 2803 | static unsigned char id_head[4] = { |
| 2804 | ASC_TO_KEY('A'), ASC_TO_KEY('W'), ASC_TO_KEY('E'), |
| 2805 | AWE_MAJOR_VERSION, |
| 2806 | }; |
| 2807 | if (memcmp(name, id_head, 4) == 0) |
| 2808 | return TRUE; |
| 2809 | return FALSE; |
| 2810 | } |
| 2811 | |
| 2812 | /* check if the given name matches to the existing list */ |
| 2813 | static int is_identical_name(unsigned char *name, sf_list *p) |
| 2814 | { |
| 2815 | char *id = p->name; |
| 2816 | if (is_shared_sf(id) && memcmp(id, name, AWE_PATCH_NAME_LEN) == 0) |
| 2817 | return TRUE; |
| 2818 | return FALSE; |
| 2819 | } |
| 2820 | |
| 2821 | /* check if the given voice info exists */ |
| 2822 | static int info_duplicated(sf_list *sf, awe_voice_list *rec) |
| 2823 | { |
| 2824 | /* search for all sharing lists */ |
| 2825 | for (; sf; sf = sf->shared) { |
| 2826 | awe_voice_list *p; |
| 2827 | for (p = sf->infos; p; p = p->next) { |
| 2828 | if (p->type == V_ST_NORMAL && |
| 2829 | p->bank == rec->bank && |
| 2830 | p->instr == rec->instr && |
| 2831 | p->v.low == rec->v.low && |
| 2832 | p->v.high == rec->v.high && |
| 2833 | p->v.sample == rec->v.sample) |
| 2834 | return TRUE; |
| 2835 | } |
| 2836 | } |
| 2837 | return FALSE; |
| 2838 | } |
| 2839 | |
| 2840 | #endif /* AWE_ALLOW_SAMPLE_SHARING */ |
| 2841 | |
| 2842 | |
| 2843 | /* free sf_list record */ |
| 2844 | /* linked-list in this function is not cared */ |
| 2845 | static void |
| 2846 | awe_free_sf(sf_list *sf) |
| 2847 | { |
| 2848 | if (sf->infos) { |
| 2849 | awe_voice_list *p, *next; |
| 2850 | for (p = sf->infos; p; p = next) { |
| 2851 | next = p->next; |
| 2852 | kfree(p); |
| 2853 | } |
| 2854 | } |
| 2855 | if (sf->samples) { |
| 2856 | awe_sample_list *p, *next; |
| 2857 | for (p = sf->samples; p; p = next) { |
| 2858 | next = p->next; |
| 2859 | kfree(p); |
| 2860 | } |
| 2861 | } |
| 2862 | kfree(sf); |
| 2863 | } |
| 2864 | |
| 2865 | |
| 2866 | /* open patch; create sf list and set opened flag */ |
| 2867 | static int |
| 2868 | awe_open_patch(awe_patch_info *patch, const char __user *addr, int count) |
| 2869 | { |
| 2870 | awe_open_parm parm; |
| 2871 | int shared; |
| 2872 | |
| 2873 | if (copy_from_user(&parm, addr + AWE_PATCH_INFO_SIZE, sizeof(parm))) |
| 2874 | return -EFAULT; |
| 2875 | shared = FALSE; |
| 2876 | |
| 2877 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 2878 | if (sftail && (parm.type & AWE_PAT_SHARED) != 0) { |
| 2879 | /* is the previous font the same font? */ |
| 2880 | if (is_identical_name(parm.name, sftail)) { |
| 2881 | /* then append to the previous */ |
| 2882 | shared = TRUE; |
| 2883 | awe_reset(0); |
| 2884 | if (parm.type & AWE_PAT_LOCKED) |
| 2885 | locked_sf_id = current_sf_id; |
| 2886 | } |
| 2887 | } |
| 2888 | #endif /* allow sharing */ |
| 2889 | if (! shared) { |
| 2890 | if (awe_create_sf(parm.type, parm.name)) { |
| 2891 | printk(KERN_ERR "AWE32: can't open: failed to alloc new list\n"); |
| 2892 | return -ENOMEM; |
| 2893 | } |
| 2894 | } |
| 2895 | patch_opened = TRUE; |
| 2896 | return current_sf_id; |
| 2897 | } |
| 2898 | |
| 2899 | /* check if the patch is already opened */ |
| 2900 | static sf_list * |
| 2901 | check_patch_opened(int type, char *name) |
| 2902 | { |
| 2903 | if (! patch_opened) { |
| 2904 | if (awe_create_sf(type, name)) { |
| 2905 | printk(KERN_ERR "AWE32: failed to alloc new list\n"); |
| 2906 | return NULL; |
| 2907 | } |
| 2908 | patch_opened = TRUE; |
| 2909 | return sftail; |
| 2910 | } |
| 2911 | return sftail; |
| 2912 | } |
| 2913 | |
| 2914 | /* close the patch; if no voice is loaded, remove the patch */ |
| 2915 | static int |
| 2916 | awe_close_patch(awe_patch_info *patch, const char __user *addr, int count) |
| 2917 | { |
| 2918 | if (patch_opened && sftail) { |
| 2919 | /* if no voice is loaded, release the current patch */ |
| 2920 | if (sftail->infos == NULL) { |
| 2921 | awe_reset(0); |
| 2922 | awe_remove_samples(current_sf_id - 1); |
| 2923 | } |
| 2924 | } |
| 2925 | patch_opened = 0; |
| 2926 | return 0; |
| 2927 | } |
| 2928 | |
| 2929 | |
| 2930 | /* remove the latest patch */ |
| 2931 | static int |
| 2932 | awe_unload_patch(awe_patch_info *patch, const char __user *addr, int count) |
| 2933 | { |
| 2934 | if (current_sf_id > 0 && current_sf_id > locked_sf_id) { |
| 2935 | awe_reset(0); |
| 2936 | awe_remove_samples(current_sf_id - 1); |
| 2937 | } |
| 2938 | return 0; |
| 2939 | } |
| 2940 | |
| 2941 | /* allocate voice info list records */ |
| 2942 | static awe_voice_list * |
| 2943 | alloc_new_info(void) |
| 2944 | { |
| 2945 | awe_voice_list *newlist; |
| 2946 | |
| 2947 | newlist = (awe_voice_list *)kmalloc(sizeof(*newlist), GFP_KERNEL); |
| 2948 | if (newlist == NULL) { |
| 2949 | printk(KERN_ERR "AWE32: can't alloc info table\n"); |
| 2950 | return NULL; |
| 2951 | } |
| 2952 | return newlist; |
| 2953 | } |
| 2954 | |
| 2955 | /* allocate sample info list records */ |
| 2956 | static awe_sample_list * |
| 2957 | alloc_new_sample(void) |
| 2958 | { |
| 2959 | awe_sample_list *newlist; |
| 2960 | |
| 2961 | newlist = (awe_sample_list *)kmalloc(sizeof(*newlist), GFP_KERNEL); |
| 2962 | if (newlist == NULL) { |
| 2963 | printk(KERN_ERR "AWE32: can't alloc sample table\n"); |
| 2964 | return NULL; |
| 2965 | } |
| 2966 | return newlist; |
| 2967 | } |
| 2968 | |
| 2969 | /* load voice map */ |
| 2970 | static int |
| 2971 | awe_load_map(awe_patch_info *patch, const char __user *addr, int count) |
| 2972 | { |
| 2973 | awe_voice_map map; |
| 2974 | awe_voice_list *rec, *p; |
| 2975 | sf_list *sf; |
| 2976 | |
| 2977 | /* get the link info */ |
| 2978 | if (count < sizeof(map)) { |
| 2979 | printk(KERN_WARNING "AWE32 Error: invalid patch info length\n"); |
| 2980 | return -EINVAL; |
| 2981 | } |
| 2982 | if (copy_from_user(&map, addr + AWE_PATCH_INFO_SIZE, sizeof(map))) |
| 2983 | return -EFAULT; |
| 2984 | |
| 2985 | /* check if the identical mapping already exists */ |
| 2986 | p = awe_search_instr(map.map_bank, map.map_instr, map.map_key); |
| 2987 | for (; p; p = p->next_instr) { |
| 2988 | if (p->type == V_ST_MAPPED && |
| 2989 | p->v.start == map.src_instr && |
| 2990 | p->v.end == map.src_bank && |
| 2991 | p->v.fixkey == map.src_key) |
| 2992 | return 0; /* already present! */ |
| 2993 | } |
| 2994 | |
| 2995 | if ((sf = check_patch_opened(AWE_PAT_TYPE_MAP, NULL)) == NULL) |
| 2996 | return -ENOMEM; |
| 2997 | |
| 2998 | if ((rec = alloc_new_info()) == NULL) |
| 2999 | return -ENOMEM; |
| 3000 | |
| 3001 | rec->bank = map.map_bank; |
| 3002 | rec->instr = map.map_instr; |
| 3003 | rec->type = V_ST_MAPPED; |
| 3004 | rec->disabled = FALSE; |
| 3005 | awe_init_voice_info(&rec->v); |
| 3006 | if (map.map_key >= 0) { |
| 3007 | rec->v.low = map.map_key; |
| 3008 | rec->v.high = map.map_key; |
| 3009 | } |
| 3010 | rec->v.start = map.src_instr; |
| 3011 | rec->v.end = map.src_bank; |
| 3012 | rec->v.fixkey = map.src_key; |
| 3013 | add_sf_info(sf, rec); |
| 3014 | add_info_list(rec); |
| 3015 | |
| 3016 | return 0; |
| 3017 | } |
| 3018 | |
| 3019 | #if 0 |
| 3020 | /* probe preset in the current list -- nothing to be loaded */ |
| 3021 | static int |
| 3022 | awe_probe_info(awe_patch_info *patch, const char __user *addr, int count) |
| 3023 | { |
| 3024 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 3025 | awe_voice_map map; |
| 3026 | awe_voice_list *p; |
| 3027 | |
| 3028 | if (! patch_opened) |
| 3029 | return -EINVAL; |
| 3030 | |
| 3031 | /* get the link info */ |
| 3032 | if (count < sizeof(map)) { |
| 3033 | printk(KERN_WARNING "AWE32 Error: invalid patch info length\n"); |
| 3034 | return -EINVAL; |
| 3035 | } |
| 3036 | if (copy_from_user(&map, addr + AWE_PATCH_INFO_SIZE, sizeof(map))) |
| 3037 | return -EFAULT; |
| 3038 | |
| 3039 | /* check if the identical mapping already exists */ |
| 3040 | if (sftail == NULL) |
| 3041 | return -EINVAL; |
| 3042 | p = awe_search_instr(map.src_bank, map.src_instr, map.src_key); |
| 3043 | for (; p; p = p->next_instr) { |
| 3044 | if (p->type == V_ST_NORMAL && |
| 3045 | is_identical_holder(p->holder, sftail) && |
| 3046 | p->v.low <= map.src_key && |
| 3047 | p->v.high >= map.src_key) |
| 3048 | return 0; /* already present! */ |
| 3049 | } |
| 3050 | #endif /* allow sharing */ |
| 3051 | return -EINVAL; |
| 3052 | } |
| 3053 | #endif |
| 3054 | |
| 3055 | /* probe sample in the current list -- nothing to be loaded */ |
| 3056 | static int |
| 3057 | awe_probe_data(awe_patch_info *patch, const char __user *addr, int count) |
| 3058 | { |
| 3059 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 3060 | if (! patch_opened) |
| 3061 | return -EINVAL; |
| 3062 | |
| 3063 | /* search the specified sample by optarg */ |
| 3064 | if (search_sample_index(sftail, patch->optarg) != NULL) |
| 3065 | return 0; |
| 3066 | #endif /* allow sharing */ |
| 3067 | return -EINVAL; |
| 3068 | } |
| 3069 | |
| 3070 | |
| 3071 | /* remove the present instrument layers */ |
| 3072 | static int |
| 3073 | remove_info(sf_list *sf, int bank, int instr) |
| 3074 | { |
| 3075 | awe_voice_list *prev, *next, *p; |
| 3076 | int removed = 0; |
| 3077 | |
| 3078 | prev = NULL; |
| 3079 | for (p = sf->infos; p; p = next) { |
| 3080 | next = p->next; |
| 3081 | if (p->type == V_ST_NORMAL && |
| 3082 | p->bank == bank && p->instr == instr) { |
| 3083 | /* remove this layer */ |
| 3084 | if (prev) |
| 3085 | prev->next = next; |
| 3086 | else |
| 3087 | sf->infos = next; |
| 3088 | if (p == sf->last_infos) |
| 3089 | sf->last_infos = prev; |
| 3090 | sf->num_info--; |
| 3091 | removed++; |
| 3092 | kfree(p); |
| 3093 | } else |
| 3094 | prev = p; |
| 3095 | } |
| 3096 | if (removed) |
| 3097 | rebuild_preset_list(); |
| 3098 | return removed; |
| 3099 | } |
| 3100 | |
| 3101 | /* load voice information data */ |
| 3102 | static int |
| 3103 | awe_load_info(awe_patch_info *patch, const char __user *addr, int count) |
| 3104 | { |
| 3105 | int offset; |
| 3106 | awe_voice_rec_hdr hdr; |
| 3107 | int i; |
| 3108 | int total_size; |
| 3109 | sf_list *sf; |
| 3110 | awe_voice_list *rec; |
| 3111 | |
| 3112 | if (count < AWE_VOICE_REC_SIZE) { |
| 3113 | printk(KERN_WARNING "AWE32 Error: invalid patch info length\n"); |
| 3114 | return -EINVAL; |
| 3115 | } |
| 3116 | |
| 3117 | offset = AWE_PATCH_INFO_SIZE; |
| 3118 | if (copy_from_user((char*)&hdr, addr + offset, AWE_VOICE_REC_SIZE)) |
| 3119 | return -EFAULT; |
| 3120 | offset += AWE_VOICE_REC_SIZE; |
| 3121 | |
| 3122 | if (hdr.nvoices <= 0 || hdr.nvoices >= 100) { |
| 3123 | printk(KERN_WARNING "AWE32 Error: Invalid voice number %d\n", hdr.nvoices); |
| 3124 | return -EINVAL; |
| 3125 | } |
| 3126 | total_size = AWE_VOICE_REC_SIZE + AWE_VOICE_INFO_SIZE * hdr.nvoices; |
| 3127 | if (count < total_size) { |
| 3128 | printk(KERN_WARNING "AWE32 Error: patch length(%d) is smaller than nvoices(%d)\n", |
| 3129 | count, hdr.nvoices); |
| 3130 | return -EINVAL; |
| 3131 | } |
| 3132 | |
| 3133 | if ((sf = check_patch_opened(AWE_PAT_TYPE_MISC, NULL)) == NULL) |
| 3134 | return -ENOMEM; |
| 3135 | |
| 3136 | switch (hdr.write_mode) { |
| 3137 | case AWE_WR_EXCLUSIVE: |
| 3138 | /* exclusive mode - if the instrument already exists, |
| 3139 | return error */ |
| 3140 | for (rec = sf->infos; rec; rec = rec->next) { |
| 3141 | if (rec->type == V_ST_NORMAL && |
| 3142 | rec->bank == hdr.bank && |
| 3143 | rec->instr == hdr.instr) |
| 3144 | return -EINVAL; |
| 3145 | } |
| 3146 | break; |
| 3147 | case AWE_WR_REPLACE: |
| 3148 | /* replace mode - remove the instrument if it already exists */ |
| 3149 | remove_info(sf, hdr.bank, hdr.instr); |
| 3150 | break; |
| 3151 | } |
| 3152 | |
| 3153 | /* append new layers */ |
| 3154 | for (i = 0; i < hdr.nvoices; i++) { |
| 3155 | rec = alloc_new_info(); |
| 3156 | if (rec == NULL) |
| 3157 | return -ENOMEM; |
| 3158 | |
| 3159 | rec->bank = hdr.bank; |
| 3160 | rec->instr = hdr.instr; |
| 3161 | rec->type = V_ST_NORMAL; |
| 3162 | rec->disabled = FALSE; |
| 3163 | |
| 3164 | /* copy awe_voice_info parameters */ |
| 3165 | if (copy_from_user(&rec->v, addr + offset, AWE_VOICE_INFO_SIZE)) { |
| 3166 | kfree(rec); |
| 3167 | return -EFAULT; |
| 3168 | } |
| 3169 | offset += AWE_VOICE_INFO_SIZE; |
| 3170 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 3171 | if (sf && sf->shared) { |
| 3172 | if (info_duplicated(sf, rec)) { |
| 3173 | kfree(rec); |
| 3174 | continue; |
| 3175 | } |
| 3176 | } |
| 3177 | #endif /* allow sharing */ |
| 3178 | if (rec->v.mode & AWE_MODE_INIT_PARM) |
| 3179 | awe_init_voice_parm(&rec->v.parm); |
| 3180 | add_sf_info(sf, rec); |
| 3181 | awe_set_sample(rec); |
| 3182 | add_info_list(rec); |
| 3183 | } |
| 3184 | |
| 3185 | return 0; |
| 3186 | } |
| 3187 | |
| 3188 | |
| 3189 | /* remove instrument layers */ |
| 3190 | static int |
| 3191 | awe_remove_info(awe_patch_info *patch, const char __user *addr, int count) |
| 3192 | { |
| 3193 | unsigned char bank, instr; |
| 3194 | sf_list *sf; |
| 3195 | |
| 3196 | if (! patch_opened || (sf = sftail) == NULL) { |
| 3197 | printk(KERN_WARNING "AWE32: remove_info: patch not opened\n"); |
| 3198 | return -EINVAL; |
| 3199 | } |
| 3200 | |
| 3201 | bank = ((unsigned short)patch->optarg >> 8) & 0xff; |
| 3202 | instr = (unsigned short)patch->optarg & 0xff; |
| 3203 | if (! remove_info(sf, bank, instr)) |
| 3204 | return -EINVAL; |
| 3205 | return 0; |
| 3206 | } |
| 3207 | |
| 3208 | |
| 3209 | /* load wave sample data */ |
| 3210 | static int |
| 3211 | awe_load_data(awe_patch_info *patch, const char __user *addr, int count) |
| 3212 | { |
| 3213 | int offset, size; |
| 3214 | int rc; |
| 3215 | awe_sample_info tmprec; |
| 3216 | awe_sample_list *rec; |
| 3217 | sf_list *sf; |
| 3218 | |
| 3219 | if ((sf = check_patch_opened(AWE_PAT_TYPE_MISC, NULL)) == NULL) |
| 3220 | return -ENOMEM; |
| 3221 | |
| 3222 | size = (count - AWE_SAMPLE_INFO_SIZE) / 2; |
| 3223 | offset = AWE_PATCH_INFO_SIZE; |
| 3224 | if (copy_from_user(&tmprec, addr + offset, AWE_SAMPLE_INFO_SIZE)) |
| 3225 | return -EFAULT; |
| 3226 | offset += AWE_SAMPLE_INFO_SIZE; |
| 3227 | if (size != tmprec.size) { |
| 3228 | printk(KERN_WARNING "AWE32: load: sample size differed (%d != %d)\n", |
| 3229 | tmprec.size, size); |
| 3230 | return -EINVAL; |
| 3231 | } |
| 3232 | |
| 3233 | if (search_sample_index(sf, tmprec.sample) != NULL) { |
| 3234 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 3235 | /* if shared sample, skip this data */ |
| 3236 | if (sf->type & AWE_PAT_SHARED) |
| 3237 | return 0; |
| 3238 | #endif /* allow sharing */ |
| 3239 | DEBUG(1,printk("AWE32: sample data %d already present\n", tmprec.sample)); |
| 3240 | return -EINVAL; |
| 3241 | } |
| 3242 | |
| 3243 | if ((rec = alloc_new_sample()) == NULL) |
| 3244 | return -ENOMEM; |
| 3245 | |
| 3246 | memcpy(&rec->v, &tmprec, sizeof(tmprec)); |
| 3247 | |
| 3248 | if (rec->v.size > 0) { |
| 3249 | if ((rc = awe_write_wave_data(addr, offset, rec, -1)) < 0) { |
| 3250 | kfree(rec); |
| 3251 | return rc; |
| 3252 | } |
| 3253 | sf->mem_ptr += rc; |
| 3254 | } |
| 3255 | |
| 3256 | add_sf_sample(sf, rec); |
| 3257 | return 0; |
| 3258 | } |
| 3259 | |
| 3260 | |
| 3261 | /* replace wave sample data */ |
| 3262 | static int |
| 3263 | awe_replace_data(awe_patch_info *patch, const char __user *addr, int count) |
| 3264 | { |
| 3265 | int offset; |
| 3266 | int size; |
| 3267 | int rc; |
| 3268 | int channels; |
| 3269 | awe_sample_info cursmp; |
| 3270 | int save_mem_ptr; |
| 3271 | sf_list *sf; |
| 3272 | awe_sample_list *rec; |
| 3273 | |
| 3274 | if (! patch_opened || (sf = sftail) == NULL) { |
| 3275 | printk(KERN_WARNING "AWE32: replace: patch not opened\n"); |
| 3276 | return -EINVAL; |
| 3277 | } |
| 3278 | |
| 3279 | size = (count - AWE_SAMPLE_INFO_SIZE) / 2; |
| 3280 | offset = AWE_PATCH_INFO_SIZE; |
| 3281 | if (copy_from_user(&cursmp, addr + offset, AWE_SAMPLE_INFO_SIZE)) |
| 3282 | return -EFAULT; |
| 3283 | offset += AWE_SAMPLE_INFO_SIZE; |
| 3284 | if (cursmp.size == 0 || size != cursmp.size) { |
| 3285 | printk(KERN_WARNING "AWE32: replace: invalid sample size (%d!=%d)\n", |
| 3286 | cursmp.size, size); |
| 3287 | return -EINVAL; |
| 3288 | } |
| 3289 | channels = patch->optarg; |
| 3290 | if (channels <= 0 || channels > AWE_NORMAL_VOICES) { |
| 3291 | printk(KERN_WARNING "AWE32: replace: invalid channels %d\n", channels); |
| 3292 | return -EINVAL; |
| 3293 | } |
| 3294 | |
| 3295 | for (rec = sf->samples; rec; rec = rec->next) { |
| 3296 | if (rec->v.sample == cursmp.sample) |
| 3297 | break; |
| 3298 | } |
| 3299 | if (rec == NULL) { |
| 3300 | printk(KERN_WARNING "AWE32: replace: cannot find existing sample data %d\n", |
| 3301 | cursmp.sample); |
| 3302 | return -EINVAL; |
| 3303 | } |
| 3304 | |
| 3305 | if (rec->v.size != cursmp.size) { |
| 3306 | printk(KERN_WARNING "AWE32: replace: exiting size differed (%d!=%d)\n", |
| 3307 | rec->v.size, cursmp.size); |
| 3308 | return -EINVAL; |
| 3309 | } |
| 3310 | |
| 3311 | save_mem_ptr = awe_free_mem_ptr(); |
| 3312 | sftail->mem_ptr = rec->v.start - awe_mem_start; |
| 3313 | memcpy(&rec->v, &cursmp, sizeof(cursmp)); |
| 3314 | rec->v.sf_id = current_sf_id; |
| 3315 | if ((rc = awe_write_wave_data(addr, offset, rec, channels)) < 0) |
| 3316 | return rc; |
| 3317 | sftail->mem_ptr = save_mem_ptr; |
| 3318 | |
| 3319 | return 0; |
| 3320 | } |
| 3321 | |
| 3322 | |
| 3323 | /*----------------------------------------------------------------*/ |
| 3324 | |
| 3325 | static const char __user *readbuf_addr; |
| 3326 | static int readbuf_offs; |
| 3327 | static int readbuf_flags; |
| 3328 | |
| 3329 | /* initialize read buffer */ |
| 3330 | static int |
| 3331 | readbuf_init(const char __user *addr, int offset, awe_sample_info *sp) |
| 3332 | { |
| 3333 | readbuf_addr = addr; |
| 3334 | readbuf_offs = offset; |
| 3335 | readbuf_flags = sp->mode_flags; |
| 3336 | return 0; |
| 3337 | } |
| 3338 | |
| 3339 | /* read directly from user buffer */ |
| 3340 | static unsigned short |
| 3341 | readbuf_word(int pos) |
| 3342 | { |
| 3343 | unsigned short c; |
| 3344 | /* read from user buffer */ |
| 3345 | if (readbuf_flags & AWE_SAMPLE_8BITS) { |
| 3346 | unsigned char cc; |
| 3347 | get_user(cc, (unsigned char __user *)(readbuf_addr + readbuf_offs + pos)); |
| 3348 | c = (unsigned short)cc << 8; /* convert 8bit -> 16bit */ |
| 3349 | } else { |
| 3350 | get_user(c, (unsigned short __user *)(readbuf_addr + readbuf_offs + pos * 2)); |
| 3351 | } |
| 3352 | if (readbuf_flags & AWE_SAMPLE_UNSIGNED) |
| 3353 | c ^= 0x8000; /* unsigned -> signed */ |
| 3354 | return c; |
| 3355 | } |
| 3356 | |
| 3357 | #define readbuf_word_cache readbuf_word |
| 3358 | #define readbuf_end() /**/ |
| 3359 | |
| 3360 | /*----------------------------------------------------------------*/ |
| 3361 | |
| 3362 | #define BLANK_LOOP_START 8 |
| 3363 | #define BLANK_LOOP_END 40 |
| 3364 | #define BLANK_LOOP_SIZE 48 |
| 3365 | |
| 3366 | /* loading onto memory - return the actual written size */ |
| 3367 | static int |
| 3368 | awe_write_wave_data(const char __user *addr, int offset, awe_sample_list *list, int channels) |
| 3369 | { |
| 3370 | int i, truesize, dram_offset; |
| 3371 | awe_sample_info *sp = &list->v; |
| 3372 | int rc; |
| 3373 | |
| 3374 | /* be sure loop points start < end */ |
| 3375 | if (sp->loopstart > sp->loopend) { |
| 3376 | int tmp = sp->loopstart; |
| 3377 | sp->loopstart = sp->loopend; |
| 3378 | sp->loopend = tmp; |
| 3379 | } |
| 3380 | |
| 3381 | /* compute true data size to be loaded */ |
| 3382 | truesize = sp->size; |
| 3383 | if (sp->mode_flags & (AWE_SAMPLE_BIDIR_LOOP|AWE_SAMPLE_REVERSE_LOOP)) |
| 3384 | truesize += sp->loopend - sp->loopstart; |
| 3385 | if (sp->mode_flags & AWE_SAMPLE_NO_BLANK) |
| 3386 | truesize += BLANK_LOOP_SIZE; |
| 3387 | if (awe_free_mem_ptr() + truesize >= memsize/2) { |
| 3388 | DEBUG(-1,printk("AWE32 Error: Sample memory full\n")); |
| 3389 | return -ENOSPC; |
| 3390 | } |
| 3391 | |
| 3392 | /* recalculate address offset */ |
| 3393 | sp->end -= sp->start; |
| 3394 | sp->loopstart -= sp->start; |
| 3395 | sp->loopend -= sp->start; |
| 3396 | |
| 3397 | dram_offset = awe_free_mem_ptr() + awe_mem_start; |
| 3398 | sp->start = dram_offset; |
| 3399 | sp->end += dram_offset; |
| 3400 | sp->loopstart += dram_offset; |
| 3401 | sp->loopend += dram_offset; |
| 3402 | |
| 3403 | /* set the total size (store onto obsolete checksum value) */ |
| 3404 | if (sp->size == 0) |
| 3405 | sp->checksum = 0; |
| 3406 | else |
| 3407 | sp->checksum = truesize; |
| 3408 | |
| 3409 | if ((rc = awe_open_dram_for_write(dram_offset, channels)) != 0) |
| 3410 | return rc; |
| 3411 | |
| 3412 | if (readbuf_init(addr, offset, sp) < 0) |
| 3413 | return -ENOSPC; |
| 3414 | |
| 3415 | for (i = 0; i < sp->size; i++) { |
| 3416 | unsigned short c; |
| 3417 | c = readbuf_word(i); |
| 3418 | awe_write_dram(c); |
| 3419 | if (i == sp->loopend && |
| 3420 | (sp->mode_flags & (AWE_SAMPLE_BIDIR_LOOP|AWE_SAMPLE_REVERSE_LOOP))) { |
| 3421 | int looplen = sp->loopend - sp->loopstart; |
| 3422 | /* copy reverse loop */ |
| 3423 | int k; |
| 3424 | for (k = 1; k <= looplen; k++) { |
| 3425 | c = readbuf_word_cache(i - k); |
| 3426 | awe_write_dram(c); |
| 3427 | } |
| 3428 | if (sp->mode_flags & AWE_SAMPLE_BIDIR_LOOP) { |
| 3429 | sp->end += looplen; |
| 3430 | } else { |
| 3431 | sp->start += looplen; |
| 3432 | sp->end += looplen; |
| 3433 | } |
| 3434 | } |
| 3435 | } |
| 3436 | readbuf_end(); |
| 3437 | |
| 3438 | /* if no blank loop is attached in the sample, add it */ |
| 3439 | if (sp->mode_flags & AWE_SAMPLE_NO_BLANK) { |
| 3440 | for (i = 0; i < BLANK_LOOP_SIZE; i++) |
| 3441 | awe_write_dram(0); |
| 3442 | if (sp->mode_flags & AWE_SAMPLE_SINGLESHOT) { |
| 3443 | sp->loopstart = sp->end + BLANK_LOOP_START; |
| 3444 | sp->loopend = sp->end + BLANK_LOOP_END; |
| 3445 | } |
| 3446 | } |
| 3447 | |
| 3448 | awe_close_dram(); |
| 3449 | |
| 3450 | /* initialize FM */ |
| 3451 | awe_init_fm(); |
| 3452 | |
| 3453 | return truesize; |
| 3454 | } |
| 3455 | |
| 3456 | |
| 3457 | /*----------------------------------------------------------------*/ |
| 3458 | |
| 3459 | #ifdef AWE_HAS_GUS_COMPATIBILITY |
| 3460 | |
| 3461 | /* calculate GUS envelope time: |
| 3462 | * is this correct? i have no idea.. |
| 3463 | */ |
| 3464 | static int |
| 3465 | calc_gus_envelope_time(int rate, int start, int end) |
| 3466 | { |
| 3467 | int r, p, t; |
| 3468 | r = (3 - ((rate >> 6) & 3)) * 3; |
| 3469 | p = rate & 0x3f; |
| 3470 | t = end - start; |
| 3471 | if (t < 0) t = -t; |
| 3472 | if (13 > r) |
| 3473 | t = t << (13 - r); |
| 3474 | else |
| 3475 | t = t >> (r - 13); |
| 3476 | return (t * 10) / (p * 441); |
| 3477 | } |
| 3478 | |
| 3479 | #define calc_gus_sustain(val) (0x7f - vol_table[(val)/2]) |
| 3480 | #define calc_gus_attenuation(val) vol_table[(val)/2] |
| 3481 | |
| 3482 | /* load GUS patch */ |
| 3483 | static int |
| 3484 | awe_load_guspatch(const char __user *addr, int offs, int size, int pmgr_flag) |
| 3485 | { |
| 3486 | struct patch_info patch; |
| 3487 | awe_voice_info *rec; |
| 3488 | awe_sample_info *smp; |
| 3489 | awe_voice_list *vrec; |
| 3490 | awe_sample_list *smprec; |
| 3491 | int sizeof_patch; |
| 3492 | int note, rc; |
| 3493 | sf_list *sf; |
| 3494 | |
| 3495 | sizeof_patch = (int)((long)&patch.data[0] - (long)&patch); /* header size */ |
| 3496 | if (size < sizeof_patch) { |
| 3497 | printk(KERN_WARNING "AWE32 Error: Patch header too short\n"); |
| 3498 | return -EINVAL; |
| 3499 | } |
| 3500 | if (copy_from_user(((char*)&patch) + offs, addr + offs, sizeof_patch - offs)) |
| 3501 | return -EFAULT; |
| 3502 | size -= sizeof_patch; |
| 3503 | if (size < patch.len) { |
| 3504 | printk(KERN_WARNING "AWE32 Error: Patch record too short (%d<%d)\n", |
| 3505 | size, patch.len); |
| 3506 | return -EINVAL; |
| 3507 | } |
| 3508 | if ((sf = check_patch_opened(AWE_PAT_TYPE_GUS, NULL)) == NULL) |
| 3509 | return -ENOMEM; |
| 3510 | if ((smprec = alloc_new_sample()) == NULL) |
| 3511 | return -ENOMEM; |
| 3512 | if ((vrec = alloc_new_info()) == NULL) { |
| 3513 | kfree(smprec); |
| 3514 | return -ENOMEM; |
| 3515 | } |
| 3516 | |
| 3517 | smp = &smprec->v; |
| 3518 | smp->sample = sf->num_sample; |
| 3519 | smp->start = 0; |
| 3520 | smp->end = patch.len; |
| 3521 | smp->loopstart = patch.loop_start; |
| 3522 | smp->loopend = patch.loop_end; |
| 3523 | smp->size = patch.len; |
| 3524 | |
| 3525 | /* set up mode flags */ |
| 3526 | smp->mode_flags = 0; |
| 3527 | if (!(patch.mode & WAVE_16_BITS)) |
| 3528 | smp->mode_flags |= AWE_SAMPLE_8BITS; |
| 3529 | if (patch.mode & WAVE_UNSIGNED) |
| 3530 | smp->mode_flags |= AWE_SAMPLE_UNSIGNED; |
| 3531 | smp->mode_flags |= AWE_SAMPLE_NO_BLANK; |
| 3532 | if (!(patch.mode & (WAVE_LOOPING|WAVE_BIDIR_LOOP|WAVE_LOOP_BACK))) |
| 3533 | smp->mode_flags |= AWE_SAMPLE_SINGLESHOT; |
| 3534 | if (patch.mode & WAVE_BIDIR_LOOP) |
| 3535 | smp->mode_flags |= AWE_SAMPLE_BIDIR_LOOP; |
| 3536 | if (patch.mode & WAVE_LOOP_BACK) |
| 3537 | smp->mode_flags |= AWE_SAMPLE_REVERSE_LOOP; |
| 3538 | |
| 3539 | DEBUG(0,printk("AWE32: [sample %d mode %x]\n", patch.instr_no, smp->mode_flags)); |
| 3540 | if (patch.mode & WAVE_16_BITS) { |
| 3541 | /* convert to word offsets */ |
| 3542 | smp->size /= 2; |
| 3543 | smp->end /= 2; |
| 3544 | smp->loopstart /= 2; |
| 3545 | smp->loopend /= 2; |
| 3546 | } |
| 3547 | smp->checksum_flag = 0; |
| 3548 | smp->checksum = 0; |
| 3549 | |
| 3550 | if ((rc = awe_write_wave_data(addr, sizeof_patch, smprec, -1)) < 0) |
| 3551 | return rc; |
| 3552 | sf->mem_ptr += rc; |
| 3553 | add_sf_sample(sf, smprec); |
| 3554 | |
| 3555 | /* set up voice info */ |
| 3556 | rec = &vrec->v; |
| 3557 | awe_init_voice_info(rec); |
| 3558 | rec->sample = sf->num_info; /* the last sample */ |
| 3559 | rec->rate_offset = calc_rate_offset(patch.base_freq); |
| 3560 | note = freq_to_note(patch.base_note); |
| 3561 | rec->root = note / 100; |
| 3562 | rec->tune = -(note % 100); |
| 3563 | rec->low = freq_to_note(patch.low_note) / 100; |
| 3564 | rec->high = freq_to_note(patch.high_note) / 100; |
| 3565 | DEBUG(1,printk("AWE32: [gus base offset=%d, note=%d, range=%d-%d(%d-%d)]\n", |
| 3566 | rec->rate_offset, note, |
| 3567 | rec->low, rec->high, |
| 3568 | patch.low_note, patch.high_note)); |
| 3569 | /* panning position; -128 - 127 => 0-127 */ |
| 3570 | rec->pan = (patch.panning + 128) / 2; |
| 3571 | |
| 3572 | /* detuning is ignored */ |
| 3573 | /* 6points volume envelope */ |
| 3574 | if (patch.mode & WAVE_ENVELOPES) { |
| 3575 | int attack, hold, decay, release; |
| 3576 | attack = calc_gus_envelope_time |
| 3577 | (patch.env_rate[0], 0, patch.env_offset[0]); |
| 3578 | hold = calc_gus_envelope_time |
| 3579 | (patch.env_rate[1], patch.env_offset[0], |
| 3580 | patch.env_offset[1]); |
| 3581 | decay = calc_gus_envelope_time |
| 3582 | (patch.env_rate[2], patch.env_offset[1], |
| 3583 | patch.env_offset[2]); |
| 3584 | release = calc_gus_envelope_time |
| 3585 | (patch.env_rate[3], patch.env_offset[1], |
| 3586 | patch.env_offset[4]); |
| 3587 | release += calc_gus_envelope_time |
| 3588 | (patch.env_rate[4], patch.env_offset[3], |
| 3589 | patch.env_offset[4]); |
| 3590 | release += calc_gus_envelope_time |
| 3591 | (patch.env_rate[5], patch.env_offset[4], |
| 3592 | patch.env_offset[5]); |
| 3593 | rec->parm.volatkhld = (calc_parm_hold(hold) << 8) | |
| 3594 | calc_parm_attack(attack); |
| 3595 | rec->parm.voldcysus = (calc_gus_sustain(patch.env_offset[2]) << 8) | |
| 3596 | calc_parm_decay(decay); |
| 3597 | rec->parm.volrelease = 0x8000 | calc_parm_decay(release); |
| 3598 | DEBUG(2,printk("AWE32: [gusenv atk=%d, hld=%d, dcy=%d, rel=%d]\n", attack, hold, decay, release)); |
| 3599 | rec->attenuation = calc_gus_attenuation(patch.env_offset[0]); |
| 3600 | } |
| 3601 | |
| 3602 | /* tremolo effect */ |
| 3603 | if (patch.mode & WAVE_TREMOLO) { |
| 3604 | int rate = (patch.tremolo_rate * 1000 / 38) / 42; |
| 3605 | rec->parm.tremfrq = ((patch.tremolo_depth / 2) << 8) | rate; |
| 3606 | DEBUG(2,printk("AWE32: [gusenv tremolo rate=%d, dep=%d, tremfrq=%x]\n", |
| 3607 | patch.tremolo_rate, patch.tremolo_depth, |
| 3608 | rec->parm.tremfrq)); |
| 3609 | } |
| 3610 | /* vibrato effect */ |
| 3611 | if (patch.mode & WAVE_VIBRATO) { |
| 3612 | int rate = (patch.vibrato_rate * 1000 / 38) / 42; |
| 3613 | rec->parm.fm2frq2 = ((patch.vibrato_depth / 6) << 8) | rate; |
| 3614 | DEBUG(2,printk("AWE32: [gusenv vibrato rate=%d, dep=%d, tremfrq=%x]\n", |
| 3615 | patch.tremolo_rate, patch.tremolo_depth, |
| 3616 | rec->parm.tremfrq)); |
| 3617 | } |
| 3618 | |
| 3619 | /* scale_freq, scale_factor, volume, and fractions not implemented */ |
| 3620 | |
| 3621 | /* append to the tail of the list */ |
| 3622 | vrec->bank = ctrls[AWE_MD_GUS_BANK]; |
| 3623 | vrec->instr = patch.instr_no; |
| 3624 | vrec->disabled = FALSE; |
| 3625 | vrec->type = V_ST_NORMAL; |
| 3626 | |
| 3627 | add_sf_info(sf, vrec); |
| 3628 | add_info_list(vrec); |
| 3629 | |
| 3630 | /* set the voice index */ |
| 3631 | awe_set_sample(vrec); |
| 3632 | |
| 3633 | return 0; |
| 3634 | } |
| 3635 | |
| 3636 | #endif /* AWE_HAS_GUS_COMPATIBILITY */ |
| 3637 | |
| 3638 | /* |
| 3639 | * sample and voice list handlers |
| 3640 | */ |
| 3641 | |
| 3642 | /* append this to the current sf list */ |
| 3643 | static void add_sf_info(sf_list *sf, awe_voice_list *rec) |
| 3644 | { |
| 3645 | if (sf == NULL) |
| 3646 | return; |
| 3647 | rec->holder = sf; |
| 3648 | rec->v.sf_id = sf->sf_id; |
| 3649 | if (sf->last_infos) |
| 3650 | sf->last_infos->next = rec; |
| 3651 | else |
| 3652 | sf->infos = rec; |
| 3653 | sf->last_infos = rec; |
| 3654 | rec->next = NULL; |
| 3655 | sf->num_info++; |
| 3656 | } |
| 3657 | |
| 3658 | /* prepend this sample to sf list */ |
| 3659 | static void add_sf_sample(sf_list *sf, awe_sample_list *rec) |
| 3660 | { |
| 3661 | if (sf == NULL) |
| 3662 | return; |
| 3663 | rec->holder = sf; |
| 3664 | rec->v.sf_id = sf->sf_id; |
| 3665 | if (sf->last_samples) |
| 3666 | sf->last_samples->next = rec; |
| 3667 | else |
| 3668 | sf->samples = rec; |
| 3669 | sf->last_samples = rec; |
| 3670 | rec->next = NULL; |
| 3671 | sf->num_sample++; |
| 3672 | } |
| 3673 | |
| 3674 | /* purge the old records which don't belong with the same file id */ |
| 3675 | static void purge_old_list(awe_voice_list *rec, awe_voice_list *next) |
| 3676 | { |
| 3677 | rec->next_instr = next; |
| 3678 | if (rec->bank == AWE_DRUM_BANK) { |
| 3679 | /* remove samples with the same note range */ |
| 3680 | awe_voice_list *cur, *prev = rec; |
| 3681 | int low = rec->v.low; |
| 3682 | int high = rec->v.high; |
| 3683 | for (cur = next; cur; cur = cur->next_instr) { |
| 3684 | if (cur->v.low == low && |
| 3685 | cur->v.high == high && |
| 3686 | ! is_identical_holder(cur->holder, rec->holder)) |
| 3687 | prev->next_instr = cur->next_instr; |
| 3688 | else |
| 3689 | prev = cur; |
| 3690 | } |
| 3691 | } else { |
| 3692 | if (! is_identical_holder(next->holder, rec->holder)) |
| 3693 | /* remove all samples */ |
| 3694 | rec->next_instr = NULL; |
| 3695 | } |
| 3696 | } |
| 3697 | |
| 3698 | /* prepend to top of the preset table */ |
| 3699 | static void add_info_list(awe_voice_list *rec) |
| 3700 | { |
| 3701 | awe_voice_list *prev, *cur; |
| 3702 | int key; |
| 3703 | |
| 3704 | if (rec->disabled) |
| 3705 | return; |
| 3706 | |
| 3707 | key = awe_search_key(rec->bank, rec->instr, rec->v.low); |
| 3708 | prev = NULL; |
| 3709 | for (cur = preset_table[key]; cur; cur = cur->next_bank) { |
| 3710 | /* search the first record with the same bank number */ |
| 3711 | if (cur->instr == rec->instr && cur->bank == rec->bank) { |
| 3712 | /* replace the list with the new record */ |
| 3713 | rec->next_bank = cur->next_bank; |
| 3714 | if (prev) |
| 3715 | prev->next_bank = rec; |
| 3716 | else |
| 3717 | preset_table[key] = rec; |
| 3718 | purge_old_list(rec, cur); |
| 3719 | return; |
| 3720 | } |
| 3721 | prev = cur; |
| 3722 | } |
| 3723 | |
| 3724 | /* this is the first bank record.. just add this */ |
| 3725 | rec->next_instr = NULL; |
| 3726 | rec->next_bank = preset_table[key]; |
| 3727 | preset_table[key] = rec; |
| 3728 | } |
| 3729 | |
| 3730 | /* remove samples later than the specified sf_id */ |
| 3731 | static void |
| 3732 | awe_remove_samples(int sf_id) |
| 3733 | { |
| 3734 | sf_list *p, *prev; |
| 3735 | |
| 3736 | if (sf_id <= 0) { |
| 3737 | awe_reset_samples(); |
| 3738 | return; |
| 3739 | } |
| 3740 | /* already removed? */ |
| 3741 | if (current_sf_id <= sf_id) |
| 3742 | return; |
| 3743 | |
| 3744 | for (p = sftail; p; p = prev) { |
| 3745 | if (p->sf_id <= sf_id) |
| 3746 | break; |
| 3747 | prev = p->prev; |
| 3748 | awe_free_sf(p); |
| 3749 | } |
| 3750 | sftail = p; |
| 3751 | if (sftail) { |
| 3752 | sf_id = sftail->sf_id; |
| 3753 | sftail->next = NULL; |
| 3754 | } else { |
| 3755 | sf_id = 0; |
| 3756 | sfhead = NULL; |
| 3757 | } |
| 3758 | current_sf_id = sf_id; |
| 3759 | if (locked_sf_id > sf_id) |
| 3760 | locked_sf_id = sf_id; |
| 3761 | |
| 3762 | rebuild_preset_list(); |
| 3763 | } |
| 3764 | |
| 3765 | /* rebuild preset search list */ |
| 3766 | static void rebuild_preset_list(void) |
| 3767 | { |
| 3768 | sf_list *p; |
| 3769 | awe_voice_list *rec; |
| 3770 | |
| 3771 | memset(preset_table, 0, sizeof(preset_table)); |
| 3772 | |
| 3773 | for (p = sfhead; p; p = p->next) { |
| 3774 | for (rec = p->infos; rec; rec = rec->next) |
| 3775 | add_info_list(rec); |
| 3776 | } |
| 3777 | } |
| 3778 | |
| 3779 | /* compare the given sf_id pair */ |
| 3780 | static int is_identical_holder(sf_list *sf1, sf_list *sf2) |
| 3781 | { |
| 3782 | if (sf1 == NULL || sf2 == NULL) |
| 3783 | return FALSE; |
| 3784 | if (sf1 == sf2) |
| 3785 | return TRUE; |
| 3786 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 3787 | { |
| 3788 | /* compare with the sharing id */ |
| 3789 | sf_list *p; |
| 3790 | int counter = 0; |
| 3791 | if (sf1->sf_id < sf2->sf_id) { /* make sure id1 > id2 */ |
| 3792 | sf_list *tmp; tmp = sf1; sf1 = sf2; sf2 = tmp; |
| 3793 | } |
| 3794 | for (p = sf1->shared; p; p = p->shared) { |
| 3795 | if (counter++ > current_sf_id) |
| 3796 | break; /* strange sharing loop.. quit */ |
| 3797 | if (p == sf2) |
| 3798 | return TRUE; |
| 3799 | } |
| 3800 | } |
| 3801 | #endif /* allow sharing */ |
| 3802 | return FALSE; |
| 3803 | } |
| 3804 | |
| 3805 | /* search the sample index matching with the given sample id */ |
| 3806 | static awe_sample_list * |
| 3807 | search_sample_index(sf_list *sf, int sample) |
| 3808 | { |
| 3809 | awe_sample_list *p; |
| 3810 | #ifdef AWE_ALLOW_SAMPLE_SHARING |
| 3811 | int counter = 0; |
| 3812 | while (sf) { |
| 3813 | for (p = sf->samples; p; p = p->next) { |
| 3814 | if (p->v.sample == sample) |
| 3815 | return p; |
| 3816 | } |
| 3817 | sf = sf->shared; |
| 3818 | if (counter++ > current_sf_id) |
| 3819 | break; /* strange sharing loop.. quit */ |
| 3820 | } |
| 3821 | #else |
| 3822 | if (sf) { |
| 3823 | for (p = sf->samples; p; p = p->next) { |
| 3824 | if (p->v.sample == sample) |
| 3825 | return p; |
| 3826 | } |
| 3827 | } |
| 3828 | #endif |
| 3829 | return NULL; |
| 3830 | } |
| 3831 | |
| 3832 | /* search the specified sample */ |
| 3833 | /* non-zero = found */ |
| 3834 | static short |
| 3835 | awe_set_sample(awe_voice_list *rec) |
| 3836 | { |
| 3837 | awe_sample_list *smp; |
| 3838 | awe_voice_info *vp = &rec->v; |
| 3839 | |
| 3840 | vp->index = 0; |
| 3841 | if ((smp = search_sample_index(rec->holder, vp->sample)) == NULL) |
| 3842 | return 0; |
| 3843 | |
| 3844 | /* set the actual sample offsets */ |
| 3845 | vp->start += smp->v.start; |
| 3846 | vp->end += smp->v.end; |
| 3847 | vp->loopstart += smp->v.loopstart; |
| 3848 | vp->loopend += smp->v.loopend; |
| 3849 | /* copy mode flags */ |
| 3850 | vp->mode = smp->v.mode_flags; |
| 3851 | /* set flag */ |
| 3852 | vp->index = 1; |
| 3853 | |
| 3854 | return 1; |
| 3855 | } |
| 3856 | |
| 3857 | |
| 3858 | /* |
| 3859 | * voice allocation |
| 3860 | */ |
| 3861 | |
| 3862 | /* look for all voices associated with the specified note & velocity */ |
| 3863 | static int |
| 3864 | awe_search_multi_voices(awe_voice_list *rec, int note, int velocity, |
| 3865 | awe_voice_info **vlist) |
| 3866 | { |
| 3867 | int nvoices; |
| 3868 | |
| 3869 | nvoices = 0; |
| 3870 | for (; rec; rec = rec->next_instr) { |
| 3871 | if (note >= rec->v.low && |
| 3872 | note <= rec->v.high && |
| 3873 | velocity >= rec->v.vellow && |
| 3874 | velocity <= rec->v.velhigh) { |
| 3875 | if (rec->type == V_ST_MAPPED) { |
| 3876 | /* mapper */ |
| 3877 | vlist[0] = &rec->v; |
| 3878 | return -1; |
| 3879 | } |
| 3880 | vlist[nvoices++] = &rec->v; |
| 3881 | if (nvoices >= AWE_MAX_VOICES) |
| 3882 | break; |
| 3883 | } |
| 3884 | } |
| 3885 | return nvoices; |
| 3886 | } |
| 3887 | |
| 3888 | /* store the voice list from the specified note and velocity. |
| 3889 | if the preset is mapped, seek for the destination preset, and rewrite |
| 3890 | the note number if necessary. |
| 3891 | */ |
| 3892 | static int |
| 3893 | really_alloc_voices(int bank, int instr, int *note, int velocity, awe_voice_info **vlist) |
| 3894 | { |
| 3895 | int nvoices; |
| 3896 | awe_voice_list *vrec; |
| 3897 | int level = 0; |
| 3898 | |
| 3899 | for (;;) { |
| 3900 | vrec = awe_search_instr(bank, instr, *note); |
| 3901 | nvoices = awe_search_multi_voices(vrec, *note, velocity, vlist); |
| 3902 | if (nvoices == 0) { |
| 3903 | if (bank == AWE_DRUM_BANK) |
| 3904 | /* search default drumset */ |
| 3905 | vrec = awe_search_instr(bank, ctrls[AWE_MD_DEF_DRUM], *note); |
| 3906 | else |
| 3907 | /* search default preset */ |
| 3908 | vrec = awe_search_instr(ctrls[AWE_MD_DEF_BANK], instr, *note); |
| 3909 | nvoices = awe_search_multi_voices(vrec, *note, velocity, vlist); |
| 3910 | } |
| 3911 | if (nvoices == 0) { |
| 3912 | if (bank == AWE_DRUM_BANK && ctrls[AWE_MD_DEF_DRUM] != 0) |
| 3913 | /* search default drumset */ |
| 3914 | vrec = awe_search_instr(bank, 0, *note); |
| 3915 | else if (bank != AWE_DRUM_BANK && ctrls[AWE_MD_DEF_BANK] != 0) |
| 3916 | /* search default preset */ |
| 3917 | vrec = awe_search_instr(0, instr, *note); |
| 3918 | nvoices = awe_search_multi_voices(vrec, *note, velocity, vlist); |
| 3919 | } |
| 3920 | if (nvoices < 0) { /* mapping */ |
| 3921 | int key = vlist[0]->fixkey; |
| 3922 | instr = vlist[0]->start; |
| 3923 | bank = vlist[0]->end; |
| 3924 | if (level++ > 5) { |
| 3925 | printk(KERN_ERR "AWE32: too deep mapping level\n"); |
| 3926 | return 0; |
| 3927 | } |
| 3928 | if (key >= 0) |
| 3929 | *note = key; |
| 3930 | } else |
| 3931 | break; |
| 3932 | } |
| 3933 | |
| 3934 | return nvoices; |
| 3935 | } |
| 3936 | |
| 3937 | /* allocate voices corresponding note and velocity; supports multiple insts. */ |
| 3938 | static void |
| 3939 | awe_alloc_multi_voices(int ch, int note, int velocity, int key) |
| 3940 | { |
| 3941 | int i, v, nvoices, bank; |
| 3942 | awe_voice_info *vlist[AWE_MAX_VOICES]; |
| 3943 | |
| 3944 | if (MULTI_LAYER_MODE() && IS_DRUM_CHANNEL(ch)) |
| 3945 | bank = AWE_DRUM_BANK; /* always search drumset */ |
| 3946 | else |
| 3947 | bank = channels[ch].bank; |
| 3948 | |
| 3949 | /* check the possible voices; note may be changeable if mapped */ |
| 3950 | nvoices = really_alloc_voices(bank, channels[ch].instr, |
| 3951 | ¬e, velocity, vlist); |
| 3952 | |
| 3953 | /* set the voices */ |
| 3954 | current_alloc_time++; |
| 3955 | for (i = 0; i < nvoices; i++) { |
| 3956 | v = awe_clear_voice(); |
| 3957 | voices[v].key = key; |
| 3958 | voices[v].ch = ch; |
| 3959 | voices[v].note = note; |
| 3960 | voices[v].velocity = velocity; |
| 3961 | voices[v].time = current_alloc_time; |
| 3962 | voices[v].cinfo = &channels[ch]; |
| 3963 | voices[v].sample = vlist[i]; |
| 3964 | voices[v].state = AWE_ST_MARK; |
| 3965 | voices[v].layer = nvoices - i - 1; /* in reverse order */ |
| 3966 | } |
| 3967 | |
| 3968 | /* clear the mark in allocated voices */ |
| 3969 | for (i = 0; i < awe_max_voices; i++) { |
| 3970 | if (voices[i].state == AWE_ST_MARK) |
| 3971 | voices[i].state = AWE_ST_OFF; |
| 3972 | |
| 3973 | } |
| 3974 | } |
| 3975 | |
| 3976 | |
| 3977 | /* search an empty voice. |
| 3978 | if no empty voice is found, at least terminate a voice |
| 3979 | */ |
| 3980 | static int |
| 3981 | awe_clear_voice(void) |
| 3982 | { |
| 3983 | enum { |
| 3984 | OFF=0, RELEASED, SUSTAINED, PLAYING, END |
| 3985 | }; |
| 3986 | struct voice_candidate_t { |
| 3987 | int best; |
| 3988 | int time; |
| 3989 | int vtarget; |
| 3990 | } candidate[END]; |
| 3991 | int i, type, vtarget; |
| 3992 | |
| 3993 | vtarget = 0xffff; |
| 3994 | for (type = OFF; type < END; type++) { |
| 3995 | candidate[type].best = -1; |
| 3996 | candidate[type].time = current_alloc_time + 1; |
| 3997 | candidate[type].vtarget = vtarget; |
| 3998 | } |
| 3999 | |
| 4000 | for (i = 0; i < awe_max_voices; i++) { |
| 4001 | if (voices[i].state & AWE_ST_OFF) |
| 4002 | type = OFF; |
| 4003 | else if (voices[i].state & AWE_ST_RELEASED) |
| 4004 | type = RELEASED; |
| 4005 | else if (voices[i].state & AWE_ST_SUSTAINED) |
| 4006 | type = SUSTAINED; |
| 4007 | else if (voices[i].state & ~AWE_ST_MARK) |
| 4008 | type = PLAYING; |
| 4009 | else |
| 4010 | continue; |
| 4011 | #ifdef AWE_CHECK_VTARGET |
| 4012 | /* get current volume */ |
| 4013 | vtarget = (awe_peek_dw(AWE_VTFT(i)) >> 16) & 0xffff; |
| 4014 | #endif |
| 4015 | if (candidate[type].best < 0 || |
| 4016 | vtarget < candidate[type].vtarget || |
| 4017 | (vtarget == candidate[type].vtarget && |
| 4018 | voices[i].time < candidate[type].time)) { |
| 4019 | candidate[type].best = i; |
| 4020 | candidate[type].time = voices[i].time; |
| 4021 | candidate[type].vtarget = vtarget; |
| 4022 | } |
| 4023 | } |
| 4024 | |
| 4025 | for (type = OFF; type < END; type++) { |
| 4026 | if ((i = candidate[type].best) >= 0) { |
| 4027 | if (voices[i].state != AWE_ST_OFF) |
| 4028 | awe_terminate(i); |
| 4029 | awe_voice_init(i, TRUE); |
| 4030 | return i; |
| 4031 | } |
| 4032 | } |
| 4033 | return 0; |
| 4034 | } |
| 4035 | |
| 4036 | |
| 4037 | /* search sample for the specified note & velocity and set it on the voice; |
| 4038 | * note that voice is the voice index (not channel index) |
| 4039 | */ |
| 4040 | static void |
| 4041 | awe_alloc_one_voice(int voice, int note, int velocity) |
| 4042 | { |
| 4043 | int ch, nvoices, bank; |
| 4044 | awe_voice_info *vlist[AWE_MAX_VOICES]; |
| 4045 | |
| 4046 | ch = voices[voice].ch; |
| 4047 | if (MULTI_LAYER_MODE() && IS_DRUM_CHANNEL(voice)) |
| 4048 | bank = AWE_DRUM_BANK; /* always search drumset */ |
| 4049 | else |
| 4050 | bank = voices[voice].cinfo->bank; |
| 4051 | |
| 4052 | nvoices = really_alloc_voices(bank, voices[voice].cinfo->instr, |
| 4053 | ¬e, velocity, vlist); |
| 4054 | if (nvoices > 0) { |
| 4055 | voices[voice].time = ++current_alloc_time; |
| 4056 | voices[voice].sample = vlist[0]; /* use the first one */ |
| 4057 | voices[voice].layer = 0; |
| 4058 | voices[voice].note = note; |
| 4059 | voices[voice].velocity = velocity; |
| 4060 | } |
| 4061 | } |
| 4062 | |
| 4063 | |
| 4064 | /* |
| 4065 | * sequencer2 functions |
| 4066 | */ |
| 4067 | |
| 4068 | /* search an empty voice; used by sequencer2 */ |
| 4069 | static int |
| 4070 | awe_alloc(int dev, int chn, int note, struct voice_alloc_info *alloc) |
| 4071 | { |
| 4072 | playing_mode = AWE_PLAY_MULTI2; |
| 4073 | awe_info.nr_voices = AWE_MAX_CHANNELS; |
| 4074 | return awe_clear_voice(); |
| 4075 | } |
| 4076 | |
| 4077 | |
| 4078 | /* set up voice; used by sequencer2 */ |
| 4079 | static void |
| 4080 | awe_setup_voice(int dev, int voice, int chn) |
| 4081 | { |
| 4082 | struct channel_info *info; |
| 4083 | if (synth_devs[dev] == NULL || |
| 4084 | (info = &synth_devs[dev]->chn_info[chn]) == NULL) |
| 4085 | return; |
| 4086 | |
| 4087 | if (voice < 0 || voice >= awe_max_voices) |
| 4088 | return; |
| 4089 | |
| 4090 | DEBUG(2,printk("AWE32: [setup(%d) ch=%d]\n", voice, chn)); |
| 4091 | channels[chn].expression_vol = info->controllers[CTL_EXPRESSION]; |
| 4092 | channels[chn].main_vol = info->controllers[CTL_MAIN_VOLUME]; |
| 4093 | channels[chn].panning = |
| 4094 | info->controllers[CTL_PAN] * 2 - 128; /* signed 8bit */ |
| 4095 | channels[chn].bender = info->bender_value; /* zero center */ |
| 4096 | channels[chn].bank = info->controllers[CTL_BANK_SELECT]; |
| 4097 | channels[chn].sustained = info->controllers[CTL_SUSTAIN]; |
| 4098 | if (info->controllers[CTL_EXT_EFF_DEPTH]) { |
| 4099 | FX_SET(&channels[chn].fx, AWE_FX_REVERB, |
| 4100 | info->controllers[CTL_EXT_EFF_DEPTH] * 2); |
| 4101 | } |
| 4102 | if (info->controllers[CTL_CHORUS_DEPTH]) { |
| 4103 | FX_SET(&channels[chn].fx, AWE_FX_CHORUS, |
| 4104 | info->controllers[CTL_CHORUS_DEPTH] * 2); |
| 4105 | } |
| 4106 | awe_set_instr(dev, chn, info->pgm_num); |
| 4107 | } |
| 4108 | |
| 4109 | |
| 4110 | #ifdef CONFIG_AWE32_MIXER |
| 4111 | /* |
| 4112 | * AWE32 mixer device control |
| 4113 | */ |
| 4114 | |
| 4115 | static int awe_mixer_ioctl(int dev, unsigned int cmd, void __user *arg); |
| 4116 | |
| 4117 | static int my_mixerdev = -1; |
| 4118 | |
| 4119 | static struct mixer_operations awe_mixer_operations = { |
| 4120 | .owner = THIS_MODULE, |
| 4121 | .id = "AWE", |
| 4122 | .name = "AWE32 Equalizer", |
| 4123 | .ioctl = awe_mixer_ioctl, |
| 4124 | }; |
| 4125 | |
| 4126 | static void __init attach_mixer(void) |
| 4127 | { |
| 4128 | if ((my_mixerdev = sound_alloc_mixerdev()) >= 0) { |
| 4129 | mixer_devs[my_mixerdev] = &awe_mixer_operations; |
| 4130 | } |
| 4131 | } |
| 4132 | |
| 4133 | static void unload_mixer(void) |
| 4134 | { |
| 4135 | if (my_mixerdev >= 0) |
| 4136 | sound_unload_mixerdev(my_mixerdev); |
| 4137 | } |
| 4138 | |
| 4139 | static int |
| 4140 | awe_mixer_ioctl(int dev, unsigned int cmd, void __user * arg) |
| 4141 | { |
| 4142 | int i, level, value; |
| 4143 | |
| 4144 | if (((cmd >> 8) & 0xff) != 'M') |
| 4145 | return -EINVAL; |
| 4146 | |
| 4147 | if (get_user(level, (int __user *)arg)) |
| 4148 | return -EFAULT; |
| 4149 | level = ((level & 0xff) + (level >> 8)) / 2; |
| 4150 | DEBUG(0,printk("AWEMix: cmd=%x val=%d\n", cmd & 0xff, level)); |
| 4151 | |
| 4152 | if (_SIOC_DIR(cmd) & _SIOC_WRITE) { |
| 4153 | switch (cmd & 0xff) { |
| 4154 | case SOUND_MIXER_BASS: |
| 4155 | value = level * 12 / 100; |
| 4156 | if (value >= 12) |
| 4157 | value = 11; |
| 4158 | ctrls[AWE_MD_BASS_LEVEL] = value; |
| 4159 | awe_update_equalizer(); |
| 4160 | break; |
| 4161 | case SOUND_MIXER_TREBLE: |
| 4162 | value = level * 12 / 100; |
| 4163 | if (value >= 12) |
| 4164 | value = 11; |
| 4165 | ctrls[AWE_MD_TREBLE_LEVEL] = value; |
| 4166 | awe_update_equalizer(); |
| 4167 | break; |
| 4168 | case SOUND_MIXER_VOLUME: |
| 4169 | level = level * 127 / 100; |
| 4170 | if (level >= 128) level = 127; |
| 4171 | atten_relative = FALSE; |
| 4172 | atten_offset = vol_table[level]; |
| 4173 | awe_update_volume(); |
| 4174 | break; |
| 4175 | } |
| 4176 | } |
| 4177 | switch (cmd & 0xff) { |
| 4178 | case SOUND_MIXER_BASS: |
| 4179 | level = ctrls[AWE_MD_BASS_LEVEL] * 100 / 24; |
| 4180 | level = (level << 8) | level; |
| 4181 | break; |
| 4182 | case SOUND_MIXER_TREBLE: |
| 4183 | level = ctrls[AWE_MD_TREBLE_LEVEL] * 100 / 24; |
| 4184 | level = (level << 8) | level; |
| 4185 | break; |
| 4186 | case SOUND_MIXER_VOLUME: |
| 4187 | value = atten_offset; |
| 4188 | if (atten_relative) |
| 4189 | value += ctrls[AWE_MD_ZERO_ATTEN]; |
| 4190 | for (i = 127; i > 0; i--) { |
| 4191 | if (value <= vol_table[i]) |
| 4192 | break; |
| 4193 | } |
| 4194 | level = i * 100 / 127; |
| 4195 | level = (level << 8) | level; |
| 4196 | break; |
| 4197 | case SOUND_MIXER_DEVMASK: |
| 4198 | level = SOUND_MASK_BASS|SOUND_MASK_TREBLE|SOUND_MASK_VOLUME; |
| 4199 | break; |
| 4200 | default: |
| 4201 | level = 0; |
| 4202 | break; |
| 4203 | } |
| 4204 | if (put_user(level, (int __user *)arg)) |
| 4205 | return -EFAULT; |
| 4206 | return level; |
| 4207 | } |
| 4208 | #endif /* CONFIG_AWE32_MIXER */ |
| 4209 | |
| 4210 | |
| 4211 | /* |
| 4212 | * initialization of Emu8000 |
| 4213 | */ |
| 4214 | |
| 4215 | /* intiailize audio channels */ |
| 4216 | static void |
| 4217 | awe_init_audio(void) |
| 4218 | { |
| 4219 | int ch; |
| 4220 | |
| 4221 | /* turn off envelope engines */ |
| 4222 | for (ch = 0; ch < AWE_MAX_VOICES; ch++) { |
| 4223 | awe_poke(AWE_DCYSUSV(ch), 0x80); |
| 4224 | } |
| 4225 | |
| 4226 | /* reset all other parameters to zero */ |
| 4227 | for (ch = 0; ch < AWE_MAX_VOICES; ch++) { |
| 4228 | awe_poke(AWE_ENVVOL(ch), 0); |
| 4229 | awe_poke(AWE_ENVVAL(ch), 0); |
| 4230 | awe_poke(AWE_DCYSUS(ch), 0); |
| 4231 | awe_poke(AWE_ATKHLDV(ch), 0); |
| 4232 | awe_poke(AWE_LFO1VAL(ch), 0); |
| 4233 | awe_poke(AWE_ATKHLD(ch), 0); |
| 4234 | awe_poke(AWE_LFO2VAL(ch), 0); |
| 4235 | awe_poke(AWE_IP(ch), 0); |
| 4236 | awe_poke(AWE_IFATN(ch), 0); |
| 4237 | awe_poke(AWE_PEFE(ch), 0); |
| 4238 | awe_poke(AWE_FMMOD(ch), 0); |
| 4239 | awe_poke(AWE_TREMFRQ(ch), 0); |
| 4240 | awe_poke(AWE_FM2FRQ2(ch), 0); |
| 4241 | awe_poke_dw(AWE_PTRX(ch), 0); |
| 4242 | awe_poke_dw(AWE_VTFT(ch), 0); |
| 4243 | awe_poke_dw(AWE_PSST(ch), 0); |
| 4244 | awe_poke_dw(AWE_CSL(ch), 0); |
| 4245 | awe_poke_dw(AWE_CCCA(ch), 0); |
| 4246 | } |
| 4247 | |
| 4248 | for (ch = 0; ch < AWE_MAX_VOICES; ch++) { |
| 4249 | awe_poke_dw(AWE_CPF(ch), 0); |
| 4250 | awe_poke_dw(AWE_CVCF(ch), 0); |
| 4251 | } |
| 4252 | } |
| 4253 | |
| 4254 | |
| 4255 | /* initialize DMA address */ |
| 4256 | static void |
| 4257 | awe_init_dma(void) |
| 4258 | { |
| 4259 | awe_poke_dw(AWE_SMALR, 0); |
| 4260 | awe_poke_dw(AWE_SMARR, 0); |
| 4261 | awe_poke_dw(AWE_SMALW, 0); |
| 4262 | awe_poke_dw(AWE_SMARW, 0); |
| 4263 | } |
| 4264 | |
| 4265 | |
| 4266 | /* initialization arrays; from ADIP */ |
| 4267 | |
| 4268 | static unsigned short init1[128] = { |
| 4269 | 0x03ff, 0x0030, 0x07ff, 0x0130, 0x0bff, 0x0230, 0x0fff, 0x0330, |
| 4270 | 0x13ff, 0x0430, 0x17ff, 0x0530, 0x1bff, 0x0630, 0x1fff, 0x0730, |
| 4271 | 0x23ff, 0x0830, 0x27ff, 0x0930, 0x2bff, 0x0a30, 0x2fff, 0x0b30, |
| 4272 | 0x33ff, 0x0c30, 0x37ff, 0x0d30, 0x3bff, 0x0e30, 0x3fff, 0x0f30, |
| 4273 | |
| 4274 | 0x43ff, 0x0030, 0x47ff, 0x0130, 0x4bff, 0x0230, 0x4fff, 0x0330, |
| 4275 | 0x53ff, 0x0430, 0x57ff, 0x0530, 0x5bff, 0x0630, 0x5fff, 0x0730, |
| 4276 | 0x63ff, 0x0830, 0x67ff, 0x0930, 0x6bff, 0x0a30, 0x6fff, 0x0b30, |
| 4277 | 0x73ff, 0x0c30, 0x77ff, 0x0d30, 0x7bff, 0x0e30, 0x7fff, 0x0f30, |
| 4278 | |
| 4279 | 0x83ff, 0x0030, 0x87ff, 0x0130, 0x8bff, 0x0230, 0x8fff, 0x0330, |
| 4280 | 0x93ff, 0x0430, 0x97ff, 0x0530, 0x9bff, 0x0630, 0x9fff, 0x0730, |
| 4281 | 0xa3ff, 0x0830, 0xa7ff, 0x0930, 0xabff, 0x0a30, 0xafff, 0x0b30, |
| 4282 | 0xb3ff, 0x0c30, 0xb7ff, 0x0d30, 0xbbff, 0x0e30, 0xbfff, 0x0f30, |
| 4283 | |
| 4284 | 0xc3ff, 0x0030, 0xc7ff, 0x0130, 0xcbff, 0x0230, 0xcfff, 0x0330, |
| 4285 | 0xd3ff, 0x0430, 0xd7ff, 0x0530, 0xdbff, 0x0630, 0xdfff, 0x0730, |
| 4286 | 0xe3ff, 0x0830, 0xe7ff, 0x0930, 0xebff, 0x0a30, 0xefff, 0x0b30, |
| 4287 | 0xf3ff, 0x0c30, 0xf7ff, 0x0d30, 0xfbff, 0x0e30, 0xffff, 0x0f30, |
| 4288 | }; |
| 4289 | |
| 4290 | static unsigned short init2[128] = { |
| 4291 | 0x03ff, 0x8030, 0x07ff, 0x8130, 0x0bff, 0x8230, 0x0fff, 0x8330, |
| 4292 | 0x13ff, 0x8430, 0x17ff, 0x8530, 0x1bff, 0x8630, 0x1fff, 0x8730, |
| 4293 | 0x23ff, 0x8830, 0x27ff, 0x8930, 0x2bff, 0x8a30, 0x2fff, 0x8b30, |
| 4294 | 0x33ff, 0x8c30, 0x37ff, 0x8d30, 0x3bff, 0x8e30, 0x3fff, 0x8f30, |
| 4295 | |
| 4296 | 0x43ff, 0x8030, 0x47ff, 0x8130, 0x4bff, 0x8230, 0x4fff, 0x8330, |
| 4297 | 0x53ff, 0x8430, 0x57ff, 0x8530, 0x5bff, 0x8630, 0x5fff, 0x8730, |
| 4298 | 0x63ff, 0x8830, 0x67ff, 0x8930, 0x6bff, 0x8a30, 0x6fff, 0x8b30, |
| 4299 | 0x73ff, 0x8c30, 0x77ff, 0x8d30, 0x7bff, 0x8e30, 0x7fff, 0x8f30, |
| 4300 | |
| 4301 | 0x83ff, 0x8030, 0x87ff, 0x8130, 0x8bff, 0x8230, 0x8fff, 0x8330, |
| 4302 | 0x93ff, 0x8430, 0x97ff, 0x8530, 0x9bff, 0x8630, 0x9fff, 0x8730, |
| 4303 | 0xa3ff, 0x8830, 0xa7ff, 0x8930, 0xabff, 0x8a30, 0xafff, 0x8b30, |
| 4304 | 0xb3ff, 0x8c30, 0xb7ff, 0x8d30, 0xbbff, 0x8e30, 0xbfff, 0x8f30, |
| 4305 | |
| 4306 | 0xc3ff, 0x8030, 0xc7ff, 0x8130, 0xcbff, 0x8230, 0xcfff, 0x8330, |
| 4307 | 0xd3ff, 0x8430, 0xd7ff, 0x8530, 0xdbff, 0x8630, 0xdfff, 0x8730, |
| 4308 | 0xe3ff, 0x8830, 0xe7ff, 0x8930, 0xebff, 0x8a30, 0xefff, 0x8b30, |
| 4309 | 0xf3ff, 0x8c30, 0xf7ff, 0x8d30, 0xfbff, 0x8e30, 0xffff, 0x8f30, |
| 4310 | }; |
| 4311 | |
| 4312 | static unsigned short init3[128] = { |
| 4313 | 0x0C10, 0x8470, 0x14FE, 0xB488, 0x167F, 0xA470, 0x18E7, 0x84B5, |
| 4314 | 0x1B6E, 0x842A, 0x1F1D, 0x852A, 0x0DA3, 0x8F7C, 0x167E, 0xF254, |
| 4315 | 0x0000, 0x842A, 0x0001, 0x852A, 0x18E6, 0x8BAA, 0x1B6D, 0xF234, |
| 4316 | 0x229F, 0x8429, 0x2746, 0x8529, 0x1F1C, 0x86E7, 0x229E, 0xF224, |
| 4317 | |
| 4318 | 0x0DA4, 0x8429, 0x2C29, 0x8529, 0x2745, 0x87F6, 0x2C28, 0xF254, |
| 4319 | 0x383B, 0x8428, 0x320F, 0x8528, 0x320E, 0x8F02, 0x1341, 0xF264, |
| 4320 | 0x3EB6, 0x8428, 0x3EB9, 0x8528, 0x383A, 0x8FA9, 0x3EB5, 0xF294, |
| 4321 | 0x3EB7, 0x8474, 0x3EBA, 0x8575, 0x3EB8, 0xC4C3, 0x3EBB, 0xC5C3, |
| 4322 | |
| 4323 | 0x0000, 0xA404, 0x0001, 0xA504, 0x141F, 0x8671, 0x14FD, 0x8287, |
| 4324 | 0x3EBC, 0xE610, 0x3EC8, 0x8C7B, 0x031A, 0x87E6, 0x3EC8, 0x86F7, |
| 4325 | 0x3EC0, 0x821E, 0x3EBE, 0xD208, 0x3EBD, 0x821F, 0x3ECA, 0x8386, |
| 4326 | 0x3EC1, 0x8C03, 0x3EC9, 0x831E, 0x3ECA, 0x8C4C, 0x3EBF, 0x8C55, |
| 4327 | |
| 4328 | 0x3EC9, 0xC208, 0x3EC4, 0xBC84, 0x3EC8, 0x8EAD, 0x3EC8, 0xD308, |
| 4329 | 0x3EC2, 0x8F7E, 0x3ECB, 0x8219, 0x3ECB, 0xD26E, 0x3EC5, 0x831F, |
| 4330 | 0x3EC6, 0xC308, 0x3EC3, 0xB2FF, 0x3EC9, 0x8265, 0x3EC9, 0x8319, |
| 4331 | 0x1342, 0xD36E, 0x3EC7, 0xB3FF, 0x0000, 0x8365, 0x1420, 0x9570, |
| 4332 | }; |
| 4333 | |
| 4334 | static unsigned short init4[128] = { |
| 4335 | 0x0C10, 0x8470, 0x14FE, 0xB488, 0x167F, 0xA470, 0x18E7, 0x84B5, |
| 4336 | 0x1B6E, 0x842A, 0x1F1D, 0x852A, 0x0DA3, 0x0F7C, 0x167E, 0x7254, |
| 4337 | 0x0000, 0x842A, 0x0001, 0x852A, 0x18E6, 0x0BAA, 0x1B6D, 0x7234, |
| 4338 | 0x229F, 0x8429, 0x2746, 0x8529, 0x1F1C, 0x06E7, 0x229E, 0x7224, |
| 4339 | |
| 4340 | 0x0DA4, 0x8429, 0x2C29, 0x8529, 0x2745, 0x07F6, 0x2C28, 0x7254, |
| 4341 | 0x383B, 0x8428, 0x320F, 0x8528, 0x320E, 0x0F02, 0x1341, 0x7264, |
| 4342 | 0x3EB6, 0x8428, 0x3EB9, 0x8528, 0x383A, 0x0FA9, 0x3EB5, 0x7294, |
| 4343 | 0x3EB7, 0x8474, 0x3EBA, 0x8575, 0x3EB8, 0x44C3, 0x3EBB, 0x45C3, |
| 4344 | |
| 4345 | 0x0000, 0xA404, 0x0001, 0xA504, 0x141F, 0x0671, 0x14FD, 0x0287, |
| 4346 | 0x3EBC, 0xE610, 0x3EC8, 0x0C7B, 0x031A, 0x07E6, 0x3EC8, 0x86F7, |
| 4347 | 0x3EC0, 0x821E, 0x3EBE, 0xD208, 0x3EBD, 0x021F, 0x3ECA, 0x0386, |
| 4348 | 0x3EC1, 0x0C03, 0x3EC9, 0x031E, 0x3ECA, 0x8C4C, 0x3EBF, 0x0C55, |
| 4349 | |
| 4350 | 0x3EC9, 0xC208, 0x3EC4, 0xBC84, 0x3EC8, 0x0EAD, 0x3EC8, 0xD308, |
| 4351 | 0x3EC2, 0x8F7E, 0x3ECB, 0x0219, 0x3ECB, 0xD26E, 0x3EC5, 0x031F, |
| 4352 | 0x3EC6, 0xC308, 0x3EC3, 0x32FF, 0x3EC9, 0x0265, 0x3EC9, 0x8319, |
| 4353 | 0x1342, 0xD36E, 0x3EC7, 0x33FF, 0x0000, 0x8365, 0x1420, 0x9570, |
| 4354 | }; |
| 4355 | |
| 4356 | |
| 4357 | /* send initialization arrays to start up */ |
| 4358 | static void |
| 4359 | awe_init_array(void) |
| 4360 | { |
| 4361 | awe_send_array(init1); |
| 4362 | awe_wait(1024); |
| 4363 | awe_send_array(init2); |
| 4364 | awe_send_array(init3); |
| 4365 | awe_poke_dw(AWE_HWCF4, 0); |
| 4366 | awe_poke_dw(AWE_HWCF5, 0x83); |
| 4367 | awe_poke_dw(AWE_HWCF6, 0x8000); |
| 4368 | awe_send_array(init4); |
| 4369 | } |
| 4370 | |
| 4371 | /* send an initialization array */ |
| 4372 | static void |
| 4373 | awe_send_array(unsigned short *data) |
| 4374 | { |
| 4375 | int i; |
| 4376 | unsigned short *p; |
| 4377 | |
| 4378 | p = data; |
| 4379 | for (i = 0; i < AWE_MAX_VOICES; i++, p++) |
| 4380 | awe_poke(AWE_INIT1(i), *p); |
| 4381 | for (i = 0; i < AWE_MAX_VOICES; i++, p++) |
| 4382 | awe_poke(AWE_INIT2(i), *p); |
| 4383 | for (i = 0; i < AWE_MAX_VOICES; i++, p++) |
| 4384 | awe_poke(AWE_INIT3(i), *p); |
| 4385 | for (i = 0; i < AWE_MAX_VOICES; i++, p++) |
| 4386 | awe_poke(AWE_INIT4(i), *p); |
| 4387 | } |
| 4388 | |
| 4389 | |
| 4390 | /* |
| 4391 | * set up awe32 channels to some known state. |
| 4392 | */ |
| 4393 | |
| 4394 | /* set the envelope & LFO parameters to the default values; see ADIP */ |
| 4395 | static void |
| 4396 | awe_tweak_voice(int i) |
| 4397 | { |
| 4398 | /* set all mod/vol envelope shape to minimum */ |
| 4399 | awe_poke(AWE_ENVVOL(i), 0x8000); |
| 4400 | awe_poke(AWE_ENVVAL(i), 0x8000); |
| 4401 | awe_poke(AWE_DCYSUS(i), 0x7F7F); |
| 4402 | awe_poke(AWE_ATKHLDV(i), 0x7F7F); |
| 4403 | awe_poke(AWE_ATKHLD(i), 0x7F7F); |
| 4404 | awe_poke(AWE_PEFE(i), 0); /* mod envelope height to zero */ |
| 4405 | awe_poke(AWE_LFO1VAL(i), 0x8000); /* no delay for LFO1 */ |
| 4406 | awe_poke(AWE_LFO2VAL(i), 0x8000); |
| 4407 | awe_poke(AWE_IP(i), 0xE000); /* no pitch shift */ |
| 4408 | awe_poke(AWE_IFATN(i), 0xFF00); /* volume to minimum */ |
| 4409 | awe_poke(AWE_FMMOD(i), 0); |
| 4410 | awe_poke(AWE_TREMFRQ(i), 0); |
| 4411 | awe_poke(AWE_FM2FRQ2(i), 0); |
| 4412 | } |
| 4413 | |
| 4414 | static void |
| 4415 | awe_tweak(void) |
| 4416 | { |
| 4417 | int i; |
| 4418 | /* reset all channels */ |
| 4419 | for (i = 0; i < awe_max_voices; i++) |
| 4420 | awe_tweak_voice(i); |
| 4421 | } |
| 4422 | |
| 4423 | |
| 4424 | /* |
| 4425 | * initializes the FM section of AWE32; |
| 4426 | * see Vince Vu's unofficial AWE32 programming guide |
| 4427 | */ |
| 4428 | |
| 4429 | static void |
| 4430 | awe_init_fm(void) |
| 4431 | { |
| 4432 | #ifndef AWE_ALWAYS_INIT_FM |
| 4433 | /* if no extended memory is on board.. */ |
| 4434 | if (memsize <= 0) |
| 4435 | return; |
| 4436 | #endif |
| 4437 | DEBUG(3,printk("AWE32: initializing FM\n")); |
| 4438 | |
| 4439 | /* Initialize the last two channels for DRAM refresh and producing |
| 4440 | the reverb and chorus effects for Yamaha OPL-3 synthesizer */ |
| 4441 | |
| 4442 | /* 31: FM left channel, 0xffffe0-0xffffe8 */ |
| 4443 | awe_poke(AWE_DCYSUSV(30), 0x80); |
| 4444 | awe_poke_dw(AWE_PSST(30), 0xFFFFFFE0); /* full left */ |
| 4445 | awe_poke_dw(AWE_CSL(30), 0x00FFFFE8 | |
| 4446 | (DEF_FM_CHORUS_DEPTH << 24)); |
| 4447 | awe_poke_dw(AWE_PTRX(30), (DEF_FM_REVERB_DEPTH << 8)); |
| 4448 | awe_poke_dw(AWE_CPF(30), 0); |
| 4449 | awe_poke_dw(AWE_CCCA(30), 0x00FFFFE3); |
| 4450 | |
| 4451 | /* 32: FM right channel, 0xfffff0-0xfffff8 */ |
| 4452 | awe_poke(AWE_DCYSUSV(31), 0x80); |
| 4453 | awe_poke_dw(AWE_PSST(31), 0x00FFFFF0); /* full right */ |
| 4454 | awe_poke_dw(AWE_CSL(31), 0x00FFFFF8 | |
| 4455 | (DEF_FM_CHORUS_DEPTH << 24)); |
| 4456 | awe_poke_dw(AWE_PTRX(31), (DEF_FM_REVERB_DEPTH << 8)); |
| 4457 | awe_poke_dw(AWE_CPF(31), 0x8000); |
| 4458 | awe_poke_dw(AWE_CCCA(31), 0x00FFFFF3); |
| 4459 | |
| 4460 | /* skew volume & cutoff */ |
| 4461 | awe_poke_dw(AWE_VTFT(30), 0x8000FFFF); |
| 4462 | awe_poke_dw(AWE_VTFT(31), 0x8000FFFF); |
| 4463 | |
| 4464 | voices[30].state = AWE_ST_FM; |
| 4465 | voices[31].state = AWE_ST_FM; |
| 4466 | |
| 4467 | /* change maximum channels to 30 */ |
| 4468 | awe_max_voices = AWE_NORMAL_VOICES; |
| 4469 | if (playing_mode == AWE_PLAY_DIRECT) |
| 4470 | awe_info.nr_voices = awe_max_voices; |
| 4471 | else |
| 4472 | awe_info.nr_voices = AWE_MAX_CHANNELS; |
| 4473 | voice_alloc->max_voice = awe_max_voices; |
| 4474 | } |
| 4475 | |
| 4476 | /* |
| 4477 | * AWE32 DRAM access routines |
| 4478 | */ |
| 4479 | |
| 4480 | /* open DRAM write accessing mode */ |
| 4481 | static int |
| 4482 | awe_open_dram_for_write(int offset, int channels) |
| 4483 | { |
| 4484 | int vidx[AWE_NORMAL_VOICES]; |
| 4485 | int i; |
| 4486 | |
| 4487 | if (channels < 0 || channels >= AWE_NORMAL_VOICES) { |
| 4488 | channels = AWE_NORMAL_VOICES; |
| 4489 | for (i = 0; i < AWE_NORMAL_VOICES; i++) |
| 4490 | vidx[i] = i; |
| 4491 | } else { |
| 4492 | for (i = 0; i < channels; i++) { |
| 4493 | vidx[i] = awe_clear_voice(); |
| 4494 | voices[vidx[i]].state = AWE_ST_MARK; |
| 4495 | } |
| 4496 | } |
| 4497 | |
| 4498 | /* use all channels for DMA transfer */ |
| 4499 | for (i = 0; i < channels; i++) { |
| 4500 | if (vidx[i] < 0) continue; |
| 4501 | awe_poke(AWE_DCYSUSV(vidx[i]), 0x80); |
| 4502 | awe_poke_dw(AWE_VTFT(vidx[i]), 0); |
| 4503 | awe_poke_dw(AWE_CVCF(vidx[i]), 0); |
| 4504 | awe_poke_dw(AWE_PTRX(vidx[i]), 0x40000000); |
| 4505 | awe_poke_dw(AWE_CPF(vidx[i]), 0x40000000); |
| 4506 | awe_poke_dw(AWE_PSST(vidx[i]), 0); |
| 4507 | awe_poke_dw(AWE_CSL(vidx[i]), 0); |
| 4508 | awe_poke_dw(AWE_CCCA(vidx[i]), 0x06000000); |
| 4509 | voices[vidx[i]].state = AWE_ST_DRAM; |
| 4510 | } |
| 4511 | /* point channels 31 & 32 to ROM samples for DRAM refresh */ |
| 4512 | awe_poke_dw(AWE_VTFT(30), 0); |
| 4513 | awe_poke_dw(AWE_PSST(30), 0x1d8); |
| 4514 | awe_poke_dw(AWE_CSL(30), 0x1e0); |
| 4515 | awe_poke_dw(AWE_CCCA(30), 0x1d8); |
| 4516 | awe_poke_dw(AWE_VTFT(31), 0); |
| 4517 | awe_poke_dw(AWE_PSST(31), 0x1d8); |
| 4518 | awe_poke_dw(AWE_CSL(31), 0x1e0); |
| 4519 | awe_poke_dw(AWE_CCCA(31), 0x1d8); |
| 4520 | voices[30].state = AWE_ST_FM; |
| 4521 | voices[31].state = AWE_ST_FM; |
| 4522 | |
| 4523 | /* if full bit is on, not ready to write on */ |
| 4524 | if (awe_peek_dw(AWE_SMALW) & 0x80000000) { |
| 4525 | for (i = 0; i < channels; i++) { |
| 4526 | awe_poke_dw(AWE_CCCA(vidx[i]), 0); |
| 4527 | voices[vidx[i]].state = AWE_ST_OFF; |
| 4528 | } |
| 4529 | printk("awe: not ready to write..\n"); |
| 4530 | return -EPERM; |
| 4531 | } |
| 4532 | |
| 4533 | /* set address to write */ |
| 4534 | awe_poke_dw(AWE_SMALW, offset); |
| 4535 | |
| 4536 | return 0; |
| 4537 | } |
| 4538 | |
| 4539 | /* open DRAM for RAM size detection */ |
| 4540 | static void |
| 4541 | awe_open_dram_for_check(void) |
| 4542 | { |
| 4543 | int i; |
| 4544 | for (i = 0; i < AWE_NORMAL_VOICES; i++) { |
| 4545 | awe_poke(AWE_DCYSUSV(i), 0x80); |
| 4546 | awe_poke_dw(AWE_VTFT(i), 0); |
| 4547 | awe_poke_dw(AWE_CVCF(i), 0); |
| 4548 | awe_poke_dw(AWE_PTRX(i), 0x40000000); |
| 4549 | awe_poke_dw(AWE_CPF(i), 0x40000000); |
| 4550 | awe_poke_dw(AWE_PSST(i), 0); |
| 4551 | awe_poke_dw(AWE_CSL(i), 0); |
| 4552 | if (i & 1) /* DMA write */ |
| 4553 | awe_poke_dw(AWE_CCCA(i), 0x06000000); |
| 4554 | else /* DMA read */ |
| 4555 | awe_poke_dw(AWE_CCCA(i), 0x04000000); |
| 4556 | voices[i].state = AWE_ST_DRAM; |
| 4557 | } |
| 4558 | } |
| 4559 | |
| 4560 | |
| 4561 | /* close dram access */ |
| 4562 | static void |
| 4563 | awe_close_dram(void) |
| 4564 | { |
| 4565 | int i; |
| 4566 | /* wait until FULL bit in SMAxW register be false */ |
| 4567 | for (i = 0; i < 10000; i++) { |
| 4568 | if (!(awe_peek_dw(AWE_SMALW) & 0x80000000)) |
| 4569 | break; |
| 4570 | awe_wait(10); |
| 4571 | } |
| 4572 | |
| 4573 | for (i = 0; i < AWE_NORMAL_VOICES; i++) { |
| 4574 | if (voices[i].state == AWE_ST_DRAM) { |
| 4575 | awe_poke_dw(AWE_CCCA(i), 0); |
| 4576 | awe_poke(AWE_DCYSUSV(i), 0x807F); |
| 4577 | voices[i].state = AWE_ST_OFF; |
| 4578 | } |
| 4579 | } |
| 4580 | } |
| 4581 | |
| 4582 | |
| 4583 | /* |
| 4584 | * check dram size on AWE board |
| 4585 | */ |
| 4586 | |
| 4587 | /* any three numbers you like */ |
| 4588 | #define UNIQUE_ID1 0x1234 |
| 4589 | #define UNIQUE_ID2 0x4321 |
| 4590 | #define UNIQUE_ID3 0xABCD |
| 4591 | |
| 4592 | static void __init |
| 4593 | awe_check_dram(void) |
| 4594 | { |
| 4595 | if (awe_present) /* already initialized */ |
| 4596 | return; |
| 4597 | |
| 4598 | if (memsize >= 0) { /* given by config file or module option */ |
| 4599 | memsize *= 1024; /* convert to Kbytes */ |
| 4600 | return; |
| 4601 | } |
| 4602 | |
| 4603 | awe_open_dram_for_check(); |
| 4604 | |
| 4605 | memsize = 0; |
| 4606 | |
| 4607 | /* set up unique two id numbers */ |
| 4608 | awe_poke_dw(AWE_SMALW, AWE_DRAM_OFFSET); |
| 4609 | awe_poke(AWE_SMLD, UNIQUE_ID1); |
| 4610 | awe_poke(AWE_SMLD, UNIQUE_ID2); |
| 4611 | |
| 4612 | while (memsize < AWE_MAX_DRAM_SIZE) { |
| 4613 | awe_wait(5); |
| 4614 | /* read a data on the DRAM start address */ |
| 4615 | awe_poke_dw(AWE_SMALR, AWE_DRAM_OFFSET); |
| 4616 | awe_peek(AWE_SMLD); /* discard stale data */ |
| 4617 | if (awe_peek(AWE_SMLD) != UNIQUE_ID1) |
| 4618 | break; |
| 4619 | if (awe_peek(AWE_SMLD) != UNIQUE_ID2) |
| 4620 | break; |
| 4621 | memsize += 512; /* increment 512kbytes */ |
| 4622 | /* Write a unique data on the test address; |
| 4623 | * if the address is out of range, the data is written on |
| 4624 | * 0x200000(=AWE_DRAM_OFFSET). Then the two id words are |
| 4625 | * broken by this data. |
| 4626 | */ |
| 4627 | awe_poke_dw(AWE_SMALW, AWE_DRAM_OFFSET + memsize*512L); |
| 4628 | awe_poke(AWE_SMLD, UNIQUE_ID3); |
| 4629 | awe_wait(5); |
| 4630 | /* read a data on the just written DRAM address */ |
| 4631 | awe_poke_dw(AWE_SMALR, AWE_DRAM_OFFSET + memsize*512L); |
| 4632 | awe_peek(AWE_SMLD); /* discard stale data */ |
| 4633 | if (awe_peek(AWE_SMLD) != UNIQUE_ID3) |
| 4634 | break; |
| 4635 | } |
| 4636 | awe_close_dram(); |
| 4637 | |
| 4638 | DEBUG(0,printk("AWE32: %d Kbytes memory detected\n", memsize)); |
| 4639 | |
| 4640 | /* convert to Kbytes */ |
| 4641 | memsize *= 1024; |
| 4642 | } |
| 4643 | |
| 4644 | |
| 4645 | /*----------------------------------------------------------------*/ |
| 4646 | |
| 4647 | /* |
| 4648 | * chorus and reverb controls; from VV's guide |
| 4649 | */ |
| 4650 | |
| 4651 | /* 5 parameters for each chorus mode; 3 x 16bit, 2 x 32bit */ |
| 4652 | static char chorus_defined[AWE_CHORUS_NUMBERS]; |
| 4653 | static awe_chorus_fx_rec chorus_parm[AWE_CHORUS_NUMBERS] = { |
| 4654 | {0xE600, 0x03F6, 0xBC2C ,0x00000000, 0x0000006D}, /* chorus 1 */ |
| 4655 | {0xE608, 0x031A, 0xBC6E, 0x00000000, 0x0000017C}, /* chorus 2 */ |
| 4656 | {0xE610, 0x031A, 0xBC84, 0x00000000, 0x00000083}, /* chorus 3 */ |
| 4657 | {0xE620, 0x0269, 0xBC6E, 0x00000000, 0x0000017C}, /* chorus 4 */ |
| 4658 | {0xE680, 0x04D3, 0xBCA6, 0x00000000, 0x0000005B}, /* feedback */ |
| 4659 | {0xE6E0, 0x044E, 0xBC37, 0x00000000, 0x00000026}, /* flanger */ |
| 4660 | {0xE600, 0x0B06, 0xBC00, 0x0000E000, 0x00000083}, /* short delay */ |
| 4661 | {0xE6C0, 0x0B06, 0xBC00, 0x0000E000, 0x00000083}, /* short delay + feedback */ |
| 4662 | }; |
| 4663 | |
| 4664 | static int |
| 4665 | awe_load_chorus_fx(awe_patch_info *patch, const char __user *addr, int count) |
| 4666 | { |
| 4667 | if (patch->optarg < AWE_CHORUS_PREDEFINED || patch->optarg >= AWE_CHORUS_NUMBERS) { |
| 4668 | printk(KERN_WARNING "AWE32 Error: invalid chorus mode %d for uploading\n", patch->optarg); |
| 4669 | return -EINVAL; |
| 4670 | } |
| 4671 | if (count < sizeof(awe_chorus_fx_rec)) { |
| 4672 | printk(KERN_WARNING "AWE32 Error: too short chorus fx parameters\n"); |
| 4673 | return -EINVAL; |
| 4674 | } |
| 4675 | if (copy_from_user(&chorus_parm[patch->optarg], addr + AWE_PATCH_INFO_SIZE, |
| 4676 | sizeof(awe_chorus_fx_rec))) |
| 4677 | return -EFAULT; |
| 4678 | chorus_defined[patch->optarg] = TRUE; |
| 4679 | return 0; |
| 4680 | } |
| 4681 | |
| 4682 | static void |
| 4683 | awe_set_chorus_mode(int effect) |
| 4684 | { |
| 4685 | if (effect < 0 || effect >= AWE_CHORUS_NUMBERS || |
| 4686 | (effect >= AWE_CHORUS_PREDEFINED && !chorus_defined[effect])) |
| 4687 | return; |
| 4688 | awe_poke(AWE_INIT3(9), chorus_parm[effect].feedback); |
| 4689 | awe_poke(AWE_INIT3(12), chorus_parm[effect].delay_offset); |
| 4690 | awe_poke(AWE_INIT4(3), chorus_parm[effect].lfo_depth); |
| 4691 | awe_poke_dw(AWE_HWCF4, chorus_parm[effect].delay); |
| 4692 | awe_poke_dw(AWE_HWCF5, chorus_parm[effect].lfo_freq); |
| 4693 | awe_poke_dw(AWE_HWCF6, 0x8000); |
| 4694 | awe_poke_dw(AWE_HWCF7, 0x0000); |
| 4695 | } |
| 4696 | |
| 4697 | static void |
| 4698 | awe_update_chorus_mode(void) |
| 4699 | { |
| 4700 | awe_set_chorus_mode(ctrls[AWE_MD_CHORUS_MODE]); |
| 4701 | } |
| 4702 | |
| 4703 | /*----------------------------------------------------------------*/ |
| 4704 | |
| 4705 | /* reverb mode settings; write the following 28 data of 16 bit length |
| 4706 | * on the corresponding ports in the reverb_cmds array |
| 4707 | */ |
| 4708 | static char reverb_defined[AWE_CHORUS_NUMBERS]; |
| 4709 | static awe_reverb_fx_rec reverb_parm[AWE_REVERB_NUMBERS] = { |
| 4710 | {{ /* room 1 */ |
| 4711 | 0xB488, 0xA450, 0x9550, 0x84B5, 0x383A, 0x3EB5, 0x72F4, |
| 4712 | 0x72A4, 0x7254, 0x7204, 0x7204, 0x7204, 0x4416, 0x4516, |
| 4713 | 0xA490, 0xA590, 0x842A, 0x852A, 0x842A, 0x852A, 0x8429, |
| 4714 | 0x8529, 0x8429, 0x8529, 0x8428, 0x8528, 0x8428, 0x8528, |
| 4715 | }}, |
| 4716 | {{ /* room 2 */ |
| 4717 | 0xB488, 0xA458, 0x9558, 0x84B5, 0x383A, 0x3EB5, 0x7284, |
| 4718 | 0x7254, 0x7224, 0x7224, 0x7254, 0x7284, 0x4448, 0x4548, |
| 4719 | 0xA440, 0xA540, 0x842A, 0x852A, 0x842A, 0x852A, 0x8429, |
| 4720 | 0x8529, 0x8429, 0x8529, 0x8428, 0x8528, 0x8428, 0x8528, |
| 4721 | }}, |
| 4722 | {{ /* room 3 */ |
| 4723 | 0xB488, 0xA460, 0x9560, 0x84B5, 0x383A, 0x3EB5, 0x7284, |
| 4724 | 0x7254, 0x7224, 0x7224, 0x7254, 0x7284, 0x4416, 0x4516, |
| 4725 | 0xA490, 0xA590, 0x842C, 0x852C, 0x842C, 0x852C, 0x842B, |
| 4726 | 0x852B, 0x842B, 0x852B, 0x842A, 0x852A, 0x842A, 0x852A, |
| 4727 | }}, |
| 4728 | {{ /* hall 1 */ |
| 4729 | 0xB488, 0xA470, 0x9570, 0x84B5, 0x383A, 0x3EB5, 0x7284, |
| 4730 | 0x7254, 0x7224, 0x7224, 0x7254, 0x7284, 0x4448, 0x4548, |
| 4731 | 0xA440, 0xA540, 0x842B, 0x852B, 0x842B, 0x852B, 0x842A, |
| 4732 | 0x852A, 0x842A, 0x852A, 0x8429, 0x8529, 0x8429, 0x8529, |
| 4733 | }}, |
| 4734 | {{ /* hall 2 */ |
| 4735 | 0xB488, 0xA470, 0x9570, 0x84B5, 0x383A, 0x3EB5, 0x7254, |
| 4736 | 0x7234, 0x7224, 0x7254, 0x7264, 0x7294, 0x44C3, 0x45C3, |
| 4737 | 0xA404, 0xA504, 0x842A, 0x852A, 0x842A, 0x852A, 0x8429, |
| 4738 | 0x8529, 0x8429, 0x8529, 0x8428, 0x8528, 0x8428, 0x8528, |
| 4739 | }}, |
| 4740 | {{ /* plate */ |
| 4741 | 0xB4FF, 0xA470, 0x9570, 0x84B5, 0x383A, 0x3EB5, 0x7234, |
| 4742 | 0x7234, 0x7234, 0x7234, 0x7234, 0x7234, 0x4448, 0x4548, |
| 4743 | 0xA440, 0xA540, 0x842A, 0x852A, 0x842A, 0x852A, 0x8429, |
| 4744 | 0x8529, 0x8429, 0x8529, 0x8428, 0x8528, 0x8428, 0x8528, |
| 4745 | }}, |
| 4746 | {{ /* delay */ |
| 4747 | 0xB4FF, 0xA470, 0x9500, 0x84B5, 0x333A, 0x39B5, 0x7204, |
| 4748 | 0x7204, 0x7204, 0x7204, 0x7204, 0x72F4, 0x4400, 0x4500, |
| 4749 | 0xA4FF, 0xA5FF, 0x8420, 0x8520, 0x8420, 0x8520, 0x8420, |
| 4750 | 0x8520, 0x8420, 0x8520, 0x8420, 0x8520, 0x8420, 0x8520, |
| 4751 | }}, |
| 4752 | {{ /* panning delay */ |
| 4753 | 0xB4FF, 0xA490, 0x9590, 0x8474, 0x333A, 0x39B5, 0x7204, |
| 4754 | 0x7204, 0x7204, 0x7204, 0x7204, 0x72F4, 0x4400, 0x4500, |
| 4755 | 0xA4FF, 0xA5FF, 0x8420, 0x8520, 0x8420, 0x8520, 0x8420, |
| 4756 | 0x8520, 0x8420, 0x8520, 0x8420, 0x8520, 0x8420, 0x8520, |
| 4757 | }}, |
| 4758 | }; |
| 4759 | |
| 4760 | static struct ReverbCmdPair { |
| 4761 | unsigned short cmd, port; |
| 4762 | } reverb_cmds[28] = { |
| 4763 | {AWE_INIT1(0x03)}, {AWE_INIT1(0x05)}, {AWE_INIT4(0x1F)}, {AWE_INIT1(0x07)}, |
| 4764 | {AWE_INIT2(0x14)}, {AWE_INIT2(0x16)}, {AWE_INIT1(0x0F)}, {AWE_INIT1(0x17)}, |
| 4765 | {AWE_INIT1(0x1F)}, {AWE_INIT2(0x07)}, {AWE_INIT2(0x0F)}, {AWE_INIT2(0x17)}, |
| 4766 | {AWE_INIT2(0x1D)}, {AWE_INIT2(0x1F)}, {AWE_INIT3(0x01)}, {AWE_INIT3(0x03)}, |
| 4767 | {AWE_INIT1(0x09)}, {AWE_INIT1(0x0B)}, {AWE_INIT1(0x11)}, {AWE_INIT1(0x13)}, |
| 4768 | {AWE_INIT1(0x19)}, {AWE_INIT1(0x1B)}, {AWE_INIT2(0x01)}, {AWE_INIT2(0x03)}, |
| 4769 | {AWE_INIT2(0x09)}, {AWE_INIT2(0x0B)}, {AWE_INIT2(0x11)}, {AWE_INIT2(0x13)}, |
| 4770 | }; |
| 4771 | |
| 4772 | static int |
| 4773 | awe_load_reverb_fx(awe_patch_info *patch, const char __user *addr, int count) |
| 4774 | { |
| 4775 | if (patch->optarg < AWE_REVERB_PREDEFINED || patch->optarg >= AWE_REVERB_NUMBERS) { |
| 4776 | printk(KERN_WARNING "AWE32 Error: invalid reverb mode %d for uploading\n", patch->optarg); |
| 4777 | return -EINVAL; |
| 4778 | } |
| 4779 | if (count < sizeof(awe_reverb_fx_rec)) { |
| 4780 | printk(KERN_WARNING "AWE32 Error: too short reverb fx parameters\n"); |
| 4781 | return -EINVAL; |
| 4782 | } |
| 4783 | if (copy_from_user(&reverb_parm[patch->optarg], addr + AWE_PATCH_INFO_SIZE, |
| 4784 | sizeof(awe_reverb_fx_rec))) |
| 4785 | return -EFAULT; |
| 4786 | reverb_defined[patch->optarg] = TRUE; |
| 4787 | return 0; |
| 4788 | } |
| 4789 | |
| 4790 | static void |
| 4791 | awe_set_reverb_mode(int effect) |
| 4792 | { |
| 4793 | int i; |
| 4794 | if (effect < 0 || effect >= AWE_REVERB_NUMBERS || |
| 4795 | (effect >= AWE_REVERB_PREDEFINED && !reverb_defined[effect])) |
| 4796 | return; |
| 4797 | for (i = 0; i < 28; i++) |
| 4798 | awe_poke(reverb_cmds[i].cmd, reverb_cmds[i].port, |
| 4799 | reverb_parm[effect].parms[i]); |
| 4800 | } |
| 4801 | |
| 4802 | static void |
| 4803 | awe_update_reverb_mode(void) |
| 4804 | { |
| 4805 | awe_set_reverb_mode(ctrls[AWE_MD_REVERB_MODE]); |
| 4806 | } |
| 4807 | |
| 4808 | /* |
| 4809 | * treble/bass equalizer control |
| 4810 | */ |
| 4811 | |
| 4812 | static unsigned short bass_parm[12][3] = { |
| 4813 | {0xD26A, 0xD36A, 0x0000}, /* -12 dB */ |
| 4814 | {0xD25B, 0xD35B, 0x0000}, /* -8 */ |
| 4815 | {0xD24C, 0xD34C, 0x0000}, /* -6 */ |
| 4816 | {0xD23D, 0xD33D, 0x0000}, /* -4 */ |
| 4817 | {0xD21F, 0xD31F, 0x0000}, /* -2 */ |
| 4818 | {0xC208, 0xC308, 0x0001}, /* 0 (HW default) */ |
| 4819 | {0xC219, 0xC319, 0x0001}, /* +2 */ |
| 4820 | {0xC22A, 0xC32A, 0x0001}, /* +4 */ |
| 4821 | {0xC24C, 0xC34C, 0x0001}, /* +6 */ |
| 4822 | {0xC26E, 0xC36E, 0x0001}, /* +8 */ |
| 4823 | {0xC248, 0xC348, 0x0002}, /* +10 */ |
| 4824 | {0xC26A, 0xC36A, 0x0002}, /* +12 dB */ |
| 4825 | }; |
| 4826 | |
| 4827 | static unsigned short treble_parm[12][9] = { |
| 4828 | {0x821E, 0xC26A, 0x031E, 0xC36A, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, /* -12 dB */ |
| 4829 | {0x821E, 0xC25B, 0x031E, 0xC35B, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, |
| 4830 | {0x821E, 0xC24C, 0x031E, 0xC34C, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, |
| 4831 | {0x821E, 0xC23D, 0x031E, 0xC33D, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, |
| 4832 | {0x821E, 0xC21F, 0x031E, 0xC31F, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, |
| 4833 | {0x821E, 0xD208, 0x031E, 0xD308, 0x021E, 0xD208, 0x831E, 0xD308, 0x0002}, |
| 4834 | {0x821E, 0xD208, 0x031E, 0xD308, 0x021D, 0xD219, 0x831D, 0xD319, 0x0002}, |
| 4835 | {0x821E, 0xD208, 0x031E, 0xD308, 0x021C, 0xD22A, 0x831C, 0xD32A, 0x0002}, |
| 4836 | {0x821E, 0xD208, 0x031E, 0xD308, 0x021A, 0xD24C, 0x831A, 0xD34C, 0x0002}, |
| 4837 | {0x821E, 0xD208, 0x031E, 0xD308, 0x0219, 0xD26E, 0x8319, 0xD36E, 0x0002}, /* +8 (HW default) */ |
| 4838 | {0x821D, 0xD219, 0x031D, 0xD319, 0x0219, 0xD26E, 0x8319, 0xD36E, 0x0002}, |
| 4839 | {0x821C, 0xD22A, 0x031C, 0xD32A, 0x0219, 0xD26E, 0x8319, 0xD36E, 0x0002}, /* +12 dB */ |
| 4840 | }; |
| 4841 | |
| 4842 | |
| 4843 | /* |
| 4844 | * set Emu8000 digital equalizer; from 0 to 11 [-12dB - 12dB] |
| 4845 | */ |
| 4846 | static void |
| 4847 | awe_equalizer(int bass, int treble) |
| 4848 | { |
| 4849 | unsigned short w; |
| 4850 | |
| 4851 | if (bass < 0 || bass > 11 || treble < 0 || treble > 11) |
| 4852 | return; |
| 4853 | awe_poke(AWE_INIT4(0x01), bass_parm[bass][0]); |
| 4854 | awe_poke(AWE_INIT4(0x11), bass_parm[bass][1]); |
| 4855 | awe_poke(AWE_INIT3(0x11), treble_parm[treble][0]); |
| 4856 | awe_poke(AWE_INIT3(0x13), treble_parm[treble][1]); |
| 4857 | awe_poke(AWE_INIT3(0x1B), treble_parm[treble][2]); |
| 4858 | awe_poke(AWE_INIT4(0x07), treble_parm[treble][3]); |
| 4859 | awe_poke(AWE_INIT4(0x0B), treble_parm[treble][4]); |
| 4860 | awe_poke(AWE_INIT4(0x0D), treble_parm[treble][5]); |
| 4861 | awe_poke(AWE_INIT4(0x17), treble_parm[treble][6]); |
| 4862 | awe_poke(AWE_INIT4(0x19), treble_parm[treble][7]); |
| 4863 | w = bass_parm[bass][2] + treble_parm[treble][8]; |
| 4864 | awe_poke(AWE_INIT4(0x15), (unsigned short)(w + 0x0262)); |
| 4865 | awe_poke(AWE_INIT4(0x1D), (unsigned short)(w + 0x8362)); |
| 4866 | } |
| 4867 | |
| 4868 | static void awe_update_equalizer(void) |
| 4869 | { |
| 4870 | awe_equalizer(ctrls[AWE_MD_BASS_LEVEL], ctrls[AWE_MD_TREBLE_LEVEL]); |
| 4871 | } |
| 4872 | |
| 4873 | |
| 4874 | /*----------------------------------------------------------------*/ |
| 4875 | |
| 4876 | #ifdef CONFIG_AWE32_MIDIEMU |
| 4877 | |
| 4878 | /* |
| 4879 | * Emu8000 MIDI Emulation |
| 4880 | */ |
| 4881 | |
| 4882 | /* |
| 4883 | * midi queue record |
| 4884 | */ |
| 4885 | |
| 4886 | /* queue type */ |
| 4887 | enum { Q_NONE, Q_VARLEN, Q_READ, Q_SYSEX, }; |
| 4888 | |
| 4889 | #define MAX_MIDIBUF 64 |
| 4890 | |
| 4891 | /* midi status */ |
| 4892 | typedef struct MidiStatus { |
| 4893 | int queue; /* queue type */ |
| 4894 | int qlen; /* queue length */ |
| 4895 | int read; /* chars read */ |
| 4896 | int status; /* current status */ |
| 4897 | int chan; /* current channel */ |
| 4898 | unsigned char buf[MAX_MIDIBUF]; |
| 4899 | } MidiStatus; |
| 4900 | |
| 4901 | /* MIDI mode type */ |
| 4902 | enum { MODE_GM, MODE_GS, MODE_XG, }; |
| 4903 | |
| 4904 | /* NRPN / CC -> Emu8000 parameter converter */ |
| 4905 | typedef struct { |
| 4906 | int control; |
| 4907 | int awe_effect; |
| 4908 | unsigned short (*convert)(int val); |
| 4909 | } ConvTable; |
| 4910 | |
| 4911 | |
| 4912 | /* |
| 4913 | * prototypes |
| 4914 | */ |
| 4915 | |
| 4916 | static int awe_midi_open(int dev, int mode, void (*input)(int,unsigned char), void (*output)(int)); |
| 4917 | static void awe_midi_close(int dev); |
| 4918 | static int awe_midi_ioctl(int dev, unsigned cmd, void __user * arg); |
| 4919 | static int awe_midi_outputc(int dev, unsigned char midi_byte); |
| 4920 | |
| 4921 | static void init_midi_status(MidiStatus *st); |
| 4922 | static void clear_rpn(void); |
| 4923 | static void get_midi_char(MidiStatus *st, int c); |
| 4924 | /*static void queue_varlen(MidiStatus *st, int c);*/ |
| 4925 | static void special_event(MidiStatus *st, int c); |
| 4926 | static void queue_read(MidiStatus *st, int c); |
| 4927 | static void midi_note_on(MidiStatus *st); |
| 4928 | static void midi_note_off(MidiStatus *st); |
| 4929 | static void midi_key_pressure(MidiStatus *st); |
| 4930 | static void midi_channel_pressure(MidiStatus *st); |
| 4931 | static void midi_pitch_wheel(MidiStatus *st); |
| 4932 | static void midi_program_change(MidiStatus *st); |
| 4933 | static void midi_control_change(MidiStatus *st); |
| 4934 | static void midi_select_bank(MidiStatus *st, int val); |
| 4935 | static void midi_nrpn_event(MidiStatus *st); |
| 4936 | static void midi_rpn_event(MidiStatus *st); |
| 4937 | static void midi_detune(int chan, int coarse, int fine); |
| 4938 | static void midi_system_exclusive(MidiStatus *st); |
| 4939 | static int send_converted_effect(ConvTable *table, int num_tables, MidiStatus *st, int type, int val); |
| 4940 | static int add_converted_effect(ConvTable *table, int num_tables, MidiStatus *st, int type, int val); |
| 4941 | static int xg_control_change(MidiStatus *st, int cmd, int val); |
| 4942 | |
| 4943 | #define numberof(ary) (sizeof(ary)/sizeof(ary[0])) |
| 4944 | |
| 4945 | |
| 4946 | /* |
| 4947 | * OSS Midi device record |
| 4948 | */ |
| 4949 | |
| 4950 | static struct midi_operations awe_midi_operations = |
| 4951 | { |
| 4952 | .owner = THIS_MODULE, |
| 4953 | .info = {"AWE Midi Emu", 0, 0, SNDCARD_SB}, |
| 4954 | .in_info = {0}, |
| 4955 | .open = awe_midi_open, /*open*/ |
| 4956 | .close = awe_midi_close, /*close*/ |
| 4957 | .ioctl = awe_midi_ioctl, /*ioctl*/ |
| 4958 | .outputc = awe_midi_outputc, /*outputc*/ |
| 4959 | }; |
| 4960 | |
| 4961 | static int my_mididev = -1; |
| 4962 | |
| 4963 | static void __init attach_midiemu(void) |
| 4964 | { |
| 4965 | if ((my_mididev = sound_alloc_mididev()) < 0) |
| 4966 | printk ("Sound: Too many midi devices detected\n"); |
| 4967 | else |
| 4968 | midi_devs[my_mididev] = &awe_midi_operations; |
| 4969 | } |
| 4970 | |
| 4971 | static void unload_midiemu(void) |
| 4972 | { |
| 4973 | if (my_mididev >= 0) |
| 4974 | sound_unload_mididev(my_mididev); |
| 4975 | } |
| 4976 | |
| 4977 | |
| 4978 | /* |
| 4979 | * open/close midi device |
| 4980 | */ |
| 4981 | |
| 4982 | static int midi_opened = FALSE; |
| 4983 | |
| 4984 | static int midi_mode; |
| 4985 | static int coarsetune, finetune; |
| 4986 | |
| 4987 | static int xg_mapping = TRUE; |
| 4988 | static int xg_bankmode; |
| 4989 | |
| 4990 | /* effect sensitivity */ |
| 4991 | |
| 4992 | #define FX_CUTOFF 0 |
| 4993 | #define FX_RESONANCE 1 |
| 4994 | #define FX_ATTACK 2 |
| 4995 | #define FX_RELEASE 3 |
| 4996 | #define FX_VIBRATE 4 |
| 4997 | #define FX_VIBDEPTH 5 |
| 4998 | #define FX_VIBDELAY 6 |
| 4999 | #define FX_NUMS 7 |
| 5000 | |
| 5001 | #define DEF_FX_CUTOFF 170 |
| 5002 | #define DEF_FX_RESONANCE 6 |
| 5003 | #define DEF_FX_ATTACK 50 |
| 5004 | #define DEF_FX_RELEASE 50 |
| 5005 | #define DEF_FX_VIBRATE 30 |
| 5006 | #define DEF_FX_VIBDEPTH 4 |
| 5007 | #define DEF_FX_VIBDELAY 1500 |
| 5008 | |
| 5009 | /* effect sense: */ |
| 5010 | static int gs_sense[] = |
| 5011 | { |
| 5012 | DEF_FX_CUTOFF, DEF_FX_RESONANCE, DEF_FX_ATTACK, DEF_FX_RELEASE, |
| 5013 | DEF_FX_VIBRATE, DEF_FX_VIBDEPTH, DEF_FX_VIBDELAY |
| 5014 | }; |
| 5015 | static int xg_sense[] = |
| 5016 | { |
| 5017 | DEF_FX_CUTOFF, DEF_FX_RESONANCE, DEF_FX_ATTACK, DEF_FX_RELEASE, |
| 5018 | DEF_FX_VIBRATE, DEF_FX_VIBDEPTH, DEF_FX_VIBDELAY |
| 5019 | }; |
| 5020 | |
| 5021 | |
| 5022 | /* current status */ |
| 5023 | static MidiStatus curst; |
| 5024 | |
| 5025 | |
| 5026 | static int |
| 5027 | awe_midi_open (int dev, int mode, |
| 5028 | void (*input)(int,unsigned char), |
| 5029 | void (*output)(int)) |
| 5030 | { |
| 5031 | if (midi_opened) |
| 5032 | return -EBUSY; |
| 5033 | |
| 5034 | midi_opened = TRUE; |
| 5035 | |
| 5036 | midi_mode = MODE_GM; |
| 5037 | |
| 5038 | curst.queue = Q_NONE; |
| 5039 | curst.qlen = 0; |
| 5040 | curst.read = 0; |
| 5041 | curst.status = 0; |
| 5042 | curst.chan = 0; |
| 5043 | memset(curst.buf, 0, sizeof(curst.buf)); |
| 5044 | |
| 5045 | init_midi_status(&curst); |
| 5046 | |
| 5047 | return 0; |
| 5048 | } |
| 5049 | |
| 5050 | static void |
| 5051 | awe_midi_close (int dev) |
| 5052 | { |
| 5053 | midi_opened = FALSE; |
| 5054 | } |
| 5055 | |
| 5056 | |
| 5057 | static int |
| 5058 | awe_midi_ioctl (int dev, unsigned cmd, void __user *arg) |
| 5059 | { |
| 5060 | return -EPERM; |
| 5061 | } |
| 5062 | |
| 5063 | static int |
| 5064 | awe_midi_outputc (int dev, unsigned char midi_byte) |
| 5065 | { |
| 5066 | if (! midi_opened) |
| 5067 | return 1; |
| 5068 | |
| 5069 | /* force to change playing mode */ |
| 5070 | playing_mode = AWE_PLAY_MULTI; |
| 5071 | |
| 5072 | get_midi_char(&curst, midi_byte); |
| 5073 | return 1; |
| 5074 | } |
| 5075 | |
| 5076 | |
| 5077 | /* |
| 5078 | * initialize |
| 5079 | */ |
| 5080 | |
| 5081 | static void init_midi_status(MidiStatus *st) |
| 5082 | { |
| 5083 | clear_rpn(); |
| 5084 | coarsetune = 0; |
| 5085 | finetune = 0; |
| 5086 | } |
| 5087 | |
| 5088 | |
| 5089 | /* |
| 5090 | * RPN & NRPN |
| 5091 | */ |
| 5092 | |
| 5093 | #define MAX_MIDI_CHANNELS 16 |
| 5094 | |
| 5095 | /* RPN & NRPN */ |
| 5096 | static unsigned char nrpn[MAX_MIDI_CHANNELS]; /* current event is NRPN? */ |
| 5097 | static int msb_bit; /* current event is msb for RPN/NRPN */ |
| 5098 | /* RPN & NRPN indeces */ |
| 5099 | static unsigned char rpn_msb[MAX_MIDI_CHANNELS], rpn_lsb[MAX_MIDI_CHANNELS]; |
| 5100 | /* RPN & NRPN values */ |
| 5101 | static int rpn_val[MAX_MIDI_CHANNELS]; |
| 5102 | |
| 5103 | static void clear_rpn(void) |
| 5104 | { |
| 5105 | int i; |
| 5106 | for (i = 0; i < MAX_MIDI_CHANNELS; i++) { |
| 5107 | nrpn[i] = 0; |
| 5108 | rpn_msb[i] = 127; |
| 5109 | rpn_lsb[i] = 127; |
| 5110 | rpn_val[i] = 0; |
| 5111 | } |
| 5112 | msb_bit = 0; |
| 5113 | } |
| 5114 | |
| 5115 | |
| 5116 | /* |
| 5117 | * process midi queue |
| 5118 | */ |
| 5119 | |
| 5120 | /* status event types */ |
| 5121 | typedef void (*StatusEvent)(MidiStatus *st); |
| 5122 | static struct StatusEventList { |
| 5123 | StatusEvent process; |
| 5124 | int qlen; |
| 5125 | } status_event[8] = { |
| 5126 | {midi_note_off, 2}, |
| 5127 | {midi_note_on, 2}, |
| 5128 | {midi_key_pressure, 2}, |
| 5129 | {midi_control_change, 2}, |
| 5130 | {midi_program_change, 1}, |
| 5131 | {midi_channel_pressure, 1}, |
| 5132 | {midi_pitch_wheel, 2}, |
| 5133 | {NULL, 0}, |
| 5134 | }; |
| 5135 | |
| 5136 | |
| 5137 | /* read a char from fifo and process it */ |
| 5138 | static void get_midi_char(MidiStatus *st, int c) |
| 5139 | { |
| 5140 | if (c == 0xfe) { |
| 5141 | /* ignore active sense */ |
| 5142 | st->queue = Q_NONE; |
| 5143 | return; |
| 5144 | } |
| 5145 | |
| 5146 | switch (st->queue) { |
| 5147 | /* case Q_VARLEN: queue_varlen(st, c); break;*/ |
| 5148 | case Q_READ: |
| 5149 | case Q_SYSEX: |
| 5150 | queue_read(st, c); |
| 5151 | break; |
| 5152 | case Q_NONE: |
| 5153 | st->read = 0; |
| 5154 | if ((c & 0xf0) == 0xf0) { |
| 5155 | special_event(st, c); |
| 5156 | } else if (c & 0x80) { /* status change */ |
| 5157 | st->status = (c >> 4) & 0x07; |
| 5158 | st->chan = c & 0x0f; |
| 5159 | st->queue = Q_READ; |
| 5160 | st->qlen = status_event[st->status].qlen; |
| 5161 | if (st->qlen == 0) |
| 5162 | st->queue = Q_NONE; |
| 5163 | } |
| 5164 | break; |
| 5165 | } |
| 5166 | } |
| 5167 | |
| 5168 | /* 0xfx events */ |
| 5169 | static void special_event(MidiStatus *st, int c) |
| 5170 | { |
| 5171 | switch (c) { |
| 5172 | case 0xf0: /* system exclusive */ |
| 5173 | st->queue = Q_SYSEX; |
| 5174 | st->qlen = 0; |
| 5175 | break; |
| 5176 | case 0xf1: /* MTC quarter frame */ |
| 5177 | case 0xf3: /* song select */ |
| 5178 | st->queue = Q_READ; |
| 5179 | st->qlen = 1; |
| 5180 | break; |
| 5181 | case 0xf2: /* song position */ |
| 5182 | st->queue = Q_READ; |
| 5183 | st->qlen = 2; |
| 5184 | break; |
| 5185 | } |
| 5186 | } |
| 5187 | |
| 5188 | #if 0 |
| 5189 | /* read variable length value */ |
| 5190 | static void queue_varlen(MidiStatus *st, int c) |
| 5191 | { |
| 5192 | st->qlen += (c & 0x7f); |
| 5193 | if (c & 0x80) { |
| 5194 | st->qlen <<= 7; |
| 5195 | return; |
| 5196 | } |
| 5197 | if (st->qlen <= 0) { |
| 5198 | st->qlen = 0; |
| 5199 | st->queue = Q_NONE; |
| 5200 | } |
| 5201 | st->queue = Q_READ; |
| 5202 | st->read = 0; |
| 5203 | } |
| 5204 | #endif |
| 5205 | |
| 5206 | |
| 5207 | /* read a char */ |
| 5208 | static void queue_read(MidiStatus *st, int c) |
| 5209 | { |
| 5210 | if (st->read < MAX_MIDIBUF) { |
| 5211 | if (st->queue != Q_SYSEX) |
| 5212 | c &= 0x7f; |
| 5213 | st->buf[st->read] = (unsigned char)c; |
| 5214 | } |
| 5215 | st->read++; |
| 5216 | if (st->queue == Q_SYSEX && c == 0xf7) { |
| 5217 | midi_system_exclusive(st); |
| 5218 | st->queue = Q_NONE; |
| 5219 | } else if (st->queue == Q_READ && st->read >= st->qlen) { |
| 5220 | if (status_event[st->status].process) |
| 5221 | status_event[st->status].process(st); |
| 5222 | st->queue = Q_NONE; |
| 5223 | } |
| 5224 | } |
| 5225 | |
| 5226 | |
| 5227 | /* |
| 5228 | * status events |
| 5229 | */ |
| 5230 | |
| 5231 | /* note on */ |
| 5232 | static void midi_note_on(MidiStatus *st) |
| 5233 | { |
| 5234 | DEBUG(2,printk("midi: note_on (%d) %d %d\n", st->chan, st->buf[0], st->buf[1])); |
| 5235 | if (st->buf[1] == 0) |
| 5236 | midi_note_off(st); |
| 5237 | else |
| 5238 | awe_start_note(0, st->chan, st->buf[0], st->buf[1]); |
| 5239 | } |
| 5240 | |
| 5241 | /* note off */ |
| 5242 | static void midi_note_off(MidiStatus *st) |
| 5243 | { |
| 5244 | DEBUG(2,printk("midi: note_off (%d) %d %d\n", st->chan, st->buf[0], st->buf[1])); |
| 5245 | awe_kill_note(0, st->chan, st->buf[0], st->buf[1]); |
| 5246 | } |
| 5247 | |
| 5248 | /* key pressure change */ |
| 5249 | static void midi_key_pressure(MidiStatus *st) |
| 5250 | { |
| 5251 | awe_key_pressure(0, st->chan, st->buf[0], st->buf[1]); |
| 5252 | } |
| 5253 | |
| 5254 | /* channel pressure change */ |
| 5255 | static void midi_channel_pressure(MidiStatus *st) |
| 5256 | { |
| 5257 | channels[st->chan].chan_press = st->buf[0]; |
| 5258 | awe_modwheel_change(st->chan, st->buf[0]); |
| 5259 | } |
| 5260 | |
| 5261 | /* pitch wheel change */ |
| 5262 | static void midi_pitch_wheel(MidiStatus *st) |
| 5263 | { |
| 5264 | int val = (int)st->buf[1] * 128 + st->buf[0]; |
| 5265 | awe_bender(0, st->chan, val); |
| 5266 | } |
| 5267 | |
| 5268 | /* program change */ |
| 5269 | static void midi_program_change(MidiStatus *st) |
| 5270 | { |
| 5271 | int preset; |
| 5272 | preset = st->buf[0]; |
| 5273 | if (midi_mode == MODE_GS && IS_DRUM_CHANNEL(st->chan) && preset == 127) |
| 5274 | preset = 0; |
| 5275 | else if (midi_mode == MODE_XG && xg_mapping && IS_DRUM_CHANNEL(st->chan)) |
| 5276 | preset += 64; |
| 5277 | |
| 5278 | awe_set_instr(0, st->chan, preset); |
| 5279 | } |
| 5280 | |
| 5281 | #define send_effect(chan,type,val) awe_send_effect(chan,-1,type,val) |
| 5282 | #define add_effect(chan,type,val) awe_send_effect(chan,-1,(type)|0x80,val) |
| 5283 | #define unset_effect(chan,type) awe_send_effect(chan,-1,(type)|0x40,0) |
| 5284 | |
| 5285 | /* midi control change */ |
| 5286 | static void midi_control_change(MidiStatus *st) |
| 5287 | { |
| 5288 | int cmd = st->buf[0]; |
| 5289 | int val = st->buf[1]; |
| 5290 | |
| 5291 | DEBUG(2,printk("midi: control (%d) %d %d\n", st->chan, cmd, val)); |
| 5292 | if (midi_mode == MODE_XG) { |
| 5293 | if (xg_control_change(st, cmd, val)) |
| 5294 | return; |
| 5295 | } |
| 5296 | |
| 5297 | /* controls #31 - #64 are LSB of #0 - #31 */ |
| 5298 | msb_bit = 1; |
| 5299 | if (cmd >= 0x20 && cmd < 0x40) { |
| 5300 | msb_bit = 0; |
| 5301 | cmd -= 0x20; |
| 5302 | } |
| 5303 | |
| 5304 | switch (cmd) { |
| 5305 | case CTL_SOFT_PEDAL: |
| 5306 | if (val == 127) |
| 5307 | add_effect(st->chan, AWE_FX_CUTOFF, -160); |
| 5308 | else |
| 5309 | unset_effect(st->chan, AWE_FX_CUTOFF); |
| 5310 | break; |
| 5311 | |
| 5312 | case CTL_BANK_SELECT: |
| 5313 | midi_select_bank(st, val); |
| 5314 | break; |
| 5315 | |
| 5316 | /* set RPN/NRPN parameter */ |
| 5317 | case CTL_REGIST_PARM_NUM_MSB: |
| 5318 | nrpn[st->chan]=0; rpn_msb[st->chan]=val; |
| 5319 | break; |
| 5320 | case CTL_REGIST_PARM_NUM_LSB: |
| 5321 | nrpn[st->chan]=0; rpn_lsb[st->chan]=val; |
| 5322 | break; |
| 5323 | case CTL_NONREG_PARM_NUM_MSB: |
| 5324 | nrpn[st->chan]=1; rpn_msb[st->chan]=val; |
| 5325 | break; |
| 5326 | case CTL_NONREG_PARM_NUM_LSB: |
| 5327 | nrpn[st->chan]=1; rpn_lsb[st->chan]=val; |
| 5328 | break; |
| 5329 | |
| 5330 | /* send RPN/NRPN entry */ |
| 5331 | case CTL_DATA_ENTRY: |
| 5332 | if (msb_bit) |
| 5333 | rpn_val[st->chan] = val * 128; |
| 5334 | else |
| 5335 | rpn_val[st->chan] |= val; |
| 5336 | if (nrpn[st->chan]) |
| 5337 | midi_nrpn_event(st); |
| 5338 | else |
| 5339 | midi_rpn_event(st); |
| 5340 | break; |
| 5341 | |
| 5342 | /* increase/decrease data entry */ |
| 5343 | case CTL_DATA_INCREMENT: |
| 5344 | rpn_val[st->chan]++; |
| 5345 | midi_rpn_event(st); |
| 5346 | break; |
| 5347 | case CTL_DATA_DECREMENT: |
| 5348 | rpn_val[st->chan]--; |
| 5349 | midi_rpn_event(st); |
| 5350 | break; |
| 5351 | |
| 5352 | /* default */ |
| 5353 | default: |
| 5354 | awe_controller(0, st->chan, cmd, val); |
| 5355 | break; |
| 5356 | } |
| 5357 | } |
| 5358 | |
| 5359 | /* tone bank change */ |
| 5360 | static void midi_select_bank(MidiStatus *st, int val) |
| 5361 | { |
| 5362 | if (midi_mode == MODE_XG && msb_bit) { |
| 5363 | xg_bankmode = val; |
| 5364 | /* XG MSB value; not normal bank selection */ |
| 5365 | switch (val) { |
| 5366 | case 127: /* remap to drum channel */ |
| 5367 | awe_controller(0, st->chan, CTL_BANK_SELECT, 128); |
| 5368 | break; |
| 5369 | default: /* remap to normal channel */ |
| 5370 | awe_controller(0, st->chan, CTL_BANK_SELECT, val); |
| 5371 | break; |
| 5372 | } |
| 5373 | return; |
| 5374 | } else if (midi_mode == MODE_GS && !msb_bit) |
| 5375 | /* ignore LSB bank in GS mode (used for mapping) */ |
| 5376 | return; |
| 5377 | |
| 5378 | /* normal bank controls; accept both MSB and LSB */ |
| 5379 | if (! IS_DRUM_CHANNEL(st->chan)) { |
| 5380 | if (midi_mode == MODE_XG) { |
| 5381 | if (xg_bankmode) return; |
| 5382 | if (val == 64 || val == 126) |
| 5383 | val = 0; |
| 5384 | } else if (midi_mode == MODE_GS && val == 127) |
| 5385 | val = 0; |
| 5386 | awe_controller(0, st->chan, CTL_BANK_SELECT, val); |
| 5387 | } |
| 5388 | } |
| 5389 | |
| 5390 | |
| 5391 | /* |
| 5392 | * RPN events |
| 5393 | */ |
| 5394 | |
| 5395 | static void midi_rpn_event(MidiStatus *st) |
| 5396 | { |
| 5397 | int type; |
| 5398 | type = (rpn_msb[st->chan]<<8) | rpn_lsb[st->chan]; |
| 5399 | switch (type) { |
| 5400 | case 0x0000: /* Pitch bend sensitivity */ |
| 5401 | /* MSB only / 1 semitone per 128 */ |
| 5402 | if (msb_bit) { |
| 5403 | channels[st->chan].bender_range = |
| 5404 | rpn_val[st->chan] * 100 / 128; |
| 5405 | } |
| 5406 | break; |
| 5407 | |
| 5408 | case 0x0001: /* fine tuning: */ |
| 5409 | /* MSB/LSB, 8192=center, 100/8192 cent step */ |
| 5410 | finetune = rpn_val[st->chan] - 8192; |
| 5411 | midi_detune(st->chan, coarsetune, finetune); |
| 5412 | break; |
| 5413 | |
| 5414 | case 0x0002: /* coarse tuning */ |
| 5415 | /* MSB only / 8192=center, 1 semitone per 128 */ |
| 5416 | if (msb_bit) { |
| 5417 | coarsetune = rpn_val[st->chan] - 8192; |
| 5418 | midi_detune(st->chan, coarsetune, finetune); |
| 5419 | } |
| 5420 | break; |
| 5421 | |
| 5422 | case 0x7F7F: /* "lock-in" RPN */ |
| 5423 | break; |
| 5424 | } |
| 5425 | } |
| 5426 | |
| 5427 | |
| 5428 | /* tuning: |
| 5429 | * coarse = -8192 to 8192 (100 cent per 128) |
| 5430 | * fine = -8192 to 8192 (max=100cent) |
| 5431 | */ |
| 5432 | static void midi_detune(int chan, int coarse, int fine) |
| 5433 | { |
| 5434 | /* 4096 = 1200 cents in AWE parameter */ |
| 5435 | int val; |
| 5436 | val = coarse * 4096 / (12 * 128); |
| 5437 | val += fine / 24; |
| 5438 | if (val) |
| 5439 | send_effect(chan, AWE_FX_INIT_PITCH, val); |
| 5440 | else |
| 5441 | unset_effect(chan, AWE_FX_INIT_PITCH); |
| 5442 | } |
| 5443 | |
| 5444 | |
| 5445 | /* |
| 5446 | * system exclusive message |
| 5447 | * GM/GS/XG macros are accepted |
| 5448 | */ |
| 5449 | |
| 5450 | static void midi_system_exclusive(MidiStatus *st) |
| 5451 | { |
| 5452 | /* GM on */ |
| 5453 | static unsigned char gm_on_macro[] = { |
| 5454 | 0x7e,0x7f,0x09,0x01, |
| 5455 | }; |
| 5456 | /* XG on */ |
| 5457 | static unsigned char xg_on_macro[] = { |
| 5458 | 0x43,0x10,0x4c,0x00,0x00,0x7e,0x00, |
| 5459 | }; |
| 5460 | /* GS prefix |
| 5461 | * drum channel: XX=0x1?(channel), YY=0x15, ZZ=on/off |
| 5462 | * reverb mode: XX=0x01, YY=0x30, ZZ=0-7 |
| 5463 | * chorus mode: XX=0x01, YY=0x38, ZZ=0-7 |
| 5464 | */ |
| 5465 | static unsigned char gs_pfx_macro[] = { |
| 5466 | 0x41,0x10,0x42,0x12,0x40,/*XX,YY,ZZ*/ |
| 5467 | }; |
| 5468 | |
| 5469 | #if 0 |
| 5470 | /* SC88 system mode set |
| 5471 | * single module mode: XX=1 |
| 5472 | * double module mode: XX=0 |
| 5473 | */ |
| 5474 | static unsigned char gs_mode_macro[] = { |
| 5475 | 0x41,0x10,0x42,0x12,0x00,0x00,0x7F,/*ZZ*/ |
| 5476 | }; |
| 5477 | /* SC88 display macro: XX=01:bitmap, 00:text |
| 5478 | */ |
| 5479 | static unsigned char gs_disp_macro[] = { |
| 5480 | 0x41,0x10,0x45,0x12,0x10,/*XX,00*/ |
| 5481 | }; |
| 5482 | #endif |
| 5483 | |
| 5484 | /* GM on */ |
| 5485 | if (memcmp(st->buf, gm_on_macro, sizeof(gm_on_macro)) == 0) { |
| 5486 | if (midi_mode != MODE_GS && midi_mode != MODE_XG) |
| 5487 | midi_mode = MODE_GM; |
| 5488 | init_midi_status(st); |
| 5489 | } |
| 5490 | |
| 5491 | /* GS macros */ |
| 5492 | else if (memcmp(st->buf, gs_pfx_macro, sizeof(gs_pfx_macro)) == 0) { |
| 5493 | if (midi_mode != MODE_GS && midi_mode != MODE_XG) |
| 5494 | midi_mode = MODE_GS; |
| 5495 | |
| 5496 | if (st->buf[5] == 0x00 && st->buf[6] == 0x7f && st->buf[7] == 0x00) { |
| 5497 | /* GS reset */ |
| 5498 | init_midi_status(st); |
| 5499 | } |
| 5500 | |
| 5501 | else if ((st->buf[5] & 0xf0) == 0x10 && st->buf[6] == 0x15) { |
| 5502 | /* drum pattern */ |
| 5503 | int p = st->buf[5] & 0x0f; |
| 5504 | if (p == 0) p = 9; |
| 5505 | else if (p < 10) p--; |
| 5506 | if (st->buf[7] == 0) |
| 5507 | DRUM_CHANNEL_OFF(p); |
| 5508 | else |
| 5509 | DRUM_CHANNEL_ON(p); |
| 5510 | |
| 5511 | } else if ((st->buf[5] & 0xf0) == 0x10 && st->buf[6] == 0x21) { |
| 5512 | /* program */ |
| 5513 | int p = st->buf[5] & 0x0f; |
| 5514 | if (p == 0) p = 9; |
| 5515 | else if (p < 10) p--; |
| 5516 | if (! IS_DRUM_CHANNEL(p)) |
| 5517 | awe_set_instr(0, p, st->buf[7]); |
| 5518 | |
| 5519 | } else if (st->buf[5] == 0x01 && st->buf[6] == 0x30) { |
| 5520 | /* reverb mode */ |
| 5521 | awe_set_reverb_mode(st->buf[7]); |
| 5522 | |
| 5523 | } else if (st->buf[5] == 0x01 && st->buf[6] == 0x38) { |
| 5524 | /* chorus mode */ |
| 5525 | awe_set_chorus_mode(st->buf[7]); |
| 5526 | |
| 5527 | } else if (st->buf[5] == 0x00 && st->buf[6] == 0x04) { |
| 5528 | /* master volume */ |
| 5529 | awe_change_master_volume(st->buf[7]); |
| 5530 | |
| 5531 | } |
| 5532 | } |
| 5533 | |
| 5534 | /* XG on */ |
| 5535 | else if (memcmp(st->buf, xg_on_macro, sizeof(xg_on_macro)) == 0) { |
| 5536 | midi_mode = MODE_XG; |
| 5537 | xg_mapping = TRUE; |
| 5538 | xg_bankmode = 0; |
| 5539 | } |
| 5540 | } |
| 5541 | |
| 5542 | |
| 5543 | /*----------------------------------------------------------------*/ |
| 5544 | |
| 5545 | /* |
| 5546 | * convert NRPN/control values |
| 5547 | */ |
| 5548 | |
| 5549 | static int send_converted_effect(ConvTable *table, int num_tables, MidiStatus *st, int type, int val) |
| 5550 | { |
| 5551 | int i, cval; |
| 5552 | for (i = 0; i < num_tables; i++) { |
| 5553 | if (table[i].control == type) { |
| 5554 | cval = table[i].convert(val); |
| 5555 | send_effect(st->chan, table[i].awe_effect, cval); |
| 5556 | return TRUE; |
| 5557 | } |
| 5558 | } |
| 5559 | return FALSE; |
| 5560 | } |
| 5561 | |
| 5562 | static int add_converted_effect(ConvTable *table, int num_tables, MidiStatus *st, int type, int val) |
| 5563 | { |
| 5564 | int i, cval; |
| 5565 | for (i = 0; i < num_tables; i++) { |
| 5566 | if (table[i].control == type) { |
| 5567 | cval = table[i].convert(val); |
| 5568 | add_effect(st->chan, table[i].awe_effect|0x80, cval); |
| 5569 | return TRUE; |
| 5570 | } |
| 5571 | } |
| 5572 | return FALSE; |
| 5573 | } |
| 5574 | |
| 5575 | |
| 5576 | /* |
| 5577 | * AWE32 NRPN effects |
| 5578 | */ |
| 5579 | |
| 5580 | static unsigned short fx_delay(int val); |
| 5581 | static unsigned short fx_attack(int val); |
| 5582 | static unsigned short fx_hold(int val); |
| 5583 | static unsigned short fx_decay(int val); |
| 5584 | static unsigned short fx_the_value(int val); |
| 5585 | static unsigned short fx_twice_value(int val); |
| 5586 | static unsigned short fx_conv_pitch(int val); |
| 5587 | static unsigned short fx_conv_Q(int val); |
| 5588 | |
| 5589 | /* function for each NRPN */ /* [range] units */ |
| 5590 | #define fx_env1_delay fx_delay /* [0,5900] 4msec */ |
| 5591 | #define fx_env1_attack fx_attack /* [0,5940] 1msec */ |
| 5592 | #define fx_env1_hold fx_hold /* [0,8191] 1msec */ |
| 5593 | #define fx_env1_decay fx_decay /* [0,5940] 4msec */ |
| 5594 | #define fx_env1_release fx_decay /* [0,5940] 4msec */ |
| 5595 | #define fx_env1_sustain fx_the_value /* [0,127] 0.75dB */ |
| 5596 | #define fx_env1_pitch fx_the_value /* [-127,127] 9.375cents */ |
| 5597 | #define fx_env1_cutoff fx_the_value /* [-127,127] 56.25cents */ |
| 5598 | |
| 5599 | #define fx_env2_delay fx_delay /* [0,5900] 4msec */ |
| 5600 | #define fx_env2_attack fx_attack /* [0,5940] 1msec */ |
| 5601 | #define fx_env2_hold fx_hold /* [0,8191] 1msec */ |
| 5602 | #define fx_env2_decay fx_decay /* [0,5940] 4msec */ |
| 5603 | #define fx_env2_release fx_decay /* [0,5940] 4msec */ |
| 5604 | #define fx_env2_sustain fx_the_value /* [0,127] 0.75dB */ |
| 5605 | |
| 5606 | #define fx_lfo1_delay fx_delay /* [0,5900] 4msec */ |
| 5607 | #define fx_lfo1_freq fx_twice_value /* [0,127] 84mHz */ |
| 5608 | #define fx_lfo1_volume fx_twice_value /* [0,127] 0.1875dB */ |
| 5609 | #define fx_lfo1_pitch fx_the_value /* [-127,127] 9.375cents */ |
| 5610 | #define fx_lfo1_cutoff fx_twice_value /* [-64,63] 56.25cents */ |
| 5611 | |
| 5612 | #define fx_lfo2_delay fx_delay /* [0,5900] 4msec */ |
| 5613 | #define fx_lfo2_freq fx_twice_value /* [0,127] 84mHz */ |
| 5614 | #define fx_lfo2_pitch fx_the_value /* [-127,127] 9.375cents */ |
| 5615 | |
| 5616 | #define fx_init_pitch fx_conv_pitch /* [-8192,8192] cents */ |
| 5617 | #define fx_chorus fx_the_value /* [0,255] -- */ |
| 5618 | #define fx_reverb fx_the_value /* [0,255] -- */ |
| 5619 | #define fx_cutoff fx_twice_value /* [0,127] 62Hz */ |
| 5620 | #define fx_filterQ fx_conv_Q /* [0,127] -- */ |
| 5621 | |
| 5622 | static unsigned short fx_delay(int val) |
| 5623 | { |
| 5624 | return (unsigned short)calc_parm_delay(val); |
| 5625 | } |
| 5626 | |
| 5627 | static unsigned short fx_attack(int val) |
| 5628 | { |
| 5629 | return (unsigned short)calc_parm_attack(val); |
| 5630 | } |
| 5631 | |
| 5632 | static unsigned short fx_hold(int val) |
| 5633 | { |
| 5634 | return (unsigned short)calc_parm_hold(val); |
| 5635 | } |
| 5636 | |
| 5637 | static unsigned short fx_decay(int val) |
| 5638 | { |
| 5639 | return (unsigned short)calc_parm_decay(val); |
| 5640 | } |
| 5641 | |
| 5642 | static unsigned short fx_the_value(int val) |
| 5643 | { |
| 5644 | return (unsigned short)(val & 0xff); |
| 5645 | } |
| 5646 | |
| 5647 | static unsigned short fx_twice_value(int val) |
| 5648 | { |
| 5649 | return (unsigned short)((val * 2) & 0xff); |
| 5650 | } |
| 5651 | |
| 5652 | static unsigned short fx_conv_pitch(int val) |
| 5653 | { |
| 5654 | return (short)(val * 4096 / 1200); |
| 5655 | } |
| 5656 | |
| 5657 | static unsigned short fx_conv_Q(int val) |
| 5658 | { |
| 5659 | return (unsigned short)((val / 8) & 0xff); |
| 5660 | } |
| 5661 | |
| 5662 | |
| 5663 | static ConvTable awe_effects[] = |
| 5664 | { |
| 5665 | { 0, AWE_FX_LFO1_DELAY, fx_lfo1_delay}, |
| 5666 | { 1, AWE_FX_LFO1_FREQ, fx_lfo1_freq}, |
| 5667 | { 2, AWE_FX_LFO2_DELAY, fx_lfo2_delay}, |
| 5668 | { 3, AWE_FX_LFO2_FREQ, fx_lfo2_freq}, |
| 5669 | |
| 5670 | { 4, AWE_FX_ENV1_DELAY, fx_env1_delay}, |
| 5671 | { 5, AWE_FX_ENV1_ATTACK,fx_env1_attack}, |
| 5672 | { 6, AWE_FX_ENV1_HOLD, fx_env1_hold}, |
| 5673 | { 7, AWE_FX_ENV1_DECAY, fx_env1_decay}, |
| 5674 | { 8, AWE_FX_ENV1_SUSTAIN, fx_env1_sustain}, |
| 5675 | { 9, AWE_FX_ENV1_RELEASE, fx_env1_release}, |
| 5676 | |
| 5677 | {10, AWE_FX_ENV2_DELAY, fx_env2_delay}, |
| 5678 | {11, AWE_FX_ENV2_ATTACK, fx_env2_attack}, |
| 5679 | {12, AWE_FX_ENV2_HOLD, fx_env2_hold}, |
| 5680 | {13, AWE_FX_ENV2_DECAY, fx_env2_decay}, |
| 5681 | {14, AWE_FX_ENV2_SUSTAIN, fx_env2_sustain}, |
| 5682 | {15, AWE_FX_ENV2_RELEASE, fx_env2_release}, |
| 5683 | |
| 5684 | {16, AWE_FX_INIT_PITCH, fx_init_pitch}, |
| 5685 | {17, AWE_FX_LFO1_PITCH, fx_lfo1_pitch}, |
| 5686 | {18, AWE_FX_LFO2_PITCH, fx_lfo2_pitch}, |
| 5687 | {19, AWE_FX_ENV1_PITCH, fx_env1_pitch}, |
| 5688 | {20, AWE_FX_LFO1_VOLUME, fx_lfo1_volume}, |
| 5689 | {21, AWE_FX_CUTOFF, fx_cutoff}, |
| 5690 | {22, AWE_FX_FILTERQ, fx_filterQ}, |
| 5691 | {23, AWE_FX_LFO1_CUTOFF, fx_lfo1_cutoff}, |
| 5692 | {24, AWE_FX_ENV1_CUTOFF, fx_env1_cutoff}, |
| 5693 | {25, AWE_FX_CHORUS, fx_chorus}, |
| 5694 | {26, AWE_FX_REVERB, fx_reverb}, |
| 5695 | }; |
| 5696 | |
| 5697 | static int num_awe_effects = numberof(awe_effects); |
| 5698 | |
| 5699 | |
| 5700 | /* |
| 5701 | * GS(SC88) NRPN effects; still experimental |
| 5702 | */ |
| 5703 | |
| 5704 | /* cutoff: quarter semitone step, max=255 */ |
| 5705 | static unsigned short gs_cutoff(int val) |
| 5706 | { |
| 5707 | return (val - 64) * gs_sense[FX_CUTOFF] / 50; |
| 5708 | } |
| 5709 | |
| 5710 | /* resonance: 0 to 15(max) */ |
| 5711 | static unsigned short gs_filterQ(int val) |
| 5712 | { |
| 5713 | return (val - 64) * gs_sense[FX_RESONANCE] / 50; |
| 5714 | } |
| 5715 | |
| 5716 | /* attack: */ |
| 5717 | static unsigned short gs_attack(int val) |
| 5718 | { |
| 5719 | return -(val - 64) * gs_sense[FX_ATTACK] / 50; |
| 5720 | } |
| 5721 | |
| 5722 | /* decay: */ |
| 5723 | static unsigned short gs_decay(int val) |
| 5724 | { |
| 5725 | return -(val - 64) * gs_sense[FX_RELEASE] / 50; |
| 5726 | } |
| 5727 | |
| 5728 | /* release: */ |
| 5729 | static unsigned short gs_release(int val) |
| 5730 | { |
| 5731 | return -(val - 64) * gs_sense[FX_RELEASE] / 50; |
| 5732 | } |
| 5733 | |
| 5734 | /* vibrato freq: 0.042Hz step, max=255 */ |
| 5735 | static unsigned short gs_vib_rate(int val) |
| 5736 | { |
| 5737 | return (val - 64) * gs_sense[FX_VIBRATE] / 50; |
| 5738 | } |
| 5739 | |
| 5740 | /* vibrato depth: max=127, 1 octave */ |
| 5741 | static unsigned short gs_vib_depth(int val) |
| 5742 | { |
| 5743 | return (val - 64) * gs_sense[FX_VIBDEPTH] / 50; |
| 5744 | } |
| 5745 | |
| 5746 | /* vibrato delay: -0.725msec step */ |
| 5747 | static unsigned short gs_vib_delay(int val) |
| 5748 | { |
| 5749 | return -(val - 64) * gs_sense[FX_VIBDELAY] / 50; |
| 5750 | } |
| 5751 | |
| 5752 | static ConvTable gs_effects[] = |
| 5753 | { |
| 5754 | {32, AWE_FX_CUTOFF, gs_cutoff}, |
| 5755 | {33, AWE_FX_FILTERQ, gs_filterQ}, |
| 5756 | {99, AWE_FX_ENV2_ATTACK, gs_attack}, |
| 5757 | {100, AWE_FX_ENV2_DECAY, gs_decay}, |
| 5758 | {102, AWE_FX_ENV2_RELEASE, gs_release}, |
| 5759 | {8, AWE_FX_LFO1_FREQ, gs_vib_rate}, |
| 5760 | {9, AWE_FX_LFO1_VOLUME, gs_vib_depth}, |
| 5761 | {10, AWE_FX_LFO1_DELAY, gs_vib_delay}, |
| 5762 | }; |
| 5763 | |
| 5764 | static int num_gs_effects = numberof(gs_effects); |
| 5765 | |
| 5766 | |
| 5767 | /* |
| 5768 | * NRPN events: accept as AWE32/SC88 specific controls |
| 5769 | */ |
| 5770 | |
| 5771 | static void midi_nrpn_event(MidiStatus *st) |
| 5772 | { |
| 5773 | if (rpn_msb[st->chan] == 127 && rpn_lsb[st->chan] <= 26) { |
| 5774 | if (! msb_bit) /* both MSB/LSB necessary */ |
| 5775 | send_converted_effect(awe_effects, num_awe_effects, |
| 5776 | st, rpn_lsb[st->chan], |
| 5777 | rpn_val[st->chan] - 8192); |
| 5778 | } else if (rpn_msb[st->chan] == 1) { |
| 5779 | if (msb_bit) /* only MSB is valid */ |
| 5780 | add_converted_effect(gs_effects, num_gs_effects, |
| 5781 | st, rpn_lsb[st->chan], |
| 5782 | rpn_val[st->chan] / 128); |
| 5783 | } |
| 5784 | } |
| 5785 | |
| 5786 | |
| 5787 | /* |
| 5788 | * XG control effects; still experimental |
| 5789 | */ |
| 5790 | |
| 5791 | /* cutoff: quarter semitone step, max=255 */ |
| 5792 | static unsigned short xg_cutoff(int val) |
| 5793 | { |
| 5794 | return (val - 64) * xg_sense[FX_CUTOFF] / 64; |
| 5795 | } |
| 5796 | |
| 5797 | /* resonance: 0(open) to 15(most nasal) */ |
| 5798 | static unsigned short xg_filterQ(int val) |
| 5799 | { |
| 5800 | return (val - 64) * xg_sense[FX_RESONANCE] / 64; |
| 5801 | } |
| 5802 | |
| 5803 | /* attack: */ |
| 5804 | static unsigned short xg_attack(int val) |
| 5805 | { |
| 5806 | return -(val - 64) * xg_sense[FX_ATTACK] / 64; |
| 5807 | } |
| 5808 | |
| 5809 | /* release: */ |
| 5810 | static unsigned short xg_release(int val) |
| 5811 | { |
| 5812 | return -(val - 64) * xg_sense[FX_RELEASE] / 64; |
| 5813 | } |
| 5814 | |
| 5815 | static ConvTable xg_effects[] = |
| 5816 | { |
| 5817 | {71, AWE_FX_CUTOFF, xg_cutoff}, |
| 5818 | {74, AWE_FX_FILTERQ, xg_filterQ}, |
| 5819 | {72, AWE_FX_ENV2_RELEASE, xg_release}, |
| 5820 | {73, AWE_FX_ENV2_ATTACK, xg_attack}, |
| 5821 | }; |
| 5822 | |
| 5823 | static int num_xg_effects = numberof(xg_effects); |
| 5824 | |
| 5825 | static int xg_control_change(MidiStatus *st, int cmd, int val) |
| 5826 | { |
| 5827 | return add_converted_effect(xg_effects, num_xg_effects, st, cmd, val); |
| 5828 | } |
| 5829 | |
| 5830 | #endif /* CONFIG_AWE32_MIDIEMU */ |
| 5831 | |
| 5832 | |
| 5833 | /*----------------------------------------------------------------*/ |
| 5834 | |
| 5835 | |
| 5836 | /* |
| 5837 | * initialization of AWE driver |
| 5838 | */ |
| 5839 | |
| 5840 | static void |
| 5841 | awe_initialize(void) |
| 5842 | { |
| 5843 | DEBUG(0,printk("AWE32: initializing..\n")); |
| 5844 | |
| 5845 | /* initialize hardware configuration */ |
| 5846 | awe_poke(AWE_HWCF1, 0x0059); |
| 5847 | awe_poke(AWE_HWCF2, 0x0020); |
| 5848 | |
| 5849 | /* disable audio; this seems to reduce a clicking noise a bit.. */ |
| 5850 | awe_poke(AWE_HWCF3, 0); |
| 5851 | |
| 5852 | /* initialize audio channels */ |
| 5853 | awe_init_audio(); |
| 5854 | |
| 5855 | /* initialize DMA */ |
| 5856 | awe_init_dma(); |
| 5857 | |
| 5858 | /* initialize init array */ |
| 5859 | awe_init_array(); |
| 5860 | |
| 5861 | /* check DRAM memory size */ |
| 5862 | awe_check_dram(); |
| 5863 | |
| 5864 | /* initialize the FM section of the AWE32 */ |
| 5865 | awe_init_fm(); |
| 5866 | |
| 5867 | /* set up voice envelopes */ |
| 5868 | awe_tweak(); |
| 5869 | |
| 5870 | /* enable audio */ |
| 5871 | awe_poke(AWE_HWCF3, 0x0004); |
| 5872 | |
| 5873 | /* set default values */ |
| 5874 | awe_init_ctrl_parms(TRUE); |
| 5875 | |
| 5876 | /* set equalizer */ |
| 5877 | awe_update_equalizer(); |
| 5878 | |
| 5879 | /* set reverb & chorus modes */ |
| 5880 | awe_update_reverb_mode(); |
| 5881 | awe_update_chorus_mode(); |
| 5882 | } |
| 5883 | |
| 5884 | |
| 5885 | /* |
| 5886 | * Core Device Management Functions |
| 5887 | */ |
| 5888 | |
| 5889 | /* store values to i/o port array */ |
| 5890 | static void setup_ports(int port1, int port2, int port3) |
| 5891 | { |
| 5892 | awe_ports[0] = port1; |
| 5893 | if (port2 == 0) |
| 5894 | port2 = port1 + 0x400; |
| 5895 | awe_ports[1] = port2; |
| 5896 | awe_ports[2] = port2 + 2; |
| 5897 | if (port3 == 0) |
| 5898 | port3 = port1 + 0x800; |
| 5899 | awe_ports[3] = port3; |
| 5900 | awe_ports[4] = port3 + 2; |
| 5901 | |
| 5902 | port_setuped = TRUE; |
| 5903 | } |
| 5904 | |
| 5905 | /* |
| 5906 | * port request |
| 5907 | * 0x620-623, 0xA20-A23, 0xE20-E23 |
| 5908 | */ |
| 5909 | |
| 5910 | static int |
| 5911 | awe_request_region(void) |
| 5912 | { |
| 5913 | if (! port_setuped) |
| 5914 | return 0; |
| 5915 | if (! request_region(awe_ports[0], 4, "sound driver (AWE32)")) |
| 5916 | return 0; |
| 5917 | if (! request_region(awe_ports[1], 4, "sound driver (AWE32)")) |
| 5918 | goto err_out; |
| 5919 | if (! request_region(awe_ports[3], 4, "sound driver (AWE32)")) |
| 5920 | goto err_out1; |
| 5921 | return 1; |
| 5922 | err_out1: |
| 5923 | release_region(awe_ports[1], 4); |
| 5924 | err_out: |
| 5925 | release_region(awe_ports[0], 4); |
| 5926 | return 0; |
| 5927 | } |
| 5928 | |
| 5929 | static void |
| 5930 | awe_release_region(void) |
| 5931 | { |
| 5932 | if (! port_setuped) return; |
| 5933 | release_region(awe_ports[0], 4); |
| 5934 | release_region(awe_ports[1], 4); |
| 5935 | release_region(awe_ports[3], 4); |
| 5936 | } |
| 5937 | |
| 5938 | static int awe_attach_device(void) |
| 5939 | { |
| 5940 | if (awe_present) return 0; /* for OSS38.. called twice? */ |
| 5941 | |
| 5942 | /* reserve I/O ports for awedrv */ |
| 5943 | if (! awe_request_region()) { |
| 5944 | printk(KERN_ERR "AWE32: I/O area already used.\n"); |
| 5945 | return 0; |
| 5946 | } |
| 5947 | |
| 5948 | /* set buffers to NULL */ |
| 5949 | sfhead = sftail = NULL; |
| 5950 | |
| 5951 | my_dev = sound_alloc_synthdev(); |
| 5952 | if (my_dev == -1) { |
| 5953 | printk(KERN_ERR "AWE32 Error: too many synthesizers\n"); |
| 5954 | awe_release_region(); |
| 5955 | return 0; |
| 5956 | } |
| 5957 | |
| 5958 | voice_alloc = &awe_operations.alloc; |
| 5959 | voice_alloc->max_voice = awe_max_voices; |
| 5960 | synth_devs[my_dev] = &awe_operations; |
| 5961 | |
| 5962 | #ifdef CONFIG_AWE32_MIXER |
| 5963 | attach_mixer(); |
| 5964 | #endif |
| 5965 | #ifdef CONFIG_AWE32_MIDIEMU |
| 5966 | attach_midiemu(); |
| 5967 | #endif |
| 5968 | |
| 5969 | /* clear all samples */ |
| 5970 | awe_reset_samples(); |
| 5971 | |
| 5972 | /* initialize AWE32 hardware */ |
| 5973 | awe_initialize(); |
| 5974 | |
| 5975 | sprintf(awe_info.name, "AWE32-%s (RAM%dk)", |
| 5976 | AWEDRV_VERSION, memsize/1024); |
| 5977 | printk(KERN_INFO "<SoundBlaster EMU8000 (RAM%dk)>\n", memsize/1024); |
| 5978 | |
| 5979 | awe_present = TRUE; |
| 5980 | |
| 5981 | return 1; |
| 5982 | } |
| 5983 | |
| 5984 | static void awe_dettach_device(void) |
| 5985 | { |
| 5986 | if (awe_present) { |
| 5987 | awe_reset_samples(); |
| 5988 | awe_release_region(); |
| 5989 | free_tables(); |
| 5990 | #ifdef CONFIG_AWE32_MIXER |
| 5991 | unload_mixer(); |
| 5992 | #endif |
| 5993 | #ifdef CONFIG_AWE32_MIDIEMU |
| 5994 | unload_midiemu(); |
| 5995 | #endif |
| 5996 | sound_unload_synthdev(my_dev); |
| 5997 | awe_present = FALSE; |
| 5998 | } |
| 5999 | } |
| 6000 | |
| 6001 | |
| 6002 | /* |
| 6003 | * Legacy device Probing |
| 6004 | */ |
| 6005 | |
| 6006 | /* detect emu8000 chip on the specified address; from VV's guide */ |
| 6007 | |
| 6008 | static int __init |
| 6009 | awe_detect_base(int addr) |
| 6010 | { |
| 6011 | setup_ports(addr, 0, 0); |
| 6012 | if ((awe_peek(AWE_U1) & 0x000F) != 0x000C) |
| 6013 | return 0; |
| 6014 | if ((awe_peek(AWE_HWCF1) & 0x007E) != 0x0058) |
| 6015 | return 0; |
| 6016 | if ((awe_peek(AWE_HWCF2) & 0x0003) != 0x0003) |
| 6017 | return 0; |
| 6018 | DEBUG(0,printk("AWE32 found at %x\n", addr)); |
| 6019 | return 1; |
| 6020 | } |
| 6021 | |
| 6022 | static int __init awe_detect_legacy_devices(void) |
| 6023 | { |
| 6024 | int base; |
| 6025 | for (base = 0x620; base <= 0x680; base += 0x20) |
| 6026 | if (awe_detect_base(base)) { |
| 6027 | awe_attach_device(); |
| 6028 | return 1; |
| 6029 | } |
| 6030 | DEBUG(0,printk("AWE32 Legacy detection failed\n")); |
| 6031 | return 0; |
| 6032 | } |
| 6033 | |
| 6034 | |
| 6035 | /* |
| 6036 | * PnP device Probing |
| 6037 | */ |
| 6038 | |
| 6039 | static struct pnp_device_id awe_pnp_ids[] = { |
| 6040 | {.id = "CTL0021", .driver_data = 0}, /* AWE32 WaveTable */ |
| 6041 | {.id = "CTL0022", .driver_data = 0}, /* AWE64 WaveTable */ |
| 6042 | {.id = "CTL0023", .driver_data = 0}, /* AWE64 Gold WaveTable */ |
| 6043 | { } /* terminator */ |
| 6044 | }; |
| 6045 | |
| 6046 | MODULE_DEVICE_TABLE(pnp, awe_pnp_ids); |
| 6047 | |
| 6048 | static int awe_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id) |
| 6049 | { |
| 6050 | int io1, io2, io3; |
| 6051 | |
| 6052 | if (awe_present) { |
| 6053 | printk(KERN_ERR "AWE32: This driver only supports one AWE32 device, skipping.\n"); |
| 6054 | } |
| 6055 | |
| 6056 | if (!pnp_port_valid(dev,0) || |
| 6057 | !pnp_port_valid(dev,1) || |
| 6058 | !pnp_port_valid(dev,2)) { |
| 6059 | printk(KERN_ERR "AWE32: The PnP device does not have the required resources.\n"); |
| 6060 | return -EINVAL; |
| 6061 | } |
| 6062 | io1 = pnp_port_start(dev,0); |
| 6063 | io2 = pnp_port_start(dev,1); |
| 6064 | io3 = pnp_port_start(dev,2); |
| 6065 | printk(KERN_INFO "AWE32: A PnP Wave Table was detected at IO's %#x,%#x,%#x\n.", |
| 6066 | io1, io2, io3); |
| 6067 | setup_ports(io1, io2, io3); |
| 6068 | |
| 6069 | awe_attach_device(); |
| 6070 | return 0; |
| 6071 | } |
| 6072 | |
| 6073 | static void awe_pnp_remove(struct pnp_dev *dev) |
| 6074 | { |
| 6075 | awe_dettach_device(); |
| 6076 | } |
| 6077 | |
| 6078 | static struct pnp_driver awe_pnp_driver = { |
| 6079 | .name = "AWE32", |
| 6080 | .id_table = awe_pnp_ids, |
| 6081 | .probe = awe_pnp_probe, |
| 6082 | .remove = awe_pnp_remove, |
| 6083 | }; |
| 6084 | |
| 6085 | static int __init awe_detect_pnp_devices(void) |
| 6086 | { |
| 6087 | int ret; |
| 6088 | |
| 6089 | ret = pnp_register_driver(&awe_pnp_driver); |
| 6090 | if (ret<0) |
| 6091 | printk(KERN_ERR "AWE32: PnP support is unavailable.\n"); |
| 6092 | return ret; |
| 6093 | } |
| 6094 | |
| 6095 | |
| 6096 | /* |
| 6097 | * device / lowlevel (module) interface |
| 6098 | */ |
| 6099 | |
| 6100 | static int __init |
| 6101 | awe_detect(void) |
| 6102 | { |
| 6103 | printk(KERN_INFO "AWE32: Probing for WaveTable...\n"); |
| 6104 | if (isapnp) { |
| 6105 | if (awe_detect_pnp_devices()>=0) |
| 6106 | return 1; |
| 6107 | } else |
| 6108 | printk(KERN_INFO "AWE32: Skipping PnP detection.\n"); |
| 6109 | |
| 6110 | if (awe_detect_legacy_devices()) |
| 6111 | return 1; |
| 6112 | |
| 6113 | return 0; |
| 6114 | } |
| 6115 | |
| 6116 | static int __init attach_awe(void) |
| 6117 | { |
| 6118 | return awe_detect() ? 0 : -ENODEV; |
| 6119 | } |
| 6120 | |
| 6121 | static void __exit unload_awe(void) |
| 6122 | { |
| 6123 | pnp_unregister_driver(&awe_pnp_driver); |
| 6124 | awe_dettach_device(); |
| 6125 | } |
| 6126 | |
| 6127 | |
| 6128 | module_init(attach_awe); |
| 6129 | module_exit(unload_awe); |
| 6130 | |
| 6131 | #ifndef MODULE |
| 6132 | static int __init setup_awe(char *str) |
| 6133 | { |
| 6134 | /* io, memsize, isapnp */ |
| 6135 | int ints[4]; |
| 6136 | |
| 6137 | str = get_options(str, ARRAY_SIZE(ints), ints); |
| 6138 | |
| 6139 | io = ints[1]; |
| 6140 | memsize = ints[2]; |
| 6141 | isapnp = ints[3]; |
| 6142 | |
| 6143 | return 1; |
| 6144 | } |
| 6145 | |
| 6146 | __setup("awe=", setup_awe); |
| 6147 | #endif |