开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
awe_wave.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：154k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

awe_wave.c：源码内容
  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.  */
  24. #include <linux/awe_voice.h>
  25. #include <linux/config.h>
  26. #include <linux/init.h>
  27. #include <linux/module.h>
  28. #include <linux/string.h>
  29. #if defined CONFIG_ISAPNP || defined CONFIG_ISAPNP_MODULE
  30. #include <linux/isapnp.h>
  31. #endif
  33. #include "sound_config.h"
  35. #include "awe_wave.h"
  36. #include "awe_hw.h"
  38. #ifdef AWE_HAS_GUS_COMPATIBILITY
  39. #include "tuning.h"
  40. #include <linux/ultrasound.h>
  41. #endif
  43. /*
  44.  * debug message
  45.  */
  47. #ifdef AWE_DEBUG_ON
  48. #define DEBUG(LVL,XXX) {if (ctrls[AWE_MD_DEBUG_MODE] > LVL) { XXX; }}
  49. #define ERRMSG(XXX) {if (ctrls[AWE_MD_DEBUG_MODE]) { XXX; }}
  50. #define FATALERR(XXX) XXX
  51. #else
  52. #define DEBUG(LVL,XXX) /**/
  53. #define ERRMSG(XXX) XXX
  54. #define FATALERR(XXX) XXX
  55. #endif
  57. /*
  58.  * bank and voice record
  59.  */
  61. typedef struct _sf_list sf_list;
  62. typedef struct _awe_voice_list awe_voice_list;
  63. typedef struct _awe_sample_list awe_sample_list;
  65. /* soundfont record */
  66. struct _sf_list {
  67. unsigned short sf_id; /* id number */
  68. unsigned short type; /* lock & shared flags */
  69. int num_info; /* current info table index */
  70. int num_sample; /* current sample table index */
  71. int mem_ptr; /* current word byte pointer */
  72. awe_voice_list *infos, *last_infos; /* instruments */
  73. awe_sample_list *samples, *last_samples; /* samples */
  74. #ifdef AWE_ALLOW_SAMPLE_SHARING
  75. sf_list *shared; /* shared list */
  76. unsigned char name[AWE_PATCH_NAME_LEN]; /* sharing id */
  77. #endif
  78. sf_list *next, *prev;
  79. };
  81. /* instrument list */
  82. struct _awe_voice_list {
  83. awe_voice_info v; /* instrument information */
  84. sf_list *holder; /* parent sf_list of this record */
  85. unsigned char bank, instr; /* preset number information */
  86. char type, disabled; /* type=normal/mapped, disabled=boolean */
  87. awe_voice_list *next; /* linked list with same sf_id */
  88. awe_voice_list *next_instr; /* instrument list */
  89. awe_voice_list *next_bank; /* hash table list */
  90. };
  92. /* voice list type */
  93. #define V_ST_NORMAL 0
  94. #define V_ST_MAPPED 1
  96. /* sample list */
  97. struct _awe_sample_list {
  98. awe_sample_info v; /* sample information */
  99. sf_list *holder; /* parent sf_list of this record */
  100. awe_sample_list *next; /* linked list with same sf_id */
  101. };
  103. /* sample and information table */
  104. static int current_sf_id = 0; /* current number of fonts */
  105. static int locked_sf_id = 0; /* locked position */
  106. static sf_list *sfhead = NULL, *sftail = NULL; /* linked-lists */
  108. #define awe_free_mem_ptr() (sftail ? sftail->mem_ptr : 0)
  109. #define awe_free_info() (sftail ? sftail->num_info : 0)
  110. #define awe_free_sample() (sftail ? sftail->num_sample : 0)
  112. #define AWE_MAX_PRESETS 256
  113. #define AWE_DEFAULT_PRESET 0
  114. #define AWE_DEFAULT_BANK 0
  115. #define AWE_DEFAULT_DRUM 0
  116. #define AWE_DRUM_BANK 128
  118. #define MAX_LAYERS AWE_MAX_VOICES
  120. /* preset table index */
  121. static awe_voice_list *preset_table[AWE_MAX_PRESETS];
  123. /*
  124.  * voice table
  125.  */
  127. /* effects table */
  128. typedef struct FX_Rec { /* channel effects */
  129. unsigned char flags[AWE_FX_END];
  130. short val[AWE_FX_END];
  131. } FX_Rec;
  134. /* channel parameters */
  135. typedef struct _awe_chan_info {
  136. int channel; /* channel number */
  137. int bank; /* current tone bank */
  138. int instr; /* current program */
  139. int bender; /* midi pitchbend (-8192 - 8192) */
  140. int bender_range; /* midi bender range (x100) */
  141. int panning; /* panning (0-127) */
  142. int main_vol; /* channel volume (0-127) */
  143. int expression_vol; /* midi expression (0-127) */
  144. int chan_press; /* channel pressure */
  145. int sustained; /* sustain status in MIDI */
  146. FX_Rec fx; /* effects */
  147. FX_Rec fx_layer[MAX_LAYERS]; /* layer effects */
  148. } awe_chan_info;
  150. /* voice parameters */
  151. typedef struct _voice_info {
  152. int state;
  153. #define AWE_ST_OFF (1<<0) /* no sound */
  154. #define AWE_ST_ON (1<<1) /* playing */
  155. #define AWE_ST_STANDBY (1<<2) /* stand by for playing */
  156. #define AWE_ST_SUSTAINED (1<<3) /* sustained */
  157. #define AWE_ST_MARK (1<<4) /* marked for allocation */
  158. #define AWE_ST_DRAM (1<<5) /* DRAM read/write */
  159. #define AWE_ST_FM (1<<6) /* reserved for FM */
  160. #define AWE_ST_RELEASED (1<<7) /* released */
  162. int ch; /* midi channel */
  163. int key; /* internal key for search */
  164. int layer; /* layer number (for channel mode only) */
  165. int time; /* allocated time */
  166. awe_chan_info *cinfo; /* channel info */
  168. int note; /* midi key (0-127) */
  169. int velocity; /* midi velocity (0-127) */
  170. int sostenuto; /* sostenuto on/off */
  171. awe_voice_info *sample; /* assigned voice */
  173. /* EMU8000 parameters */
  174. int apitch; /* pitch parameter */
  175. int avol; /* volume parameter */
  176. int apan; /* panning parameter */
  177. int acutoff; /* cutoff parameter */
  178. short aaux; /* aux word */
  179. } voice_info;
  181. /* voice information */
  182. static voice_info voices[AWE_MAX_VOICES];
  184. #define IS_NO_SOUND(v) (voices[v].state & (AWE_ST_OFF|AWE_ST_RELEASED|AWE_ST_STANDBY|AWE_ST_SUSTAINED))
  185. #define IS_NO_EFFECT(v) (voices[v].state != AWE_ST_ON)
  186. #define IS_PLAYING(v) (voices[v].state & (AWE_ST_ON|AWE_ST_SUSTAINED|AWE_ST_RELEASED))
  187. #define IS_EMPTY(v) (voices[v].state & (AWE_ST_OFF|AWE_ST_MARK|AWE_ST_DRAM|AWE_ST_FM))
  190. /* MIDI channel effects information (for hw control) */
  191. static awe_chan_info channels[AWE_MAX_CHANNELS];
  194. /*
  195.  * global variables
  196.  */
  198. #ifndef AWE_DEFAULT_BASE_ADDR
  199. #define AWE_DEFAULT_BASE_ADDR 0 /* autodetect */
  200. #endif
  202. #ifndef AWE_DEFAULT_MEM_SIZE
  203. #define AWE_DEFAULT_MEM_SIZE -1 /* autodetect */
  204. #endif
  206. int io = AWE_DEFAULT_BASE_ADDR; /* Emu8000 base address */
  207. int memsize = AWE_DEFAULT_MEM_SIZE; /* memory size in Kbytes */
  208. #if defined CONFIG_ISAPNP || defined CONFIG_ISAPNP_MODULE
  209. static int isapnp = -1;
  210. #else
  211. static int isapnp = 0;
  212. #endif
  214. MODULE_AUTHOR("Takashi Iwai <iwai@ww.uni-erlangen.de>");
  215. MODULE_DESCRIPTION("SB AWE32/64 WaveTable driver");
  216. MODULE_LICENSE("GPL");
  218. MODULE_PARM(io, "i");
  219. MODULE_PARM_DESC(io, "base i/o port of Emu8000");
  220. MODULE_PARM(memsize, "i");
  221. MODULE_PARM_DESC(memsize, "onboard DRAM size in Kbytes");
  222. MODULE_PARM(isapnp, "i");
  223. MODULE_PARM_DESC(isapnp, "use ISAPnP detection");
  224. EXPORT_NO_SYMBOLS;
  226. /* DRAM start offset */
  227. static int awe_mem_start = AWE_DRAM_OFFSET;
  229. /* maximum channels for playing */
  230. static int awe_max_voices = AWE_MAX_VOICES;
  232. static int patch_opened = 0; /* sample already loaded? */
  234. static char atten_relative = FALSE;
  235. static short atten_offset = 0;
  237. static int awe_present = FALSE; /* awe device present? */
  238. static int awe_busy = FALSE; /* awe device opened? */
  240. static int my_dev = -1;
  242. #define DEFAULT_DRUM_FLAGS ((1 << 9) | (1 << 25))
  243. #define IS_DRUM_CHANNEL(c) (drum_flags & (1 << (c)))
  244. #define DRUM_CHANNEL_ON(c) (drum_flags |= (1 << (c)))
  245. #define DRUM_CHANNEL_OFF(c) (drum_flags &= ~(1 << (c)))
  246. static unsigned int drum_flags = DEFAULT_DRUM_FLAGS; /* channel flags */
  248. static int playing_mode = AWE_PLAY_INDIRECT;
  249. #define SINGLE_LAYER_MODE() (playing_mode == AWE_PLAY_INDIRECT || playing_mode == AWE_PLAY_DIRECT)
  250. #define MULTI_LAYER_MODE() (playing_mode == AWE_PLAY_MULTI || playing_mode == AWE_PLAY_MULTI2)
  252. static int current_alloc_time = 0; /* voice allocation index for channel mode */
  254. static struct synth_info awe_info = {
  255. "AWE32 Synth", /* name */
  256. 0, /* device */
  257. SYNTH_TYPE_SAMPLE, /* synth_type */
  258. SAMPLE_TYPE_AWE32, /* synth_subtype */
  259. 0, /* perc_mode (obsolete) */
  260. AWE_MAX_VOICES, /* nr_voices */
  261. 0, /* nr_drums (obsolete) */
  262. 400 /* instr_bank_size */
  263. };
  266. static struct voice_alloc_info *voice_alloc; /* set at initialization */
  269. /*
  270.  * function prototypes
  271.  */
  273. static int awe_check_port(void);
  274. static void awe_request_region(void);
  275. static void awe_release_region(void);
  277. static void awe_reset_samples(void);
  278. /* emu8000 chip i/o access */
  279. static void setup_ports(int p1, int p2, int p3);
  280. static void awe_poke(unsigned short cmd, unsigned short port, unsigned short data);
  281. static void awe_poke_dw(unsigned short cmd, unsigned short port, unsigned int data);
  282. static unsigned short awe_peek(unsigned short cmd, unsigned short port);
  283. static unsigned int awe_peek_dw(unsigned short cmd, unsigned short port);
  284. static void awe_wait(unsigned short delay);
  286. /* initialize emu8000 chip */
  287. static int _attach_awe(void);
  288. static void _unload_awe(void);
  289. static void awe_initialize(void);
  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 */
  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);
  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);
  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, caddr_t 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 *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);
  356. #define awe_key_pressure(dev,voice,key,press) awe_start_note(dev,voice,(key)+128,press)
  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);
  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);
  376. /* load / remove patches */
  377. static int awe_open_patch(awe_patch_info *patch, const char *addr, int count);
  378. static int awe_close_patch(awe_patch_info *patch, const char *addr, int count);
  379. static int awe_unload_patch(awe_patch_info *patch, const char *addr, int count);
  380. static int awe_load_info(awe_patch_info *patch, const char *addr, int count);
  381. static int awe_remove_info(awe_patch_info *patch, const char *addr, int count);
  382. static int awe_load_data(awe_patch_info *patch, const char *addr, int count);
  383. static int awe_replace_data(awe_patch_info *patch, const char *addr, int count);
  384. static int awe_load_map(awe_patch_info *patch, const char *addr, int count);
  385. #ifdef AWE_HAS_GUS_COMPATIBILITY
  386. static int awe_load_guspatch(const char *addr, int offs, int size, int pmgr_flag);
  387. #endif
  388. /*static int awe_probe_info(awe_patch_info *patch, const char *addr, int count);*/
  389. static int awe_probe_data(awe_patch_info *patch, const char *addr, int count);
  390. static sf_list *check_patch_opened(int type, char *name);
  391. static int awe_write_wave_data(const char *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);
  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 */
  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 *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 *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);
  434. #ifdef CONFIG_AWE32_MIXER
  435. static void attach_mixer(void);
  436. static void unload_mixer(void);
  437. #endif
  439. #ifdef CONFIG_AWE32_MIDIEMU
  440. static void attach_midiemu(void);
  441. static void unload_midiemu(void);
  442. #endif
  444. #define limitvalue(x, a, b) if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b)
  446. /*
  447.  * control parameters
  448.  */
  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 */
  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
  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. };
  491. static int ctrls[AWE_MD_END];
  494. /*
  495.  * synth operation table
  496.  */
  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. };
  525. /*
  526.  * General attach / unload interface
  527.  */
  529. static int __init _attach_awe(void)
  530. {
  531. if (awe_present) return 0; /* for OSS38.. called twice? */
  533. /* check presence of AWE32 card */
  534. if (! awe_detect()) {
  535. printk(KERN_ERR "AWE32: not detectedn");
  536. return 0;
  537. }
  539. /* check AWE32 ports are available */
  540. if (awe_check_port()) {
  541. printk(KERN_ERR "AWE32: I/O area already used.n");
  542. return 0;
  543. }
  545. /* set buffers to NULL */
  546. sfhead = sftail = NULL;
  548. my_dev = sound_alloc_synthdev();
  549. if (my_dev == -1) {
  550. printk(KERN_ERR "AWE32 Error: too many synthesizersn");
  551. return 0;
  552. }
  554. voice_alloc = &awe_operations.alloc;
  555. voice_alloc->max_voice = awe_max_voices;
  556. synth_devs[my_dev] = &awe_operations;
  558. #ifdef CONFIG_AWE32_MIXER
  559. attach_mixer();
  560. #endif
  561. #ifdef CONFIG_AWE32_MIDIEMU
  562. attach_midiemu();
  563. #endif
  565. /* reserve I/O ports for awedrv */
  566. awe_request_region();
  568. /* clear all samples */
  569. awe_reset_samples();
  571. /* intialize AWE32 hardware */
  572. awe_initialize();
  574. sprintf(awe_info.name, "AWE32-%s (RAM%dk)",
  575. AWEDRV_VERSION, memsize/1024);
  576. printk(KERN_INFO "<SoundBlaster EMU8000 (RAM%dk)>n", memsize/1024);
  578. awe_present = TRUE;
  580. return 1;
  581. }
  584. static void free_tables(void)
  585. {
  586. if (sftail) {
  587. sf_list *p, *prev;
  588. for (p = sftail; p; p = prev) {
  589. prev = p->prev;
  590. awe_free_sf(p);
  591. }
  592. }
  593. sfhead = sftail = NULL;
  594. }
  597. static void __exit _unload_awe(void)
  598. {
  599. if (awe_present) {
  600. awe_reset_samples();
  601. awe_release_region();
  602. free_tables();
  603. #ifdef CONFIG_AWE32_MIXER
  604. unload_mixer();
  605. #endif
  606. #ifdef CONFIG_AWE32_MIDIEMU
  607. unload_midiemu();
  608. #endif
  609. sound_unload_synthdev(my_dev);
  610. awe_present = FALSE;
  611. }
  612. }
  615. /*
  616.  * clear sample tables 
  617.  */
  619. static void
  620. awe_reset_samples(void)
  621. {
  622. /* free all bank tables */
  623. memset(preset_table, 0, sizeof(preset_table));
  624. free_tables();
  626. current_sf_id = 0;
  627. locked_sf_id = 0;
  628. patch_opened = 0;
  629. }
  632. /*
  633.  * EMU register access
  634.  */
  636. /* select a given AWE32 pointer */
  637. static int awe_ports[5];
  638. static int port_setuped = FALSE;
  639. static int awe_cur_cmd = -1;
  640. #define awe_set_cmd(cmd) 
  641. if (awe_cur_cmd != cmd) { outw(cmd, awe_ports[Pointer]); awe_cur_cmd = cmd; }
  643. /* store values to i/o port array */
  644. static void setup_ports(int port1, int port2, int port3)
  645. {
  646. awe_ports[0] = port1;
  647. if (port2 == 0)
  648. port2 = port1 + 0x400;
  649. awe_ports[1] = port2;
  650. awe_ports[2] = port2 + 2;
  651. if (port3 == 0)
  652. port3 = port1 + 0x800;
  653. awe_ports[3] = port3;
  654. awe_ports[4] = port3 + 2;
  656. port_setuped = TRUE;
  657. }
  659. /* write 16bit data */
  660. static void
  661. awe_poke(unsigned short cmd, unsigned short port, unsigned short data)
  662. {
  663. awe_set_cmd(cmd);
  664. outw(data, awe_ports[port]);
  665. }
  667. /* write 32bit data */
  668. static void
  669. awe_poke_dw(unsigned short cmd, unsigned short port, unsigned int data)
  670. {
  671. unsigned short addr = awe_ports[port];
  672. awe_set_cmd(cmd);
  673. outw(data, addr); /* write lower 16 bits */
  674. outw(data >> 16, addr + 2); /* write higher 16 bits */
  675. }
  677. /* read 16bit data */
  678. static unsigned short
  679. awe_peek(unsigned short cmd, unsigned short port)
  680. {
  681. unsigned short k;
  682. awe_set_cmd(cmd);
  683. k = inw(awe_ports[port]);
  684. return k;
  685. }
  687. /* read 32bit data */
  688. static unsigned int
  689. awe_peek_dw(unsigned short cmd, unsigned short port)
  690. {
  691. unsigned int k1, k2;
  692. unsigned short addr = awe_ports[port];
  693. awe_set_cmd(cmd);
  694. k1 = inw(addr);
  695. k2 = inw(addr + 2);
  696. k1 |= k2 << 16;
  697. return k1;
  698. }
  700. /* wait delay number of AWE32 44100Hz clocks */
  701. #ifdef WAIT_BY_LOOP /* wait by loop -- that's not good.. */
  702. static void
  703. awe_wait(unsigned short delay)
  704. {
  705. unsigned short clock, target;
  706. unsigned short port = awe_ports[AWE_WC_Port];
  707. int counter;
  708.   
  709. /* sample counter */
  710. awe_set_cmd(AWE_WC_Cmd);
  711. clock = (unsigned short)inw(port);
  712. target = clock + delay;
  713. counter = 0;
  714. if (target < clock) {
  715. for (; (unsigned short)inw(port) > target; counter++)
  716. if (counter > 65536)
  717. break;
  718. }
  719. for (; (unsigned short)inw(port) < target; counter++)
  720. if (counter > 65536)
  721. break;
  722. }
  723. #else
  725. static void awe_wait(unsigned short delay)
  726. {
  727. current->state = TASK_INTERRUPTIBLE;
  728. schedule_timeout((HZ*(unsigned long)delay + 44099)/44100);
  729. }
  730. /*
  731. static void awe_wait(unsigned short delay)
  732. {
  733. udelay(((unsigned long)delay * 1000000L + 44099) / 44100);
  734. }
  735. */
  736. #endif /* wait by loop */
  738. /* write a word data */
  739. #define awe_write_dram(c) awe_poke(AWE_SMLD, c)
  742. /*
  743.  * port check / request
  744.  *  0x620-623, 0xA20-A23, 0xE20-E23
  745.  */
  747. static int __init
  748. awe_check_port(void)
  749. {
  750. if (! port_setuped) return 0;
  751. return (check_region(awe_ports[0], 4) ||
  752. check_region(awe_ports[1], 4) ||
  753. check_region(awe_ports[3], 4));
  754. }
  756. static void __init
  757. awe_request_region(void)
  758. {
  759. if (! port_setuped) return;
  760. request_region(awe_ports[0], 4, "sound driver (AWE32)");
  761. request_region(awe_ports[1], 4, "sound driver (AWE32)");
  762. request_region(awe_ports[3], 4, "sound driver (AWE32)");
  763. }
  765. static void __exit
  766. awe_release_region(void)
  767. {
  768. if (! port_setuped) return;
  769. release_region(awe_ports[0], 4);
  770. release_region(awe_ports[1], 4);
  771. release_region(awe_ports[3], 4);
  772. }
  775. /*
  776.  * initialization of AWE driver
  777.  */
  779. static void
  780. awe_initialize(void)
  781. {
  782. DEBUG(0,printk("AWE32: initializing..n"));
  784. /* initialize hardware configuration */
  785. awe_poke(AWE_HWCF1, 0x0059);
  786. awe_poke(AWE_HWCF2, 0x0020);
  788. /* disable audio; this seems to reduce a clicking noise a bit.. */
  789. awe_poke(AWE_HWCF3, 0);
  791. /* initialize audio channels */
  792. awe_init_audio();
  794. /* initialize DMA */
  795. awe_init_dma();
  797. /* initialize init array */
  798. awe_init_array();
  800. /* check DRAM memory size */
  801. awe_check_dram();
  803. /* initialize the FM section of the AWE32 */
  804. awe_init_fm();
  806. /* set up voice envelopes */
  807. awe_tweak();
  809. /* enable audio */
  810. awe_poke(AWE_HWCF3, 0x0004);
  812. /* set default values */
  813. awe_init_ctrl_parms(TRUE);
  815. /* set equalizer */
  816. awe_update_equalizer();
  818. /* set reverb & chorus modes */
  819. awe_update_reverb_mode();
  820. awe_update_chorus_mode();
  821. }
  824. /*
  825.  * AWE32 voice parameters
  826.  */
  828. /* initialize voice_info record */
  829. static void
  830. awe_init_voice_info(awe_voice_info *vp)
  831. {
  832. vp->sample = 0;
  833. vp->rate_offset = 0;
  835. vp->start = 0;
  836. vp->end = 0;
  837. vp->loopstart = 0;
  838. vp->loopend = 0;
  839. vp->mode = 0;
  840. vp->root = 60;
  841. vp->tune = 0;
  842. vp->low = 0;
  843. vp->high = 127;
  844. vp->vellow = 0;
  845. vp->velhigh = 127;
  847. vp->fixkey = -1;
  848. vp->fixvel = -1;
  849. vp->fixpan = -1;
  850. vp->pan = -1;
  852. vp->exclusiveClass = 0;
  853. vp->amplitude = 127;
  854. vp->attenuation = 0;
  855. vp->scaleTuning = 100;
  857. awe_init_voice_parm(&vp->parm);
  858. }
  860. /* initialize voice_parm record:
  861.  * Env1/2: delay=0, attack=0, hold=0, sustain=0, decay=0, release=0.
  862.  * Vibrato and Tremolo effects are zero.
  863.  * Cutoff is maximum.
  864.  * Chorus and Reverb effects are zero.
  865.  */
  866. static void
  867. awe_init_voice_parm(awe_voice_parm *pp)
  868. {
  869. pp->moddelay = 0x8000;
  870. pp->modatkhld = 0x7f7f;
  871. pp->moddcysus = 0x7f7f;
  872. pp->modrelease = 0x807f;
  873. pp->modkeyhold = 0;
  874. pp->modkeydecay = 0;
  876. pp->voldelay = 0x8000;
  877. pp->volatkhld = 0x7f7f;
  878. pp->voldcysus = 0x7f7f;
  879. pp->volrelease = 0x807f;
  880. pp->volkeyhold = 0;
  881. pp->volkeydecay = 0;
  883. pp->lfo1delay = 0x8000;
  884. pp->lfo2delay = 0x8000;
  885. pp->pefe = 0;
  887. pp->fmmod = 0;
  888. pp->tremfrq = 0;
  889. pp->fm2frq2 = 0;
  891. pp->cutoff = 0xff;
  892. pp->filterQ = 0;
  894. pp->chorus = 0;
  895. pp->reverb = 0;
  896. }
  899. #ifdef AWE_HAS_GUS_COMPATIBILITY
  901. /* convert frequency mHz to abstract cents (= midi key * 100) */
  902. static int
  903. freq_to_note(int mHz)
  904. {
  905. /* abscents = log(mHz/8176) / log(2) * 1200 */
  906. unsigned int max_val = (unsigned int)0xffffffff / 10000;
  907. int i, times;
  908. unsigned int base;
  909. unsigned int freq;
  910. int note, tune;
  912. if (mHz == 0)
  913. return 0;
  914. if (mHz < 0)
  915. return 12799; /* maximum */
  917. freq = mHz;
  918. note = 0;
  919. for (base = 8176 * 2; freq >= base; base *= 2) {
  920. note += 12;
  921. if (note >= 128) /* over maximum */
  922. return 12799;
  923. }
  924. base /= 2;
  926. /* to avoid overflow... */
  927. times = 10000;
  928. while (freq > max_val) {
  929. max_val *= 10;
  930. times /= 10;
  931. base /= 10;
  932. }
  934. freq = freq * times / base;
  935. for (i = 0; i < 12; i++) {
  936. if (freq < semitone_tuning[i+1])
  937. break;
  938. note++;
  939. }
  941. tune = 0;
  942. freq = freq * 10000 / semitone_tuning[i];
  943. for (i = 0; i < 100; i++) {
  944. if (freq < cent_tuning[i+1])
  945. break;
  946. tune++;
  947. }
  949. return note * 100 + tune;
  950. }
  953. /* convert Hz to AWE32 rate offset:
  954.  * sample pitch offset for the specified sample rate
  955.  * rate=44100 is no offset, each 4096 is 1 octave (twice).
  956.  * eg, when rate is 22050, this offset becomes -4096.
  957.  */
  958. static int
  959. calc_rate_offset(int Hz)
  960. {
  961. /* offset = log(Hz / 44100) / log(2) * 4096 */
  962. int freq, base, i;
  964. /* maybe smaller than max (44100Hz) */
  965. if (Hz <= 0 || Hz >= 44100) return 0;
  967. base = 0;
  968. for (freq = Hz * 2; freq < 44100; freq *= 2)
  969. base++;
  970. base *= 1200;
  972. freq = 44100 * 10000 / (freq/2);
  973. for (i = 0; i < 12; i++) {
  974. if (freq < semitone_tuning[i+1])
  975. break;
  976. base += 100;
  977. }
  978. freq = freq * 10000 / semitone_tuning[i];
  979. for (i = 0; i < 100; i++) {
  980. if (freq < cent_tuning[i+1])
  981. break;
  982. base++;
  983. }
  984. return -base * 4096 / 1200;
  985. }
  988. /*
  989.  * convert envelope time parameter to AWE32 raw parameter
  990.  */
  992. /* attack & decay/release time table (msec) */
  993. static short attack_time_tbl[128] = {
  994. 32767, 32767, 5989, 4235, 2994, 2518, 2117, 1780, 1497, 1373, 1259, 1154, 1058, 970, 890, 816,
  995. 707, 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377,
  996. 361, 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188,
  997. 180, 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94,
  998. 90, 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47,
  999. 45, 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23,
  1000. 22, 21, 20, 19, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12,
  1001. 11, 11, 10, 10, 10, 9, 9, 8, 8, 8, 8, 7, 7, 7, 6, 0,
  1002. };
  1004. static short decay_time_tbl[128] = {
  1005. 32767, 32767, 22614, 15990, 11307, 9508, 7995, 6723, 5653, 5184, 4754, 4359, 3997, 3665, 3361, 3082,
  1006. 2828, 2765, 2648, 2535, 2428, 2325, 2226, 2132, 2042, 1955, 1872, 1793, 1717, 1644, 1574, 1507,
  1007. 1443, 1382, 1324, 1267, 1214, 1162, 1113, 1066, 978, 936, 897, 859, 822, 787, 754, 722,
  1008. 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, 361,
  1009. 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, 180,
  1010. 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, 90,
  1011. 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, 45,
  1012. 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, 22,
  1013. };
  1015. #define calc_parm_delay(msec) (0x8000 - (msec) * 1000 / 725);
  1017. /* delay time = 0x8000 - msec/92 */
  1018. static int
  1019. calc_parm_hold(int msec)
  1020. {
  1021. int val = (0x7f * 92 - msec) / 92;
  1022. if (val < 1) val = 1;
  1023. if (val > 127) val = 127;
  1024. return val;
  1025. }
  1027. /* attack time: search from time table */
  1028. static int
  1029. calc_parm_attack(int msec)
  1030. {
  1031. return calc_parm_search(msec, attack_time_tbl);
  1032. }
  1034. /* decay/release time: search from time table */
  1035. static int
  1036. calc_parm_decay(int msec)
  1037. {
  1038. return calc_parm_search(msec, decay_time_tbl);
  1039. }
  1041. /* search an index for specified time from given time table */
  1042. static int
  1043. calc_parm_search(int msec, short *table)
  1044. {
  1045. int left = 1, right = 127, mid;
  1046. while (left < right) {
  1047. mid = (left + right) / 2;
  1048. if (msec < (int)table[mid])
  1049. left = mid + 1;
  1050. else
  1051. right = mid;
  1052. }
  1053. return left;
  1054. }
  1055. #endif /* AWE_HAS_GUS_COMPATIBILITY */
  1058. /*
  1059.  * effects table
  1060.  */
  1062. /* set an effect value */
  1063. #define FX_FLAG_OFF 0
  1064. #define FX_FLAG_SET 1
  1065. #define FX_FLAG_ADD 2
  1067. #define FX_SET(rec,type,value) 
  1068. ((rec)->flags[type] = FX_FLAG_SET, (rec)->val[type] = (value))
  1069. #define FX_ADD(rec,type,value) 
  1070. ((rec)->flags[type] = FX_FLAG_ADD, (rec)->val[type] = (value))
  1071. #define FX_UNSET(rec,type) 
  1072. ((rec)->flags[type] = FX_FLAG_OFF, (rec)->val[type] = 0)
  1074. /* check the effect value is set */
  1075. #define FX_ON(rec,type) ((rec)->flags[type])
  1077. #define PARM_BYTE 0
  1078. #define PARM_WORD 1
  1079. #define PARM_SIGN 2
  1081. static struct PARM_DEFS {
  1082. int type; /* byte or word */
  1083. int low, high; /* value range */
  1084. fx_affect_func realtime; /* realtime paramater change */
  1085. } parm_defs[] = {
  1086. {PARM_WORD, 0, 0x8000, NULL}, /* env1 delay */
  1087. {PARM_BYTE, 1, 0x7f, NULL}, /* env1 attack */
  1088. {PARM_BYTE, 0, 0x7e, NULL}, /* env1 hold */
  1089. {PARM_BYTE, 1, 0x7f, NULL}, /* env1 decay */
  1090. {PARM_BYTE, 1, 0x7f, NULL}, /* env1 release */
  1091. {PARM_BYTE, 0, 0x7f, NULL}, /* env1 sustain */
  1092. {PARM_BYTE, 0, 0xff, NULL}, /* env1 pitch */
  1093. {PARM_BYTE, 0, 0xff, NULL}, /* env1 cutoff */
  1095. {PARM_WORD, 0, 0x8000, NULL}, /* env2 delay */
  1096. {PARM_BYTE, 1, 0x7f, NULL}, /* env2 attack */
  1097. {PARM_BYTE, 0, 0x7e, NULL}, /* env2 hold */
  1098. {PARM_BYTE, 1, 0x7f, NULL}, /* env2 decay */
  1099. {PARM_BYTE, 1, 0x7f, NULL}, /* env2 release */
  1100. {PARM_BYTE, 0, 0x7f, NULL}, /* env2 sustain */
  1102. {PARM_WORD, 0, 0x8000, NULL}, /* lfo1 delay */
  1103. {PARM_BYTE, 0, 0xff, awe_fx_tremfrq}, /* lfo1 freq */
  1104. {PARM_SIGN, -128, 127, awe_fx_tremfrq}, /* lfo1 volume */
  1105. {PARM_SIGN, -128, 127, awe_fx_fmmod}, /* lfo1 pitch */
  1106. {PARM_BYTE, 0, 0xff, awe_fx_fmmod}, /* lfo1 cutoff */
  1108. {PARM_WORD, 0, 0x8000, NULL}, /* lfo2 delay */
  1109. {PARM_BYTE, 0, 0xff, awe_fx_fm2frq2}, /* lfo2 freq */
  1110. {PARM_SIGN, -128, 127, awe_fx_fm2frq2}, /* lfo2 pitch */
  1112. {PARM_WORD, 0, 0xffff, awe_set_voice_pitch}, /* initial pitch */
  1113. {PARM_BYTE, 0, 0xff, NULL}, /* chorus */
  1114. {PARM_BYTE, 0, 0xff, NULL}, /* reverb */
  1115. {PARM_BYTE, 0, 0xff, awe_set_volume}, /* initial cutoff */
  1116. {PARM_BYTE, 0, 15, awe_fx_filterQ}, /* initial resonance */
  1118. {PARM_WORD, 0, 0xffff, NULL}, /* sample start */
  1119. {PARM_WORD, 0, 0xffff, NULL}, /* loop start */
  1120. {PARM_WORD, 0, 0xffff, NULL}, /* loop end */
  1121. {PARM_WORD, 0, 0xffff, NULL}, /* coarse sample start */
  1122. {PARM_WORD, 0, 0xffff, NULL}, /* coarse loop start */
  1123. {PARM_WORD, 0, 0xffff, NULL}, /* coarse loop end */
  1124. {PARM_BYTE, 0, 0xff, awe_set_volume}, /* initial attenuation */
  1125. };
  1128. static unsigned char
  1129. FX_BYTE(FX_Rec *rec, FX_Rec *lay, int type, unsigned char value)
  1130. {
  1131. int effect = 0;
  1132. int on = 0;
  1133. if (lay && (on = FX_ON(lay, type)) != 0)
  1134. effect = lay->val[type];
  1135. if (!on && (on = FX_ON(rec, type)) != 0)
  1136. effect = rec->val[type];
  1137. if (on == FX_FLAG_ADD) {
  1138. if (parm_defs[type].type == PARM_SIGN) {
  1139. if (value > 0x7f)
  1140. effect += (int)value - 0x100;
  1141. else
  1142. effect += (int)value;
  1143. } else {
  1144. effect += (int)value;
  1145. }
  1146. }
  1147. if (on) {
  1148. if (effect < parm_defs[type].low)
  1149. effect = parm_defs[type].low;
  1150. else if (effect > parm_defs[type].high)
  1151. effect = parm_defs[type].high;
  1152. return (unsigned char)effect;
  1153. }
  1154. return value;
  1155. }
  1157. /* get word effect value */
  1158. static unsigned short
  1159. FX_WORD(FX_Rec *rec, FX_Rec *lay, int type, unsigned short value)
  1160. {
  1161. int effect = 0;
  1162. int on = 0;
  1163. if (lay && (on = FX_ON(lay, type)) != 0)
  1164. effect = lay->val[type];
  1165. if (!on && (on = FX_ON(rec, type)) != 0)
  1166. effect = rec->val[type];
  1167. if (on == FX_FLAG_ADD)
  1168. effect += (int)value;
  1169. if (on) {
  1170. if (effect < parm_defs[type].low)
  1171. effect = parm_defs[type].low;
  1172. else if (effect > parm_defs[type].high)
  1173. effect = parm_defs[type].high;
  1174. return (unsigned short)effect;
  1175. }
  1176. return value;
  1177. }
  1179. /* get word (upper=type1/lower=type2) effect value */
  1180. static unsigned short
  1181. FX_COMB(FX_Rec *rec, FX_Rec *lay, int type1, int type2, unsigned short value)
  1182. {
  1183. unsigned short tmp;
  1184. tmp = FX_BYTE(rec, lay, type1, (unsigned char)(value >> 8));
  1185. tmp <<= 8;
  1186. tmp |= FX_BYTE(rec, lay, type2, (unsigned char)(value & 0xff));
  1187. return tmp;
  1188. }
  1190. /* address offset */
  1191. static int
  1192. FX_OFFSET(FX_Rec *rec, FX_Rec *lay, int lo, int hi, int mode)
  1193. {
  1194. int addr = 0;
  1195. if (lay && FX_ON(lay, hi))
  1196. addr = (short)lay->val[hi];
  1197. else if (FX_ON(rec, hi))
  1198. addr = (short)rec->val[hi];
  1199. addr = addr << 15;
  1200. if (lay && FX_ON(lay, lo))
  1201. addr += (short)lay->val[lo];
  1202. else if (FX_ON(rec, lo))
  1203. addr += (short)rec->val[lo];
  1204. if (!(mode & AWE_SAMPLE_8BITS))
  1205. addr /= 2;
  1206. return addr;
  1207. }
  1210. /*
  1211.  * turn on/off sample
  1212.  */
  1214. /* table for volume target calculation */
  1215. static unsigned short voltarget[16] = { 
  1216.    0xEAC0, 0XE0C8, 0XD740, 0XCE20, 0XC560, 0XBD08, 0XB500, 0XAD58,
  1217.    0XA5F8, 0X9EF0, 0X9830, 0X91C0, 0X8B90, 0X85A8, 0X8000, 0X7A90
  1218. };
  1220. static void
  1221. awe_note_on(int voice)
  1222. {
  1223. unsigned int temp;
  1224. int addr;
  1225. int vtarget, ftarget, ptarget, pitch;
  1226. awe_voice_info *vp;
  1227. awe_voice_parm_block *parm;
  1228. FX_Rec *fx = &voices[voice].cinfo->fx;
  1229. FX_Rec *fx_lay = NULL;
  1230. if (voices[voice].layer < MAX_LAYERS)
  1231. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1233. /* A voice sample must assigned before calling */
  1234. if ((vp = voices[voice].sample) == NULL || vp->index == 0)
  1235. return;
  1237. parm = (awe_voice_parm_block*)&vp->parm;
  1239. /* channel to be silent and idle */
  1240. awe_poke(AWE_DCYSUSV(voice), 0x0080);
  1241. awe_poke(AWE_VTFT(voice), 0x0000FFFF);
  1242. awe_poke(AWE_CVCF(voice), 0x0000FFFF);
  1243. awe_poke(AWE_PTRX(voice), 0);
  1244. awe_poke(AWE_CPF(voice), 0);
  1246. /* set pitch offset */
  1247. awe_set_pitch(voice, TRUE);
  1249. /* modulation & volume envelope */
  1250. if (parm->modatk >= 0x80 && parm->moddelay >= 0x8000) {
  1251. awe_poke(AWE_ENVVAL(voice), 0xBFFF);
  1252. pitch = (parm->env1pit<<4) + voices[voice].apitch;
  1253. if (pitch > 0xffff) pitch = 0xffff;
  1254. /* calculate filter target */
  1255. ftarget = parm->cutoff + parm->env1fc;
  1256. limitvalue(ftarget, 0, 255);
  1257. ftarget <<= 8;
  1258. } else {
  1259. awe_poke(AWE_ENVVAL(voice),
  1260.  FX_WORD(fx, fx_lay, AWE_FX_ENV1_DELAY, parm->moddelay));
  1261. ftarget = parm->cutoff;
  1262. ftarget <<= 8;
  1263. pitch = voices[voice].apitch;
  1264. }
  1266. /* calcualte pitch target */
  1267. if (pitch != 0xffff) {
  1268. ptarget = 1 << (pitch >> 12);
  1269. if (pitch & 0x800) ptarget += (ptarget*0x102e)/0x2710;
  1270. if (pitch & 0x400) ptarget += (ptarget*0x764)/0x2710;
  1271. if (pitch & 0x200) ptarget += (ptarget*0x389)/0x2710;
  1272. ptarget += (ptarget>>1);
  1273. if (ptarget > 0xffff) ptarget = 0xffff;
  1275. } else ptarget = 0xffff;
  1276. if (parm->modatk >= 0x80)
  1277. awe_poke(AWE_ATKHLD(voice),
  1278.  FX_BYTE(fx, fx_lay, AWE_FX_ENV1_HOLD, parm->modhld) << 8 | 0x7f);
  1279. else
  1280. awe_poke(AWE_ATKHLD(voice),
  1281.  FX_COMB(fx, fx_lay, AWE_FX_ENV1_HOLD, AWE_FX_ENV1_ATTACK,
  1282.  vp->parm.modatkhld));
  1283. awe_poke(AWE_DCYSUS(voice),
  1284.  FX_COMB(fx, fx_lay, AWE_FX_ENV1_SUSTAIN, AWE_FX_ENV1_DECAY,
  1285.   vp->parm.moddcysus));
  1287. if (parm->volatk >= 0x80 && parm->voldelay >= 0x8000) {
  1288. awe_poke(AWE_ENVVOL(voice), 0xBFFF);
  1289. vtarget = voltarget[voices[voice].avol%0x10]>>(voices[voice].avol>>4);
  1290. } else {
  1291. awe_poke(AWE_ENVVOL(voice),
  1292.  FX_WORD(fx, fx_lay, AWE_FX_ENV2_DELAY, vp->parm.voldelay));
  1293. vtarget = 0;
  1294. }
  1295. if (parm->volatk >= 0x80)
  1296. awe_poke(AWE_ATKHLDV(voice),
  1297.  FX_BYTE(fx, fx_lay, AWE_FX_ENV2_HOLD, parm->volhld) << 8 | 0x7f);
  1298. else
  1299. awe_poke(AWE_ATKHLDV(voice),
  1300.  FX_COMB(fx, fx_lay, AWE_FX_ENV2_HOLD, AWE_FX_ENV2_ATTACK,
  1301.  vp->parm.volatkhld));
  1302. /* decay/sustain parameter for volume envelope must be set at last */
  1304. /* cutoff and volume */
  1305. awe_set_volume(voice, TRUE);
  1307. /* modulation envelope heights */
  1308. awe_poke(AWE_PEFE(voice),
  1309.  FX_COMB(fx, fx_lay, AWE_FX_ENV1_PITCH, AWE_FX_ENV1_CUTOFF,
  1310.  vp->parm.pefe));
  1312. /* lfo1/2 delay */
  1313. awe_poke(AWE_LFO1VAL(voice),
  1314.  FX_WORD(fx, fx_lay, AWE_FX_LFO1_DELAY, vp->parm.lfo1delay));
  1315. awe_poke(AWE_LFO2VAL(voice),
  1316.  FX_WORD(fx, fx_lay, AWE_FX_LFO2_DELAY, vp->parm.lfo2delay));
  1318. /* lfo1 pitch & cutoff shift */
  1319. awe_fx_fmmod(voice, TRUE);
  1320. /* lfo1 volume & freq */
  1321. awe_fx_tremfrq(voice, TRUE);
  1322. /* lfo2 pitch & freq */
  1323. awe_fx_fm2frq2(voice, TRUE);
  1324. /* pan & loop start */
  1325. awe_set_pan(voice, TRUE);
  1327. /* chorus & loop end (chorus 8bit, MSB) */
  1328. addr = vp->loopend - 1;
  1329. addr += FX_OFFSET(fx, fx_lay, AWE_FX_LOOP_END,
  1330.   AWE_FX_COARSE_LOOP_END, vp->mode);
  1331. temp = FX_BYTE(fx, fx_lay, AWE_FX_CHORUS, vp->parm.chorus);
  1332. temp = (temp <<24) | (unsigned int)addr;
  1333. awe_poke_dw(AWE_CSL(voice), temp);
  1334. DEBUG(4,printk("AWE32: [-- loopend=%x/%x]n", vp->loopend, addr));
  1336. /* Q & current address (Q 4bit value, MSB) */
  1337. addr = vp->start - 1;
  1338. addr += FX_OFFSET(fx, fx_lay, AWE_FX_SAMPLE_START,
  1339.   AWE_FX_COARSE_SAMPLE_START, vp->mode);
  1340. temp = FX_BYTE(fx, fx_lay, AWE_FX_FILTERQ, vp->parm.filterQ);
  1341. temp = (temp<<28) | (unsigned int)addr;
  1342. awe_poke_dw(AWE_CCCA(voice), temp);
  1343. DEBUG(4,printk("AWE32: [-- startaddr=%x/%x]n", vp->start, addr));
  1345. /* clear unknown registers */
  1346. awe_poke_dw(AWE_00A0(voice), 0);
  1347. awe_poke_dw(AWE_0080(voice), 0);
  1349. /* reset volume */
  1350. awe_poke_dw(AWE_VTFT(voice), (vtarget<<16)|ftarget);
  1351. awe_poke_dw(AWE_CVCF(voice), (vtarget<<16)|ftarget);
  1353. /* set reverb */
  1354. temp = FX_BYTE(fx, fx_lay, AWE_FX_REVERB, vp->parm.reverb);
  1355. temp = (temp << 8) | (ptarget << 16) | voices[voice].aaux;
  1356. awe_poke_dw(AWE_PTRX(voice), temp);
  1357. awe_poke_dw(AWE_CPF(voice), ptarget << 16);
  1358. /* turn on envelope */
  1359. awe_poke(AWE_DCYSUSV(voice),
  1360.  FX_COMB(fx, fx_lay, AWE_FX_ENV2_SUSTAIN, AWE_FX_ENV2_DECAY,
  1361.   vp->parm.voldcysus));
  1363. voices[voice].state = AWE_ST_ON;
  1365. /* clear voice position for the next note on this channel */
  1366. if (SINGLE_LAYER_MODE()) {
  1367. FX_UNSET(fx, AWE_FX_SAMPLE_START);
  1368. FX_UNSET(fx, AWE_FX_COARSE_SAMPLE_START);
  1369. }
  1370. }
  1373. /* turn off the voice */
  1374. static void
  1375. awe_note_off(int voice)
  1376. {
  1377. awe_voice_info *vp;
  1378. unsigned short tmp;
  1379. FX_Rec *fx = &voices[voice].cinfo->fx;
  1380. FX_Rec *fx_lay = NULL;
  1381. if (voices[voice].layer < MAX_LAYERS)
  1382. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1384. if ((vp = voices[voice].sample) == NULL) {
  1385. voices[voice].state = AWE_ST_OFF;
  1386. return;
  1387. }
  1389. tmp = 0x8000 | FX_BYTE(fx, fx_lay, AWE_FX_ENV1_RELEASE,
  1390.        (unsigned char)vp->parm.modrelease);
  1391. awe_poke(AWE_DCYSUS(voice), tmp);
  1392. tmp = 0x8000 | FX_BYTE(fx, fx_lay, AWE_FX_ENV2_RELEASE,
  1393.        (unsigned char)vp->parm.volrelease);
  1394. awe_poke(AWE_DCYSUSV(voice), tmp);
  1395. voices[voice].state = AWE_ST_RELEASED;
  1396. }
  1398. /* force to terminate the voice (no releasing echo) */
  1399. static void
  1400. awe_terminate(int voice)
  1401. {
  1402. awe_poke(AWE_DCYSUSV(voice), 0x807F);
  1403. awe_tweak_voice(voice);
  1404. voices[voice].state = AWE_ST_OFF;
  1405. }
  1407. /* turn off other voices with the same exclusive class (for drums) */
  1408. static void
  1409. awe_exclusive_off(int voice)
  1410. {
  1411. int i, exclass;
  1413. if (voices[voice].sample == NULL)
  1414. return;
  1415. if ((exclass = voices[voice].sample->exclusiveClass) == 0)
  1416. return; /* not exclusive */
  1418. /* turn off voices with the same class */
  1419. for (i = 0; i < awe_max_voices; i++) {
  1420. if (i != voice && IS_PLAYING(i) &&
  1421.     voices[i].sample && voices[i].ch == voices[voice].ch &&
  1422.     voices[i].sample->exclusiveClass == exclass) {
  1423. DEBUG(4,printk("AWE32: [exoff(%d)]n", i));
  1424. awe_terminate(i);
  1425. awe_voice_init(i, TRUE);
  1426. }
  1427. }
  1428. }
  1431. /*
  1432.  * change the parameters of an audible voice
  1433.  */
  1435. /* change pitch */
  1436. static void
  1437. awe_set_pitch(int voice, int forced)
  1438. {
  1439. if (IS_NO_EFFECT(voice) && !forced) return;
  1440. awe_poke(AWE_IP(voice), voices[voice].apitch);
  1441. DEBUG(3,printk("AWE32: [-- pitch=%x]n", voices[voice].apitch));
  1442. }
  1444. /* calculate & change pitch */
  1445. static void
  1446. awe_set_voice_pitch(int voice, int forced)
  1447. {
  1448. awe_calc_pitch(voice);
  1449. awe_set_pitch(voice, forced);
  1450. }
  1452. /* change volume & cutoff */
  1453. static void
  1454. awe_set_volume(int voice, int forced)
  1455. {
  1456. awe_voice_info *vp;
  1457. unsigned short tmp2;
  1458. FX_Rec *fx = &voices[voice].cinfo->fx;
  1459. FX_Rec *fx_lay = NULL;
  1460. if (voices[voice].layer < MAX_LAYERS)
  1461. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1463. if (!IS_PLAYING(voice) && !forced) return;
  1464. if ((vp = voices[voice].sample) == NULL || vp->index == 0)
  1465. return;
  1467. tmp2 = FX_BYTE(fx, fx_lay, AWE_FX_CUTOFF,
  1468.        (unsigned char)voices[voice].acutoff);
  1469. tmp2 = (tmp2 << 8);
  1470. tmp2 |= FX_BYTE(fx, fx_lay, AWE_FX_ATTEN,
  1471. (unsigned char)voices[voice].avol);
  1472. awe_poke(AWE_IFATN(voice), tmp2);
  1473. }
  1475. /* calculate & change volume */
  1476. static void
  1477. awe_set_voice_vol(int voice, int forced)
  1478. {
  1479. if (IS_EMPTY(voice))
  1480. return;
  1481. awe_calc_volume(voice);
  1482. awe_set_volume(voice, forced);
  1483. }
  1486. /* change pan; this could make a click noise.. */
  1487. static void
  1488. awe_set_pan(int voice, int forced)
  1489. {
  1490. unsigned int temp;
  1491. int addr;
  1492. awe_voice_info *vp;
  1493. FX_Rec *fx = &voices[voice].cinfo->fx;
  1494. FX_Rec *fx_lay = NULL;
  1495. if (voices[voice].layer < MAX_LAYERS)
  1496. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1498. if (IS_NO_EFFECT(voice) && !forced) return;
  1499. if ((vp = voices[voice].sample) == NULL || vp->index == 0)
  1500. return;
  1502. /* pan & loop start (pan 8bit, MSB, 0:right, 0xff:left) */
  1503. if (vp->fixpan > 0) /* 0-127 */
  1504. temp = 255 - (int)vp->fixpan * 2;
  1505. else {
  1506. int pos = 0;
  1507. if (vp->pan >= 0) /* 0-127 */
  1508. pos = (int)vp->pan * 2 - 128;
  1509. pos += voices[voice].cinfo->panning; /* -128 - 127 */
  1510. temp = 127 - pos;
  1511. }
  1512. limitvalue(temp, 0, 255);
  1513. if (ctrls[AWE_MD_PAN_EXCHANGE]) {
  1514. temp = 255 - temp;
  1515. }
  1516. if (forced || temp != voices[voice].apan) {
  1517. voices[voice].apan = temp;
  1518. if (temp == 0)
  1519. voices[voice].aaux = 0xff;
  1520. else
  1521. voices[voice].aaux = (-temp) & 0xff;
  1522. addr = vp->loopstart - 1;
  1523. addr += FX_OFFSET(fx, fx_lay, AWE_FX_LOOP_START,
  1524.   AWE_FX_COARSE_LOOP_START, vp->mode);
  1525. temp = (temp<<24) | (unsigned int)addr;
  1526. awe_poke_dw(AWE_PSST(voice), temp);
  1527. DEBUG(4,printk("AWE32: [-- loopstart=%x/%x]n", vp->loopstart, addr));
  1528. }
  1529. }
  1531. /* effects change during playing */
  1532. static void
  1533. awe_fx_fmmod(int voice, int forced)
  1534. {
  1535. awe_voice_info *vp;
  1536. FX_Rec *fx = &voices[voice].cinfo->fx;
  1537. FX_Rec *fx_lay = NULL;
  1538. if (voices[voice].layer < MAX_LAYERS)
  1539. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1541. if (IS_NO_EFFECT(voice) && !forced) return;
  1542. if ((vp = voices[voice].sample) == NULL || vp->index == 0)
  1543. return;
  1544. awe_poke(AWE_FMMOD(voice),
  1545.  FX_COMB(fx, fx_lay, AWE_FX_LFO1_PITCH, AWE_FX_LFO1_CUTOFF,
  1546.  vp->parm.fmmod));
  1547. }
  1549. /* set tremolo (lfo1) volume & frequency */
  1550. static void
  1551. awe_fx_tremfrq(int voice, int forced)
  1552. {
  1553. awe_voice_info *vp;
  1554. FX_Rec *fx = &voices[voice].cinfo->fx;
  1555. FX_Rec *fx_lay = NULL;
  1556. if (voices[voice].layer < MAX_LAYERS)
  1557. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1559. if (IS_NO_EFFECT(voice) && !forced) return;
  1560. if ((vp = voices[voice].sample) == NULL || vp->index == 0)
  1561. return;
  1562. awe_poke(AWE_TREMFRQ(voice),
  1563.  FX_COMB(fx, fx_lay, AWE_FX_LFO1_VOLUME, AWE_FX_LFO1_FREQ,
  1564.  vp->parm.tremfrq));
  1565. }
  1567. /* set lfo2 pitch & frequency */
  1568. static void
  1569. awe_fx_fm2frq2(int voice, int forced)
  1570. {
  1571. awe_voice_info *vp;
  1572. FX_Rec *fx = &voices[voice].cinfo->fx;
  1573. FX_Rec *fx_lay = NULL;
  1574. if (voices[voice].layer < MAX_LAYERS)
  1575. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1577. if (IS_NO_EFFECT(voice) && !forced) return;
  1578. if ((vp = voices[voice].sample) == NULL || vp->index == 0)
  1579. return;
  1580. awe_poke(AWE_FM2FRQ2(voice),
  1581.  FX_COMB(fx, fx_lay, AWE_FX_LFO2_PITCH, AWE_FX_LFO2_FREQ,
  1582.  vp->parm.fm2frq2));
  1583. }
  1586. /* Q & current address (Q 4bit value, MSB) */
  1587. static void
  1588. awe_fx_filterQ(int voice, int forced)
  1589. {
  1590. unsigned int addr;
  1591. awe_voice_info *vp;
  1592. FX_Rec *fx = &voices[voice].cinfo->fx;
  1593. FX_Rec *fx_lay = NULL;
  1594. if (voices[voice].layer < MAX_LAYERS)
  1595. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1597. if (IS_NO_EFFECT(voice) && !forced) return;
  1598. if ((vp = voices[voice].sample) == NULL || vp->index == 0)
  1599. return;
  1601. addr = awe_peek_dw(AWE_CCCA(voice)) & 0xffffff;
  1602. addr |= (FX_BYTE(fx, fx_lay, AWE_FX_FILTERQ, vp->parm.filterQ) << 28);
  1603. awe_poke_dw(AWE_CCCA(voice), addr);
  1604. }
  1606. /*
  1607.  * calculate pitch offset
  1608.  *
  1609.  * 0xE000 is no pitch offset at 44100Hz sample.
  1610.  * Every 4096 is one octave.
  1611.  */
  1613. static void
  1614. awe_calc_pitch(int voice)
  1615. {
  1616. voice_info *vp = &voices[voice];
  1617. awe_voice_info *ap;
  1618. awe_chan_info *cp = voices[voice].cinfo;
  1619. int offset;
  1621. /* search voice information */
  1622. if ((ap = vp->sample) == NULL)
  1623. return;
  1624. if (ap->index == 0) {
  1625. DEBUG(3,printk("AWE32: set sample (%d)n", ap->sample));
  1626. if (awe_set_sample((awe_voice_list*)ap) == 0)
  1627. return;
  1628. }
  1630. /* calculate offset */
  1631. if (ap->fixkey >= 0) {
  1632. DEBUG(3,printk("AWE32: p-> fixkey(%d) tune(%d)n", ap->fixkey, ap->tune));
  1633. offset = (ap->fixkey - ap->root) * 4096 / 12;
  1634. } else {
  1635. DEBUG(3,printk("AWE32: p(%d)-> root(%d) tune(%d)n", vp->note, ap->root, ap->tune));
  1636. offset = (vp->note - ap->root) * 4096 / 12;
  1637. DEBUG(4,printk("AWE32: p-> ofs=%dn", offset));
  1638. }
  1639. offset = (offset * ap->scaleTuning) / 100;
  1640. DEBUG(4,printk("AWE32: p-> scale* ofs=%dn", offset));
  1641. offset += ap->tune * 4096 / 1200;
  1642. DEBUG(4,printk("AWE32: p-> tune+ ofs=%dn", offset));
  1643. if (cp->bender != 0) {
  1644. DEBUG(3,printk("AWE32: p-> bend(%d) %dn", voice, cp->bender));
  1645. /* (819200: 1 semitone) ==> (4096: 12 semitones) */
  1646. offset += cp->bender * cp->bender_range / 2400;
  1647. }
  1649. /* add initial pitch correction */
  1650. if (FX_ON(&cp->fx_layer[vp->layer], AWE_FX_INIT_PITCH))
  1651. offset += cp->fx_layer[vp->layer].val[AWE_FX_INIT_PITCH];
  1652. else if (FX_ON(&cp->fx, AWE_FX_INIT_PITCH))
  1653. offset += cp->fx.val[AWE_FX_INIT_PITCH];
  1655. /* 0xe000: root pitch */
  1656. vp->apitch = 0xe000 + ap->rate_offset + offset;
  1657. DEBUG(4,printk("AWE32: p-> sum aofs=%x, rate_ofs=%dn", vp->apitch, ap->rate_offset));
  1658. if (vp->apitch > 0xffff)
  1659. vp->apitch = 0xffff;
  1660. if (vp->apitch < 0)
  1661. vp->apitch = 0;
  1662. }
  1665. #ifdef AWE_HAS_GUS_COMPATIBILITY
  1666. /* calculate MIDI key and semitone from the specified frequency */
  1667. static void
  1668. awe_calc_pitch_from_freq(int voice, int freq)
  1669. {
  1670. voice_info *vp = &voices[voice];
  1671. awe_voice_info *ap;
  1672. FX_Rec *fx = &voices[voice].cinfo->fx;
  1673. FX_Rec *fx_lay = NULL;
  1674. int offset;
  1675. int note;
  1677. if (voices[voice].layer < MAX_LAYERS)
  1678. fx_lay = &voices[voice].cinfo->fx_layer[voices[voice].layer];
  1680. /* search voice information */
  1681. if ((ap = vp->sample) == NULL)
  1682. return;
  1683. if (ap->index == 0) {
  1684. DEBUG(3,printk("AWE32: set sample (%d)n", ap->sample));
  1685. if (awe_set_sample((awe_voice_list*)ap) == 0)
  1686. return;
  1687. }
  1688. note = freq_to_note(freq);
  1689. offset = (note - ap->root * 100 + ap->tune) * 4096 / 1200;
  1690. offset = (offset * ap->scaleTuning) / 100;
  1691. if (fx_lay && FX_ON(fx_lay, AWE_FX_INIT_PITCH))
  1692. offset += fx_lay->val[AWE_FX_INIT_PITCH];
  1693. else if (FX_ON(fx, AWE_FX_INIT_PITCH))
  1694. offset += fx->val[AWE_FX_INIT_PITCH];
  1695. vp->apitch = 0xe000 + ap->rate_offset + offset;
  1696. if (vp->apitch > 0xffff)
  1697. vp->apitch = 0xffff;
  1698. if (vp->apitch < 0)
  1699. vp->apitch = 0;
  1700. }
  1701. #endif /* AWE_HAS_GUS_COMPATIBILITY */
  1704. /*
  1705.  * calculate volume attenuation
  1706.  *
  1707.  * Voice volume is controlled by volume attenuation parameter.
  1708.  * So volume becomes maximum when avol is 0 (no attenuation), and
  1709.  * minimum when 255 (-96dB or silence).
  1710.  */
  1712. static int vol_table[128] = {
  1713. 255,111,95,86,79,74,70,66,63,61,58,56,54,52,50,49,
  1714. 47,46,45,43,42,41,40,39,38,37,36,35,34,34,33,32,
  1715. 31,31,30,29,29,28,27,27,26,26,25,24,24,23,23,22,
  1716. 22,21,21,21,20,20,19,19,18,18,18,17,17,16,16,16,
  1717. 15,15,15,14,14,14,13,13,13,12,12,12,11,11,11,10,
  1718. 10,10,10,9,9,9,8,8,8,8,7,7,7,7,6,6,
  1719. 6,6,5,5,5,5,5,4,4,4,4,3,3,3,3,3,
  1720. 2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,0,
  1721. };
  1723. /* tables for volume->attenuation calculation */
  1724. static unsigned char voltab1[128] = {
  1725.    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
  1726.    0x63, 0x2b, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22,
  1727.    0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a,
  1728.    0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14,
  1729.    0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10,
  1730.    0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d,
  1731.    0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b,
  1732.    0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09,
  1733.    0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06,
  1734.    0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04,
  1735.    0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02,
  1736.    0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01,
  1737.    0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  1738. };
  1740. static unsigned char voltab2[128] = {
  1741.    0x32, 0x31, 0x30, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x2a,
  1742.    0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21,
  1743.    0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a,
  1744.    0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x16, 0x16, 0x15, 0x15,
  1745.    0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x10,
  1746.    0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d,
  1747.    0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a,
  1748.    0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08,
  1749.    0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06,
  1750.    0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  1751.    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03,
  1752.    0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01,
  1753.    0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
  1754. };
  1756. static unsigned char expressiontab[128] = {
  1757.    0x7f, 0x6c, 0x62, 0x5a, 0x54, 0x50, 0x4b, 0x48, 0x45, 0x42,
  1758.    0x40, 0x3d, 0x3b, 0x39, 0x38, 0x36, 0x34, 0x33, 0x31, 0x30,
  1759.    0x2f, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25,
  1760.    0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x20, 0x1f, 0x1e, 0x1e,
  1761.    0x1d, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x18,
  1762.    0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13,
  1763.    0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f,
  1764.    0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c,
  1765.    0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09,
  1766.    0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06,
  1767.    0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03,
  1768.    0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
  1769.    0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  1770. };
  1772. static void
  1773. awe_calc_volume(int voice)
  1774. {
  1775. voice_info *vp = &voices[voice];
  1776. awe_voice_info *ap;
  1777. awe_chan_info *cp = voices[voice].cinfo;
  1778. int vol;
  1780. /* search voice information */
  1781. if ((ap = vp->sample) == NULL)
  1782. return;
  1784. ap = vp->sample;
  1785. if (ap->index == 0) {
  1786. DEBUG(3,printk("AWE32: set sample (%d)n", ap->sample));
  1787. if (awe_set_sample((awe_voice_list*)ap) == 0)
  1788. return;
  1789. }
  1791. if (ctrls[AWE_MD_NEW_VOLUME_CALC]) {
  1792. int main_vol = cp->main_vol * ap->amplitude / 127;
  1793. limitvalue(vp->velocity, 0, 127);
  1794. limitvalue(main_vol, 0, 127);
  1795. limitvalue(cp->expression_vol, 0, 127);
  1797. vol = voltab1[main_vol] + voltab2[vp->velocity];
  1798. vol = (vol * 8) / 3;
  1799. vol += ap->attenuation;
  1800. if (cp->expression_vol < 127)
  1801. vol += ((0x100 - vol) * expressiontab[cp->expression_vol])/128;
  1802. vol += atten_offset;
  1803. if (atten_relative)
  1804. vol += ctrls[AWE_MD_ZERO_ATTEN];
  1805. limitvalue(vol, 0, 255);
  1806. vp->avol = vol;
  1808. } else {
  1809. /* 0 - 127 */
  1810. vol = (vp->velocity * cp->main_vol * cp->expression_vol) / (127*127);
  1811. vol = vol * ap->amplitude / 127;
  1813. if (vol < 0) vol = 0;
  1814. if (vol > 127) vol = 127;
  1816. /* calc to attenuation */
  1817. vol = vol_table[vol];
  1818. vol += (int)ap->attenuation;
  1819. vol += atten_offset;
  1820. if (atten_relative)
  1821. vol += ctrls[AWE_MD_ZERO_ATTEN];
  1822. if (vol > 255) vol = 255;
  1824. vp->avol = vol;
  1825. }
  1826. if (cp->bank !=  AWE_DRUM_BANK && ((awe_voice_parm_block*)(&ap->parm))->volatk < 0x7d) {
  1827. int atten;
  1828. if (vp->velocity < 70) atten = 70;
  1829. else atten = vp->velocity;
  1830. vp->acutoff = (atten * ap->parm.cutoff + 0xa0) >> 7;
  1831. } else {
  1832. vp->acutoff = ap->parm.cutoff;
  1833. }
  1834. DEBUG(3,printk("AWE32: [-- voice(%d) vol=%x]n", voice, vol));
  1835. }
  1837. /* change master volume */
  1838. static void
  1839. awe_change_master_volume(short val)
  1840. {
  1841. limitvalue(val, 0, 127);
  1842. atten_offset = vol_table[val];
  1843. atten_relative = TRUE;
  1844. awe_update_volume();
  1845. }
  1847. /* update volumes of all available channels */
  1848. static void awe_update_volume(void)
  1849. {
  1850. int i;
  1851. for (i = 0; i < awe_max_voices; i++)
  1852. awe_set_voice_vol(i, TRUE);
  1853. }
  1855. /* set sostenuto on */
  1856. static void awe_sostenuto_on(int voice, int forced)
  1857. {
  1858. if (IS_NO_EFFECT(voice) && !forced) return;
  1859. voices[voice].sostenuto = 127;
  1860. }
  1863. /* drop sustain */
  1864. static void awe_sustain_off(int voice, int forced)
  1865. {
  1866. if (voices[voice].state == AWE_ST_SUSTAINED) {
  1867. awe_note_off(voice);
  1868. awe_fx_init(voices[voice].ch);
  1869. awe_voice_init(voice, FALSE);
  1870. }
  1871. }
  1874. /* terminate and initialize voice */
  1875. static void awe_terminate_and_init(int voice, int forced)
  1876. {
  1877. awe_terminate(voice);
  1878. awe_fx_init(voices[voice].ch);
  1879. awe_voice_init(voice, TRUE);
  1880. }
  1883. /*
  1884.  * synth operation routines
  1885.  */
  1887. #define AWE_VOICE_KEY(v) (0x8000 | (v))
  1888. #define AWE_CHAN_KEY(c,n) (((c) << 8) | ((n) + 1))
  1889. #define KEY_CHAN_MATCH(key,c) (((key) >> 8) == (c))
  1891. /* initialize the voice */
  1892. static void
  1893. awe_voice_init(int voice, int init_all)
  1894. {
  1895. voice_info *vp = &voices[voice];
  1897. /* reset voice search key */
  1898. if (playing_mode == AWE_PLAY_DIRECT)
  1899. vp->key = AWE_VOICE_KEY(voice);
  1900. else
  1901. vp->key = 0;
  1903. /* clear voice mapping */
  1904. voice_alloc->map[voice] = 0;
  1906. /* touch the timing flag */
  1907. vp->time = current_alloc_time;
  1909. /* initialize other parameters if necessary */
  1910. if (init_all) {
  1911. vp->note = -1;
  1912. vp->velocity = 0;
  1913. vp->sostenuto = 0;
  1915. vp->sample = NULL;
  1916. vp->cinfo = &channels[voice];
  1917. vp->ch = voice;
  1918. vp->state = AWE_ST_OFF;
  1920. /* emu8000 parameters */
  1921. vp->apitch = 0;
  1922. vp->avol = 255;
  1923. vp->apan = -1;
  1924. }
  1925. }
  1927. /* clear effects */
  1928. static void awe_fx_init(int ch)
  1929. {
  1930. if (SINGLE_LAYER_MODE() && !ctrls[AWE_MD_KEEP_EFFECT]) {
  1931. memset(&channels[ch].fx, 0, sizeof(channels[ch].fx));
  1932. memset(&channels[ch].fx_layer, 0, sizeof(&channels[ch].fx_layer));
  1933. }
  1934. }
  1936. /* initialize channel info */
  1937. static void awe_channel_init(int ch, int init_all)
  1938. {
  1939. awe_chan_info *cp = &channels[ch];
  1940. cp->channel = ch;
  1941. if (init_all) {
  1942. cp->panning = 0; /* zero center */
  1943. cp->bender_range = 200; /* sense * 100 */
  1944. cp->main_vol = 127;
  1945. if (MULTI_LAYER_MODE() && IS_DRUM_CHANNEL(ch)) {
  1946. cp->instr = ctrls[AWE_MD_DEF_DRUM];
  1947. cp->bank = AWE_DRUM_BANK;
  1948. } else {
  1949. cp->instr = ctrls[AWE_MD_DEF_PRESET];
  1950. cp->bank = ctrls[AWE_MD_DEF_BANK];
  1951. }
  1952. }
  1954. cp->bender = 0; /* zero tune skew */
  1955. cp->expression_vol = 127;
  1956. cp->chan_press = 0;
  1957. cp->sustained = 0;
  1959. if (! ctrls[AWE_MD_KEEP_EFFECT]) {
  1960. memset(&cp->fx, 0, sizeof(cp->fx));
  1961. memset(&cp->fx_layer, 0, sizeof(cp->fx_layer));
  1962. }
  1963. }
  1966. /* change the voice parameters; voice = channel */
  1967. static void awe_voice_change(int voice, fx_affect_func func)
  1968. {
  1969. int i; 
  1970. switch (playing_mode) {
  1971. case AWE_PLAY_DIRECT:
  1972. func(voice, FALSE);
  1973. break;
  1974. case AWE_PLAY_INDIRECT:
  1975. for (i = 0; i < awe_max_voices; i++)
  1976. if (voices[i].key == AWE_VOICE_KEY(voice))
  1977. func(i, FALSE);
  1978. break;
  1979. default:
  1980. for (i = 0; i < awe_max_voices; i++)
  1981. if (KEY_CHAN_MATCH(voices[i].key, voice))
  1982. func(i, FALSE);
  1983. break;
  1984. }
  1985. }
  1988. /*
  1989.  * device open / close
  1990.  */
  1992. /* open device:
  1993.  *   reset status of all voices, and clear sample position flag
  1994.  */
  1995. static int
  1996. awe_open(int dev, int mode)
  1997. {
  1998. if (awe_busy)
  1999. return -EBUSY;
  2001. awe_busy = TRUE;
  2003. /* set default mode */
  2004. awe_init_ctrl_parms(FALSE);
  2005. atten_relative = TRUE;
  2006. atten_offset = 0;
  2007. drum_flags = DEFAULT_DRUM_FLAGS;
  2008. playing_mode = AWE_PLAY_INDIRECT;
  2010. /* reset voices & channels */
  2011. awe_reset(dev);
  2013. patch_opened = 0;
  2015. return 0;
  2016. }
  2019. /* close device:
  2020.  *   reset all voices again (terminate sounds)
  2021.  */
  2022. static void
  2023. awe_close(int dev)
  2024. {
  2025. awe_reset(dev);
  2026. awe_busy = FALSE;
  2027. }
  2030. /* set miscellaneous mode parameters
  2031.  */
  2032. static void
  2033. awe_init_ctrl_parms(int init_all)
  2034. {
  2035. int i;
  2036. for (i = 0; i < AWE_MD_END; i++) {
  2037. if (init_all || ctrl_parms[i].init_each_time)
  2038. ctrls[i] = ctrl_parms[i].value;
  2039. }
  2040. }
  2043. /* sequencer I/O control:
  2044.  */
  2045. static int
  2046. awe_ioctl(int dev, unsigned int cmd, caddr_t arg)
  2047. {
  2048. switch (cmd) {
  2049. case SNDCTL_SYNTH_INFO:
  2050. if (playing_mode == AWE_PLAY_DIRECT)
  2051. awe_info.nr_voices = awe_max_voices;
  2052. else
  2053. awe_info.nr_voices = AWE_MAX_CHANNELS;
  2054. memcpy((char*)arg, &awe_info, sizeof(awe_info));
  2055. return 0;
  2056. break;
  2058. case SNDCTL_SEQ_RESETSAMPLES:
  2059. awe_reset(dev);
  2060. awe_reset_samples();
  2061. return 0;
  2062. break;
  2064. case SNDCTL_SEQ_PERCMODE:
  2065. /* what's this? */
  2066. return 0;
  2067. break;
  2069. case SNDCTL_SYNTH_MEMAVL:
  2070. return memsize - awe_free_mem_ptr() * 2;
  2072. default:
  2073. printk(KERN_WARNING "AWE32: unsupported ioctl %dn", cmd);
  2074. return -EINVAL;
  2075. }
  2076. }
  2079. static int voice_in_range(int voice)
  2080. {
  2081. if (playing_mode == AWE_PLAY_DIRECT) {
  2082. if (voice < 0 || voice >= awe_max_voices)
  2083. return FALSE;
  2084. } else {
  2085. if (voice < 0 || voice >= AWE_MAX_CHANNELS)
  2086. return FALSE;
  2087. }
  2088. return TRUE;
  2089. }
  2091. static void release_voice(int voice, int do_sustain)
  2092. {
  2093. if (IS_NO_SOUND(voice))
  2094. return;
  2095. if (do_sustain && (voices[voice].cinfo->sustained == 127 ||
  2096.     voices[voice].sostenuto == 127))
  2097. voices[voice].state = AWE_ST_SUSTAINED;
  2098. else {
  2099. awe_note_off(voice);
  2100. awe_fx_init(voices[voice].ch);
  2101. awe_voice_init(voice, FALSE);
  2102. }
  2103. }
  2105. /* release all notes */
  2106. static void awe_note_off_all(int do_sustain)
  2107. {
  2108. int i;
  2109. for (i = 0; i < awe_max_voices; i++)
  2110. release_voice(i, do_sustain);
  2111. }
  2113. /* kill a voice:
  2114.  *   not terminate, just release the voice.
  2115.  */
  2116. static int
  2117. awe_kill_note(int dev, int voice, int note, int velocity)
  2118. {
  2119. int i, v2, key;
  2121. DEBUG(2,printk("AWE32: [off(%d) nt=%d vl=%d]n", voice, note, velocity));
  2122. if (! voice_in_range(voice))
  2123. return -EINVAL;
  2125. switch (playing_mode) {
  2126. case AWE_PLAY_DIRECT:
  2127. case AWE_PLAY_INDIRECT:
  2128. key = AWE_VOICE_KEY(voice);
  2129. break;
  2131. case AWE_PLAY_MULTI2:
  2132. v2 = voice_alloc->map[voice] >> 8;
  2133. voice_alloc->map[voice] = 0;
  2134. voice = v2;
  2135. if (voice < 0 || voice >= AWE_MAX_CHANNELS)
  2136. return -EINVAL;
  2137. /* continue to below */
  2138. default:
  2139. key = AWE_CHAN_KEY(voice, note);
  2140. break;
  2141. }
  2143. for (i = 0; i < awe_max_voices; i++) {
  2144. if (voices[i].key == key)
  2145. release_voice(i, TRUE);
  2146. }
  2147. return 0;
  2148. }
  2151. static void start_or_volume_change(int voice, int velocity)
  2152. {
  2153. voices[voice].velocity = velocity;
  2154. awe_calc_volume(voice);
  2155. if (voices[voice].state == AWE_ST_STANDBY)
  2156. awe_note_on(voice);
  2157. else if (voices[voice].state == AWE_ST_ON)
  2158. awe_set_volume(voice, FALSE);
  2159. }
  2161. static void set_and_start_voice(int voice, int state)
  2162. {
  2163. /* calculate pitch & volume parameters */
  2164. voices[voice].state = state;
  2165. awe_calc_pitch(voice);
  2166. awe_calc_volume(voice);
  2167. if (state == AWE_ST_ON)
  2168. awe_note_on(voice);
  2169. }
  2171. /* start a voice:
  2172.  *   if note is 255, identical with aftertouch function.
  2173.  *   Otherwise, start a voice with specified not and volume.
  2174.  */
  2175. static int
  2176. awe_start_note(int dev, int voice, int note, int velocity)
  2177. {
  2178. int i, key, state, volonly;
  2180. DEBUG(2,printk("AWE32: [on(%d) nt=%d vl=%d]n", voice, note, velocity));
  2181. if (! voice_in_range(voice))
  2182. return -EINVAL;
  2183.     
  2184. if (velocity == 0)
  2185. state = AWE_ST_STANDBY; /* stand by for playing */
  2186. else
  2187. state = AWE_ST_ON; /* really play */
  2188. volonly = FALSE;
  2190. switch (playing_mode) {
  2191. case AWE_PLAY_DIRECT:
  2192. case AWE_PLAY_INDIRECT:
  2193. key = AWE_VOICE_KEY(voice);
  2194. if (note == 255)
  2195. volonly = TRUE;
  2196. break;
  2198. case AWE_PLAY_MULTI2:
  2199. voice = voice_alloc->map[voice] >> 8;
  2200. if (voice < 0 || voice >= AWE_MAX_CHANNELS)
  2201. return -EINVAL;
  2202. /* continue to below */
  2203. default:
  2204. if (note >= 128) { /* key volume mode */
  2205. note -= 128;
  2206. volonly = TRUE;
  2207. }
  2208. key = AWE_CHAN_KEY(voice, note);
  2209. break;
  2210. }
  2212. /* dynamic volume change */
  2213. if (volonly) {
  2214. for (i = 0; i < awe_max_voices; i++) {
  2215. if (voices[i].key == key)
  2216. start_or_volume_change(i, velocity);
  2217. }
  2218. return 0;
  2219. }
  2221. /* if the same note still playing, stop it */
  2222. if (playing_mode != AWE_PLAY_DIRECT || ctrls[AWE_MD_EXCLUSIVE_SOUND]) {
  2223. for (i = 0; i < awe_max_voices; i++)
  2224. if (voices[i].key == key) {
  2225. if (voices[i].state == AWE_ST_ON) {
  2226. awe_note_off(i);
  2227. awe_voice_init(i, FALSE);
  2228. } else if (voices[i].state == AWE_ST_STANDBY)
  2229. awe_voice_init(i, TRUE);
  2230. }
  2231. }
  2233. /* allocate voices */
  2234. if (playing_mode == AWE_PLAY_DIRECT)
  2235. awe_alloc_one_voice(voice, note, velocity);
  2236. else
  2237. awe_alloc_multi_voices(voice, note, velocity, key);
  2239. /* turn off other voices exlusively (for drums) */
  2240. for (i = 0; i < awe_max_voices; i++)
  2241. if (voices[i].key == key)
  2242. awe_exclusive_off(i);
  2244. /* set up pitch and volume parameters */
  2245. for (i = 0; i < awe_max_voices; i++) {
  2246. if (voices[i].key == key && voices[i].state == AWE_ST_OFF)
  2247. set_and_start_voice(i, state);
  2248. }
  2250. return 0;
  2251. }
  2254. /* calculate hash key */
  2255. static int
  2256. awe_search_key(int bank, int preset, int note)
  2257. {
  2258. unsigned int key;
  2260. #if 1 /* new hash table */
  2261. if (bank == AWE_DRUM_BANK)
  2262. key = preset + note + 128;
  2263. else
  2264. key = bank + preset;
  2265. #else
  2266. key = preset;
  2267. #endif
  2268. key %= AWE_MAX_PRESETS;
  2270. return (int)key;
  2271. }
  2274. /* search instrument from hash table */
  2275. static awe_voice_list *
  2276. awe_search_instr(int bank, int preset, int note)
  2277. {
  2278. awe_voice_list *p;
  2279. int key, key2;
  2281. key = awe_search_key(bank, preset, note);
  2282. for (p = preset_table[key]; p; p = p->next_bank) {
  2283. if (p->instr == preset && p->bank == bank)
  2284. return p;
  2285. }
  2286. key2 = awe_search_key(bank, preset, 0); /* search default */
  2287. if (key == key2)
  2288. return NULL;
  2289. for (p = preset_table[key2]; p; p = p->next_bank) {
  2290. if (p->instr == preset && p->bank == bank)
  2291. return p;
  2292. }
  2293. return NULL;
  2294. }
  2297. /* assign the instrument to a voice */
  2298. static int
  2299. awe_set_instr_2(int dev, int voice, int instr_no)
  2300. {
  2301. if (playing_mode == AWE_PLAY_MULTI2) {
  2302. voice = voice_alloc->map[voice] >> 8;
  2303. if (voice < 0 || voice >= AWE_MAX_CHANNELS)
  2304. return -EINVAL;
  2305. }
  2306. return awe_set_instr(dev, voice, instr_no);
  2307. }
  2309. /* assign the instrument to a channel; voice is the channel number */
  2310. static int
  2311. awe_set_instr(int dev, int voice, int instr_no)
  2312. {
  2313. awe_chan_info *cinfo;
  2315. if (! voice_in_range(voice))
  2316. return -EINVAL;
  2318. if (instr_no < 0 || instr_no >= AWE_MAX_PRESETS)
  2319. return -EINVAL;
  2321. cinfo = &channels[voice];
  2322. cinfo->instr = instr_no;
  2323. DEBUG(2,printk("AWE32: [program(%d) %d]n", voice, instr_no));
  2325. return 0;
  2326. }
  2329. /* reset all voices; terminate sounds and initialize parameters */
  2330. static void
  2331. awe_reset(int dev)
  2332. {
  2333. int i;
  2334. current_alloc_time = 0;
  2335. /* don't turn off voice 31 and 32.  they are used also for FM voices */
  2336. for (i = 0; i < awe_max_voices; i++) {
  2337. awe_terminate(i);
  2338. awe_voice_init(i, TRUE);
  2339. }
  2340. for (i = 0; i < AWE_MAX_CHANNELS; i++)
  2341. awe_channel_init(i, TRUE);
  2342. for (i = 0; i < 16; i++) {
  2343. awe_operations.chn_info[i].controllers[CTL_MAIN_VOLUME] = 127;
  2344. awe_operations.chn_info[i].controllers[CTL_EXPRESSION] = 127;
  2345. }
  2346. awe_init_fm();
  2347. awe_tweak();
  2348. }
  2351. /* hardware specific control:
  2352.  *   GUS specific and AWE32 specific controls are available.
  2353.  */
  2354. static void
  2355. awe_hw_control(int dev, unsigned char *event)
  2356. {
  2357. int cmd = event[2];
  2358. if (cmd & _AWE_MODE_FLAG)
  2359. awe_hw_awe_control(dev, cmd & _AWE_MODE_VALUE_MASK, event);
  2360. #ifdef AWE_HAS_GUS_COMPATIBILITY
  2361. else
  2362. awe_hw_gus_control(dev, cmd & _AWE_MODE_VALUE_MASK, event);
  2363. #endif
  2364. }
  2367. #ifdef AWE_HAS_GUS_COMPATIBILITY
  2369. /* GUS compatible controls */
  2370. static void
  2371. awe_hw_gus_control(int dev, int cmd, unsigned char *event)
  2372. {
  2373. int voice, i, key;
  2374. unsigned short p1;
  2375. short p2;
  2376. int plong;
  2378. if (MULTI_LAYER_MODE())
  2379. return;
  2380. if (cmd == _GUS_NUMVOICES)
  2381. return;
  2383. voice = event[3];
  2384. if (! voice_in_range(voice))
  2385. return;
  2387. p1 = *(unsigned short *) &event[4];
  2388. p2 = *(short *) &event[6];
  2389. plong = *(int*) &event[4];
  2391. switch (cmd) {
  2392. case _GUS_VOICESAMPLE:
  2393. awe_set_instr(dev, voice, p1);
  2394. return;
  2396. case _GUS_VOICEBALA:
  2397. /* 0 to 15 --> -128 to 127 */
  2398. awe_panning(dev, voice, ((int)p1 << 4) - 128);
  2399. return;
  2401. case _GUS_VOICEVOL:
  2402. case _GUS_VOICEVOL2:
  2403. /* not supported yet */
  2404. return;
  2406. case _GUS_RAMPRANGE:
  2407. case _GUS_RAMPRATE:
  2408. case _GUS_RAMPMODE:
  2409. case _GUS_RAMPON:
  2410. case _GUS_RAMPOFF:
  2411. /* volume ramping not supported */
  2412. return;
  2414. case _GUS_VOLUME_SCALE:
  2415. return;
  2417. case _GUS_VOICE_POS:
  2418. FX_SET(&channels[voice].fx, AWE_FX_SAMPLE_START,
  2419.        (short)(plong & 0x7fff));
  2420. FX_SET(&channels[voice].fx, AWE_FX_COARSE_SAMPLE_START,
  2421.        (plong >> 15) & 0xffff);
  2422. return;
  2423. }
  2425. key = AWE_VOICE_KEY(voice);
  2426. for (i = 0; i < awe_max_voices; i++) {
  2427. if (voices[i].key == key) {
  2428. switch (cmd) {
  2429. case _GUS_VOICEON:
  2430. awe_note_on(i);
  2431. break;
  2433. case _GUS_VOICEOFF:
  2434. awe_terminate(i);
  2435. awe_fx_init(voices[i].ch);
  2436. awe_voice_init(i, TRUE);
  2437. break;
  2439. case _GUS_VOICEFADE:
  2440. awe_note_off(i);
  2441. awe_fx_init(voices[i].ch);
  2442. awe_voice_init(i, FALSE);
  2443. break;
  2445. case _GUS_VOICEFREQ:
  2446. awe_calc_pitch_from_freq(i, plong);
  2447. break;
  2448. }
  2449. }
  2450. }
  2451. }
  2453. #endif /* gus_compat */
  2456. /* AWE32 specific controls */
  2457. static void
  2458. awe_hw_awe_control(int dev, int cmd, unsigned char *event)
  2459. {
  2460. int voice;
  2461. unsigned short p1;
  2462. short p2;
  2463. int i;
  2465. voice = event[3];
  2466. if (! voice_in_range(voice))
  2467. return;
  2469. if (playing_mode == AWE_PLAY_MULTI2) {
  2470. voice = voice_alloc->map[voice] >> 8;
  2471. if (voice < 0 || voice >= AWE_MAX_CHANNELS)
  2472. return;
  2473. }
  2475. p1 = *(unsigned short *) &event[4];
  2476. p2 = *(short *) &event[6];
  2478. switch (cmd) {
  2479. case _AWE_DEBUG_MODE:
  2480. ctrls[AWE_MD_DEBUG_MODE] = p1;
  2481. printk(KERN_DEBUG "AWE32: debug mode = %dn", ctrls[AWE_MD_DEBUG_MODE]);
  2482. break;
  2483. case _AWE_REVERB_MODE:
  2484. ctrls[AWE_MD_REVERB_MODE] = p1;
  2485. awe_update_reverb_mode();
  2486. break;
  2488. case _AWE_CHORUS_MODE:
  2489. ctrls[AWE_MD_CHORUS_MODE] = p1;
  2490. awe_update_chorus_mode();
  2491. break;
  2492.       
  2493. case _AWE_REMOVE_LAST_SAMPLES:
  2494. DEBUG(0,printk("AWE32: remove last samplesn"));
  2495. awe_reset(0);
  2496. if (locked_sf_id > 0)
  2497. awe_remove_samples(locked_sf_id);
  2498. break;
  2500. case _AWE_INITIALIZE_CHIP:
  2501. awe_initialize();
  2502. break;
  2504. case _AWE_SEND_EFFECT:
  2505. i = -1;
  2506. if (p1 >= 0x100) {
  2507. i = (p1 >> 8);
  2508. if (i < 0 || i >= MAX_LAYERS)
  2509. break;
  2510. }
  2511. awe_send_effect(voice, i, p1, p2);
  2512. break;
  2514. case _AWE_RESET_CHANNEL:
  2515. awe_channel_init(voice, !p1);
  2516. break;
  2518. case _AWE_TERMINATE_ALL:
  2519. awe_reset(0);
  2520. break;
  2522. case _AWE_TERMINATE_CHANNEL:
  2523. awe_voice_change(voice, awe_terminate_and_init);
  2524. break;
  2526. case _AWE_RELEASE_ALL:
  2527. awe_note_off_all(FALSE);
  2528. break;
  2529. case _AWE_NOTEOFF_ALL:
  2530. awe_note_off_all(TRUE);
  2531. break;
  2533. case _AWE_INITIAL_VOLUME:
  2534. DEBUG(0,printk("AWE32: init attenuation %dn", p1));
  2535. atten_relative = (char)p2;
  2536. atten_offset = (short)p1;
  2537. awe_update_volume();
  2538. break;
  2540. case _AWE_CHN_PRESSURE:
  2541. channels[voice].chan_press = p1;
  2542. awe_modwheel_change(voice, p1);
  2543. break;
  2545. case _AWE_CHANNEL_MODE:
  2546. DEBUG(0,printk("AWE32: channel mode = %dn", p1));
  2547. playing_mode = p1;
  2548. awe_reset(0);
  2549. break;
  2551. case _AWE_DRUM_CHANNELS:
  2552. DEBUG(0,printk("AWE32: drum flags = %xn", p1));
  2553. drum_flags = *(unsigned int*)&event[4];
  2554. break;
  2556. case _AWE_MISC_MODE:
  2557. DEBUG(0,printk("AWE32: ctrl parms = %d %dn", p1, p2));
  2558. if (p1 > AWE_MD_VERSION && p1 < AWE_MD_END) {
  2559. ctrls[p1] = p2;
  2560. if (ctrl_parms[p1].update)
  2561. ctrl_parms[p1].update();
  2562. }
  2563. break;
  2565. case _AWE_EQUALIZER:
  2566. ctrls[AWE_MD_BASS_LEVEL] = p1;
  2567. ctrls[AWE_MD_TREBLE_LEVEL] = p2;
  2568. awe_update_equalizer();
  2569. break;
  2571. default:
  2572. DEBUG(0,printk("AWE32: hw control cmd=%d voice=%dn", cmd, voice));
  2573. break;
  2574. }
  2575. }
  2578. /* change effects */
  2579. static void
  2580. awe_send_effect(int voice, int layer, int type, int val)
  2581. {
  2582. awe_chan_info *cinfo;
  2583. FX_Rec *fx;
  2584. int mode;
  2586. cinfo = &channels[voice];
  2587. if (layer >= 0 && layer < MAX_LAYERS)
  2588. fx = &cinfo->fx_layer[layer];
  2589. else
  2590. fx = &cinfo->fx;
  2592. if (type & 0x40)
  2593. mode = FX_FLAG_OFF;
  2594. else if (type & 0x80)
  2595. mode = FX_FLAG_ADD;
  2596. else
  2597. mode = FX_FLAG_SET;
  2598. type &= 0x3f;
  2600. if (type >= 0 && type < AWE_FX_END) {
  2601. DEBUG(2,printk("AWE32: effects (%d) %d %dn", voice, type, val));
  2602. if (mode == FX_FLAG_SET)
  2603. FX_SET(fx, type, val);
  2604. else if (mode == FX_FLAG_ADD)
  2605. FX_ADD(fx, type, val);
  2606. else
  2607. FX_UNSET(fx, type);
  2608. if (mode != FX_FLAG_OFF && parm_defs[type].realtime) {
  2609. DEBUG(2,printk("AWE32: fx_realtime (%d)n", voice));
  2610. awe_voice_change(voice, parm_defs[type].realtime);
  2611. }
  2612. }
  2613. }
  2616. /* change modulation wheel; voice is already mapped on multi2 mode */
  2617. static void
  2618. awe_modwheel_change(int voice, int value)
  2619. {
  2620. int i;
  2621. awe_chan_info *cinfo;
  2623. cinfo = &channels[voice];
  2624. i = value * ctrls[AWE_MD_MOD_SENSE] / 1200;
  2625. FX_ADD(&cinfo->fx, AWE_FX_LFO1_PITCH, i);
  2626. awe_voice_change(voice, awe_fx_fmmod);
  2627. FX_ADD(&cinfo->fx, AWE_FX_LFO2_PITCH, i);
  2628. awe_voice_change(voice, awe_fx_fm2frq2);
  2629. }
  2632. /* voice pressure change */
  2633. static void
  2634. awe_aftertouch(int dev, int voice, int pressure)
  2635. {
  2636. int note;
  2638. DEBUG(2,printk("AWE32: [after(%d) %d]n", voice, pressure));
  2639. if (! voice_in_range(voice))
  2640. return;
  2642. switch (playing_mode) {
  2643. case AWE_PLAY_DIRECT:
  2644. case AWE_PLAY_INDIRECT:
  2645. awe_start_note(dev, voice, 255, pressure);
  2646. break;
  2647. case AWE_PLAY_MULTI2:
  2648. note = (voice_alloc->map[voice] & 0xff) - 1;
  2649. awe_key_pressure(dev, voice, note + 0x80, pressure);
  2650. break;
  2651. }
  2652. }
  2655. /* voice control change */
  2656. static void
  2657. awe_controller(int dev, int voice, int ctrl_num, int value)
  2658. {
  2659. awe_chan_info *cinfo;
  2661. if (! voice_in_range(voice))
  2662. return;
  2664. if (playing_mode == AWE_PLAY_MULTI2) {
  2665. voice = voice_alloc->map[voice] >> 8;
  2666. if (voice < 0 || voice >= AWE_MAX_CHANNELS)
  2667. return;
  2668. }
  2670. cinfo = &channels[voice];
  2672. switch (ctrl_num) {
  2673. case CTL_BANK_SELECT: /* MIDI control #0 */
  2674. DEBUG(2,printk("AWE32: [bank(%d) %d]n", voice, value));
  2675. if (MULTI_LAYER_MODE() && IS_DRUM_CHANNEL(voice) &&
  2676.     !ctrls[AWE_MD_TOGGLE_DRUM_BANK])
  2677. break;
  2678. if (value < 0 || value > 255)
  2679. break;
  2680. cinfo->bank = value;
  2681. if (cinfo->bank == AWE_DRUM_BANK)
  2682. DRUM_CHANNEL_ON(cinfo->channel);
  2683. else
  2684. DRUM_CHANNEL_OFF(cinfo->channel);
  2685. awe_set_instr(dev, voice, cinfo->instr);
  2686. break;
  2688. case CTL_MODWHEEL: /* MIDI control #1 */
  2689. DEBUG(2,printk("AWE32: [modwheel(%d) %d]n", voice, value));
  2690. awe_modwheel_change(voice, value);
  2691. break;
  2693. case CTRL_PITCH_BENDER: /* SEQ1 V2 contorl */
  2694. DEBUG(2,printk("AWE32: [bend(%d) %d]n", voice, value));
  2695. /* zero centered */
  2696. cinfo->bender = value;
  2697. awe_voice_change(voice, awe_set_voice_pitch);
  2698. break;
  2700. case CTRL_PITCH_BENDER_RANGE: /* SEQ1 V2 control */
  2701. DEBUG(2,printk("AWE32: [range(%d) %d]n", voice, value));
  2702. /* value = sense x 100 */
  2703. cinfo->bender_range = value;
  2704. /* no audible pitch change yet.. */
  2705. break;
  2707. case CTL_EXPRESSION: /* MIDI control #11 */
  2708. if (SINGLE_LAYER_MODE())
  2709. value /= 128;
  2710. case CTRL_EXPRESSION: /* SEQ1 V2 control */
  2711. DEBUG(2,printk("AWE32: [expr(%d) %d]n", voice, value));
  2712. /* 0 - 127 */
  2713. cinfo->expression_vol = value;
  2714. awe_voice_change(voice, awe_set_voice_vol);
  2715. break;
  2717. case CTL_PAN: /* MIDI control #10 */
  2718. DEBUG(2,printk("AWE32: [pan(%d) %d]n", voice, value));
  2719. /* (0-127) -> signed 8bit */
  2720. cinfo->panning = value * 2 - 128;
  2721. if (ctrls[AWE_MD_REALTIME_PAN])
  2722. awe_voice_change(voice, awe_set_pan);
  2723. break;
  2725. case CTL_MAIN_VOLUME: /* MIDI control #7 */
  2726. if (SINGLE_LAYER_MODE())
  2727. value = (value * 100) / 16383;
  2728. case CTRL_MAIN_VOLUME: /* SEQ1 V2 control */
  2729. DEBUG(2,printk("AWE32: [mainvol(%d) %d]n", voice, value));
  2730. /* 0 - 127 */
  2731. cinfo->main_vol = value;
  2732. awe_voice_change(voice, awe_set_voice_vol);
  2733. break;
  2735. case CTL_EXT_EFF_DEPTH: /* reverb effects: 0-127 */
  2736. DEBUG(2,printk("AWE32: [reverb(%d) %d]n", voice, value));
  2737. FX_SET(&cinfo->fx, AWE_FX_REVERB, value * 2);
  2738. break;
  2740. case CTL_CHORUS_DEPTH: /* chorus effects: 0-127 */
  2741. DEBUG(2,printk("AWE32: [chorus(%d) %d]n", voice, value));
  2742. FX_SET(&cinfo->fx, AWE_FX_CHORUS, value * 2);
  2743. break;
  2745. case 120:  /* all sounds off */
  2746. awe_note_off_all(FALSE);
  2747. break;
  2748. case 123:  /* all notes off */
  2749. awe_note_off_all(TRUE);
  2750. break;
  2752. case CTL_SUSTAIN: /* MIDI control #64 */
  2753. cinfo->sustained = value;
  2754. if (value != 127)
  2755. awe_voice_change(voice, awe_sustain_off);
  2756. break;
  2758. case CTL_SOSTENUTO: /* MIDI control #66 */
  2759. if (value == 127)
  2760. awe_voice_change(voice, awe_sostenuto_on);
  2761. else
  2762. awe_voice_change(voice, awe_sustain_off);
  2763. break;
  2765. default:
  2766. DEBUG(0,printk("AWE32: [control(%d) ctrl=%d val=%d]n",
  2767.    voice, ctrl_num, value));
  2768. break;
  2769. }
  2770. }
  2773. /* voice pan change (value = -128 - 127) */
  2774. static void
  2775. awe_panning(int dev, int voice, int value)
  2776. {
  2777. awe_chan_info *cinfo;
  2779. if (! voice_in_range(voice))
  2780. return;
  2782. if (playing_mode == AWE_PLAY_MULTI2) {
  2783. voice = voice_alloc->map[voice] >> 8;
  2784. if (voice < 0 || voice >= AWE_MAX_CHANNELS)
  2785. return;
  2786. }
  2788. cinfo = &channels[voice];
  2789. cinfo->panning = value;
  2790. DEBUG(2,printk("AWE32: [pan(%d) %d]n", voice, cinfo->panning));
  2791. if (ctrls[AWE_MD_REALTIME_PAN])
  2792. awe_voice_change(voice, awe_set_pan);
  2793. }
  2796. /* volume mode change */
  2797. static void
  2798. awe_volume_method(int dev, int mode)
  2799. {
  2800. /* not impremented */
  2801. DEBUG(0,printk("AWE32: [volmethod mode=%d]n", mode));
  2802. }
  2805. /* pitch wheel change: 0-16384 */
  2806. static void
  2807. awe_bender(int dev, int voice, int value)
  2808. {
  2809. awe_chan_info *cinfo;
  2811. if (! voice_in_range(voice))
  2812. return;
  2814. if (playing_mode == AWE_PLAY_MULTI2) {
  2815. voice = voice_alloc->map[voice] >> 8;
  2816. if (voice < 0 || voice >= AWE_MAX_CHANNELS)
  2817. return;
  2818. }
  2820. /* convert to zero centered value */
  2821. cinfo = &channels[voice];
  2822. cinfo->bender = value - 8192;
  2823. DEBUG(2,printk("AWE32: [bend(%d) %d]n", voice, cinfo->bender));
  2824. awe_voice_change(voice, awe_set_voice_pitch);
  2825. }
  2828. /*
  2829.  * load a sound patch:
  2830.  *   three types of patches are accepted: AWE, GUS, and SYSEX.
  2831.  */
  2833. static int
  2834. awe_load_patch(int dev, int format, const char *addr,
  2835.        int offs, int count, int pmgr_flag)
  2836. {
  2837. awe_patch_info patch;
  2838. int rc = 0;
  2840. #ifdef AWE_HAS_GUS_COMPATIBILITY
  2841. if (format == GUS_PATCH) {
  2842. return awe_load_guspatch(addr, offs, count, pmgr_flag);
  2843. } else
  2844. #endif
  2845. if (format == SYSEX_PATCH) {
  2846. /* no system exclusive message supported yet */
  2847. return 0;
  2848. } else if (format != AWE_PATCH) {
  2849. printk(KERN_WARNING "AWE32 Error: Invalid patch format (key) 0x%xn", format);
  2850. return -EINVAL;
  2851. }
  2853. if (count < AWE_PATCH_INFO_SIZE) {
  2854. printk(KERN_WARNING "AWE32 Error: Patch header too shortn");
  2855. return -EINVAL;
  2856. }
  2857. if (copy_from_user(((char*)&patch) + offs, addr + offs, 
  2858.    AWE_PATCH_INFO_SIZE - offs))
  2859. return -EFAULT;
  2861. count -= AWE_PATCH_INFO_SIZE;
  2862. if (count < patch.len) {
  2863. printk(KERN_WARNING "AWE32: sample: Patch record too short (%d<%d)n",
  2864.        count, patch.len);
  2865. return -EINVAL;
  2866. }
  2868. switch (patch.type) {
  2869. case AWE_LOAD_INFO:
  2870. rc = awe_load_info(&patch, addr, count);
  2871. break;
  2872. case AWE_LOAD_DATA:
  2873. rc = awe_load_data(&patch, addr, count);
  2874. break;
  2875. case AWE_OPEN_PATCH:
  2876. rc = awe_open_patch(&patch, addr, count);
  2877. break;
  2878. case AWE_CLOSE_PATCH:
  2879. rc = awe_close_patch(&patch, addr, count);
  2880. break;
  2881. case AWE_UNLOAD_PATCH:
  2882. rc = awe_unload_patch(&patch, addr, count);
  2883. break;
  2884. case AWE_REPLACE_DATA:
  2885. rc = awe_replace_data(&patch, addr, count);
  2886. break;
  2887. case AWE_MAP_PRESET:
  2888. rc = awe_load_map(&patch, addr, count);
  2889. break;
  2890. /* case AWE_PROBE_INFO:
  2891. rc = awe_probe_info(&patch, addr, count);
  2892. break;*/
  2893. case AWE_PROBE_DATA:
  2894. rc = awe_probe_data(&patch, addr, count);
  2895. break;
  2896. case AWE_REMOVE_INFO:
  2897. rc = awe_remove_info(&patch, addr, count);
  2898. break;
  2899. case AWE_LOAD_CHORUS_FX:
  2900. rc = awe_load_chorus_fx(&patch, addr, count);
  2901. break;
  2902. case AWE_LOAD_REVERB_FX:
  2903. rc = awe_load_reverb_fx(&patch, addr, count);
  2904. break;
  2906. default:
  2907. printk(KERN_WARNING "AWE32 Error: unknown patch format type %dn",
  2908.        patch.type);
  2909. rc = -EINVAL;
  2910. }
  2912. return rc;
  2913. }
  2916. /* create an sf list record */
  2917. static int
  2918. awe_create_sf(int type, char *name)
  2919. {
  2920. sf_list *rec;
  2922. /* terminate sounds */
  2923. awe_reset(0);
  2924. rec = (sf_list *)kmalloc(sizeof(*rec), GFP_KERNEL);
  2925. if (rec == NULL)
  2926. return 1; /* no memory */
  2927. rec->sf_id = current_sf_id + 1;
  2928. rec->type = type;
  2929. if (/*current_sf_id == 0 ||*/ (type & AWE_PAT_LOCKED) != 0)
  2930. locked_sf_id = current_sf_id + 1;
  2931. rec->num_info = awe_free_info();
  2932. rec->num_sample = awe_free_sample();
  2933. rec->mem_ptr = awe_free_mem_ptr();
  2934. rec->infos = rec->last_infos = NULL;
  2935. rec->samples = rec->last_samples = NULL;
  2937. /* add to linked-list */
  2938. rec->next = NULL;
  2939. rec->prev = sftail;
  2940. if (sftail)
  2941. sftail->next = rec;
  2942. else
  2943. sfhead = rec;
  2944. sftail = rec;
  2945. current_sf_id++;
  2947. #ifdef AWE_ALLOW_SAMPLE_SHARING
  2948. rec->shared = NULL;
  2949. if (name)
  2950. memcpy(rec->name, name, AWE_PATCH_NAME_LEN);
  2951. else
  2952. strcpy(rec->name, "*TEMPORARY*");
  2953. if (current_sf_id > 1 && name && (type & AWE_PAT_SHARED) != 0) {
  2954. /* is the current font really a shared font? */
  2955. if (is_shared_sf(rec->name)) {
  2956. /* check if the shared font is already installed */
  2957. sf_list *p;
  2958. for (p = rec->prev; p; p = p->prev) {
  2959. if (is_identical_name(rec->name, p)) {
  2960. rec->shared = p;
  2961. break;
  2962. }
  2963. }
  2964. }
  2965. }
  2966. #endif /* allow sharing */
  2968. return 0;
  2969. }
  2972. #ifdef AWE_ALLOW_SAMPLE_SHARING
  2974. /* check if the given name is a valid shared name */
  2975. #define ASC_TO_KEY(c) ((c) - 'A' + 1)
  2976. static int is_shared_sf(unsigned char *name)
  2977. {
  2978. static unsigned char id_head[4] = {
  2979. ASC_TO_KEY('A'), ASC_TO_KEY('W'), ASC_TO_KEY('E'),
  2980. AWE_MAJOR_VERSION,
  2981. };
  2982. if (memcmp(name, id_head, 4) == 0)
  2983. return TRUE;
  2984. return FALSE;
  2985. }
  2987. /* check if the given name matches to the existing list */
  2988. static int is_identical_name(unsigned char *name, sf_list *p) 
  2989. {
  2990. char *id = p->name;
  2991. if (is_shared_sf(id) && memcmp(id, name, AWE_PATCH_NAME_LEN) == 0)
  2992. return TRUE;
  2993. return FALSE;
  2994. }
  2996. /* check if the given voice info exists */
  2997. static int info_duplicated(sf_list *sf, awe_voice_list *rec)
  2998. {
  2999. /* search for all sharing lists */
  3000. for (; sf; sf = sf->shared) {
  3001. awe_voice_list *p;
  3002. for (p = sf->infos; p; p = p->next) {
  3003. if (p->type == V_ST_NORMAL &&
  3004.     p->bank == rec->bank &&
  3005.     p->instr == rec->instr &&
  3006.     p->v.low == rec->v.low &&
  3007.     p->v.high == rec->v.high &&
  3008.     p->v.sample == rec->v.sample)
  3009. return TRUE;
  3010. }
  3011. }
  3012. return FALSE;
  3013. }
  3015. #endif /* AWE_ALLOW_SAMPLE_SHARING */
  3018. /* free sf_list record */
  3019. /* linked-list in this function is not cared */
  3020. static void
  3021. awe_free_sf(sf_list *sf)
  3022. {
  3023. if (sf->infos) {
  3024. awe_voice_list *p, *next;
  3025. for (p = sf->infos; p; p = next) {
  3026. next = p->next;
  3027. kfree(p);
  3028. }
  3029. }
  3030. if (sf->samples) {
  3031. awe_sample_list *p, *next;
  3032. for (p = sf->samples; p; p = next) {
  3033. next = p->next;
  3034. kfree(p);
  3035. }
  3036. }
  3037. kfree(sf);
  3038. }
  3041. /* open patch; create sf list and set opened flag */
  3042. static int
  3043. awe_open_patch(awe_patch_info *patch, const char *addr, int count)
  3044. {
  3045. awe_open_parm parm;
  3046. int shared;
  3048. if (copy_from_user(&parm, addr + AWE_PATCH_INFO_SIZE, sizeof(parm)))
  3049. return -EFAULT;
  3050. shared = FALSE;
  3052. #ifdef AWE_ALLOW_SAMPLE_SHARING
  3053. if (sftail && (parm.type & AWE_PAT_SHARED) != 0) {
  3054. /* is the previous font the same font? */
  3055. if (is_identical_name(parm.name, sftail)) {
  3056. /* then append to the previous */
  3057. shared = TRUE;
  3058. awe_reset(0);
  3059. if (parm.type & AWE_PAT_LOCKED)
  3060. locked_sf_id = current_sf_id;
  3061. }
  3062. }
  3063. #endif /* allow sharing */
  3064. if (! shared) {
  3065. if (awe_create_sf(parm.type, parm.name)) {
  3066. printk(KERN_ERR "AWE32: can't open: failed to alloc new listn");
  3067. return -ENOMEM;
  3068. }
  3069. }
  3070. patch_opened = TRUE;
  3071. return current_sf_id;
  3072. }
  3074. /* check if the patch is already opened */
  3075. static sf_list *
  3076. check_patch_opened(int type, char *name)
  3077. {
  3078. if (! patch_opened) {
  3079. if (awe_create_sf(type, name)) {