1 /* -*- linux-c -*-
2 *
3 * sound/wavfront.c
4 *
5 * A Linux driver for Turtle Beach WaveFront Series (Maui, Tropez, Tropez Plus)
6 *
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.
12 *
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
15 * wf_midi.c.
16 *
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.
24 *
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.
28 *
29 *
30 * Supported devices:
31 *
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
35 *
36 **********************************************************************
37 *
38 * Copyright (C) by Paul Barton-Davis 1998
39 *
40 * Some portions of this file are taken from work that is
41 * copyright (C) by Hannu Savolainen 1993-1996
42 *
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.
49 *
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.
52 *
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
57 * effects processor.
58 *
59 * $Id: wavfront.c,v 0.7 1998/09/09 15:47:36 pbd Exp $
60 *
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
63 * for more info.
64 *
65 * Changes:
66 * 11-10-2000 Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
67 * Added some __init and __initdata to entries in yss225.c
68 */
69
70 #include <linux/module.h>
71
72 #include <linux/kernel.h>
73 #include <linux/init.h>
74 #include <linux/sched.h>
75 #include <linux/smp_lock.h>
76 #include <linux/ptrace.h>
77 #include <linux/fcntl.h>
78 #include <linux/syscalls.h>
79 #include <linux/ioport.h>
80 #include <linux/spinlock.h>
81 #include <linux/interrupt.h>
82 #include <linux/config.h>
83
84 #include <linux/delay.h>
85
86 #include "sound_config.h"
87
88 #include <linux/wavefront.h>
89
90 #define _MIDI_SYNTH_C_
91 #define MIDI_SYNTH_NAME "WaveFront MIDI"
92 #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
93 #include "midi_synth.h"
94
95 /* Compile-time control of the extent to which OSS is supported.
96
97 I consider /dev/sequencer to be an anachronism, but given its
98 widespread usage by various Linux MIDI software, it seems worth
99 offering support to it if it's not too painful. Instead of using
100 /dev/sequencer, I recommend:
101
102 for synth programming and patch loading: /dev/synthNN
103 for kernel-synchronized MIDI sequencing: the ALSA sequencer
104 for direct MIDI control: /dev/midiNN
105
106 I have never tried static compilation into the kernel. The #if's
107 for this are really just notes to myself about what the code is
108 for.
109 */
110
111 #define OSS_SUPPORT_SEQ 0x1 /* use of /dev/sequencer */
112 #define OSS_SUPPORT_STATIC_INSTALL 0x2 /* static compilation into kernel */
113
114 #define OSS_SUPPORT_LEVEL 0x1 /* just /dev/sequencer for now */
115
116 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
117 static int (*midi_load_patch) (int devno, int format, const char __user *addr,
118 int offs, int count, int pmgr_flag) = NULL;
119 #endif /* OSS_SUPPORT_SEQ */
120
121 /* if WF_DEBUG not defined, no run-time debugging messages will
122 be available via the debug flag setting. Given the current
123 beta state of the driver, this will remain set until a future
124 version.
125 */
126
127 #define WF_DEBUG 1
128
129 #ifdef WF_DEBUG
130
131 /* Thank goodness for gcc's preprocessor ... */
132
133 #define DPRINT(cond, format, args...) \
134 if ((dev.debug & (cond)) == (cond)) { \
135 printk (KERN_DEBUG LOGNAME format, ## args); \
136 }
137 #else
138 #define DPRINT(cond, format, args...)
139 #endif
140
141 #define LOGNAME "WaveFront: "
142
143 /* bitmasks for WaveFront status port value */
144
145 #define STAT_RINTR_ENABLED 0x01
146 #define STAT_CAN_READ 0x02
147 #define STAT_INTR_READ 0x04
148 #define STAT_WINTR_ENABLED 0x10
149 #define STAT_CAN_WRITE 0x20
150 #define STAT_INTR_WRITE 0x40
151
152 /*** Module-accessible parameters ***************************************/
153
154 int wf_raw; /* we normally check for "raw state" to firmware
155 loading. if set, then during driver loading, the
156 state of the board is ignored, and we reset the
157 board and load the firmware anyway.
158 */
159
160 static int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
161 whatever state it is when the driver is loaded.
162 The default is to download the microprogram and
163 associated coefficients to set it up for "default"
164 operation, whatever that means.
165 */
166
167 static int debug_default; /* you can set this to control debugging
168 during driver loading. it takes any combination
169 of the WF_DEBUG_* flags defined in
170 wavefront.h
171 */
172
173 /* XXX this needs to be made firmware and hardware version dependent */
174
175 static char *ospath = "/etc/sound/wavefront.os"; /* where to find a processed
176 version of the WaveFront OS
177 */
178
179 static int wait_polls = 2000; /* This is a number of tries we poll the
180 status register before resorting to sleeping.
181 WaveFront being an ISA card each poll takes
182 about 1.2us. So before going to
183 sleep we wait up to 2.4ms in a loop.
184 */
185
186 static int sleep_length = HZ/100; /* This says how long we're going to
187 sleep between polls.
188 10ms sounds reasonable for fast response.
189 */
190
191 static int sleep_tries = 50; /* Wait for status 0.5 seconds total. */
192
193 static int reset_time = 2; /* hundreths of a second we wait after a HW reset for
194 the expected interrupt.
195 */
196
197 static int ramcheck_time = 20; /* time in seconds to wait while ROM code
198 checks on-board RAM.
199 */
200
201 static int osrun_time = 10; /* time in seconds we wait for the OS to
202 start running.
203 */
204
205 module_param(wf_raw, int, 0);
206 module_param(fx_raw, int, 0);
207 module_param(debug_default, int, 0);
208 module_param(wait_polls, int, 0);
209 module_param(sleep_length, int, 0);
210 module_param(sleep_tries, int, 0);
211 module_param(ospath, charp, 0);
212 module_param(reset_time, int, 0);
213 module_param(ramcheck_time, int, 0);
214 module_param(osrun_time, int, 0);
215
216 /***************************************************************************/
217
218 /* Note: because this module doesn't export any symbols, this really isn't
219 a global variable, even if it looks like one. I was quite confused by
220 this when I started writing this as a (newer) module -- pbd.
221 */
222
223 struct wf_config {
224 int devno; /* device number from kernel */
225 int irq; /* "you were one, one of the few ..." */
226 int base; /* low i/o port address */
227
228 #define mpu_data_port base
229 #define mpu_command_port base + 1 /* write semantics */
230 #define mpu_status_port base + 1 /* read semantics */
231 #define data_port base + 2
232 #define status_port base + 3 /* read semantics */
233 #define control_port base + 3 /* write semantics */
234 #define block_port base + 4 /* 16 bit, writeonly */
235 #define last_block_port base + 6 /* 16 bit, writeonly */
236
237 /* FX ports. These are mapped through the ICS2115 to the YS225.
238 The ICS2115 takes care of flipping the relevant pins on the
239 YS225 so that access to each of these ports does the right
240 thing. Note: these are NOT documented by Turtle Beach.
241 */
242
243 #define fx_status base + 8
244 #define fx_op base + 8
245 #define fx_lcr base + 9
246 #define fx_dsp_addr base + 0xa
247 #define fx_dsp_page base + 0xb
248 #define fx_dsp_lsb base + 0xc
249 #define fx_dsp_msb base + 0xd
250 #define fx_mod_addr base + 0xe
251 #define fx_mod_data base + 0xf
252
253 volatile int irq_ok; /* set by interrupt handler */
254 volatile int irq_cnt; /* ditto */
255 int opened; /* flag, holds open(2) mode */
256 char debug; /* debugging flags */
257 int freemem; /* installed RAM, in bytes */
258
259 int synth_dev; /* devno for "raw" synth */
260 int mididev; /* devno for internal MIDI */
261 int ext_mididev; /* devno for external MIDI */
262 int fx_mididev; /* devno for FX MIDI interface */
263 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
264 int oss_dev; /* devno for OSS sequencer synth */
265 #endif /* OSS_SUPPORT_SEQ */
266
267 char fw_version[2]; /* major = [0], minor = [1] */
268 char hw_version[2]; /* major = [0], minor = [1] */
269 char israw; /* needs Motorola microcode */
270 char has_fx; /* has FX processor (Tropez+) */
271 char prog_status[WF_MAX_PROGRAM]; /* WF_SLOT_* */
272 char patch_status[WF_MAX_PATCH]; /* WF_SLOT_* */
273 char sample_status[WF_MAX_SAMPLE]; /* WF_ST_* | WF_SLOT_* */
274 int samples_used; /* how many */
275 char interrupts_on; /* h/w MPU interrupts enabled ? */
276 char rom_samples_rdonly; /* can we write on ROM samples */
277 wait_queue_head_t interrupt_sleeper;
278 } dev;
279
280 static DEFINE_SPINLOCK(lock);
281 static int detect_wffx(void);
282 static int wffx_ioctl (wavefront_fx_info *);
283 static int wffx_init (void);
284
285 static int wavefront_delete_sample (int sampnum);
286 static int wavefront_find_free_sample (void);
287
288 /* From wf_midi.c */
289
290 extern int virtual_midi_enable (void);
291 extern int virtual_midi_disable (void);
292 extern int detect_wf_mpu (int, int);
293 extern int install_wf_mpu (void);
294 extern int uninstall_wf_mpu (void);
295
296 typedef struct {
297 int cmd;
298 char *action;
299 unsigned int read_cnt;
300 unsigned int write_cnt;
301 int need_ack;
302 } wavefront_command;
303
304 static struct {
305 int errno;
306 const char *errstr;
307 } wavefront_errors[] = {
308 { 0x01, "Bad sample number" },
309 { 0x02, "Out of sample memory" },
310 { 0x03, "Bad patch number" },
311 { 0x04, "Error in number of voices" },
312 { 0x06, "Sample load already in progress" },
313 { 0x0B, "No sample load request pending" },
314 { 0x0E, "Bad MIDI channel number" },
315 { 0x10, "Download Record Error" },
316 { 0x80, "Success" },
317 { 0 }
318 };
319
320 #define NEEDS_ACK 1
321
322 static wavefront_command wavefront_commands[] = {
323 { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK },
324 { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0},
325 { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK },
326 { WFC_GET_NVOICES, "get number of voices", 1, 0, 0 },
327 { WFC_SET_TUNING, "set synthesizer tuning", 0, 2, NEEDS_ACK },
328 { WFC_GET_TUNING, "get synthesizer tuning", 2, 0, 0 },
329 { WFC_DISABLE_CHANNEL, "disable synth channel", 0, 1, NEEDS_ACK },
330 { WFC_ENABLE_CHANNEL, "enable synth channel", 0, 1, NEEDS_ACK },
331 { WFC_GET_CHANNEL_STATUS, "get synth channel status", 3, 0, 0 },
332 { WFC_MISYNTH_OFF, "disable midi-in to synth", 0, 0, NEEDS_ACK },
333 { WFC_MISYNTH_ON, "enable midi-in to synth", 0, 0, NEEDS_ACK },
334 { WFC_VMIDI_ON, "enable virtual midi mode", 0, 0, NEEDS_ACK },
335 { WFC_VMIDI_OFF, "disable virtual midi mode", 0, 0, NEEDS_ACK },
336 { WFC_MIDI_STATUS, "report midi status", 1, 0, 0 },
337 { WFC_FIRMWARE_VERSION, "report firmware version", 2, 0, 0 },
338 { WFC_HARDWARE_VERSION, "report hardware version", 2, 0, 0 },
339 { WFC_GET_NSAMPLES, "report number of samples", 2, 0, 0 },
340 { WFC_INSTOUT_LEVELS, "report instantaneous output levels", 7, 0, 0 },
341 { WFC_PEAKOUT_LEVELS, "report peak output levels", 7, 0, 0 },
342 { WFC_DOWNLOAD_SAMPLE, "download sample",
343 0, WF_SAMPLE_BYTES, NEEDS_ACK },
344 { WFC_DOWNLOAD_BLOCK, "download block", 0, 0, NEEDS_ACK},
345 { WFC_DOWNLOAD_SAMPLE_HEADER, "download sample header",
346 0, WF_SAMPLE_HDR_BYTES, NEEDS_ACK },
347 { WFC_UPLOAD_SAMPLE_HEADER, "upload sample header", 13, 2, 0 },
348
349 /* This command requires a variable number of bytes to be written.
350 There is a hack in wavefront_cmd() to support this. The actual
351 count is passed in as the read buffer ptr, cast appropriately.
352 Ugh.
353 */
354
355 { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
356
357 /* This one is a hack as well. We just read the first byte of the
358 response, don't fetch an ACK, and leave the rest to the
359 calling function. Ugly, ugly, ugly.
360 */
361
362 { WFC_UPLOAD_MULTISAMPLE, "upload multisample", 2, 1, 0 },
363 { WFC_DOWNLOAD_SAMPLE_ALIAS, "download sample alias",
364 0, WF_ALIAS_BYTES, NEEDS_ACK },
365 { WFC_UPLOAD_SAMPLE_ALIAS, "upload sample alias", WF_ALIAS_BYTES, 2, 0},
366 { WFC_DELETE_SAMPLE, "delete sample", 0, 2, NEEDS_ACK },
367 { WFC_IDENTIFY_SAMPLE_TYPE, "identify sample type", 5, 2, 0 },
368 { WFC_UPLOAD_SAMPLE_PARAMS, "upload sample parameters" },
369 { WFC_REPORT_FREE_MEMORY, "report free memory", 4, 0, 0 },
370 { WFC_DOWNLOAD_PATCH, "download patch", 0, 134, NEEDS_ACK },
371 { WFC_UPLOAD_PATCH, "upload patch", 132, 2, 0 },
372 { WFC_DOWNLOAD_PROGRAM, "download program", 0, 33, NEEDS_ACK },
373 { WFC_UPLOAD_PROGRAM, "upload program", 32, 1, 0 },
374 { WFC_DOWNLOAD_EDRUM_PROGRAM, "download enhanced drum program", 0, 9,
375 NEEDS_ACK},
376 { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
377 { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
378 0, 1, NEEDS_ACK },
379 { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
380 { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
381 32, 0, 0 },
382 { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
383 { 0x00 }
384 };
385
386 static const char *
387 wavefront_errorstr (int errnum)
388
389 {
390 int i;
391
392 for (i = 0; wavefront_errors[i].errstr; i++) {
393 if (wavefront_errors[i].errno == errnum) {
394 return wavefront_errors[i].errstr;
395 }
396 }
397
398 return "Unknown WaveFront error";
399 }
400
401 static wavefront_command *
402 wavefront_get_command (int cmd)
403
404 {
405 int i;
406
407 for (i = 0; wavefront_commands[i].cmd != 0; i++) {
408 if (cmd == wavefront_commands[i].cmd) {
409 return &wavefront_commands[i];
410 }
411 }
412
413 return (wavefront_command *) 0;
414 }
415
416 static inline int
417 wavefront_status (void)
418
419 {
420 return inb (dev.status_port);
421 }
422
423 static int
424 wavefront_wait (int mask)
425
426 {
427 int i;
428
429 for (i = 0; i < wait_polls; i++)
430 if (wavefront_status() & mask)
431 return 1;
432
433 for (i = 0; i < sleep_tries; i++) {
434
435 if (wavefront_status() & mask) {
436 set_current_state(TASK_RUNNING);
437 return 1;
438 }
439
440 set_current_state(TASK_INTERRUPTIBLE);
441 schedule_timeout(sleep_length);
442 if (signal_pending(current))
443 break;
444 }
445
446 set_current_state(TASK_RUNNING);
447 return 0;
448 }
449
450 static int
451 wavefront_read (void)
452
453 {
454 if (wavefront_wait (STAT_CAN_READ))
455 return inb (dev.data_port);
456
457 DPRINT (WF_DEBUG_DATA, "read timeout.\n");
458
459 return -1;
460 }
461
462 static int
463 wavefront_write (unsigned char data)
464
465 {
466 if (wavefront_wait (STAT_CAN_WRITE)) {
467 outb (data, dev.data_port);
468 return 0;
469 }
470
471 DPRINT (WF_DEBUG_DATA, "write timeout.\n");
472
473 return -1;
474 }
475
476 static int
477 wavefront_cmd (int cmd, unsigned char *rbuf, unsigned char *wbuf)
478
479 {
480 int ack;
481 int i;
482 int c;
483 wavefront_command *wfcmd;
484
485 if ((wfcmd = wavefront_get_command (cmd)) == (wavefront_command *) 0) {
486 printk (KERN_WARNING LOGNAME "command 0x%x not supported.\n",
487 cmd);
488 return 1;
489 }
490
491 /* Hack to handle the one variable-size write command. See
492 wavefront_send_multisample() for the other half of this
493 gross and ugly strategy.
494 */
495
496 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
497 wfcmd->write_cnt = (unsigned int) rbuf;
498 rbuf = NULL;
499 }
500
501 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
502 cmd, wfcmd->action, wfcmd->read_cnt,
503 wfcmd->write_cnt, wfcmd->need_ack);
504
505 if (wavefront_write (cmd)) {
506 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
507 "0x%x [%s].\n",
508 cmd, wfcmd->action);
509 return 1;
510 }
511
512 if (wfcmd->write_cnt > 0) {
513 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
514 "for 0x%x\n",
515 wfcmd->write_cnt, cmd);
516
517 for (i = 0; i < wfcmd->write_cnt; i++) {
518 if (wavefront_write (wbuf[i])) {
519 DPRINT (WF_DEBUG_IO, "bad write for byte "
520 "%d of 0x%x [%s].\n",
521 i, cmd, wfcmd->action);
522 return 1;
523 }
524
525 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
526 i, wbuf[i]);
527 }
528 }
529
530 if (wfcmd->read_cnt > 0) {
531 DPRINT (WF_DEBUG_DATA, "reading %d ints "
532 "for 0x%x\n",
533 wfcmd->read_cnt, cmd);
534
535 for (i = 0; i < wfcmd->read_cnt; i++) {
536
537 if ((c = wavefront_read()) == -1) {
538 DPRINT (WF_DEBUG_IO, "bad read for byte "
539 "%d of 0x%x [%s].\n",
540 i, cmd, wfcmd->action);
541 return 1;
542 }
543
544 /* Now handle errors. Lots of special cases here */
545
546 if (c == 0xff) {
547 if ((c = wavefront_read ()) == -1) {
548 DPRINT (WF_DEBUG_IO, "bad read for "
549 "error byte at "
550 "read byte %d "
551 "of 0x%x [%s].\n",
552 i, cmd,
553 wfcmd->action);
554 return 1;
555 }
556
557 /* Can you believe this madness ? */
558
559 if (c == 1 &&
560 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
561 rbuf[0] = WF_ST_EMPTY;
562 return (0);
563
564 } else if (c == 3 &&
565 wfcmd->cmd == WFC_UPLOAD_PATCH) {
566
567 return 3;
568
569 } else if (c == 1 &&
570 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
571
572 return 1;
573
574 } else {
575
576 DPRINT (WF_DEBUG_IO, "error %d (%s) "
577 "during "
578 "read for byte "
579 "%d of 0x%x "
580 "[%s].\n",
581 c,
582 wavefront_errorstr (c),
583 i, cmd,
584 wfcmd->action);
585 return 1;
586
587 }
588
589 } else {
590 rbuf[i] = c;
591 }
592
593 DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
594 }
595 }
596
597 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
598
599 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
600
601 /* Some commands need an ACK, but return zero instead
602 of the standard value.
603 */
604
605 if ((ack = wavefront_read()) == 0) {
606 ack = WF_ACK;
607 }
608
609 if (ack != WF_ACK) {
610 if (ack == -1) {
611 DPRINT (WF_DEBUG_IO, "cannot read ack for "
612 "0x%x [%s].\n",
613 cmd, wfcmd->action);
614 return 1;
615
616 } else {
617 int err = -1; /* something unknown */
618
619 if (ack == 0xff) { /* explicit error */
620
621 if ((err = wavefront_read ()) == -1) {
622 DPRINT (WF_DEBUG_DATA,
623 "cannot read err "
624 "for 0x%x [%s].\n",
625 cmd, wfcmd->action);
626 }
627 }
628
629 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
630 "failed (0x%x, 0x%x, %s)\n",
631 cmd, wfcmd->action, ack, err,
632 wavefront_errorstr (err));
633
634 return -err;
635 }
636 }
637
638 DPRINT (WF_DEBUG_DATA, "ack received "
639 "for 0x%x [%s]\n",
640 cmd, wfcmd->action);
641 } else {
642
643 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
644 "ACK (%d,%d,%d)\n",
645 cmd, wfcmd->action, wfcmd->read_cnt,
646 wfcmd->write_cnt, wfcmd->need_ack);
647 }
648
649 return 0;
650
651 }
652
653 /***********************************************************************
654 WaveFront: data munging
655
656 Things here are weird. All data written to the board cannot
657 have its most significant bit set. Any data item with values
658 potentially > 0x7F (127) must be split across multiple bytes.
659
660 Sometimes, we need to munge numeric values that are represented on
661 the x86 side as 8-32 bit values. Sometimes, we need to munge data
662 that is represented on the x86 side as an array of bytes. The most
663 efficient approach to handling both cases seems to be to use 2
664 different functions for munging and 2 for de-munging. This avoids
665 weird casting and worrying about bit-level offsets.
666
667 **********************************************************************/
668
669 static
670 unsigned char *
671 munge_int32 (unsigned int src,
672 unsigned char *dst,
673 unsigned int dst_size)
674 {
675 int i;
676
677 for (i = 0;i < dst_size; i++) {
678 *dst = src & 0x7F; /* Mask high bit of LSB */
679 src = src >> 7; /* Rotate Right 7 bits */
680 /* Note: we leave the upper bits in place */
681
682 dst++;
683 };
684 return dst;
685 };
686
687 static int
688 demunge_int32 (unsigned char* src, int src_size)
689
690 {
691 int i;
692 int outval = 0;
693
694 for (i = src_size - 1; i >= 0; i--) {
695 outval=(outval<<7)+src[i];
696 }
697
698 return outval;
699 };
700
701 static
702 unsigned char *
703 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
704
705 {
706 int i;
707 unsigned int last = dst_size / 2;
708
709 for (i = 0; i < last; i++) {
710 *dst++ = src[i] & 0x7f;
711 *dst++ = src[i] >> 7;
712 }
713 return dst;
714 }
715
716 static
717 unsigned char *
718 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
719
720 {
721 int i;
722 unsigned char *end = src + src_bytes;
723
724 end = src + src_bytes;
725
726 /* NOTE: src and dst *CAN* point to the same address */
727
728 for (i = 0; src != end; i++) {
729 dst[i] = *src++;
730 dst[i] |= (*src++)<<7;
731 }
732
733 return dst;
734 }
735
736 /***********************************************************************
737 WaveFront: sample, patch and program management.
738 ***********************************************************************/
739
740 static int
741 wavefront_delete_sample (int sample_num)
742
743 {
744 unsigned char wbuf[2];
745 int x;
746
747 wbuf[0] = sample_num & 0x7f;
748 wbuf[1] = sample_num >> 7;
749
750 if ((x = wavefront_cmd (WFC_DELETE_SAMPLE, NULL, wbuf)) == 0) {
751 dev.sample_status[sample_num] = WF_ST_EMPTY;
752 }
753
754 return x;
755 }
756
757 static int
758 wavefront_get_sample_status (int assume_rom)
759
760 {
761 int i;
762 unsigned char rbuf[32], wbuf[32];
763 unsigned int sc_real, sc_alias, sc_multi;
764
765 /* check sample status */
766
767 if (wavefront_cmd (WFC_GET_NSAMPLES, rbuf, wbuf)) {
768 printk (KERN_WARNING LOGNAME "cannot request sample count.\n");
769 return -1;
770 }
771
772 sc_real = sc_alias = sc_multi = dev.samples_used = 0;
773
774 for (i = 0; i < WF_MAX_SAMPLE; i++) {
775
776 wbuf[0] = i & 0x7f;
777 wbuf[1] = i >> 7;
778
779 if (wavefront_cmd (WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
780 printk (KERN_WARNING LOGNAME
781 "cannot identify sample "
782 "type of slot %d\n", i);
783 dev.sample_status[i] = WF_ST_EMPTY;
784 continue;
785 }
786
787 dev.sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
788
789 if (assume_rom) {
790 dev.sample_status[i] |= WF_SLOT_ROM;
791 }
792
793 switch (rbuf[0] & WF_ST_MASK) {
794 case WF_ST_SAMPLE:
795 sc_real++;
796 break;
797 case WF_ST_MULTISAMPLE:
798 sc_multi++;
799 break;
800 case WF_ST_ALIAS:
801 sc_alias++;
802 break;
803 case WF_ST_EMPTY:
804 break;
805
806 default:
807 printk (KERN_WARNING LOGNAME "unknown sample type for "
808 "slot %d (0x%x)\n",
809 i, rbuf[0]);
810 }
811
812 if (rbuf[0] != WF_ST_EMPTY) {
813 dev.samples_used++;
814 }
815 }
816
817 printk (KERN_INFO LOGNAME
818 "%d samples used (%d real, %d aliases, %d multi), "
819 "%d empty\n", dev.samples_used, sc_real, sc_alias, sc_multi,
820 WF_MAX_SAMPLE - dev.samples_used);
821
822
823 return (0);
824
825 }
826
827 static int
828 wavefront_get_patch_status (void)
829
830 {
831 unsigned char patchbuf[WF_PATCH_BYTES];
832 unsigned char patchnum[2];
833 wavefront_patch *p;
834 int i, x, cnt, cnt2;
835
836 for (i = 0; i < WF_MAX_PATCH; i++) {
837 patchnum[0] = i & 0x7f;
838 patchnum[1] = i >> 7;
839
840 if ((x = wavefront_cmd (WFC_UPLOAD_PATCH, patchbuf,
841 patchnum)) == 0) {
842
843 dev.patch_status[i] |= WF_SLOT_FILLED;
844 p = (wavefront_patch *) patchbuf;
845 dev.sample_status
846 [p->sample_number|(p->sample_msb<<7)] |=
847 WF_SLOT_USED;
848
849 } else if (x == 3) { /* Bad patch number */
850 dev.patch_status[i] = 0;
851 } else {
852 printk (KERN_ERR LOGNAME "upload patch "
853 "error 0x%x\n", x);
854 dev.patch_status[i] = 0;
855 return 1;
856 }
857 }
858
859 /* program status has already filled in slot_used bits */
860
861 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
862 if (dev.patch_status[i] & WF_SLOT_FILLED) {
863 cnt++;
864 }
865 if (dev.patch_status[i] & WF_SLOT_USED) {
866 cnt2++;
867 }
868
869 }
870 printk (KERN_INFO LOGNAME
871 "%d patch slots filled, %d in use\n", cnt, cnt2);
872
873 return (0);
874 }
875
876 static int
877 wavefront_get_program_status (void)
878
879 {
880 unsigned char progbuf[WF_PROGRAM_BYTES];
881 wavefront_program prog;
882 unsigned char prognum;
883 int i, x, l, cnt;
884
885 for (i = 0; i < WF_MAX_PROGRAM; i++) {
886 prognum = i;
887
888 if ((x = wavefront_cmd (WFC_UPLOAD_PROGRAM, progbuf,
889 &prognum)) == 0) {
890
891 dev.prog_status[i] |= WF_SLOT_USED;
892
893 demunge_buf (progbuf, (unsigned char *) &prog,
894 WF_PROGRAM_BYTES);
895
896 for (l = 0; l < WF_NUM_LAYERS; l++) {
897 if (prog.layer[l].mute) {
898 dev.patch_status
899 [prog.layer[l].patch_number] |=
900 WF_SLOT_USED;
901 }
902 }
903 } else if (x == 1) { /* Bad program number */
904 dev.prog_status[i] = 0;
905 } else {
906 printk (KERN_ERR LOGNAME "upload program "
907 "error 0x%x\n", x);
908 dev.prog_status[i] = 0;
909 }
910 }
911
912 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
913 if (dev.prog_status[i]) {
914 cnt++;
915 }
916 }
917
918 printk (KERN_INFO LOGNAME "%d programs slots in use\n", cnt);
919
920 return (0);
921 }
922
923 static int
924 wavefront_send_patch (wavefront_patch_info *header)
925
926 {
927 unsigned char buf[WF_PATCH_BYTES+2];
928 unsigned char *bptr;
929
930 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
931 header->number);
932
933 dev.patch_status[header->number] |= WF_SLOT_FILLED;
934
935 bptr = buf;
936 bptr = munge_int32 (header->number, buf, 2);
937 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
938
939 if (wavefront_cmd (WFC_DOWNLOAD_PATCH, NULL, buf)) {
940 printk (KERN_ERR LOGNAME "download patch failed\n");
941 return -(EIO);
942 }
943
944 return (0);
945 }
946
947 static int
948 wavefront_send_program (wavefront_patch_info *header)
949
950 {
951 unsigned char buf[WF_PROGRAM_BYTES+1];
952 int i;
953
954 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
955 header->number);
956
957 dev.prog_status[header->number] = WF_SLOT_USED;
958
959 /* XXX need to zero existing SLOT_USED bit for program_status[i]
960 where `i' is the program that's being (potentially) overwritten.
961 */
962
963 for (i = 0; i < WF_NUM_LAYERS; i++) {
964 if (header->hdr.pr.layer[i].mute) {
965 dev.patch_status[header->hdr.pr.layer[i].patch_number] |=
966 WF_SLOT_USED;
967
968 /* XXX need to mark SLOT_USED for sample used by
969 patch_number, but this means we have to load it. Ick.
970 */
971 }
972 }
973
974 buf[0] = header->number;
975 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
976
977 if (wavefront_cmd (WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
978 printk (KERN_WARNING LOGNAME "download patch failed\n");
979 return -(EIO);
980 }
981
982 return (0);
983 }
984
985 static int
986 wavefront_freemem (void)
987
988 {
989 char rbuf[8];
990
991 if (wavefront_cmd (WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
992 printk (KERN_WARNING LOGNAME "can't get memory stats.\n");
993 return -1;
994 } else {
995 return demunge_int32 (rbuf, 4);
996 }
997 }
998
999 static int
1000 wavefront_send_sample (wavefront_patch_info *header,
1001 UINT16 __user *dataptr,
1002 int data_is_unsigned)
1003
1004 {
1005 /* samples are downloaded via a 16-bit wide i/o port
1006 (you could think of it as 2 adjacent 8-bit wide ports
1007 but its less efficient that way). therefore, all
1008 the blocksizes and so forth listed in the documentation,
1009 and used conventionally to refer to sample sizes,
1010 which are given in 8-bit units (bytes), need to be
1011 divided by 2.
1012 */
1013
1014 UINT16 sample_short;
1015 UINT32 length;
1016 UINT16 __user *data_end = NULL;
1017 unsigned int i;
1018 const int max_blksize = 4096/2;
1019 unsigned int written;
1020 unsigned int blocksize;
1021 int dma_ack;
1022 int blocknum;
1023 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
1024 unsigned char *shptr;
1025 int skip = 0;
1026 int initial_skip = 0;
1027
1028 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
1029 "type %d, %d bytes from %p\n",
1030 header->size ? "" : "header ",
1031 header->number, header->subkey,
1032 header->size,
1033 header->dataptr);
1034
1035 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
1036 int x;
1037
1038 if ((x = wavefront_find_free_sample ()) < 0) {
1039 return -ENOMEM;
1040 }
1041 printk (KERN_DEBUG LOGNAME "unspecified sample => %d\n", x);
1042 header->number = x;
1043 }
1044
1045 if (header->size) {
1046
1047 /* XXX it's a debatable point whether or not RDONLY semantics
1048 on the ROM samples should cover just the sample data or
1049 the sample header. For now, it only covers the sample data,
1050 so anyone is free at all times to rewrite sample headers.
1051
1052 My reason for this is that we have the sample headers
1053 available in the WFB file for General MIDI, and so these
1054 can always be reset if needed. The sample data, however,
1055 cannot be recovered without a complete reset and firmware
1056 reload of the ICS2115, which is a very expensive operation.
1057
1058 So, doing things this way allows us to honor the notion of
1059 "RESETSAMPLES" reasonably cheaply. Note however, that this
1060 is done purely at user level: there is no WFB parser in
1061 this driver, and so a complete reset (back to General MIDI,
1062 or theoretically some other configuration) is the
1063 responsibility of the user level library.
1064
1065 To try to do this in the kernel would be a little
1066 crazy: we'd need 158K of kernel space just to hold
1067 a copy of the patch/program/sample header data.
1068 */
1069
1070 if (dev.rom_samples_rdonly) {
1071 if (dev.sample_status[header->number] & WF_SLOT_ROM) {
1072 printk (KERN_ERR LOGNAME "sample slot %d "
1073 "write protected\n",
1074 header->number);
1075 return -EACCES;
1076 }
1077 }
1078
1079 wavefront_delete_sample (header->number);
1080 }
1081
1082 if (header->size) {
1083 dev.freemem = wavefront_freemem ();
1084
1085 if (dev.freemem < header->size) {
1086 printk (KERN_ERR LOGNAME
1087 "insufficient memory to "
1088 "load %d byte sample.\n",
1089 header->size);
1090 return -ENOMEM;
1091 }
1092
1093 }
1094
1095 skip = WF_GET_CHANNEL(&header->hdr.s);
1096
1097 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
1098 printk (KERN_ERR LOGNAME "channel selection only "
1099 "possible on 16-bit samples");
1100 return -(EINVAL);
1101 }
1102
1103 switch (skip) {
1104 case 0:
1105 initial_skip = 0;
1106 skip = 1;
1107 break;
1108 case 1:
1109 initial_skip = 0;
1110 skip = 2;
1111 break;
1112 case 2:
1113 initial_skip = 1;
1114 skip = 2;
1115 break;
1116 case 3:
1117 initial_skip = 2;
1118 skip = 3;
1119 break;
1120 case 4:
1121 initial_skip = 3;
1122 skip = 4;
1123 break;
1124 case 5:
1125 initial_skip = 4;
1126 skip = 5;
1127 break;
1128 case 6:
1129 initial_skip = 5;
1130 skip = 6;
1131 break;
1132 }
1133
1134 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
1135 "initial skip = %d, skip = %d\n",
1136 WF_GET_CHANNEL (&header->hdr.s),
1137 initial_skip, skip);
1138
1139 /* Be safe, and zero the "Unused" bits ... */
1140
1141 WF_SET_CHANNEL(&header->hdr.s, 0);
1142
1143 /* adjust size for 16 bit samples by dividing by two. We always
1144 send 16 bits per write, even for 8 bit samples, so the length
1145 is always half the size of the sample data in bytes.
1146 */
1147
1148 length = header->size / 2;
1149
1150 /* the data we're sent has not been munged, and in fact, the
1151 header we have to send isn't just a munged copy either.
1152 so, build the sample header right here.
1153 */
1154
1155 shptr = &sample_hdr[0];
1156
1157 shptr = munge_int32 (header->number, shptr, 2);
1158
1159 if (header->size) {
1160 shptr = munge_int32 (length, shptr, 4);
1161 }
1162
1163 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1164 but the offset only uses 24 bits.
1165 */
1166
1167 shptr = munge_int32 (*((UINT32 *) &header->hdr.s.sampleStartOffset),
1168 shptr, 4);
1169 shptr = munge_int32 (*((UINT32 *) &header->hdr.s.loopStartOffset),
1170 shptr, 4);
1171 shptr = munge_int32 (*((UINT32 *) &header->hdr.s.loopEndOffset),
1172 shptr, 4);
1173 shptr = munge_int32 (*((UINT32 *) &header->hdr.s.sampleEndOffset),
1174 shptr, 4);
1175
1176 /* This one is truly weird. What kind of weirdo decided that in
1177 a system dominated by 16 and 32 bit integers, they would use
1178 a just 12 bits ?
1179 */
1180
1181 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1182
1183 /* Why is this nybblified, when the MSB is *always* zero ?
1184 Anyway, we can't take address of bitfield, so make a
1185 good-faith guess at where it starts.
1186 */
1187
1188 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1189 shptr, 2);
1190
1191 if (wavefront_cmd (header->size ?
1192 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1193 NULL, sample_hdr)) {
1194 printk (KERN_WARNING LOGNAME "sample %sdownload refused.\n",
1195 header->size ? "" : "header ");
1196 return -(EIO);
1197 }
1198
1199 if (header->size == 0) {
1200 goto sent; /* Sorry. Just had to have one somewhere */
1201 }
1202
1203 data_end = dataptr + length;
1204
1205 /* Do any initial skip over an unused channel's data */
1206
1207 dataptr += initial_skip;
1208
1209 for (written = 0, blocknum = 0;
1210 written < length; written += max_blksize, blocknum++) {
1211
1212 if ((length - written) > max_blksize) {
1213 blocksize = max_blksize;
1214 } else {
1215 /* round to nearest 16-byte value */
1216 blocksize = ((length-written+7)&~0x7);
1217 }
1218
1219 if (wavefront_cmd (WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1220 printk (KERN_WARNING LOGNAME "download block "
1221 "request refused.\n");
1222 return -(EIO);
1223 }
1224
1225 for (i = 0; i < blocksize; i++) {
1226
1227 if (dataptr < data_end) {
1228
1229 __get_user (sample_short, dataptr);
1230 dataptr += skip;
1231
1232 if (data_is_unsigned) { /* GUS ? */
1233
1234 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1235
1236 /* 8 bit sample
1237 resolution, sign
1238 extend both bytes.
1239 */
1240
1241 ((unsigned char*)
1242 &sample_short)[0] += 0x7f;
1243 ((unsigned char*)
1244 &sample_short)[1] += 0x7f;
1245
1246 } else {
1247
1248 /* 16 bit sample
1249 resolution, sign
1250 extend the MSB.
1251 */
1252
1253 sample_short += 0x7fff;
1254 }
1255 }
1256
1257 } else {
1258
1259 /* In padding section of final block:
1260
1261 Don't fetch unsupplied data from
1262 user space, just continue with
1263 whatever the final value was.
1264 */
1265 }
1266
1267 if (i < blocksize - 1) {
1268 outw (sample_short, dev.block_port);
1269 } else {
1270 outw (sample_short, dev.last_block_port);
1271 }
1272 }
1273
1274 /* Get "DMA page acknowledge", even though its really
1275 nothing to do with DMA at all.
1276 */
1277
1278 if ((dma_ack = wavefront_read ()) != WF_DMA_ACK) {
1279 if (dma_ack == -1) {
1280 printk (KERN_ERR LOGNAME "upload sample "
1281 "DMA ack timeout\n");
1282 return -(EIO);
1283 } else {
1284 printk (KERN_ERR LOGNAME "upload sample "
1285 "DMA ack error 0x%x\n",
1286 dma_ack);
1287 return -(EIO);
1288 }
1289 }
1290 }
1291
1292 dev.sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1293
1294 /* Note, label is here because sending the sample header shouldn't
1295 alter the sample_status info at all.
1296 */
1297
1298 sent:
1299 return (0);
1300 }
1301
1302 static int
1303 wavefront_send_alias (wavefront_patch_info *header)
1304
1305 {
1306 unsigned char alias_hdr[WF_ALIAS_BYTES];
1307
1308 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1309 "alias for %d\n",
1310 header->number,
1311 header->hdr.a.OriginalSample);
1312
1313 munge_int32 (header->number, &alias_hdr[0], 2);
1314 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1315 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1316 &alias_hdr[4], 4);
1317 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1318 &alias_hdr[8], 4);
1319 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1320 &alias_hdr[12], 4);
1321 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1322 &alias_hdr[16], 4);
1323 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1324 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1325
1326 if (wavefront_cmd (WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1327 printk (KERN_ERR LOGNAME "download alias failed.\n");
1328 return -(EIO);
1329 }
1330
1331 dev.sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1332
1333 return (0);
1334 }
1335
1336 static int
1337 wavefront_send_multisample (wavefront_patch_info *header)
1338 {
1339 int i;
1340 int num_samples;
1341 unsigned char msample_hdr[WF_MSAMPLE_BYTES];
1342
1343 munge_int32 (header->number, &msample_hdr[0], 2);
1344
1345 /* You'll recall at this point that the "number of samples" value
1346 in a wavefront_multisample struct is actually the log2 of the
1347 real number of samples.
1348 */
1349
1350 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1351 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1352
1353 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1354 header->number,
1355 header->hdr.ms.NumberOfSamples,
1356 num_samples);
1357
1358 for (i = 0; i < num_samples; i++) {
1359 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1360 i, header->hdr.ms.SampleNumber[i]);
1361 munge_int32 (header->hdr.ms.SampleNumber[i],
1362 &msample_hdr[3+(i*2)], 2);
1363 }
1364
1365 /* Need a hack here to pass in the number of bytes
1366 to be written to the synth. This is ugly, and perhaps
1367 one day, I'll fix it.
1368 */
1369
1370 if (wavefront_cmd (WFC_DOWNLOAD_MULTISAMPLE,
1371 (unsigned char *) ((num_samples*2)+3),
1372 msample_hdr)) {
1373 printk (KERN_ERR LOGNAME "download of multisample failed.\n");
1374 return -(EIO);
1375 }
1376
1377 dev.sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1378
1379 return (0);
1380 }
1381
1382 static int
1383 wavefront_fetch_multisample (wavefront_patch_info *header)
1384 {
1385 int i;
1386 unsigned char log_ns[1];
1387 unsigned char number[2];
1388 int num_samples;
1389
1390 munge_int32 (header->number, number, 2);
1391
1392 if (wavefront_cmd (WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1393 printk (KERN_ERR LOGNAME "upload multisample failed.\n");
1394 return -(EIO);
1395 }
1396
1397 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1398 header->number, log_ns[0]);
1399
1400 header->hdr.ms.NumberOfSamples = log_ns[0];
1401
1402 /* get the number of samples ... */
1403
1404 num_samples = (1 << log_ns[0]);
1405
1406 for (i = 0; i < num_samples; i++) {
1407 s8 d[2];
1408
1409 if ((d[0] = wavefront_read ()) == -1) {
1410 printk (KERN_ERR LOGNAME "upload multisample failed "
1411 "during sample loop.\n");
1412 return -(EIO);
1413 }
1414
1415 if ((d[1] = wavefront_read ()) == -1) {
1416 printk (KERN_ERR LOGNAME "upload multisample failed "
1417 "during sample loop.\n");
1418 return -(EIO);
1419 }
1420
1421 header->hdr.ms.SampleNumber[i] =
1422 demunge_int32 ((unsigned char *) d, 2);
1423
1424 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1425 i, header->hdr.ms.SampleNumber[i]);
1426 }
1427
1428 return (0);
1429 }
1430
1431
1432 static int
1433 wavefront_send_drum (wavefront_patch_info *header)
1434
1435 {
1436 unsigned char drumbuf[WF_DRUM_BYTES];
1437 wavefront_drum *drum = &header->hdr.d;
1438 int i;
1439
1440 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1441 "note %d, patch = %d\n",
1442 header->number, drum->PatchNumber);
1443
1444 drumbuf[0] = header->number & 0x7f;
1445
1446 for (i = 0; i < 4; i++) {
1447 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1448 }
1449
1450 if (wavefront_cmd (WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1451 printk (KERN_ERR LOGNAME "download drum failed.\n");
1452 return -(EIO);
1453 }
1454
1455 return (0);
1456 }
1457
1458 static int
1459 wavefront_find_free_sample (void)
1460
1461 {
1462 int i;
1463
1464 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1465 if (!(dev.sample_status[i] & WF_SLOT_FILLED)) {
1466 return i;
1467 }
1468 }
1469 printk (KERN_WARNING LOGNAME "no free sample slots!\n");
1470 return -1;
1471 }
1472
1473 static int
1474 wavefront_find_free_patch (void)
1475
1476 {
1477 int i;
1478
1479 for (i = 0; i < WF_MAX_PATCH; i++) {
1480 if (!(dev.patch_status[i] & WF_SLOT_FILLED)) {
1481 return i;
1482 }
1483 }
1484 printk (KERN_WARNING LOGNAME "no free patch slots!\n");
1485 return -1;
1486 }
1487
1488 static int
1489 log2_2048(int n)
1490
1491 {
1492 int tbl[]={0, 0, 2048, 3246, 4096, 4755, 5294, 5749, 6143,
1493 6492, 6803, 7084, 7342, 7578, 7797, 8001, 8192,
1494 8371, 8540, 8699, 8851, 8995, 9132, 9264, 9390,
1495 9510, 9626, 9738, 9845, 9949, 10049, 10146};
1496 int i;
1497
1498 /* Returns 2048*log2(n) */
1499
1500 /* FIXME: this is like doing integer math
1501 on quantum particles (RuN) */
1502
1503 i=0;
1504 while(n>=32*256) {
1505 n>>=8;
1506 i+=2048*8;
1507 }
1508 while(n>=32) {
1509 n>>=1;
1510 i+=2048;
1511 }
1512 i+=tbl[n];
1513 return(i);
1514 }
1515
1516 static int
1517 wavefront_load_gus_patch (int devno, int format, const char __user *addr,
1518 int offs, int count, int pmgr_flag)
1519 {
1520 struct patch_info guspatch;
1521 wavefront_patch_info samp, pat, prog;
1522 wavefront_patch *patp;
1523 wavefront_sample *sampp;
1524 wavefront_program *progp;
1525
1526 int i,base_note;
1527 long sizeof_patch;
1528
1529 /* Copy in the header of the GUS patch */
1530
1531 sizeof_patch = (long) &guspatch.data[0] - (long) &guspatch;
1532 if (copy_from_user(&((char *) &guspatch)[offs],
1533 &(addr)[offs], sizeof_patch - offs))
1534 return -EFAULT;
1535
1536 if ((i = wavefront_find_free_patch ()) == -1) {
1537 return -EBUSY;
1538 }
1539 pat.number = i;
1540 pat.subkey = WF_ST_PATCH;
1541 patp = &pat.hdr.p;
1542
1543 if ((i = wavefront_find_free_sample ()) == -1) {
1544 return -EBUSY;
1545 }
1546 samp.number = i;
1547 samp.subkey = WF_ST_SAMPLE;
1548 samp.size = guspatch.len;
1549 sampp = &samp.hdr.s;
1550
1551 prog.number = guspatch.instr_no;
1552 progp = &prog.hdr.pr;
1553
1554 /* Setup the patch structure */
1555
1556 patp->amplitude_bias=guspatch.volume;
1557 patp->portamento=0;
1558 patp->sample_number= samp.number & 0xff;
1559 patp->sample_msb= samp.number>>8;
1560 patp->pitch_bend= /*12*/ 0;
1561 patp->mono=1;
1562 patp->retrigger=1;
1563 patp->nohold=(guspatch.mode & WAVE_SUSTAIN_ON) ? 0:1;
1564 patp->frequency_bias=0;
1565 patp->restart=0;
1566 patp->reuse=0;
1567 patp->reset_lfo=1;
1568 patp->fm_src2=0;
1569 patp->fm_src1=WF_MOD_MOD_WHEEL;
1570 patp->am_src=WF_MOD_PRESSURE;
1571 patp->am_amount=127;
1572 patp->fc1_mod_amount=0;
1573 patp->fc2_mod_amount=0;
1574 patp->fm_amount1=0;
1575 patp->fm_amount2=0;
1576 patp->envelope1.attack_level=127;
1577 patp->envelope1.decay1_level=127;
1578 patp->envelope1.decay2_level=127;
1579 patp->envelope1.sustain_level=127;
1580 patp->envelope1.release_level=0;
1581 patp->envelope2.attack_velocity=127;
1582 patp->envelope2.attack_level=127;
1583 patp->envelope2.decay1_level=127;
1584 patp->envelope2.decay2_level=127;
1585 patp->envelope2.sustain_level=127;
1586 patp->envelope2.release_level=0;
1587 patp->envelope2.attack_velocity=127;
1588 patp->randomizer=0;
1589
1590 /* Program for this patch */
1591
1592 progp->layer[0].patch_number= pat.number; /* XXX is this right ? */
1593 progp->layer[0].mute=1;
1594 progp->layer[0].pan_or_mod=1;
1595 progp->layer[0].pan=7;
1596 progp->layer[0].mix_level=127 /* guspatch.volume */;
1597 progp->layer[0].split_type=0;
1598 progp->layer[0].split_point=0;
1599 progp->layer[0].play_below=0;
1600
1601 for (i = 1; i < 4; i++) {
1602 progp->layer[i].mute=0;
1603 }
1604
1605 /* Sample data */
1606
1607 sampp->SampleResolution=((~guspatch.mode & WAVE_16_BITS)<<1);
1608
1609 for (base_note=0;
1610 note_to_freq (base_note) < guspatch.base_note;
1611 base_note++);
1612
1613 if ((guspatch.base_note-note_to_freq(base_note))
1614 >(note_to_freq(base_note)-guspatch.base_note))
1615 base_note++;
1616
1617 printk(KERN_DEBUG "ref freq=%d,base note=%d\n",
1618 guspatch.base_freq,
1619 base_note);
1620
1621 sampp->FrequencyBias = (29550 - log2_2048(guspatch.base_freq)
1622 + base_note*171);
1623 printk(KERN_DEBUG "Freq Bias is %d\n", sampp->FrequencyBias);
1624 sampp->Loop=(guspatch.mode & WAVE_LOOPING) ? 1:0;
1625 sampp->sampleStartOffset.Fraction=0;
1626 sampp->sampleStartOffset.Integer=0;
1627 sampp->loopStartOffset.Fraction=0;
1628 sampp->loopStartOffset.Integer=guspatch.loop_start
1629 >>((guspatch.mode&WAVE_16_BITS) ? 1:0);
1630 sampp->loopEndOffset.Fraction=0;
1631 sampp->loopEndOffset.Integer=guspatch.loop_end
1632 >>((guspatch.mode&WAVE_16_BITS) ? 1:0);
1633 sampp->sampleEndOffset.Fraction=0;
1634 sampp->sampleEndOffset.Integer=guspatch.len >> (guspatch.mode&1);
1635 sampp->Bidirectional=(guspatch.mode&WAVE_BIDIR_LOOP) ? 1:0;
1636 sampp->Reverse=(guspatch.mode&WAVE_LOOP_BACK) ? 1:0;
1637
1638 /* Now ship it down */
1639
1640 wavefront_send_sample (&samp,
1641 (unsigned short __user *) &(addr)[sizeof_patch],
1642 (guspatch.mode & WAVE_UNSIGNED) ? 1:0);
1643 wavefront_send_patch (&pat);
1644 wavefront_send_program (&prog);
1645
1646 /* Now pan as best we can ... use the slave/internal MIDI device
1647 number if it exists (since it talks to the WaveFront), or the
1648 master otherwise.
1649 */
1650
1651 if (dev.mididev > 0) {
1652 midi_synth_controller (dev.mididev, guspatch.instr_no, 10,
1653 ((guspatch.panning << 4) > 127) ?
1654 127 : (guspatch.panning << 4));
1655 }
1656
1657 return(0);
1658 }
1659
1660 static int
1661 wavefront_load_patch (const char __user *addr)
1662
1663
1664 {
1665 wavefront_patch_info header;
1666
1667 if (copy_from_user (&header, addr, sizeof(wavefront_patch_info) -
1668 sizeof(wavefront_any))) {
1669 printk (KERN_WARNING LOGNAME "bad address for load patch.\n");
1670 return -EFAULT;
1671 }
1672
1673 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1674 "Sample type: %d "
1675 "Sample number: %d "
1676 "Sample size: %d\n",
1677 header.subkey,
1678 header.number,
1679 header.size);
1680
1681 switch (header.subkey) {
1682 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1683
1684 if (copy_from_user((unsigned char *) &header.hdr.s,
1685 (unsigned char __user *) header.hdrptr,
1686 sizeof (wavefront_sample)))
1687 return -EFAULT;
1688
1689 return wavefront_send_sample (&header, header.dataptr, 0);
1690
1691 case WF_ST_MULTISAMPLE:
1692
1693 if (copy_from_user(&header.hdr.s, header.hdrptr,
1694 sizeof(wavefront_multisample)))
1695 return -EFAULT;
1696
1697 return wavefront_send_multisample (&header);
1698
1699
1700 case WF_ST_ALIAS:
1701
1702 if (copy_from_user(&header.hdr.a, header.hdrptr,
1703 sizeof (wavefront_alias)))
1704 return -EFAULT;
1705
1706 return wavefront_send_alias (&header);
1707
1708 case WF_ST_DRUM:
1709 if (copy_from_user(&header.hdr.d, header.hdrptr,
1710 sizeof (wavefront_drum)))
1711 return -EFAULT;
1712
1713 return wavefront_send_drum (&header);
1714
1715 case WF_ST_PATCH:
1716 if (copy_from_user(&header.hdr.p, header.hdrptr,
1717 sizeof (wavefront_patch)))
1718 return -EFAULT;
1719
1720 return wavefront_send_patch (&header);
1721
1722 case WF_ST_PROGRAM:
1723 if (copy_from_user(&header.hdr.pr, header.hdrptr,
1724 sizeof (wavefront_program)))
1725 return -EFAULT;
1726
1727 return wavefront_send_program (&header);
1728
1729 default:
1730 printk (KERN_ERR LOGNAME "unknown patch type %d.\n",
1731 header.subkey);
1732 return -(EINVAL);
1733 }
1734
1735 return 0;
1736 }
1737
1738 /***********************************************************************
1739 WaveFront: /dev/sequencer{,2} and other hardware-dependent interfaces
1740 ***********************************************************************/
1741
1742 static void
1743 process_sample_hdr (UCHAR8 *buf)
1744
1745 {
1746 wavefront_sample s;
1747 UCHAR8 *ptr;
1748
1749 ptr = buf;
1750
1751 /* The board doesn't send us an exact copy of a "wavefront_sample"
1752 in response to an Upload Sample Header command. Instead, we
1753 have to convert the data format back into our data structure,
1754 just as in the Download Sample command, where we have to do
1755 something very similar in the reverse direction.
1756 */
1757
1758 *((UINT32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1759 *((UINT32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1760 *((UINT32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1761 *((UINT32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1762 *((UINT32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1763
1764 s.SampleResolution = *ptr & 0x3;
1765 s.Loop = *ptr & 0x8;
1766 s.Bidirectional = *ptr & 0x10;
1767 s.Reverse = *ptr & 0x40;
1768
1769 /* Now copy it back to where it came from */
1770
1771 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1772 }
1773
1774 static int
1775 wavefront_synth_control (int cmd, wavefront_control *wc)
1776
1777 {
1778 unsigned char patchnumbuf[2];
1779 int i;
1780
1781 DPRINT (WF_DEBUG_CMD, "synth control with "
1782 "cmd 0x%x\n", wc->cmd);
1783
1784 /* Pre-handling of or for various commands */
1785
1786 switch (wc->cmd) {
1787 case WFC_DISABLE_INTERRUPTS:
1788 printk (KERN_INFO LOGNAME "interrupts disabled.\n");
1789 outb (0x80|0x20, dev.control_port);
1790 dev.interrupts_on = 0;
1791 return 0;
1792
1793 case WFC_ENABLE_INTERRUPTS:
1794 printk (KERN_INFO LOGNAME "interrupts enabled.\n");
1795 outb (0x80|0x40|0x20, dev.control_port);
1796 dev.interrupts_on = 1;
1797 return 0;
1798
1799 case WFC_INTERRUPT_STATUS:
1800 wc->rbuf[0] = dev.interrupts_on;
1801 return 0;
1802
1803 case WFC_ROMSAMPLES_RDONLY:
1804 dev.rom_samples_rdonly = wc->wbuf[0];
1805 wc->status = 0;
1806 return 0;
1807
1808 case WFC_IDENTIFY_SLOT_TYPE:
1809 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1810 if (i <0 || i >= WF_MAX_SAMPLE) {
1811 printk (KERN_WARNING LOGNAME "invalid slot ID %d\n",
1812 i);
1813 wc->status = EINVAL;
1814 return 0;
1815 }
1816 wc->rbuf[0] = dev.sample_status[i];
1817 wc->status = 0;
1818 return 0;
1819
1820 case WFC_DEBUG_DRIVER:
1821 dev.debug = wc->wbuf[0];
1822 printk (KERN_INFO LOGNAME "debug = 0x%x\n", dev.debug);
1823 return 0;
1824
1825 case WFC_FX_IOCTL:
1826 wffx_ioctl ((wavefront_fx_info *) &wc->wbuf[0]);
1827 return 0;
1828
1829 case WFC_UPLOAD_PATCH:
1830 munge_int32 (*((UINT32 *) wc->wbuf), patchnumbuf, 2);
1831 memcpy (wc->wbuf, patchnumbuf, 2);
1832 break;
1833
1834 case WFC_UPLOAD_MULTISAMPLE:
1835 /* multisamples have to be handled differently, and
1836 cannot be dealt with properly by wavefront_cmd() alone.
1837 */
1838 wc->status = wavefront_fetch_multisample
1839 ((wavefront_patch_info *) wc->rbuf);
1840 return 0;
1841
1842 case WFC_UPLOAD_SAMPLE_ALIAS:
1843 printk (KERN_INFO LOGNAME "support for sample alias upload "
1844 "being considered.\n");
1845 wc->status = EINVAL;
1846 return -EINVAL;
1847 }
1848
1849 wc->status = wavefront_cmd (wc->cmd, wc->rbuf, wc->wbuf);
1850
1851 /* Post-handling of certain commands.
1852
1853 In particular, if the command was an upload, demunge the data
1854 so that the user-level doesn't have to think about it.
1855 */
1856
1857 if (wc->status == 0) {
1858 switch (wc->cmd) {
1859 /* intercept any freemem requests so that we know
1860 we are always current with the user-level view
1861 of things.
1862 */
1863
1864 case WFC_REPORT_FREE_MEMORY:
1865 dev.freemem = demunge_int32 (wc->rbuf, 4);
1866 break;
1867
1868 case WFC_UPLOAD_PATCH:
1869 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1870 break;
1871
1872 case WFC_UPLOAD_PROGRAM:
1873 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1874 break;
1875
1876 case WFC_UPLOAD_EDRUM_PROGRAM:
1877 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1878 break;
1879
1880 case WFC_UPLOAD_SAMPLE_HEADER:
1881 process_sample_hdr (wc->rbuf);
1882 break;
1883
1884 case WFC_UPLOAD_SAMPLE_ALIAS:
1885 printk (KERN_INFO LOGNAME "support for "
1886 "sample aliases still "
1887 "being considered.\n");
1888 break;
1889
1890 case WFC_VMIDI_OFF:
1891 if (virtual_midi_disable () < 0) {
1892 return -(EIO);
1893 }
1894 break;
1895
1896 case WFC_VMIDI_ON:
1897 if (virtual_midi_enable () < 0) {
1898 return -(EIO);
1899 }
1900 break;
1901 }
1902 }
1903
1904 return 0;
1905 }
1906
1907
1908 /***********************************************************************/
1909 /* WaveFront: Linux file system interface (for access via raw synth) */
1910 /***********************************************************************/
1911
1912 static int
1913 wavefront_open (struct inode *inode, struct file *file)
1914 {
1915 /* XXX fix me */
1916 dev.opened = file->f_flags;
1917 return 0;
1918 }
1919
1920 static int
1921 wavefront_release(struct inode *inode, struct file *file)
1922 {
1923 lock_kernel();
1924 dev.opened = 0;
1925 dev.debug = 0;
1926 unlock_kernel();
1927 return 0;
1928 }
1929
1930 static int
1931 wavefront_ioctl(struct inode *inode, struct file *file,
1932 unsigned int cmd, unsigned long arg)
1933 {
1934 wavefront_control wc;
1935 int err;
1936
1937 switch (cmd) {
1938
1939 case WFCTL_WFCMD:
1940 if (copy_from_user(&wc, (void __user *) arg, sizeof (wc)))
1941 return -EFAULT;
1942
1943 if ((err = wavefront_synth_control (cmd, &wc)) == 0) {
1944 if (copy_to_user ((void __user *) arg, &wc, sizeof (wc)))
1945 return -EFAULT;
1946 }
1947
1948 return err;
1949
1950 case WFCTL_LOAD_SPP:
1951 return wavefront_load_patch ((const char __user *) arg);
1952
1953 default:
1954 printk (KERN_WARNING LOGNAME "invalid ioctl %#x\n", cmd);
1955 return -(EINVAL);
1956
1957 }
1958 return 0;
1959 }
1960
1961 static /*const*/ struct file_operations wavefront_fops = {
1962 .owner = THIS_MODULE,
1963 .llseek = no_llseek,
1964 .ioctl = wavefront_ioctl,
1965 .open = wavefront_open,
1966 .release = wavefront_release,
1967 };
1968
1969
1970 /***********************************************************************/
1971 /* WaveFront: OSS installation and support interface */
1972 /***********************************************************************/
1973
1974 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
1975
1976 static struct synth_info wavefront_info =
1977 {"Turtle Beach WaveFront", 0, SYNTH_TYPE_SAMPLE, SAMPLE_TYPE_WAVEFRONT,
1978 0, 32, 0, 0, SYNTH_CAP_INPUT};
1979
1980 static int
1981 wavefront_oss_open (int devno, int mode)
1982
1983 {
1984 dev.opened = mode;
1985 return 0;
1986 }
1987
1988 static void
1989 wavefront_oss_close (int devno)
1990
1991 {
1992 dev.opened = 0;
1993 dev.debug = 0;
1994 return;
1995 }
1996
1997 static int
1998 wavefront_oss_ioctl (int devno, unsigned int cmd, void __user * arg)
1999
2000 {
2001 wavefront_control wc;
2002 int err;
2003
2004 switch (cmd) {
2005 case SNDCTL_SYNTH_INFO:
2006 if(copy_to_user(arg, &wavefront_info, sizeof (wavefront_info)))
2007 return -EFAULT;
2008 return 0;
2009
2010 case SNDCTL_SEQ_RESETSAMPLES:
2011 // printk (KERN_WARNING LOGNAME "driver cannot reset samples.\n");
2012 return 0; /* don't force an error */
2013
2014 case SNDCTL_SEQ_PERCMODE:
2015 return 0; /* don't force an error */
2016
2017 case SNDCTL_SYNTH_MEMAVL:
2018 if ((dev.freemem = wavefront_freemem ()) < 0) {
2019 printk (KERN_ERR LOGNAME "cannot get memory size\n");
2020 return -EIO;
2021 } else {
2022 return dev.freemem;
2023 }
2024 break;
2025
2026 case SNDCTL_SYNTH_CONTROL:
2027 if(copy_from_user (&wc, arg, sizeof (wc)))
2028 err = -EFAULT;
2029 else if ((err = wavefront_synth_control (cmd, &wc)) == 0) {
2030 if(copy_to_user (arg, &wc, sizeof (wc)))
2031 err = -EFAULT;
2032 }
2033
2034 return err;
2035
2036 default:
2037 return -(EINVAL);
2038 }
2039 }
2040
2041 static int
2042 wavefront_oss_load_patch (int devno, int format, const char __user *addr,
2043 int offs, int count, int pmgr_flag)
2044 {
2045
2046 if (format == SYSEX_PATCH) { /* Handled by midi_synth.c */
2047 if (midi_load_patch == NULL) {
2048 printk (KERN_ERR LOGNAME
2049 "SYSEX not loadable: "
2050 "no midi patch loader!\n");
2051 return -(EINVAL);
2052 }
2053
2054 return midi_load_patch (devno, format, addr,
2055 offs, count, pmgr_flag);
2056
2057 } else if (format == GUS_PATCH) {
2058 return wavefront_load_gus_patch (devno, format,
2059 addr, offs, count, pmgr_flag);
2060
2061 } else if (format != WAVEFRONT_PATCH) {
2062 printk (KERN_ERR LOGNAME "unknown patch format %d\n", format);
2063 return -(EINVAL);
2064 }
2065
2066 if (count < sizeof (wavefront_patch_info)) {
2067 printk (KERN_ERR LOGNAME "sample header too short\n");
2068 return -(EINVAL);
2069 }
2070
2071 /* "addr" points to a user-space wavefront_patch_info */
2072
2073 return wavefront_load_patch (addr);
2074 }
2075
2076 static struct synth_operations wavefront_operations =
2077 {
2078 .owner = THIS_MODULE,
2079 .id = "WaveFront",
2080 .info = &wavefront_info,
2081 .midi_dev = 0,
2082 .synth_type = SYNTH_TYPE_SAMPLE,
2083 .synth_subtype = SAMPLE_TYPE_WAVEFRONT,
2084 .open = wavefront_oss_open,
2085 .close = wavefront_oss_close,
2086 .ioctl = wavefront_oss_ioctl,
2087 .kill_note = midi_synth_kill_note,
2088 .start_note = midi_synth_start_note,
2089 .set_instr = midi_synth_set_instr,
2090 .reset = midi_synth_reset,
2091 .load_patch = midi_synth_load_patch,
2092 .aftertouch = midi_synth_aftertouch,
2093 .controller = midi_synth_controller,
2094 .panning = midi_synth_panning,
2095 .bender = midi_synth_bender,
2096 .setup_voice = midi_synth_setup_voice
2097 };
2098 #endif /* OSS_SUPPORT_SEQ */
2099
2100 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_STATIC_INSTALL
2101
2102 static void __init attach_wavefront (struct address_info *hw_config)
2103 {
2104 (void) install_wavefront ();
2105 }
2106
2107 static int __init probe_wavefront (struct address_info *hw_config)
2108 {
2109 return !detect_wavefront (hw_config->irq, hw_config->io_base);
2110 }
2111
2112 static void __exit unload_wavefront (struct address_info *hw_config)
2113 {
2114 (void) uninstall_wavefront ();
2115 }
2116
2117 #endif /* OSS_SUPPORT_STATIC_INSTALL */
2118
2119 /***********************************************************************/
2120 /* WaveFront: Linux modular sound kernel installation interface */
2121 /***********************************************************************/
2122
2123 static irqreturn_t
2124 wavefrontintr(int irq, void *dev_id, struct pt_regs *dummy)
2125 {
2126 struct wf_config *hw = dev_id;
2127
2128 /*
2129 Some comments on interrupts. I attempted a version of this
2130 driver that used interrupts throughout the code instead of
2131 doing busy and/or sleep-waiting. Alas, it appears that once
2132 the Motorola firmware is downloaded, the card *never*
2133 generates an RX interrupt. These are successfully generated
2134 during firmware loading, and after that wavefront_status()
2135 reports that an interrupt is pending on the card from time
2136 to time, but it never seems to be delivered to this
2137 driver. Note also that wavefront_status() continues to
2138 report that RX interrupts are enabled, suggesting that I
2139 didn't goof up and disable them by mistake.
2140
2141 Thus, I stepped back to a prior version of
2142 wavefront_wait(), the only place where this really
2143 matters. Its sad, but I've looked through the code to check
2144 on things, and I really feel certain that the Motorola
2145 firmware prevents RX-ready interrupts.
2146 */
2147
2148 if ((wavefront_status() & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
2149 return IRQ_NONE;
2150 }
2151
2152 hw->irq_ok = 1;
2153 hw->irq_cnt++;
2154 wake_up_interruptible (&hw->interrupt_sleeper);
2155 return IRQ_HANDLED;
2156 }
2157
2158 /* STATUS REGISTER
2159
2160 0 Host Rx Interrupt Enable (1=Enabled)
2161 1 Host Rx Register Full (1=Full)
2162 2 Host Rx Interrupt Pending (1=Interrupt)
2163 3 Unused
2164 4 Host Tx Interrupt (1=Enabled)
2165 5 Host Tx Register empty (1=Empty)
2166 6 Host Tx Interrupt Pending (1=Interrupt)
2167 7 Unused
2168 */
2169
2170 static int
2171 wavefront_interrupt_bits (int irq)
2172
2173 {
2174 int bits;
2175
2176 switch (irq) {
2177 case 9:
2178 bits = 0x00;
2179 break;
2180 case 5:
2181 bits = 0x08;
2182 break;
2183 case 12:
2184 bits = 0x10;
2185 break;
2186 case 15:
2187 bits = 0x18;
2188 break;
2189
2190 default:
2191 printk (KERN_WARNING LOGNAME "invalid IRQ %d\n", irq);
2192 bits = -1;
2193 }
2194
2195 return bits;
2196 }
2197
2198 static void
2199 wavefront_should_cause_interrupt (int val, int port, int timeout)
2200
2201 {
2202 unsigned long flags;
2203
2204 /* this will not help on SMP - but at least it compiles */
2205 spin_lock_irqsave(&lock, flags);
2206 dev.irq_ok = 0;
2207 outb (val,port);
2208 interruptible_sleep_on_timeout (&dev.interrupt_sleeper, timeout);
2209 spin_unlock_irqrestore(&lock,flags);
2210 }
2211
2212 static int __init wavefront_hw_reset (void)
2213 {
2214 int bits;
2215 int hwv[2];
2216 unsigned long irq_mask;
2217 short reported_irq;
2218
2219 /* IRQ already checked in init_module() */
2220
2221 bits = wavefront_interrupt_bits (dev.irq);
2222
2223 printk (KERN_DEBUG LOGNAME "autodetecting WaveFront IRQ\n");
2224
2225 irq_mask = probe_irq_on ();
2226
2227 outb (0x0, dev.control_port);
2228 outb (0x80 | 0x40 | bits, dev.data_port);
2229 wavefront_should_cause_interrupt(0x80|0x40|0x10|0x1,
2230 dev.control_port,
2231 (reset_time*HZ)/100);
2232
2233 reported_irq = probe_irq_off (irq_mask);
2234
2235 if (reported_irq != dev.irq) {
2236 if (reported_irq == 0) {
2237 printk (KERN_ERR LOGNAME
2238 "No unassigned interrupts detected "
2239 "after h/w reset\n");
2240 } else if (reported_irq < 0) {
2241 printk (KERN_ERR LOGNAME
2242 "Multiple unassigned interrupts detected "
2243 "after h/w reset\n");
2244 } else {
2245 printk (KERN_ERR LOGNAME "autodetected IRQ %d not the "
2246 "value provided (%d)\n", reported_irq,
2247 dev.irq);
2248 }
2249 dev.irq = -1;
2250 return 1;
2251 } else {
2252 printk (KERN_INFO LOGNAME "autodetected IRQ at %d\n",
2253 reported_irq);
2254 }
2255
2256 if (request_irq (dev.irq, wavefrontintr,
2257 SA_INTERRUPT|SA_SHIRQ,
2258 "wavefront synth", &dev) < 0) {
2259 printk (KERN_WARNING LOGNAME "IRQ %d not available!\n",
2260 dev.irq);
2261 return 1;
2262 }
2263
2264 /* try reset of port */
2265
2266 outb (0x0, dev.control_port);
2267
2268 /* At this point, the board is in reset, and the H/W initialization
2269 register is accessed at the same address as the data port.
2270
2271 Bit 7 - Enable IRQ Driver
2272 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
2273 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
2274
2275 Bit 6 - MIDI Interface Select
2276
2277 0 - Use the MIDI Input from the 26-pin WaveBlaster
2278 compatible header as the serial MIDI source
2279 1 - Use the MIDI Input from the 9-pin D connector as the
2280 serial MIDI source.
2281
2282 Bits 5:3 - IRQ Selection
2283 0 0 0 - IRQ 2/9
2284 0 0 1 - IRQ 5
2285 0 1 0 - IRQ 12
2286 0 1 1 - IRQ 15
2287 1 0 0 - Reserved
2288 1 0 1 - Reserved
2289 1 1 0 - Reserved
2290 1 1 1 - Reserved
2291
2292 Bits 2:1 - Reserved
2293 Bit 0 - Disable Boot ROM
2294 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
2295 1 - memory accesses to 03FC30-03FFFFH are directed to external
2296 storage.
2297
2298 */
2299
2300 /* configure hardware: IRQ, enable interrupts,
2301 plus external 9-pin MIDI interface selected
2302 */
2303
2304 outb (0x80 | 0x40 | bits, dev.data_port);
2305
2306 /* CONTROL REGISTER
2307
2308 0 Host Rx Interrupt Enable (1=Enabled) 0x1
2309 1 Unused 0x2
2310 2 Unused 0x4
2311 3 Unused 0x8
2312 4 Host Tx Interrupt Enable 0x10
2313 5 Mute (0=Mute; 1=Play) 0x20
2314 6 Master Interrupt Enable (1=Enabled) 0x40
2315 7 Master Reset (0=Reset; 1=Run) 0x80
2316
2317 Take us out of reset, mute output, master + TX + RX interrupts on.
2318
2319 We'll get an interrupt presumably to tell us that the TX
2320 register is clear.
2321 */
2322
2323 wavefront_should_cause_interrupt(0x80|0x40|0x10|0x1,
2324 dev.control_port,
2325 (reset_time*HZ)/100);
2326
2327 /* Note: data port is now the data port, not the h/w initialization
2328 port.
2329 */
2330
2331 if (!dev.irq_ok) {
2332 printk (KERN_WARNING LOGNAME
2333 "intr not received after h/w un-reset.\n");
2334 goto gone_bad;
2335 }
2336
2337 dev.interrupts_on = 1;
2338
2339 /* Note: data port is now the data port, not the h/w initialization
2340 port.
2341
2342 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
2343 will work. So, issue one of them, and wait for TX
2344 interrupt. This can take a *long* time after a cold boot,
2345 while the ISC ROM does its RAM test. The SDK says up to 4
2346 seconds - with 12MB of RAM on a Tropez+, it takes a lot
2347 longer than that (~16secs). Note that the card understands
2348 the difference between a warm and a cold boot, so
2349 subsequent ISC2115 reboots (say, caused by module
2350 reloading) will get through this much faster.
2351
2352 XXX Interesting question: why is no RX interrupt received first ?
2353 */
2354
2355 wavefront_should_cause_interrupt(WFC_HARDWARE_VERSION,
2356 dev.data_port, ramcheck_time*HZ);
2357
2358 if (!dev.irq_ok) {
2359 printk (KERN_WARNING LOGNAME
2360 "post-RAM-check interrupt not received.\n");
2361 goto gone_bad;
2362 }
2363
2364 if (!wavefront_wait (STAT_CAN_READ)) {
2365 printk (KERN_WARNING LOGNAME
2366 "no response to HW version cmd.\n");
2367 goto gone_bad;
2368 }
2369
2370 if ((hwv[0] = wavefront_read ()) == -1) {
2371 printk (KERN_WARNING LOGNAME
2372 "board not responding correctly.\n");
2373 goto gone_bad;
2374 }
2375
2376 if (hwv[0] == 0xFF) { /* NAK */
2377
2378 /* Board's RAM test failed. Try to read error code,
2379 and tell us about it either way.
2380 */
2381
2382 if ((hwv[0] = wavefront_read ()) == -1) {
2383 printk (KERN_WARNING LOGNAME "on-board RAM test failed "
2384 "(bad error code).\n");
2385 } else {
2386 printk (KERN_WARNING LOGNAME "on-board RAM test failed "
2387 "(error code: 0x%x).\n",
2388 hwv[0]);
2389 }
2390 goto gone_bad;
2391 }
2392
2393 /* We're OK, just get the next byte of the HW version response */
2394
2395 if ((hwv[1] = wavefront_read ()) == -1) {
2396 printk (KERN_WARNING LOGNAME "incorrect h/w response.\n");
2397 goto gone_bad;
2398 }
2399
2400 printk (KERN_INFO LOGNAME "hardware version %d.%d\n",
2401 hwv[0], hwv[1]);
2402
2403 return 0;
2404
2405
2406 gone_bad:
2407 if (dev.irq >= 0) {
2408 free_irq (dev.irq, &dev);
2409 dev.irq = -1;
2410 }
2411 return (1);
2412 }
2413
2414 static int __init detect_wavefront (int irq, int io_base)
2415 {
2416 unsigned char rbuf[4], wbuf[4];
2417
2418 /* TB docs say the device takes up 8 ports, but we know that
2419 if there is an FX device present (i.e. a Tropez+) it really
2420 consumes 16.
2421 */
2422
2423 if (check_region (io_base, 16)) {
2424 printk (KERN_ERR LOGNAME "IO address range 0x%x - 0x%x "
2425 "already in use - ignored\n", dev.base,
2426 dev.base+15);
2427 return -1;
2428 }
2429
2430 dev.irq = irq;
2431 dev.base = io_base;
2432 dev.israw = 0;
2433 dev.debug = debug_default;
2434 dev.interrupts_on = 0;
2435 dev.irq_cnt = 0;
2436 dev.rom_samples_rdonly = 1; /* XXX default lock on ROM sample slots */
2437
2438 if (wavefront_cmd (WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2439
2440 dev.fw_version[0] = rbuf[0];
2441 dev.fw_version[1] = rbuf[1];
2442 printk (KERN_INFO LOGNAME
2443 "firmware %d.%d already loaded.\n",
2444 rbuf[0], rbuf[1]);
2445
2446 /* check that a command actually works */
2447
2448 if (wavefront_cmd (WFC_HARDWARE_VERSION,
2449 rbuf, wbuf) == 0) {
2450 dev.hw_version[0] = rbuf[0];
2451 dev.hw_version[1] = rbuf[1];
2452 } else {
2453 printk (KERN_WARNING LOGNAME "not raw, but no "
2454 "hardware version!\n");
2455 return 0;
2456 }
2457
2458 if (!wf_raw) {
2459 return 1;
2460 } else {
2461 printk (KERN_INFO LOGNAME
2462 "reloading firmware anyway.\n");
2463 dev.israw = 1;
2464 }
2465
2466 } else {
2467
2468 dev.israw = 1;
2469 printk (KERN_INFO LOGNAME
2470 "no response to firmware probe, assume raw.\n");
2471
2472 }
2473
2474 init_waitqueue_head (&dev.interrupt_sleeper);
2475
2476 if (wavefront_hw_reset ()) {
2477 printk (KERN_WARNING LOGNAME "hardware reset failed\n");
2478 return 0;
2479 }
2480
2481 /* Check for FX device, present only on Tropez+ */
2482
2483 dev.has_fx = (detect_wffx () == 0);
2484
2485 return 1;
2486 }
2487
2488 #include "os.h"
2489 #include <linux/fs.h>
2490 #include <linux/mm.h>
2491 #include <linux/slab.h>
2492 #include <asm/uaccess.h>
2493
2494
2495 static int
2496 wavefront_download_firmware (char *path)
2497
2498 {
2499 unsigned char section[WF_SECTION_MAX];
2500 char section_length; /* yes, just a char; max value is WF_SECTION_MAX */
2501 int section_cnt_downloaded = 0;
2502 int fd;
2503 int c;
2504 int i;
2505 mm_segment_t fs;
2506
2507 /* This tries to be a bit cleverer than the stuff Alan Cox did for
2508 the generic sound firmware, in that it actually knows
2509 something about the structure of the Motorola firmware. In
2510 particular, it uses a version that has been stripped of the
2511 20K of useless header information, and had section lengths
2512 added, making it possible to load the entire OS without any
2513 [kv]malloc() activity, since the longest entity we ever read is
2514 42 bytes (well, WF_SECTION_MAX) long.
2515 */
2516
2517 fs = get_fs();
2518 set_fs (get_ds());
2519
2520 if ((fd = sys_open (path, 0, 0)) < 0) {
2521 printk (KERN_WARNING LOGNAME "Unable to load \"%s\".\n",
2522 path);
2523 return 1;
2524 }
2525
2526 while (1) {
2527 int x;
2528
2529 if ((x = sys_read (fd, §ion_length, sizeof (section_length))) !=
2530 sizeof (section_length)) {
2531 printk (KERN_ERR LOGNAME "firmware read error.\n");
2532 goto failure;
2533 }
2534
2535 if (section_length == 0) {
2536 break;
2537 }
2538
2539 if (sys_read (fd, section, section_length) != section_length) {
2540 printk (KERN_ERR LOGNAME "firmware section "
2541 "read error.\n");
2542 goto failure;
2543 }
2544
2545 /* Send command */
2546
2547 if (wavefront_write (WFC_DOWNLOAD_OS)) {
2548 goto failure;
2549 }
2550
2551 for (i = 0; i < section_length; i++) {
2552 if (wavefront_write (section[i])) {
2553 goto failure;
2554 }
2555 }
2556
2557 /* get ACK */
2558
2559 if (wavefront_wait (STAT_CAN_READ)) {
2560
2561 if ((c = inb (dev.data_port)) != WF_ACK) {
2562
2563 printk (KERN_ERR LOGNAME "download "
2564 "of section #%d not "
2565 "acknowledged, ack = 0x%x\n",
2566 section_cnt_downloaded + 1, c);
2567 goto failure;
2568
2569 }
2570
2571 } else {
2572 printk (KERN_ERR LOGNAME "time out for firmware ACK.\n");
2573 goto failure;
2574 }
2575
2576 }
2577
2578 sys_close (fd);
2579 set_fs (fs);
2580 return 0;
2581
2582 failure:
2583 sys_close (fd);
2584 set_fs (fs);
2585 printk (KERN_ERR "\nWaveFront: firmware download failed!!!\n");
2586 return 1;
2587 }
2588
2589 static int __init wavefront_config_midi (void)
2590 {
2591 unsigned char rbuf[4], wbuf[4];
2592
2593 if (detect_wf_mpu (dev.irq, dev.base) < 0) {
2594 printk (KERN_WARNING LOGNAME
2595 "could not find working MIDI device\n");
2596 return -1;
2597 }
2598
2599 if ((dev.mididev = install_wf_mpu ()) < 0) {
2600 printk (KERN_WARNING LOGNAME
2601 "MIDI interfaces not configured\n");
2602 return -1;
2603 }
2604
2605 /* Route external MIDI to WaveFront synth (by default) */
2606
2607 if (wavefront_cmd (WFC_MISYNTH_ON, rbuf, wbuf)) {
2608 printk (KERN_WARNING LOGNAME
2609 "cannot enable MIDI-IN to synth routing.\n");
2610 /* XXX error ? */
2611 }
2612
2613
2614 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2615 /* Get the regular MIDI patch loading function, so we can
2616 use it if we ever get handed a SYSEX patch. This is
2617 unlikely, because its so damn slow, but we may as well
2618 leave this functionality from maui.c behind, since it
2619 could be useful for sequencer applications that can
2620 only use MIDI to do patch loading.
2621 */
2622
2623 if (midi_devs[dev.mididev]->converter != NULL) {
2624 midi_load_patch = midi_devs[dev.mididev]->converter->load_patch;
2625 midi_devs[dev.mididev]->converter->load_patch =
2626 &wavefront_oss_load_patch;
2627 }
2628
2629 #endif /* OSS_SUPPORT_SEQ */
2630
2631 /* Turn on Virtual MIDI, but first *always* turn it off,
2632 since otherwise consectutive reloads of the driver will
2633 never cause the hardware to generate the initial "internal" or
2634 "external" source bytes in the MIDI data stream. This
2635 is pretty important, since the internal hardware generally will
2636 be used to generate none or very little MIDI output, and
2637 thus the only source of MIDI data is actually external. Without
2638 the switch bytes, the driver will think it all comes from
2639 the internal interface. Duh.
2640 */
2641
2642 if (wavefront_cmd (WFC_VMIDI_OFF, rbuf, wbuf)) {
2643 printk (KERN_WARNING LOGNAME
2644 "virtual MIDI mode not disabled\n");
2645 return 0; /* We're OK, but missing the external MIDI dev */
2646 }
2647
2648 if ((dev.ext_mididev = virtual_midi_enable ()) < 0) {
2649 printk (KERN_WARNING LOGNAME "no virtual MIDI access.\n");
2650 } else {
2651 if (wavefront_cmd (WFC_VMIDI_ON, rbuf, wbuf)) {
2652 printk (KERN_WARNING LOGNAME
2653 "cannot enable virtual MIDI mode.\n");
2654 virtual_midi_disable ();
2655 }
2656 }
2657
2658 return 0;
2659 }
2660
2661 static int __init wavefront_do_reset (int atboot)
2662 {
2663 char voices[1];
2664
2665 if (!atboot && wavefront_hw_reset ()) {
2666 printk (KERN_WARNING LOGNAME "hw reset failed.\n");
2667 goto gone_bad;
2668 }
2669
2670 if (dev.israw) {
2671 if (wavefront_download_firmware (ospath)) {
2672 goto gone_bad;
2673 }
2674
2675 dev.israw = 0;
2676
2677 /* Wait for the OS to get running. The protocol for
2678 this is non-obvious, and was determined by
2679 using port-IO tracing in DOSemu and some
2680 experimentation here.
2681
2682 Rather than using timed waits, use interrupts creatively.
2683 */
2684
2685 wavefront_should_cause_interrupt (WFC_NOOP,
2686 dev.data_port,
2687 (osrun_time*HZ));
2688
2689 if (!dev.irq_ok) {
2690 printk (KERN_WARNING LOGNAME
2691 "no post-OS interrupt.\n");
2692 goto gone_bad;
2693 }
2694
2695 /* Now, do it again ! */
2696
2697 wavefront_should_cause_interrupt (WFC_NOOP,
2698 dev.data_port, (10*HZ));
2699
2700 if (!dev.irq_ok) {
2701 printk (KERN_WARNING LOGNAME
2702 "no post-OS interrupt(2).\n");
2703 goto gone_bad;
2704 }
2705
2706 /* OK, no (RX/TX) interrupts any more, but leave mute
2707 in effect.
2708 */
2709
2710 outb (0x80|0x40, dev.control_port);
2711
2712 /* No need for the IRQ anymore */
2713
2714 free_irq (dev.irq, &dev);
2715
2716 }
2717
2718 if (dev.has_fx && fx_raw) {
2719 wffx_init ();
2720 }
2721
2722 /* SETUPSND.EXE asks for sample memory config here, but since i
2723 have no idea how to interpret the result, we'll forget
2724 about it.
2725 */
2726
2727 if ((dev.freemem = wavefront_freemem ()) < 0) {
2728 goto gone_bad;
2729 }
2730
2731 printk (KERN_INFO LOGNAME "available DRAM %dk\n", dev.freemem / 1024);
2732
2733 if (wavefront_write (0xf0) ||
2734 wavefront_write (1) ||
2735 (wavefront_read () < 0)) {
2736 dev.debug = 0;
2737 printk (KERN_WARNING LOGNAME "MPU emulation mode not set.\n");
2738 goto gone_bad;
2739 }
2740
2741 voices[0] = 32;
2742
2743 if (wavefront_cmd (WFC_SET_NVOICES, NULL, voices)) {
2744 printk (KERN_WARNING LOGNAME
2745 "cannot set number of voices to 32.\n");
2746 goto gone_bad;
2747 }
2748
2749
2750 return 0;
2751
2752 gone_bad:
2753 /* reset that sucker so that it doesn't bother us. */
2754
2755 outb (0x0, dev.control_port);
2756 dev.interrupts_on = 0;
2757 if (dev.irq >= 0) {
2758 free_irq (dev.irq, &dev);
2759 }
2760 return 1;
2761 }
2762
2763 static int __init wavefront_init (int atboot)
2764 {
2765 int samples_are_from_rom;
2766
2767 if (dev.israw) {
2768 samples_are_from_rom = 1;
2769 } else {
2770 /* XXX is this always true ? */
2771 samples_are_from_rom = 0;
2772 }
2773
2774 if (dev.israw || fx_raw) {
2775 if (wavefront_do_reset (atboot)) {
2776 return -1;
2777 }
2778 }
2779
2780 wavefront_get_sample_status (samples_are_from_rom);
2781 wavefront_get_program_status ();
2782 wavefront_get_patch_status ();
2783
2784 /* Start normal operation: unreset, master interrupt enabled, no mute
2785 */
2786
2787 outb (0x80|0x40|0x20, dev.control_port);
2788
2789 return (0);
2790 }
2791
2792 static int __init install_wavefront (void)
2793
2794 {
2795 if ((dev.synth_dev = register_sound_synth (&wavefront_fops, -1)) < 0) {
2796 printk (KERN_ERR LOGNAME "cannot register raw synth\n");
2797 return -1;
2798 }
2799
2800 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2801 if ((dev.oss_dev = sound_alloc_synthdev()) == -1) {
2802 printk (KERN_ERR LOGNAME "Too many sequencers\n");
2803 return -1;
2804 } else {
2805 synth_devs[dev.oss_dev] = &wavefront_operations;
2806 }
2807 #endif /* OSS_SUPPORT_SEQ */
2808
2809 if (wavefront_init (1) < 0) {
2810 printk (KERN_WARNING LOGNAME "initialization failed.\n");
2811
2812 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2813 sound_unload_synthdev (dev.oss_dev);
2814 #endif /* OSS_SUPPORT_SEQ */
2815
2816 return -1;
2817 }
2818
2819 request_region (dev.base+2, 6, "wavefront synth");
2820
2821 if (dev.has_fx) {
2822 request_region (dev.base+8, 8, "wavefront fx");
2823 }
2824
2825 if (wavefront_config_midi ()) {
2826 printk (KERN_WARNING LOGNAME "could not initialize MIDI.\n");
2827 }
2828
2829 return dev.oss_dev;
2830 }
2831
2832 static void __exit uninstall_wavefront (void)
2833 {
2834 /* the first two i/o addresses are freed by the wf_mpu code */
2835 release_region (dev.base+2, 6);
2836
2837 if (dev.has_fx) {
2838 release_region (dev.base+8, 8);
2839 }
2840
2841 unregister_sound_synth (dev.synth_dev);
2842
2843 #if OSS_SUPPORT_LEVEL & OSS_SUPPORT_SEQ
2844 sound_unload_synthdev (dev.oss_dev);
2845 #endif /* OSS_SUPPORT_SEQ */
2846 uninstall_wf_mpu ();
2847 }
2848
2849 /***********************************************************************/
2850 /* WaveFront FX control */
2851 /***********************************************************************/
2852
2853 #include "yss225.h"
2854
2855 /* Control bits for the Load Control Register
2856 */
2857
2858 #define FX_LSB_TRANSFER 0x01 /* transfer after DSP LSB byte written */
2859 #define FX_MSB_TRANSFER 0x02 /* transfer after DSP MSB byte written */
2860 #define FX_AUTO_INCR 0x04 /* auto-increment DSP address after transfer */
2861
2862 static int
2863 wffx_idle (void)
2864
2865 {
2866 int i;
2867 unsigned int x = 0x80;
2868
2869 for (i = 0; i < 1000; i++) {
2870 x = inb (dev.fx_status);
2871 if ((x & 0x80) == 0) {
2872 break;
2873 }
2874 }
2875
2876 if (x & 0x80) {
2877 printk (KERN_ERR LOGNAME "FX device never idle.\n");
2878 return 0;
2879 }
2880
2881 return (1);
2882 }
2883
2884 int __init detect_wffx (void)
2885 {
2886 /* This is a crude check, but its the best one I have for now.
2887 Certainly on the Maui and the Tropez, wffx_idle() will
2888 report "never idle", which suggests that this test should
2889 work OK.
2890 */
2891
2892 if (inb (dev.fx_status) & 0x80) {
2893 printk (KERN_INFO LOGNAME "Hmm, probably a Maui or Tropez.\n");
2894 return -1;
2895 }
2896
2897 return 0;
2898 }
2899
2900 void
2901 wffx_mute (int onoff)
2902
2903 {
2904 if (!wffx_idle()) {
2905 return;
2906 }
2907
2908 outb (onoff ? 0x02 : 0x00, dev.fx_op);
2909 }
2910
2911 static int
2912 wffx_memset (int page,
2913 int addr, int cnt, unsigned short *data)
2914 {
2915 if (page < 0 || page > 7) {
2916 printk (KERN_ERR LOGNAME "FX memset: "
2917 "page must be >= 0 and <= 7\n");
2918 return -(EINVAL);
2919 }
2920
2921 if (addr < 0 || addr > 0x7f) {
2922 printk (KERN_ERR LOGNAME "FX memset: "
2923 "addr must be >= 0 and <= 7f\n");
2924 return -(EINVAL);
2925 }
2926
2927 if (cnt == 1) {
2928
2929 outb (FX_LSB_TRANSFER, dev.fx_lcr);
2930 outb (page, dev.fx_dsp_page);
2931 outb (addr, dev.fx_dsp_addr);
2932 outb ((data[0] >> 8), dev.fx_dsp_msb);
2933 outb ((data[0] & 0xff), dev.fx_dsp_lsb);
2934
2935 printk (KERN_INFO LOGNAME "FX: addr %d:%x set to 0x%x\n",
2936 page, addr, data[0]);
2937
2938 } else {
2939 int i;
2940
2941 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
2942 outb (page, dev.fx_dsp_page);
2943 outb (addr, dev.fx_dsp_addr);
2944
2945 for (i = 0; i < cnt; i++) {
2946 outb ((data[i] >> 8), dev.fx_dsp_msb);
2947 outb ((data[i] & 0xff), dev.fx_dsp_lsb);
2948 if (!wffx_idle ()) {
2949 break;
2950 }
2951 }
2952
2953 if (i != cnt) {
2954 printk (KERN_WARNING LOGNAME
2955 "FX memset "
2956 "(0x%x, 0x%x, %p, %d) incomplete\n",
2957 page, addr, data, cnt);
2958 return -(EIO);
2959 }
2960 }
2961
2962 return 0;
2963 }
2964
2965 static int
2966 wffx_ioctl (wavefront_fx_info *r)
2967
2968 {
2969 unsigned short page_data[256];
2970 unsigned short *pd;
2971
2972 switch (r->request) {
2973 case WFFX_MUTE:
2974 wffx_mute (r->data[0]);
2975 return 0;
2976
2977 case WFFX_MEMSET:
2978
2979 if (r->data[2] <= 0) {
2980 printk (KERN_ERR LOGNAME "cannot write "
2981 "<= 0 bytes to FX\n");
2982 return -(EINVAL);
2983 } else if (r->data[2] == 1) {
2984 pd = (unsigned short *) &r->data[3];
2985 } else {
2986 if (r->data[2] > sizeof (page_data)) {
2987 printk (KERN_ERR LOGNAME "cannot write "
2988 "> 255 bytes to FX\n");
2989 return -(EINVAL);
2990 }
2991 if (copy_from_user(page_data,
2992 (unsigned char __user *)r->data[3],
2993 r->data[2]))
2994 return -EFAULT;
2995 pd = page_data;
2996 }
2997
2998 return wffx_memset (r->data[0], /* page */
2999 r->data[1], /* addr */
3000 r->data[2], /* cnt */
3001 pd);
3002
3003 default:
3004 printk (KERN_WARNING LOGNAME
3005 "FX: ioctl %d not yet supported\n",
3006 r->request);
3007 return -(EINVAL);
3008 }
3009 }
3010
3011 /* YSS225 initialization.
3012
3013 This code was developed using DOSEMU. The Turtle Beach SETUPSND
3014 utility was run with I/O tracing in DOSEMU enabled, and a reconstruction
3015 of the port I/O done, using the Yamaha faxback document as a guide
3016 to add more logic to the code. Its really pretty weird.
3017
3018 There was an alternative approach of just dumping the whole I/O
3019 sequence as a series of port/value pairs and a simple loop
3020 that output it. However, I hope that eventually I'll get more
3021 control over what this code does, and so I tried to stick with
3022 a somewhat "algorithmic" approach.
3023 */
3024
3025 static int __init wffx_init (void)
3026 {
3027 int i;
3028 int j;
3029
3030 /* Set all bits for all channels on the MOD unit to zero */
3031 /* XXX But why do this twice ? */
3032
3033 for (j = 0; j < 2; j++) {
3034 for (i = 0x10; i <= 0xff; i++) {
3035
3036 if (!wffx_idle ()) {
3037 return (-1);
3038 }
3039
3040 outb (i, dev.fx_mod_addr);
3041 outb (0x0, dev.fx_mod_data);
3042 }
3043 }
3044
3045 if (!wffx_idle()) return (-1);
3046 outb (0x02, dev.fx_op); /* mute on */
3047
3048 if (!wffx_idle()) return (-1);
3049 outb (0x07, dev.fx_dsp_page);
3050 outb (0x44, dev.fx_dsp_addr);
3051 outb (0x00, dev.fx_dsp_msb);
3052 outb (0x00, dev.fx_dsp_lsb);
3053 if (!wffx_idle()) return (-1);
3054 outb (0x07, dev.fx_dsp_page);
3055 outb (0x42, dev.fx_dsp_addr);
3056 outb (0x00, dev.fx_dsp_msb);
3057 outb (0x00, dev.fx_dsp_lsb);
3058 if (!wffx_idle()) return (-1);
3059 outb (0x07, dev.fx_dsp_page);
3060 outb (0x43, dev.fx_dsp_addr);
3061 outb (0x00, dev.fx_dsp_msb);
3062 outb (0x00, dev.fx_dsp_lsb);
3063 if (!wffx_idle()) return (-1);
3064 outb (0x07, dev.fx_dsp_page);
3065 outb (0x7c, dev.fx_dsp_addr);
3066 outb (0x00, dev.fx_dsp_msb);
3067 outb (0x00, dev.fx_dsp_lsb);
3068 if (!wffx_idle()) return (-1);
3069 outb (0x07, dev.fx_dsp_page);
3070 outb (0x7e, dev.fx_dsp_addr);
3071 outb (0x00, dev.fx_dsp_msb);
3072 outb (0x00, dev.fx_dsp_lsb);
3073 if (!wffx_idle()) return (-1);
3074 outb (0x07, dev.fx_dsp_page);
3075 outb (0x46, dev.fx_dsp_addr);
3076 outb (0x00, dev.fx_dsp_msb);
3077 outb (0x00, dev.fx_dsp_lsb);
3078 if (!wffx_idle()) return (-1);
3079 outb (0x07, dev.fx_dsp_page);
3080 outb (0x49, dev.fx_dsp_addr);
3081 outb (0x00, dev.fx_dsp_msb);
3082 outb (0x00, dev.fx_dsp_lsb);
3083 if (!wffx_idle()) return (-1);
3084 outb (0x07, dev.fx_dsp_page);
3085 outb (0x47, dev.fx_dsp_addr);
3086 outb (0x00, dev.fx_dsp_msb);
3087 outb (0x00, dev.fx_dsp_lsb);
3088 if (!wffx_idle()) return (-1);
3089 outb (0x07, dev.fx_dsp_page);
3090 outb (0x4a, dev.fx_dsp_addr);
3091 outb (0x00, dev.fx_dsp_msb);
3092 outb (0x00, dev.fx_dsp_lsb);
3093
3094 /* either because of stupidity by TB's programmers, or because it
3095 actually does something, rezero the MOD page.
3096 */
3097 for (i = 0x10; i <= 0xff; i++) {
3098
3099 if (!wffx_idle ()) {
3100 return (-1);
3101 }
3102
3103 outb (i, dev.fx_mod_addr);
3104 outb (0x0, dev.fx_mod_data);
3105 }
3106 /* load page zero */
3107
3108 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3109 outb (0x00, dev.fx_dsp_page);
3110 outb (0x00, dev.fx_dsp_addr);
3111
3112 for (i = 0; i < sizeof (page_zero); i += 2) {
3113 outb (page_zero[i], dev.fx_dsp_msb);
3114 outb (page_zero[i+1], dev.fx_dsp_lsb);
3115 if (!wffx_idle()) return (-1);
3116 }
3117
3118 /* Now load page one */
3119
3120 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3121 outb (0x01, dev.fx_dsp_page);
3122 outb (0x00, dev.fx_dsp_addr);
3123
3124 for (i = 0; i < sizeof (page_one); i += 2) {
3125 outb (page_one[i], dev.fx_dsp_msb);
3126 outb (page_one[i+1], dev.fx_dsp_lsb);
3127 if (!wffx_idle()) return (-1);
3128 }
3129
3130 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3131 outb (0x02, dev.fx_dsp_page);
3132 outb (0x00, dev.fx_dsp_addr);
3133
3134 for (i = 0; i < sizeof (page_two); i++) {
3135 outb (page_two[i], dev.fx_dsp_lsb);
3136 if (!wffx_idle()) return (-1);
3137 }
3138
3139 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3140 outb (0x03, dev.fx_dsp_page);
3141 outb (0x00, dev.fx_dsp_addr);
3142
3143 for (i = 0; i < sizeof (page_three); i++) {
3144 outb (page_three[i], dev.fx_dsp_lsb);
3145 if (!wffx_idle()) return (-1);
3146 }
3147
3148 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3149 outb (0x04, dev.fx_dsp_page);
3150 outb (0x00, dev.fx_dsp_addr);
3151
3152 for (i = 0; i < sizeof (page_four); i++) {
3153 outb (page_four[i], dev.fx_dsp_lsb);
3154 if (!wffx_idle()) return (-1);
3155 }
3156
3157 /* Load memory area (page six) */
3158
3159 outb (FX_LSB_TRANSFER, dev.fx_lcr);
3160 outb (0x06, dev.fx_dsp_page);
3161
3162 for (i = 0; i < sizeof (page_six); i += 3) {
3163 outb (page_six[i], dev.fx_dsp_addr);
3164 outb (page_six[i+1], dev.fx_dsp_msb);
3165 outb (page_six[i+2], dev.fx_dsp_lsb);
3166 if (!wffx_idle()) return (-1);
3167 }
3168
3169 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3170 outb (0x07, dev.fx_dsp_page);
3171 outb (0x00, dev.fx_dsp_addr);
3172
3173 for (i = 0; i < sizeof (page_seven); i += 2) {
3174 outb (page_seven[i], dev.fx_dsp_msb);
3175 outb (page_seven[i+1], dev.fx_dsp_lsb);
3176 if (!wffx_idle()) return (-1);
3177 }
3178
3179 /* Now setup the MOD area. We do this algorithmically in order to
3180 save a little data space. It could be done in the same fashion
3181 as the "pages".
3182 */
3183
3184 for (i = 0x00; i <= 0x0f; i++) {
3185 outb (0x01, dev.fx_mod_addr);
3186 outb (i, dev.fx_mod_data);
3187 if (!wffx_idle()) return (-1);
3188 outb (0x02, dev.fx_mod_addr);
3189 outb (0x00, dev.fx_mod_data);
3190 if (!wffx_idle()) return (-1);
3191 }
3192
3193 for (i = 0xb0; i <= 0xbf; i++) {
3194 outb (i, dev.fx_mod_addr);
3195 outb (0x20, dev.fx_mod_data);
3196 if (!wffx_idle()) return (-1);
3197 }
3198
3199 for (i = 0xf0; i <= 0xff; i++) {
3200 outb (i, dev.fx_mod_addr);
3201 outb (0x20, dev.fx_mod_data);
3202 if (!wffx_idle()) return (-1);
3203 }
3204
3205 for (i = 0x10; i <= 0x1d; i++) {
3206 outb (i, dev.fx_mod_addr);
3207 outb (0xff, dev.fx_mod_data);
3208 if (!wffx_idle()) return (-1);
3209 }
3210
3211 outb (0x1e, dev.fx_mod_addr);
3212 outb (0x40, dev.fx_mod_data);
3213 if (!wffx_idle()) return (-1);
3214
3215 for (i = 0x1f; i <= 0x2d; i++) {
3216 outb (i, dev.fx_mod_addr);
3217 outb (0xff, dev.fx_mod_data);
3218 if (!wffx_idle()) return (-1);
3219 }
3220
3221 outb (0x2e, dev.fx_mod_addr);
3222 outb (0x00, dev.fx_mod_data);
3223 if (!wffx_idle()) return (-1);
3224
3225 for (i = 0x2f; i <= 0x3e; i++) {
3226 outb (i, dev.fx_mod_addr);
3227 outb (0x00, dev.fx_mod_data);
3228 if (!wffx_idle()) return (-1);
3229 }
3230
3231 outb (0x3f, dev.fx_mod_addr);
3232 outb (0x20, dev.fx_mod_data);
3233 if (!wffx_idle()) return (-1);
3234
3235 for (i = 0x40; i <= 0x4d; i++) {
3236 outb (i, dev.fx_mod_addr);
3237 outb (0x00, dev.fx_mod_data);
3238 if (!wffx_idle()) return (-1);
3239 }
3240
3241 outb (0x4e, dev.fx_mod_addr);
3242 outb (0x0e, dev.fx_mod_data);
3243 if (!wffx_idle()) return (-1);
3244 outb (0x4f, dev.fx_mod_addr);
3245 outb (0x0e, dev.fx_mod_data);
3246 if (!wffx_idle()) return (-1);
3247
3248
3249 for (i = 0x50; i <= 0x6b; i++) {
3250 outb (i, dev.fx_mod_addr);
3251 outb (0x00, dev.fx_mod_data);
3252 if (!wffx_idle()) return (-1);
3253 }
3254
3255 outb (0x6c, dev.fx_mod_addr);
3256 outb (0x40, dev.fx_mod_data);
3257 if (!wffx_idle()) return (-1);
3258
3259 outb (0x6d, dev.fx_mod_addr);
3260 outb (0x00, dev.fx_mod_data);
3261 if (!wffx_idle()) return (-1);
3262
3263 outb (0x6e, dev.fx_mod_addr);
3264 outb (0x40, dev.fx_mod_data);
3265 if (!wffx_idle()) return (-1);
3266
3267 outb (0x6f, dev.fx_mod_addr);
3268 outb (0x40, dev.fx_mod_data);
3269 if (!wffx_idle()) return (-1);
3270
3271 for (i = 0x70; i <= 0x7f; i++) {
3272 outb (i, dev.fx_mod_addr);
3273 outb (0xc0, dev.fx_mod_data);
3274 if (!wffx_idle()) return (-1);
3275 }
3276
3277 for (i = 0x80; i <= 0xaf; i++) {
3278 outb (i, dev.fx_mod_addr);
3279 outb (0x00, dev.fx_mod_data);
3280 if (!wffx_idle()) return (-1);
3281 }
3282
3283 for (i = 0xc0; i <= 0xdd; i++) {
3284 outb (i, dev.fx_mod_addr);
3285 outb (0x00, dev.fx_mod_data);
3286 if (!wffx_idle()) return (-1);
3287 }
3288
3289 outb (0xde, dev.fx_mod_addr);
3290 outb (0x10, dev.fx_mod_data);
3291 if (!wffx_idle()) return (-1);
3292 outb (0xdf, dev.fx_mod_addr);
3293 outb (0x10, dev.fx_mod_data);
3294 if (!wffx_idle()) return (-1);
3295
3296 for (i = 0xe0; i <= 0xef; i++) {
3297 outb (i, dev.fx_mod_addr);
3298 outb (0x00, dev.fx_mod_data);
3299 if (!wffx_idle()) return (-1);
3300 }
3301
3302 for (i = 0x00; i <= 0x0f; i++) {
3303 outb (0x01, dev.fx_mod_addr);
3304 outb (i, dev.fx_mod_data);
3305 outb (0x02, dev.fx_mod_addr);
3306 outb (0x01, dev.fx_mod_data);
3307 if (!wffx_idle()) return (-1);
3308 }
3309
3310 outb (0x02, dev.fx_op); /* mute on */
3311
3312 /* Now set the coefficients and so forth for the programs above */
3313
3314 for (i = 0; i < sizeof (coefficients); i += 4) {
3315 outb (coefficients[i], dev.fx_dsp_page);
3316 outb (coefficients[i+1], dev.fx_dsp_addr);
3317 outb (coefficients[i+2], dev.fx_dsp_msb);
3318 outb (coefficients[i+3], dev.fx_dsp_lsb);
3319 if (!wffx_idle()) return (-1);
3320 }
3321
3322 /* Some settings (?) that are too small to bundle into loops */
3323
3324 if (!wffx_idle()) return (-1);
3325 outb (0x1e, dev.fx_mod_addr);
3326 outb (0x14, dev.fx_mod_data);
3327 if (!wffx_idle()) return (-1);
3328 outb (0xde, dev.fx_mod_addr);
3329 outb (0x20, dev.fx_mod_data);
3330 if (!wffx_idle()) return (-1);
3331 outb (0xdf, dev.fx_mod_addr);
3332 outb (0x20, dev.fx_mod_data);
3333
3334 /* some more coefficients */
3335
3336 if (!wffx_idle()) return (-1);
3337 outb (0x06, dev.fx_dsp_page);
3338 outb (0x78, dev.fx_dsp_addr);
3339 outb (0x00, dev.fx_dsp_msb);
3340 outb (0x40, dev.fx_dsp_lsb);
3341 if (!wffx_idle()) return (-1);
3342 outb (0x07, dev.fx_dsp_page);
3343 outb (0x03, dev.fx_dsp_addr);
3344 outb (0x0f, dev.fx_dsp_msb);
3345 outb (0xff, dev.fx_dsp_lsb);
3346 if (!wffx_idle()) return (-1);
3347 outb (0x07, dev.fx_dsp_page);
3348 outb (0x0b, dev.fx_dsp_addr);
3349 outb (0x0f, dev.fx_dsp_msb);
3350 outb (0xff, dev.fx_dsp_lsb);
3351 if (!wffx_idle()) return (-1);
3352 outb (0x07, dev.fx_dsp_page);
3353 outb (0x02, dev.fx_dsp_addr);
3354 outb (0x00, dev.fx_dsp_msb);
3355 outb (0x00, dev.fx_dsp_lsb);
3356 if (!wffx_idle()) return (-1);
3357 outb (0x07, dev.fx_dsp_page);
3358 outb (0x0a, dev.fx_dsp_addr);
3359 outb (0x00, dev.fx_dsp_msb);
3360 outb (0x00, dev.fx_dsp_lsb);
3361 if (!wffx_idle()) return (-1);
3362 outb (0x07, dev.fx_dsp_page);
3363 outb (0x46, dev.fx_dsp_addr);
3364 outb (0x00, dev.fx_dsp_msb);
3365 outb (0x00, dev.fx_dsp_lsb);
3366 if (!wffx_idle()) return (-1);
3367 outb (0x07, dev.fx_dsp_page);
3368 outb (0x49, dev.fx_dsp_addr);
3369 outb (0x00, dev.fx_dsp_msb);
3370 outb (0x00, dev.fx_dsp_lsb);
3371
3372 /* Now, for some strange reason, lets reload every page
3373 and all the coefficients over again. I have *NO* idea
3374 why this is done. I do know that no sound is produced
3375 is this phase is omitted.
3376 */
3377
3378 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3379 outb (0x00, dev.fx_dsp_page);
3380 outb (0x10, dev.fx_dsp_addr);
3381
3382 for (i = 0; i < sizeof (page_zero_v2); i += 2) {
3383 outb (page_zero_v2[i], dev.fx_dsp_msb);
3384 outb (page_zero_v2[i+1], dev.fx_dsp_lsb);
3385 if (!wffx_idle()) return (-1);
3386 }
3387
3388 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3389 outb (0x01, dev.fx_dsp_page);
3390 outb (0x10, dev.fx_dsp_addr);
3391
3392 for (i = 0; i < sizeof (page_one_v2); i += 2) {
3393 outb (page_one_v2[i], dev.fx_dsp_msb);
3394 outb (page_one_v2[i+1], dev.fx_dsp_lsb);
3395 if (!wffx_idle()) return (-1);
3396 }
3397
3398 if (!wffx_idle()) return (-1);
3399 if (!wffx_idle()) return (-1);
3400
3401 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3402 outb (0x02, dev.fx_dsp_page);
3403 outb (0x10, dev.fx_dsp_addr);
3404
3405 for (i = 0; i < sizeof (page_two_v2); i++) {
3406 outb (page_two_v2[i], dev.fx_dsp_lsb);
3407 if (!wffx_idle()) return (-1);
3408 }
3409 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3410 outb (0x03, dev.fx_dsp_page);
3411 outb (0x10, dev.fx_dsp_addr);
3412
3413 for (i = 0; i < sizeof (page_three_v2); i++) {
3414 outb (page_three_v2[i], dev.fx_dsp_lsb);
3415 if (!wffx_idle()) return (-1);
3416 }
3417
3418 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3419 outb (0x04, dev.fx_dsp_page);
3420 outb (0x10, dev.fx_dsp_addr);
3421
3422 for (i = 0; i < sizeof (page_four_v2); i++) {
3423 outb (page_four_v2[i], dev.fx_dsp_lsb);
3424 if (!wffx_idle()) return (-1);
3425 }
3426
3427 outb (FX_LSB_TRANSFER, dev.fx_lcr);
3428 outb (0x06, dev.fx_dsp_page);
3429
3430 /* Page six v.2 is algorithmic */
3431
3432 for (i = 0x10; i <= 0x3e; i += 2) {
3433 outb (i, 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 }
3438
3439 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev.fx_lcr);
3440 outb (0x07, dev.fx_dsp_page);
3441 outb (0x10, dev.fx_dsp_addr);
3442
3443 for (i = 0; i < sizeof (page_seven_v2); i += 2) {
3444 outb (page_seven_v2[i], dev.fx_dsp_msb);
3445 outb (page_seven_v2[i+1], dev.fx_dsp_lsb);
3446 if (!wffx_idle()) return (-1);
3447 }
3448
3449 for (i = 0x00; i < sizeof(mod_v2); i += 2) {
3450 outb (mod_v2[i], dev.fx_mod_addr);
3451 outb (mod_v2[i+1], dev.fx_mod_data);
3452 if (!wffx_idle()) return (-1);
3453 }
3454
3455 for (i = 0; i < sizeof (coefficients2); i += 4) {
3456 outb (coefficients2[i], dev.fx_dsp_page);
3457 outb (coefficients2[i+1], dev.fx_dsp_addr);
3458 outb (coefficients2[i+2], dev.fx_dsp_msb);
3459 outb (coefficients2[i+3], dev.fx_dsp_lsb);
3460 if (!wffx_idle()) return (-1);
3461 }
3462
3463 for (i = 0; i < sizeof (coefficients3); i += 2) {
3464 int x;
3465
3466 outb (0x07, dev.fx_dsp_page);
3467 x = (i % 4) ? 0x4e : 0x4c;
3468 outb (x, dev.fx_dsp_addr);
3469 outb (coefficients3[i], dev.fx_dsp_msb);
3470 outb (coefficients3[i+1], dev.fx_dsp_lsb);
3471 }
3472
3473 outb (0x00, dev.fx_op); /* mute off */
3474 if (!wffx_idle()) return (-1);
3475
3476 return (0);
3477 }
3478
3479 static int io = -1;
3480 static int irq = -1;
3481
3482 MODULE_AUTHOR ("Paul Barton-Davis <pbd@op.net>");
3483 MODULE_DESCRIPTION ("Turtle Beach WaveFront Linux Driver");
3484 MODULE_LICENSE("GPL");
3485 module_param (io, int, 0);
3486 module_param (irq, int, 0);
3487
3488 static int __init init_wavfront (void)
3489 {
3490 printk ("Turtle Beach WaveFront Driver\n"
3491 "Copyright (C) by Hannu Solvainen, "
3492 "Paul Barton-Davis 1993-1998.\n");
3493
3494 /* XXX t'would be lovely to ask the CS4232 for these values, eh ? */
3495
3496 if (io == -1 || irq == -1) {
3497 printk (KERN_INFO LOGNAME "irq and io options must be set.\n");
3498 return -EINVAL;
3499 }
3500
3501 if (wavefront_interrupt_bits (irq) < 0) {
3502 printk (KERN_INFO LOGNAME
3503 "IRQ must be 9, 5, 12 or 15 (not %d)\n", irq);
3504 return -ENODEV;
3505 }
3506
3507 if (detect_wavefront (irq, io) < 0) {
3508 return -ENODEV;
3509 }
3510
3511 if (install_wavefront () < 0) {
3512 return -EIO;
3513 }
3514
3515 return 0;
3516 }
3517
3518 static void __exit cleanup_wavfront (void)
3519 {
3520 uninstall_wavefront ();
3521 }
3522
3523 module_init(init_wavfront);
3524 module_exit(cleanup_wavfront);
3525
|
This page was automatically generated by the
LXR engine.
|