diff -ruN --exclude CVS --exclude RCS alsa-driver/include/emu8000.h new/include/emu8000.h --- alsa-driver/include/emu8000.h Fri Nov 6 00:14:56 1998 +++ new/include/emu8000.h Mon Feb 22 17:16:51 1999 @@ -1,10 +1,9 @@ #ifndef __EMU8000_H #define __EMU8000_H - /* - * Definitions for the EMU-8000. + * Defines for the emu8000 (AWE32/64) * - * Copyright (c) by Jaroslav Kysela . + * Copyright (C) 1999 Steve Ratcliffe * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -23,14 +22,154 @@ */ #include "synth.h" +#include "lists.h" +#include "soundfont.h" +#include "seq_kernel.h" +#include "midi_channel.h" + +#define EMU8000_MAGIC (0x7e591a1e) +#define EMU8000_CHECK(emu) if (emu == NULL) { \ + snd_printd("*** Bad emu pointer (%s:%d)\n", __FILE__ , __LINE__);\ + return; \ + } \ + if (emu->magic != EMU8000_MAGIC) { \ + snd_printd("*** Bad magic number in EMU8000 (%s:%d)\n", \ + __FILE__, __LINE__); \ + return; \ + } -typedef struct snd_emu8000 emu8000_t; +/* + * Hardware parameters. + */ +#define EMU8000_MAX_DRAM (28 * 1024 * 1024) /* Max on-board mem is 28Mb ???*/ +#define EMU8000_DRAM_OFFSET 0x200000 /* Beginning of on board ram */ +#define EMU8000_CHANNELS 32 /* Number of hardware channels */ + +/* Flags to set a dma channel to read or write */ +#define EMU8000_RAM_READ 0 +#define EMU8000_RAM_WRITE 1 + +#define NELEM(arr) (sizeof(arr)/sizeof((arr)[0])) +/* + * A structure to keep track of each hardware voice on the emu8000 + */ +typedef struct emu8000_voice { + int ch; /* Hardware channel number */ + + int state; +#define EMU8000_ST_OFF 0x00 /* Not playing, and inactive */ +#define EMU8000_ST_ON 0x01 /* Note on */ +#define EMU8000_ST_RELEASED (0x02|EMU8000_ST_ON) /* Note released */ +#define EMU8000_ST_SUSTAINED (0x04|EMU8000_ST_ON) /* Note sustained */ +#define EMU8000_ST_DRAM 0x10 /* Being used for read/write */ +#define EMU8000_ST_FM 0x20 /* Being used for FM */ + + unsigned int time; /* An allocation time */ + short note; /* Note currently assigned to this voice */ + short velocity; /* Velocity of current note */ + + int avol; + int acutoff; + int apitch; + int aaux; + int apan; + + snd_sf_zone_t *zone; /* Zone assigned to this note */ + snd_midi_channel_t *chan; /* Midi channel for this note */ +} emu8000_voice_t; + +/* + * Structure to hold all state information for the emu8000 driver. + * + * Note 1: The chip supports 32 channels in hardware this is max_channels + * some of the channels may be used for other things so max_voices is + * the number in use for wave voices. + */ struct snd_emu8000 { - unsigned short port; - snd_spin_define(reg); + int magic; /* Magic number to detect incrorect structures */ + + unsigned short port1; /* Port usually base+0 */ + unsigned short port2; /* Port usually at base+0x400 */ + unsigned short port3; /* Port usually at base+0x800 */ + unsigned short last_reg;/* Last register command */ + + snd_card_t *card; /* The card that this belongs to */ + + int mem_size; /* Amount of ram on board */ + int max_channels; /* Number of channels on the chip (note 1) */ + int max_voices; /* Number of channels that we are using as voices */ + + snd_sf_list_t sflist; /* Soundfont list */ + + snd_info_entry_t *rom_proc_entry; /* The on board rom */ + snd_info_entry_t *ram_proc_entry; /* The on board ram */ + snd_info_entry_t *patch_proc_entry; /* Patch device */ + + struct emu8000_voice voices[EMU8000_CHANNELS]; /* Voices (EMU 'channel') */ + + int client; /* For the sequencer client */ +#define EMU8000_MAX_PORTS 4 + int ports[EMU8000_MAX_PORTS]; /* The ports for this device */ + snd_midi_channel_set_t *chsets[EMU8000_MAX_PORTS]; /* The channel sets for this device */ + + snd_spin_define(voice); /* Lock for voice access */ + snd_spin_define(reg); /* Lock for chip register access */ + snd_sleep_define(wait); /* Lock for waits */ }; +typedef struct snd_emu8000 emu8000_t; + +/* Macros for register access */ +#include "emu8000_reg.h" -extern snd_synth_t *snd_emu8000_new_device(snd_card_t * card, unsigned short port); +/* Prototypes for emu8000.c */ +void snd_emu8000_poke(emu8000_t *emu, unsigned int port, unsigned int reg, + unsigned int val); +unsigned short snd_emu8000_peek(emu8000_t *emu, unsigned int port, + unsigned int reg); +void snd_emu8000_poke_dw(emu8000_t *emu, unsigned int port, unsigned int reg, + unsigned int val); +unsigned int snd_emu8000_peek_dw(emu8000_t *emu, unsigned int port, + unsigned int reg); +snd_synth_t *snd_emu8000_new_device(snd_card_t *card, unsigned short base); +void snd_emu8000_dma_chan(emu8000_t *emu, int ch, int write); +int snd_emu8000_open_dma(emu8000_t *emu, int write); +void snd_emu8000_close_dma(emu8000_t *emu); +void snd_emu8000_read_wait(emu8000_t *emu); +void snd_emu8000_write_wait(emu8000_t *emu); +void snd_emu8000_wait(emu8000_t *emu, unsigned short delay); +int init_module(void); +void cleanup_module(void); + +/* Prototypes for emu8000_init.c */ +void snd_emu8000_init(emu8000_t *emu); +void snd_emu8000_init_fm(emu8000_t *emu); +void snd_emu8000_set_equalizer(emu8000_t *emu, int bass, int treble); +void snd_emu8000_set_chorus_mode(emu8000_t *emu, int effect); +void snd_emu8000_set_reverb_mode(emu8000_t *emu, int effect); + +/* Prototypes for emu8000_proc.c */ +void snd_emu8000_proc_init(emu8000_t *emu); +void snd_emu8000_proc_free(snd_info_entry_t *ip); + +/* Prototypes for emu8000_patch.c */ +int snd_emu8000_patch(emu8000_t *emu, const void *data, long count); + +/* Prototypes for sndgeneric.c */ +void *snd_list_newsize(void *name, int itemsize, int sizereq, int *max); + +#include "midi.h" + +/* Prototypes for emu8000_synth.c */ +void snd_emu8000_note_on(void *private, int note, int vel, + snd_midi_channel_t *chan); +void snd_emu8000_note_off(void *private, int note, int vel, + snd_midi_channel_t *chan); +void snd_emu8000_control(void *private, int type, snd_midi_channel_t *chan); +void snd_emu8000_terminate_all(emu8000_t *emu, int pnumber); + +/* Prototypes for emu8000_seq.c */ +void snd_emu8000_init_seq(emu8000_t *emu); +void snd_emu8000_detach_seq(emu8000_t *emu); -#endif /* __EMU8000_H */ +#endif diff -ruN --exclude CVS --exclude RCS alsa-driver/include/emu8000_reg.h new/include/emu8000_reg.h --- alsa-driver/include/emu8000_reg.h Thu Jan 1 00:00:00 1970 +++ new/include/emu8000_reg.h Mon Feb 22 17:16:51 1999 @@ -0,0 +1,208 @@ +#ifndef __EMU8000_REG_H +#define __EMU8000_REG_H +/* + * Register operations for the EMU8000 + * + * Copyright (C) 1999 Steve Ratcliffe + * + * Based on awe_wave.c by Takashi Iwai + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +/* + * Data port addresses relative to the EMU base. + */ +#define EMU8000_DATA0(e) ((e)->port1) +#define EMU8000_DATA1(e) ((e)->port2) +#define EMU8000_DATA2(e) ((e)->port2+2) +#define EMU8000_DATA3(e) ((e)->port3) +#define EMU8000_PTR(e) ((e)->port3+2) + +/* + * Make a command from a register and channel. + */ +#define EMU8000_CMD(reg, chan) ((reg)<<5 | (chan)) + +/* + * Commands to read and write the EMU8000 registers. + * These macros should be used for all register accesses. + */ +#define EMU8000_CPF_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(0, (chan))) +#define EMU8000_PTRX_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(1, (chan))) +#define EMU8000_CVCF_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(2, (chan))) +#define EMU8000_VTFT_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(3, (chan))) +#define EMU8000_PSST_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(6, (chan))) +#define EMU8000_CSL_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(7, (chan))) +#define EMU8000_CCCA_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(0, (chan))) +#define EMU8000_HWCF4_READ(emu) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 9)) +#define EMU8000_HWCF5_READ(emu) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 10)) +#define EMU8000_HWCF6_READ(emu) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 13)) +#define EMU8000_HWCF7_READ(emu) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 14)) +#define EMU8000_SMALR_READ(emu) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 20)) +#define EMU8000_SMARR_READ(emu) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 21)) +#define EMU8000_SMALW_READ(emu) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 22)) +#define EMU8000_SMARW_READ(emu) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 23)) +#define EMU8000_SMLD_READ(emu) \ + snd_emu8000_peek((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 26)) +#define EMU8000_SMRD_READ(emu) \ + snd_emu8000_peek((emu), EMU8000_DATA2(emu), EMU8000_CMD(1, 26)) +#define EMU8000_WC_READ(emu) \ + snd_emu8000_peek((emu), EMU8000_DATA2(emu), EMU8000_CMD(1, 27)) +#define EMU8000_HWCF1_READ(emu) \ + snd_emu8000_peek((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 29)) +#define EMU8000_HWCF2_READ(emu) \ + snd_emu8000_peek((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 30)) +#define EMU8000_HWCF3_READ(emu) \ + snd_emu8000_peek((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 31)) +#define EMU8000_INIT1_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(2, (chan))) +#define EMU8000_INIT2_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA2(emu), EMU8000_CMD(2, (chan))) +#define EMU8000_INIT3_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(3, (chan))) +#define EMU8000_INIT4_READ(emu, chan) \ + snd_emu8000_peek_dw((emu), EMU8000_DATA2(emu), EMU8000_CMD(3, (chan))) +#define EMU8000_ENVVOL_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA1(emu), EMU8000_CMD(4, (chan))) +#define EMU8000_DCYSUSV_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA1(emu), EMU8000_CMD(5, (chan))) +#define EMU8000_ENVVAL_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA1(emu), EMU8000_CMD(6, (chan))) +#define EMU8000_DCYSUS_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA1(emu), EMU8000_CMD(7, (chan))) +#define EMU8000_ATKHLDV_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA2(emu), EMU8000_CMD(4, (chan))) +#define EMU8000_LFO1VAL_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA2(emu), EMU8000_CMD(5, (chan))) +#define EMU8000_ATKHLD_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA2(emu), EMU8000_CMD(6, (chan))) +#define EMU8000_LFO2VAL_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA2(emu), EMU8000_CMD(7, (chan))) +#define EMU8000_IP_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA3(emu), EMU8000_CMD(0, (chan))) +#define EMU8000_IFATN_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA3(emu), EMU8000_CMD(1, (chan))) +#define EMU8000_PEFE_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA3(emu), EMU8000_CMD(2, (chan))) +#define EMU8000_FMMOD_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA3(emu), EMU8000_CMD(3, (chan))) +#define EMU8000_TREMFRQ_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA3(emu), EMU8000_CMD(4, (chan))) +#define EMU8000_FM2FRQ2_READ(emu, chan) \ + snd_emu8000_peek((emu), EMU8000_DATA3(emu), EMU8000_CMD(5, (chan))) + + +#define EMU8000_CPF_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(0, (chan)), (val)) +#define EMU8000_PTRX_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(1, (chan)), (val)) +#define EMU8000_CVCF_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(2, (chan)), (val)) +#define EMU8000_VTFT_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(3, (chan)), (val)) +#define EMU8000_PSST_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(6, (chan)), (val)) +#define EMU8000_CSL_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(7, (chan)), (val)) +#define EMU8000_CCCA_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(0, (chan)), (val)) +#define EMU8000_HWCF4_WRITE(emu, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 9), (val)) +#define EMU8000_HWCF5_WRITE(emu, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 10), (val)) +#define EMU8000_HWCF6_WRITE(emu, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 13), (val)) +#define EMU8000_HWCF7_WRITE(emu, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 14), (val)) +#define EMU8000_SMALR_WRITE(emu, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 20), (val)) +#define EMU8000_SMARR_WRITE(emu, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 21), (val)) +#define EMU8000_SMALW_WRITE(emu, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 22), (val)) +#define EMU8000_SMARW_WRITE(emu, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 23), (val)) +#define EMU8000_SMLD_WRITE(emu, val) \ + snd_emu8000_poke((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 26), (val)) +#define EMU8000_SMRD_WRITE(emu, val) \ + snd_emu8000_poke((emu), EMU8000_DATA2(emu), EMU8000_CMD(1, 26), (val)) +#define EMU8000_WC_WRITE(emu, val) \ + snd_emu8000_poke((emu), EMU8000_DATA2(emu), EMU8000_CMD(1, 27), (val)) +#define EMU8000_HWCF1_WRITE(emu, val) \ + snd_emu8000_poke((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 29), (val)) +#define EMU8000_HWCF2_WRITE(emu, val) \ + snd_emu8000_poke((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 30), (val)) +#define EMU8000_HWCF3_WRITE(emu, val) \ + snd_emu8000_poke((emu), EMU8000_DATA1(emu), EMU8000_CMD(1, 31), (val)) +#define EMU8000_INIT1_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(2, (chan)), (val)) +#define EMU8000_INIT2_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA2(emu), EMU8000_CMD(2, (chan)), (val)) +#define EMU8000_INIT3_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA1(emu), EMU8000_CMD(3, (chan)), (val)) +#define EMU8000_INIT4_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA2(emu), EMU8000_CMD(3, (chan)), (val)) +#define EMU8000_ENVVOL_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA1(emu), EMU8000_CMD(4, (chan)), (val)) +#define EMU8000_DCYSUSV_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA1(emu), EMU8000_CMD(5, (chan)), (val)) +#define EMU8000_ENVVAL_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA1(emu), EMU8000_CMD(6, (chan)), (val)) +#define EMU8000_DCYSUS_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA1(emu), EMU8000_CMD(7, (chan)), (val)) +#define EMU8000_ATKHLDV_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA2(emu), EMU8000_CMD(4, (chan)), (val)) +#define EMU8000_LFO1VAL_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA2(emu), EMU8000_CMD(5, (chan)), (val)) +#define EMU8000_ATKHLD_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA2(emu), EMU8000_CMD(6, (chan)), (val)) +#define EMU8000_LFO2VAL_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA2(emu), EMU8000_CMD(7, (chan)), (val)) +#define EMU8000_IP_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA3(emu), EMU8000_CMD(0, (chan)), (val)) +#define EMU8000_IFATN_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA3(emu), EMU8000_CMD(1, (chan)), (val)) +#define EMU8000_PEFE_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA3(emu), EMU8000_CMD(2, (chan)), (val)) +#define EMU8000_FMMOD_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA3(emu), EMU8000_CMD(3, (chan)), (val)) +#define EMU8000_TREMFRQ_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA3(emu), EMU8000_CMD(4, (chan)), (val)) +#define EMU8000_FM2FRQ2_WRITE(emu, chan, val) \ + snd_emu8000_poke((emu), EMU8000_DATA3(emu), EMU8000_CMD(5, (chan)), (val)) + +#define EMU8000_0080_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(4, (chan)), (val)) +#define EMU8000_00A0_WRITE(emu, chan, val) \ + snd_emu8000_poke_dw((emu), EMU8000_DATA0(emu), EMU8000_CMD(5, (chan)), (val)) + +#endif diff -ruN --exclude CVS --exclude RCS alsa-driver/include/lists.h new/include/lists.h --- alsa-driver/include/lists.h Thu Jan 1 00:00:00 1970 +++ new/include/lists.h Mon Feb 22 17:16:51 1999 @@ -0,0 +1,70 @@ +/* + * Macros to manage dynamically growing lists. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +/* + * Macros to manage dynamically growing lists. + */ +/* Declare a list */ +#define snd_list_declare(_type_, _name_) \ + _type_ *_name_;\ + int _name_##_itemsize; /* size of each item */\ + int _name_##_size; /* size of used array */\ + int _name_##_max /* size of allocated array */ + +/* Initialise a list for use */ +#define snd_list_prepare(_object_, _type_, _name_) \ + do { \ + _object_->_name_ = NULL;\ + _object_->_name_##_itemsize = sizeof(_type_); /* size of each item */\ + _object_->_name_##_size = 0; /* size of used array */\ + _object_->_name_##_max = 0; /* size of allocated array */\ + } while (0) + +/* Free the list */ +#define snd_list_free(_object_, _name_) \ + do { if (_object_) {\ + snd__list_free(_object_->_name_,\ + _object_->_name_##_itemsize * _object_->_name_##_max /*for snd_free*/);\ + _object_->_name_##_size = 0; /* size of used array */\ + _object_->_name_##_max = 0; /* size of allocated array */\ + } } while (0) + +/* Ensure that it will hold at least size items, returns + * a pointer to the possibly moved space */ +#define snd_list_ensure_size(_object_, _name_, _size_) \ + ((_size_ < _object_->_name_##_max)? _object_->name: \ + (((_object_->_name_ = snd_list_newsize(_object_->_name_,\ + _object_->_name_##_itemsize, _size_,\ + &_object_->_name_##_max)) != NULL)? _object_->_name_: NULL)) + +/* Ensure that it will hold at least inc more items, returns + * a pointer to the possibly moved space */ +#define snd_list_ensure_inc(_object_, _name_, _inc_) \ + ((_object_->_name_##_size + _inc_ < _object_->_name_##_max) \ + ? _object_->_name_: \ + (((_object_->_name_ = snd_list_newsize(_object_->_name_,\ + _object_->_name_##_itemsize, _object_->_name_##_size + _inc_,\ + &_object_->_name_##_max)) != NULL)? ( _object_->_name_):\ + NULL)) + + +void * snd_list_newsize(void *list, int itemsize, int sizereq, int *max); +void snd__list_free(void *list, int count); diff -ruN --exclude CVS --exclude RCS alsa-driver/include/midi_channel.h new/include/midi_channel.h --- alsa-driver/include/midi_channel.h Thu Jan 1 00:00:00 1970 +++ new/include/midi_channel.h Mon Feb 22 17:16:51 1999 @@ -0,0 +1,217 @@ +#ifndef __MIDI_EMULATION_H +#define __MIDI_EMULATION_H +/* + * Midi channel definition for optional channel management. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + + +/* + * This structure is used to keep track of the current state on each + * channel. All drivers for hardware that does not understand midi + * directly will probably need to use this structure. + */ +typedef struct { + void *private; /* A back pointer to driver data */ + int number; /* The channel number */ + int port; /* The port associated with this channel */ + + unsigned char midi_mode; /* GM, GS, XG etc */ + unsigned int + drum_channel:1, /* Drum channel */ + param_type:1 /* RPN/NRPN */ + ; + + unsigned char midi_aftertouch; /* Aftertouch (key pressure) */ + unsigned char midi_pressure; /* Channel pressure */ + unsigned char midi_program; /* Instrument number */ + short midi_pitchbend; /* Pitch bend amount */ + + unsigned char control[127]; /* Current value of all controls */ + unsigned char note[127]; /* Current status for all notes */ + + short gm_rpn_pitch_bend_range; /* Pitch bend range */ + short gm_rpn_fine_tuning; /* Master fine tuning */ + +} snd_midi_channel_t; + +/* + * A structure that represets a set of channels bound to a port. There + * would usually be 16 channels per port. But fewer could be used for + * particular cases. + * The channel set consists of information describing the client and + * port for this midi synth and an array of snd_midi_channel_t structures. + * A driver that had no need for snd_midi_channel_t could still use the + * channel set type if it wished with the channel array null. + */ +typedef struct snd_stru_midi_channel_set { + void *private_data; /* Driver data */ + int client; /* Client for this port */ + int port; /* The port number */ + + int max_channels; /* Size of the channels array */ + snd_midi_channel_t *channels; +} snd_midi_channel_set_t; + +typedef struct snd_seq_midi_op { + void (*note_on)(void *private, int note, int vel, snd_midi_channel_t *chan); + void (*note_off)(void *private,int note, int vel, snd_midi_channel_t *chan); + void (*control)(void *private, int type, snd_midi_channel_t *chan); +} snd_midi_op_t; + +/* + * Controller value numbers. + */ +#define SND_MIDI_CTL_BANK_SELECT 0 +#define SND_MIDI_CTL_MODULATION 1 +#define SND_MIDI_CTL_BREATH 2 +#define SND_MIDI_CTL_FOOT_PEDAL 4 +#define SND_MIDI_CTL_PORTAMENTO_TIME 5 +#define SND_MIDI_CTL_DATA_ENTRY 6 +#define SND_MIDI_CTL_VOLUME 7 +#define SND_MIDI_CTL_BALANCE 8 +#define SND_MIDI_CTL_PAN 10 +#define SND_MIDI_CTL_EXPRESSION 11 +#define SND_MIDI_CTL_EFFECT_CONTROL1 12 +#define SND_MIDI_CTL_EFFECT_CONTROL2 13 +#define SND_MIDI_CTL_SLIDER1 16 +#define SND_MIDI_CTL_SLIDER2 17 +#define SND_MIDI_CTL_SLIDER3 18 +#define SND_MIDI_CTL_SLIDER4 19 + +#define SND_MIDI_CTL_BANK_SELECT_LSB 32 +#define SND_MIDI_CTL_MODULATION_WHEEL_LSB 33 +#define SND_MIDI_CTL_BREATH_LSB 34 +#define SND_MIDI_CTL_FOOT_PEDAL_LSB 36 +#define SND_MIDI_CTL_PORTAMENTO_TIME_LSB 37 +#define SND_MIDI_CTL_DATA_ENTRY_LSB 38 +#define SND_MIDI_CTL_VOLUME_LSB 39 +#define SND_MIDI_CTL_BALANCE_LSB 40 +#define SND_MIDI_CTL_PAN_LSB 42 +#define SND_MIDI_CTL_EXPRESSION_LSB 43 +#define SND_MIDI_CTL_EFFECT_CONTROL1_LSB 44 +#define SND_MIDI_CTL_EFFECT_CONTROL2_LSB 45 + +#define SND_MIDI_CTL_HOLD 64 +#define SND_MIDI_CTL_PORTAMENTO 65 +#define SND_MIDI_CTL_SUSTENUTO 66 +#define SND_MIDI_CTL_SOFT 67 +#define SND_MIDI_CTL_LEGATO 68 +#define SND_MIDI_CTL_HOLD2 69 +#define SND_MIDI_CTL_SOUND_VARIATION 70 +#define SND_MIDI_CTL_SOUND_TIMBRE 71 +#define SND_MIDI_CTL_SOUND_RELEASE_TIME 72 +#define SND_MIDI_CTL_SOUND_ATTACK_TIME 73 +#define SND_MIDI_CTL_SOUND_BRIGHTNESS 74 + +#define SND_MIDI_CTL_NONREG_PARAM_LSB 98 +#define SND_MIDI_CTL_NONREG_PARAM 99 +#define SND_MIDI_CTL_REG_PARAM_LSB 100 +#define SND_MIDI_CTL_REG_PARAM 101 + +#define SND_MIDI_CTL_ALL_SOUNDS_OFF 120 +#define SND_MIDI_CTL_ALL_CONTROLLERS_OFF 121 +#define SND_MIDI_CTL_LOCAL_KEYBOARD 122 + +#define SND_MIDI_CTL_ALL_NOTES_OFF 123 +/* + * These defines are used so that pitchbend, aftertouch etc, can be + * distinguished from controller values. + */ +/* 0-127 controller values */ +#define SND_MIDI_CTL_PITCHBEND 128 +#define SND_MIDI_CTL_AFTERTOUCH 129 +#define SND_MIDI_CTL_PRESSURE 130 + +/* + * These names exist to allow symbolic access to the controls array. + * The usage is eg: chan->gm_bank_select. Another implementation would + * be really have these members in the struct, and not the array. + */ +#define gm_bank_select control[0] +#define gm_modulation control[1] +#define gm_breath control[2] +#define gm_foot_pedal control[4] +#define gm_portamento_time control[5] +#define gm_data_entry control[6] +#define gm_volume control[7] +#define gm_balance control[8] +#define gm_pan control[10] +#define gm_expression control[11] +#define gm_effect_control1 control[12] +#define gm_effect_control2 control[13] +#define gm_slider1 control[16] +#define gm_slider2 control[17] +#define gm_slider3 control[18] +#define gm_slider4 control[19] + +#define gm_bank_select_lsb control[32] +#define gm_modulation_wheel_lsb control[33] +#define gm_breath_lsb control[34] +#define gm_foot_pedal_lsb control[36] +#define gm_portamento_time_lsb control[37] +#define gm_data_entry_lsb control[38] +#define gm_volume_lsb control[39] +#define gm_balance_lsb control[40] +#define gm_pan_lsb control[42] +#define gm_expression_lsb control[43] +#define gm_effect_control1_lsb control[44] +#define gm_effect_control2_lsb control[45] + +#define gm_hold control[SND_MIDI_CTL_HOLD] +#define gm_portamento control[SND_MIDI_CTL_PORTAMENTO] +#define gm_sustenuto control[SND_MIDI_CTL_SUSTENUTO] + +/* + * These macros give the complete value of the controls that consist + * of coarse and fine pairs. Of course the fine controls are seldom used + * but there is no harm in being complete. + */ +#define SND_GM_BANK_SELECT(cp) (((cp)->control[0]<<7)|((cp)->control[32])) +#define SND_GM_MODULATION_WHEEL(cp) (((cp)->control[1]<<7)|((cp)->control[33])) +#define SND_GM_BREATH(cp) (((cp)->control[2]<<7)|((cp)->control[34])) +#define SND_GM_FOOT_PEDAL(cp) (((cp)->control[4]<<7)|((cp)->control[36])) +#define SND_GM_PORTAMENTO_TIME(cp) (((cp)->control[5]<<7)|((cp)->control[37])) +#define SND_GM_DATA_ENTRY(cp) (((cp)->control[6]<<7)|((cp)->control[38])) +#define SND_GM_VOLUME(cp) (((cp)->control[7]<<7)|((cp)->control[39])) +#define SND_GM_BALANCE(cp) (((cp)->control[8]<<7)|((cp)->control[40])) +#define SND_GM_PAN(cp) (((cp)->control[10]<<7)|((cp)->control[42])) +#define SND_GM_EXPRESSION(cp) (((cp)->control[11]<<7)|((cp)->control[43])) + + +/* MIDI mode */ +#define SND_MIDI_MODE_NONE 0 /* Generic midi */ +#define SND_MIDI_MODE_GM 1 +#define SND_MIDI_MODE_GS 2 +#define SND_MIDI_MODE_XG 3 + +/* MIDI note state */ +#define SND_MIDI_NOTE_OFF 0x00 +#define SND_MIDI_NOTE_ON 0x01 +#define SND_MIDI_NOTE_RELEASED 0x02 +#define SND_MIDI_NOTE_SUSTENUTO 0x04 + +#define SND_MIDI_PARAM_TYPE_REGISTERED 0 +#define SND_MIDI_PARAM_TYPE_NONREGISTERED 1 + +/* Prototypes for midi_process.c */ +void snd_midi_process_event(snd_midi_op_t *ops, snd_seq_event_t *ev, + snd_midi_channel_set_t *chanset); + +#endif diff -ruN --exclude CVS --exclude RCS alsa-driver/include/seq_alloc.h new/include/seq_alloc.h --- alsa-driver/include/seq_alloc.h Thu Jan 1 00:00:00 1970 +++ new/include/seq_alloc.h Mon Feb 22 17:16:51 1999 @@ -0,0 +1,33 @@ +#ifndef __SEQ_ALLOC_H +#define __SEQ_ALLOC_H +/* + * Allocation routines header. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include "seq_kernel.h" + +/* Prototypes for seq_alloc.c */ +void snd_init_port_callback(snd_seq_port_callback_t *p); +snd_seq_port_callback_t *snd_alloc_port_callback(void); +void snd_init_midi_channel(snd_midi_channel_t *p, int n); +snd_midi_channel_t *snd_alloc_midi_channels(int n); +snd_midi_channel_set_t *snd_alloc_midi_channel_set(int n); + +#endif diff -ruN --exclude CVS --exclude RCS alsa-driver/include/seq_midi_event.h new/include/seq_midi_event.h --- alsa-driver/include/seq_midi_event.h Thu Jan 1 00:00:00 1970 +++ new/include/seq_midi_event.h Mon Feb 22 17:16:51 1999 @@ -0,0 +1,25 @@ +/* + * Defines for seq_event_midi.c + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +/* Prototypes for seq_midi_event.c */ +int snd_seq_event_port_attach(int client, snd_seq_port_callback_t *pcbp, + int cap, int type, char *portname); +int snd_seq_event_port_detach(int client, int port); diff -ruN --exclude CVS --exclude RCS alsa-driver/include/soundfont.h new/include/soundfont.h --- alsa-driver/include/soundfont.h Thu Jan 1 00:00:00 1970 +++ new/include/soundfont.h Mon Feb 22 17:16:51 1999 @@ -0,0 +1,90 @@ +#ifndef __SOUNDFONT_H +#define __SOUNDFONT_H +/* + * Soundfont defines and definitions. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +/* At present using definition from oss driver to ease transition */ +#include "linux/awe_voice.h" + +#define SF_MAX_PRESETS 128 /* Includes drum bank */ +#define SF_IS_DRUM_BANK(z) ((z) == 128) + +#define SF_SAMPLE_BIDIR_LOOP AWE_SAMPLE_BIDIR_LOOP +#define SF_SAMPLE_REVERSE_LOOP AWE_SAMPLE_REVERSE_LOOP +#define SF_SAMPLE_NO_BLANK AWE_SAMPLE_NO_BLANK +#define SF_SAMPLE_SINGLESHOT AWE_SAMPLE_SINGLESHOT + +typedef struct snd_sf_zone { + struct snd_sf_zone_t *next; /* Link to next */ + unsigned char bank; /* Midi bank for this zone */ + unsigned char instr; /* Midi program for this zone */ + unsigned char mapped; /* True if mapped to something else */ + unsigned char disabled; /* True/false */ + + awe_voice_info v; /* All the soundfont parameters */ + struct snd_sf_sample *sample; /* Link to sample */ + + /* The following deals with preset numbers (programs) */ + struct snd_sf_zone *next_bank; /* Next bank for this preset */ + struct snd_sf_zone *next_instr; /* Next zone of this instrument */ + struct snd_sf_zone *zone_link; /* Next zone in play list */ +} snd_sf_zone_t; + +typedef struct snd_sf_sample { + awe_sample_info v; +} snd_sf_sample_t; +// ALT typedef awe_sample_info snd_sf_sample_t; + +/* + * This represents all the information relating to a soundfont. + */ +typedef struct snd_soundfont { + struct snd_soundfont *next; /* Link to next */ + struct snd_soundfont *prev; /* Link to previous */ + short id; /* file id */ + short type; /* ?? */ + int mem_offset; /* zero based offset into sample memory */ + snd_list_declare(snd_sf_zone_t, zones); /* Font information */ + snd_list_declare(snd_sf_sample_t, samples);/* The sample headers */ +} snd_soundfont_t; + +/* + * List of soundfonts. + */ +typedef struct snd_sf_list { + int current_id; /* Current soundfont id */ + int locked_id; + snd_soundfont_t *currsf; /* The currently open soundfont */ + snd_sf_zone_t *presets[SF_MAX_PRESETS+1]; + snd_list_declare(snd_soundfont_t, fonts); /* The list of soundfonts */ +} snd_sf_list_t; + +/* Type of the sample write callback */ +typedef int (*snd_sf_sample_write_t)(void *, snd_sf_sample_t *sp, + const void *, long); + +/* Prototypes for soundfont.c */ +int snd_soundfont_load(snd_sf_list_t *sflist, const void *data, long count, + snd_sf_sample_write_t sw, void *callarg); +void snd_sf_init(snd_sf_list_t *sflist); +void snd_sf_free(snd_sf_list_t *sflist); + +#endif diff -ruN --exclude CVS --exclude RCS alsa-driver/kernel/Makefile new/kernel/Makefile --- alsa-driver/kernel/Makefile Wed Feb 3 23:53:31 1999 +++ new/kernel/Makefile Mon Feb 22 17:16:51 1999 @@ -22,7 +22,9 @@ pcm_export.c midi_export.c timer_export.c synth_export.c PERSIST = persist.o persist_export.o OBJECTS = sound.o init.o isadma.o memory.o \ - info.o control.o pci.o misc.o sthread.o snd_export.o + info.o control.o pci.o misc.o sthread.o snd_export.o \ + lists.o + ifeq (1,$(SNDCFG_OSSEMUL)) OBJECTS += sound_oss.o info_oss.o endif @@ -32,6 +34,7 @@ TIMER = timer.o timer_export.o SYNTH = synth.o synth_export.o TEST = test.o +RTCTIMER = rtctimer.o include $(TOPDIR)/Rules.make @@ -69,6 +72,10 @@ snd-test.o: .depend $(SNDVERSIONS) $(TEST) $(LINKER) -o $@ $(TEST) + +rtc: snd-rtctimer.o +snd-rtctimer.o: .depend $(SNDVERSIONS) $(RTCTIMER) + $(LINKER) -o $@ $(RTCTIMER); gcompile: $(TARGETS) diff -ruN --exclude CVS --exclude RCS alsa-driver/kernel/lists.c new/kernel/lists.c --- alsa-driver/kernel/lists.c Thu Jan 1 00:00:00 1970 +++ new/kernel/lists.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,71 @@ +/* + * List allocation routines. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include "driver.h" + +/* + * NOTES: + * + * List allocation routines. At present they keep one big chunch + * of memory so that they can be accessed like an array. This is so it + * makes things similar to the OSS driver. + * Other approaches need investigating. + * + * Currently use vmalloc/vfree because need to much memory to use snd_malloc() + */ + +#define ALLOC_STEP 20 +/* + * Resizes a list. Returns a pointer the (possibly moved) list and + * updates the maxsize of the list though max. + * More space than requested is allocated to avoid repeated calls. + */ +void * +snd_list_newsize(void *list, int itemsize, int sizereq, int *max) +{ + void *new; + /* Grrr, there is no snd_realloc ... */ + + sizereq += ALLOC_STEP; + new = vmalloc(sizereq * itemsize/*, GFP_KERNEL*/); + if (new == NULL) + return NULL; + + if (list) { + memcpy(new, list, *max * itemsize); + vfree(list/*, *max * itemsize*/); + } + + *max = sizereq; + //snd_printk("new mem %p, n=%d, size %d\n", new, *max, *max * itemsize); + return new; +} + +/* + * Free a list. + * The macro has one underscore this function two. + */ +/*ARGSUSED*/ +void +snd__list_free(void *list, int count) +{ + vfree(list); +} diff -ruN --exclude CVS --exclude RCS alsa-driver/kernel/seq/Makefile new/kernel/seq/Makefile --- alsa-driver/kernel/seq/Makefile Mon Jan 4 14:37:53 1999 +++ new/kernel/seq/Makefile Mon Feb 22 17:16:51 1999 @@ -14,8 +14,8 @@ OBJECTS = seq.o seq_clientmgr.o seq_memory.o seq_queue.o \ seq_fifo.o seq_prioq.o seq_timer.o \ seq_system.o seq_ports.o seq_export.o \ - seq_info.o -MIDI = seq_midi.o seq_midi_export.o + seq_info.o seq_alloc.o +MIDI = seq_midi.o seq_midi_event.o seq_midi_export.o include $(TOPDIR)/Rules.make diff -ruN --exclude CVS --exclude RCS alsa-driver/kernel/seq/seq_alloc.c new/kernel/seq/seq_alloc.c --- alsa-driver/kernel/seq/seq_alloc.c Thu Jan 1 00:00:00 1970 +++ new/kernel/seq/seq_alloc.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,117 @@ +/* + * Allocation routines for sequencer related structures. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +/* + * Code to allocate and initialise structures used. + * memset() should not be used to initialize pointers + * to null. + */ + +#include "driver.h" + +#include "seq_kernel.h" +#include "midi_channel.h" + +/* + * Initialise a port callback structure. + */ +void +snd_init_port_callback(snd_seq_port_callback_t *p) +{ + if (!p) + return; + p->use = NULL; + p->unuse = NULL; + p->subscribe = NULL; + p->unsubscribe = NULL; + p->event_input = NULL; + p->private_data = NULL; +} + +/* + * Allocate and initialise a port callback + */ +snd_seq_port_callback_t * +snd_alloc_port_callback(void) +{ + snd_seq_port_callback_t *p; + + p = snd_malloc(sizeof(snd_seq_port_callback_t)); + snd_init_port_callback(p); + + return p; +} + +/* + * Initialise a single midi channel control block. + */ +void +snd_init_midi_channel(snd_midi_channel_t *p, int n) +{ + if (!p) + return; + + memset(p, 0, sizeof(snd_midi_channel_t)); + p->private = NULL; + p->number = n; + + p->gm_volume = 127; + p->gm_expression = 127; + p->gm_pan = 64; + p->gm_rpn_pitch_bend_range = 200; + + if (n == 9) + p->drum_channel = 1; /* Default ch 10 as drums */ +} + +/* + * Allocate and initialise a set of midi channel control blocks. + */ +snd_midi_channel_t * +snd_alloc_midi_channels(int n) +{ + snd_midi_channel_t *chan; + int i; + + chan = snd_malloc(n * sizeof(snd_midi_channel_t)); + if (chan) { + for (i = 0; i < n; i++) + snd_init_midi_channel(chan+i, i); + } + + return chan; +} + +/* + * Allocate and initialise a midi channel set. + */ +snd_midi_channel_set_t * +snd_alloc_midi_channel_set(int n) +{ + snd_midi_channel_set_t *chset; + + chset = snd_malloc(sizeof(*chset)); + chset->channels = snd_alloc_midi_channels(n); + + chset->private_data = NULL; + chset->max_channels = n; + return chset; +} diff -ruN --exclude CVS --exclude RCS alsa-driver/kernel/seq/seq_export.sym new/kernel/seq/seq_export.sym --- alsa-driver/kernel/seq/seq_export.sym Mon Jan 4 14:38:11 1999 +++ new/kernel/seq/seq_export.sym Mon Feb 22 17:16:51 1999 @@ -1,5 +1,8 @@ + #include "seq_kernel.h" + #include "seq_timer.h" ++ #include "seq_kernel.h" ++ #include "midi_channel.h" ++ #include "seq_alloc.h" # # symbols for kernel clients # @@ -9,3 +12,6 @@ snd_seq_kernel_client_ctl snd_seq_ext_malloc snd_seq_ext_free +snd_alloc_midi_channel_set +snd_init_midi_channel +snd_alloc_port_callback diff -ruN --exclude CVS --exclude RCS alsa-driver/kernel/seq/seq_midi_event.c new/kernel/seq/seq_midi_event.c --- alsa-driver/kernel/seq/seq_midi_event.c Thu Jan 1 00:00:00 1970 +++ new/kernel/seq/seq_midi_event.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,220 @@ +/* + * Generic event based MIDI synth driver for ALSA sequencer + * + * Copyright (c) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + + /* + * Routines to manage devices that want to receive events from the sequencer. + * The driver attaches to the sequencer using snd_seq_event_port_attach(). + */ + +#include "driver.h" +#include "midi.h" +#include "seq_kernel.h" +#include "seq_midi.h" + + +#if 0 +typedef struct snd_seq_stru_event_filter { + int card; /* Card number */ + int client; /* Client number */ + int port; /* Port number */ + + snd_seq_port_callback_t cb; /* Callbacks to be linked in */ + + struct snd_seq_stru_event_filter *next; /* Next in chain */ +} snd_seq_event_filter_t; + +/* + * Callbacks. The use, unuse etc callbacks are only called on the first + * and final opens/closes. You don't get called for each open. + */ +/* + * Callback for when this port is opened for output for the first time. + */ +static int +use(void *private_data) +{ + snd_seq_event_filter_t *f; + int ret = 0; + + f = private_data; + if (f == NULL) + return -EINVAL; + + MOD_INC_USE_COUNT; + + for (; f != NULL && ret >= 0; f = f->next) { + if (f->cb.use) + ret = f->cb.use(f->cb.private_data); + } + + if (ret < 0) + MOD_DEC_USE_COUNT; + + return ret; +} + + +/* + * Callback for when this port is closed for output for final time. + */ +static int +unuse(void *private_data) +{ + snd_seq_event_filter_t *f; + int ret = 0; + + f = private_data; + if (f == NULL) + ret = -EINVAL; + + for (; f != NULL && ret >= 0; f = f->next) { + if (f->cb.unuse) + ret = f->cb.unuse(f->cb.private_data); + } + + MOD_DEC_USE_COUNT; + return ret; +} + +/* + * Callback for when this port is opened for input for first time. + */ +static int +subscribe(void *private_data) +{ + snd_seq_event_filter_t *f; + int ret = 0; + + f = private_data; + if (f == NULL) + return -EINVAL; + + MOD_INC_USE_COUNT; + + for (; f !=NULL && ret >= 0; f = f->next) { + if (f->cb.subscribe) + ret = f->cb.subscribe(f->cb.private_data); + } + + if (ret < 0) + MOD_DEC_USE_COUNT; + + return ret; +} + +/* + * Callback for when this port is closed for input for the final + * time. + */ +static int +unsubscribe(void *private_data) +{ + snd_seq_event_filter_t *f; + int ret = 0; + + f = private_data; + if (f == NULL) + ret = -EINVAL; + + for (; f != NULL && ret >= 0; f = f->next) { + if (f->cb.unsubscribe) + ret = f->cb.unsubscribe(f->cb.private_data); + } + + MOD_DEC_USE_COUNT; + return ret; +} + +/* + * call-back function for event input. + * This is a bit of a poor name, I would call this an output... + */ +static int +event_input(snd_seq_event_t *ev, void *private_data) +{ + snd_seq_event_filter_t *f = private_data; + int ret = 0; + + if (!f || !ev) + return -EINVAL; + + for (; f !=NULL && ret >= 0; f = f->next) { + if (f->cb.event_input) + ret = f->cb.event_input(ev, f); + } + + return ret; +} +#endif + +/* + * Attach a device driver that wants to receive events from the + * sequencer. Returns the new port number on success. + * A driver that wants to receive the events converted to midi, will + * use snd_seq_midisynth_register_port(). + */ +int +snd_seq_event_port_attach(int client, snd_seq_port_callback_t *pcbp, + int cap, int type, char *portname) +{ + snd_seq_port_info_t portinfo; + int ret; + + /* Set up the port */ + portinfo.client = client; + if (portname) + strncpy(portinfo.name, portname, sizeof(portinfo.name)); + else + sprintf(portinfo.name, "Unamed port"); + + portinfo.capability = SND_SEQ_PORT_CAP_SUBSCRIPTION; + portinfo.capability |= cap; + portinfo.type = type; + portinfo.kernel = pcbp; + + /* Create it */ + ret = snd_seq_kernel_client_ctl(client, SND_SEQ_IOCTL_CREATE_PORT, + &portinfo); + + if (ret >= 0) + ret = portinfo.port; + + return ret; +} + + +/* + * Detach the driver from a port. + */ +int +snd_seq_event_port_detach(int client, int port) +{ + snd_seq_port_info_t portinfo; + int err; + + memset(&portinfo, 0, sizeof(portinfo)); + portinfo.client = client; + portinfo.port = port; + err = snd_seq_kernel_client_ctl(client, SND_SEQ_IOCTL_DELETE_PORT, + &portinfo); + + return err; +} diff -ruN --exclude CVS --exclude RCS alsa-driver/kernel/seq/seq_midi_export.sym new/kernel/seq/seq_midi_export.sym --- alsa-driver/kernel/seq/seq_midi_export.sym Sun Dec 27 00:25:33 1998 +++ new/kernel/seq/seq_midi_export.sym Mon Feb 22 17:16:51 1999 @@ -1,7 +1,10 @@ + #include "seq_kernel.h" + #include "seq_midi.h" ++ #include "seq_midi_event.h" # # symbols for midisynth clients # snd_seq_midisynth_register_port snd_seq_midisynth_unregister_port +snd_seq_event_port_attach +snd_seq_event_port_detach diff -ruN --exclude CVS --exclude RCS alsa-driver/kernel/snd_export.sym new/kernel/snd_export.sym --- alsa-driver/kernel/snd_export.sym Wed Feb 3 23:53:32 1999 +++ new/kernel/snd_export.sym Mon Feb 22 17:16:51 1999 @@ -3,6 +3,7 @@ + #include "sndpci.h" + #include "sndpersist.h" + #include "sthread.h" ++ #include "lists.h" # sound.c snd_ecards_limit snd_register_device @@ -77,3 +78,6 @@ # sthread.c snd_thread_create snd_thread_remove +# lists.c +snd__list_free +snd_list_newsize diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/Makefile new/lowlevel/sb/Makefile --- alsa-driver/lowlevel/sb/Makefile Sun Aug 23 20:16:58 1998 +++ new/lowlevel/sb/Makefile Mon Feb 22 17:16:51 1999 @@ -8,11 +8,20 @@ include $(TOPDIR)/Makefile.conf TARGETS = $(SNDVERSIONS) \ + $(TOPDIR)/modules/snd-emu8000.o \ $(TOPDIR)/modules/snd-sb-dsp.o \ - $(TOPDIR)/modules/snd-emu8000.o + $(EMPTY) + SYMFILES = sb_export.c emu8000_export.c SBDSP = sb.o sb8.o sb16.o mixer.o midi.o sb_export.o -EMU8000 = emu8000.o emu8000_export.o +EMU8000 =\ + midi_emulate.o \ + emu8000_seq.o \ + emu8000_synth.o \ + emu8000_patch.o soundfont.o \ + emu8000.o emu8000_export.o emu8000_init.o\ + emu8000_proc.o \ + $(EMPTY) include $(TOPDIR)/Rules.make @@ -21,6 +30,10 @@ @echo "ALSA SoundBlaster modules were sucessfully compiled." @echo +install: all + cp $(TOPDIR)/modules/snd-sb-dsp.o $(TOPDIR)/modules/snd-emu8000.o \ + /lib/modules/`uname -r`/misc + include $(TOPDIR)/Rules1.make $(TOPDIR)/modules/snd-sb-dsp.o: .depend $(SNDVERSIONS) $(SBDSP) @@ -41,6 +54,10 @@ dep: .depend dummy: + +README: $(HOME)/websrc/alsa/index.mm + HERE=$$PWD; cd $(HOME)/websrc/alsa;\ + mmtext -o $$HERE/README ../text.mm index.mm # # include a dependency file if one exists diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/README new/lowlevel/sb/README --- alsa-driver/lowlevel/sb/README Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/README Mon Feb 22 17:16:51 1999 @@ -0,0 +1,176 @@ + +1. AWE64 midi synth driver v0.4.0 + + +1.1 Description + +Here is my experimental AWE64 midi synth driver for ALSA. With +it you can play a type 0 midi file using the playmidi1 test program. +A temporary method also exists for connecting Midi-in to the driver +which allows direct playing from a midi keyboard. + +Since I hope that parts of this driver patch will be useful for +writing similar drivers. + +1.1.1 Version 0.4.0 + +Big reorganization of the interface. + + + The driver now appears as four ports on one kernel client. + This gives you 64 midi channels (you only can have less + than 30 voices at once). + + Routines to connect drivers that use sequencer events, + rather than raw midi, are provided. + + The MIDI emulation is separated out so that other drivers + could use it. + + Sustain is added and so now the most common controls are + implemented. The framework is there to quickly add the + rest. + +If you have previously downloaded my modified playmidi1.c file +you will need to replace it with the latest. + +2. What is needed + + +2.1 Downloads + +You need to download the + + + The alsa-emu-0.4.0.patch.gz driver source. This is in + the form of a patch that can be applied to the current + CVS tree of ALSA. I don't think that it will patch the + latest release of ALSA so be sure to use an up to date + CVS tree. + + Source to a slightly modified version of sfxload alsa-sfx.tar.gz + or as a patch against sfxload-0.4.2. + + Use this playmidi1.c instead of the one in the alsa-lib/test + directory. + + Earlier restrictions on the soundfont you can use no longer + apply. But if you don't have a suitable one use GU11-ROM.SF2.gz + (as supplied with RedHat). + +3. Building + + +3.1 Apply patch + +The patch (its mainly new files) should be unpacked in the alsa-driver +directory. + + cd ..where-ever/alsa-driver + patch -p1 < alsa-emu-0.4.0.patch + +3.2 Driver + +After applying the patch it should just build if you have a 2.2.x +system. I have not even tried it on 2.0.x. + + autoconf + ./configure --with-sequencer=yes --with-isapnp=yes --with-debug=full + make install + +The --with-cards=sbawe option can be used to cut down on compilation +time. + +3.3 sfxload + +Unpack the source somewhere and type make. + +3.4 Making it work + +You have to follow this slightly lengthy procedure to load everything +up. You will probably want to make these steps into a script. + + 1. Load modules as normal + + modprobe snd-sbawe + + 2. Load a soundfont that uses only the ROM samples, (writing + samples to RAM is not quite supported yet). You need to + use the very slightly modified sfxload that you downloaded + above to do this. + + sfxload GU11-ROM.SF2 + + Must use the newly built version. + 3. Un-mute channels as normal using alsamixer, xamixer, amixer + etc. Make sure that the synth output is un-muted and turned + up. + + +Now you should be able to run the test playmidi1 program. + +3.4.1 Controls + +There are a few things that can be controlled temporarily via +the patch interface. + + dd if=/dev/asound/0/patch0 count=1 bs=1 + +Using a different block size will trigger a particular command. + +bs=1Trigger a test note. +bs=2Connect MIDI-in to the synth. After this command it will be +possible to play from a connected keyboard etc. +bs=3Disconnects from MIDI-in. +bs=4All notes off. This is now done automatically when the sequencer +disconnects, so this is not really needed anymore needed. + +3.5 Unloading the modules + +Should you want to unload the modules you may find that you need +to run the following command first. (But try without first as +this may not be a problem anymore). + + dd if=/proc/asound/0/patch0 bs=3 count=1 + +Then you can unload everything with a simple + + modprobe -r snd-sbawe + +3.6 Possible problems and limitations. + + + -- It will most likely break if you try to load a font while + playing. There is no locking at all between these actions. + I haven't actually had a problem, but you were warned. + Temporary solution: don't do it. + -- You can now load a soundfont that uses samples that are + stored in RAM. Although it works it is much slower to + load than it should be. This is because I can not get + the samples to write to RAM reliably. Many samples will + write perfectly, but some will have a large number of + missing sample points. It is as if sometimes the write + address pointer does not increment properly (I saw the + same problem on read as well, leading to duplicate words). + The only way that I can get it to work is to set the address + each time. The OSS driver doesn't do this and seems to + work fine so there must be something that I am missing. + Any help would be appreciated. + -- There is not a good method of loading up the sequencer + client. Really the user is the only one who can know what + should be connected to what. You may or may not want MIDI + in to be connected directly to the soundcard. Therefore + we need a user utility to determine which client/port + combinations are connected together. At present I just + have a hack to connect the synth driver to the MIDI-in. + Thats all the dd stuff. + -- I get + + snd: seq: snd_seq_pool_done() - pool isn't free!! + + messages. When a client disconnects from the synth. I + believe that this is harmless, or at least mostly harmless. + +4. Feedback + + +4.1 Bug reports + +Please let me know if this works for you. I am happy to receive +bug reports, or any mail about this driver. Send them to steve@parabola.demon.co.uk + +4.1.1 Design notes + +There are some design notes (under construction). diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/emu8000.c new/lowlevel/sb/emu8000.c --- alsa-driver/lowlevel/sb/emu8000.c Sat Jan 23 15:45:01 1999 +++ new/lowlevel/sb/emu8000.c Mon Feb 22 17:16:51 1999 @@ -1,8 +1,8 @@ /* * Copyright (c) by Jaroslav Kysela - * Routines for control of EMU8000 chip + * and (c) 1999 Steve Ratcliffe * - * This is only prepared envelope for developers of EMU8000 code. + * Routines for control of EMU8000 chip * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -23,67 +23,101 @@ #define SND_MAIN_OBJECT_FILE #include "driver.h" #include "emu8000.h" +#include "info.h" -/* +static int snd_emu8000_detect(emu8000_t * emu); +static void snd_emu8000_free(void *private_data); +/* + * The following routines read and write registers on the emu8000. They + * should always be called via the EMU8000*READ/WRITE macros and never + * directly. The macros handle the port number and command word. */ +/* Write a word */ +void snd_emu8000_poke(emu8000_t *emu, unsigned int port, unsigned int reg, unsigned int val) +{ + unsigned long flags; + //printk("poke %x, reg %d,%d --> %x\n", port, reg>>5, reg&0x1f, val); + //outw((unsigned short)reg, EMU8000_PTR(emu)); /* Set register */ + if (val & 0xffff0000) + snd_printd("UhOh: %x poke(%d, %d)\n", val, port, reg); + snd_spin_lock(emu, reg, &flags); + if (reg != emu->last_reg) { + outw((unsigned short)reg, EMU8000_PTR(emu)); /* Set register */ + emu->last_reg = reg; + } + outw((unsigned short)val, port); /* Send data */ + snd_spin_unlock(emu, reg, &flags); +} -#define EMU8000_CMD( addr, reg, chn ) \ - (((addr) << 16) | ((reg) << 5) | (chn)) - -#define EMU8000_DATA0 0x620 -#define EMU8000_DATA1 0xa20 -#define EMU8000_DATA2 0xa22 -#define EMU8000_DATA3 0xe20 -#define EMU8000_PTR 0xe22 +/* Read a word */ +unsigned short snd_emu8000_peek(emu8000_t *emu, unsigned int port, unsigned int reg) +{ + unsigned short res; + unsigned long flags; -#define EMU8000_U1 EMU8000_CMD( EMU8000_DATA3, 0, 0xe0 ) -#define EMU8000_HWCF1 EMU8000_CMD( EMU8000_DATA1, 1, 29 ) -#define EMU8000_HWCF2 EMU8000_CMD( EMU8000_DATA1, 1, 30 ) -#define EMU8000_HWCF3 EMU8000_CMD( EMU8000_DATA1, 1, 31 ) + //outw((unsigned short)reg, EMU8000_PTR(emu)); /* Set register */ + snd_spin_lock(emu, reg, &flags); + if (reg != emu->last_reg) { + outw((unsigned short)reg, EMU8000_PTR(emu)); /* Set register */ + emu->last_reg = reg; + } + res = inw(port); /* Read data */ + snd_spin_unlock(emu, reg, &flags); + //printk("peek %x, reg %d,%d --> %x\n", port, reg>>5, reg&0x1f, res); + return res; +} -static void snd_emu8000_poke(emu8000_t * emu, - unsigned int cmd, unsigned short val) +/* Write a double word */ +void snd_emu8000_poke_dw(emu8000_t *emu, unsigned int port, unsigned int reg, unsigned int val) { - outw((unsigned short) cmd, emu->port + 0x802); - outw(val, (emu->port - 0x620) + (cmd >> 16)); + unsigned long flags; + //printk("pokedw %x, reg %d,%d --> %x\n", port, reg>>5, reg&0x1f, val); + snd_spin_lock(emu, reg, &flags); + if (reg != emu->last_reg) { + outw((unsigned short)reg, EMU8000_PTR(emu)); /* Set register */ + emu->last_reg = reg; + } + outw((unsigned short)val, port); /* Send low word of data */ + outw((unsigned short)(val>>16), port+2); /* Send high word of data */ + snd_spin_unlock(emu, reg, &flags); } -static unsigned short snd_emu8000_peek(emu8000_t * emu, unsigned int cmd) +/* Read a double word */ +unsigned int snd_emu8000_peek_dw(emu8000_t *emu, unsigned int port, unsigned int reg) { -#if 1 - outw((unsigned short) cmd, emu->port + 0x802); - return inw((emu->port - 0x620) + (cmd >> 16)); -#else - unsigned short res; + unsigned short low; + unsigned int res; + unsigned long flags; + + //outw((unsigned short) reg, EMU8000_PTR(emu)); /* Set register */ + snd_spin_lock(emu, reg, &flags); + if (reg != emu->last_reg) { + outw((unsigned short)reg, EMU8000_PTR(emu)); /* Set register */ + emu->last_reg = reg; + } + low = inw(port); /* Read low word of data */ - outw((unsigned short) cmd, emu->port + 0x802); - res = inw((emu->port - 0x620) + (cmd >> 16)); - printk("res = 0x%x, cmd = 0x%x, cmd port = 0x%x, read port = 0x%x\n", res, cmd, - emu->port + 0x802, - (emu->port - 0x620) + (cmd >> 16)); + res = low + (inw(port+2) << 16); + snd_spin_unlock(emu, reg, &flags); + //printk("peekdw %x, reg %d,%d --> %x\n", port, reg>>5, reg&0x1f, res); return res; -#endif } static int snd_emu8000_detect(emu8000_t * emu) { -#if 0 - printk("0x620 = 0x%x\n", inw(0x620)); - printk("0x622 = 0x%x\n", inw(0x622)); - printk("0x624 = 0x%x\n", inw(0x624)); - printk("0xa20 = 0x%x\n", inw(0xa20)); - printk("0xe20 = 0x%x\n", inw(0xe20)); -#endif - if ((snd_emu8000_peek(emu, EMU8000_U1) & 0x000f) != 0x000c) + /* Initialise */ + EMU8000_HWCF1_WRITE(emu, 0x0059); + EMU8000_HWCF2_WRITE(emu, 0x0020); + EMU8000_HWCF3_WRITE(emu, 0x0000); + /* Check for a recognisable emu8000 */ + //if ((EMU8000_U1_READ(emu) & 0x000f) != 0x000c) + //return -ENODEV; + if ((EMU8000_HWCF1_READ(emu) & 0x007e) != 0x0058) return -ENODEV; - if ((snd_emu8000_peek(emu, EMU8000_HWCF1) & 0x007e) != 0x0058) + if ((EMU8000_HWCF2_READ(emu) & 0x0003) != 0x0003) return -ENODEV; - if ((snd_emu8000_peek(emu, EMU8000_HWCF2) & 0x0003) != 0x0003) - return -ENODEV; - snd_emu8000_poke(emu, EMU8000_HWCF1, 0x0059); - snd_emu8000_poke(emu, EMU8000_HWCF2, 0x0020); - snd_emu8000_poke(emu, EMU8000_HWCF3, 0x0000); + return 0; } @@ -93,6 +127,21 @@ static void snd_emu8000_free(void *private_data) { + emu8000_t *emu; + + emu = (emu8000_t *)private_data; + + snd_emu8000_detach_seq(emu); + +/* It would be nice if info_free_entry would do this for us */ +snd_emu8000_proc_free(emu->ram_proc_entry); /* TEMP */ + snd_info_free_entry(emu->ram_proc_entry); +snd_emu8000_proc_free(emu->rom_proc_entry); /* TEMP */ + snd_info_free_entry(emu->rom_proc_entry); +snd_emu8000_proc_free(emu->patch_proc_entry); /* TEMP */ + snd_info_free_entry(emu->patch_proc_entry); + + snd_sf_free(&emu->sflist); snd_free(private_data, sizeof(emu8000_t)); } @@ -104,27 +153,164 @@ if ((synth = snd_synth_new_device(card, "EMU8000")) == NULL) return NULL; + strcpy(synth->name, "EMU-8000"); + emu = snd_calloc(sizeof(emu8000_t)); if (!emu) { snd_synth_free(synth); return NULL; } - strcpy(synth->name, "EMU-8000"); - emu->port = base; + + emu->magic = EMU8000_MAGIC; + + emu->port1 = base; + emu->port2 = base + 0x400; + emu->port3 = base + 0x800; + + emu->card = card; + + emu->mem_size = -1; + emu->max_channels = EMU8000_CHANNELS; + emu->max_voices = EMU8000_CHANNELS; + + snd_spin_prepare(emu, voice); snd_spin_prepare(emu, reg); + snd_sleep_prepare(emu, wait); + synth->private_data = emu; synth->private_free = snd_emu8000_free; if (snd_emu8000_detect(emu) < 0) { + snd_free(emu, sizeof(*emu)); snd_synth_free(synth); return NULL; } + + snd_emu8000_init(emu); + return synth; } /* - * INIT part + * Set up a channel to be used for DMA. */ +void +snd_emu8000_dma_chan(emu8000_t *emu, int ch, int write) +{ + EMU8000_DCYSUSV_WRITE(emu, ch, 0x80); + EMU8000_VTFT_WRITE(emu, ch, 0); + EMU8000_CVCF_WRITE(emu, ch, 0); + EMU8000_PTRX_WRITE(emu, ch, 0x40000000); + EMU8000_CPF_WRITE(emu, ch, 0x40000000); + EMU8000_PSST_WRITE(emu, ch, 0); + EMU8000_CSL_WRITE(emu, ch, 0); + if (write == EMU8000_RAM_WRITE) /* DMA write */ + EMU8000_CCCA_WRITE(emu, ch, 0x06000000); + else /* DMA read */ + EMU8000_CCCA_WRITE(emu, ch, 0x04000000); + emu->voices[ch].state = EMU8000_ST_DRAM; +} +/* + * Open up channels. + */ +int +snd_emu8000_open_dma(emu8000_t *emu, int write) +{ + int i; + int found; + + found = 0; + + /* Only use channels that are not being used for any voices */ + for (i = 0; i < emu->max_voices; i++) { + if (emu->voices[i].state == EMU8000_ST_OFF) { + snd_emu8000_dma_chan(emu, i, write); + found++; + } + } + + + if (found == 0) { + /* Maybe we should force some to be freed up */ + for (i = 0; i < emu->max_voices; i++) { + if (emu->voices[i].state == EMU8000_ST_RELEASED) { + snd_emu8000_dma_chan(emu, i, write); + found++; + } + } + //return -EIO; + } + +#if 0 + EMU8000_VTFT_WRITE(emu, 30, 0); + EMU8000_PSST_WRITE(emu, 30, 0x1d8); + EMU8000_CSL_WRITE(emu, 30, 0x1e0); + EMU8000_CCCA_WRITE(emu, 30, 0x1d8); + EMU8000_VTFT_WRITE(emu, 31, 0); + EMU8000_PSST_WRITE(emu, 31, 0x1d8); + EMU8000_CSL_WRITE(emu, 31, 0x1e0); + EMU8000_CCCA_WRITE(emu, 31, 0x1d8); +#endif + + return 0; +} + +/* + * Close all dram channels. + * XXX Do we ever want to just close a few? + */ +void +snd_emu8000_close_dma(emu8000_t *emu) +{ + int i; + + /* wait until FULL bit in SMAxW register is false */ + for (i = 0; i < 10000; i++) { + if ((EMU8000_SMALW_READ(emu) & 0x80000000) == 0) + break; + snd_emu8000_wait(emu, 10); + } + + for (i = 0; i < emu->max_voices; i++) { + if (emu->voices[i].state == EMU8000_ST_DRAM) { + EMU8000_CCCA_WRITE(emu, i, 0); + EMU8000_DCYSUSV_WRITE(emu, i, 0x807F); + emu->voices[i].state = EMU8000_ST_OFF; + } + } +} + +void snd_emu8000_read_wait(emu8000_t *emu) +{ + while ((EMU8000_SMALR_READ(emu) & 0x80000000) != 0) { + //if (i++ < 5) + // continue; + //printk("readwait\n"); + snd_emu8000_wait(emu, 5); + } +} + +void snd_emu8000_write_wait(emu8000_t *emu) +{ + while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) { + //printk("writewait\n"); + snd_emu8000_wait(emu, 5); + } +} + +void snd_emu8000_wait(emu8000_t *emu, unsigned short delay) +{ + unsigned long waittime; + + waittime = (HZ * (unsigned long)delay + 44099) / 44100; + //printk("wait %ld\n", waittime); + snd_sleep_prepare(emu, wait); + snd_sleep(emu, wait, waittime); +} + +/* + * INIT part + */ #ifndef LINUX_2_1 extern struct symbol_table snd_symbol_table_emu8000_export; #endif @@ -135,6 +321,7 @@ if (register_symtab(&snd_symbol_table_emu8000_export) < 0) return -ENOMEM; #endif + return 0; } diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/emu8000_init.c new/lowlevel/sb/emu8000_init.c --- alsa-driver/lowlevel/sb/emu8000_init.c Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/emu8000_init.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,634 @@ +/* + * Initialisation routines for the emu8000 (AWE32/64) + * + * Copyright (C) 1999 Steve Ratcliffe + * + * Based on awe_wave.c by Takashi Iwai + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ +/* + * Initialisation routines for the emu8000. + * + * If this chip is used on any card other than the AWE32/64 then it + * is possible that different initialisations will be needed. + */ + +#include "driver.h" +#include "emu8000.h" + +/* Debugging stuff, one day will be ifdefed out */ +int emu8000_debug = 0; +#define DEBUG(lvl, action) if ((lvl) <= emu8000_debug) action + +/* Prototypes for static functions */ +static void init_audio(emu8000_t *emu); +static void init_dma(emu8000_t *emu); +static void init_arrays(emu8000_t *emu); +static void send_array(emu8000_t *emu, unsigned short *data, int size); +static void size_dram(emu8000_t *emu); +static void init_channels(emu8000_t *emu); + +#define DEF_FM_CHORUS_DEPTH 0x10 +#define DEF_FM_REVERB_DEPTH 0x10 + +/* + * The main initialisation routine. + */ +void +snd_emu8000_init(emu8000_t *emu) +{ + DEBUG(1, snd_printk("EMU8000: initializing..\n")); + + emu->last_reg = 0xffff; + + /* initialize hardware configuration */ + EMU8000_HWCF1_WRITE(emu, 0x0059); + EMU8000_HWCF2_WRITE(emu, 0x0020); + + /* disable audio; this seems to reduce a clicking noise a bit.. */ + EMU8000_HWCF3_WRITE(emu, 0); + + /* initialize audio channels */ + init_audio(emu); + + /* initialize DMA */ + init_dma(emu); + + /* initialize init arrays */ + init_arrays(emu); + + /* check DRAM memory size */ + size_dram(emu); + + init_channels(emu); + + /* + * Initialize the FM section of the AWE32, this is needed + * for DRAM refresh as well + */ + snd_emu8000_init_fm(emu); +#if 0 + + /* set up voice envelopes */ + awe_tweak(); +#endif + + /* enable audio */ + EMU8000_HWCF3_WRITE(emu, 0x4); + +#if 0 + /* set default values */ + awe_init_ctrl_parms(TRUE); + +#endif + /* set equalizer */ + //snd_emu8000_set_equalizer(emu, 5, 9); + + /* set reverb & chorus modes */ + snd_emu8000_set_reverb_mode(emu, 2); + // chorus not working very well + //snd_emu8000_set_chorus_mode(emu, 0); + + snd_emu8000_proc_init(emu); + snd_sf_init(&emu->sflist); + + + snd_emu8000_init_seq(emu); +} + +/* intiailize audio channels */ +static void +init_audio(emu8000_t *emu) +{ + int ch; + + /* turn off envelope engines */ + for (ch = 0; ch < emu->max_channels; ch++) + EMU8000_DCYSUSV_WRITE(emu, ch, 0x80); + + /* reset all other parameters to zero */ + for (ch = 0; ch < emu->max_channels; ch++) { + EMU8000_ENVVOL_WRITE(emu, ch, 0); + EMU8000_ENVVAL_WRITE(emu, ch, 0); + EMU8000_DCYSUS_WRITE(emu, ch, 0); + EMU8000_ATKHLDV_WRITE(emu, ch, 0); + EMU8000_LFO1VAL_WRITE(emu, ch, 0); + EMU8000_ATKHLD_WRITE(emu, ch, 0); + EMU8000_LFO2VAL_WRITE(emu, ch, 0); + EMU8000_IP_WRITE(emu, ch, 0); + EMU8000_IFATN_WRITE(emu, ch, 0); + EMU8000_PEFE_WRITE(emu, ch, 0); + EMU8000_FMMOD_WRITE(emu, ch, 0); + EMU8000_TREMFRQ_WRITE(emu, ch, 0); + EMU8000_FM2FRQ2_WRITE(emu, ch, 0); + EMU8000_PTRX_WRITE(emu, ch, 0); + EMU8000_VTFT_WRITE(emu, ch, 0); + EMU8000_PSST_WRITE(emu, ch, 0); + EMU8000_CSL_WRITE(emu, ch, 0); + EMU8000_CCCA_WRITE(emu, ch, 0); + } + + for (ch = 0; ch < emu->max_channels; ch++) { + EMU8000_CPF_WRITE(emu, ch, 0); + EMU8000_CVCF_WRITE(emu, ch, 0); + } +} + +/* initialize DMA address */ +static void +init_dma(emu8000_t *emu) +{ + EMU8000_SMALR_WRITE(emu, 0); + EMU8000_SMARR_WRITE(emu, 0); + EMU8000_SMALW_WRITE(emu, 0); + EMU8000_SMARW_WRITE(emu, 0); +} + +/* initialization arrays; from ADIP */ +static unsigned short init1[128] = { + 0x03ff, 0x0030, 0x07ff, 0x0130, 0x0bff, 0x0230, 0x0fff, 0x0330, + 0x13ff, 0x0430, 0x17ff, 0x0530, 0x1bff, 0x0630, 0x1fff, 0x0730, + 0x23ff, 0x0830, 0x27ff, 0x0930, 0x2bff, 0x0a30, 0x2fff, 0x0b30, + 0x33ff, 0x0c30, 0x37ff, 0x0d30, 0x3bff, 0x0e30, 0x3fff, 0x0f30, + + 0x43ff, 0x0030, 0x47ff, 0x0130, 0x4bff, 0x0230, 0x4fff, 0x0330, + 0x53ff, 0x0430, 0x57ff, 0x0530, 0x5bff, 0x0630, 0x5fff, 0x0730, + 0x63ff, 0x0830, 0x67ff, 0x0930, 0x6bff, 0x0a30, 0x6fff, 0x0b30, + 0x73ff, 0x0c30, 0x77ff, 0x0d30, 0x7bff, 0x0e30, 0x7fff, 0x0f30, + + 0x83ff, 0x0030, 0x87ff, 0x0130, 0x8bff, 0x0230, 0x8fff, 0x0330, + 0x93ff, 0x0430, 0x97ff, 0x0530, 0x9bff, 0x0630, 0x9fff, 0x0730, + 0xa3ff, 0x0830, 0xa7ff, 0x0930, 0xabff, 0x0a30, 0xafff, 0x0b30, + 0xb3ff, 0x0c30, 0xb7ff, 0x0d30, 0xbbff, 0x0e30, 0xbfff, 0x0f30, + + 0xc3ff, 0x0030, 0xc7ff, 0x0130, 0xcbff, 0x0230, 0xcfff, 0x0330, + 0xd3ff, 0x0430, 0xd7ff, 0x0530, 0xdbff, 0x0630, 0xdfff, 0x0730, + 0xe3ff, 0x0830, 0xe7ff, 0x0930, 0xebff, 0x0a30, 0xefff, 0x0b30, + 0xf3ff, 0x0c30, 0xf7ff, 0x0d30, 0xfbff, 0x0e30, 0xffff, 0x0f30, +}; + +static unsigned short init2[128] = { + 0x03ff, 0x8030, 0x07ff, 0x8130, 0x0bff, 0x8230, 0x0fff, 0x8330, + 0x13ff, 0x8430, 0x17ff, 0x8530, 0x1bff, 0x8630, 0x1fff, 0x8730, + 0x23ff, 0x8830, 0x27ff, 0x8930, 0x2bff, 0x8a30, 0x2fff, 0x8b30, + 0x33ff, 0x8c30, 0x37ff, 0x8d30, 0x3bff, 0x8e30, 0x3fff, 0x8f30, + + 0x43ff, 0x8030, 0x47ff, 0x8130, 0x4bff, 0x8230, 0x4fff, 0x8330, + 0x53ff, 0x8430, 0x57ff, 0x8530, 0x5bff, 0x8630, 0x5fff, 0x8730, + 0x63ff, 0x8830, 0x67ff, 0x8930, 0x6bff, 0x8a30, 0x6fff, 0x8b30, + 0x73ff, 0x8c30, 0x77ff, 0x8d30, 0x7bff, 0x8e30, 0x7fff, 0x8f30, + + 0x83ff, 0x8030, 0x87ff, 0x8130, 0x8bff, 0x8230, 0x8fff, 0x8330, + 0x93ff, 0x8430, 0x97ff, 0x8530, 0x9bff, 0x8630, 0x9fff, 0x8730, + 0xa3ff, 0x8830, 0xa7ff, 0x8930, 0xabff, 0x8a30, 0xafff, 0x8b30, + 0xb3ff, 0x8c30, 0xb7ff, 0x8d30, 0xbbff, 0x8e30, 0xbfff, 0x8f30, + + 0xc3ff, 0x8030, 0xc7ff, 0x8130, 0xcbff, 0x8230, 0xcfff, 0x8330, + 0xd3ff, 0x8430, 0xd7ff, 0x8530, 0xdbff, 0x8630, 0xdfff, 0x8730, + 0xe3ff, 0x8830, 0xe7ff, 0x8930, 0xebff, 0x8a30, 0xefff, 0x8b30, + 0xf3ff, 0x8c30, 0xf7ff, 0x8d30, 0xfbff, 0x8e30, 0xffff, 0x8f30, +}; + +static unsigned short init3[128] = { + 0x0C10, 0x8470, 0x14FE, 0xB488, 0x167F, 0xA470, 0x18E7, 0x84B5, + 0x1B6E, 0x842A, 0x1F1D, 0x852A, 0x0DA3, 0x8F7C, 0x167E, 0xF254, + 0x0000, 0x842A, 0x0001, 0x852A, 0x18E6, 0x8BAA, 0x1B6D, 0xF234, + 0x229F, 0x8429, 0x2746, 0x8529, 0x1F1C, 0x86E7, 0x229E, 0xF224, + + 0x0DA4, 0x8429, 0x2C29, 0x8529, 0x2745, 0x87F6, 0x2C28, 0xF254, + 0x383B, 0x8428, 0x320F, 0x8528, 0x320E, 0x8F02, 0x1341, 0xF264, + 0x3EB6, 0x8428, 0x3EB9, 0x8528, 0x383A, 0x8FA9, 0x3EB5, 0xF294, + 0x3EB7, 0x8474, 0x3EBA, 0x8575, 0x3EB8, 0xC4C3, 0x3EBB, 0xC5C3, + + 0x0000, 0xA404, 0x0001, 0xA504, 0x141F, 0x8671, 0x14FD, 0x8287, + 0x3EBC, 0xE610, 0x3EC8, 0x8C7B, 0x031A, 0x87E6, 0x3EC8, 0x86F7, + 0x3EC0, 0x821E, 0x3EBE, 0xD208, 0x3EBD, 0x821F, 0x3ECA, 0x8386, + 0x3EC1, 0x8C03, 0x3EC9, 0x831E, 0x3ECA, 0x8C4C, 0x3EBF, 0x8C55, + + 0x3EC9, 0xC208, 0x3EC4, 0xBC84, 0x3EC8, 0x8EAD, 0x3EC8, 0xD308, + 0x3EC2, 0x8F7E, 0x3ECB, 0x8219, 0x3ECB, 0xD26E, 0x3EC5, 0x831F, + 0x3EC6, 0xC308, 0x3EC3, 0xB2FF, 0x3EC9, 0x8265, 0x3EC9, 0x8319, + 0x1342, 0xD36E, 0x3EC7, 0xB3FF, 0x0000, 0x8365, 0x1420, 0x9570, +}; + +static unsigned short init4[128] = { + 0x0C10, 0x8470, 0x14FE, 0xB488, 0x167F, 0xA470, 0x18E7, 0x84B5, + 0x1B6E, 0x842A, 0x1F1D, 0x852A, 0x0DA3, 0x0F7C, 0x167E, 0x7254, + 0x0000, 0x842A, 0x0001, 0x852A, 0x18E6, 0x0BAA, 0x1B6D, 0x7234, + 0x229F, 0x8429, 0x2746, 0x8529, 0x1F1C, 0x06E7, 0x229E, 0x7224, + + 0x0DA4, 0x8429, 0x2C29, 0x8529, 0x2745, 0x07F6, 0x2C28, 0x7254, + 0x383B, 0x8428, 0x320F, 0x8528, 0x320E, 0x0F02, 0x1341, 0x7264, + 0x3EB6, 0x8428, 0x3EB9, 0x8528, 0x383A, 0x0FA9, 0x3EB5, 0x7294, + 0x3EB7, 0x8474, 0x3EBA, 0x8575, 0x3EB8, 0x44C3, 0x3EBB, 0x45C3, + + 0x0000, 0xA404, 0x0001, 0xA504, 0x141F, 0x0671, 0x14FD, 0x0287, + 0x3EBC, 0xE610, 0x3EC8, 0x0C7B, 0x031A, 0x07E6, 0x3EC8, 0x86F7, + 0x3EC0, 0x821E, 0x3EBE, 0xD208, 0x3EBD, 0x021F, 0x3ECA, 0x0386, + 0x3EC1, 0x0C03, 0x3EC9, 0x031E, 0x3ECA, 0x8C4C, 0x3EBF, 0x0C55, + + 0x3EC9, 0xC208, 0x3EC4, 0xBC84, 0x3EC8, 0x0EAD, 0x3EC8, 0xD308, + 0x3EC2, 0x8F7E, 0x3ECB, 0x0219, 0x3ECB, 0xD26E, 0x3EC5, 0x031F, + 0x3EC6, 0xC308, 0x3EC3, 0x32FF, 0x3EC9, 0x0265, 0x3EC9, 0x8319, + 0x1342, 0xD36E, 0x3EC7, 0x33FF, 0x0000, 0x8365, 0x1420, 0x9570, +}; + + +/* + * Send initialization arrays to start up, this just follows the + * initialisation sequence in the adip. + */ +static void +init_arrays(emu8000_t *emu) +{ + send_array(emu, init1, NELEM(init1)/4); + + snd_emu8000_wait(emu, 1024); + + send_array(emu, init2, NELEM(init2)/4); + send_array(emu, init3, NELEM(init3)/4); + + EMU8000_HWCF4_WRITE(emu, 0); + EMU8000_HWCF5_WRITE(emu, 0x83); + EMU8000_HWCF6_WRITE(emu, 0x8000); + + send_array(emu, init4, NELEM(init4)/4); +} + +/* send an initialization array + * Taken from the oss driver, not obvious from the doc how this + * is meant to work + */ +static void +send_array(emu8000_t *emu, unsigned short *data, int size) +{ + int i; + unsigned short *p; + + p = data; + for (i = 0; i < size; i++, p++) + EMU8000_INIT1_WRITE(emu, i, *p); + for (i = 0; i < size; i++, p++) + EMU8000_INIT2_WRITE(emu, i, *p); + for (i = 0; i < size; i++, p++) + EMU8000_INIT3_WRITE(emu, i, *p); + for (i = 0; i < size; i++, p++) + EMU8000_INIT4_WRITE(emu, i, *p); +} + +#define UNIQUE_ID1 0xa5b9 +#define UNIQUE_ID2 0x9d53 + +/* + * Size the onboard memory. + * This is written so as not to need arbitary delays after the write. It + * seems that the only way to do this is to use the one channel and keep + * reallocating between read and write. + */ +static void +size_dram(emu8000_t *emu) +{ + int size; + + if (emu->mem_size >= 0) /* already initialized */ + return; + + size = 0; + + /* write out a magic number */ + snd_emu8000_dma_chan(emu, 0, EMU8000_RAM_WRITE); + snd_emu8000_dma_chan(emu, 1, EMU8000_RAM_READ); + EMU8000_SMALW_WRITE(emu, EMU8000_DRAM_OFFSET); + EMU8000_SMLD_WRITE(emu, UNIQUE_ID1); + snd_emu8000_init_fm(emu); /* This must really be here and not 2 lines back even */ + + while (size < EMU8000_MAX_DRAM) { + + size += 512 * 1024; /* increment 512kbytes */ + + /* Write a unique data on the test address. + * if the address is out of range, the data is written on + * 0x200000(=EMU8000_DRAM_OFFSET). Then the id word is + * changed by this data. + */ + //snd_emu8000_dma_chan(emu, 0, EMU8000_RAM_WRITE); + EMU8000_SMALW_WRITE(emu, EMU8000_DRAM_OFFSET + (size>>1)); + EMU8000_SMLD_WRITE(emu, UNIQUE_ID2); + snd_emu8000_write_wait(emu); + + /* + * read the data on the just written DRAM address + * if not the same then we have reached the end of ram. + */ + //snd_emu8000_dma_chan(emu, 0, EMU8000_RAM_READ); + EMU8000_SMALR_WRITE(emu, EMU8000_DRAM_OFFSET + (size>>1)); + //snd_emu8000_read_wait(emu); + EMU8000_SMLD_READ(emu); /* discard stale data */ + snd_emu8000_read_wait(emu); + + /* + * If it is the same it could be that the address just + * wraps back to the beginning; so check to see if the + * initial value has been overwritten. + */ + EMU8000_SMALR_WRITE(emu, EMU8000_DRAM_OFFSET); + EMU8000_SMLD_READ(emu); /* discard stale data */ + if (EMU8000_SMLD_READ(emu) != UNIQUE_ID1) + break; /* we must have wrapped around */ + snd_emu8000_read_wait(emu); + } + snd_emu8000_close_dma(emu); + + snd_printd("EMU8000: %d Kbytes memory detected\n", size/1024); + + emu->mem_size = size; +} + +static void +init_channels(emu8000_t *emu) +{ + emu8000_voice_t *vp; + int ch; + + for (ch = 0; ch < EMU8000_CHANNELS; ch++) { + vp = &emu->voices[ch]; + + vp->ch = ch; + vp->state = EMU8000_ST_OFF; + /* XXX check if up to date */ + } +} + + +/* + * Initiailise the FM section. You have to do this to use sample RAM + * and therefore lose 2 voices. + */ +void +snd_emu8000_init_fm(emu8000_t *emu) +{ + unsigned long flags; + + /* Initialize the last two channels for DRAM refresh and producing + the reverb and chorus effects for Yamaha OPL-3 synthesizer */ + + /* 31: FM left channel, 0xffffe0-0xffffe8 */ + EMU8000_DCYSUSV_WRITE(emu, 30, 0x80); + EMU8000_PSST_WRITE(emu, 30, 0xFFFFFFE0); /* full left */ + EMU8000_CSL_WRITE(emu, 30, 0x00FFFFE8 | (DEF_FM_CHORUS_DEPTH << 24)); + EMU8000_PTRX_WRITE(emu, 30, (DEF_FM_REVERB_DEPTH << 8)); + EMU8000_CPF_WRITE(emu, 30, 0); + EMU8000_CCCA_WRITE(emu, 30, 0x00FFFFE3); + + /* 32: FM right channel, 0xfffff0-0xfffff8 */ + EMU8000_DCYSUSV_WRITE(emu, 31, 0x80); + EMU8000_PSST_WRITE(emu, 31, 0x00FFFFF0); /* full right */ + EMU8000_CSL_WRITE(emu, 31, 0x00FFFFF8 | (DEF_FM_CHORUS_DEPTH << 24)); + EMU8000_PTRX_WRITE(emu, 31, (DEF_FM_REVERB_DEPTH << 8)); + EMU8000_CPF_WRITE(emu, 31, 0x8000); + EMU8000_CCCA_WRITE(emu, 31, 0x00FFFFF3); + + snd_emu8000_poke((emu), EMU8000_DATA0(emu), EMU8000_CMD(1, (30)), 0); + snd_spin_lock(emu, reg, &flags); + while (!(inw(EMU8000_PTR(emu)) & 0x1000)) + ; + while ((inw(EMU8000_PTR(emu)) & 0x1000)) + ; + snd_spin_unlock(emu, reg, &flags); + snd_emu8000_poke((emu), EMU8000_DATA0(emu), EMU8000_CMD(1, (30)), 0x4828); + EMU8000_IFATN_WRITE(emu, 28, 0); + + /* skew volume & cutoff */ + EMU8000_VTFT_WRITE(emu, 30, 0x8000FFFF); + EMU8000_VTFT_WRITE(emu, 31, 0x8000FFFF); + +#if 0 + EMU8000_VTFT_WRITE(emu, 30, 0); + EMU8000_PSST_WRITE(emu, 30, 0x1d8); + EMU8000_CSL_WRITE(emu, 30, 0x1e0); + EMU8000_CCCA_WRITE(emu, 30, 0x1d8); + EMU8000_VTFT_WRITE(emu, 31, 0); + EMU8000_PSST_WRITE(emu, 31, 0x1d8); + EMU8000_CSL_WRITE(emu, 31, 0x1e0); + EMU8000_CCCA_WRITE(emu, 31, 0x1d8); +#endif + + emu->voices[30].state = EMU8000_ST_FM; + emu->voices[31].state = EMU8000_ST_FM; + + /* change maximum channels to 30 */ + emu->max_voices = emu->max_channels - 2; +} + +/* The following are pretty much directly taken from awe_wave.c */ +/*================================================================ + * treble/bass equalizer control + *================================================================*/ + +static unsigned short bass_parm[12][3] = { + {0xD26A, 0xD36A, 0x0000}, /* -12 dB */ + {0xD25B, 0xD35B, 0x0000}, /* -8 */ + {0xD24C, 0xD34C, 0x0000}, /* -6 */ + {0xD23D, 0xD33D, 0x0000}, /* -4 */ + {0xD21F, 0xD31F, 0x0000}, /* -2 */ + {0xC208, 0xC308, 0x0001}, /* 0 (HW default) */ + {0xC219, 0xC319, 0x0001}, /* +2 */ + {0xC22A, 0xC32A, 0x0001}, /* +4 */ + {0xC24C, 0xC34C, 0x0001}, /* +6 */ + {0xC26E, 0xC36E, 0x0001}, /* +8 */ + {0xC248, 0xC348, 0x0002}, /* +10 */ + {0xC26A, 0xC36A, 0x0002}, /* +12 dB */ +}; + +static unsigned short treble_parm[12][9] = { + {0x821E, 0xC26A, 0x031E, 0xC36A, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, /* -12 dB */ + {0x821E, 0xC25B, 0x031E, 0xC35B, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, + {0x821E, 0xC24C, 0x031E, 0xC34C, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, + {0x821E, 0xC23D, 0x031E, 0xC33D, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, + {0x821E, 0xC21F, 0x031E, 0xC31F, 0x021E, 0xD208, 0x831E, 0xD308, 0x0001}, + {0x821E, 0xD208, 0x031E, 0xD308, 0x021E, 0xD208, 0x831E, 0xD308, 0x0002}, + {0x821E, 0xD208, 0x031E, 0xD308, 0x021D, 0xD219, 0x831D, 0xD319, 0x0002}, + {0x821E, 0xD208, 0x031E, 0xD308, 0x021C, 0xD22A, 0x831C, 0xD32A, 0x0002}, + {0x821E, 0xD208, 0x031E, 0xD308, 0x021A, 0xD24C, 0x831A, 0xD34C, 0x0002}, + {0x821E, 0xD208, 0x031E, 0xD308, 0x0219, 0xD26E, 0x8319, 0xD36E, 0x0002}, /* +8 (HW default) */ + {0x821D, 0xD219, 0x031D, 0xD319, 0x0219, 0xD26E, 0x8319, 0xD36E, 0x0002}, + {0x821C, 0xD22A, 0x031C, 0xD32A, 0x0219, 0xD26E, 0x8319, 0xD36E, 0x0002}, /* +12 dB */ +}; + + +/* + * set Emu8000 digital equalizer; from 0 to 11 [-12dB - 12dB] + */ +void +snd_emu8000_set_equalizer(emu8000_t *emu, int bass, int treble) +{ + unsigned short w; + + if (bass < 0 || bass > 11 || treble < 0 || treble > 11) + return; + + EMU8000_INIT4_WRITE(emu, 0x01, bass_parm[bass][0]); + EMU8000_INIT4_WRITE(emu, 0x11, bass_parm[bass][1]); + EMU8000_INIT3_WRITE(emu, 0x11, treble_parm[treble][0]); + EMU8000_INIT3_WRITE(emu, 0x13, treble_parm[treble][1]); + EMU8000_INIT3_WRITE(emu, 0x1B, treble_parm[treble][2]); + EMU8000_INIT4_WRITE(emu, 0x07, treble_parm[treble][3]); + EMU8000_INIT4_WRITE(emu, 0x0B, treble_parm[treble][4]); + EMU8000_INIT4_WRITE(emu, 0x0D, treble_parm[treble][5]); + EMU8000_INIT4_WRITE(emu, 0x17, treble_parm[treble][6]); + EMU8000_INIT4_WRITE(emu, 0x19, treble_parm[treble][7]); + w = bass_parm[bass][2] + treble_parm[treble][8]; + EMU8000_INIT4_WRITE(emu, 0x15, (unsigned short)(w + 0x0262)); + EMU8000_INIT4_WRITE(emu, 0x1D, (unsigned short)(w + 0x8362)); +} + + +/* + * Chorus effects. + */ +typedef struct chorus_fx_rec { + unsigned short feedback; /* feedback level (0xE600-0xE6FF) */ + unsigned short delay_offset; /* delay (0-0x0DA3) [1/44100 sec] */ + unsigned short lfo_depth; /* LFO depth (0xBC00-0xBCFF) */ + unsigned int delay; /* right delay (0-0xFFFFFFFF) [1/256/44100 sec] */ + unsigned int lfo_freq; /* LFO freq LFO freq (0-0xFFFFFFFF) */ +} chorus_fx_rec; + +static chorus_fx_rec chorus_parm[] = { + {0xE600, 0x03F6, 0xBC2C ,0x00000000, 0x0000006D}, /* chorus 1 */ + {0xE608, 0x031A, 0xBC6E, 0x00000000, 0x0000017C}, /* chorus 2 */ + {0xE610, 0x031A, 0xBC84, 0x00000000, 0x00000083}, /* chorus 3 */ + {0xE620, 0x0269, 0xBC6E, 0x00000000, 0x0000017C}, /* chorus 4 */ + {0xE680, 0x04D3, 0xBCA6, 0x00000000, 0x0000005B}, /* feedback */ + {0xE6E0, 0x044E, 0xBC37, 0x00000000, 0x00000026}, /* flanger */ + {0xE600, 0x0B06, 0xBC00, 0x0000E000, 0x00000083}, /* short delay */ + {0xE6C0, 0x0B06, 0xBC00, 0x0000E000, 0x00000083}, /* short delay + feedback */ +}; + +void +snd_emu8000_set_chorus_mode(emu8000_t *emu, int effect) +{ + if (effect < 0 || effect >= NELEM(chorus_parm)) + return; /* In future, may get user defined effects */ + + /* XXX Experimenting , do not use */ + EMU8000_INIT3_WRITE(emu, 9, chorus_parm[effect].feedback); + EMU8000_INIT3_WRITE(emu, 12, chorus_parm[effect].delay_offset); + EMU8000_INIT4_WRITE(emu, 3, chorus_parm[effect].lfo_depth); + EMU8000_HWCF4_WRITE(emu, chorus_parm[effect].delay); + EMU8000_HWCF5_WRITE(emu, chorus_parm[effect].lfo_freq); + EMU8000_HWCF6_WRITE(emu, 0x8000); + EMU8000_HWCF7_WRITE(emu, 0x0000); +} + +/*----------------------------------------------------------------*/ + +/* reverb mode settings; write the following 28 data of 16 bit length + * on the corresponding ports in the reverb_cmds array + */ +typedef struct reverb_fx_rec { + unsigned short parms[28]; +} reverb_fx_rec; +static reverb_fx_rec reverb_parm[AWE_REVERB_NUMBERS] = { +{{ /* room 1 */ + 0xB488, 0xA450, 0x9550, 0x84B5, 0x383A, 0x3EB5, 0x72F4, + 0x72A4, 0x7254, 0x7204, 0x7204, 0x7204, 0x4416, 0x4516, + 0xA490, 0xA590, 0x842A, 0x852A, 0x842A, 0x852A, 0x8429, + 0x8529, 0x8429, 0x8529, 0x8428, 0x8528, 0x8428, 0x8528, +}}, +{{ /* room 2 */ + 0xB488, 0xA458, 0x9558, 0x84B5, 0x383A, 0x3EB5, 0x7284, + 0x7254, 0x7224, 0x7224, 0x7254, 0x7284, 0x4448, 0x4548, + 0xA440, 0xA540, 0x842A, 0x852A, 0x842A, 0x852A, 0x8429, + 0x8529, 0x8429, 0x8529, 0x8428, 0x8528, 0x8428, 0x8528, +}}, +{{ /* room 3 */ + 0xB488, 0xA460, 0x9560, 0x84B5, 0x383A, 0x3EB5, 0x7284, + 0x7254, 0x7224, 0x7224, 0x7254, 0x7284, 0x4416, 0x4516, + 0xA490, 0xA590, 0x842C, 0x852C, 0x842C, 0x852C, 0x842B, + 0x852B, 0x842B, 0x852B, 0x842A, 0x852A, 0x842A, 0x852A, +}}, +{{ /* hall 1 */ + 0xB488, 0xA470, 0x9570, 0x84B5, 0x383A, 0x3EB5, 0x7284, + 0x7254, 0x7224, 0x7224, 0x7254, 0x7284, 0x4448, 0x4548, + 0xA440, 0xA540, 0x842B, 0x852B, 0x842B, 0x852B, 0x842A, + 0x852A, 0x842A, 0x852A, 0x8429, 0x8529, 0x8429, 0x8529, +}}, +{{ /* hall 2 */ + 0xB488, 0xA470, 0x9570, 0x84B5, 0x383A, 0x3EB5, 0x7254, + 0x7234, 0x7224, 0x7254, 0x7264, 0x7294, 0x44C3, 0x45C3, + 0xA404, 0xA504, 0x842A, 0x852A, 0x842A, 0x852A, 0x8429, + 0x8529, 0x8429, 0x8529, 0x8428, 0x8528, 0x8428, 0x8528, +}}, +{{ /* plate */ + 0xB4FF, 0xA470, 0x9570, 0x84B5, 0x383A, 0x3EB5, 0x7234, + 0x7234, 0x7234, 0x7234, 0x7234, 0x7234, 0x4448, 0x4548, + 0xA440, 0xA540, 0x842A, 0x852A, 0x842A, 0x852A, 0x8429, + 0x8529, 0x8429, 0x8529, 0x8428, 0x8528, 0x8428, 0x8528, +}}, +{{ /* delay */ + 0xB4FF, 0xA470, 0x9500, 0x84B5, 0x333A, 0x39B5, 0x7204, + 0x7204, 0x7204, 0x7204, 0x7204, 0x72F4, 0x4400, 0x4500, + 0xA4FF, 0xA5FF, 0x8420, 0x8520, 0x8420, 0x8520, 0x8420, + 0x8520, 0x8420, 0x8520, 0x8420, 0x8520, 0x8420, 0x8520, +}}, +{{ /* panning delay */ + 0xB4FF, 0xA490, 0x9590, 0x8474, 0x333A, 0x39B5, 0x7204, + 0x7204, 0x7204, 0x7204, 0x7204, 0x72F4, 0x4400, 0x4500, + 0xA4FF, 0xA5FF, 0x8420, 0x8520, 0x8420, 0x8520, 0x8420, + 0x8520, 0x8420, 0x8520, 0x8420, 0x8520, 0x8420, 0x8520, +}}, +}; + +static struct ReverbCmdPair { + unsigned short cmd, port; +} reverb_cmds[28] = { +#define AWE_INIT1(ch) EMU8000_CMD(2, (ch)) , 1 +#define AWE_INIT2(ch) EMU8000_CMD(2, (ch)) , 2 +#define AWE_INIT3(ch) EMU8000_CMD(3, (ch)) , 1 +#define AWE_INIT4(ch) EMU8000_CMD(3, (ch)) , 2 + {AWE_INIT1(0x03)}, {AWE_INIT1(0x05)}, {AWE_INIT4(0x1F)}, {AWE_INIT1(0x07)}, + {AWE_INIT2(0x14)}, {AWE_INIT2(0x16)}, {AWE_INIT1(0x0F)}, {AWE_INIT1(0x17)}, + {AWE_INIT1(0x1F)}, {AWE_INIT2(0x07)}, {AWE_INIT2(0x0F)}, {AWE_INIT2(0x17)}, + {AWE_INIT2(0x1D)}, {AWE_INIT2(0x1F)}, {AWE_INIT3(0x01)}, {AWE_INIT3(0x03)}, + {AWE_INIT1(0x09)}, {AWE_INIT1(0x0B)}, {AWE_INIT1(0x11)}, {AWE_INIT1(0x13)}, + {AWE_INIT1(0x19)}, {AWE_INIT1(0x1B)}, {AWE_INIT2(0x01)}, {AWE_INIT2(0x03)}, + {AWE_INIT2(0x09)}, {AWE_INIT2(0x0B)}, {AWE_INIT2(0x11)}, {AWE_INIT2(0x13)}, +}; + +void +snd_emu8000_set_reverb_mode(emu8000_t *emu, int effect) +{ + int i; + if (effect < 0 || effect >= NELEM(reverb_parm)) + return; + + for (i = 0; i < 28; i++) { + int port; + if (reverb_cmds[i].port == 1) + port = EMU8000_DATA1(emu); + else if (reverb_cmds[i].port == 2) + port = EMU8000_DATA2(emu); + else { + snd_printk("BUG: snd_emu8000_set_reverb_mode\n"); + continue; + } + + snd_emu8000_poke(emu, port, reverb_cmds[i].cmd, + reverb_parm[effect].parms[i]); + } +} diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/emu8000_patch.c new/lowlevel/sb/emu8000_patch.c --- alsa-driver/lowlevel/sb/emu8000_patch.c Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/emu8000_patch.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,164 @@ +/* + * Patch routines for the emu8000 (AWE32/64) + * + * Copyright (C) 1999 Steve Ratcliffe + * + * Based on awe_wave.c by Takashi Iwai + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ +/* + * All the code for loading in a patch. There is very little that is + * chip specific here. Just the actual writing to the board. + */ + +#include "driver.h" +#include "emu8000.h" +#include "linux/awe_voice.h" + +#define BLANK_LOOP_START 8 +#define BLANK_LOOP_END 40 +#define BLANK_LOOP_SIZE 48 + +int +sample_write(void *private, snd_sf_sample_t *sp, const void *data, + long count) +{ + int i; + int rc; + int offset; + int truesize; + int dram_offset; + emu8000_t *emu; + snd_soundfont_t *sf; + + emu = private; + if (emu == NULL) + return -EINVAL; + + sf = emu->sflist.currsf; + + /* be sure loop points start < end */ + if (sp->v.loopstart > sp->v.loopend) { + int tmp = sp->v.loopstart; + sp->v.loopstart = sp->v.loopend; + sp->v.loopend = tmp; + } + + /* compute true data size to be loaded */ + truesize = sp->v.size; + if (sp->v.mode_flags & SF_SAMPLE_BIDIR_LOOP) + truesize += sp->v.loopend - sp->v.loopstart; + if (sp->v.mode_flags & SF_SAMPLE_NO_BLANK) + truesize += BLANK_LOOP_SIZE; + if (sf->mem_offset + truesize >= emu->mem_size/2) { + snd_printd("Uh Oh: out of memory off %x, true=%x size=%x\n", sf->mem_offset, truesize, emu->mem_size); + return -ENOSPC; + } + + /* recalculate address offset */ + dram_offset = EMU8000_DRAM_OFFSET + sf->mem_offset; + sp->v.end += dram_offset - sp->v.start; + sp->v.loopstart += dram_offset - sp->v.start; + sp->v.loopend += dram_offset - sp->v.start; + sp->v.start = dram_offset; + + /* set the total size (store onto obsolete checksum value) */ + if (sp->v.size == 0) + sp->v.checksum = 0; + else + sp->v.checksum = truesize; + + if ((rc = snd_emu8000_open_dma(emu, EMU8000_RAM_WRITE)) != 0) + return rc; + + /* Set the address to start writing at */ + snd_emu8000_write_wait(emu); + EMU8000_SMALW_WRITE(emu, sp->v.start); +// snd_emu8000_init_fm(emu); + + offset = 0; + for (i = 0; i < sp->v.size; i++) { + unsigned short s; + //static unsigned short foo; + + /* + * You should not have to keep resetting the address each time + * as the chip is supposed to step on the next address automatically. + * It mostly does, but during writes of some samples at random it + * completely loses words (every one in 16 roughly but with no + * obvious pattern). + * + * This is therefore much slower than need be, but is at least + * working. + */ + snd_emu8000_write_wait(emu); + EMU8000_SMALW_WRITE(emu, sp->v.start + offset); + + get_user(s, ((unsigned short *)data)+offset); + offset++; + + //EMU8000_SMLD_WRITE(emu, (i==0)?0xffff:foo); + EMU8000_SMLD_WRITE(emu, s); + + if (i == sp->v.loopend && + (sp->v.mode_flags & (AWE_SAMPLE_BIDIR_LOOP|AWE_SAMPLE_REVERSE_LOOP))) + { + int looplen = sp->v.loopend - sp->v.loopstart; + int k; + + /* copy reverse loop */ + for (k = 1; k <= looplen; k++) { + get_user(s, ((unsigned short *)data)+offset-k); + EMU8000_SMLD_WRITE(emu, s); + } + if (sp->v.mode_flags & AWE_SAMPLE_BIDIR_LOOP) { + sp->v.end += looplen; + } else { + sp->v.start += looplen; + sp->v.end += looplen; + } + } + } + + /* if no blank loop is attached in the sample, add it */ + if (sp->v.mode_flags & AWE_SAMPLE_NO_BLANK) { + for (i = 0; i < BLANK_LOOP_SIZE; i++) + EMU8000_SMLD_WRITE(emu, 0); + if (sp->v.mode_flags & AWE_SAMPLE_SINGLESHOT) { + sp->v.loopstart = sp->v.end + BLANK_LOOP_START; + sp->v.loopend = sp->v.end + BLANK_LOOP_END; + } + } + + sf->mem_offset += truesize; + snd_emu8000_close_dma(emu); + snd_emu8000_init_fm(emu); + + return count; +} + +int +snd_emu8000_patch(emu8000_t *emu, const void *data, long count) +{ + int rc; + + rc = snd_soundfont_load(&emu->sflist, data, count, + sample_write, emu); + + return rc; +} + diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/emu8000_proc.c new/lowlevel/sb/emu8000_proc.c --- alsa-driver/lowlevel/sb/emu8000_proc.c Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/emu8000_proc.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,361 @@ +/* + * The /proc routines for emu8000 (AWE32/64) + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ +/* + * This is all new for alsa. + * At present allows you to read the memory from the emu8000. + * + * This is mainly a debugging thing, I'm not sure that you would ever + * want to do this in normal use, or even write directly to the ram. + * + * NOTE: the ram is addressed as words, whereas reading from this interface + * will use the usual byte offsets. If you are going from one to the + * other don't get confused... + */ + +#include "driver.h" +#include "emu8000.h" +#include "info.h" +#include "seq_alloc.h" + +/* + * The private data. Mainly used to tell which memory area we are + * looking at. + */ +struct proc_private { + emu8000_t *emu; + loff_t begin; + char *name; +}; + +/* Prototypes for static functions */ +static long proc_mem_read(void *private_data, void *file_private_data, + struct file *file, char *buf, long count); +static long patch_write(void *private_data, void *file_private_data, + struct file *file, const char *buf, long count); +static long hack(void *private_data, void *file_private_data, struct file *file, + char *buf, long count); +static void sub_midi_in_hack(emu8000_t *emu); +static void unsub_midi_in_hack(emu8000_t *emu); +static snd_info_entry_t *make_mem_proc_entry(emu8000_t *emu, + struct proc_private *pp); + +/* + * Read from the onboard memory. + * This is arranged into two devices one for the rom and one for the ram. + */ +static long +proc_mem_read(void *private_data, void *file_private_data, + struct file * file, char *buf, long count) +{ + struct proc_private *pp = (struct proc_private *)private_data; + emu8000_t *emu; + loff_t off; + unsigned short word; + int i; + long result; + + if (pp == NULL) + return -EIO; + + emu = pp->emu; + off = pp->begin + file->f_pos; + + /* Don't allow the count to be odd */ + if (count & 1) + count--; + result = 0; + + /* + * Allocate all the channels for dma, this will cause all notes to be + * abruptly terminated... FIXME(perhaps) + */ + for (i = 0; i < emu->max_voices; i++) + snd_emu8000_dma_chan(emu, i, EMU8000_RAM_READ); + + snd_emu8000_read_wait(emu); + + /* + * This is the only way that I could get this to work, by reseting + * the address each time a word is read. You are not supposed to + * have to do that, should be enough to keep reading the data + * register. The flag to say that the read was complete does + * not appear to work. YMMV. + */ + while (count > 0) { + EMU8000_SMALR_WRITE(emu, off>>1); /* set read address */ + //snd_emu8000_read_wait(emu); /* needed ??? */ + EMU8000_SMLD_READ(emu); /* Discard pre-fetch word */ + + word = EMU8000_SMLD_READ(emu); + buf[0] = word>>8; + buf[1] = word; + snd_emu8000_read_wait(emu); /* needed ??? */ + + off += 2; + buf += 2; + count -= 2; + result += 2; + } + file->f_pos += result; + snd_emu8000_read_wait(emu); + snd_emu8000_close_dma(emu); + + return result; +} + +static long +patch_write(void *private_data, void *file_private_data, + struct file * file, const char *buf, long count) +{ + struct proc_private *pp = (struct proc_private *)private_data; + emu8000_t *emu; + long result; + + emu = pp->emu; +if(emu==NULL) +snd_printd("emu is NULL in patch pp%p, name %s\n", pp, pp->name?pp->name:"MMM no name"); + if (emu == NULL) + return -EIO; + + result = snd_emu8000_patch(emu, buf, count); +if(pp->emu==NULL) +snd_printd("AT END emu is NULL in patch pp%p, name %s\n", pp, pp->name?pp->name:"MMM no name"); + return result; +} + +/* HACK HACK */ +#include "midi.h" + +static long +hack(void *private_data, void *file_private_data, + struct file * file, char *buf, long count) +{ + struct proc_private *pp = (struct proc_private *)private_data; + emu8000_t *emu; + static snd_midi_channel_t chanbuf; + int i; + + emu = pp->emu; + + switch (count) { + case 1: /* Give a nice piano note */ + snd_init_midi_channel(&chanbuf, 0); + + snd_emu8000_note_on(emu, 60, 80, &chanbuf); + snd_emu8000_wait(emu, 31000); + snd_emu8000_note_off(emu, 60, 0, &chanbuf); + break; + case 2: /* Subscribe to midi in */ + sub_midi_in_hack(emu); + break; + case 3: /* Switch it off */ + unsub_midi_in_hack(emu); + /*FALLTHROUGH*/ + case 4: + for (i = 0; i < 4; i++) + snd_emu8000_terminate_all(emu, emu->ports[i]); + break; + default: + /* Whatever.. */ + break; + } + return count; +} + +static void +sub_midi_in_hack(emu8000_t *emu) +{ + int err; + snd_seq_port_subscribe_t sub; + + /* Subscribe to the midi input */ + memset(&sub, 0, sizeof(sub)); + sub.sender.queue = 0; + sub.sender.client = 64; + sub.sender.port = 0; + sub.sender.channel = 0; + + sub.dest.queue = 0; + sub.dest.client = emu->client; + sub.dest.port = emu->ports[0]; + sub.dest.channel = 0; + + err = snd_seq_kernel_client_ctl(emu->client, + SND_SEQ_IOCTL_SUBSCRIBE_PORT, &sub); + if (err < 0) { + snd_printk("ioctl failed %d\n", err); + } +} + +static void +unsub_midi_in_hack(emu8000_t *emu) +{ + int err; + snd_seq_port_subscribe_t sub; + + /* Subscribe to the midi input */ + memset(&sub, 0, sizeof(sub)); + sub.sender.queue = 0; + sub.sender.client = 64; + sub.sender.port = 0; + sub.sender.channel = 0; + + sub.dest.queue = 0; + sub.dest.client = emu->client; + sub.dest.port = emu->ports[0]; + sub.dest.channel = 0; + + err = snd_seq_kernel_client_ctl(emu->client, + SND_SEQ_IOCTL_UNSUBSCRIBE_PORT, &sub); + if (err < 0) { + snd_printk("ioctl failed %d\n", err); + } +} + +/* + * Set up the /proc devices under the relevant card directory for this + * device. + */ +void +snd_emu8000_proc_init(emu8000_t *emu) +{ + struct proc_private *rampp; + struct proc_private *rompp; + struct proc_private *patchpp; + snd_info_entry_t *entry; + + patchpp = snd_malloc(sizeof(*rampp)); + if (patchpp == NULL) + return; + rampp = snd_malloc(sizeof(*rampp)); + if (rampp == NULL) { + snd_free(patchpp, sizeof(*patchpp)); + return; + } + rompp = snd_malloc(sizeof(*rompp)); + if (rompp == NULL) { + snd_free(patchpp, sizeof(*patchpp)); + snd_free(rampp, sizeof(*rampp)); + return; + } + + /* + * Make a patch access device. Writing to this will install patches + * onto the card. At present done in a semi-compatible way to OSS to + * avoid extensive changes. May be done completely differently in + * the future. + */ + patchpp->name = "patch0"; /* XXX */ + patchpp->emu = emu; + entry = snd_info_create_entry(emu->card, patchpp->name); + if (!entry) { + snd_free(patchpp, sizeof(*patchpp)); + snd_free(rampp, sizeof(*rampp)); + return; + } + + /* Set up the routines */ + entry->type = SND_INFO_ENTRY_DATA; + entry->mode |= S_IWUSR; + entry->private_data = patchpp; + entry->t.data.open = NULL; + entry->t.data.release = NULL; + entry->t.data.read = hack; + entry->t.data.write = patch_write; + entry->t.data.ioctl = NULL; +#ifdef LINUX_2_1 + entry->t.data.poll = NULL; +#else + entry->t.data.select = NULL; +#endif + + /* Now register it so it will appear */ + if (snd_info_register(entry) < 0) { + snd_free(patchpp, sizeof(struct proc_private)); + snd_info_free_entry(entry); + return; + } + emu->patch_proc_entry = entry; + + /* + * Make a device that allows us to view the on card RAM. Mainly + * for debugging purposes. + */ + rampp->emu = emu; + rampp->name = "ram0"; /* XXX ram%d, chip_number */ + rampp->begin = EMU8000_DRAM_OFFSET << 1; + + entry = make_mem_proc_entry(emu, rampp); + emu->ram_proc_entry = entry; + + /* + * Make a device that allows us to view the on card ROM. Mainly + * for completeness. + */ + rompp->emu = emu; + rompp->name = "rom0"; /* XXX */ + rompp->begin = 0; + + entry = make_mem_proc_entry(emu, rompp); + emu->rom_proc_entry = entry; +} + +static snd_info_entry_t * +make_mem_proc_entry(emu8000_t *emu, struct proc_private *pp) +{ + snd_info_entry_t *entry; + + entry = snd_info_create_entry(emu->card, pp->name); + if (!entry) + return 0; + + /* Set up the routines */ + entry->type = SND_INFO_ENTRY_DATA; + if (pp->name[1] == 'a') + entry->mode |= S_IWUSR; + entry->private_data = pp; + entry->t.data.open = NULL; + entry->t.data.release = NULL; + entry->t.data.read = proc_mem_read; + entry->t.data.write = NULL; + entry->t.data.ioctl = NULL; +#ifdef LINUX_2_1 + entry->t.data.poll = NULL; +#else + entry->t.data.select = NULL; +#endif + + /* Now register it so it will appear */ + if (snd_info_register(entry) < 0) { + snd_free(pp, sizeof(struct proc_private)); + snd_info_free_entry(entry); + return 0; + } + + return entry; +} + +void +snd_emu8000_proc_free(snd_info_entry_t *ip) +{ + snd_free(ip->private_data, sizeof(struct proc_private)); +} + diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/emu8000_seq.c new/lowlevel/sb/emu8000_seq.c --- alsa-driver/lowlevel/sb/emu8000_seq.c Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/emu8000_seq.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,215 @@ +/* + * Midi Sequencer interface routines. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * Contains code based on awe_wave.c by Takashi Iwai + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include "driver.h" +#include "emu8000.h" +#include "seq_kernel.h" +#include "seq_alloc.h" +#include "seq_midi_event.h" + +/* Prototypes for static functions */ +static int emu8000_event_input(snd_seq_event_t *ev, void *private); +static int emu8000_use(void *private); +static int emu8000_unuse(void *private); +static int not_allowed(void *private); +static int get_client(snd_card_t *card, char *name); + +static snd_midi_op_t emu8000_ops = { + snd_emu8000_note_on, + snd_emu8000_note_off, + snd_emu8000_control, +}; + +/* + * Initialise the EMU8000 Synth by creating a client and registering + * a series of ports. + * Each of the ports will contain the 16 midi channels. Applications + * can connect to these ports to play midi data. + */ +void +snd_emu8000_init_seq(emu8000_t *emu) +{ + snd_seq_port_callback_t *pcbp; + snd_midi_channel_set_t *chset; + snd_seq_queue_info_t qinfo; + int client; + int err; + int i; + + EMU8000_CHECK(emu); + + client = get_client(emu->card, "AWE Wave Table Synth"); + emu->client = client; + + pcbp = snd_alloc_port_callback(); + + pcbp->use = emu8000_use; + pcbp->unuse = emu8000_unuse; + pcbp->subscribe = not_allowed; /* Give an error if this happens */ + pcbp->unsubscribe = not_allowed; /* Give an error if this happens */ + pcbp->event_input = emu8000_event_input; + + for (i = 0; i < EMU8000_MAX_PORTS; i++) { + char name[30]; + + sprintf(name, "AWE port %d", i); + + /* Allocate structures for this channel */ + chset = snd_alloc_midi_channel_set(16); + chset->private_data = emu; + chset->client = client; + + pcbp->private_data = chset; + + chset->port = snd_seq_event_port_attach(client, pcbp, + SND_SEQ_PORT_CAP_IN, + SND_SEQ_PORT_TYPE_MIDI_GM | SND_SEQ_PORT_TYPE_SOUNDFONT, + name); + emu->ports[i] = chset->port; + emu->chsets[i] = chset; + } + + /* Set up a queue for us to use */ + /* is this right ??? XXX */ + memset(&qinfo, 0, sizeof(qinfo)); + qinfo.queue = 0; + err = snd_seq_kernel_client_ctl(client, SND_SEQ_IOCTL_GET_QUEUE_INFO, &qinfo); + if (err < 0) + printk("Q get failed %d\n", err); + qinfo.locked = 1; + qinfo.owner = client; + err = snd_seq_kernel_client_ctl(client, SND_SEQ_IOCTL_SET_QUEUE_INFO, &qinfo); + if (err < 0) + printk("Q set failed %d\n", err); + + snd_free(pcbp, sizeof(*pcbp)); + return; +} + +/* + * Detach from the ports that were set up for this synthesizer and + * destroy the kernel client. + */ +void +snd_emu8000_detach_seq(emu8000_t *emu) +{ + int i; + + /* Close down the ports */ + for (i = 0; i < EMU8000_MAX_PORTS; i++) { + snd_seq_event_port_detach(emu->client, emu->ports[i]); + snd_free(emu->chsets[i], sizeof(*emu->chsets[i])); + } + + /* Now delete the client */ + if (emu->client > 0) + snd_seq_delete_kernel_client(emu->client); +} + +static int +emu8000_event_input(snd_seq_event_t *ev, void *private) +{ + emu8000_t *emu; + snd_midi_channel_set_t *chset; + + if (private == NULL) + return -EINVAL; + + chset = private; + emu = chset->private_data; + + if (ev == NULL || emu == NULL) { + snd_printd("ev or emu was NULL\n"); + return -EINVAL; + } + + snd_midi_process_event(&emu8000_ops, ev, chset); + + return 0; +} + +/* + * Routine that is called upon a first use of a particular port + */ +static int +emu8000_use(void *private) +{ + return 0; +} + +/* + * Routine that is called upon the last unuse() of a particular port. + */ +static int +emu8000_unuse(void *private) +{ + snd_midi_channel_set_t *chset; + emu8000_t *emu; + + if (!private) + return 0; + chset = private; + emu = chset->private_data; + + if (emu) + snd_emu8000_terminate_all(emu, chset->port); + + return 0; +} + +/* + * A routine that returns EINVAL to disallow the action. + */ +static int +not_allowed(void *private) +{ + return -EINVAL; +} + +static int +get_client(snd_card_t *card, char *name) +{ + snd_seq_client_callback_t callbacks; + snd_seq_client_info_t cinfo; + int client; + int n; + + callbacks.private_data = NULL; + callbacks.allow_input = 1; + callbacks.allow_output = 1; + + /* Find a free client, start from 1 as the MPU expects to use 0 */ + for (n = 1; n < 7; n++) { + client = snd_seq_create_kernel_client(card, n, &callbacks); + if (client >= 0) + break; + } + if (client < 0) + return client; + + memset(&cinfo, 0, sizeof(cinfo)); + sprintf(cinfo.name, "%d: AWE (EMU8000) MIDI Synth", card->number); + snd_seq_kernel_client_ctl(client, SND_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); + + return client; +} diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/emu8000_synth.c new/lowlevel/sb/emu8000_synth.c --- alsa-driver/lowlevel/sb/emu8000_synth.c Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/emu8000_synth.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,850 @@ +/* + * Midi synth routines for the emu8000 (AWE32/64) + * + * Copyright (C) 1999 Steve Ratcliffe + * + * Contains code based on awe_wave.c by Takashi Iwai + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include "driver.h" +#include "emu8000.h" +#include "soundfont.h" +#include "midi.h" + +/* + * Routines to actually synthesize sounds. + * + * + */ + +/* Prototypes for static functions */ +static void terminate_same_notes(emu8000_t *emu, int note, int exclass, + snd_midi_channel_t *chan); +static emu8000_voice_t *setup_voice(emu8000_t *emu, emu8000_voice_t *voice, + snd_midi_channel_t *chan); +static void calc_volume(emu8000_voice_t *vp, snd_midi_channel_t *chan); +static void calc_pitch(emu8000_voice_t *vp, snd_midi_channel_t *chan); +static emu8000_voice_t *get_voice(emu8000_t *emu); +static snd_sf_zone_t *get_zone(emu8000_t *emu, int note, int vel, + snd_midi_channel_t *chan); +static snd_sf_zone_t *find_zone(snd_sf_list_t *sf, int bank, int preset, + int note, int vel); +static void start_note(emu8000_t *emu, emu8000_voice_t *vp, + snd_midi_channel_t *chan); +static void set_pitch(emu8000_t *emu, emu8000_voice_t *vp); +static void set_volume(emu8000_t *emu, emu8000_voice_t *vp); +static void set_pan(emu8000_t *emu, emu8000_voice_t *vp, + snd_midi_channel_t *chan); +static void set_fmmod(emu8000_t *emu, emu8000_voice_t *vp, snd_sf_zone_t *zp); +static void set_tremfreq(emu8000_t *emu, emu8000_voice_t *vp, + snd_sf_zone_t *zp); +static void set_fm2frq2(emu8000_t *emu, emu8000_voice_t *vp, snd_sf_zone_t *zp); + +/* A counter used to track least recently used voice */ +static unsigned int use_time; + +/* + * Ensure a value is between two points + * macro evaluates its args more than once, so changed to upper-case. + */ +#define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0) +#define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0) + +#define STATE_IS_PLAYING(s) ((s) & EMU8000_ST_ON) + +/* + * Start a note. + */ +void +snd_emu8000_note_on(void *p, int note, int vel, snd_midi_channel_t *chan) +{ + emu8000_voice_t *vp; + snd_sf_zone_t *zp; + emu8000_t *emu; + + emu = p; + EMU8000_CHECK(emu); + + if (chan == NULL) + return; + + zp = get_zone(emu, note, vel, chan); + if (zp == NULL) + return; + + terminate_same_notes(emu, note, zp->v.exclusiveClass, chan); + + for (; zp; zp = zp->zone_link) { + vp = get_voice(emu); + + vp->chan = chan; + vp->note = note; + vp->velocity = vel; + vp->zone = zp; + +//snd_printk("Voice %d cn%d n%d v%d\n", vp->ch, chan->number, note, vel); + setup_voice(emu, vp, chan); +//snd_printk("setup_voice avol=%d, note=%d\n", vp->avol, vp->note); + + start_note(emu, vp, chan); +//snd_printk("start_note\n"); + } +} + +/* + * Release a note in response to a midi note off. + */ +void +snd_emu8000_note_off(void *p, int note, int vel, + snd_midi_channel_t *chan) +{ + int ch; + int dcysusv; + emu8000_t *emu; + emu8000_voice_t *vp; + snd_sf_zone_t *zp; + + emu = p; + EMU8000_CHECK(emu); + +//snd_printk("note off n%d v%d ch%d\n", note, vel, chan->number); + for (ch = 0; ch < emu->max_voices; ch++) { + vp = &emu->voices[ch]; + if ((vp->state & EMU8000_ST_ON) && + vp->chan->number == chan->number && + vp->note == note) + { +//snd_printk(" releasing voice%d\n", ch); + vp->state = EMU8000_ST_RELEASED; + vp->time = use_time++; + zp = vp->zone; + + dcysusv = 0x8000 | (unsigned char)zp->v.parm.modrelease; + EMU8000_DCYSUS_WRITE(emu, ch, dcysusv); + dcysusv = 0x8000 | (unsigned char)zp->v.parm.volrelease; + EMU8000_DCYSUSV_WRITE(emu, ch, dcysusv); + } + } +} + +/* + * Deal with a controler type event. This includes all types of + * control events, not just the midi controllers + */ +void +snd_emu8000_control(void *p, int type, snd_midi_channel_t *chan) +{ + emu8000_voice_t *vp; + emu8000_t *emu; + snd_sf_zone_t *zp; + int i; + + emu = p; + EMU8000_CHECK(emu); + + if (chan == NULL) + return; + + /* + * At present recalc every thing, we can be more selective based on + * type if that proves to be necessary. + */ + + /* + * Need to find all active voices that belong to this channel. Have + * to search through them all as there could be several notes playing + * on the channel and also there can be several voices per note. + */ + for (i = 0; i < emu->max_voices; i++) { + vp = &emu->voices[i]; + + if (vp->chan && vp->chan->number == chan->number) { + if (!STATE_IS_PLAYING(vp->state)) + continue; + + zp = vp->zone; + if (zp == NULL) + continue; + + setup_voice(emu, vp, chan); + + set_volume(emu, vp); + set_pitch(emu, vp); + set_pan(emu, vp, chan); + set_fmmod(emu, vp, zp); + set_tremfreq(emu, vp, zp); + set_fm2frq2(emu, vp, zp); + } + } +} + +/* + * Terminate all voices that have the same exclusive class. This + * is mainly for drums. + * Well exclusive class isn't commonly used? + * Also turn off same notes. Perhaps should only do this for drum_channel. + * May want to do something similar for mono-phonic instruments. + */ +static void +terminate_same_notes(emu8000_t *emu, int note, int exclass, + snd_midi_channel_t *chan) +{ + emu8000_voice_t *vp; + int i; + + for (i = 0; i < emu->max_voices; i++) { + vp = &emu->voices[i]; + if (!STATE_IS_PLAYING(vp->state)) + continue; + if (vp->chan == NULL || vp->zone == NULL) + continue; + + if (vp->chan->number == chan->number) { + if (note == vp->note || + (exclass && vp->zone->v.exclusiveClass == exclass)) { + EMU8000_DCYSUSV_WRITE(emu, i, 0x807F); + emu->voices[i].state = EMU8000_ST_OFF; + } + } + } +} + +/* + * Terminate all the notes on a particular port number. + */ +void +snd_emu8000_terminate_all(emu8000_t *emu, int pnumber) +{ + int i; + + /* Can't tell at present so do all */ + for (i = 0; i < emu->max_voices; i++) { + EMU8000_DCYSUSV_WRITE(emu, i, 0x807F); + emu->voices[i].state = EMU8000_ST_OFF; + } +} + +/* + * Sets up the voice structure by calculating some values that + * will be needed later. + * I believe that it is possible to move all the layer stuff in Takashi's + * driver to this routine. + */ +static emu8000_voice_t * +setup_voice(emu8000_t *emu, emu8000_voice_t *voice, snd_midi_channel_t *chan) +{ +/* do we need emu ??? */ + + calc_volume(voice, chan); + calc_pitch(voice, chan); + + /* If we do layer here then we will be returning a shadow voice */ + return voice; +} + +/*================================================================ + * calculate volume attenuation + *---------------------------------------------------------------- + * Voice volume is controlled by volume attenuation parameter. + * So volume becomes maximum when avol is 0 (no attenuation), and + * minimum when 255 (-96dB or silence). + *================================================================*/ + +/* tables for volume->attenuation calculation */ +static unsigned char voltab1[128] = { + 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, + 0x63, 0x2b, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, + 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, + 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, + 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, + 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, + 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +static unsigned char voltab2[128] = { + 0x32, 0x31, 0x30, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x2a, + 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21, + 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, + 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x16, 0x16, 0x15, 0x15, + 0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x10, + 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, + 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, + 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +static unsigned char expressiontab[128] = { + 0x7f, 0x6c, 0x62, 0x5a, 0x54, 0x50, 0x4b, 0x48, 0x45, 0x42, + 0x40, 0x3d, 0x3b, 0x39, 0x38, 0x36, 0x34, 0x33, 0x31, 0x30, + 0x2f, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25, + 0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x20, 0x1f, 0x1e, 0x1e, + 0x1d, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x18, + 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13, + 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f, + 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, + 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, + 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, + 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, + 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +static int vol_table[128] = { + 255,111,95,86,79,74,70,66,63,61,58,56,54,52,50,49, + 47,46,45,43,42,41,40,39,38,37,36,35,34,34,33,32, + 31,31,30,29,29,28,27,27,26,26,25,24,24,23,23,22, + 22,21,21,21,20,20,19,19,18,18,18,17,17,16,16,16, + 15,15,15,14,14,14,13,13,13,12,12,12,11,11,11,10, + 10,10,10,9,9,9,8,8,8,8,7,7,7,7,6,6, + 6,6,5,5,5,5,5,4,4,4,4,3,3,3,3,3, + 2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,0, +}; +/* + * Magic to calculate the volume (actually attenuation) from all the + * voice and channels parameters. + */ +static void +calc_volume(emu8000_voice_t *vp, snd_midi_channel_t *chan) +{ + int vol; + int chan_vol; + snd_sf_zone_t *zp; + + /* search voice information */ + if ((zp = vp->zone) == NULL) + return; + +#if 1 + /* I am using the 'new' volume calc */ + chan_vol = SND_GM_VOLUME(chan) * zp->v.amplitude / 127*127; + LIMITVALUE(vp->velocity, 0, 127); + LIMITVALUE(chan_vol, 0, 127); + LIMITMAX(chan->gm_expression, 127); + + vol = voltab1[chan_vol] + voltab2[vp->velocity]; + vol = (vol * 8) / 3; + vol += zp->v.attenuation; + if (chan->gm_expression < 127) + vol += ((0x100 - vol) * expressiontab[chan->gm_expression])/128; +#if 0/*NOTYET*/ + vol += atten_offset; + if (atten_relative) + vol += ctrls[AWE_MD_ZERO_ATTEN]; +#endif + LIMITVALUE(vol, 0, 255); + vp->avol = vol; +#else + /* Or perhaps a completely different method */ + vol = (vp->velocity * chan->gm_volume * chan->gm_expression) / (128*128); + vol = 128-vol; + vol += (int)zp->v.attenuation; + //vp->avol = 2*vol; + vp->avol = vol; + LIMITMAX(vp->avol, 255); +#endif +//snd_printk("gmvol%d vel %d atten %d avol %d\n", SND_GM_VOLUME(chan)/127, vp->velocity, zp->v.attenuation, vp->avol); + + if (!chan->drum_channel + && ((awe_voice_parm_block*)&zp->v.parm)->volatk < 0x7d) + { + int atten; + if (vp->velocity < 70) + atten = 70; + else + atten = vp->velocity; + vp->acutoff = (atten * zp->v.parm.cutoff + 0xa0) >> 7; + } else { + vp->acutoff = zp->v.parm.cutoff; + } +} + +/*================================================================ + * calculate pitch offset + *---------------------------------------------------------------- + * 0xE000 is no pitch offset at 44100Hz sample. + * Every 4096 is one octave. + *================================================================*/ +static void +calc_pitch(emu8000_voice_t *vp, snd_midi_channel_t *chan) +{ + snd_sf_zone_t *zp; + int offset; + + /* search voice information */ + if ((zp = vp->zone) == NULL) + return; + + /* calculate offset */ + if (zp->v.fixkey >= 0) { + offset = (zp->v.fixkey - zp->v.root) * 4096 / 12; + } else { + offset = (vp->note - zp->v.root) * 4096 / 12; + } + offset = (offset * zp->v.scaleTuning) / 100; + offset += zp->v.tune * 4096 / 1200; + if (chan->midi_pitchbend != 0) { + /* (819200: 1 semitone) ==> (4096: 12 semitones) */ + offset += chan->midi_pitchbend * chan->gm_rpn_pitch_bend_range / 2400; + } + +#if 0 + /* add initial pitch correction */ + if (FX_ON(&chan->fx_layer[vp->layer], AWE_FX_INIT_PITCH)) + offset += chan->fx_layer[vp->layer].val[AWE_FX_INIT_PITCH]; + else if (FX_ON(&chan->fx, AWE_FX_INIT_PITCH)) + offset += chan->fx.val[AWE_FX_INIT_PITCH]; +#endif + + /* 0xe000: root pitch */ + vp->apitch = 0xe000 + zp->v.rate_offset + offset; + if (vp->apitch > 0xffff) + vp->apitch = 0xffff; + if (vp->apitch < 0) + vp->apitch = 0; +} + +/* + * Find a channel (voice) within the EMU that is not in use or at least + * less in use than other channels. Always returns a valid pointer + * no matter what. If there is a real shortage of voices then one + * will be cut. Such is life. + */ +static emu8000_voice_t * +get_voice(emu8000_t *emu) +{ + int i; + emu8000_voice_t *vp; + + /* what we are looking for, in order of preference */ + enum { + OFF=0, RELEASED, SUSTAINED, PLAYING, END + }; + + /* Keeps track of what we are finding */ + struct best { + unsigned int time; + emu8000_voice_t *voice; + } best[END]; + struct best *bp; + + for (i = 0; i < END; i++) { + best[i].time = 0x7fffffff /* XXX MAX_?INT really */; + best[i].voice = NULL; + } + + /* + * Go through them all and get a best one to use. + * NOTE: could also look at volume and pick the quietest one. + */ + for (i = 0; i < emu->max_voices; i++) { + int state; + + vp = &emu->voices[i]; + state = vp->state; + + if (state == EMU8000_ST_OFF) + bp = best + OFF; + else if (state == EMU8000_ST_RELEASED) + bp = best + RELEASED; +#if 0 + else if (state == EMU8000_ST_SUSTAINED) + bp = best + SUSTAINED; +#endif + else + bp = best + PLAYING; + + if (vp->time < bp->time) { + bp->time = vp->time; + bp->voice = vp; + } + } + + for (i = 0; i < END; i++) { + vp = best[i].voice; + if (vp) { + vp->time = use_time++; + return vp; + } + } + + snd_printd("Oh, we shouldn't be here (get_voice)\n"); + return &emu->voices[0]; /* Always return something anyway */ +} + +/* + * Get a set of what I am calling zone parameters that describe the + * voice for this note and velocity. Also need midi channel information + * for the bank number(s). + */ +static snd_sf_zone_t * +get_zone(emu8000_t *emu, int note, int vel, snd_midi_channel_t *chan) +{ + snd_sf_zone_t *zp; + int preset; + int bank, defbank; + + //snd_printk("get zone: chan%d bank%d note%d preset[program]=%p\n", chan->number, chan->bank, note, emu->sflist.presets[chan->program]); + + preset = chan->midi_program; + LIMITVALUE(preset, 0, 127); + + /* + * Calculate our idea of bank number from the midi bank number. + * This depends on if we are a drum channel and what mode we + * are in. + * Also set a default bank in case the wanted one is not found. + */ + switch (chan->midi_mode) { + case SND_MIDI_MODE_GM: + default: + /* + * Default and GM case use the msb of bank select and use + * bank 128 if a drum channel. + */ + if (chan->drum_channel) { + bank = 128; + defbank = 128; + } else { + bank = chan->gm_bank_select; + defbank = 0; + } + break; + } + + zp = find_zone(&emu->sflist, bank, preset, note, vel); + if (zp == NULL) { + /* Haven't got what we want, try a default */ + if (chan->drum_channel) { + /* Try standard drum kit */ + zp = find_zone(&emu->sflist, defbank, 0, note, vel); + } else { + /* Try bank 0 instead of a variation bank */ + zp = find_zone(&emu->sflist, defbank, preset, note, vel); + } + } + + return zp; +} + +static snd_sf_zone_t * +find_zone(snd_sf_list_t *sf, int bank, int preset, int note, int vel) +{ + snd_sf_zone_t *zp; + snd_sf_zone_t *foundzp; + +//snd_printd("look for %d, %d\n", bank, preset); + /* Get to the correct tone bank */ + for (zp = sf->presets[preset]; zp; zp = zp->next_bank) { + if (zp->bank == bank) + break; /* Got it */ + } +//snd_printd("got %p\n", zp); + + /* Now get the actual instrument range */ + foundzp = NULL; + for (; zp; zp = zp->next_instr) { +//if (chan->gm_bank_select == 128)snd_printk("zone:bank%d,instr%d low%d high%d, vellow%d velhi%d\n", chan->gm_bank_select, zp->instr, zp->v.low, zp->v.high, zp->v.vellow, zp->v.velhigh); + if (note >= zp->v.low && note <= zp->v.high + && vel >= zp->v.vellow && vel <= zp->v.velhigh) { + +//snd_printd("sample-id %d start %x end %x lstart %x lend %x\n", zp->sample->v.sample, zp->v.start, zp->v.end, zp->v.loopstart, zp->v.loopend); + zp->zone_link = NULL; + if (foundzp) + foundzp->zone_link = zp; + else + foundzp = zp; + } + } + + return foundzp; +} + +/* table for volume target calculation */ +static unsigned short voltarget[16] = { + 0xEAC0, 0xE0C8, 0xD740, 0xCE20, 0xC560, 0xBD08, 0xB500, 0xAD58, + 0xA5F8, 0x9EF0, 0x9830, 0x91C0, 0x8B90, 0x85A8, 0x8000, 0x7A90 +}; + +/* Here goes... */ + +/* + * This is it, write all the registers to get the note going. There + * is so much to do here that it is a wonder that it can all be done + * before the note is finished.. + * All copied directly from Takashi's driver apart from name changes etc. + */ +static void +start_note(emu8000_t *emu, emu8000_voice_t *vp, snd_midi_channel_t *chan) +{ + unsigned int temp; + int ch; + int addr; + int vtarget, ftarget, ptarget, pitch; + /* Still using awe_ for stuff that is from userspace (sfxload) */ + awe_voice_parm_block *parm; + snd_sf_zone_t *zp; + + zp = vp->zone; + if (zp == NULL) + return; + + ch = vp - emu->voices; + if (ch < 0) { + snd_printd("ch -ve %d!\n", ch); + ch = 0; + } + + parm = (awe_voice_parm_block*)&zp->v.parm; + + /* channel to be silent and idle */ + EMU8000_DCYSUSV_WRITE(emu, ch, 0x0080); + EMU8000_VTFT_WRITE(emu, ch, 0x0000FFFF); + EMU8000_CVCF_WRITE(emu, ch, 0x0000FFFF); + EMU8000_PTRX_WRITE(emu, ch, 0); + EMU8000_CPF_WRITE(emu, ch, 0); + + /* set pitch offset */ + set_pitch(emu, vp); + + /* modulation & volume envelope */ + if (parm->modatk >= 0x80 && parm->moddelay >= 0x8000) { + EMU8000_ENVVAL_WRITE(emu, ch, 0xBFFF); + pitch = (parm->env1pit<<4) + vp->apitch; + if (pitch > 0xffff) pitch = 0xffff; + /* calculate filter target */ + ftarget = parm->cutoff + parm->env1fc; + LIMITVALUE(ftarget, 0, 255); + ftarget <<= 8; + } else { + EMU8000_ENVVAL_WRITE(emu, ch, parm->moddelay); + ftarget = parm->cutoff; + ftarget <<= 8; + pitch = vp->apitch; + } + + /* calcualte pitch target */ + if (pitch != 0xffff) { + ptarget = 1 << (pitch >> 12); + if (pitch & 0x800) ptarget += (ptarget*0x102e)/0x2710; + if (pitch & 0x400) ptarget += (ptarget*0x764)/0x2710; + if (pitch & 0x200) ptarget += (ptarget*0x389)/0x2710; + ptarget += (ptarget>>1); + if (ptarget > 0xffff) ptarget = 0xffff; + + } else ptarget = 0xffff; + if (parm->modatk >= 0x80) + EMU8000_ATKHLD_WRITE(emu, ch, (parm->modhld << 8) | 0x7f); + else + EMU8000_ATKHLD_WRITE(emu, ch, zp->v.parm.modatkhld); + EMU8000_DCYSUS_WRITE(emu, ch, zp->v.parm.moddcysus); + + if (parm->volatk >= 0x80 && parm->voldelay >= 0x8000) { + EMU8000_ENVVAL_WRITE(emu, ch, 0xBFFF); + vtarget = voltarget[vp->avol%0x10]>>(vp->avol>>4); + } else { + EMU8000_ENVVOL_WRITE(emu, ch, zp->v.parm.voldelay); + vtarget = 0; + } + if (parm->volatk >= 0x80) + EMU8000_ATKHLDV_WRITE(emu, ch, (parm->volhld << 8) | 0x7f); + else + EMU8000_ATKHLDV_WRITE(emu, ch, zp->v.parm.volatkhld); + /* decay/sustain parameter for volume envelope must be set at last */ + + /* cutoff and volume */ + set_volume(emu, vp); + + /* modulation envelope heights */ + EMU8000_PEFE_WRITE(emu, ch, zp->v.parm.pefe); + + /* lfo1/2 delay */ + EMU8000_LFO1VAL_WRITE(emu, ch, zp->v.parm.lfo1delay); + EMU8000_LFO2VAL_WRITE(emu, ch, zp->v.parm.lfo2delay); + + /* lfo1 pitch & cutoff shift */ + set_fmmod(emu, vp, zp); + /* lfo1 volume & freq */ + set_tremfreq(emu, vp, zp); + /* lfo2 pitch & freq */ + set_fm2frq2(emu, vp, zp); + /* pan & loop start */ + set_pan(emu, vp, chan); + + /* chorus & loop end (chorus 8bit, MSB) */ + addr = zp->v.loopend - 1; + addr += zp->v.mode; + temp = zp->v.parm.chorus; + temp = (temp <<24) | (unsigned int)addr; + EMU8000_CSL_WRITE(emu, ch, temp); + + /* Q & current address (Q 4bit value, MSB) */ + addr = zp->v.start - 1; + addr += zp->v.mode; + temp = zp->v.parm.filterQ; + temp = (temp<<28) | (unsigned int)addr; + EMU8000_CCCA_WRITE(emu, ch, temp); + + /* clear unknown registers */ + EMU8000_00A0_WRITE(emu, ch, 0); + EMU8000_0080_WRITE(emu, ch, 0); + +//snd_printk("vtarget %d, ftarget %d\n", vtarget, ftarget); + /* reset volume */ + EMU8000_VTFT_WRITE(emu, ch, (vtarget<<16)|ftarget); + EMU8000_CVCF_WRITE(emu, ch, (vtarget<<16)|ftarget); + +//snd_printk("DCYSUSV %x\n", zp->v.parm.voldcysus); + /* turn on envelope */ + EMU8000_DCYSUSV_WRITE(emu, ch, zp->v.parm.voldcysus); + /* set reverb */ + temp = zp->v.parm.reverb; + temp = (temp << 8) | (ptarget << 16) | vp->aaux; + EMU8000_PTRX_WRITE(emu, ch, temp); + EMU8000_CPF_WRITE(emu, ch, ptarget << 16); + + vp->state = EMU8000_ST_ON; + +#if 0 + /* clear voice position for the next note on this channel */ + if (SINGLE_LAYER_MODE()) { + FX_UNSET(fx, AWE_FX_SAMPLE_START); + FX_UNSET(fx, AWE_FX_COARSE_SAMPLE_START); + } +#endif +} + +/* + * Set the pitch of a possibly playing note. + */ +static void +set_pitch(emu8000_t *emu, emu8000_voice_t *vp) +{ + EMU8000_IP_WRITE(emu, vp->ch, vp->apitch); +} + +/* + * Set the volume of a possibly already playing note + */ +static void +set_volume(emu8000_t *emu, emu8000_voice_t *vp) +{ + int ifatn; + + ifatn = (unsigned char)vp->acutoff; + ifatn = (ifatn << 8); + ifatn |= (unsigned char)vp->avol; + EMU8000_IFATN_WRITE(emu, vp->ch, ifatn); +} + +/* + * Set pan and loop start address. + */ +static void +set_pan(emu8000_t *emu, emu8000_voice_t *vp, snd_midi_channel_t *chan) +{ + snd_sf_zone_t *zp; + unsigned int temp; + int addr; + + zp = vp->zone; + if (zp == NULL) + return; + + /* pan & loop start (pan 8bit, MSB, 0:right, 0xff:left) */ + if (zp->v.fixpan > 0) /* 0-127 */ + temp = 255 - (int)zp->v.fixpan * 2; + else { + int pos = 0; + if (zp->v.pan >= 0) /* 0-127 */ + pos = zp->v.pan * 2 - 128; + pos += chan->gm_pan * 2 - 128; /* -128 - 127 */ + temp = 127 - pos; + } + LIMITVALUE(temp, 0, 255); + + if (1 || temp != vp->apan) { + /* + * The loop start and the pan position both go in the same + * register. + */ + vp->apan = temp; + + addr = zp->v.loopstart - 1; + addr += zp->v.mode; + temp = (temp<<24) | (unsigned int)addr; + + EMU8000_PSST_WRITE(emu, vp->ch, temp); + + if (temp == 0) + vp->aaux = 0xff; + else + vp->aaux = (-temp)&0xff; + } +} + +#define MOD_SENSE 18 + +static void +set_fmmod(emu8000_t *emu, emu8000_voice_t *vp, snd_sf_zone_t *zp) +{ + short fmmod; + unsigned char pitch; + unsigned char cutoff; + + pitch = (zp->v.parm.fmmod>>8) & 0xff; + cutoff = (zp->v.parm.fmmod & 0xff); + pitch += (MOD_SENSE * vp->chan->gm_modulation) / 1200; + fmmod = (pitch<<8) + cutoff; + + EMU8000_FMMOD_WRITE(emu, vp->ch, fmmod); +} + +/* set tremolo (lfo1) volume & frequency */ +static void +set_tremfreq(emu8000_t *emu, emu8000_voice_t *vp, snd_sf_zone_t *zp) +{ + EMU8000_TREMFRQ_WRITE(emu, vp->ch, zp->v.parm.tremfrq); +} + +/* set lfo2 pitch & frequency */ +static void +set_fm2frq2(emu8000_t *emu, emu8000_voice_t *vp, snd_sf_zone_t *zp) +{ + unsigned char pitch; + unsigned char freq; + short fm2frq2; + + pitch = (zp->v.parm.fm2frq2>>8) & 0xff; + freq = zp->v.parm.fm2frq2 & 0xff; + pitch += (MOD_SENSE * vp->chan->gm_modulation) / 1200; + LIMITMAX(pitch, 255); + fm2frq2 = (pitch<<8) + freq; + + EMU8000_FM2FRQ2_WRITE(emu, vp->ch, fm2frq2); +} + diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/midi_emulate.c new/lowlevel/sb/midi_emulate.c --- alsa-driver/lowlevel/sb/midi_emulate.c Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/midi_emulate.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,340 @@ +/* + * GM/GS/XG midi module. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * Based on awe_wave.c by Takashi Iwai + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ +/* + * This module is used to keep track of the current midi state. + * It can be used for drivers that are required to emulate midi when + * the hardware doesn't. + * + * It was written for a AWE64 driver, but there should be no AWE specific + * code in here. If there is it should be reported as a bug. + */ + +#include "driver.h" +#include "seq_kernel.h" +#include "midi_channel.h" + +/* Prototypes for static functions */ +static void do_control(snd_midi_op_t *ops, void *private, + snd_midi_channel_t *chan, int control, int value); +static void rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan); +static void nrpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan); +static void sysex(void *private, unsigned char *sysex, + snd_midi_channel_t *chan); +static void pre_note_proc(int client, snd_midi_channel_t *chan, + snd_seq_event_t *ev); + + +/* + * Process an event in a driver independant way. This means dealing + * with RPN, NRPN, SysEx etc that are defined for common midi applications + * such as GM, GS and XG. + * There modes that this module will run in are: + * Generic MIDI - no interpretation at all, it will just save current values + * of controlers etc. + * GM - You can use all gm_ prefixed elements of chan. Controls, RPN, NRPN, + * SysEx will be interpreded as defined in General Midi. + * GS - You can use all gs_ prefixed elements of chan. Codes for GS will be + * interpreted. + * XG - You can use all xg_ prefixed elements of chan. Codes for XG will + * be interpreted. + */ +void +snd_midi_process_event(snd_midi_op_t *ops, + snd_seq_event_t *ev, snd_midi_channel_set_t *chanset) +{ + snd_midi_channel_t *chan; + void *drv; + + if (ev == NULL || chanset == NULL) { + snd_printd("ev or chanbase NULL (snd_midi_process_event)\n"); + return; + } + if (chanset->channels == NULL) + return; + if (ev->dest.channel >= chanset->max_channels) { + snd_printd("dest channel is %d, max is %d\n", ev->dest.channel, + chanset->max_channels); + return; + } + + chan = chanset->channels + ev->dest.channel; + drv = chanset->private_data; + + /* + * First deal with EVENT_NOTE, this is converted into a NOTE_ON + * and the corresponding NOTE_OFF, which is queued. + */ + if (ev->type == SND_SEQ_EVENT_NOTE) + pre_note_proc(chanset->client, chan, ev); + + /* Make sure that we don't have a note on that should really be + * a note off */ + if (ev->type == SND_SEQ_EVENT_NOTEON && ev->data.note.velocity == 0) + ev->type = SND_SEQ_EVENT_NOTEOFF; + + switch (ev->type) { + case SND_SEQ_EVENT_NOTEON: + chan->note[ev->data.note.note] = SND_MIDI_NOTE_ON; + ops->note_on(drv, ev->data.note.note, ev->data.note.velocity, chan); + break; + case SND_SEQ_EVENT_NOTEOFF: + if (chan->gm_hold) { + /* Hold this note until pedal is turned off */ + chan->note[ev->data.note.note] |= SND_MIDI_NOTE_RELEASED; + } else if (chan->note[ev->data.note.note] & SND_MIDI_NOTE_SUSTENUTO) { + /* Mark this note as release; it will be turned off when sustenuto + * is turned off */ + chan->note[ev->data.note.note] |= SND_MIDI_NOTE_RELEASED; + } else { + chan->note[ev->data.note.note] = 0; + ops->note_off(drv, ev->data.note.note, ev->data.note.velocity, chan); + } + break; + case SND_SEQ_EVENT_KEYPRESS: + chan->midi_aftertouch = ev->data.control.value; + ops->control(drv, SND_MIDI_CTL_AFTERTOUCH, chan); + break; + case SND_SEQ_EVENT_CONTROLLER: + do_control(ops, drv, chan, ev->data.control.param, ev->data.control.value); + break; + case SND_SEQ_EVENT_PGMCHANGE: + chan->midi_program = ev->data.control.value; + break; + case SND_SEQ_EVENT_PITCHBEND: + chan->midi_pitchbend = ev->data.control.value; + ops->control(drv, SND_MIDI_CTL_PITCHBEND, chan); + break; + case SND_SEQ_EVENT_CONTROL14: + /* This is general pupose slider 1. I don't know why it has + * its own event. It is equivalent to controler14, I assume */ + do_control(ops, drv, chan, 14, ev->data.control.value); + break; + case SND_SEQ_EVENT_NONREGPARAM: + /* Break it back into its controler values */ + chan->param_type = SND_MIDI_PARAM_TYPE_NONREGISTERED; + chan->control[SND_MIDI_CTL_DATA_ENTRY] + = (ev->data.control.value>>8)&0xff; + chan->control[SND_MIDI_CTL_DATA_ENTRY_LSB] + = ev->data.control.value&0xff; + chan->control[SND_MIDI_CTL_NONREG_PARAM] + = (ev->data.control.param >> 8) & 0xff; + chan->control[SND_MIDI_CTL_NONREG_PARAM_LSB] + = (ev->data.control.param >> 8) & 0xff; + nrpn(ops, drv, chan); + break; + case SND_SEQ_EVENT_REGPARAM: + /* Break it back into its controler values */ + chan->param_type = SND_MIDI_PARAM_TYPE_REGISTERED; + chan->control[SND_MIDI_CTL_DATA_ENTRY] + = (ev->data.control.value>>8)&0xff; + chan->control[SND_MIDI_CTL_DATA_ENTRY_LSB] + = ev->data.control.value&0xff; + chan->control[SND_MIDI_CTL_REG_PARAM] + = (ev->data.control.param >> 8) & 0xff; + chan->control[SND_MIDI_CTL_REG_PARAM_LSB] + = (ev->data.control.param >> 8) & 0xff; + rpn(ops, drv, chan); + break; + case SND_SEQ_EVENT_SONGPOS: + case SND_SEQ_EVENT_SONGSEL: + case SND_SEQ_EVENT_CLOCK: + case SND_SEQ_EVENT_START: + case SND_SEQ_EVENT_CONTINUE: + case SND_SEQ_EVENT_STOP: + case SND_SEQ_EVENT_QFRAME: + case SND_SEQ_EVENT_TEMPO: + case SND_SEQ_EVENT_TIMESIGN: + case SND_SEQ_EVENT_KEYSIGN: + case SND_SEQ_EVENT_SYSEX: + goto not_yet; + case SND_SEQ_EVENT_HEARTBEAT: + break; + case SND_SEQ_EVENT_CLIENT_START: + case SND_SEQ_EVENT_CLIENT_EXIT: + case SND_SEQ_EVENT_CLIENT_CHANGE: + case SND_SEQ_EVENT_PORT_START: + case SND_SEQ_EVENT_PORT_EXIT: + case SND_SEQ_EVENT_PORT_CHANGE: + case SND_SEQ_EVENT_SAMPLE: + case SND_SEQ_EVENT_SAMPLE_START: + case SND_SEQ_EVENT_SAMPLE_STOP: + case SND_SEQ_EVENT_SAMPLE_FREQ: + case SND_SEQ_EVENT_SAMPLE_VOLUME: + case SND_SEQ_EVENT_SAMPLE_LOOP: + case SND_SEQ_EVENT_SAMPLE_POSITION: + case SND_SEQ_EVENT_ECHO: + not_yet: + default: + snd_printd("Unimplemented event %d\n", ev->type); + break; + } +} + + +/* + * Do all driver independant operations for this controler and pass + * events that need to take place immediately to the driver. + */ +static void +do_control(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, + int control, int value) +{ + int i; + + /* Switches */ + if ((control >=64 && control <=69) || (control >= 80 && control <= 83)) { + /* These are all switches; either off or on so set to 0 or 127 */ + value = (value >= 64)? 127: 0; + } + chan->control[control] = value; + + switch (control) { + case SND_MIDI_CTL_HOLD: + if (value == 0) { + /* Sustain has been released, turn off held notes */ + for (i = 0; i < 127; i++) { + if (chan->note[i] & SND_MIDI_NOTE_RELEASED) { + chan->note[i] = SND_MIDI_NOTE_OFF; + ops->note_off(drv, i, 0, chan); + } + } + } + break; + case SND_MIDI_CTL_PORTAMENTO: + break; + case SND_MIDI_CTL_SUSTENUTO: + if (value) { + /* Mark each note that is currently held down */ + for (i = 0; i < 127; i++) { + if (chan->note[i] & SND_MIDI_NOTE_ON) + chan->note[i] |= SND_MIDI_NOTE_SUSTENUTO; + } + } else { + /* release all notes that were held */ + for (i = 0; i < 127; i++) { + if (chan->note[i] & SND_MIDI_NOTE_SUSTENUTO) { + chan->note[i] &= ~SND_MIDI_NOTE_SUSTENUTO; + if (chan->note[i] & SND_MIDI_NOTE_RELEASED) { + chan->note[i] = SND_MIDI_NOTE_OFF; + ops->note_off(drv, i, 0, chan); + } + } + } + } + break; + case SND_MIDI_CTL_DATA_ENTRY: + break; + case SND_MIDI_CTL_DATA_ENTRY_LSB: + if (chan->param_type == SND_MIDI_PARAM_TYPE_REGISTERED) + rpn(ops, drv, chan); + else + nrpn(ops, drv, chan); + break; + case SND_MIDI_CTL_REG_PARAM: + chan->param_type = SND_MIDI_PARAM_TYPE_REGISTERED; + break; + case SND_MIDI_CTL_REG_PARAM_LSB: + break; + case SND_MIDI_CTL_NONREG_PARAM: + chan->param_type = SND_MIDI_PARAM_TYPE_NONREGISTERED; + break; + case SND_MIDI_CTL_NONREG_PARAM_LSB: + break; + case SND_MIDI_CTL_SOFT: + case SND_MIDI_CTL_LEGATO: + case SND_MIDI_CTL_HOLD2: + case SND_MIDI_CTL_SOUND_VARIATION: + case SND_MIDI_CTL_SOUND_TIMBRE: + case SND_MIDI_CTL_SOUND_RELEASE_TIME: + case SND_MIDI_CTL_SOUND_ATTACK_TIME: + case SND_MIDI_CTL_SOUND_BRIGHTNESS: +#if 0 + case SND_MIDI_CTL_EFFECTS_LEVEL: + case SND_MIDI_CTL_TREMULO_LEVEL: + case SND_MIDI_CTL_CHORUS_LEVEL: + case SND_MIDI_CTL_CELESTE_LEVEL: + case SND_MIDI_CTL_PHASER_LEVEL: +#endif + goto notyet; + notyet: + default: + ops->control(drv, control, chan); + break; + } +} + +/* + * Process a rpn message. + */ +static void +rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan) +{ +} + +/* + * Process an nrpn message. + */ +static void +nrpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan) +{ +} + +/* + * Process a sysex message. + */ +static void +sysex(void *private, unsigned char *sysex, snd_midi_channel_t *chan) +{ +} + +/* + * Deal with the NOTE event. This is converted into a note on event + * and a corresponding note off event. + */ +static void +pre_note_proc(int client, snd_midi_channel_t *chan, snd_seq_event_t *ev) +{ + snd_seq_event_t offev; + + /* Convert this one */ + ev->type = SND_SEQ_EVENT_NOTEON; + + /* Enqueue the note off first, to make sure */ + memcpy(&offev, ev, sizeof(offev)); + switch (offev.flags & SND_SEQ_TIME_STAMP_MASK) { + case SND_SEQ_TIME_STAMP_TICK: + offev.time.tick = offev.data.note.duration; + break; + case SND_SEQ_TIME_STAMP_REAL: + /* unit for duration is ms */ + offev.time.real.tv_sec = ev->data.note.duration / 1000; + offev.time.real.tv_nsec = + 1000000 * (ev->data.note.duration % 1000); + break; + } + + offev.flags = (offev.flags & ~SND_SEQ_TIME_MODE_MASK) | SND_SEQ_TIME_MODE_REL; + offev.type = SND_SEQ_EVENT_NOTEOFF; + snd_seq_kernel_client_enqueue(client, &offev, 1); +} + diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/soundfont.c new/lowlevel/sb/soundfont.c --- alsa-driver/lowlevel/sb/soundfont.c Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/soundfont.c Mon Feb 22 17:16:51 1999 @@ -0,0 +1,617 @@ +/* + * Soundfont generic routines. + * It is intended that these should be used by any driver that is willing + * to accept soundfont patches. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * Parts of this driver are based on work by Takashi Iwai. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ +/* + * Deal with reading in of a soundfont. Code follows the OSS way + * of doing things so that the old sfxload utility can be used. + * Everything may change when there is an alsa way of doing things. + * + * TODO: obviously, all AWE_ prefixes need to go away + */ +#include "driver.h" +#include "linux/awe_voice.h" +#include "soundfont.h" + +static int open_patch(snd_sf_list_t *sflist, const char *data, int count); +static int newsf(snd_sf_list_t *sflist, int type, char *name); +static snd_soundfont_t *open_patch_check(snd_sf_list_t *sflist, int type, + char *name); +static int close_patch(snd_sf_list_t *sflist); +static int load_info(snd_sf_list_t *sflist, const void *data, long count); +static void init_voice_parm(awe_voice_parm *pp); +static snd_sf_sample_t *set_sample(snd_sf_list_t *sflist, awe_voice_info *avp); +static snd_sf_sample_t *find_sample(snd_sf_list_t *sflist, int sample_id); +static int load_data(snd_sf_list_t *sflist, const void *data, long count, + snd_sf_sample_write_t sample_write, void *callarg); +static void rebuild_presets(snd_sf_list_t *sflist); +static void add_instr(snd_sf_zone_t *new, snd_sf_zone_t *old); + +/* + * Deal with a soundfont patch. Any driver could use these routines + * although it was designed for the AWE64. + * + * The sample_write and callargs pararameters allow a callback into + * the actual driver to write sample data to the board or whatever + * it wants to do with it. + */ +int +snd_soundfont_load(snd_sf_list_t *sflist, const void *data, long count, + snd_sf_sample_write_t sample_write, void *callarg) +{ + awe_patch_info patch; + int rc; + + //snd_mutex_down(sflist, sem); + + if (count < AWE_PATCH_INFO_SIZE) { + snd_printk("patch record too small %ld\n", count); + return -EINVAL; + } + + copy_from_user(&patch, data, sizeof(patch)); + count -= sizeof(patch); + data += sizeof(patch); + + if (patch.key != AWE_PATCH) { + snd_printk("'The wrong kind of patch' %x\n", patch.key); + return -EINVAL; + } + if (count < patch.len) { + snd_printk("Patch too short %ld, need %d\n", count, patch.len); + return -EINVAL; + } + if (patch.len < 0) { + return -EINVAL; + } + + rc = -EINVAL; + switch (patch.type) { + case AWE_OPEN_PATCH: + rc = open_patch(sflist, data, count); + break; + case AWE_LOAD_INFO: + rc = load_info(sflist, data, count); + break; + case AWE_LOAD_DATA: + rc = load_data(sflist, data, count, sample_write, callarg); + break; + case AWE_CLOSE_PATCH: + rc = close_patch(sflist); + break; +#if 0 + case AWE_UNLOAD_PATCH: + rc = unload_patch(&patch, data, count); + break; + case AWE_REPLACE_DATA: + rc = replace_data(&patch, data, count); + break; + case AWE_MAP_PRESET: + rc = load_map(&patch, data, count); + break; + /* case AWE_PROBE_INFO: + rc = probe_info(&patch, data, count); + break;*/ + case AWE_PROBE_DATA: + rc = probe_data(&patch, data, count); + break; + case AWE_LOAD_CHORUS_FX: + rc = load_chorus_fx(&patch, data, count); + break; + case AWE_LOAD_REVERB_FX: + rc = load_reverb_fx(&patch, data, count); + break; +#endif + + default: + snd_printk("AWE32 Error: unknown patch format type %x\n", + patch.type); + rc = -EINVAL; + break; + } + + //snd_mutex_up(sflist, sem); + return rc; +} + +/* open patch; create sf list */ +static int +open_patch(snd_sf_list_t *sflist, const char *data, int count) +{ + awe_open_parm parm; + + copy_from_user(&parm, data, sizeof(parm)); + + snd_printk("open %d, %s\n", parm.type, parm.name); + if (newsf(sflist, parm.type, parm.name) < 0) { + printk("EMU8000: can't open: failed to alloc new list\n"); + return -ENOSPC; + } + + return 0; +} + +/* + * Allocate a new soundfont structure. + */ +static int +newsf(snd_sf_list_t *sflist, int type, char *name) +{ + snd_soundfont_t *sf; + + if (snd_list_ensure_inc(sflist, fonts, 1) == NULL) + return -ENOSPC; + sf = &sflist->fonts[sflist->fonts_size++]; + sf->id = sflist->current_id++; + sf->type = type; + if (sflist->current_id == 0 || (type & AWE_PAT_LOCKED) != 0) + sflist->locked_id = sflist->current_id; + sf->mem_offset = 0; + snd_list_prepare(sf, snd_sf_zone_t, zones); + snd_list_prepare(sf, snd_sf_sample_t, samples); + + sflist->currsf = sf; + return 0; +} + +/* + * Check to see if the patch is open. If not we just do it anyway... + */ +static snd_soundfont_t * +open_patch_check(snd_sf_list_t *sflist, int type, char *name) +{ + if (sflist->currsf != NULL) + return sflist->currsf; + + if (name == NULL) + name = "Nameless patch"; + + if (newsf(sflist, type, name) < 0) + return NULL; + + return sflist->currsf; +} + +/* + * Close the current patch. + */ +static int +close_patch(snd_sf_list_t *sflist) +{ + sflist->currsf = NULL; + rebuild_presets(sflist); + return 0; +} + +/* + * Read an info record from the user buffer and save it on the current + * open soundfont. + */ +static int +load_info(snd_sf_list_t *sflist, const void *data, long count) +{ + snd_soundfont_t *sf; + snd_sf_zone_t *zones; + snd_sf_zone_t *zone; + + awe_voice_rec_hdr hdr; + int i; + + if (count < sizeof(awe_voice_rec_hdr)) { + printk("Soundfont error: invalid patch zone length\n"); + return (-EINVAL); + } + + copy_from_user((char*)&hdr, data, sizeof(hdr)); + data += sizeof(hdr); + count -= sizeof(hdr); + + if (hdr.nvoices <= 0 || hdr.nvoices >= 100) { + printk("Soundfont error: Illegal voice number %d\n", hdr.nvoices); + return -EINVAL; + } + + if (hdr.nvoices > 1) + snd_printk("Mmm nvoices is greater than 1\n"); /* XXX */ + + if (count < sizeof(awe_voice_info)*hdr.nvoices) { + printk("AWE32 Error: patch length(%ld) is smaller than nvoices(%d)\n", + count, hdr.nvoices); + return -EINVAL; + } + + sf = open_patch_check(sflist, AWE_PAT_TYPE_MISC, NULL); + if (sf == NULL) + return -ENOSPC; + + if (snd_list_ensure_inc(sf, zones, hdr.nvoices) == NULL) + return -ENOSPC; + zones = sf->zones;/*NEEDED XXX */ + + for (i = 0; i < hdr.nvoices; i++) { + //int rec = awe_free_info(); + zone = &zones[sf->zones_size++]; + + if (zone == NULL) + return -ENOSPC; + + zone->bank = hdr.bank; + zone->instr = hdr.instr; + zone->mapped = 0; + zone->disabled = 0; + + /* copy awe_voice_info parameters */ + copy_from_user(&zone->v, data, sizeof(zone->v)); + data += sizeof(zone->v); + count -= sizeof(zone->v); + + zone->v.sf_id = sflist->current_id; + if (zone->v.mode & AWE_MODE_INIT_PARM) + init_voice_parm(&zone->v.parm); + + zone->sample = set_sample(sflist, &zone->v); + } + + return 0; +} + + +#if 0 +/* initialize voice_info record */ +static void +init_voice_info(awe_voice_info *avp) +{ + avp->sf_id = 0; /* normal mode */ + avp->sample = 0; + avp->rate_offset = 0; + + avp->start = 0; + avp->end = 0; + avp->loopstart = 0; + avp->loopend = 0; + avp->mode = 0; + avp->root = 60; + avp->tune = 0; + avp->low = 0; + avp->high = 127; + avp->vellow = 0; + avp->velhigh = 127; + + avp->fixkey = -1; + avp->fixvel = -1; + avp->fixpan = -1; + avp->pan = -1; + + avp->exclusiveClass = 0; + avp->amplitude = 127; + avp->attenuation = 0; + avp->scaleTuning = 100; + + init_voice_parm(&avp->parm); +} +#endif + +/* initialize voice_parm record: + * Env1/2: delay=0, attack=0, hold=0, sustain=0, decay=0, release=0. + * Vibrato and Tremolo effects are zero. + * Cutoff is maximum. + * Chorus and Reverb effects are zero. + */ +static void +init_voice_parm(awe_voice_parm *pp) +{ + pp->moddelay = 0x8000; + pp->modatkhld = 0x7f7f; + pp->moddcysus = 0x7f7f; + pp->modrelease = 0x807f; + pp->modkeyhold = 0; + pp->modkeydecay = 0; + + pp->voldelay = 0x8000; + pp->volatkhld = 0x7f7f; + pp->voldcysus = 0x7f7f; + pp->volrelease = 0x807f; + pp->volkeyhold = 0; + pp->volkeydecay = 0; + + pp->lfo1delay = 0x8000; + pp->lfo2delay = 0x8000; + pp->pefe = 0; + + pp->fmmod = 0; + pp->tremfrq = 0; + pp->fm2frq2 = 0; + + pp->cutoff = 0xff; + pp->filterQ = 0; + + pp->chorus = 0; + pp->reverb = 0; +} + +/* search the specified sample */ +static snd_sf_sample_t * +set_sample(snd_sf_list_t *sflist, awe_voice_info *avp) +{ + snd_sf_sample_t *sample; + + avp->index = -1; /* Its never used */ + sample = find_sample(sflist, avp->sample); + if (sample == NULL) + return NULL; + + /* add in the actual sample offsets (I dont understand this ..sr) */ + avp->start += sample->v.start; + avp->end += sample->v.end; + avp->loopstart += sample->v.loopstart; + avp->loopend += sample->v.loopend; + + /* copy mode flags */ + avp->mode = sample->v.mode_flags; + + return sample; +} + +static snd_sf_sample_t * +find_sample(snd_sf_list_t *sflist, int sample_id) +{ + int i; + snd_soundfont_t *sf = sflist->currsf; + + for (i = 0; i < sf->samples_size; i++) { + if (sf->samples[i].v.sample == sample_id) { +//snd_printd("sample-id %d start %x end %x lstart %x lend %x\n", sf->samples[i].v.sample, sf->samples[i].v.start, sf->samples[i].v.end, sf->samples[i].v.loopstart, sf->samples[i].v.loopend); + return sf->samples+i; + } + } + return NULL; +} + +/* + * Load sample information, this can include data to be loaded onto + * the soundcard. It can also just be a pointer into soundcard ROM. + * If there is data it will be written to the soundcard via the callback + * routine. + */ +static int +load_data(snd_sf_list_t *sflist, const void *data, long count, + snd_sf_sample_write_t sample_write, void *callarg) +{ + snd_soundfont_t *sf; + awe_sample_info sample_info; + snd_sf_sample_t *sp; + long off; + + sf = open_patch_check(sflist, AWE_PAT_TYPE_MISC, NULL); + if (sf == NULL) + return -ENOSPC; + + copy_from_user(&sample_info, data, sizeof(sample_info)); + off = sizeof(sample_info); + + if (sample_info.size != (count-off)/2) + return -EINVAL; + + // Check for dup --> EINVAL + + /* Allocate a new sample structure */ + snd_list_ensure_inc(sf, samples, 1); + sp = &sf->samples[sf->samples_size]; + + sp->v = sample_info; + sp->v.sf_id = sflist->current_id; + + /* + * If there is sample data then save it now. + */ + if (sp->v.size > 0) { + + if (sample_write) { + int rc; + + rc = (*sample_write)(callarg, sp, data+off, count-off); + if (rc < 0) + return rc; + } + } + + sf->samples_size++; /* Commit to change */ + return count; +} + +/* + * Rebuild the preset table. This is like a hash table in that it allows + * quick access to the zone information. For each preset there are zone + * structures linked by bank and for each bank there are instrument zones + * linked off it. + */ +static void +rebuild_presets(snd_sf_list_t *sflist) +{ + int i; + int zi; + int sfi; + snd_soundfont_t *sf; + + /* preset table is 1 based */ + for (i = 0; i < SF_MAX_PRESETS+1; i++) + sflist->presets[i] = NULL; + + /* + * We go through each soundfont. + * Within a soundfont we go through all the zone info structures and + * link them into the correct place in the preset table. Instruments + * in later soundfonts override those in previous ones. + */ + for (sfi = 0; sfi < sflist->fonts_size; sfi++) { + snd_sf_zone_t **prevpp; + snd_sf_zone_t *cur; + snd_sf_zone_t *zp; + + sf = &sflist->fonts[sfi]; + + for (zi = 0; zi < sf->zones_size; zi++) { + + zp = &sf->zones[zi]; + +if (zp == NULL) + return; + /* + * Now get a pointer to the correct place in the preset + * table for this zone. + */ + prevpp = &sflist->presets[zp->instr]; + + /* Now link it in the right place */ + while (*prevpp != NULL) { + cur = *prevpp; + if (cur->bank == zp->bank) { + /* + * We have found the correct bank for this zp + * Place at the very head of the preset bank chain + */ + zp->next_bank = cur->next_bank; + *prevpp = zp; + + /* Add to the instrument chain, dealing with dups */ + add_instr(zp, cur); + break; + } + prevpp = &cur->next_bank; + } + if (*prevpp == NULL) { + /* Nothing for this bank yet */ + zp->next_instr = NULL; + zp->next_bank = NULL; + *prevpp = zp; + } + } + } +} + +/* + * Add to the instrument chain of a bank. This would be straight + * forward, except that we need to deal with different soundfonts + * and also deal with drums specially. + */ +static void +add_instr(snd_sf_zone_t *new, snd_sf_zone_t *old) +{ + /* + * 'old' was previously the head of the instrument chain. In the + * normal case all we want to do is copy it to next_instr of the new + * head of the list new. + * + * We don't do this if old was a different soundfont, except in the + * case of drums where it is a little more complex. + */ + + if (new->v.sf_id == old->v.sf_id) { + new->next_instr = old; /* Keep them */ + } else { + if (SF_IS_DRUM_BANK(new->bank)) { + /* + * In drum banks we allow a mix of soundfonts. I assume + * this is so you can have say one font of cymbals and another + * of woodsticks or whatever. Each note is usually a different + * type of instrument so it makes sense to mix them like this. + * + * We go through the list and throw out any zone that overlaps + * with the one we are trying to add. + */ + /* remove samples with the same note range */ + snd_sf_zone_t *zp; + snd_sf_zone_t *prev; + int low = new->v.low; + int high = new->v.high; + + new->next_instr = old; /* add the chain to begin with */ + + prev = new; + + /* Now throw out all old with same note range */ + for (zp = new->next_instr; zp; zp = zp->next_instr) { + + if (zp->v.low == low && zp->v.high == high && + zp->v.sf_id != new->v.sf_id) + { + /* It has the same note range and is different font + * so throw it away + */ + prev->next_instr = zp->next_instr; + /* prev stays the same */ + } else { + prev = zp; + } + } + } else { + /* Easy case, old was a different soundfont so loose them */ + new->next_instr = NULL; + } + } + +} + +/* + * Initialise the sflist structure. + */ +void +snd_sf_init(snd_sf_list_t *sflist) +{ + int i; + + if (sflist == NULL) { + snd_printk("NULL sflist\n"); + return; + } + + /* Clear presets */ + for (i = 0; i < SF_MAX_PRESETS+1; i++) + sflist->presets[i] = NULL; + + sflist->current_id = 0; + sflist->locked_id = 0; + sflist->currsf = NULL; + snd_list_prepare(sflist, snd_soundfont_t, fonts); +} + +/* + * Free everything allocated off the sflist structure. + */ +void +snd_sf_free(snd_sf_list_t *sflist) +{ + snd_soundfont_t *sf; + + if (sflist == NULL) + return; + + sf = sflist->fonts; + if (sf) { + snd_list_free(sf, zones); + snd_list_free(sf, samples); + } + + /* Now the soundfont list */ + snd_list_free(sflist, fonts); +} diff -ruN --exclude CVS --exclude RCS alsa-driver/lowlevel/sb/soundfont.h new/lowlevel/sb/soundfont.h --- alsa-driver/lowlevel/sb/soundfont.h Thu Jan 1 00:00:00 1970 +++ new/lowlevel/sb/soundfont.h Mon Feb 22 17:16:51 1999 @@ -0,0 +1,91 @@ +#ifndef __SOUNDFONT_H +#define __SOUNDFONT_H +/* + * Soundfont defines and definitions. + * + * Copyright (C) 1999 Steve Ratcliffe + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +/* At present using definition from oss driver to ease transition */ +#include "linux/awe_voice.h" +#include "lists.h" + +#define SF_MAX_PRESETS 128 /* Includes drum bank */ +#define SF_IS_DRUM_BANK(z) ((z) == 128) + +#define SF_SAMPLE_BIDIR_LOOP AWE_SAMPLE_BIDIR_LOOP +#define SF_SAMPLE_REVERSE_LOOP AWE_SAMPLE_REVERSE_LOOP +#define SF_SAMPLE_NO_BLANK AWE_SAMPLE_NO_BLANK +#define SF_SAMPLE_SINGLESHOT AWE_SAMPLE_SINGLESHOT + +typedef struct snd_sf_zone { + struct snd_sf_zone_t *next; /* Link to next */ + unsigned char bank; /* Midi bank for this zone */ + unsigned char instr; /* Midi program for this zone */ + unsigned char mapped; /* True if mapped to something else */ + unsigned char disabled; /* True/false */ + + awe_voice_info v; /* All the soundfont parameters */ + struct snd_sf_sample *sample; /* Link to sample */ + + /* The following deals with preset numbers (programs) */ + struct snd_sf_zone *next_bank; /* Next bank for this preset */ + struct snd_sf_zone *next_instr; /* Next zone of this instrument */ + struct snd_sf_zone *zone_link; /* Next zone in play list */ +} snd_sf_zone_t; + +typedef struct snd_sf_sample { + awe_sample_info v; +} snd_sf_sample_t; +// ALT typedef awe_sample_info snd_sf_sample_t; + +/* + * This represents all the information relating to a soundfont. + */ +typedef struct snd_soundfont { + struct snd_soundfont *next; /* Link to next */ + struct snd_soundfont *prev; /* Link to previous */ + short id; /* file id */ + short type; /* ?? */ + int mem_offset; /* zero based offset into sample memory */ + snd_list_declare(snd_sf_zone_t, zones); /* Font information */ + snd_list_declare(snd_sf_sample_t, samples);/* The sample headers */ +} snd_soundfont_t; + +/* + * List of soundfonts. + */ +typedef struct snd_sf_list { + int current_id; /* Current soundfont id */ + int locked_id; + snd_soundfont_t *currsf; /* The currently open soundfont */ + snd_sf_zone_t *presets[SF_MAX_PRESETS+1]; + snd_list_declare(snd_soundfont_t, fonts); /* The list of soundfonts */ +} snd_sf_list_t; + +/* Type of the sample write callback */ +typedef int (*snd_sf_sample_write_t)(void *, snd_sf_sample_t *sp, + const void *, long); + +/* Prototypes for soundfont.c */ +int snd_soundfont_load(snd_sf_list_t *sflist, const void *data, long count, + snd_sf_sample_write_t sw, void *callarg); +void snd_sf_init(snd_sf_list_t *sflist); +void snd_sf_free(snd_sf_list_t *sflist); + +#endif