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