5 * A Linux driver for Turtle Beach WaveFront Series (Maui, Tropez, Tropez Plus)
7 * This driver supports the onboard wavetable synthesizer (an ICS2115),
8 * including patch, sample and program loading and unloading, conversion
9 * of GUS patches during loading, and full user-level access to all
10 * WaveFront commands. It tries to provide semi-intelligent patch and
11 * sample management as well.
13 * It also provides support for the ICS emulation of an MPU-401. Full
14 * support for the ICS emulation's "virtual MIDI mode" is provided in
17 * Support is also provided for the Tropez Plus' onboard FX processor,
18 * a Yamaha YSS225. Currently, code exists to configure the YSS225,
19 * and there is an interface allowing tweaking of any of its memory
20 * addresses. However, I have been unable to decipher the logical
21 * positioning of the configuration info for various effects, so for
22 * now, you just get the YSS225 in the same state as Turtle Beach's
23 * "SETUPSND.EXE" utility leaves it.
25 * The boards' DAC/ADC (a Crystal CS4232) is supported by cs4232.[co],
26 * This chip also controls the configuration of the card: the wavefront
27 * synth is logical unit 4.
32 * /dev/dsp - using cs4232+ad1848 modules, OSS compatible
33 * /dev/midiNN and /dev/midiNN+1 - using wf_midi code, OSS compatible
34 * /dev/synth00 - raw synth interface
36 **********************************************************************
38 * Copyright (C) by Paul Barton-Davis 1998
40 * Some portions of this file are taken from work that is
41 * copyright (C) by Hannu Savolainen 1993-1996
43 * Although the relevant code here is all new, the handling of
44 * sample/alias/multi- samples is entirely based on a driver by Matt
45 * Martin and Rutger Nijlunsing which demonstrated how to get things
46 * to work correctly. The GUS patch loading code has been almost
47 * unaltered by me, except to fit formatting and function names in the
48 * rest of the file. Many thanks to them.
50 * Appreciation and thanks to Hannu Savolainen for his early work on the Maui
51 * driver, and answering a few questions while this one was developed.
53 * Absolutely NO thanks to Turtle Beach/Voyetra and Yamaha for their
54 * complete lack of help in developing this driver, and in particular
55 * for their utter silence in response to questions about undocumented
56 * aspects of configuring a WaveFront soundcard, particularly the
59 * $Id: wavfront.c,v 0.7 1998/09/09 15:47:36 pbd Exp $
61 * This program is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
62 * Version 2 (June 1991). See the "COPYING" file distributed with this software
65 #include <linux/module.h>
67 #include <linux/kernel.h>
68 #include <linux/sched.h>
69 #include <linux/ptrace.h>
70 #include <linux/fcntl.h>
71 #include <linux/ioport.h>
73 #include <linux/interrupt.h>
74 #include <linux/config.h>
75 #include <linux/init.h>
77 #include <linux/delay.h>
79 #include "sound_config.h"
80 #include "soundmodule.h"
82 #include <linux/wavefront.h>
85 * This sucks, hopefully it'll get standardised
88 #if defined(__alpha__)
90 #define LOOPS_PER_SEC cpu_data[smp_processor_id()].loops_per_sec
92 #define LOOPS_PER_SEC loops_per_sec
97 #define LOOPS_PER_SEC current_cpu_data.loops_per_sec
100 #define _MIDI_SYNTH_C_
101 #define MIDI_SYNTH_NAME "WaveFront MIDI"
102 #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
103 #include "midi_synth.h"
105 /* Compile-time control of the extent to which OSS is supported.
107 I consider /dev/sequencer to be an anachronism, but given its
108 widespread usage by various Linux MIDI software, it seems worth
109 offering support to it if its not too painful. Instead of using
110 /dev/sequencer, I recommend:
112 for synth programming and patch loading: /dev/synthNN
113 for kernel-synchronized MIDI sequencing: the ALSA sequencer
114 for direct MIDI control: /dev/midiNN
116 I have never tried static compilation into the kernel. The #if's
117 for this are really just notes to myself about what the code is
121 #define OSS_SUPPORT_SEQ 0x1 /* use of /dev/sequencer */
122 #define OSS_SUPPORT_STATIC_INSTALL 0x2 /* static compilation into kernel */
124 #define OSS_SUPPORT_LEVEL 0x1 /* just /dev/sequencer for now */
126 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
127 static int (*midi_load_patch
) (int devno
, int format
, const char *addr
,
128 int offs
, int count
, int pmgr_flag
) = NULL
;
129 #endif OSS_SUPPORT_SEQ
131 /* This is meant to work as a module */
133 #if defined(CONFIG_SOUND_WAVEFRONT_MODULE) && defined(MODULE)
135 /* if WF_DEBUG not defined, no run-time debugging messages will
136 be available via the debug flag setting. Given the current
137 beta state of the driver, this will remain set until a future
145 /* Thank goodness for gcc's preprocessor ... */
147 #define DPRINT(cond, format, args...) \
148 if ((dev.debug & (cond)) == (cond)) { \
149 printk (KERN_DEBUG LOGNAME format, ## args); \
152 #define DPRINT(cond, format, args...)
155 #define LOGNAME "WaveFront: "
157 /* bitmasks for WaveFront status port value */
159 #define STAT_RINTR_ENABLED 0x01
160 #define STAT_CAN_READ 0x02
161 #define STAT_INTR_READ 0x04
162 #define STAT_WINTR_ENABLED 0x10
163 #define STAT_CAN_WRITE 0x20
164 #define STAT_INTR_WRITE 0x40
166 /*** Module-accessible parameters ***************************************/
168 int wf_raw
= 0; /* we normally check for "raw state" to firmware
169 loading. if set, then during driver loading, the
170 state of the board is ignored, and we reset the
171 board and load the firmware anyway.
174 int fx_raw
= 1; /* if this is zero, we'll leave the FX processor in
175 whatever state it is when the driver is loaded.
176 The default is to download the microprogram and
177 associated coefficients to set it up for "default"
178 operation, whatever that means.
181 int debug_default
= 0; /* you can set this to control debugging
182 during driver loading. it takes any combination
183 of the WF_DEBUG_* flags defined in
187 /* XXX this needs to be made firmware and hardware version dependent */
189 char *ospath
= "/etc/sound/wavefront.os"; /* where to find a processed
190 version of the WaveFront OS
193 int wait_usecs
= 150; /* This magic number seems to give pretty optimal
194 throughput based on my limited experimentation.
195 If you want to play around with it and find a better
196 value, be my guest. Remember, the idea is to
197 get a number that causes us to just busy wait
198 for as many WaveFront commands as possible, without
199 coming up with a number so large that we hog the
202 Specifically, with this number, out of about 134,000
203 status waits, only about 250 result in a sleep.
206 int sleep_interval
= 100; /* HZ/sleep_interval seconds per sleep */
207 int sleep_tries
= 50; /* number of times we'll try to sleep */
209 int reset_time
= 2; /* hundreths of a second we wait after a HW reset for
210 the expected interrupt.
213 int ramcheck_time
= 20; /* time in seconds to wait while ROM code
217 int osrun_time
= 10; /* time in seconds we wait for the OS to
221 MODULE_PARM(wf_raw
,"i");
222 MODULE_PARM(fx_raw
,"i");
223 MODULE_PARM(debug_default
,"i");
224 MODULE_PARM(wait_usecs
,"i");
225 MODULE_PARM(sleep_interval
,"i");
226 MODULE_PARM(sleep_tries
,"i");
227 MODULE_PARM(ospath
,"s");
228 MODULE_PARM(reset_time
,"i");
229 MODULE_PARM(ramcheck_time
,"i");
230 MODULE_PARM(osrun_time
,"i");
232 /***************************************************************************/
234 /* Note: because this module doesn't export any symbols, this really isn't
235 a global variable, even if it looks like one. I was quite confused by
236 this when I started writing this as a (newer) module -- pbd.
240 int devno
; /* device number from kernel */
241 int irq
; /* "you were one, one of the few ..." */
242 int base
; /* low i/o port address */
244 #define mpu_data_port base
245 #define mpu_command_port base + 1 /* write semantics */
246 #define mpu_status_port base + 1 /* read semantics */
247 #define data_port base + 2
248 #define status_port base + 3 /* read semantics */
249 #define control_port base + 3 /* write semantics */
250 #define block_port base + 4 /* 16 bit, writeonly */
251 #define last_block_port base + 6 /* 16 bit, writeonly */
253 /* FX ports. These are mapped through the ICS2115 to the YS225.
254 The ICS2115 takes care of flipping the relevant pins on the
255 YS225 so that access to each of these ports does the right
256 thing. Note: these are NOT documented by Turtle Beach.
259 #define fx_status base + 8
260 #define fx_op base + 8
261 #define fx_lcr base + 9
262 #define fx_dsp_addr base + 0xa
263 #define fx_dsp_page base + 0xb
264 #define fx_dsp_lsb base + 0xc
265 #define fx_dsp_msb base + 0xd
266 #define fx_mod_addr base + 0xe
267 #define fx_mod_data base + 0xf
269 volatile int irq_ok
; /* set by interrupt handler */
270 volatile int irq_cnt
; /* ditto */
271 int opened
; /* flag, holds open(2) mode */
272 char debug
; /* debugging flags */
273 int freemem
; /* installed RAM, in bytes */
275 int synth_dev
; /* devno for "raw" synth */
276 int mididev
; /* devno for internal MIDI */
277 int ext_mididev
; /* devno for external MIDI */
278 int fx_mididev
; /* devno for FX MIDI interface */
279 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
280 int oss_dev
; /* devno for OSS sequencer synth */
281 #endif OSS_SUPPORT_SEQ
283 char fw_version
[2]; /* major = [0], minor = [1] */
284 char hw_version
[2]; /* major = [0], minor = [1] */
285 char israw
; /* needs Motorola microcode */
286 char has_fx
; /* has FX processor (Tropez+) */
287 char prog_status
[WF_MAX_PROGRAM
]; /* WF_SLOT_* */
288 char patch_status
[WF_MAX_PATCH
]; /* WF_SLOT_* */
289 char sample_status
[WF_MAX_SAMPLE
]; /* WF_ST_* | WF_SLOT_* */
290 int samples_used
; /* how many */
291 char interrupts_on
; /* h/w MPU interrupts enabled ? */
292 char rom_samples_rdonly
; /* can we write on ROM samples */
293 wait_queue_head_t interrupt_sleeper
;
296 static int detect_wffx(void);
297 static int wffx_ioctl (wavefront_fx_info
*);
298 static int wffx_init (void);
300 static int wavefront_delete_sample (int sampnum
);
301 static int wavefront_find_free_sample (void);
305 extern int virtual_midi_enable (void);
306 extern int virtual_midi_disable (void);
307 extern int detect_wf_mpu (int, int);
308 extern int install_wf_mpu (void);
309 extern int uninstall_wf_mpu (void);
314 unsigned int read_cnt
;
315 unsigned int write_cnt
;
322 } wavefront_errors
[] = {
323 { 0x01, "Bad sample number" },
324 { 0x02, "Out of sample memory" },
325 { 0x03, "Bad patch number" },
326 { 0x04, "Error in number of voices" },
327 { 0x06, "Sample load already in progress" },
328 { 0x0B, "No sample load request pending" },
329 { 0x0E, "Bad MIDI channel number" },
330 { 0x10, "Download Record Error" },
337 static wavefront_command wavefront_commands
[] = {
338 { WFC_SET_SYNTHVOL
, "set synthesizer volume", 0, 1, NEEDS_ACK
},
339 { WFC_GET_SYNTHVOL
, "get synthesizer volume", 1, 0, 0},
340 { WFC_SET_NVOICES
, "set number of voices", 0, 1, NEEDS_ACK
},
341 { WFC_GET_NVOICES
, "get number of voices", 1, 0, 0 },
342 { WFC_SET_TUNING
, "set synthesizer tuning", 0, 2, NEEDS_ACK
},
343 { WFC_GET_TUNING
, "get synthesizer tuning", 2, 0, 0 },
344 { WFC_DISABLE_CHANNEL
, "disable synth channel", 0, 1, NEEDS_ACK
},
345 { WFC_ENABLE_CHANNEL
, "enable synth channel", 0, 1, NEEDS_ACK
},
346 { WFC_GET_CHANNEL_STATUS
, "get synth channel status", 3, 0, 0 },
347 { WFC_MISYNTH_OFF
, "disable midi-in to synth", 0, 0, NEEDS_ACK
},
348 { WFC_MISYNTH_ON
, "enable midi-in to synth", 0, 0, NEEDS_ACK
},
349 { WFC_VMIDI_ON
, "enable virtual midi mode", 0, 0, NEEDS_ACK
},
350 { WFC_VMIDI_OFF
, "disable virtual midi mode", 0, 0, NEEDS_ACK
},
351 { WFC_MIDI_STATUS
, "report midi status", 1, 0, 0 },
352 { WFC_FIRMWARE_VERSION
, "report firmware version", 2, 0, 0 },
353 { WFC_HARDWARE_VERSION
, "report hardware version", 2, 0, 0 },
354 { WFC_GET_NSAMPLES
, "report number of samples", 2, 0, 0 },
355 { WFC_INSTOUT_LEVELS
, "report instantaneous output levels", 7, 0, 0 },
356 { WFC_PEAKOUT_LEVELS
, "report peak output levels", 7, 0, 0 },
357 { WFC_DOWNLOAD_SAMPLE
, "download sample",
358 0, WF_SAMPLE_BYTES
, NEEDS_ACK
},
359 { WFC_DOWNLOAD_BLOCK
, "download block", 0, 0, NEEDS_ACK
},
360 { WFC_DOWNLOAD_SAMPLE_HEADER
, "download sample header",
361 0, WF_SAMPLE_HDR_BYTES
, NEEDS_ACK
},
362 { WFC_UPLOAD_SAMPLE_HEADER
, "upload sample header", 13, 2, 0 },
364 /* This command requires a variable number of bytes to be written.
365 There is a hack in wavefront_cmd() to support this. The actual
366 count is passed in as the read buffer ptr, cast appropriately.
370 { WFC_DOWNLOAD_MULTISAMPLE
, "download multisample", 0, 0, NEEDS_ACK
},
372 /* This one is a hack as well. We just read the first byte of the
373 response, don't fetch an ACK, and leave the rest to the
374 calling function. Ugly, ugly, ugly.
377 { WFC_UPLOAD_MULTISAMPLE
, "upload multisample", 2, 1, 0 },
378 { WFC_DOWNLOAD_SAMPLE_ALIAS
, "download sample alias",
379 0, WF_ALIAS_BYTES
, NEEDS_ACK
},
380 { WFC_UPLOAD_SAMPLE_ALIAS
, "upload sample alias", WF_ALIAS_BYTES
, 2, 0},
381 { WFC_DELETE_SAMPLE
, "delete sample", 0, 2, NEEDS_ACK
},
382 { WFC_IDENTIFY_SAMPLE_TYPE
, "identify sample type", 5, 2, 0 },
383 { WFC_UPLOAD_SAMPLE_PARAMS
, "upload sample parameters" },
384 { WFC_REPORT_FREE_MEMORY
, "report free memory", 4, 0, 0 },
385 { WFC_DOWNLOAD_PATCH
, "download patch", 0, 134, NEEDS_ACK
},
386 { WFC_UPLOAD_PATCH
, "upload patch", 132, 2, 0 },
387 { WFC_DOWNLOAD_PROGRAM
, "download program", 0, 33, NEEDS_ACK
},
388 { WFC_UPLOAD_PROGRAM
, "upload program", 32, 1, 0 },
389 { WFC_DOWNLOAD_EDRUM_PROGRAM
, "download enhanced drum program", 0, 9,
391 { WFC_UPLOAD_EDRUM_PROGRAM
, "upload enhanced drum program", 8, 1, 0},
392 { WFC_SET_EDRUM_CHANNEL
, "set enhanced drum program channel",
394 { WFC_DISABLE_DRUM_PROGRAM
, "disable drum program", 0, 1, NEEDS_ACK
},
395 { WFC_REPORT_CHANNEL_PROGRAMS
, "report channel program numbers",
397 { WFC_NOOP
, "the no-op command", 0, 0, NEEDS_ACK
},
402 wavefront_errorstr (int errnum
)
407 for (i
= 0; wavefront_errors
[i
].errstr
; i
++) {
408 if (wavefront_errors
[i
].errno
== errnum
) {
409 return wavefront_errors
[i
].errstr
;
413 return "Unknown WaveFront error";
416 static wavefront_command
*
417 wavefront_get_command (int cmd
)
422 for (i
= 0; wavefront_commands
[i
].cmd
!= 0; i
++) {
423 if (cmd
== wavefront_commands
[i
].cmd
) {
424 return &wavefront_commands
[i
];
428 return (wavefront_command
*) 0;
432 wavefront_status (void)
435 return inb (dev
.status_port
);
439 wavefront_sleep (int limit
)
442 current
->state
= TASK_INTERRUPTIBLE
;
443 schedule_timeout(limit
);
445 return signal_pending(current
);
449 wavefront_wait (int mask
)
453 static int short_loop_cnt
= 0;
455 /* Compute the loop count that lets us sleep for about the
456 right amount of time, cache issues, bus speeds and all
457 other issues being unequal but largely irrelevant.
460 if (short_loop_cnt
== 0) {
461 short_loop_cnt
= wait_usecs
*
462 (LOOPS_PER_SEC
/ 1000000);
465 /* Spin for a short period of time, because >99% of all
466 requests to the WaveFront can be serviced inline like this.
469 for (i
= 0; i
< short_loop_cnt
; i
++) {
470 if (wavefront_status() & mask
) {
475 for (i
= 0; i
< sleep_tries
; i
++) {
477 if (wavefront_status() & mask
) {
481 if (wavefront_sleep (HZ
/sleep_interval
)) {
490 wavefront_read (void)
493 if (wavefront_wait (STAT_CAN_READ
))
494 return inb (dev
.data_port
);
496 DPRINT (WF_DEBUG_DATA
, "read timeout.\n");
502 wavefront_write (unsigned char data
)
505 if (wavefront_wait (STAT_CAN_WRITE
)) {
506 outb (data
, dev
.data_port
);
510 DPRINT (WF_DEBUG_DATA
, "write timeout.\n");
516 wavefront_cmd (int cmd
, unsigned char *rbuf
, unsigned char *wbuf
)
522 wavefront_command
*wfcmd
;
524 if ((wfcmd
= wavefront_get_command (cmd
)) == (wavefront_command
*) 0) {
525 printk (KERN_WARNING LOGNAME
"command 0x%x not supported.\n",
530 /* Hack to handle the one variable-size write command. See
531 wavefront_send_multisample() for the other half of this
532 gross and ugly strategy.
535 if (cmd
== WFC_DOWNLOAD_MULTISAMPLE
) {
536 wfcmd
->write_cnt
= (unsigned int) rbuf
;
540 DPRINT (WF_DEBUG_CMD
, "0x%x [%s] (%d,%d,%d)\n",
541 cmd
, wfcmd
->action
, wfcmd
->read_cnt
,
542 wfcmd
->write_cnt
, wfcmd
->need_ack
);
544 if (wavefront_write (cmd
)) {
545 DPRINT ((WF_DEBUG_IO
|WF_DEBUG_CMD
), "cannot request "
551 if (wfcmd
->write_cnt
> 0) {
552 DPRINT (WF_DEBUG_DATA
, "writing %d bytes "
554 wfcmd
->write_cnt
, cmd
);
556 for (i
= 0; i
< wfcmd
->write_cnt
; i
++) {
557 if (wavefront_write (wbuf
[i
])) {
558 DPRINT (WF_DEBUG_IO
, "bad write for byte "
559 "%d of 0x%x [%s].\n",
560 i
, cmd
, wfcmd
->action
);
564 DPRINT (WF_DEBUG_DATA
, "write[%d] = 0x%x\n",
569 if (wfcmd
->read_cnt
> 0) {
570 DPRINT (WF_DEBUG_DATA
, "reading %d ints "
572 wfcmd
->read_cnt
, cmd
);
574 for (i
= 0; i
< wfcmd
->read_cnt
; i
++) {
576 if ((c
= wavefront_read()) == -1) {
577 DPRINT (WF_DEBUG_IO
, "bad read for byte "
578 "%d of 0x%x [%s].\n",
579 i
, cmd
, wfcmd
->action
);
583 /* Now handle errors. Lots of special cases here */
586 if ((c
= wavefront_read ()) == -1) {
587 DPRINT (WF_DEBUG_IO
, "bad read for "
596 /* Can you believe this madness ? */
599 wfcmd
->cmd
== WFC_IDENTIFY_SAMPLE_TYPE
) {
600 rbuf
[0] = WF_ST_EMPTY
;
604 wfcmd
->cmd
== WFC_UPLOAD_PATCH
) {
609 wfcmd
->cmd
== WFC_UPLOAD_PROGRAM
) {
615 DPRINT (WF_DEBUG_IO
, "error %d (%s) "
621 wavefront_errorstr (c
),
632 DPRINT (WF_DEBUG_DATA
, "read[%d] = 0x%x\n",i
, rbuf
[i
]);
636 if ((wfcmd
->read_cnt
== 0 && wfcmd
->write_cnt
== 0) || wfcmd
->need_ack
) {
638 DPRINT (WF_DEBUG_CMD
, "reading ACK for 0x%x\n", cmd
);
640 /* Some commands need an ACK, but return zero instead
641 of the standard value.
644 if ((ack
= wavefront_read()) == 0) {
650 DPRINT (WF_DEBUG_IO
, "cannot read ack for "
656 int err
= -1; /* something unknown */
658 if (ack
== 0xff) { /* explicit error */
660 if ((err
= wavefront_read ()) == -1) {
661 DPRINT (WF_DEBUG_DATA
,
668 DPRINT (WF_DEBUG_IO
, "0x%x [%s] "
669 "failed (0x%x, 0x%x, %s)\n",
670 cmd
, wfcmd
->action
, ack
, err
,
671 wavefront_errorstr (err
));
677 DPRINT (WF_DEBUG_DATA
, "ack received "
682 DPRINT (WF_DEBUG_CMD
, "0x%x [%s] does not need "
684 cmd
, wfcmd
->action
, wfcmd
->read_cnt
,
685 wfcmd
->write_cnt
, wfcmd
->need_ack
);
692 /***********************************************************************
693 WaveFront: data munging
695 Things here are wierd. All data written to the board cannot
696 have its most significant bit set. Any data item with values
697 potentially > 0x7F (127) must be split across multiple bytes.
699 Sometimes, we need to munge numeric values that are represented on
700 the x86 side as 8-32 bit values. Sometimes, we need to munge data
701 that is represented on the x86 side as an array of bytes. The most
702 efficient approach to handling both cases seems to be to use 2
703 different functions for munging and 2 for de-munging. This avoids
704 wierd casting and worrying about bit-level offsets.
706 **********************************************************************/
710 munge_int32 (unsigned int src
,
712 unsigned int dst_size
)
716 for (i
= 0;i
< dst_size
; i
++) {
717 *dst
= src
& 0x7F; /* Mask high bit of LSB */
718 src
= src
>> 7; /* Rotate Right 7 bits */
719 /* Note: we leave the upper bits in place */
727 demunge_int32 (unsigned char* src
, int src_size
)
733 for (i
= src_size
- 1; i
>= 0; i
--) {
734 outval
=(outval
<<7)+src
[i
];
742 munge_buf (unsigned char *src
, unsigned char *dst
, unsigned int dst_size
)
746 unsigned int last
= dst_size
/ 2;
748 for (i
= 0; i
< last
; i
++) {
749 *dst
++ = src
[i
] & 0x7f;
750 *dst
++ = src
[i
] >> 7;
757 demunge_buf (unsigned char *src
, unsigned char *dst
, unsigned int src_bytes
)
761 unsigned char *end
= src
+ src_bytes
;
763 end
= src
+ src_bytes
;
765 /* NOTE: src and dst *CAN* point to the same address */
767 for (i
= 0; src
!= end
; i
++) {
769 dst
[i
] |= (*src
++)<<7;
775 /***********************************************************************
776 WaveFront: sample, patch and program management.
777 ***********************************************************************/
780 wavefront_delete_sample (int sample_num
)
783 unsigned char wbuf
[2];
786 wbuf
[0] = sample_num
& 0x7f;
787 wbuf
[1] = sample_num
>> 7;
789 if ((x
= wavefront_cmd (WFC_DELETE_SAMPLE
, 0, wbuf
)) == 0) {
790 dev
.sample_status
[sample_num
] = WF_ST_EMPTY
;
797 wavefront_get_sample_status (int assume_rom
)
801 unsigned char rbuf
[32], wbuf
[32];
802 unsigned int sc_real
, sc_alias
, sc_multi
;
804 /* check sample status */
806 if (wavefront_cmd (WFC_GET_NSAMPLES
, rbuf
, wbuf
)) {
807 printk (KERN_WARNING LOGNAME
"cannot request sample count.\n");
811 sc_real
= sc_alias
= sc_multi
= dev
.samples_used
= 0;
813 for (i
= 0; i
< WF_MAX_SAMPLE
; i
++) {
818 if (wavefront_cmd (WFC_IDENTIFY_SAMPLE_TYPE
, rbuf
, wbuf
)) {
819 printk (KERN_WARNING LOGNAME
820 "cannot identify sample "
821 "type of slot %d\n", i
);
822 dev
.sample_status
[i
] = WF_ST_EMPTY
;
826 dev
.sample_status
[i
] = (WF_SLOT_FILLED
|rbuf
[0]);
829 dev
.sample_status
[i
] |= WF_SLOT_ROM
;
832 switch (rbuf
[0] & WF_ST_MASK
) {
836 case WF_ST_MULTISAMPLE
:
846 printk (KERN_WARNING LOGNAME
"unknown sample type for "
851 if (rbuf
[0] != WF_ST_EMPTY
) {
856 printk (KERN_INFO LOGNAME
857 "%d samples used (%d real, %d aliases, %d multi), "
858 "%d empty\n", dev
.samples_used
, sc_real
, sc_alias
, sc_multi
,
859 WF_MAX_SAMPLE
- dev
.samples_used
);
867 wavefront_get_patch_status (void)
870 unsigned char patchbuf
[WF_PATCH_BYTES
];
871 unsigned char patchnum
[2];
875 for (i
= 0; i
< WF_MAX_PATCH
; i
++) {
876 patchnum
[0] = i
& 0x7f;
877 patchnum
[1] = i
>> 7;
879 if ((x
= wavefront_cmd (WFC_UPLOAD_PATCH
, patchbuf
,
882 dev
.patch_status
[i
] |= WF_SLOT_FILLED
;
883 p
= (wavefront_patch
*) patchbuf
;
885 [p
->sample_number
|(p
->sample_msb
<<7)] |=
888 } else if (x
== 3) { /* Bad patch number */
889 dev
.patch_status
[i
] = 0;
891 printk (KERN_ERR LOGNAME
"upload patch "
893 dev
.patch_status
[i
] = 0;
898 /* program status has already filled in slot_used bits */
900 for (i
= 0, cnt
= 0, cnt2
= 0; i
< WF_MAX_PATCH
; i
++) {
901 if (dev
.patch_status
[i
] & WF_SLOT_FILLED
) {
904 if (dev
.patch_status
[i
] & WF_SLOT_USED
) {
909 printk (KERN_INFO LOGNAME
910 "%d patch slots filled, %d in use\n", cnt
, cnt2
);
916 wavefront_get_program_status (void)
919 unsigned char progbuf
[WF_PROGRAM_BYTES
];
920 wavefront_program prog
;
921 unsigned char prognum
;
924 for (i
= 0; i
< WF_MAX_PROGRAM
; i
++) {
927 if ((x
= wavefront_cmd (WFC_UPLOAD_PROGRAM
, progbuf
,
930 dev
.prog_status
[i
] |= WF_SLOT_USED
;
932 demunge_buf (progbuf
, (unsigned char *) &prog
,
935 for (l
= 0; l
< WF_NUM_LAYERS
; l
++) {
936 if (prog
.layer
[l
].mute
) {
938 [prog
.layer
[l
].patch_number
] |=
942 } else if (x
== 1) { /* Bad program number */
943 dev
.prog_status
[i
] = 0;
945 printk (KERN_ERR LOGNAME
"upload program "
947 dev
.prog_status
[i
] = 0;
951 for (i
= 0, cnt
= 0; i
< WF_MAX_PROGRAM
; i
++) {
952 if (dev
.prog_status
[i
]) {
957 printk (KERN_INFO LOGNAME
"%d programs slots in use\n", cnt
);
963 wavefront_send_patch (wavefront_patch_info
*header
)
966 unsigned char buf
[WF_PATCH_BYTES
+2];
969 DPRINT (WF_DEBUG_LOAD_PATCH
, "downloading patch %d\n",
972 dev
.patch_status
[header
->number
] |= WF_SLOT_FILLED
;
975 bptr
= munge_int32 (header
->number
, buf
, 2);
976 munge_buf ((unsigned char *)&header
->hdr
.p
, bptr
, WF_PATCH_BYTES
);
978 if (wavefront_cmd (WFC_DOWNLOAD_PATCH
, 0, buf
)) {
979 printk (KERN_ERR LOGNAME
"download patch failed\n");
987 wavefront_send_program (wavefront_patch_info
*header
)
990 unsigned char buf
[WF_PROGRAM_BYTES
+1];
993 DPRINT (WF_DEBUG_LOAD_PATCH
, "downloading program %d\n",
996 dev
.prog_status
[header
->number
] = WF_SLOT_USED
;
998 /* XXX need to zero existing SLOT_USED bit for program_status[i]
999 where `i' is the program that's being (potentially) overwritten.
1002 for (i
= 0; i
< WF_NUM_LAYERS
; i
++) {
1003 if (header
->hdr
.pr
.layer
[i
].mute
) {
1004 dev
.patch_status
[header
->hdr
.pr
.layer
[i
].patch_number
] |=
1007 /* XXX need to mark SLOT_USED for sample used by
1008 patch_number, but this means we have to load it. Ick.
1013 buf
[0] = header
->number
;
1014 munge_buf ((unsigned char *)&header
->hdr
.pr
, &buf
[1], WF_PROGRAM_BYTES
);
1016 if (wavefront_cmd (WFC_DOWNLOAD_PROGRAM
, 0, buf
)) {
1017 printk (KERN_WARNING LOGNAME
"download patch failed\n");
1025 wavefront_freemem (void)
1030 if (wavefront_cmd (WFC_REPORT_FREE_MEMORY
, rbuf
, 0)) {
1031 printk (KERN_WARNING LOGNAME
"can't get memory stats.\n");
1034 return demunge_int32 (rbuf
, 4);
1039 wavefront_send_sample (wavefront_patch_info
*header
,
1041 int data_is_unsigned
)
1044 /* samples are downloaded via a 16-bit wide i/o port
1045 (you could think of it as 2 adjacent 8-bit wide ports
1046 but its less efficient that way). therefore, all
1047 the blocksizes and so forth listed in the documentation,
1048 and used conventionally to refer to sample sizes,
1049 which are given in 8-bit units (bytes), need to be
1053 UINT16 sample_short
;
1055 UINT16
*data_end
= 0;
1057 const int max_blksize
= 4096/2;
1058 unsigned int written
;
1059 unsigned int blocksize
;
1062 unsigned char sample_hdr
[WF_SAMPLE_HDR_BYTES
];
1063 unsigned char *shptr
;
1065 int initial_skip
= 0;
1067 DPRINT (WF_DEBUG_LOAD_PATCH
, "sample %sdownload for slot %d, "
1068 "type %d, %d bytes from 0x%x\n",
1069 header
->size
? "" : "header ",
1070 header
->number
, header
->subkey
,
1072 (int) header
->dataptr
);
1074 if (header
->number
== WAVEFRONT_FIND_FREE_SAMPLE_SLOT
) {
1077 if ((x
= wavefront_find_free_sample ()) < 0) {
1080 printk (KERN_DEBUG LOGNAME
"unspecified sample => %d\n", x
);
1086 /* XXX its a debatable point whether or not RDONLY semantics
1087 on the ROM samples should cover just the sample data or
1088 the sample header. For now, it only covers the sample data,
1089 so anyone is free at all times to rewrite sample headers.
1091 My reason for this is that we have the sample headers
1092 available in the WFB file for General MIDI, and so these
1093 can always be reset if needed. The sample data, however,
1094 cannot be recovered without a complete reset and firmware
1095 reload of the ICS2115, which is a very expensive operation.
1097 So, doing things this way allows us to honor the notion of
1098 "RESETSAMPLES" reasonably cheaply. Note however, that this
1099 is done purely at user level: there is no WFB parser in
1100 this driver, and so a complete reset (back to General MIDI,
1101 or theoretically some other configuration) is the
1102 responsibility of the user level library.
1104 To try to do this in the kernel would be a little
1105 crazy: we'd need 158K of kernel space just to hold
1106 a copy of the patch/program/sample header data.
1109 if (dev
.rom_samples_rdonly
) {
1110 if (dev
.sample_status
[header
->number
] & WF_SLOT_ROM
) {
1111 printk (KERN_ERR LOGNAME
"sample slot %d "
1112 "write protected\n",
1118 wavefront_delete_sample (header
->number
);
1122 dev
.freemem
= wavefront_freemem ();
1124 if (dev
.freemem
< header
->size
) {
1125 printk (KERN_ERR LOGNAME
1126 "insufficient memory to "
1127 "load %d byte sample.\n",
1134 skip
= WF_GET_CHANNEL(&header
->hdr
.s
);
1136 if (skip
> 0 && header
->hdr
.s
.SampleResolution
!= LINEAR_16BIT
) {
1137 printk (KERN_ERR LOGNAME
"channel selection only "
1138 "possible on 16-bit samples");
1173 DPRINT (WF_DEBUG_LOAD_PATCH
, "channel selection: %d => "
1174 "initial skip = %d, skip = %d\n",
1175 WF_GET_CHANNEL (&header
->hdr
.s
),
1176 initial_skip
, skip
);
1178 /* Be safe, and zero the "Unused" bits ... */
1180 WF_SET_CHANNEL(&header
->hdr
.s
, 0);
1182 /* adjust size for 16 bit samples by dividing by two. We always
1183 send 16 bits per write, even for 8 bit samples, so the length
1184 is always half the size of the sample data in bytes.
1187 length
= header
->size
/ 2;
1189 /* the data we're sent has not been munged, and in fact, the
1190 header we have to send isn't just a munged copy either.
1191 so, build the sample header right here.
1194 shptr
= &sample_hdr
[0];
1196 shptr
= munge_int32 (header
->number
, shptr
, 2);
1199 shptr
= munge_int32 (length
, shptr
, 4);
1202 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1203 but the offset only uses 24 bits.
1206 shptr
= munge_int32 (*((UINT32
*) &header
->hdr
.s
.sampleStartOffset
),
1208 shptr
= munge_int32 (*((UINT32
*) &header
->hdr
.s
.loopStartOffset
),
1210 shptr
= munge_int32 (*((UINT32
*) &header
->hdr
.s
.loopEndOffset
),
1212 shptr
= munge_int32 (*((UINT32
*) &header
->hdr
.s
.sampleEndOffset
),
1215 /* This one is truly wierd. What kind of wierdo decided that in
1216 a system dominated by 16 and 32 bit integers, they would use
1220 shptr
= munge_int32 (header
->hdr
.s
.FrequencyBias
, shptr
, 3);
1222 /* Why is this nybblified, when the MSB is *always* zero ?
1223 Anyway, we can't take address of bitfield, so make a
1224 good-faith guess at where it starts.
1227 shptr
= munge_int32 (*(&header
->hdr
.s
.FrequencyBias
+1),
1230 if (wavefront_cmd (header
->size
?
1231 WFC_DOWNLOAD_SAMPLE
: WFC_DOWNLOAD_SAMPLE_HEADER
,
1233 printk (KERN_WARNING LOGNAME
"sample %sdownload refused.\n",
1234 header
->size
? "" : "header ");
1238 if (header
->size
== 0) {
1239 goto sent
; /* Sorry. Just had to have one somewhere */
1242 data_end
= dataptr
+ length
;
1244 /* Do any initial skip over an unused channel's data */
1246 dataptr
+= initial_skip
;
1248 for (written
= 0, blocknum
= 0;
1249 written
< length
; written
+= max_blksize
, blocknum
++) {
1251 if ((length
- written
) > max_blksize
) {
1252 blocksize
= max_blksize
;
1254 /* round to nearest 16-byte value */
1255 blocksize
= ((length
-written
+7)&~0x7);
1258 if (wavefront_cmd (WFC_DOWNLOAD_BLOCK
, 0, 0)) {
1259 printk (KERN_WARNING LOGNAME
"download block "
1260 "request refused.\n");
1264 for (i
= 0; i
< blocksize
; i
++) {
1266 if (dataptr
< data_end
) {
1268 __get_user (sample_short
, dataptr
);
1271 if (data_is_unsigned
) { /* GUS ? */
1273 if (WF_SAMPLE_IS_8BIT(&header
->hdr
.s
)) {
1281 &sample_short
)[0] += 0x7f;
1283 &sample_short
)[1] += 0x7f;
1292 sample_short
+= 0x7fff;
1298 /* In padding section of final block:
1300 Don't fetch unsupplied data from
1301 user space, just continue with
1302 whatever the final value was.
1306 if (i
< blocksize
- 1) {
1307 outw (sample_short
, dev
.block_port
);
1309 outw (sample_short
, dev
.last_block_port
);
1313 /* Get "DMA page acknowledge", even though its really
1314 nothing to do with DMA at all.
1317 if ((dma_ack
= wavefront_read ()) != WF_DMA_ACK
) {
1318 if (dma_ack
== -1) {
1319 printk (KERN_ERR LOGNAME
"upload sample "
1320 "DMA ack timeout\n");
1323 printk (KERN_ERR LOGNAME
"upload sample "
1324 "DMA ack error 0x%x\n",
1331 dev
.sample_status
[header
->number
] = (WF_SLOT_FILLED
|WF_ST_SAMPLE
);
1333 /* Note, label is here because sending the sample header shouldn't
1334 alter the sample_status info at all.
1342 wavefront_send_alias (wavefront_patch_info
*header
)
1345 unsigned char alias_hdr
[WF_ALIAS_BYTES
];
1347 DPRINT (WF_DEBUG_LOAD_PATCH
, "download alias, %d is "
1350 header
->hdr
.a
.OriginalSample
);
1352 munge_int32 (header
->number
, &alias_hdr
[0], 2);
1353 munge_int32 (header
->hdr
.a
.OriginalSample
, &alias_hdr
[2], 2);
1354 munge_int32 (*((unsigned int *)&header
->hdr
.a
.sampleStartOffset
),
1356 munge_int32 (*((unsigned int *)&header
->hdr
.a
.loopStartOffset
),
1358 munge_int32 (*((unsigned int *)&header
->hdr
.a
.loopEndOffset
),
1360 munge_int32 (*((unsigned int *)&header
->hdr
.a
.sampleEndOffset
),
1362 munge_int32 (header
->hdr
.a
.FrequencyBias
, &alias_hdr
[20], 3);
1363 munge_int32 (*(&header
->hdr
.a
.FrequencyBias
+1), &alias_hdr
[23], 2);
1365 if (wavefront_cmd (WFC_DOWNLOAD_SAMPLE_ALIAS
, 0, alias_hdr
)) {
1366 printk (KERN_ERR LOGNAME
"download alias failed.\n");
1370 dev
.sample_status
[header
->number
] = (WF_SLOT_FILLED
|WF_ST_ALIAS
);
1376 wavefront_send_multisample (wavefront_patch_info
*header
)
1380 unsigned char msample_hdr
[WF_MSAMPLE_BYTES
];
1382 munge_int32 (header
->number
, &msample_hdr
[0], 2);
1384 /* You'll recall at this point that the "number of samples" value
1385 in a wavefront_multisample struct is actually the log2 of the
1386 real number of samples.
1389 num_samples
= (1<<(header
->hdr
.ms
.NumberOfSamples
&7));
1390 msample_hdr
[2] = (unsigned char) header
->hdr
.ms
.NumberOfSamples
;
1392 DPRINT (WF_DEBUG_LOAD_PATCH
, "multi %d with %d=%d samples\n",
1394 header
->hdr
.ms
.NumberOfSamples
,
1397 for (i
= 0; i
< num_samples
; i
++) {
1398 DPRINT(WF_DEBUG_LOAD_PATCH
|WF_DEBUG_DATA
, "sample[%d] = %d\n",
1399 i
, header
->hdr
.ms
.SampleNumber
[i
]);
1400 munge_int32 (header
->hdr
.ms
.SampleNumber
[i
],
1401 &msample_hdr
[3+(i
*2)], 2);
1404 /* Need a hack here to pass in the number of bytes
1405 to be written to the synth. This is ugly, and perhaps
1406 one day, I'll fix it.
1409 if (wavefront_cmd (WFC_DOWNLOAD_MULTISAMPLE
,
1410 (unsigned char *) ((num_samples
*2)+3),
1412 printk (KERN_ERR LOGNAME
"download of multisample failed.\n");
1416 dev
.sample_status
[header
->number
] = (WF_SLOT_FILLED
|WF_ST_MULTISAMPLE
);
1422 wavefront_fetch_multisample (wavefront_patch_info
*header
)
1425 unsigned char log_ns
[1];
1426 unsigned char number
[2];
1429 munge_int32 (header
->number
, number
, 2);
1431 if (wavefront_cmd (WFC_UPLOAD_MULTISAMPLE
, log_ns
, number
)) {
1432 printk (KERN_ERR LOGNAME
"upload multisample failed.\n");
1436 DPRINT (WF_DEBUG_DATA
, "msample %d has %d samples\n",
1437 header
->number
, log_ns
[0]);
1439 header
->hdr
.ms
.NumberOfSamples
= log_ns
[0];
1441 /* get the number of samples ... */
1443 num_samples
= (1 << log_ns
[0]);
1445 for (i
= 0; i
< num_samples
; i
++) {
1448 if ((d
[0] = wavefront_read ()) == -1) {
1449 printk (KERN_ERR LOGNAME
"upload multisample failed "
1450 "during sample loop.\n");
1454 if ((d
[1] = wavefront_read ()) == -1) {
1455 printk (KERN_ERR LOGNAME
"upload multisample failed "
1456 "during sample loop.\n");
1460 header
->hdr
.ms
.SampleNumber
[i
] =
1461 demunge_int32 ((unsigned char *) d
, 2);
1463 DPRINT (WF_DEBUG_DATA
, "msample sample[%d] = %d\n",
1464 i
, header
->hdr
.ms
.SampleNumber
[i
]);
1472 wavefront_send_drum (wavefront_patch_info
*header
)
1475 unsigned char drumbuf
[WF_DRUM_BYTES
];
1476 wavefront_drum
*drum
= &header
->hdr
.d
;
1479 DPRINT (WF_DEBUG_LOAD_PATCH
, "downloading edrum for MIDI "
1480 "note %d, patch = %d\n",
1481 header
->number
, drum
->PatchNumber
);
1483 drumbuf
[0] = header
->number
& 0x7f;
1485 for (i
= 0; i
< 4; i
++) {
1486 munge_int32 (((unsigned char *)drum
)[i
], &drumbuf
[1+(i
*2)], 2);
1489 if (wavefront_cmd (WFC_DOWNLOAD_EDRUM_PROGRAM
, 0, drumbuf
)) {
1490 printk (KERN_ERR LOGNAME
"download drum failed.\n");
1498 wavefront_find_free_sample (void)
1503 for (i
= 0; i
< WF_MAX_SAMPLE
; i
++) {
1504 if (!(dev
.sample_status
[i
] & WF_SLOT_FILLED
)) {
1508 printk (KERN_WARNING LOGNAME
"no free sample slots!\n");
1513 wavefront_find_free_patch (void)
1518 for (i
= 0; i
< WF_MAX_PATCH
; i
++) {
1519 if (!(dev
.patch_status
[i
] & WF_SLOT_FILLED
)) {
1523 printk (KERN_WARNING LOGNAME
"no free patch slots!\n");
1531 int tbl
[]={0, 0, 2048, 3246, 4096, 4755, 5294, 5749, 6143,
1532 6492, 6803, 7084, 7342, 7578, 7797, 8001, 8192,
1533 8371, 8540, 8699, 8851, 8995, 9132, 9264, 9390,
1534 9510, 9626, 9738, 9845, 9949, 10049, 10146};
1537 /* Returns 2048*log2(n) */
1539 /* FIXME: this is like doing integer math
1540 on quantum particles (RuN) */
1556 wavefront_load_gus_patch (int devno
, int format
, const char *addr
,
1557 int offs
, int count
, int pmgr_flag
)
1559 struct patch_info guspatch
;
1560 wavefront_patch_info samp
, pat
, prog
;
1561 wavefront_patch
*patp
;
1562 wavefront_sample
*sampp
;
1563 wavefront_program
*progp
;
1568 /* Copy in the header of the GUS patch */
1570 sizeof_patch
= (long) &guspatch
.data
[0] - (long) &guspatch
;
1571 copy_from_user (&((char *) &guspatch
)[offs
],
1572 &(addr
)[offs
], sizeof_patch
- offs
);
1574 if ((i
= wavefront_find_free_patch ()) == -1) {
1578 pat
.subkey
= WF_ST_PATCH
;
1581 if ((i
= wavefront_find_free_sample ()) == -1) {
1585 samp
.subkey
= WF_ST_SAMPLE
;
1586 samp
.size
= guspatch
.len
;
1587 sampp
= &samp
.hdr
.s
;
1589 prog
.number
= guspatch
.instr_no
;
1590 progp
= &prog
.hdr
.pr
;
1592 /* Setup the patch structure */
1594 patp
->amplitude_bias
=guspatch
.volume
;
1596 patp
->sample_number
= samp
.number
& 0xff;
1597 patp
->sample_msb
= samp
.number
>>8;
1598 patp
->pitch_bend
= /*12*/ 0;
1601 patp
->nohold
=(guspatch
.mode
& WAVE_SUSTAIN_ON
) ? 0:1;
1602 patp
->frequency_bias
=0;
1607 patp
->fm_src1
=WF_MOD_MOD_WHEEL
;
1608 patp
->am_src
=WF_MOD_PRESSURE
;
1609 patp
->am_amount
=127;
1610 patp
->fc1_mod_amount
=0;
1611 patp
->fc2_mod_amount
=0;
1614 patp
->envelope1
.attack_level
=127;
1615 patp
->envelope1
.decay1_level
=127;
1616 patp
->envelope1
.decay2_level
=127;
1617 patp
->envelope1
.sustain_level
=127;
1618 patp
->envelope1
.release_level
=0;
1619 patp
->envelope2
.attack_velocity
=127;
1620 patp
->envelope2
.attack_level
=127;
1621 patp
->envelope2
.decay1_level
=127;
1622 patp
->envelope2
.decay2_level
=127;
1623 patp
->envelope2
.sustain_level
=127;
1624 patp
->envelope2
.release_level
=0;
1625 patp
->envelope2
.attack_velocity
=127;
1628 /* Program for this patch */
1630 progp
->layer
[0].patch_number
= pat
.number
; /* XXX is this right ? */
1631 progp
->layer
[0].mute
=1;
1632 progp
->layer
[0].pan_or_mod
=1;
1633 progp
->layer
[0].pan
=7;
1634 progp
->layer
[0].mix_level
=127 /* guspatch.volume */;
1635 progp
->layer
[0].split_type
=0;
1636 progp
->layer
[0].split_point
=0;
1637 progp
->layer
[0].play_below
=0;
1639 for (i
= 1; i
< 4; i
++) {
1640 progp
->layer
[i
].mute
=0;
1645 sampp
->SampleResolution
=((~guspatch
.mode
& WAVE_16_BITS
)<<1);
1648 note_to_freq (base_note
) < guspatch
.base_note
;
1651 if ((guspatch
.base_note
-note_to_freq(base_note
))
1652 >(note_to_freq(base_note
)-guspatch
.base_note
))
1655 printk(KERN_DEBUG
"ref freq=%d,base note=%d\n",
1659 sampp
->FrequencyBias
= (29550 - log2_2048(guspatch
.base_freq
)
1661 printk(KERN_DEBUG
"Freq Bias is %d\n", sampp
->FrequencyBias
);
1662 sampp
->Loop
=(guspatch
.mode
& WAVE_LOOPING
) ? 1:0;
1663 sampp
->sampleStartOffset
.Fraction
=0;
1664 sampp
->sampleStartOffset
.Integer
=0;
1665 sampp
->loopStartOffset
.Fraction
=0;
1666 sampp
->loopStartOffset
.Integer
=guspatch
.loop_start
1667 >>((guspatch
.mode
&WAVE_16_BITS
) ? 1:0);
1668 sampp
->loopEndOffset
.Fraction
=0;
1669 sampp
->loopEndOffset
.Integer
=guspatch
.loop_end
1670 >>((guspatch
.mode
&WAVE_16_BITS
) ? 1:0);
1671 sampp
->sampleEndOffset
.Fraction
=0;
1672 sampp
->sampleEndOffset
.Integer
=guspatch
.len
>> (guspatch
.mode
&1);
1673 sampp
->Bidirectional
=(guspatch
.mode
&WAVE_BIDIR_LOOP
) ? 1:0;
1674 sampp
->Reverse
=(guspatch
.mode
&WAVE_LOOP_BACK
) ? 1:0;
1676 /* Now ship it down */
1678 wavefront_send_sample (&samp
,
1679 (unsigned short *) &(addr
)[sizeof_patch
],
1680 (guspatch
.mode
& WAVE_UNSIGNED
) ? 1:0);
1681 wavefront_send_patch (&pat
);
1682 wavefront_send_program (&prog
);
1684 /* Now pan as best we can ... use the slave/internal MIDI device
1685 number if it exists (since it talks to the WaveFront), or the
1690 if (dev
.mididev
> 0) {
1691 midi_synth_controller (dev
.mididev
, guspatch
.instr_no
, 10,
1692 ((guspatch
.panning
<< 4) > 127) ?
1693 127 : (guspatch
.panning
<< 4));
1701 wavefront_load_patch (const char *addr
)
1705 wavefront_patch_info header
;
1707 if (copy_from_user (&header
, addr
, sizeof(wavefront_patch_info
) -
1708 sizeof(wavefront_any
))) {
1709 printk (KERN_WARNING LOGNAME
"bad address for load patch.\n");
1713 DPRINT (WF_DEBUG_LOAD_PATCH
, "download "
1715 "Sample number: %d "
1716 "Sample size: %d\n",
1721 switch (header
.subkey
) {
1722 case WF_ST_SAMPLE
: /* sample or sample_header, based on patch->size */
1724 copy_from_user ((unsigned char *) &header
.hdr
.s
,
1725 (unsigned char *) header
.hdrptr
,
1726 sizeof (wavefront_sample
));
1728 return wavefront_send_sample (&header
, header
.dataptr
, 0);
1730 case WF_ST_MULTISAMPLE
:
1732 copy_from_user ((unsigned char *) &header
.hdr
.s
,
1733 (unsigned char *) header
.hdrptr
,
1734 sizeof (wavefront_multisample
));
1736 return wavefront_send_multisample (&header
);
1741 copy_from_user ((unsigned char *) &header
.hdr
.a
,
1742 (unsigned char *) header
.hdrptr
,
1743 sizeof (wavefront_alias
));
1745 return wavefront_send_alias (&header
);
1748 copy_from_user ((unsigned char *) &header
.hdr
.d
,
1749 (unsigned char *) header
.hdrptr
,
1750 sizeof (wavefront_drum
));
1752 return wavefront_send_drum (&header
);
1755 copy_from_user ((unsigned char *) &header
.hdr
.p
,
1756 (unsigned char *) header
.hdrptr
,
1757 sizeof (wavefront_patch
));
1759 return wavefront_send_patch (&header
);
1762 copy_from_user ((unsigned char *) &header
.hdr
.pr
,
1763 (unsigned char *) header
.hdrptr
,
1764 sizeof (wavefront_program
));
1766 return wavefront_send_program (&header
);
1769 printk (KERN_ERR LOGNAME
"unknown patch type %d.\n",
1777 /***********************************************************************
1778 WaveFront: /dev/sequencer{,2} and other hardware-dependent interfaces
1779 ***********************************************************************/
1782 process_sample_hdr (UCHAR8
*buf
)
1790 /* The board doesn't send us an exact copy of a "wavefront_sample"
1791 in response to an Upload Sample Header command. Instead, we
1792 have to convert the data format back into our data structure,
1793 just as in the Download Sample command, where we have to do
1794 something very similar in the reverse direction.
1797 *((UINT32
*) &s
.sampleStartOffset
) = demunge_int32 (ptr
, 4); ptr
+= 4;
1798 *((UINT32
*) &s
.loopStartOffset
) = demunge_int32 (ptr
, 4); ptr
+= 4;
1799 *((UINT32
*) &s
.loopEndOffset
) = demunge_int32 (ptr
, 4); ptr
+= 4;
1800 *((UINT32
*) &s
.sampleEndOffset
) = demunge_int32 (ptr
, 4); ptr
+= 4;
1801 *((UINT32
*) &s
.FrequencyBias
) = demunge_int32 (ptr
, 3); ptr
+= 3;
1803 s
.SampleResolution
= *ptr
& 0x3;
1804 s
.Loop
= *ptr
& 0x8;
1805 s
.Bidirectional
= *ptr
& 0x10;
1806 s
.Reverse
= *ptr
& 0x40;
1808 /* Now copy it back to where it came from */
1810 memcpy (buf
, (unsigned char *) &s
, sizeof (wavefront_sample
));
1814 wavefront_synth_control (int cmd
, wavefront_control
*wc
)
1817 unsigned char patchnumbuf
[2];
1820 DPRINT (WF_DEBUG_CMD
, "synth control with "
1821 "cmd 0x%x\n", wc
->cmd
);
1823 /* Pre-handling of or for various commands */
1826 case WFC_DISABLE_INTERRUPTS
:
1827 printk (KERN_INFO LOGNAME
"interrupts disabled.\n");
1828 outb (0x80|0x20, dev
.control_port
);
1829 dev
.interrupts_on
= 0;
1832 case WFC_ENABLE_INTERRUPTS
:
1833 printk (KERN_INFO LOGNAME
"interrupts enabled.\n");
1834 outb (0x80|0x40|0x20, dev
.control_port
);
1835 dev
.interrupts_on
= 1;
1838 case WFC_INTERRUPT_STATUS
:
1839 wc
->rbuf
[0] = dev
.interrupts_on
;
1842 case WFC_ROMSAMPLES_RDONLY
:
1843 dev
.rom_samples_rdonly
= wc
->wbuf
[0];
1847 case WFC_IDENTIFY_SLOT_TYPE
:
1848 i
= wc
->wbuf
[0] | (wc
->wbuf
[1] << 7);
1849 if (i
<0 || i
>= WF_MAX_SAMPLE
) {
1850 printk (KERN_WARNING LOGNAME
"invalid slot ID %d\n",
1852 wc
->status
= EINVAL
;
1855 wc
->rbuf
[0] = dev
.sample_status
[i
];
1859 case WFC_DEBUG_DRIVER
:
1860 dev
.debug
= wc
->wbuf
[0];
1861 printk (KERN_INFO LOGNAME
"debug = 0x%x\n", dev
.debug
);
1865 wffx_ioctl ((wavefront_fx_info
*) &wc
->wbuf
[0]);
1868 case WFC_UPLOAD_PATCH
:
1869 munge_int32 (*((UINT32
*) wc
->wbuf
), patchnumbuf
, 2);
1870 memcpy (wc
->wbuf
, patchnumbuf
, 2);
1873 case WFC_UPLOAD_MULTISAMPLE
:
1874 /* multisamples have to be handled differently, and
1875 cannot be dealt with properly by wavefront_cmd() alone.
1877 wc
->status
= wavefront_fetch_multisample
1878 ((wavefront_patch_info
*) wc
->rbuf
);
1881 case WFC_UPLOAD_SAMPLE_ALIAS
:
1882 printk (KERN_INFO LOGNAME
"support for sample alias upload "
1883 "being considered.\n");
1884 wc
->status
= EINVAL
;
1888 wc
->status
= wavefront_cmd (wc
->cmd
, wc
->rbuf
, wc
->wbuf
);
1890 /* Post-handling of certain commands.
1892 In particular, if the command was an upload, demunge the data
1893 so that the user-level doesn't have to think about it.
1896 if (wc
->status
== 0) {
1898 /* intercept any freemem requests so that we know
1899 we are always current with the user-level view
1903 case WFC_REPORT_FREE_MEMORY
:
1904 dev
.freemem
= demunge_int32 (wc
->rbuf
, 4);
1907 case WFC_UPLOAD_PATCH
:
1908 demunge_buf (wc
->rbuf
, wc
->rbuf
, WF_PATCH_BYTES
);
1911 case WFC_UPLOAD_PROGRAM
:
1912 demunge_buf (wc
->rbuf
, wc
->rbuf
, WF_PROGRAM_BYTES
);
1915 case WFC_UPLOAD_EDRUM_PROGRAM
:
1916 demunge_buf (wc
->rbuf
, wc
->rbuf
, WF_DRUM_BYTES
- 1);
1919 case WFC_UPLOAD_SAMPLE_HEADER
:
1920 process_sample_hdr (wc
->rbuf
);
1923 case WFC_UPLOAD_SAMPLE_ALIAS
:
1924 printk (KERN_INFO LOGNAME
"support for "
1925 "sample aliases still "
1926 "being considered.\n");
1930 if (virtual_midi_disable () < 0) {
1936 if (virtual_midi_enable () < 0) {
1947 /***********************************************************************/
1948 /* WaveFront: Linux file system interface (for access via raw synth) */
1949 /***********************************************************************/
1952 wavefront_llseek(struct file
*file
, loff_t offset
, int origin
)
1958 wavefront_open (struct inode
*inode
, struct file
*file
)
1961 dev
.opened
= file
->f_flags
;
1967 wavefront_release(struct inode
*inode
, struct file
*file
)
1976 wavefront_ioctl(struct inode
*inode
, struct file
*file
,
1977 unsigned int cmd
, unsigned long arg
)
1979 wavefront_control wc
;
1985 copy_from_user (&wc
, (void *) arg
, sizeof (wc
));
1987 if ((err
= wavefront_synth_control (cmd
, &wc
)) == 0) {
1988 copy_to_user ((void *) arg
, &wc
, sizeof (wc
));
1993 case WFCTL_LOAD_SPP
:
1994 return wavefront_load_patch ((const char *) arg
);
1997 printk (KERN_WARNING LOGNAME
"invalid ioctl %#x\n", cmd
);
2004 static /*const*/ struct file_operations wavefront_fops
= {
2017 NULL
, /* check_media_change */
2018 NULL
, /* revalidate */
2023 /***********************************************************************/
2024 /* WaveFront: OSS installation and support interface */
2025 /***********************************************************************/
2027 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2029 static struct synth_info wavefront_info
=
2030 {"Turtle Beach WaveFront", 0, SYNTH_TYPE_SAMPLE
, SAMPLE_TYPE_WAVEFRONT
,
2031 0, 32, 0, 0, SYNTH_CAP_INPUT
};
2034 wavefront_oss_open (int devno
, int mode
)
2042 wavefront_oss_close (int devno
)
2051 wavefront_oss_ioctl (int devno
, unsigned int cmd
, caddr_t arg
)
2054 wavefront_control wc
;
2058 case SNDCTL_SYNTH_INFO
:
2059 memcpy (&((char *) arg
)[0], &wavefront_info
,
2060 sizeof (wavefront_info
));
2064 case SNDCTL_SEQ_RESETSAMPLES
:
2065 printk (KERN_WARNING LOGNAME
"driver cannot reset samples.\n");
2066 return 0; /* don't force an error */
2069 case SNDCTL_SEQ_PERCMODE
:
2070 return 0; /* don't force an error */
2073 case SNDCTL_SYNTH_MEMAVL
:
2074 if ((dev
.freemem
= wavefront_freemem ()) < 0) {
2075 printk (KERN_ERR LOGNAME
"cannot get memory size\n");
2082 case SNDCTL_SYNTH_CONTROL
:
2083 copy_from_user (&wc
, arg
, sizeof (wc
));
2085 if ((err
= wavefront_synth_control (cmd
, &wc
)) == 0) {
2086 copy_to_user (arg
, &wc
, sizeof (wc
));
2097 wavefront_oss_load_patch (int devno
, int format
, const char *addr
,
2098 int offs
, int count
, int pmgr_flag
)
2101 if (format
== SYSEX_PATCH
) { /* Handled by midi_synth.c */
2102 if (midi_load_patch
== NULL
) {
2103 printk (KERN_ERR LOGNAME
2104 "SYSEX not loadable: "
2105 "no midi patch loader!\n");
2109 return midi_load_patch (devno
, format
, addr
,
2110 offs
, count
, pmgr_flag
);
2112 } else if (format
== GUS_PATCH
) {
2113 return wavefront_load_gus_patch (devno
, format
,
2114 addr
, offs
, count
, pmgr_flag
);
2116 } else if (format
!= WAVEFRONT_PATCH
) {
2117 printk (KERN_ERR LOGNAME
"unknown patch format %d\n", format
);
2121 if (count
< sizeof (wavefront_patch_info
)) {
2122 printk (KERN_ERR LOGNAME
"sample header too short\n");
2126 /* "addr" points to a user-space wavefront_patch_info */
2128 return wavefront_load_patch (addr
);
2131 static struct synth_operations wavefront_operations
=
2137 SAMPLE_TYPE_WAVEFRONT
,
2139 wavefront_oss_close
,
2140 wavefront_oss_ioctl
,
2142 midi_synth_kill_note
,
2143 midi_synth_start_note
,
2144 midi_synth_set_instr
,
2146 NULL
, /* hw_control */
2147 midi_synth_load_patch
,
2148 midi_synth_aftertouch
,
2149 midi_synth_controller
,
2151 NULL
, /* volume method */
2153 NULL
, /* alloc voice */
2154 midi_synth_setup_voice
2156 #endif OSS_SUPPORT_SEQ
2158 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_STATIC_INSTALL
2160 void attach_wavefront (struct address_info
*hw_config
)
2163 (void) install_wavefront ();
2166 int probe_wavefront (struct address_info
*hw_config
)
2169 return !detect_wavefront (hw_config
->irq
, hw_config
->io_base
);
2172 void unload_wavefront (struct address_info
*hw_config
)
2174 (void) uninstall_wavefront ();
2177 #endif OSS_SUPPORT_STATIC_INSTALL
2179 /***********************************************************************/
2180 /* WaveFront: Linux modular sound kernel installation interface */
2181 /***********************************************************************/
2184 wavefrontintr (int irq
, void *dev_id
, struct pt_regs
*dummy
)
2186 struct wf_config
*hw
= dev_id
;
2189 Some comments on interrupts. I attempted a version of this
2190 driver that used interrupts throughout the code instead of
2191 doing busy and/or sleep-waiting. Alas, it appears that once
2192 the Motorola firmware is downloaded, the card *never*
2193 generates an RX interrupt. These are successfully generated
2194 during firmware loading, and after that wavefront_status()
2195 reports that an interrupt is pending on the card from time
2196 to time, but it never seems to be delivered to this
2197 driver. Note also that wavefront_status() continues to
2198 report that RX interrupts are enabled, suggesting that I
2199 didn't goof up and disable them by mistake.
2201 Thus, I stepped back to a prior version of
2202 wavefront_wait(), the only place where this really
2203 matters. Its sad, but I've looked through the code to check
2204 on things, and I really feel certain that the Motorola
2205 firmware prevents RX-ready interrupts.
2208 if ((wavefront_status() & (STAT_INTR_READ
|STAT_INTR_WRITE
)) == 0) {
2214 wake_up_interruptible (&hw
->interrupt_sleeper
);
2219 0 Host Rx Interrupt Enable (1=Enabled)
2220 1 Host Rx Register Full (1=Full)
2221 2 Host Rx Interrupt Pending (1=Interrupt)
2223 4 Host Tx Interrupt (1=Enabled)
2224 5 Host Tx Register empty (1=Empty)
2225 6 Host Tx Interrupt Pending (1=Interrupt)
2230 wavefront_interrupt_bits (int irq
)
2250 printk (KERN_WARNING LOGNAME
"invalid IRQ %d\n", irq
);
2258 wavefront_should_cause_interrupt (int val
, int port
, int timeout
)
2261 unsigned long flags
;
2267 interruptible_sleep_on_timeout (&dev
.interrupt_sleeper
, timeout
);
2268 restore_flags (flags
);
2272 wavefront_hw_reset (void)
2277 unsigned long irq_mask
;
2280 /* IRQ already checked in init_module() */
2282 bits
= wavefront_interrupt_bits (dev
.irq
);
2284 printk (KERN_DEBUG LOGNAME
"autodetecting WaveFront IRQ\n");
2288 irq_mask
= probe_irq_on ();
2290 outb (0x0, dev
.control_port
);
2291 outb (0x80 | 0x40 | bits
, dev
.data_port
);
2292 wavefront_should_cause_interrupt(0x80|0x40|0x10|0x1,
2294 (reset_time
*HZ
)/100);
2296 reported_irq
= probe_irq_off (irq_mask
);
2298 if (reported_irq
!= dev
.irq
) {
2299 if (reported_irq
== 0) {
2300 printk (KERN_ERR LOGNAME
2301 "No unassigned interrupts detected "
2302 "after h/w reset\n");
2303 } else if (reported_irq
< 0) {
2304 printk (KERN_ERR LOGNAME
2305 "Multiple unassigned interrupts detected "
2306 "after h/w reset\n");
2308 printk (KERN_ERR LOGNAME
"autodetected IRQ %d not the "
2309 "value provided (%d)\n", reported_irq
,
2315 printk (KERN_INFO LOGNAME
"autodetected IRQ at %d\n",
2319 if (request_irq (dev
.irq
, wavefrontintr
,
2320 SA_INTERRUPT
|SA_SHIRQ
,
2321 "wavefront synth", &dev
) < 0) {
2322 printk (KERN_WARNING LOGNAME
"IRQ %d not available!\n",
2327 /* try reset of port */
2329 outb (0x0, dev
.control_port
);
2331 /* At this point, the board is in reset, and the H/W initialization
2332 register is accessed at the same address as the data port.
2334 Bit 7 - Enable IRQ Driver
2335 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
2336 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
2338 Bit 6 - MIDI Interface Select
2340 0 - Use the MIDI Input from the 26-pin WaveBlaster
2341 compatible header as the serial MIDI source
2342 1 - Use the MIDI Input from the 9-pin D connector as the
2345 Bits 5:3 - IRQ Selection
2356 Bit 0 - Disable Boot ROM
2357 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
2358 1 - memory accesses to 03FC30-03FFFFH are directed to external
2363 /* configure hardware: IRQ, enable interrupts,
2364 plus external 9-pin MIDI interface selected
2367 outb (0x80 | 0x40 | bits
, dev
.data_port
);
2371 0 Host Rx Interrupt Enable (1=Enabled) 0x1
2375 4 Host Tx Interrupt Enable 0x10
2376 5 Mute (0=Mute; 1=Play) 0x20
2377 6 Master Interrupt Enable (1=Enabled) 0x40
2378 7 Master Reset (0=Reset; 1=Run) 0x80
2380 Take us out of reset, mute output, master + TX + RX interrupts on.
2382 We'll get an interrupt presumably to tell us that the TX
2386 wavefront_should_cause_interrupt(0x80|0x40|0x10|0x1,
2388 (reset_time
*HZ
)/100);
2390 /* Note: data port is now the data port, not the h/w initialization
2395 printk (KERN_WARNING LOGNAME
2396 "intr not received after h/w un-reset.\n");
2400 dev
.interrupts_on
= 1;
2402 /* Note: data port is now the data port, not the h/w initialization
2405 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
2406 will work. So, issue one of them, and wait for TX
2407 interrupt. This can take a *long* time after a cold boot,
2408 while the ISC ROM does its RAM test. The SDK says up to 4
2409 seconds - with 12MB of RAM on a Tropez+, it takes a lot
2410 longer than that (~16secs). Note that the card understands
2411 the difference between a warm and a cold boot, so
2412 subsequent ISC2115 reboots (say, caused by module
2413 reloading) will get through this much faster.
2415 XXX Interesting question: why is no RX interrupt received first ?
2418 wavefront_should_cause_interrupt(WFC_HARDWARE_VERSION
,
2419 dev
.data_port
, ramcheck_time
*HZ
);
2422 printk (KERN_WARNING LOGNAME
2423 "post-RAM-check interrupt not received.\n");
2427 if (!wavefront_wait (STAT_CAN_READ
)) {
2428 printk (KERN_WARNING LOGNAME
2429 "no response to HW version cmd.\n");
2433 if ((hwv
[0] = wavefront_read ()) == -1) {
2434 printk (KERN_WARNING LOGNAME
2435 "board not responding correctly.\n");
2439 if (hwv
[0] == 0xFF) { /* NAK */
2441 /* Board's RAM test failed. Try to read error code,
2442 and tell us about it either way.
2445 if ((hwv
[0] = wavefront_read ()) == -1) {
2446 printk (KERN_WARNING LOGNAME
"on-board RAM test failed "
2447 "(bad error code).\n");
2449 printk (KERN_WARNING LOGNAME
"on-board RAM test failed "
2450 "(error code: 0x%x).\n",
2456 /* We're OK, just get the next byte of the HW version response */
2458 if ((hwv
[1] = wavefront_read ()) == -1) {
2459 printk (KERN_WARNING LOGNAME
"incorrect h/w response.\n");
2463 printk (KERN_INFO LOGNAME
"hardware version %d.%d\n",
2471 free_irq (dev
.irq
, &dev
);
2477 static int __init
detect_wavefront (int irq
, int io_base
)
2479 unsigned char rbuf
[4], wbuf
[4];
2481 /* TB docs say the device takes up 8 ports, but we know that
2482 if there is an FX device present (i.e. a Tropez+) it really
2486 if (check_region (io_base
, 16)) {
2487 printk (KERN_ERR LOGNAME
"IO address range 0x%x - 0x%x "
2488 "already in use - ignored\n", dev
.base
,
2496 dev
.debug
= debug_default
;
2497 dev
.interrupts_on
= 0;
2499 dev
.rom_samples_rdonly
= 1; /* XXX default lock on ROM sample slots */
2501 if (wavefront_cmd (WFC_FIRMWARE_VERSION
, rbuf
, wbuf
) == 0) {
2503 dev
.fw_version
[0] = rbuf
[0];
2504 dev
.fw_version
[1] = rbuf
[1];
2505 printk (KERN_INFO LOGNAME
2506 "firmware %d.%d already loaded.\n",
2509 /* check that a command actually works */
2511 if (wavefront_cmd (WFC_HARDWARE_VERSION
,
2513 dev
.hw_version
[0] = rbuf
[0];
2514 dev
.hw_version
[1] = rbuf
[1];
2516 printk (KERN_WARNING LOGNAME
"not raw, but no "
2517 "hardware version!\n");
2524 printk (KERN_INFO LOGNAME
2525 "reloading firmware anyway.\n");
2532 printk (KERN_INFO LOGNAME
2533 "no response to firmware probe, assume raw.\n");
2537 init_waitqueue_head (&dev
.interrupt_sleeper
);
2539 if (wavefront_hw_reset ()) {
2540 printk (KERN_WARNING LOGNAME
"hardware reset failed\n");
2544 /* Check for FX device, present only on Tropez+ */
2546 dev
.has_fx
= (detect_wffx () == 0);
2552 #define __KERNEL_SYSCALLS__
2553 #include <linux/fs.h>
2554 #include <linux/mm.h>
2555 #include <linux/malloc.h>
2556 #include <linux/unistd.h>
2557 #include <asm/uaccess.h>
2562 wavefront_download_firmware (char *path
)
2565 unsigned char section
[WF_SECTION_MAX
];
2566 char section_length
; /* yes, just a char; max value is WF_SECTION_MAX */
2567 int section_cnt_downloaded
= 0;
2573 /* This tries to be a bit cleverer than the stuff Alan Cox did for
2574 the generic sound firmware, in that it actually knows
2575 something about the structure of the Motorola firmware. In
2576 particular, it uses a version that has been stripped of the
2577 20K of useless header information, and had section lengths
2578 added, making it possible to load the entire OS without any
2579 [kv]malloc() activity, since the longest entity we ever read is
2580 42 bytes (well, WF_SECTION_MAX) long.
2586 if ((fd
= open (path
, 0, 0)) < 0) {
2587 printk (KERN_WARNING LOGNAME
"Unable to load \"%s\".\n",
2595 if ((x
= read (fd
, §ion_length
, sizeof (section_length
))) !=
2596 sizeof (section_length
)) {
2597 printk (KERN_ERR LOGNAME
"firmware read error.\n");
2601 if (section_length
== 0) {
2605 if (read (fd
, section
, section_length
) != section_length
) {
2606 printk (KERN_ERR LOGNAME
"firmware section "
2613 if (wavefront_write (WFC_DOWNLOAD_OS
)) {
2617 for (i
= 0; i
< section_length
; i
++) {
2618 if (wavefront_write (section
[i
])) {
2625 if (wavefront_wait (STAT_CAN_READ
)) {
2627 if ((c
= inb (dev
.data_port
)) != WF_ACK
) {
2629 printk (KERN_ERR LOGNAME
"download "
2630 "of section #%d not "
2631 "acknowledged, ack = 0x%x\n",
2632 section_cnt_downloaded
+ 1, c
);
2638 printk (KERN_ERR LOGNAME
"time out for firmware ACK.\n");
2651 printk (KERN_ERR
"\nWaveFront: firmware download failed!!!\n");
2655 static int __init
wavefront_config_midi (void)
2657 unsigned char rbuf
[4], wbuf
[4];
2659 if (detect_wf_mpu (dev
.irq
, dev
.base
) < 0) {
2660 printk (KERN_WARNING LOGNAME
2661 "could not find working MIDI device\n");
2665 if ((dev
.mididev
= install_wf_mpu ()) < 0) {
2666 printk (KERN_WARNING LOGNAME
2667 "MIDI interfaces not configured\n");
2671 /* Route external MIDI to WaveFront synth (by default) */
2673 if (wavefront_cmd (WFC_MISYNTH_ON
, rbuf
, wbuf
)) {
2674 printk (KERN_WARNING LOGNAME
2675 "cannot enable MIDI-IN to synth routing.\n");
2680 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2681 /* Get the regular MIDI patch loading function, so we can
2682 use it if we ever get handed a SYSEX patch. This is
2683 unlikely, because its so damn slow, but we may as well
2684 leave this functionality from maui.c behind, since it
2685 could be useful for sequencer applications that can
2686 only use MIDI to do patch loading.
2689 if (midi_devs
[dev
.mididev
]->converter
!= NULL
) {
2690 midi_load_patch
= midi_devs
[dev
.mididev
]->converter
->load_patch
;
2691 midi_devs
[dev
.mididev
]->converter
->load_patch
=
2692 &wavefront_oss_load_patch
;
2695 #endif OSS_SUPPORT_SEQ
2697 /* Turn on Virtual MIDI, but first *always* turn it off,
2698 since otherwise consectutive reloads of the driver will
2699 never cause the hardware to generate the initial "internal" or
2700 "external" source bytes in the MIDI data stream. This
2701 is pretty important, since the internal hardware generally will
2702 be used to generate none or very little MIDI output, and
2703 thus the only source of MIDI data is actually external. Without
2704 the switch bytes, the driver will think it all comes from
2705 the internal interface. Duh.
2708 if (wavefront_cmd (WFC_VMIDI_OFF
, rbuf
, wbuf
)) {
2709 printk (KERN_WARNING LOGNAME
2710 "virtual MIDI mode not disabled\n");
2711 return 0; /* We're OK, but missing the external MIDI dev */
2714 if ((dev
.ext_mididev
= virtual_midi_enable ()) < 0) {
2715 printk (KERN_WARNING LOGNAME
"no virtual MIDI access.\n");
2717 if (wavefront_cmd (WFC_VMIDI_ON
, rbuf
, wbuf
)) {
2718 printk (KERN_WARNING LOGNAME
2719 "cannot enable virtual MIDI mode.\n");
2720 virtual_midi_disable ();
2728 wavefront_do_reset (int atboot
)
2732 if (!atboot
&& wavefront_hw_reset ()) {
2733 printk (KERN_WARNING LOGNAME
"hw reset failed.\n");
2738 if (wavefront_download_firmware (ospath
)) {
2744 /* Wait for the OS to get running. The protocol for
2745 this is non-obvious, and was determined by
2746 using port-IO tracing in DOSemu and some
2747 experimentation here.
2749 Rather than using timed waits, use interrupts creatively.
2752 wavefront_should_cause_interrupt (WFC_NOOP
,
2757 printk (KERN_WARNING LOGNAME
2758 "no post-OS interrupt.\n");
2762 /* Now, do it again ! */
2764 wavefront_should_cause_interrupt (WFC_NOOP
,
2765 dev
.data_port
, (10*HZ
));
2768 printk (KERN_WARNING LOGNAME
2769 "no post-OS interrupt(2).\n");
2773 /* OK, no (RX/TX) interrupts any more, but leave mute
2777 outb (0x80|0x40, dev
.control_port
);
2779 /* No need for the IRQ anymore */
2781 free_irq (dev
.irq
, &dev
);
2785 if (dev
.has_fx
&& fx_raw
) {
2789 /* SETUPSND.EXE asks for sample memory config here, but since i
2790 have no idea how to interpret the result, we'll forget
2794 if ((dev
.freemem
= wavefront_freemem ()) < 0) {
2798 printk (KERN_INFO LOGNAME
"available DRAM %dk\n", dev
.freemem
/ 1024);
2800 if (wavefront_write (0xf0) ||
2801 wavefront_write (1) ||
2802 (wavefront_read () < 0)) {
2804 printk (KERN_WARNING LOGNAME
"MPU emulation mode not set.\n");
2810 if (wavefront_cmd (WFC_SET_NVOICES
, 0, voices
)) {
2811 printk (KERN_WARNING LOGNAME
2812 "cannot set number of voices to 32.\n");
2820 /* reset that sucker so that it doesn't bother us. */
2822 outb (0x0, dev
.control_port
);
2823 dev
.interrupts_on
= 0;
2825 free_irq (dev
.irq
, &dev
);
2831 wavefront_init (int atboot
)
2833 int samples_are_from_rom
;
2836 samples_are_from_rom
= 1;
2838 /* XXX is this always true ? */
2839 samples_are_from_rom
= 0;
2842 if (dev
.israw
|| fx_raw
) {
2843 if (wavefront_do_reset (atboot
)) {
2848 wavefront_get_sample_status (samples_are_from_rom
);
2849 wavefront_get_program_status ();
2850 wavefront_get_patch_status ();
2852 /* Start normal operation: unreset, master interrupt enabled, no mute
2855 outb (0x80|0x40|0x20, dev
.control_port
);
2860 static int __init
install_wavefront (void)
2863 if ((dev
.synth_dev
= register_sound_synth (&wavefront_fops
, -1)) < 0) {
2864 printk (KERN_ERR LOGNAME
"cannot register raw synth\n");
2868 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2869 if ((dev
.oss_dev
= sound_alloc_synthdev()) == -1) {
2870 printk (KERN_ERR LOGNAME
"Too many sequencers\n");
2873 synth_devs
[dev
.oss_dev
] = &wavefront_operations
;
2875 #endif OSS_SUPPORT_SEQ
2877 if (wavefront_init (1) < 0) {
2878 printk (KERN_WARNING LOGNAME
"initialization failed.\n");
2880 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2881 sound_unload_synthdev (dev
.oss_dev
);
2882 #endif OSS_SUPPORT_SEQ
2887 request_region (dev
.base
+2, 6, "wavefront synth");
2890 request_region (dev
.base
+8, 8, "wavefront fx");
2893 if (wavefront_config_midi ()) {
2894 printk (KERN_WARNING LOGNAME
"could not initialize MIDI.\n");
2901 uninstall_wavefront (void)
2904 /* the first two i/o addresses are freed by the wf_mpu code */
2905 release_region (dev
.base
+2, 6);
2908 release_region (dev
.base
+8, 8);
2911 unregister_sound_synth (dev
.synth_dev
);
2913 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2914 sound_unload_synthdev (dev
.oss_dev
);
2915 #endif OSS_SUPPORT_SEQ
2916 uninstall_wf_mpu ();
2919 /***********************************************************************/
2920 /* WaveFront FX control */
2921 /***********************************************************************/
2925 /* Control bits for the Load Control Register
2928 #define FX_LSB_TRANSFER 0x01 /* transfer after DSP LSB byte written */
2929 #define FX_MSB_TRANSFER 0x02 /* transfer after DSP MSB byte written */
2930 #define FX_AUTO_INCR 0x04 /* auto-increment DSP address after transfer */
2937 unsigned int x
= 0x80;
2939 for (i
= 0; i
< 1000; i
++) {
2940 x
= inb (dev
.fx_status
);
2941 if ((x
& 0x80) == 0) {
2947 printk (KERN_ERR LOGNAME
"FX device never idle.\n");
2954 static int __init
detect_wffx (void)
2956 /* This is a crude check, but its the best one I have for now.
2957 Certainly on the Maui and the Tropez, wffx_idle() will
2958 report "never idle", which suggests that this test should
2962 if (inb (dev
.fx_status
) & 0x80) {
2963 printk (KERN_INFO LOGNAME
"Hmm, probably a Maui or Tropez.\n");
2970 static int __init
attach_wffx (void)
2972 if ((dev
.fx_mididev
= sound_alloc_mididev ()) < 0) {
2973 printk (KERN_WARNING LOGNAME
"cannot install FX Midi driver\n");
2981 wffx_mute (int onoff
)
2988 outb (onoff
? 0x02 : 0x00, dev
.fx_op
);
2992 wffx_memset (int page
,
2993 int addr
, int cnt
, unsigned short *data
)
2995 if (page
< 0 || page
> 7) {
2996 printk (KERN_ERR LOGNAME
"FX memset: "
2997 "page must be >= 0 and <= 7\n");
3001 if (addr
< 0 || addr
> 0x7f) {
3002 printk (KERN_ERR LOGNAME
"FX memset: "
3003 "addr must be >= 0 and <= 7f\n");
3009 outb (FX_LSB_TRANSFER
, dev
.fx_lcr
);
3010 outb (page
, dev
.fx_dsp_page
);
3011 outb (addr
, dev
.fx_dsp_addr
);
3012 outb ((data
[0] >> 8), dev
.fx_dsp_msb
);
3013 outb ((data
[0] & 0xff), dev
.fx_dsp_lsb
);
3015 printk (KERN_INFO LOGNAME
"FX: addr %d:%x set to 0x%x\n",
3016 page
, addr
, data
[0]);
3021 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3022 outb (page
, dev
.fx_dsp_page
);
3023 outb (addr
, dev
.fx_dsp_addr
);
3025 for (i
= 0; i
< cnt
; i
++) {
3026 outb ((data
[i
] >> 8), dev
.fx_dsp_msb
);
3027 outb ((data
[i
] & 0xff), dev
.fx_dsp_lsb
);
3028 if (!wffx_idle ()) {
3034 printk (KERN_WARNING LOGNAME
3036 "(0x%x, 0x%x, 0x%x, %d) incomplete\n",
3037 page
, addr
, (int) data
, cnt
);
3046 wffx_ioctl (wavefront_fx_info
*r
)
3049 unsigned short page_data
[256];
3052 switch (r
->request
) {
3054 wffx_mute (r
->data
[0]);
3059 if (r
->data
[2] <= 0) {
3060 printk (KERN_ERR LOGNAME
"cannot write "
3061 "<= 0 bytes to FX\n");
3063 } else if (r
->data
[2] == 1) {
3064 pd
= (unsigned short *) &r
->data
[3];
3066 if (r
->data
[2] > sizeof (page_data
)) {
3067 printk (KERN_ERR LOGNAME
"cannot write "
3068 "> 255 bytes to FX\n");
3071 copy_from_user (page_data
, (unsigned char *) r
->data
[3],
3076 return wffx_memset (r
->data
[0], /* page */
3077 r
->data
[1], /* addr */
3078 r
->data
[2], /* cnt */
3082 printk (KERN_WARNING LOGNAME
3083 "FX: ioctl %d not yet supported\n",
3089 /* YSS225 initialization.
3091 This code was developed using DOSEMU. The Turtle Beach SETUPSND
3092 utility was run with I/O tracing in DOSEMU enabled, and a reconstruction
3093 of the port I/O done, using the Yamaha faxback document as a guide
3094 to add more logic to the code. Its really pretty wierd.
3096 There was an alternative approach of just dumping the whole I/O
3097 sequence as a series of port/value pairs and a simple loop
3098 that output it. However, I hope that eventually I'll get more
3099 control over what this code does, and so I tried to stick with
3100 a somewhat "algorithmic" approach.
3110 /* Set all bits for all channels on the MOD unit to zero */
3111 /* XXX But why do this twice ? */
3113 for (j
= 0; j
< 2; j
++) {
3114 for (i
= 0x10; i
<= 0xff; i
++) {
3116 if (!wffx_idle ()) {
3120 outb (i
, dev
.fx_mod_addr
);
3121 outb (0x0, dev
.fx_mod_data
);
3125 if (!wffx_idle()) return (-1);
3126 outb (0x02, dev
.fx_op
); /* mute on */
3128 if (!wffx_idle()) return (-1);
3129 outb (0x07, dev
.fx_dsp_page
);
3130 outb (0x44, dev
.fx_dsp_addr
);
3131 outb (0x00, dev
.fx_dsp_msb
);
3132 outb (0x00, dev
.fx_dsp_lsb
);
3133 if (!wffx_idle()) return (-1);
3134 outb (0x07, dev
.fx_dsp_page
);
3135 outb (0x42, dev
.fx_dsp_addr
);
3136 outb (0x00, dev
.fx_dsp_msb
);
3137 outb (0x00, dev
.fx_dsp_lsb
);
3138 if (!wffx_idle()) return (-1);
3139 outb (0x07, dev
.fx_dsp_page
);
3140 outb (0x43, dev
.fx_dsp_addr
);
3141 outb (0x00, dev
.fx_dsp_msb
);
3142 outb (0x00, dev
.fx_dsp_lsb
);
3143 if (!wffx_idle()) return (-1);
3144 outb (0x07, dev
.fx_dsp_page
);
3145 outb (0x7c, dev
.fx_dsp_addr
);
3146 outb (0x00, dev
.fx_dsp_msb
);
3147 outb (0x00, dev
.fx_dsp_lsb
);
3148 if (!wffx_idle()) return (-1);
3149 outb (0x07, dev
.fx_dsp_page
);
3150 outb (0x7e, dev
.fx_dsp_addr
);
3151 outb (0x00, dev
.fx_dsp_msb
);
3152 outb (0x00, dev
.fx_dsp_lsb
);
3153 if (!wffx_idle()) return (-1);
3154 outb (0x07, dev
.fx_dsp_page
);
3155 outb (0x46, dev
.fx_dsp_addr
);
3156 outb (0x00, dev
.fx_dsp_msb
);
3157 outb (0x00, dev
.fx_dsp_lsb
);
3158 if (!wffx_idle()) return (-1);
3159 outb (0x07, dev
.fx_dsp_page
);
3160 outb (0x49, dev
.fx_dsp_addr
);
3161 outb (0x00, dev
.fx_dsp_msb
);
3162 outb (0x00, dev
.fx_dsp_lsb
);
3163 if (!wffx_idle()) return (-1);
3164 outb (0x07, dev
.fx_dsp_page
);
3165 outb (0x47, dev
.fx_dsp_addr
);
3166 outb (0x00, dev
.fx_dsp_msb
);
3167 outb (0x00, dev
.fx_dsp_lsb
);
3168 if (!wffx_idle()) return (-1);
3169 outb (0x07, dev
.fx_dsp_page
);
3170 outb (0x4a, dev
.fx_dsp_addr
);
3171 outb (0x00, dev
.fx_dsp_msb
);
3172 outb (0x00, dev
.fx_dsp_lsb
);
3174 /* either because of stupidity by TB's programmers, or because it
3175 actually does something, rezero the MOD page.
3177 for (i
= 0x10; i
<= 0xff; i
++) {
3179 if (!wffx_idle ()) {
3183 outb (i
, dev
.fx_mod_addr
);
3184 outb (0x0, dev
.fx_mod_data
);
3186 /* load page zero */
3188 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3189 outb (0x00, dev
.fx_dsp_page
);
3190 outb (0x00, dev
.fx_dsp_addr
);
3192 for (i
= 0; i
< sizeof (page_zero
); i
+= 2) {
3193 outb (page_zero
[i
], dev
.fx_dsp_msb
);
3194 outb (page_zero
[i
+1], dev
.fx_dsp_lsb
);
3195 if (!wffx_idle()) return (-1);
3198 /* Now load page one */
3200 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3201 outb (0x01, dev
.fx_dsp_page
);
3202 outb (0x00, dev
.fx_dsp_addr
);
3204 for (i
= 0; i
< sizeof (page_one
); i
+= 2) {
3205 outb (page_one
[i
], dev
.fx_dsp_msb
);
3206 outb (page_one
[i
+1], dev
.fx_dsp_lsb
);
3207 if (!wffx_idle()) return (-1);
3210 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3211 outb (0x02, dev
.fx_dsp_page
);
3212 outb (0x00, dev
.fx_dsp_addr
);
3214 for (i
= 0; i
< sizeof (page_two
); i
++) {
3215 outb (page_two
[i
], dev
.fx_dsp_lsb
);
3216 if (!wffx_idle()) return (-1);
3219 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3220 outb (0x03, dev
.fx_dsp_page
);
3221 outb (0x00, dev
.fx_dsp_addr
);
3223 for (i
= 0; i
< sizeof (page_three
); i
++) {
3224 outb (page_three
[i
], dev
.fx_dsp_lsb
);
3225 if (!wffx_idle()) return (-1);
3228 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3229 outb (0x04, dev
.fx_dsp_page
);
3230 outb (0x00, dev
.fx_dsp_addr
);
3232 for (i
= 0; i
< sizeof (page_four
); i
++) {
3233 outb (page_four
[i
], dev
.fx_dsp_lsb
);
3234 if (!wffx_idle()) return (-1);
3237 /* Load memory area (page six) */
3239 outb (FX_LSB_TRANSFER
, dev
.fx_lcr
);
3240 outb (0x06, dev
.fx_dsp_page
);
3242 for (i
= 0; i
< sizeof (page_six
); i
+= 3) {
3243 outb (page_six
[i
], dev
.fx_dsp_addr
);
3244 outb (page_six
[i
+1], dev
.fx_dsp_msb
);
3245 outb (page_six
[i
+2], dev
.fx_dsp_lsb
);
3246 if (!wffx_idle()) return (-1);
3249 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3250 outb (0x07, dev
.fx_dsp_page
);
3251 outb (0x00, dev
.fx_dsp_addr
);
3253 for (i
= 0; i
< sizeof (page_seven
); i
+= 2) {
3254 outb (page_seven
[i
], dev
.fx_dsp_msb
);
3255 outb (page_seven
[i
+1], dev
.fx_dsp_lsb
);
3256 if (!wffx_idle()) return (-1);
3259 /* Now setup the MOD area. We do this algorithmically in order to
3260 save a little data space. It could be done in the same fashion
3264 for (i
= 0x00; i
<= 0x0f; i
++) {
3265 outb (0x01, dev
.fx_mod_addr
);
3266 outb (i
, dev
.fx_mod_data
);
3267 if (!wffx_idle()) return (-1);
3268 outb (0x02, dev
.fx_mod_addr
);
3269 outb (0x00, dev
.fx_mod_data
);
3270 if (!wffx_idle()) return (-1);
3273 for (i
= 0xb0; i
<= 0xbf; i
++) {
3274 outb (i
, dev
.fx_mod_addr
);
3275 outb (0x20, dev
.fx_mod_data
);
3276 if (!wffx_idle()) return (-1);
3279 for (i
= 0xf0; i
<= 0xff; i
++) {
3280 outb (i
, dev
.fx_mod_addr
);
3281 outb (0x20, dev
.fx_mod_data
);
3282 if (!wffx_idle()) return (-1);
3285 for (i
= 0x10; i
<= 0x1d; i
++) {
3286 outb (i
, dev
.fx_mod_addr
);
3287 outb (0xff, dev
.fx_mod_data
);
3288 if (!wffx_idle()) return (-1);
3291 outb (0x1e, dev
.fx_mod_addr
);
3292 outb (0x40, dev
.fx_mod_data
);
3293 if (!wffx_idle()) return (-1);
3295 for (i
= 0x1f; i
<= 0x2d; i
++) {
3296 outb (i
, dev
.fx_mod_addr
);
3297 outb (0xff, dev
.fx_mod_data
);
3298 if (!wffx_idle()) return (-1);
3301 outb (0x2e, dev
.fx_mod_addr
);
3302 outb (0x00, dev
.fx_mod_data
);
3303 if (!wffx_idle()) return (-1);
3305 for (i
= 0x2f; i
<= 0x3e; i
++) {
3306 outb (i
, dev
.fx_mod_addr
);
3307 outb (0x00, dev
.fx_mod_data
);
3308 if (!wffx_idle()) return (-1);
3311 outb (0x3f, dev
.fx_mod_addr
);
3312 outb (0x20, dev
.fx_mod_data
);
3313 if (!wffx_idle()) return (-1);
3315 for (i
= 0x40; i
<= 0x4d; i
++) {
3316 outb (i
, dev
.fx_mod_addr
);
3317 outb (0x00, dev
.fx_mod_data
);
3318 if (!wffx_idle()) return (-1);
3321 outb (0x4e, dev
.fx_mod_addr
);
3322 outb (0x0e, dev
.fx_mod_data
);
3323 if (!wffx_idle()) return (-1);
3324 outb (0x4f, dev
.fx_mod_addr
);
3325 outb (0x0e, dev
.fx_mod_data
);
3326 if (!wffx_idle()) return (-1);
3329 for (i
= 0x50; i
<= 0x6b; i
++) {
3330 outb (i
, dev
.fx_mod_addr
);
3331 outb (0x00, dev
.fx_mod_data
);
3332 if (!wffx_idle()) return (-1);
3335 outb (0x6c, dev
.fx_mod_addr
);
3336 outb (0x40, dev
.fx_mod_data
);
3337 if (!wffx_idle()) return (-1);
3339 outb (0x6d, dev
.fx_mod_addr
);
3340 outb (0x00, dev
.fx_mod_data
);
3341 if (!wffx_idle()) return (-1);
3343 outb (0x6e, dev
.fx_mod_addr
);
3344 outb (0x40, dev
.fx_mod_data
);
3345 if (!wffx_idle()) return (-1);
3347 outb (0x6f, dev
.fx_mod_addr
);
3348 outb (0x40, dev
.fx_mod_data
);
3349 if (!wffx_idle()) return (-1);
3351 for (i
= 0x70; i
<= 0x7f; i
++) {
3352 outb (i
, dev
.fx_mod_addr
);
3353 outb (0xc0, dev
.fx_mod_data
);
3354 if (!wffx_idle()) return (-1);
3357 for (i
= 0x80; i
<= 0xaf; i
++) {
3358 outb (i
, dev
.fx_mod_addr
);
3359 outb (0x00, dev
.fx_mod_data
);
3360 if (!wffx_idle()) return (-1);
3363 for (i
= 0xc0; i
<= 0xdd; i
++) {
3364 outb (i
, dev
.fx_mod_addr
);
3365 outb (0x00, dev
.fx_mod_data
);
3366 if (!wffx_idle()) return (-1);
3369 outb (0xde, dev
.fx_mod_addr
);
3370 outb (0x10, dev
.fx_mod_data
);
3371 if (!wffx_idle()) return (-1);
3372 outb (0xdf, dev
.fx_mod_addr
);
3373 outb (0x10, dev
.fx_mod_data
);
3374 if (!wffx_idle()) return (-1);
3376 for (i
= 0xe0; i
<= 0xef; i
++) {
3377 outb (i
, dev
.fx_mod_addr
);
3378 outb (0x00, dev
.fx_mod_data
);
3379 if (!wffx_idle()) return (-1);
3382 for (i
= 0x00; i
<= 0x0f; i
++) {
3383 outb (0x01, dev
.fx_mod_addr
);
3384 outb (i
, dev
.fx_mod_data
);
3385 outb (0x02, dev
.fx_mod_addr
);
3386 outb (0x01, dev
.fx_mod_data
);
3387 if (!wffx_idle()) return (-1);
3390 outb (0x02, dev
.fx_op
); /* mute on */
3392 /* Now set the coefficients and so forth for the programs above */
3394 for (i
= 0; i
< sizeof (coefficients
); i
+= 4) {
3395 outb (coefficients
[i
], dev
.fx_dsp_page
);
3396 outb (coefficients
[i
+1], dev
.fx_dsp_addr
);
3397 outb (coefficients
[i
+2], dev
.fx_dsp_msb
);
3398 outb (coefficients
[i
+3], dev
.fx_dsp_lsb
);
3399 if (!wffx_idle()) return (-1);
3402 /* Some settings (?) that are too small to bundle into loops */
3404 if (!wffx_idle()) return (-1);
3405 outb (0x1e, dev
.fx_mod_addr
);
3406 outb (0x14, dev
.fx_mod_data
);
3407 if (!wffx_idle()) return (-1);
3408 outb (0xde, dev
.fx_mod_addr
);
3409 outb (0x20, dev
.fx_mod_data
);
3410 if (!wffx_idle()) return (-1);
3411 outb (0xdf, dev
.fx_mod_addr
);
3412 outb (0x20, dev
.fx_mod_data
);
3414 /* some more coefficients */
3416 if (!wffx_idle()) return (-1);
3417 outb (0x06, dev
.fx_dsp_page
);
3418 outb (0x78, dev
.fx_dsp_addr
);
3419 outb (0x00, dev
.fx_dsp_msb
);
3420 outb (0x40, dev
.fx_dsp_lsb
);
3421 if (!wffx_idle()) return (-1);
3422 outb (0x07, dev
.fx_dsp_page
);
3423 outb (0x03, dev
.fx_dsp_addr
);
3424 outb (0x0f, dev
.fx_dsp_msb
);
3425 outb (0xff, dev
.fx_dsp_lsb
);
3426 if (!wffx_idle()) return (-1);
3427 outb (0x07, dev
.fx_dsp_page
);
3428 outb (0x0b, dev
.fx_dsp_addr
);
3429 outb (0x0f, dev
.fx_dsp_msb
);
3430 outb (0xff, dev
.fx_dsp_lsb
);
3431 if (!wffx_idle()) return (-1);
3432 outb (0x07, dev
.fx_dsp_page
);
3433 outb (0x02, dev
.fx_dsp_addr
);
3434 outb (0x00, dev
.fx_dsp_msb
);
3435 outb (0x00, dev
.fx_dsp_lsb
);
3436 if (!wffx_idle()) return (-1);
3437 outb (0x07, dev
.fx_dsp_page
);
3438 outb (0x0a, dev
.fx_dsp_addr
);
3439 outb (0x00, dev
.fx_dsp_msb
);
3440 outb (0x00, dev
.fx_dsp_lsb
);
3441 if (!wffx_idle()) return (-1);
3442 outb (0x07, dev
.fx_dsp_page
);
3443 outb (0x46, dev
.fx_dsp_addr
);
3444 outb (0x00, dev
.fx_dsp_msb
);
3445 outb (0x00, dev
.fx_dsp_lsb
);
3446 if (!wffx_idle()) return (-1);
3447 outb (0x07, dev
.fx_dsp_page
);
3448 outb (0x49, dev
.fx_dsp_addr
);
3449 outb (0x00, dev
.fx_dsp_msb
);
3450 outb (0x00, dev
.fx_dsp_lsb
);
3452 /* Now, for some strange reason, lets reload every page
3453 and all the coefficients over again. I have *NO* idea
3454 why this is done. I do know that no sound is produced
3455 is this phase is omitted.
3458 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3459 outb (0x00, dev
.fx_dsp_page
);
3460 outb (0x10, dev
.fx_dsp_addr
);
3462 for (i
= 0; i
< sizeof (page_zero_v2
); i
+= 2) {
3463 outb (page_zero_v2
[i
], dev
.fx_dsp_msb
);
3464 outb (page_zero_v2
[i
+1], dev
.fx_dsp_lsb
);
3465 if (!wffx_idle()) return (-1);
3468 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3469 outb (0x01, dev
.fx_dsp_page
);
3470 outb (0x10, dev
.fx_dsp_addr
);
3472 for (i
= 0; i
< sizeof (page_one_v2
); i
+= 2) {
3473 outb (page_one_v2
[i
], dev
.fx_dsp_msb
);
3474 outb (page_one_v2
[i
+1], dev
.fx_dsp_lsb
);
3475 if (!wffx_idle()) return (-1);
3478 if (!wffx_idle()) return (-1);
3479 if (!wffx_idle()) return (-1);
3481 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3482 outb (0x02, dev
.fx_dsp_page
);
3483 outb (0x10, dev
.fx_dsp_addr
);
3485 for (i
= 0; i
< sizeof (page_two_v2
); i
++) {
3486 outb (page_two_v2
[i
], dev
.fx_dsp_lsb
);
3487 if (!wffx_idle()) return (-1);
3489 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3490 outb (0x03, dev
.fx_dsp_page
);
3491 outb (0x10, dev
.fx_dsp_addr
);
3493 for (i
= 0; i
< sizeof (page_three_v2
); i
++) {
3494 outb (page_three_v2
[i
], dev
.fx_dsp_lsb
);
3495 if (!wffx_idle()) return (-1);
3498 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3499 outb (0x04, dev
.fx_dsp_page
);
3500 outb (0x10, dev
.fx_dsp_addr
);
3502 for (i
= 0; i
< sizeof (page_four_v2
); i
++) {
3503 outb (page_four_v2
[i
], dev
.fx_dsp_lsb
);
3504 if (!wffx_idle()) return (-1);
3507 outb (FX_LSB_TRANSFER
, dev
.fx_lcr
);
3508 outb (0x06, dev
.fx_dsp_page
);
3510 /* Page six v.2 is algorithmic */
3512 for (i
= 0x10; i
<= 0x3e; i
+= 2) {
3513 outb (i
, dev
.fx_dsp_addr
);
3514 outb (0x00, dev
.fx_dsp_msb
);
3515 outb (0x00, dev
.fx_dsp_lsb
);
3516 if (!wffx_idle()) return (-1);
3519 outb (FX_AUTO_INCR
|FX_LSB_TRANSFER
, dev
.fx_lcr
);
3520 outb (0x07, dev
.fx_dsp_page
);
3521 outb (0x10, dev
.fx_dsp_addr
);
3523 for (i
= 0; i
< sizeof (page_seven_v2
); i
+= 2) {
3524 outb (page_seven_v2
[i
], dev
.fx_dsp_msb
);
3525 outb (page_seven_v2
[i
+1], dev
.fx_dsp_lsb
);
3526 if (!wffx_idle()) return (-1);
3529 for (i
= 0x00; i
< sizeof(mod_v2
); i
+= 2) {
3530 outb (mod_v2
[i
], dev
.fx_mod_addr
);
3531 outb (mod_v2
[i
+1], dev
.fx_mod_data
);
3532 if (!wffx_idle()) return (-1);
3535 for (i
= 0; i
< sizeof (coefficients2
); i
+= 4) {
3536 outb (coefficients2
[i
], dev
.fx_dsp_page
);
3537 outb (coefficients2
[i
+1], dev
.fx_dsp_addr
);
3538 outb (coefficients2
[i
+2], dev
.fx_dsp_msb
);
3539 outb (coefficients2
[i
+3], dev
.fx_dsp_lsb
);
3540 if (!wffx_idle()) return (-1);
3543 for (i
= 0; i
< sizeof (coefficients3
); i
+= 2) {
3546 outb (0x07, dev
.fx_dsp_page
);
3547 x
= (i
% 4) ? 0x4e : 0x4c;
3548 outb (x
, dev
.fx_dsp_addr
);
3549 outb (coefficients3
[i
], dev
.fx_dsp_msb
);
3550 outb (coefficients3
[i
+1], dev
.fx_dsp_lsb
);
3553 outb (0x00, dev
.fx_op
); /* mute off */
3554 if (!wffx_idle()) return (-1);
3564 MODULE_AUTHOR ("Paul Barton-Davis <pbd@op.net>");
3565 MODULE_DESCRIPTION ("Turtle Beach WaveFront Linux Driver");
3566 MODULE_PARM (io
,"i");
3567 MODULE_PARM (irq
,"i");
3569 int init_module (void)
3572 printk ("Turtle Beach WaveFront Driver\n"
3573 "Copyright (C) by Hannu Solvainen, "
3574 "Paul Barton-Davis 1993-1998.\n");
3576 /* XXX t'would be lovely to ask the CS4232 for these values, eh ? */
3578 if (io
== -1 || irq
== -1) {
3579 printk (KERN_INFO LOGNAME
"irq and io options must be set.\n");
3583 if (wavefront_interrupt_bits (irq
) < 0) {
3584 printk (KERN_INFO LOGNAME
3585 "IRQ must be 9, 5, 12 or 15 (not %d)\n", irq
);
3589 if (detect_wavefront (irq
, io
) < 0) {
3593 if (install_wavefront () < 0) {
3601 void cleanup_module (void)
3604 uninstall_wavefront ();
3609 #endif CONFIG_SOUND_WAVEFRONT_MODULE && MODULE