[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / sound / wavefront.h

#ifndef __SOUND_WAVEFRONT_H__
#define __SOUND_WAVEFRONT_H__

/*
 *  Driver for Turtle Beach Wavefront cards (Maui,Tropez,Tropez+)
 *
 *  Copyright (c) by Paul Barton-Davis <pbd@op.net>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#if (!defined(__GNUC__) && !defined(__GNUG__))

     You will not be able to compile this file correctly without gcc, because
     it is necessary to pack the "wavefront_alias" structure to a size
     of 22 bytes, corresponding to 16-bit alignment (as would have been
     the case on the original platform, MS-DOS). If this is not done,
     then WavePatch-format files cannot be read/written correctly.
     The method used to do this here ("__attribute__((packed)") is
     completely compiler dependent.
     
     All other wavefront_* types end up aligned to 32 bit values and
     still have the same (correct) size.

#else

     /* However, note that as of G++ 2.7.3.2, g++ was unable to
	correctly parse *type* __attribute__ tags. It will do the
	right thing if we use the "packed" attribute on each struct
	member, which has the same semantics anyway. 
     */

#endif /* __GNUC__ */

/***************************** WARNING ********************************
  PLEASE DO NOT MODIFY THIS FILE IN ANY WAY THAT AFFECTS ITS ABILITY TO 
  BE USED WITH EITHER C *OR* C++.
 **********************************************************************/

#ifndef NUM_MIDIKEYS 
#define NUM_MIDIKEYS 128
#endif  /* NUM_MIDIKEYS */

#ifndef NUM_MIDICHANNELS
#define NUM_MIDICHANNELS 16
#endif  /* NUM_MIDICHANNELS */

/* These are very useful/important. the original wavefront interface
   was developed on a 16 bit system, where sizeof(int) = 2
   bytes. Defining things like this makes the code much more portable, and
   easier to understand without having to toggle back and forth
   between a 16-bit view of the world and a 32-bit one. 
 */   

#ifndef __KERNEL__
/* keep them for compatibility */
typedef short s16;
typedef unsigned short u16;
typedef int s32;
typedef unsigned int u32;
typedef char s8;
typedef unsigned char u8;
typedef s16 INT16;
typedef u16 UINT16;
typedef s32 INT32;
typedef u32 UINT32;
typedef s8 CHAR8;
typedef u8 UCHAR8;
#endif

/* Pseudo-commands not part of the WaveFront command set.
   These are used for various driver controls and direct
   hardware control.
 */

#define WFC_DEBUG_DRIVER                0
#define WFC_FX_IOCTL                    1
#define WFC_PATCH_STATUS                2
#define WFC_PROGRAM_STATUS              3
#define WFC_SAMPLE_STATUS               4
#define WFC_DISABLE_INTERRUPTS          5
#define WFC_ENABLE_INTERRUPTS           6
#define WFC_INTERRUPT_STATUS            7
#define WFC_ROMSAMPLES_RDONLY           8
#define WFC_IDENTIFY_SLOT_TYPE          9

/* Wavefront synth commands
 */

#define WFC_DOWNLOAD_SAMPLE		0x80
#define WFC_DOWNLOAD_BLOCK		0x81
#define WFC_DOWNLOAD_MULTISAMPLE	0x82
#define WFC_DOWNLOAD_SAMPLE_ALIAS	0x83
#define WFC_DELETE_SAMPLE		0x84
#define WFC_REPORT_FREE_MEMORY		0x85
#define WFC_DOWNLOAD_PATCH		0x86
#define WFC_DOWNLOAD_PROGRAM		0x87
#define WFC_SET_SYNTHVOL		0x89
#define WFC_SET_NVOICES			0x8B
#define WFC_DOWNLOAD_DRUM		0x90
#define WFC_GET_SYNTHVOL		0x92
#define WFC_GET_NVOICES			0x94
#define WFC_DISABLE_CHANNEL		0x9A
#define WFC_ENABLE_CHANNEL		0x9B
#define WFC_MISYNTH_OFF			0x9D
#define WFC_MISYNTH_ON			0x9E
#define WFC_FIRMWARE_VERSION		0x9F
#define WFC_GET_NSAMPLES		0xA0
#define WFC_DISABLE_DRUM_PROGRAM	0xA2
#define WFC_UPLOAD_PATCH		0xA3
#define WFC_UPLOAD_PROGRAM		0xA4
#define WFC_SET_TUNING			0xA6
#define WFC_GET_TUNING			0xA7
#define WFC_VMIDI_ON			0xA8
#define WFC_VMIDI_OFF			0xA9
#define WFC_MIDI_STATUS			0xAA
#define WFC_GET_CHANNEL_STATUS		0xAB
#define WFC_DOWNLOAD_SAMPLE_HEADER	0xAC
#define WFC_UPLOAD_SAMPLE_HEADER	0xAD
#define WFC_UPLOAD_MULTISAMPLE		0xAE
#define WFC_UPLOAD_SAMPLE_ALIAS		0xAF
#define WFC_IDENTIFY_SAMPLE_TYPE	0xB0
#define WFC_DOWNLOAD_EDRUM_PROGRAM	0xB1
#define WFC_UPLOAD_EDRUM_PROGRAM	0xB2
#define WFC_SET_EDRUM_CHANNEL		0xB3
#define WFC_INSTOUT_LEVELS		0xB4
#define WFC_PEAKOUT_LEVELS		0xB5
#define WFC_REPORT_CHANNEL_PROGRAMS	0xB6
#define WFC_HARDWARE_VERSION		0xCF
#define WFC_UPLOAD_SAMPLE_PARAMS	0xD7
#define WFC_DOWNLOAD_OS			0xF1
#define WFC_NOOP                        0xFF

#define WF_MAX_SAMPLE   512
#define WF_MAX_PATCH    256
#define WF_MAX_PROGRAM  128

#define WF_SECTION_MAX  44   /* longest OS section length */

/* # of bytes we send to the board when sending it various kinds of
   substantive data, such as samples, patches and programs.
*/

#define WF_PROGRAM_BYTES 32
#define WF_PATCH_BYTES 132
#define WF_SAMPLE_BYTES 27
#define WF_SAMPLE_HDR_BYTES 25
#define WF_ALIAS_BYTES 25
#define WF_DRUM_BYTES 9
#define WF_MSAMPLE_BYTES 259 /* (MIDI_KEYS * 2) + 3 */

#define WF_ACK     0x80
#define WF_DMA_ACK 0x81

/* OR-values for MIDI status bits */

#define WF_MIDI_VIRTUAL_ENABLED 0x1
#define WF_MIDI_VIRTUAL_IS_EXTERNAL 0x2
#define WF_MIDI_IN_TO_SYNTH_DISABLED 0x4

/* slot indexes for struct address_info: makes code a little more mnemonic */

#define WF_SYNTH_SLOT         0
#define WF_INTERNAL_MIDI_SLOT 1
#define WF_EXTERNAL_MIDI_SLOT 2

/* Magic MIDI bytes used to switch I/O streams on the ICS2115 MPU401
   emulation. Note these NEVER show up in output from the device and
   should NEVER be used in input unless Virtual MIDI mode has been 
   disabled. If they do show up as input, the results are unpredictable.
*/

#define WF_EXTERNAL_SWITCH  0xFD
#define WF_INTERNAL_SWITCH  0xF9

/* Debugging flags */

#define WF_DEBUG_CMD 0x1
#define WF_DEBUG_DATA 0x2
#define WF_DEBUG_LOAD_PATCH 0x4
#define WF_DEBUG_IO 0x8

/* WavePatch file format stuff */

#define WF_WAVEPATCH_VERSION     120;  /*  Current version number (1.2)  */
#define WF_MAX_COMMENT           64    /*  Comment length */
#define WF_NUM_LAYERS            4
#define WF_NAME_LENGTH           32
#define WF_SOURCE_LENGTH         260

#define BankFileID     "Bank"
#define DrumkitFileID  "DrumKit"
#define ProgramFileID  "Program"

struct wf_envelope
{
    u8 attack_time:7;
    u8 Unused1:1;

    u8 decay1_time:7;
    u8 Unused2:1;

    u8 decay2_time:7;
    u8 Unused3:1;

    u8 sustain_time:7;
    u8 Unused4:1;

    u8 release_time:7;
    u8 Unused5:1;

    u8 release2_time:7;
    u8 Unused6:1;

    s8 attack_level;
    s8 decay1_level;
    s8 decay2_level;
    s8 sustain_level;
    s8 release_level;

    u8 attack_velocity:7;
    u8 Unused7:1;

    u8 volume_velocity:7;
    u8 Unused8:1;

    u8 keyboard_scaling:7;
    u8 Unused9:1;
};
typedef struct wf_envelope wavefront_envelope;

struct wf_lfo
{
    u8 sample_number;

    u8 frequency:7;
    u8 Unused1:1;

    u8 am_src:4;
    u8 fm_src:4;

    s8 fm_amount;
    s8 am_amount;
    s8 start_level;
    s8 end_level;

    u8 ramp_delay:7;
    u8 wave_restart:1; /* for LFO2 only */

    u8 ramp_time:7;
    u8 Unused2:1;
};
typedef struct wf_lfo wavefront_lfo;

struct wf_patch
{
    s16  frequency_bias;         /*  ** THIS IS IN MOTOROLA FORMAT!! ** */

    u8 amplitude_bias:7;
    u8 Unused1:1;

    u8 portamento:7;
    u8 Unused2:1;

    u8 sample_number;

    u8 pitch_bend:4;
    u8 sample_msb:1;
    u8 Unused3:3;

    u8 mono:1;
    u8 retrigger:1;
    u8 nohold:1;
    u8 restart:1;
    u8 filterconfig:2; /* SDK says "not used" */
    u8 reuse:1;
    u8 reset_lfo:1;    

    u8 fm_src2:4;
    u8 fm_src1:4;   

    s8 fm_amount1;
    s8 fm_amount2;

    u8 am_src:4;
    u8 Unused4:4;

    s8 am_amount;

    u8 fc1_mode:4;
    u8 fc2_mode:4;

    s8 fc1_mod_amount;
    s8 fc1_keyboard_scaling;
    s8 fc1_bias;
    s8 fc2_mod_amount;
    s8 fc2_keyboard_scaling;
    s8 fc2_bias;

    u8 randomizer:7;
    u8 Unused5:1;

    struct wf_envelope envelope1;
    struct wf_envelope envelope2;
    struct wf_lfo lfo1;
    struct wf_lfo lfo2;
};
typedef struct wf_patch wavefront_patch;

struct wf_layer
{
    u8 patch_number;

    u8 mix_level:7;
    u8 mute:1;

    u8 split_point:7;
    u8 play_below:1;

    u8 pan_mod_src:2;
    u8 pan_or_mod:1;
    u8 pan:4;
    u8 split_type:1;
};
typedef struct wf_layer wavefront_layer;

struct wf_program
{
    struct wf_layer layer[WF_NUM_LAYERS];
};
typedef struct wf_program wavefront_program;

struct wf_sample_offset
{
    s32 Fraction:4;
    s32 Integer:20;
    s32 Unused:8;
};
typedef struct wf_sample_offset wavefront_sample_offset;          
     
/* Sample slot types */

#define WF_ST_SAMPLE      0
#define WF_ST_MULTISAMPLE 1
#define WF_ST_ALIAS       2
#define WF_ST_EMPTY       3

/* pseudo's */

#define WF_ST_DRUM        4
#define WF_ST_PROGRAM     5
#define WF_ST_PATCH       6
#define WF_ST_SAMPLEHDR   7

#define WF_ST_MASK        0xf

/* Flags for slot status. These occupy the upper bits of the same byte
   as a sample type.
*/

#define WF_SLOT_USED      0x80   /* XXX don't rely on this being accurate */
#define WF_SLOT_FILLED    0x40
#define WF_SLOT_ROM       0x20

#define WF_SLOT_MASK      0xf0

/* channel constants */

#define WF_CH_MONO  0
#define WF_CH_LEFT  1
#define WF_CH_RIGHT 2

/* Sample formats */

#define LINEAR_16BIT 0
#define WHITE_NOISE  1
#define LINEAR_8BIT  2
#define MULAW_8BIT   3

#define WF_SAMPLE_IS_8BIT(smpl) ((smpl)->SampleResolution&2)


/* 

  Because most/all of the sample data we pass in via pointers has
  never been copied (just mmap-ed into user space straight from the
  disk), it would be nice to allow handling of multi-channel sample
  data without forcing user-level extraction of the relevant bytes.
  
  So, we need a way of specifying which channel to use (the WaveFront
  only handles mono samples in a given slot), and the only way to do
  this without using some struct other than wavefront_sample as the
  interface is the awful hack of using the unused bits in a
  wavefront_sample:
  
  Val      Meaning
  ---      -------
  0        no channel selection (use channel 1, sample is MONO)
  1        use first channel, and skip one
  2        use second channel, and skip one
  3        use third channel, and skip two
  4        use fourth channel, skip three
  5        use fifth channel, skip four
  6        use six channel, skip five


  This can handle up to 4 channels, and anyone downloading >4 channels
  of sample data just to select one of them needs to find some tools
  like sox ...

  NOTE: values 0, 1 and 2 correspond to WF_CH_* above. This is 
  important.

*/

#define WF_SET_CHANNEL(samp,chn) \
 (samp)->Unused1 = chn & 0x1; \
 (samp)->Unused2 = chn & 0x2; \
 (samp)->Unused3 = chn & 0x4 
  
#define WF_GET_CHANNEL(samp) \
  (((samp)->Unused3 << 2)|((samp)->Unused2<<1)|(samp)->Unused1)
  
typedef struct wf_sample {
    struct wf_sample_offset sampleStartOffset;
    struct wf_sample_offset loopStartOffset;
    struct wf_sample_offset loopEndOffset;
    struct wf_sample_offset sampleEndOffset;
    s16 FrequencyBias;
    u8 SampleResolution:2;  /* sample_format */
    u8 Unused1:1;
    u8 Loop:1;
    u8 Bidirectional:1;
    u8 Unused2:1;
    u8 Reverse:1;
    u8 Unused3:1;
} wavefront_sample;

typedef struct wf_multisample {
    s16 NumberOfSamples;   /* log2 of the number of samples */
    s16 SampleNumber[NUM_MIDIKEYS];
} wavefront_multisample;

typedef struct wf_alias {
    s16 OriginalSample;

    struct wf_sample_offset sampleStartOffset;
    struct wf_sample_offset loopStartOffset;
    struct wf_sample_offset sampleEndOffset;
    struct wf_sample_offset loopEndOffset;

    s16  FrequencyBias;

    u8 SampleResolution:2;
    u8 Unused1:1;
    u8 Loop:1;
    u8 Bidirectional:1;
    u8 Unused2:1;
    u8 Reverse:1;
    u8 Unused3:1;
    
    /* This structure is meant to be padded only to 16 bits on their
       original. Of course, whoever wrote their documentation didn't
       realize that sizeof(struct) can be >=
       sum(sizeof(struct-fields)) and so thought that giving a C level
       description of the structs used in WavePatch files was
       sufficient. I suppose it was, as long as you remember the 
       standard 16->32 bit issues.
    */

    u8 sixteen_bit_padding;
} __attribute__((packed)) wavefront_alias;

typedef struct wf_drum {
    u8 PatchNumber;
    u8 MixLevel:7;
    u8 Unmute:1;
    u8 Group:4;
    u8 Unused1:4;
    u8 PanModSource:2;
    u8 PanModulated:1;
    u8 PanAmount:4;
    u8 Unused2:1;
} wavefront_drum;

typedef struct wf_drumkit {
    struct wf_drum drum[NUM_MIDIKEYS];
} wavefront_drumkit;

typedef struct wf_channel_programs {
    u8 Program[NUM_MIDICHANNELS];
} wavefront_channel_programs;

/* How to get MIDI channel status from the data returned by
   a WFC_GET_CHANNEL_STATUS command (a struct wf_channel_programs)
*/

#define WF_CHANNEL_STATUS(ch,wcp) (wcp)[(ch/7)] & (1<<((ch)%7))

typedef union wf_any {
    wavefront_sample s;
    wavefront_multisample ms;
    wavefront_alias a;
    wavefront_program pr;
    wavefront_patch p;
    wavefront_drum d;
} wavefront_any;

/* Hannu Solvainen hoped that his "patch_info" struct in soundcard.h
   might work for other wave-table based patch loading situations.
   Alas, his fears were correct. The WaveFront doesn't even come with
   just "patches", but several different kind of structures that
   control the sound generation process.
 */

typedef struct wf_patch_info {
    
    /* the first two fields are used by the OSS "patch loading" interface
       only, and are unused by the current user-level library.
    */

    s16   key;               /* Use WAVEFRONT_PATCH here */
    u16  devno;             /* fill in when sending */
    u8  subkey;            /* WF_ST_{SAMPLE,ALIAS,etc.} */

#define WAVEFRONT_FIND_FREE_SAMPLE_SLOT 999

    u16  number;            /* patch/sample/prog number */

    u32  size;              /* size of any data included in 
				  one of the fields in `hdrptr', or
				  as `dataptr'.

				  NOTE: for actual samples, this is
				  the size of the *SELECTED CHANNEL*
				  even if more data is actually available.
				  
				  So, a stereo sample (2 channels) of
				  6000 bytes total has `size' = 3000.

				  See the macros and comments for
				  WF_{GET,SET}_CHANNEL above.

			       */
    wavefront_any __user *hdrptr;      /* user-space ptr to hdr bytes */
    u16 __user *dataptr;            /* actual sample data */

    wavefront_any hdr;          /* kernel-space copy of hdr bytes */         
} wavefront_patch_info;

/* The maximum number of bytes we will ever move to or from user space
   in response to a WFC_* command.  This obviously doesn't cover
   actual sample data.
*/

#define WF_MAX_READ sizeof(wavefront_multisample)
#define WF_MAX_WRITE sizeof(wavefront_multisample)

/*
   This allows us to execute any WF command except the download/upload
   ones, which are handled differently due to copyin/copyout issues as
   well as data-nybbling to/from the card.
 */

typedef struct wavefront_control {
    int cmd;                           /* WFC_* */
    char status;                       /* return status to user-space */
    unsigned char rbuf[WF_MAX_READ];   /* bytes read from card */
    unsigned char wbuf[WF_MAX_WRITE];  /* bytes written to card */
} wavefront_control;

#define WFCTL_WFCMD    0x1
#define WFCTL_LOAD_SPP 0x2

/* Modulator table */

#define WF_MOD_LFO1      0
#define WF_MOD_LFO2      1
#define WF_MOD_ENV1      2
#define WF_MOD_ENV2      3
#define WF_MOD_KEYBOARD  4
#define WF_MOD_LOGKEY    5
#define WF_MOD_VELOCITY  6
#define WF_MOD_LOGVEL    7
#define WF_MOD_RANDOM    8
#define WF_MOD_PRESSURE  9
#define WF_MOD_MOD_WHEEL 10
#define WF_MOD_1         WF_MOD_MOD_WHEEL 
#define WF_MOD_BREATH    11
#define WF_MOD_2         WF_MOD_BREATH
#define WF_MOD_FOOT      12
#define WF_MOD_4         WF_MOD_FOOT
#define WF_MOD_VOLUME    13
#define WF_MOD_7         WF_MOD_VOLUME
#define WF_MOD_PAN       14
#define WF_MOD_10        WF_MOD_PAN
#define WF_MOD_EXPR      15
#define WF_MOD_11        WF_MOD_EXPR

/* FX-related material */

typedef struct wf_fx_info {
    int request;             /* see list below */
    long data[4];             /* we don't need much */
} wavefront_fx_info;

/* support for each of these will be forthcoming once I or someone 
   else has figured out which of the addresses on page 6 and page 7 of 
   the YSS225 control each parameter. Incidentally, these come from
   the Windows driver interface, but again, Turtle Beach didn't
   document the API to use them.
*/

#define WFFX_SETOUTGAIN		        0
#define WFFX_SETSTEREOOUTGAIN		1
#define WFFX_SETREVERBIN1GAIN		2
#define WFFX_SETREVERBIN2GAIN		3
#define WFFX_SETREVERBIN3GAIN		4
#define WFFX_SETCHORUSINPORT		5
#define WFFX_SETREVERBIN1PORT		6
#define WFFX_SETREVERBIN2PORT		7
#define WFFX_SETREVERBIN3PORT		8
#define WFFX_SETEFFECTPORT		9
#define WFFX_SETAUXPORT		        10
#define WFFX_SETREVERBTYPE		11
#define WFFX_SETREVERBDELAY		12
#define WFFX_SETCHORUSLFO		13
#define WFFX_SETCHORUSPMD		14
#define WFFX_SETCHORUSAMD		15
#define WFFX_SETEFFECT		        16
#define WFFX_SETBASEALL		        17
#define WFFX_SETREVERBALL		18
#define WFFX_SETCHORUSALL		20
#define WFFX_SETREVERBDEF		22
#define WFFX_SETCHORUSDEF		23
#define WFFX_DELAYSETINGAIN		24
#define WFFX_DELAYSETFBGAIN	        25
#define WFFX_DELAYSETFBLPF		26
#define WFFX_DELAYSETGAIN		27
#define WFFX_DELAYSETTIME		28
#define WFFX_DELAYSETFBTIME		29
#define WFFX_DELAYSETALL		30
#define WFFX_DELAYSETDEF		32
#define WFFX_SDELAYSETINGAIN		33
#define WFFX_SDELAYSETFBGAIN		34
#define WFFX_SDELAYSETFBLPF		35
#define WFFX_SDELAYSETGAIN		36
#define WFFX_SDELAYSETTIME		37
#define WFFX_SDELAYSETFBTIME		38
#define WFFX_SDELAYSETALL		39
#define WFFX_SDELAYSETDEF		41
#define WFFX_DEQSETINGAIN		42
#define WFFX_DEQSETFILTER		43
#define WFFX_DEQSETALL		        44
#define WFFX_DEQSETDEF		        46
#define WFFX_MUTE		        47
#define WFFX_FLANGESETBALANCE	        48	
#define WFFX_FLANGESETDELAY		49
#define WFFX_FLANGESETDWFFX_TH		50
#define WFFX_FLANGESETFBGAIN		51
#define WFFX_FLANGESETINGAIN		52
#define WFFX_FLANGESETLFO		53
#define WFFX_FLANGESETALL		54
#define WFFX_FLANGESETDEF		56
#define WFFX_PITCHSETSHIFT		57
#define WFFX_PITCHSETBALANCE		58
#define WFFX_PITCHSETALL		59
#define WFFX_PITCHSETDEF		61
#define WFFX_SRSSETINGAIN		62
#define WFFX_SRSSETSPACE		63
#define WFFX_SRSSETCENTER		64
#define WFFX_SRSSETGAIN		        65
#define WFFX_SRSSETMODE	        	66
#define WFFX_SRSSETDEF		        68

/* Allow direct user-space control over FX memory/coefficient data.
   In theory this could be used to download the FX microprogram,
   but it would be a little slower, and involve some weird code.
 */

#define WFFX_MEMSET              69

#endif /* __SOUND_WAVEFRONT_H__ */
Commit	Line	Data
	1	#ifndef __SOUND_WAVEFRONT_H__
	2	#define __SOUND_WAVEFRONT_H__
	3
	4	/*
	5	* Driver for Turtle Beach Wavefront cards (Maui,Tropez,Tropez+)
	6	*
	7	* Copyright (c) by Paul Barton-Davis <pbd@op.net>
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	22	*/
	23
	24	#if (!defined(__GNUC__) && !defined(__GNUG__))
	25
	26	You will not be able to compile this file correctly without gcc, because
	27	it is necessary to pack the "wavefront_alias" structure to a size
	28	of 22 bytes, corresponding to 16-bit alignment (as would have been
	29	the case on the original platform, MS-DOS). If this is not done,
	30	then WavePatch-format files cannot be read/written correctly.
	31	The method used to do this here ("__attribute__((packed)") is
	32	completely compiler dependent.
	33
	34	All other wavefront_* types end up aligned to 32 bit values and
	35	still have the same (correct) size.
	36
	37	#else
	38
	39	/* However, note that as of G++ 2.7.3.2, g++ was unable to
	40	correctly parse type __attribute__ tags. It will do the
	41	right thing if we use the "packed" attribute on each struct
	42	member, which has the same semantics anyway.
	43	*/
	44
	45	#endif /* __GNUC__ */
	46
	47	/*************************** WARNING ******************************
	48	PLEASE DO NOT MODIFY THIS FILE IN ANY WAY THAT AFFECTS ITS ABILITY TO
	49	BE USED WITH EITHER C OR C++.
	50	**********************************************************************/
	51
	52	#ifndef NUM_MIDIKEYS
	53	#define NUM_MIDIKEYS 128
	54	#endif /* NUM_MIDIKEYS */
	55
	56	#ifndef NUM_MIDICHANNELS
	57	#define NUM_MIDICHANNELS 16
	58	#endif /* NUM_MIDICHANNELS */
	59
	60	/* These are very useful/important. the original wavefront interface
	61	was developed on a 16 bit system, where sizeof(int) = 2
	62	bytes. Defining things like this makes the code much more portable, and
	63	easier to understand without having to toggle back and forth
	64	between a 16-bit view of the world and a 32-bit one.
	65	*/
	66
	67	#ifndef __KERNEL__
	68	/* keep them for compatibility */
	69	typedef short s16;
	70	typedef unsigned short u16;
	71	typedef int s32;
	72	typedef unsigned int u32;
	73	typedef char s8;
	74	typedef unsigned char u8;
	75	typedef s16 INT16;
	76	typedef u16 UINT16;
	77	typedef s32 INT32;
	78	typedef u32 UINT32;
	79	typedef s8 CHAR8;
	80	typedef u8 UCHAR8;
	81	#endif
	82
	83	/* Pseudo-commands not part of the WaveFront command set.
	84	These are used for various driver controls and direct
	85	hardware control.
	86	*/
	87
	88	#define WFC_DEBUG_DRIVER 0
	89	#define WFC_FX_IOCTL 1
	90	#define WFC_PATCH_STATUS 2
	91	#define WFC_PROGRAM_STATUS 3
	92	#define WFC_SAMPLE_STATUS 4
	93	#define WFC_DISABLE_INTERRUPTS 5
	94	#define WFC_ENABLE_INTERRUPTS 6
	95	#define WFC_INTERRUPT_STATUS 7
	96	#define WFC_ROMSAMPLES_RDONLY 8
	97	#define WFC_IDENTIFY_SLOT_TYPE 9
	98
	99	/* Wavefront synth commands
	100	*/
	101
	102	#define WFC_DOWNLOAD_SAMPLE 0x80
	103	#define WFC_DOWNLOAD_BLOCK 0x81
	104	#define WFC_DOWNLOAD_MULTISAMPLE 0x82
	105	#define WFC_DOWNLOAD_SAMPLE_ALIAS 0x83
	106	#define WFC_DELETE_SAMPLE 0x84
	107	#define WFC_REPORT_FREE_MEMORY 0x85
	108	#define WFC_DOWNLOAD_PATCH 0x86
	109	#define WFC_DOWNLOAD_PROGRAM 0x87
	110	#define WFC_SET_SYNTHVOL 0x89
	111	#define WFC_SET_NVOICES 0x8B
	112	#define WFC_DOWNLOAD_DRUM 0x90
	113	#define WFC_GET_SYNTHVOL 0x92
	114	#define WFC_GET_NVOICES 0x94
	115	#define WFC_DISABLE_CHANNEL 0x9A
	116	#define WFC_ENABLE_CHANNEL 0x9B
	117	#define WFC_MISYNTH_OFF 0x9D
	118	#define WFC_MISYNTH_ON 0x9E
	119	#define WFC_FIRMWARE_VERSION 0x9F
	120	#define WFC_GET_NSAMPLES 0xA0
	121	#define WFC_DISABLE_DRUM_PROGRAM 0xA2
	122	#define WFC_UPLOAD_PATCH 0xA3
	123	#define WFC_UPLOAD_PROGRAM 0xA4
	124	#define WFC_SET_TUNING 0xA6
	125	#define WFC_GET_TUNING 0xA7
	126	#define WFC_VMIDI_ON 0xA8
	127	#define WFC_VMIDI_OFF 0xA9
	128	#define WFC_MIDI_STATUS 0xAA
	129	#define WFC_GET_CHANNEL_STATUS 0xAB
	130	#define WFC_DOWNLOAD_SAMPLE_HEADER 0xAC
	131	#define WFC_UPLOAD_SAMPLE_HEADER 0xAD
	132	#define WFC_UPLOAD_MULTISAMPLE 0xAE
	133	#define WFC_UPLOAD_SAMPLE_ALIAS 0xAF
	134	#define WFC_IDENTIFY_SAMPLE_TYPE 0xB0
	135	#define WFC_DOWNLOAD_EDRUM_PROGRAM 0xB1
	136	#define WFC_UPLOAD_EDRUM_PROGRAM 0xB2
	137	#define WFC_SET_EDRUM_CHANNEL 0xB3
	138	#define WFC_INSTOUT_LEVELS 0xB4
	139	#define WFC_PEAKOUT_LEVELS 0xB5
	140	#define WFC_REPORT_CHANNEL_PROGRAMS 0xB6
	141	#define WFC_HARDWARE_VERSION 0xCF
	142	#define WFC_UPLOAD_SAMPLE_PARAMS 0xD7
	143	#define WFC_DOWNLOAD_OS 0xF1
	144	#define WFC_NOOP 0xFF
	145
	146	#define WF_MAX_SAMPLE 512
	147	#define WF_MAX_PATCH 256
	148	#define WF_MAX_PROGRAM 128
	149
	150	#define WF_SECTION_MAX 44 /* longest OS section length */
	151
	152	/* # of bytes we send to the board when sending it various kinds of
	153	substantive data, such as samples, patches and programs.
	154	*/
	155
	156	#define WF_PROGRAM_BYTES 32
	157	#define WF_PATCH_BYTES 132
	158	#define WF_SAMPLE_BYTES 27
	159	#define WF_SAMPLE_HDR_BYTES 25
	160	#define WF_ALIAS_BYTES 25
	161	#define WF_DRUM_BYTES 9
	162	#define WF_MSAMPLE_BYTES 259 /* (MIDI_KEYS * 2) + 3 */
	163
	164	#define WF_ACK 0x80
	165	#define WF_DMA_ACK 0x81
	166
	167	/* OR-values for MIDI status bits */
	168
	169	#define WF_MIDI_VIRTUAL_ENABLED 0x1
	170	#define WF_MIDI_VIRTUAL_IS_EXTERNAL 0x2
	171	#define WF_MIDI_IN_TO_SYNTH_DISABLED 0x4
	172
	173	/* slot indexes for struct address_info: makes code a little more mnemonic */
	174
	175	#define WF_SYNTH_SLOT 0
	176	#define WF_INTERNAL_MIDI_SLOT 1
	177	#define WF_EXTERNAL_MIDI_SLOT 2
	178
	179	/* Magic MIDI bytes used to switch I/O streams on the ICS2115 MPU401
	180	emulation. Note these NEVER show up in output from the device and
	181	should NEVER be used in input unless Virtual MIDI mode has been
	182	disabled. If they do show up as input, the results are unpredictable.
	183	*/
	184
	185	#define WF_EXTERNAL_SWITCH 0xFD
	186	#define WF_INTERNAL_SWITCH 0xF9
	187
	188	/* Debugging flags */
	189
	190	#define WF_DEBUG_CMD 0x1
	191	#define WF_DEBUG_DATA 0x2
	192	#define WF_DEBUG_LOAD_PATCH 0x4
	193	#define WF_DEBUG_IO 0x8
	194
	195	/* WavePatch file format stuff */
	196
	197	#define WF_WAVEPATCH_VERSION 120; /* Current version number (1.2) */
	198	#define WF_MAX_COMMENT 64 /* Comment length */
	199	#define WF_NUM_LAYERS 4
	200	#define WF_NAME_LENGTH 32
	201	#define WF_SOURCE_LENGTH 260
	202
	203	#define BankFileID "Bank"
	204	#define DrumkitFileID "DrumKit"
	205	#define ProgramFileID "Program"
	206
	207	struct wf_envelope
	208	{
	209	u8 attack_time:7;
	210	u8 Unused1:1;
	211
	212	u8 decay1_time:7;
	213	u8 Unused2:1;
	214
	215	u8 decay2_time:7;
	216	u8 Unused3:1;
	217
	218	u8 sustain_time:7;
	219	u8 Unused4:1;
	220
	221	u8 release_time:7;
	222	u8 Unused5:1;
	223
	224	u8 release2_time:7;
	225	u8 Unused6:1;
	226
	227	s8 attack_level;
	228	s8 decay1_level;
	229	s8 decay2_level;
	230	s8 sustain_level;
	231	s8 release_level;
	232
	233	u8 attack_velocity:7;
	234	u8 Unused7:1;
	235
	236	u8 volume_velocity:7;
	237	u8 Unused8:1;
	238
	239	u8 keyboard_scaling:7;
	240	u8 Unused9:1;
	241	};
	242	typedef struct wf_envelope wavefront_envelope;
	243
	244	struct wf_lfo
	245	{
	246	u8 sample_number;
	247
	248	u8 frequency:7;
	249	u8 Unused1:1;
	250
	251	u8 am_src:4;
	252	u8 fm_src:4;
	253
	254	s8 fm_amount;
	255	s8 am_amount;
	256	s8 start_level;
	257	s8 end_level;
	258
	259	u8 ramp_delay:7;
	260	u8 wave_restart:1; /* for LFO2 only */
	261
	262	u8 ramp_time:7;
	263	u8 Unused2:1;
	264	};
	265	typedef struct wf_lfo wavefront_lfo;
	266
	267	struct wf_patch
	268	{
	269	s16 frequency_bias; /* THIS IS IN MOTOROLA FORMAT!! */
	270
	271	u8 amplitude_bias:7;
	272	u8 Unused1:1;
	273
	274	u8 portamento:7;
	275	u8 Unused2:1;
	276
	277	u8 sample_number;
	278
	279	u8 pitch_bend:4;
	280	u8 sample_msb:1;
	281	u8 Unused3:3;
	282
	283	u8 mono:1;
	284	u8 retrigger:1;
	285	u8 nohold:1;
	286	u8 restart:1;
	287	u8 filterconfig:2; /* SDK says "not used" */
	288	u8 reuse:1;
	289	u8 reset_lfo:1;
	290
	291	u8 fm_src2:4;
	292	u8 fm_src1:4;
	293
	294	s8 fm_amount1;
	295	s8 fm_amount2;
	296
	297	u8 am_src:4;
	298	u8 Unused4:4;
	299
	300	s8 am_amount;
	301
	302	u8 fc1_mode:4;
	303	u8 fc2_mode:4;
	304
	305	s8 fc1_mod_amount;
	306	s8 fc1_keyboard_scaling;
	307	s8 fc1_bias;
	308	s8 fc2_mod_amount;
	309	s8 fc2_keyboard_scaling;
	310	s8 fc2_bias;
	311
	312	u8 randomizer:7;
	313	u8 Unused5:1;
	314
	315	struct wf_envelope envelope1;
	316	struct wf_envelope envelope2;
	317	struct wf_lfo lfo1;
	318	struct wf_lfo lfo2;
	319	};
	320	typedef struct wf_patch wavefront_patch;
	321
	322	struct wf_layer
	323	{
	324	u8 patch_number;
	325
	326	u8 mix_level:7;
	327	u8 mute:1;
	328
	329	u8 split_point:7;
	330	u8 play_below:1;
	331
	332	u8 pan_mod_src:2;
	333	u8 pan_or_mod:1;
	334	u8 pan:4;
	335	u8 split_type:1;
	336	};
	337	typedef struct wf_layer wavefront_layer;
	338
	339	struct wf_program
	340	{
	341	struct wf_layer layer[WF_NUM_LAYERS];
	342	};
	343	typedef struct wf_program wavefront_program;
	344
	345	struct wf_sample_offset
	346	{
	347	s32 Fraction:4;
	348	s32 Integer:20;
	349	s32 Unused:8;
	350	};
	351	typedef struct wf_sample_offset wavefront_sample_offset;
	352
	353	/* Sample slot types */
	354
	355	#define WF_ST_SAMPLE 0
	356	#define WF_ST_MULTISAMPLE 1
	357	#define WF_ST_ALIAS 2
	358	#define WF_ST_EMPTY 3
	359
	360	/* pseudo's */
	361
	362	#define WF_ST_DRUM 4
	363	#define WF_ST_PROGRAM 5
	364	#define WF_ST_PATCH 6
	365	#define WF_ST_SAMPLEHDR 7
	366
	367	#define WF_ST_MASK 0xf
	368
	369	/* Flags for slot status. These occupy the upper bits of the same byte
	370	as a sample type.
	371	*/
	372
	373	#define WF_SLOT_USED 0x80 /* XXX don't rely on this being accurate */
	374	#define WF_SLOT_FILLED 0x40
	375	#define WF_SLOT_ROM 0x20
	376
	377	#define WF_SLOT_MASK 0xf0
	378
	379	/* channel constants */
	380
	381	#define WF_CH_MONO 0
	382	#define WF_CH_LEFT 1
	383	#define WF_CH_RIGHT 2
	384
	385	/* Sample formats */
	386
	387	#define LINEAR_16BIT 0
	388	#define WHITE_NOISE 1
	389	#define LINEAR_8BIT 2
	390	#define MULAW_8BIT 3
	391
	392	#define WF_SAMPLE_IS_8BIT(smpl) ((smpl)->SampleResolution&2)
	393
	394
	395	/*
	396
	397	Because most/all of the sample data we pass in via pointers has
	398	never been copied (just mmap-ed into user space straight from the
	399	disk), it would be nice to allow handling of multi-channel sample
	400	data without forcing user-level extraction of the relevant bytes.
	401
	402	So, we need a way of specifying which channel to use (the WaveFront
	403	only handles mono samples in a given slot), and the only way to do
	404	this without using some struct other than wavefront_sample as the
	405	interface is the awful hack of using the unused bits in a
	406	wavefront_sample:
	407
	408	Val Meaning
	409	--- -------
	410	0 no channel selection (use channel 1, sample is MONO)
	411	1 use first channel, and skip one
	412	2 use second channel, and skip one
	413	3 use third channel, and skip two
	414	4 use fourth channel, skip three
	415	5 use fifth channel, skip four
	416	6 use six channel, skip five
	417
	418
	419	This can handle up to 4 channels, and anyone downloading >4 channels
	420	of sample data just to select one of them needs to find some tools
	421	like sox ...
	422
	423	NOTE: values 0, 1 and 2 correspond to WF_CH_* above. This is
	424	important.
	425
	426	*/
	427
	428	#define WF_SET_CHANNEL(samp,chn) \
	429	(samp)->Unused1 = chn & 0x1; \
	430	(samp)->Unused2 = chn & 0x2; \
	431	(samp)->Unused3 = chn & 0x4
	432
	433	#define WF_GET_CHANNEL(samp) \
	434	(((samp)->Unused3 << 2)\|((samp)->Unused2<<1)\|(samp)->Unused1)
	435
	436	typedef struct wf_sample {
	437	struct wf_sample_offset sampleStartOffset;
	438	struct wf_sample_offset loopStartOffset;
	439	struct wf_sample_offset loopEndOffset;
	440	struct wf_sample_offset sampleEndOffset;
	441	s16 FrequencyBias;
	442	u8 SampleResolution:2; /* sample_format */
	443	u8 Unused1:1;
	444	u8 Loop:1;
	445	u8 Bidirectional:1;
	446	u8 Unused2:1;
	447	u8 Reverse:1;
	448	u8 Unused3:1;
	449	} wavefront_sample;
	450
	451	typedef struct wf_multisample {
	452	s16 NumberOfSamples; /* log2 of the number of samples */
	453	s16 SampleNumber[NUM_MIDIKEYS];
	454	} wavefront_multisample;
	455
	456	typedef struct wf_alias {
	457	s16 OriginalSample;
	458
	459	struct wf_sample_offset sampleStartOffset;
	460	struct wf_sample_offset loopStartOffset;
	461	struct wf_sample_offset sampleEndOffset;
	462	struct wf_sample_offset loopEndOffset;
	463
	464	s16 FrequencyBias;
	465
	466	u8 SampleResolution:2;
	467	u8 Unused1:1;
	468	u8 Loop:1;
	469	u8 Bidirectional:1;
	470	u8 Unused2:1;
	471	u8 Reverse:1;
	472	u8 Unused3:1;
	473
	474	/* This structure is meant to be padded only to 16 bits on their
	475	original. Of course, whoever wrote their documentation didn't
	476	realize that sizeof(struct) can be >=
	477	sum(sizeof(struct-fields)) and so thought that giving a C level
	478	description of the structs used in WavePatch files was
	479	sufficient. I suppose it was, as long as you remember the
	480	standard 16->32 bit issues.
	481	*/
	482
	483	u8 sixteen_bit_padding;
	484	} __attribute__((packed)) wavefront_alias;
	485
	486	typedef struct wf_drum {
	487	u8 PatchNumber;
	488	u8 MixLevel:7;
	489	u8 Unmute:1;
	490	u8 Group:4;
	491	u8 Unused1:4;
	492	u8 PanModSource:2;
	493	u8 PanModulated:1;
	494	u8 PanAmount:4;
	495	u8 Unused2:1;
	496	} wavefront_drum;
	497
	498	typedef struct wf_drumkit {
	499	struct wf_drum drum[NUM_MIDIKEYS];
	500	} wavefront_drumkit;
	501
	502	typedef struct wf_channel_programs {
	503	u8 Program[NUM_MIDICHANNELS];
	504	} wavefront_channel_programs;
	505
	506	/* How to get MIDI channel status from the data returned by
	507	a WFC_GET_CHANNEL_STATUS command (a struct wf_channel_programs)
	508	*/
	509
	510	#define WF_CHANNEL_STATUS(ch,wcp) (wcp)[(ch/7)] & (1<<((ch)%7))
	511
	512	typedef union wf_any {
	513	wavefront_sample s;
	514	wavefront_multisample ms;
	515	wavefront_alias a;
	516	wavefront_program pr;
	517	wavefront_patch p;
	518	wavefront_drum d;
	519	} wavefront_any;
	520
	521	/* Hannu Solvainen hoped that his "patch_info" struct in soundcard.h
	522	might work for other wave-table based patch loading situations.
	523	Alas, his fears were correct. The WaveFront doesn't even come with
	524	just "patches", but several different kind of structures that
	525	control the sound generation process.
	526	*/
	527
	528	typedef struct wf_patch_info {
	529
	530	/* the first two fields are used by the OSS "patch loading" interface
	531	only, and are unused by the current user-level library.
	532	*/
	533
	534	s16 key; /* Use WAVEFRONT_PATCH here */
	535	u16 devno; /* fill in when sending */
	536	u8 subkey; /* WF_ST_{SAMPLE,ALIAS,etc.} */
	537
	538	#define WAVEFRONT_FIND_FREE_SAMPLE_SLOT 999
	539
	540	u16 number; /* patch/sample/prog number */
	541
	542	u32 size; /* size of any data included in
	543	one of the fields in `hdrptr', or
	544	as `dataptr'.
	545
	546	NOTE: for actual samples, this is
	547	the size of the SELECTED CHANNEL
	548	even if more data is actually available.
	549
	550	So, a stereo sample (2 channels) of
	551	6000 bytes total has `size' = 3000.
	552
	553	See the macros and comments for
	554	WF_{GET,SET}_CHANNEL above.
	555
	556	*/
	557	wavefront_any __user hdrptr; / user-space ptr to hdr bytes */
	558	u16 __user dataptr; / actual sample data */
	559
	560	wavefront_any hdr; /* kernel-space copy of hdr bytes */
	561	} wavefront_patch_info;
	562
	563	/* The maximum number of bytes we will ever move to or from user space
	564	in response to a WFC_* command. This obviously doesn't cover
	565	actual sample data.
	566	*/
	567
	568	#define WF_MAX_READ sizeof(wavefront_multisample)
	569	#define WF_MAX_WRITE sizeof(wavefront_multisample)
	570
	571	/*
	572	This allows us to execute any WF command except the download/upload
	573	ones, which are handled differently due to copyin/copyout issues as
	574	well as data-nybbling to/from the card.
	575	*/
	576
	577	typedef struct wavefront_control {
	578	int cmd; /* WFC_* */
	579	char status; /* return status to user-space */
	580	unsigned char rbuf[WF_MAX_READ]; /* bytes read from card */
	581	unsigned char wbuf[WF_MAX_WRITE]; /* bytes written to card */
	582	} wavefront_control;
	583
	584	#define WFCTL_WFCMD 0x1
	585	#define WFCTL_LOAD_SPP 0x2
	586
	587	/* Modulator table */
	588
	589	#define WF_MOD_LFO1 0
	590	#define WF_MOD_LFO2 1
	591	#define WF_MOD_ENV1 2
	592	#define WF_MOD_ENV2 3
	593	#define WF_MOD_KEYBOARD 4
	594	#define WF_MOD_LOGKEY 5
	595	#define WF_MOD_VELOCITY 6
	596	#define WF_MOD_LOGVEL 7
	597	#define WF_MOD_RANDOM 8
	598	#define WF_MOD_PRESSURE 9
	599	#define WF_MOD_MOD_WHEEL 10
	600	#define WF_MOD_1 WF_MOD_MOD_WHEEL
	601	#define WF_MOD_BREATH 11
	602	#define WF_MOD_2 WF_MOD_BREATH
	603	#define WF_MOD_FOOT 12
	604	#define WF_MOD_4 WF_MOD_FOOT
	605	#define WF_MOD_VOLUME 13
	606	#define WF_MOD_7 WF_MOD_VOLUME
	607	#define WF_MOD_PAN 14
	608	#define WF_MOD_10 WF_MOD_PAN
	609	#define WF_MOD_EXPR 15
	610	#define WF_MOD_11 WF_MOD_EXPR
	611
	612	/* FX-related material */
	613
	614	typedef struct wf_fx_info {
	615	int request; /* see list below */
	616	long data[4]; /* we don't need much */
	617	} wavefront_fx_info;
	618
	619	/* support for each of these will be forthcoming once I or someone
	620	else has figured out which of the addresses on page 6 and page 7 of
	621	the YSS225 control each parameter. Incidentally, these come from
	622	the Windows driver interface, but again, Turtle Beach didn't
	623	document the API to use them.
	624	*/
	625
	626	#define WFFX_SETOUTGAIN 0
	627	#define WFFX_SETSTEREOOUTGAIN 1
	628	#define WFFX_SETREVERBIN1GAIN 2
	629	#define WFFX_SETREVERBIN2GAIN 3
	630	#define WFFX_SETREVERBIN3GAIN 4
	631	#define WFFX_SETCHORUSINPORT 5
	632	#define WFFX_SETREVERBIN1PORT 6
	633	#define WFFX_SETREVERBIN2PORT 7
	634	#define WFFX_SETREVERBIN3PORT 8
	635	#define WFFX_SETEFFECTPORT 9
	636	#define WFFX_SETAUXPORT 10
	637	#define WFFX_SETREVERBTYPE 11
	638	#define WFFX_SETREVERBDELAY 12
	639	#define WFFX_SETCHORUSLFO 13
	640	#define WFFX_SETCHORUSPMD 14
	641	#define WFFX_SETCHORUSAMD 15
	642	#define WFFX_SETEFFECT 16
	643	#define WFFX_SETBASEALL 17
	644	#define WFFX_SETREVERBALL 18
	645	#define WFFX_SETCHORUSALL 20
	646	#define WFFX_SETREVERBDEF 22
	647	#define WFFX_SETCHORUSDEF 23
	648	#define WFFX_DELAYSETINGAIN 24
	649	#define WFFX_DELAYSETFBGAIN 25
	650	#define WFFX_DELAYSETFBLPF 26
	651	#define WFFX_DELAYSETGAIN 27
	652	#define WFFX_DELAYSETTIME 28
	653	#define WFFX_DELAYSETFBTIME 29
	654	#define WFFX_DELAYSETALL 30
	655	#define WFFX_DELAYSETDEF 32
	656	#define WFFX_SDELAYSETINGAIN 33
	657	#define WFFX_SDELAYSETFBGAIN 34
	658	#define WFFX_SDELAYSETFBLPF 35
	659	#define WFFX_SDELAYSETGAIN 36
	660	#define WFFX_SDELAYSETTIME 37
	661	#define WFFX_SDELAYSETFBTIME 38
	662	#define WFFX_SDELAYSETALL 39
	663	#define WFFX_SDELAYSETDEF 41
	664	#define WFFX_DEQSETINGAIN 42
	665	#define WFFX_DEQSETFILTER 43
	666	#define WFFX_DEQSETALL 44
	667	#define WFFX_DEQSETDEF 46
	668	#define WFFX_MUTE 47
	669	#define WFFX_FLANGESETBALANCE 48
	670	#define WFFX_FLANGESETDELAY 49
	671	#define WFFX_FLANGESETDWFFX_TH 50
	672	#define WFFX_FLANGESETFBGAIN 51
	673	#define WFFX_FLANGESETINGAIN 52
	674	#define WFFX_FLANGESETLFO 53
	675	#define WFFX_FLANGESETALL 54
	676	#define WFFX_FLANGESETDEF 56
	677	#define WFFX_PITCHSETSHIFT 57
	678	#define WFFX_PITCHSETBALANCE 58
	679	#define WFFX_PITCHSETALL 59
	680	#define WFFX_PITCHSETDEF 61
	681	#define WFFX_SRSSETINGAIN 62
	682	#define WFFX_SRSSETSPACE 63
	683	#define WFFX_SRSSETCENTER 64
	684	#define WFFX_SRSSETGAIN 65
	685	#define WFFX_SRSSETMODE 66
	686	#define WFFX_SRSSETDEF 68
	687
	688	/* Allow direct user-space control over FX memory/coefficient data.
	689	In theory this could be used to download the FX microprogram,
	690	but it would be a little slower, and involve some weird code.
	691	*/
	692
	693	#define WFFX_MEMSET 69
	694
	695	#endif /* __SOUND_WAVEFRONT_H__ */