1 /* Copyright (C) by Paul Barton-Davis 1998-1999
3 * Some portions of this file are taken from work that is
4 * copyright (C) by Hannu Savolainen 1993-1996
6 * This program is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
7 * Version 2 (June 1991). See the "COPYING" file distributed with this software
12 * An ALSA lowlevel driver for Turtle Beach ICS2115 wavetable synth
13 * (Maui, Tropez, Tropez Plus)
15 * This driver supports the onboard wavetable synthesizer (an ICS2115),
16 * including patch, sample and program loading and unloading, conversion
17 * of GUS patches during loading, and full user-level access to all
18 * WaveFront commands. It tries to provide semi-intelligent patch and
19 * sample management as well.
23 #include <sound/driver.h>
25 #include <linux/interrupt.h>
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/time.h>
29 #include <linux/wait.h>
30 #include <linux/moduleparam.h>
31 #include <sound/core.h>
32 #include <sound/snd_wavefront.h>
33 #include <sound/initval.h>
35 int wf_raw = 0; /* we normally check for "raw state" to firmware
36 loading. if non-zero, then during driver loading, the
37 state of the board is ignored, and we reset the
38 board and load the firmware anyway.
41 int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
42 whatever state it is when the driver is loaded.
43 The default is to download the microprogram and
44 associated coefficients to set it up for "default"
45 operation, whatever that means.
48 int debug_default = 0; /* you can set this to control debugging
49 during driver loading. it takes any combination
50 of the WF_DEBUG_* flags defined in
54 /* XXX this needs to be made firmware and hardware version dependent */
56 char *ospath = "/etc/sound/wavefront.os"; /* where to find a processed
57 version of the WaveFront OS
60 int wait_usecs = 150; /* This magic number seems to give pretty optimal
61 throughput based on my limited experimentation.
62 If you want to play around with it and find a better
63 value, be my guest. Remember, the idea is to
64 get a number that causes us to just busy wait
65 for as many WaveFront commands as possible, without
66 coming up with a number so large that we hog the
69 Specifically, with this number, out of about 134,000
70 status waits, only about 250 result in a sleep.
73 int sleep_interval = 100; /* HZ/sleep_interval seconds per sleep */
74 int sleep_tries = 50; /* number of times we'll try to sleep */
76 int reset_time = 2; /* hundreths of a second we wait after a HW
77 reset for the expected interrupt.
80 int ramcheck_time = 20; /* time in seconds to wait while ROM code
84 int osrun_time = 10; /* time in seconds we wait for the OS to
87 module_param(wf_raw, int, 0444);
88 MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
89 module_param(fx_raw, int, 0444);
90 MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
91 module_param(debug_default, int, 0444);
92 MODULE_PARM_DESC(debug_default, "debug parameters for card initialization");
93 module_param(wait_usecs, int, 0444);
94 MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs");
95 module_param(sleep_interval, int, 0444);
96 MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply");
97 module_param(sleep_tries, int, 0444);
98 MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait");
99 module_param(ospath, charp, 0444);
100 MODULE_PARM_DESC(ospath, "full pathname to processed ICS2115 OS firmware");
101 module_param(reset_time, int, 0444);
102 MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect");
103 module_param(ramcheck_time, int, 0444);
104 MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test");
105 module_param(osrun_time, int, 0444);
106 MODULE_PARM_DESC(osrun_time, "how many seconds to wait for the ICS2115 OS");
108 /* if WF_DEBUG not defined, no run-time debugging messages will
109 be available via the debug flag setting. Given the current
110 beta state of the driver, this will remain set until a future
118 #if defined(NEW_MACRO_VARARGS) || __GNUC__ >= 3
119 #define DPRINT(cond, ...) \
120 if ((dev->debug & (cond)) == (cond)) { \
121 snd_printk (__VA_ARGS__); \
124 #define DPRINT(cond, args...) \
125 if ((dev->debug & (cond)) == (cond)) { \
130 #define DPRINT(cond, args...)
131 #endif /* WF_DEBUG */
133 #define LOGNAME "WaveFront: "
135 /* bitmasks for WaveFront status port value */
137 #define STAT_RINTR_ENABLED 0x01
138 #define STAT_CAN_READ 0x02
139 #define STAT_INTR_READ 0x04
140 #define STAT_WINTR_ENABLED 0x10
141 #define STAT_CAN_WRITE 0x20
142 #define STAT_INTR_WRITE 0x40
144 static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
145 static int wavefront_find_free_sample (snd_wavefront_t *);
150 unsigned int read_cnt;
151 unsigned int write_cnt;
158 } wavefront_errors[] = {
159 { 0x01, "Bad sample number" },
160 { 0x02, "Out of sample memory" },
161 { 0x03, "Bad patch number" },
162 { 0x04, "Error in number of voices" },
163 { 0x06, "Sample load already in progress" },
164 { 0x0B, "No sample load request pending" },
165 { 0x0E, "Bad MIDI channel number" },
166 { 0x10, "Download Record Error" },
173 static wavefront_command wavefront_commands[] = {
174 { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK },
175 { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0},
176 { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK },
177 { WFC_GET_NVOICES, "get number of voices", 1, 0, 0 },
178 { WFC_SET_TUNING, "set synthesizer tuning", 0, 2, NEEDS_ACK },
179 { WFC_GET_TUNING, "get synthesizer tuning", 2, 0, 0 },
180 { WFC_DISABLE_CHANNEL, "disable synth channel", 0, 1, NEEDS_ACK },
181 { WFC_ENABLE_CHANNEL, "enable synth channel", 0, 1, NEEDS_ACK },
182 { WFC_GET_CHANNEL_STATUS, "get synth channel status", 3, 0, 0 },
183 { WFC_MISYNTH_OFF, "disable midi-in to synth", 0, 0, NEEDS_ACK },
184 { WFC_MISYNTH_ON, "enable midi-in to synth", 0, 0, NEEDS_ACK },
185 { WFC_VMIDI_ON, "enable virtual midi mode", 0, 0, NEEDS_ACK },
186 { WFC_VMIDI_OFF, "disable virtual midi mode", 0, 0, NEEDS_ACK },
187 { WFC_MIDI_STATUS, "report midi status", 1, 0, 0 },
188 { WFC_FIRMWARE_VERSION, "report firmware version", 2, 0, 0 },
189 { WFC_HARDWARE_VERSION, "report hardware version", 2, 0, 0 },
190 { WFC_GET_NSAMPLES, "report number of samples", 2, 0, 0 },
191 { WFC_INSTOUT_LEVELS, "report instantaneous output levels", 7, 0, 0 },
192 { WFC_PEAKOUT_LEVELS, "report peak output levels", 7, 0, 0 },
193 { WFC_DOWNLOAD_SAMPLE, "download sample",
194 0, WF_SAMPLE_BYTES, NEEDS_ACK },
195 { WFC_DOWNLOAD_BLOCK, "download block", 0, 0, NEEDS_ACK},
196 { WFC_DOWNLOAD_SAMPLE_HEADER, "download sample header",
197 0, WF_SAMPLE_HDR_BYTES, NEEDS_ACK },
198 { WFC_UPLOAD_SAMPLE_HEADER, "upload sample header", 13, 2, 0 },
200 /* This command requires a variable number of bytes to be written.
201 There is a hack in snd_wavefront_cmd() to support this. The actual
202 count is passed in as the read buffer ptr, cast appropriately.
206 { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
208 /* This one is a hack as well. We just read the first byte of the
209 response, don't fetch an ACK, and leave the rest to the
210 calling function. Ugly, ugly, ugly.
213 { WFC_UPLOAD_MULTISAMPLE, "upload multisample", 2, 1, 0 },
214 { WFC_DOWNLOAD_SAMPLE_ALIAS, "download sample alias",
215 0, WF_ALIAS_BYTES, NEEDS_ACK },
216 { WFC_UPLOAD_SAMPLE_ALIAS, "upload sample alias", WF_ALIAS_BYTES, 2, 0},
217 { WFC_DELETE_SAMPLE, "delete sample", 0, 2, NEEDS_ACK },
218 { WFC_IDENTIFY_SAMPLE_TYPE, "identify sample type", 5, 2, 0 },
219 { WFC_UPLOAD_SAMPLE_PARAMS, "upload sample parameters" },
220 { WFC_REPORT_FREE_MEMORY, "report free memory", 4, 0, 0 },
221 { WFC_DOWNLOAD_PATCH, "download patch", 0, 134, NEEDS_ACK },
222 { WFC_UPLOAD_PATCH, "upload patch", 132, 2, 0 },
223 { WFC_DOWNLOAD_PROGRAM, "download program", 0, 33, NEEDS_ACK },
224 { WFC_UPLOAD_PROGRAM, "upload program", 32, 1, 0 },
225 { WFC_DOWNLOAD_EDRUM_PROGRAM, "download enhanced drum program", 0, 9,
227 { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
228 { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
230 { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
231 { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
233 { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
238 wavefront_errorstr (int errnum)
243 for (i = 0; wavefront_errors[i].errstr; i++) {
244 if (wavefront_errors[i].errno == errnum) {
245 return wavefront_errors[i].errstr;
249 return "Unknown WaveFront error";
252 static wavefront_command *
253 wavefront_get_command (int cmd)
258 for (i = 0; wavefront_commands[i].cmd != 0; i++) {
259 if (cmd == wavefront_commands[i].cmd) {
260 return &wavefront_commands[i];
264 return (wavefront_command *) 0;
268 wavefront_status (snd_wavefront_t *dev)
271 return inb (dev->status_port);
275 wavefront_sleep (int limit)
278 set_current_state(TASK_INTERRUPTIBLE);
279 schedule_timeout(limit);
281 return signal_pending(current);
285 wavefront_wait (snd_wavefront_t *dev, int mask)
290 /* Spin for a short period of time, because >99% of all
291 requests to the WaveFront can be serviced inline like this.
294 for (i = 0; i < wait_usecs; i += 5) {
295 if (wavefront_status (dev) & mask) {
301 for (i = 0; i < sleep_tries; i++) {
303 if (wavefront_status (dev) & mask) {
307 if (wavefront_sleep (HZ/sleep_interval)) {
316 wavefront_read (snd_wavefront_t *dev)
319 if (wavefront_wait (dev, STAT_CAN_READ))
320 return inb (dev->data_port);
322 DPRINT (WF_DEBUG_DATA, "read timeout.\n");
328 wavefront_write (snd_wavefront_t *dev, unsigned char data)
331 if (wavefront_wait (dev, STAT_CAN_WRITE)) {
332 outb (data, dev->data_port);
336 DPRINT (WF_DEBUG_DATA, "write timeout.\n");
342 snd_wavefront_cmd (snd_wavefront_t *dev,
343 int cmd, unsigned char *rbuf, unsigned char *wbuf)
349 wavefront_command *wfcmd;
351 if ((wfcmd = wavefront_get_command (cmd)) == (wavefront_command *) 0) {
352 snd_printk ("command 0x%x not supported.\n",
357 /* Hack to handle the one variable-size write command. See
358 wavefront_send_multisample() for the other half of this
359 gross and ugly strategy.
362 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
363 wfcmd->write_cnt = (unsigned long) rbuf;
367 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
368 cmd, wfcmd->action, wfcmd->read_cnt,
369 wfcmd->write_cnt, wfcmd->need_ack);
371 if (wavefront_write (dev, cmd)) {
372 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
378 if (wfcmd->write_cnt > 0) {
379 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
381 wfcmd->write_cnt, cmd);
383 for (i = 0; i < wfcmd->write_cnt; i++) {
384 if (wavefront_write (dev, wbuf[i])) {
385 DPRINT (WF_DEBUG_IO, "bad write for byte "
386 "%d of 0x%x [%s].\n",
387 i, cmd, wfcmd->action);
391 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
396 if (wfcmd->read_cnt > 0) {
397 DPRINT (WF_DEBUG_DATA, "reading %d ints "
399 wfcmd->read_cnt, cmd);
401 for (i = 0; i < wfcmd->read_cnt; i++) {
403 if ((c = wavefront_read (dev)) == -1) {
404 DPRINT (WF_DEBUG_IO, "bad read for byte "
405 "%d of 0x%x [%s].\n",
406 i, cmd, wfcmd->action);
410 /* Now handle errors. Lots of special cases here */
413 if ((c = wavefront_read (dev)) == -1) {
414 DPRINT (WF_DEBUG_IO, "bad read for "
423 /* Can you believe this madness ? */
426 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
427 rbuf[0] = WF_ST_EMPTY;
431 wfcmd->cmd == WFC_UPLOAD_PATCH) {
436 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
442 DPRINT (WF_DEBUG_IO, "error %d (%s) "
448 wavefront_errorstr (c),
459 DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
463 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
465 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
467 /* Some commands need an ACK, but return zero instead
468 of the standard value.
471 if ((ack = wavefront_read (dev)) == 0) {
477 DPRINT (WF_DEBUG_IO, "cannot read ack for "
483 int err = -1; /* something unknown */
485 if (ack == 0xff) { /* explicit error */
487 if ((err = wavefront_read (dev)) == -1) {
488 DPRINT (WF_DEBUG_DATA,
495 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
496 "failed (0x%x, 0x%x, %s)\n",
497 cmd, wfcmd->action, ack, err,
498 wavefront_errorstr (err));
504 DPRINT (WF_DEBUG_DATA, "ack received "
509 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
511 cmd, wfcmd->action, wfcmd->read_cnt,
512 wfcmd->write_cnt, wfcmd->need_ack);
519 /***********************************************************************
520 WaveFront data munging
522 Things here are weird. All data written to the board cannot
523 have its most significant bit set. Any data item with values
524 potentially > 0x7F (127) must be split across multiple bytes.
526 Sometimes, we need to munge numeric values that are represented on
527 the x86 side as 8-32 bit values. Sometimes, we need to munge data
528 that is represented on the x86 side as an array of bytes. The most
529 efficient approach to handling both cases seems to be to use 2
530 different functions for munging and 2 for de-munging. This avoids
531 weird casting and worrying about bit-level offsets.
533 **********************************************************************/
535 static unsigned char *
536 munge_int32 (unsigned int src,
538 unsigned int dst_size)
542 for (i = 0; i < dst_size; i++) {
543 *dst = src & 0x7F; /* Mask high bit of LSB */
544 src = src >> 7; /* Rotate Right 7 bits */
545 /* Note: we leave the upper bits in place */
553 demunge_int32 (unsigned char* src, int src_size)
559 for (i = src_size - 1; i >= 0; i--) {
560 outval=(outval<<7)+src[i];
568 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
572 unsigned int last = dst_size / 2;
574 for (i = 0; i < last; i++) {
575 *dst++ = src[i] & 0x7f;
576 *dst++ = src[i] >> 7;
583 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
587 unsigned char *end = src + src_bytes;
589 end = src + src_bytes;
591 /* NOTE: src and dst *CAN* point to the same address */
593 for (i = 0; src != end; i++) {
595 dst[i] |= (*src++)<<7;
601 /***********************************************************************
602 WaveFront: sample, patch and program management.
603 ***********************************************************************/
606 wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
609 unsigned char wbuf[2];
612 wbuf[0] = sample_num & 0x7f;
613 wbuf[1] = sample_num >> 7;
615 if ((x = snd_wavefront_cmd (dev, WFC_DELETE_SAMPLE, NULL, wbuf)) == 0) {
616 dev->sample_status[sample_num] = WF_ST_EMPTY;
623 wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
627 unsigned char rbuf[32], wbuf[32];
628 unsigned int sc_real, sc_alias, sc_multi;
630 /* check sample status */
632 if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
633 snd_printk ("cannot request sample count.\n");
637 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
639 for (i = 0; i < WF_MAX_SAMPLE; i++) {
644 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
645 snd_printk("cannot identify sample "
646 "type of slot %d\n", i);
647 dev->sample_status[i] = WF_ST_EMPTY;
651 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
654 dev->sample_status[i] |= WF_SLOT_ROM;
657 switch (rbuf[0] & WF_ST_MASK) {
661 case WF_ST_MULTISAMPLE:
671 snd_printk ("unknown sample type for "
676 if (rbuf[0] != WF_ST_EMPTY) {
681 snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
682 "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
683 WF_MAX_SAMPLE - dev->samples_used);
691 wavefront_get_patch_status (snd_wavefront_t *dev)
694 unsigned char patchbuf[WF_PATCH_BYTES];
695 unsigned char patchnum[2];
699 for (i = 0; i < WF_MAX_PATCH; i++) {
700 patchnum[0] = i & 0x7f;
701 patchnum[1] = i >> 7;
703 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PATCH, patchbuf,
706 dev->patch_status[i] |= WF_SLOT_FILLED;
707 p = (wavefront_patch *) patchbuf;
709 [p->sample_number|(p->sample_msb<<7)] |=
712 } else if (x == 3) { /* Bad patch number */
713 dev->patch_status[i] = 0;
715 snd_printk ("upload patch "
717 dev->patch_status[i] = 0;
722 /* program status has already filled in slot_used bits */
724 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
725 if (dev->patch_status[i] & WF_SLOT_FILLED) {
728 if (dev->patch_status[i] & WF_SLOT_USED) {
733 snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
739 wavefront_get_program_status (snd_wavefront_t *dev)
742 unsigned char progbuf[WF_PROGRAM_BYTES];
743 wavefront_program prog;
744 unsigned char prognum;
747 for (i = 0; i < WF_MAX_PROGRAM; i++) {
750 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PROGRAM, progbuf,
753 dev->prog_status[i] |= WF_SLOT_USED;
755 demunge_buf (progbuf, (unsigned char *) &prog,
758 for (l = 0; l < WF_NUM_LAYERS; l++) {
759 if (prog.layer[l].mute) {
761 [prog.layer[l].patch_number] |=
765 } else if (x == 1) { /* Bad program number */
766 dev->prog_status[i] = 0;
768 snd_printk ("upload program "
770 dev->prog_status[i] = 0;
774 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
775 if (dev->prog_status[i]) {
780 snd_printk ("%d programs slots in use\n", cnt);
786 wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
789 unsigned char buf[WF_PATCH_BYTES+2];
792 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
795 dev->patch_status[header->number] |= WF_SLOT_FILLED;
798 bptr = munge_int32 (header->number, buf, 2);
799 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
801 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
802 snd_printk ("download patch failed\n");
810 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
813 unsigned char buf[WF_PROGRAM_BYTES+1];
816 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
819 dev->prog_status[header->number] = WF_SLOT_USED;
821 /* XXX need to zero existing SLOT_USED bit for program_status[i]
822 where `i' is the program that's being (potentially) overwritten.
825 for (i = 0; i < WF_NUM_LAYERS; i++) {
826 if (header->hdr.pr.layer[i].mute) {
827 dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
830 /* XXX need to mark SLOT_USED for sample used by
831 patch_number, but this means we have to load it. Ick.
836 buf[0] = header->number;
837 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
839 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
840 snd_printk ("download patch failed\n");
848 wavefront_freemem (snd_wavefront_t *dev)
853 if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
854 snd_printk ("can't get memory stats.\n");
857 return demunge_int32 (rbuf, 4);
862 wavefront_send_sample (snd_wavefront_t *dev,
863 wavefront_patch_info *header,
865 int data_is_unsigned)
868 /* samples are downloaded via a 16-bit wide i/o port
869 (you could think of it as 2 adjacent 8-bit wide ports
870 but its less efficient that way). therefore, all
871 the blocksizes and so forth listed in the documentation,
872 and used conventionally to refer to sample sizes,
873 which are given in 8-bit units (bytes), need to be
879 u16 __user *data_end = NULL;
881 const unsigned int max_blksize = 4096/2;
882 unsigned int written;
883 unsigned int blocksize;
886 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
887 unsigned char *shptr;
889 int initial_skip = 0;
891 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
892 "type %d, %d bytes from 0x%lx\n",
893 header->size ? "" : "header ",
894 header->number, header->subkey,
896 (unsigned long) header->dataptr);
898 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
901 if ((x = wavefront_find_free_sample (dev)) < 0) {
904 snd_printk ("unspecified sample => %d\n", x);
910 /* XXX it's a debatable point whether or not RDONLY semantics
911 on the ROM samples should cover just the sample data or
912 the sample header. For now, it only covers the sample data,
913 so anyone is free at all times to rewrite sample headers.
915 My reason for this is that we have the sample headers
916 available in the WFB file for General MIDI, and so these
917 can always be reset if needed. The sample data, however,
918 cannot be recovered without a complete reset and firmware
919 reload of the ICS2115, which is a very expensive operation.
921 So, doing things this way allows us to honor the notion of
922 "RESETSAMPLES" reasonably cheaply. Note however, that this
923 is done purely at user level: there is no WFB parser in
924 this driver, and so a complete reset (back to General MIDI,
925 or theoretically some other configuration) is the
926 responsibility of the user level library.
928 To try to do this in the kernel would be a little
929 crazy: we'd need 158K of kernel space just to hold
930 a copy of the patch/program/sample header data.
933 if (dev->rom_samples_rdonly) {
934 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
935 snd_printk ("sample slot %d "
942 wavefront_delete_sample (dev, header->number);
946 dev->freemem = wavefront_freemem (dev);
948 if (dev->freemem < (int)header->size) {
949 snd_printk ("insufficient memory to "
950 "load %d byte sample.\n",
957 skip = WF_GET_CHANNEL(&header->hdr.s);
959 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
960 snd_printk ("channel selection only "
961 "possible on 16-bit samples");
996 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
997 "initial skip = %d, skip = %d\n",
998 WF_GET_CHANNEL (&header->hdr.s),
1001 /* Be safe, and zero the "Unused" bits ... */
1003 WF_SET_CHANNEL(&header->hdr.s, 0);
1005 /* adjust size for 16 bit samples by dividing by two. We always
1006 send 16 bits per write, even for 8 bit samples, so the length
1007 is always half the size of the sample data in bytes.
1010 length = header->size / 2;
1012 /* the data we're sent has not been munged, and in fact, the
1013 header we have to send isn't just a munged copy either.
1014 so, build the sample header right here.
1017 shptr = &sample_hdr[0];
1019 shptr = munge_int32 (header->number, shptr, 2);
1022 shptr = munge_int32 (length, shptr, 4);
1025 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1026 but the offset only uses 24 bits.
1029 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1031 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1033 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1035 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1038 /* This one is truly weird. What kind of weirdo decided that in
1039 a system dominated by 16 and 32 bit integers, they would use
1043 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1045 /* Why is this nybblified, when the MSB is *always* zero ?
1046 Anyway, we can't take address of bitfield, so make a
1047 good-faith guess at where it starts.
1050 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1053 if (snd_wavefront_cmd (dev,
1055 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1056 NULL, sample_hdr)) {
1057 snd_printk ("sample %sdownload refused.\n",
1058 header->size ? "" : "header ");
1062 if (header->size == 0) {
1063 goto sent; /* Sorry. Just had to have one somewhere */
1066 data_end = dataptr + length;
1068 /* Do any initial skip over an unused channel's data */
1070 dataptr += initial_skip;
1072 for (written = 0, blocknum = 0;
1073 written < length; written += max_blksize, blocknum++) {
1075 if ((length - written) > max_blksize) {
1076 blocksize = max_blksize;
1078 /* round to nearest 16-byte value */
1079 blocksize = ((length-written+7)&~0x7);
1082 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1083 snd_printk ("download block "
1084 "request refused.\n");
1088 for (i = 0; i < blocksize; i++) {
1090 if (dataptr < data_end) {
1092 __get_user (sample_short, dataptr);
1095 if (data_is_unsigned) { /* GUS ? */
1097 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1105 &sample_short)[0] += 0x7f;
1107 &sample_short)[1] += 0x7f;
1116 sample_short += 0x7fff;
1122 /* In padding section of final block:
1124 Don't fetch unsupplied data from
1125 user space, just continue with
1126 whatever the final value was.
1130 if (i < blocksize - 1) {
1131 outw (sample_short, dev->block_port);
1133 outw (sample_short, dev->last_block_port);
1137 /* Get "DMA page acknowledge", even though its really
1138 nothing to do with DMA at all.
1141 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1142 if (dma_ack == -1) {
1143 snd_printk ("upload sample "
1144 "DMA ack timeout\n");
1147 snd_printk ("upload sample "
1148 "DMA ack error 0x%x\n",
1155 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1157 /* Note, label is here because sending the sample header shouldn't
1158 alter the sample_status info at all.
1166 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1169 unsigned char alias_hdr[WF_ALIAS_BYTES];
1171 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1174 header->hdr.a.OriginalSample);
1176 munge_int32 (header->number, &alias_hdr[0], 2);
1177 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1178 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1180 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1182 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1184 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1186 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1187 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1189 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1190 snd_printk ("download alias failed.\n");
1194 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1200 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1204 unsigned char msample_hdr[WF_MSAMPLE_BYTES];
1206 munge_int32 (header->number, &msample_hdr[0], 2);
1208 /* You'll recall at this point that the "number of samples" value
1209 in a wavefront_multisample struct is actually the log2 of the
1210 real number of samples.
1213 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1214 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1216 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1218 header->hdr.ms.NumberOfSamples,
1221 for (i = 0; i < num_samples; i++) {
1222 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1223 i, header->hdr.ms.SampleNumber[i]);
1224 munge_int32 (header->hdr.ms.SampleNumber[i],
1225 &msample_hdr[3+(i*2)], 2);
1228 /* Need a hack here to pass in the number of bytes
1229 to be written to the synth. This is ugly, and perhaps
1230 one day, I'll fix it.
1233 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1234 (unsigned char *) (long) ((num_samples*2)+3),
1236 snd_printk ("download of multisample failed.\n");
1240 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1246 wavefront_fetch_multisample (snd_wavefront_t *dev,
1247 wavefront_patch_info *header)
1250 unsigned char log_ns[1];
1251 unsigned char number[2];
1254 munge_int32 (header->number, number, 2);
1256 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1257 snd_printk ("upload multisample failed.\n");
1261 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1262 header->number, log_ns[0]);
1264 header->hdr.ms.NumberOfSamples = log_ns[0];
1266 /* get the number of samples ... */
1268 num_samples = (1 << log_ns[0]);
1270 for (i = 0; i < num_samples; i++) {
1274 if ((val = wavefront_read (dev)) == -1) {
1275 snd_printk ("upload multisample failed "
1276 "during sample loop.\n");
1281 if ((val = wavefront_read (dev)) == -1) {
1282 snd_printk ("upload multisample failed "
1283 "during sample loop.\n");
1288 header->hdr.ms.SampleNumber[i] =
1289 demunge_int32 ((unsigned char *) d, 2);
1291 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1292 i, header->hdr.ms.SampleNumber[i]);
1300 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1303 unsigned char drumbuf[WF_DRUM_BYTES];
1304 wavefront_drum *drum = &header->hdr.d;
1307 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1308 "note %d, patch = %d\n",
1309 header->number, drum->PatchNumber);
1311 drumbuf[0] = header->number & 0x7f;
1313 for (i = 0; i < 4; i++) {
1314 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1317 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1318 snd_printk ("download drum failed.\n");
1326 wavefront_find_free_sample (snd_wavefront_t *dev)
1331 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1332 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1336 snd_printk ("no free sample slots!\n");
1342 wavefront_find_free_patch (snd_wavefront_t *dev)
1347 for (i = 0; i < WF_MAX_PATCH; i++) {
1348 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1352 snd_printk ("no free patch slots!\n");
1358 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1361 wavefront_patch_info header;
1363 if (copy_from_user (&header, addr, sizeof(wavefront_patch_info) -
1364 sizeof(wavefront_any))) {
1365 snd_printk ("bad address for load patch.\n");
1369 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1371 "Sample number: %d "
1372 "Sample size: %d\n",
1377 switch (header.subkey) {
1378 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1380 if (copy_from_user (&header.hdr.s, header.hdrptr,
1381 sizeof (wavefront_sample)))
1384 return wavefront_send_sample (dev, &header, header.dataptr, 0);
1386 case WF_ST_MULTISAMPLE:
1388 if (copy_from_user (&header.hdr.s, header.hdrptr,
1389 sizeof (wavefront_multisample)))
1392 return wavefront_send_multisample (dev, &header);
1397 if (copy_from_user (&header.hdr.a, header.hdrptr,
1398 sizeof (wavefront_alias)))
1401 return wavefront_send_alias (dev, &header);
1404 if (copy_from_user (&header.hdr.d, header.hdrptr,
1405 sizeof (wavefront_drum)))
1408 return wavefront_send_drum (dev, &header);
1411 if (copy_from_user (&header.hdr.p, header.hdrptr,
1412 sizeof (wavefront_patch)))
1415 return wavefront_send_patch (dev, &header);
1418 if (copy_from_user (&header.hdr.pr, header.hdrptr,
1419 sizeof (wavefront_program)))
1422 return wavefront_send_program (dev, &header);
1425 snd_printk ("unknown patch type %d.\n",
1433 /***********************************************************************
1434 WaveFront: hardware-dependent interface
1435 ***********************************************************************/
1438 process_sample_hdr (u8 *buf)
1446 /* The board doesn't send us an exact copy of a "wavefront_sample"
1447 in response to an Upload Sample Header command. Instead, we
1448 have to convert the data format back into our data structure,
1449 just as in the Download Sample command, where we have to do
1450 something very similar in the reverse direction.
1453 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1454 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1455 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1456 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1457 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1459 s.SampleResolution = *ptr & 0x3;
1460 s.Loop = *ptr & 0x8;
1461 s.Bidirectional = *ptr & 0x10;
1462 s.Reverse = *ptr & 0x40;
1464 /* Now copy it back to where it came from */
1466 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1470 wavefront_synth_control (snd_wavefront_card_t *acard,
1471 wavefront_control *wc)
1474 snd_wavefront_t *dev = &acard->wavefront;
1475 unsigned char patchnumbuf[2];
1478 DPRINT (WF_DEBUG_CMD, "synth control with "
1479 "cmd 0x%x\n", wc->cmd);
1481 /* Pre-handling of or for various commands */
1485 case WFC_DISABLE_INTERRUPTS:
1486 snd_printk ("interrupts disabled.\n");
1487 outb (0x80|0x20, dev->control_port);
1488 dev->interrupts_are_midi = 1;
1491 case WFC_ENABLE_INTERRUPTS:
1492 snd_printk ("interrupts enabled.\n");
1493 outb (0x80|0x40|0x20, dev->control_port);
1494 dev->interrupts_are_midi = 1;
1497 case WFC_INTERRUPT_STATUS:
1498 wc->rbuf[0] = dev->interrupts_are_midi;
1501 case WFC_ROMSAMPLES_RDONLY:
1502 dev->rom_samples_rdonly = wc->wbuf[0];
1506 case WFC_IDENTIFY_SLOT_TYPE:
1507 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1508 if (i <0 || i >= WF_MAX_SAMPLE) {
1509 snd_printk ("invalid slot ID %d\n",
1511 wc->status = EINVAL;
1514 wc->rbuf[0] = dev->sample_status[i];
1518 case WFC_DEBUG_DRIVER:
1519 dev->debug = wc->wbuf[0];
1520 snd_printk ("debug = 0x%x\n", dev->debug);
1523 case WFC_UPLOAD_PATCH:
1524 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1525 memcpy (wc->wbuf, patchnumbuf, 2);
1528 case WFC_UPLOAD_MULTISAMPLE:
1529 /* multisamples have to be handled differently, and
1530 cannot be dealt with properly by snd_wavefront_cmd() alone.
1532 wc->status = wavefront_fetch_multisample
1533 (dev, (wavefront_patch_info *) wc->rbuf);
1536 case WFC_UPLOAD_SAMPLE_ALIAS:
1537 snd_printk ("support for sample alias upload "
1538 "being considered.\n");
1539 wc->status = EINVAL;
1543 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1545 /* Post-handling of certain commands.
1547 In particular, if the command was an upload, demunge the data
1548 so that the user-level doesn't have to think about it.
1551 if (wc->status == 0) {
1553 /* intercept any freemem requests so that we know
1554 we are always current with the user-level view
1558 case WFC_REPORT_FREE_MEMORY:
1559 dev->freemem = demunge_int32 (wc->rbuf, 4);
1562 case WFC_UPLOAD_PATCH:
1563 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1566 case WFC_UPLOAD_PROGRAM:
1567 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1570 case WFC_UPLOAD_EDRUM_PROGRAM:
1571 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1574 case WFC_UPLOAD_SAMPLE_HEADER:
1575 process_sample_hdr (wc->rbuf);
1578 case WFC_UPLOAD_SAMPLE_ALIAS:
1579 snd_printk ("support for "
1580 "sample aliases still "
1581 "being considered.\n");
1585 snd_wavefront_midi_disable_virtual (acard);
1589 snd_wavefront_midi_enable_virtual (acard);
1598 snd_wavefront_synth_open (snd_hwdep_t *hw, struct file *file)
1601 if (!try_module_get(hw->card->module))
1603 file->private_data = hw;
1608 snd_wavefront_synth_release (snd_hwdep_t *hw, struct file *file)
1611 module_put(hw->card->module);
1616 snd_wavefront_synth_ioctl (snd_hwdep_t *hw, struct file *file,
1617 unsigned int cmd, unsigned long arg)
1621 snd_wavefront_t *dev;
1622 snd_wavefront_card_t *acard;
1623 wavefront_control wc;
1624 void __user *argp = (void __user *)arg;
1626 card = (snd_card_t *) hw->card;
1628 snd_assert(card != NULL, return -ENODEV);
1630 snd_assert(card->private_data != NULL, return -ENODEV);
1632 acard = card->private_data;
1633 dev = &acard->wavefront;
1636 case WFCTL_LOAD_SPP:
1637 if (wavefront_load_patch (dev, argp) != 0) {
1643 if (copy_from_user (&wc, argp, sizeof (wc)))
1645 if (wavefront_synth_control (acard, &wc) < 0) {
1648 if (copy_to_user (argp, &wc, sizeof (wc)))
1660 /***********************************************************************/
1661 /* WaveFront: interface for card-level wavefront module */
1662 /***********************************************************************/
1665 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1667 snd_wavefront_t *dev = &card->wavefront;
1670 Some comments on interrupts. I attempted a version of this
1671 driver that used interrupts throughout the code instead of
1672 doing busy and/or sleep-waiting. Alas, it appears that once
1673 the Motorola firmware is downloaded, the card *never*
1674 generates an RX interrupt. These are successfully generated
1675 during firmware loading, and after that wavefront_status()
1676 reports that an interrupt is pending on the card from time
1677 to time, but it never seems to be delivered to this
1678 driver. Note also that wavefront_status() continues to
1679 report that RX interrupts are enabled, suggesting that I
1680 didn't goof up and disable them by mistake.
1682 Thus, I stepped back to a prior version of
1683 wavefront_wait(), the only place where this really
1684 matters. Its sad, but I've looked through the code to check
1685 on things, and I really feel certain that the Motorola
1686 firmware prevents RX-ready interrupts.
1689 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1693 spin_lock(&dev->irq_lock);
1696 spin_unlock(&dev->irq_lock);
1697 wake_up(&dev->interrupt_sleeper);
1702 0 Host Rx Interrupt Enable (1=Enabled)
1703 1 Host Rx Register Full (1=Full)
1704 2 Host Rx Interrupt Pending (1=Interrupt)
1706 4 Host Tx Interrupt (1=Enabled)
1707 5 Host Tx Register empty (1=Empty)
1708 6 Host Tx Interrupt Pending (1=Interrupt)
1713 snd_wavefront_interrupt_bits (int irq)
1733 snd_printk ("invalid IRQ %d\n", irq);
1741 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1742 int val, int port, int timeout)
1747 init_waitqueue_entry(&wait, current);
1748 spin_lock_irq(&dev->irq_lock);
1749 add_wait_queue(&dev->interrupt_sleeper, &wait);
1752 spin_unlock_irq(&dev->irq_lock);
1754 if ((timeout = schedule_timeout(timeout)) == 0)
1762 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1768 /* IRQ already checked */
1770 bits = snd_wavefront_interrupt_bits (dev->irq);
1772 /* try reset of port */
1774 outb (0x0, dev->control_port);
1776 /* At this point, the board is in reset, and the H/W initialization
1777 register is accessed at the same address as the data port.
1779 Bit 7 - Enable IRQ Driver
1780 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1781 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1783 Bit 6 - MIDI Interface Select
1785 0 - Use the MIDI Input from the 26-pin WaveBlaster
1786 compatible header as the serial MIDI source
1787 1 - Use the MIDI Input from the 9-pin D connector as the
1790 Bits 5:3 - IRQ Selection
1801 Bit 0 - Disable Boot ROM
1802 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1803 1 - memory accesses to 03FC30-03FFFFH are directed to external
1808 /* configure hardware: IRQ, enable interrupts,
1809 plus external 9-pin MIDI interface selected
1812 outb (0x80 | 0x40 | bits, dev->data_port);
1816 0 Host Rx Interrupt Enable (1=Enabled) 0x1
1820 4 Host Tx Interrupt Enable 0x10
1821 5 Mute (0=Mute; 1=Play) 0x20
1822 6 Master Interrupt Enable (1=Enabled) 0x40
1823 7 Master Reset (0=Reset; 1=Run) 0x80
1825 Take us out of reset, mute output, master + TX + RX interrupts on.
1827 We'll get an interrupt presumably to tell us that the TX
1831 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1833 (reset_time*HZ)/100);
1835 /* Note: data port is now the data port, not the h/w initialization
1840 snd_printk ("intr not received after h/w un-reset.\n");
1844 /* Note: data port is now the data port, not the h/w initialization
1847 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1848 will work. So, issue one of them, and wait for TX
1849 interrupt. This can take a *long* time after a cold boot,
1850 while the ISC ROM does its RAM test. The SDK says up to 4
1851 seconds - with 12MB of RAM on a Tropez+, it takes a lot
1852 longer than that (~16secs). Note that the card understands
1853 the difference between a warm and a cold boot, so
1854 subsequent ISC2115 reboots (say, caused by module
1855 reloading) will get through this much faster.
1857 XXX Interesting question: why is no RX interrupt received first ?
1860 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1861 dev->data_port, ramcheck_time*HZ);
1864 snd_printk ("post-RAM-check interrupt not received.\n");
1868 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1869 snd_printk ("no response to HW version cmd.\n");
1873 if ((hwv[0] = wavefront_read (dev)) == -1) {
1874 snd_printk ("board not responding correctly.\n");
1878 if (hwv[0] == 0xFF) { /* NAK */
1880 /* Board's RAM test failed. Try to read error code,
1881 and tell us about it either way.
1884 if ((hwv[0] = wavefront_read (dev)) == -1) {
1885 snd_printk ("on-board RAM test failed "
1886 "(bad error code).\n");
1888 snd_printk ("on-board RAM test failed "
1889 "(error code: 0x%x).\n",
1895 /* We're OK, just get the next byte of the HW version response */
1897 if ((hwv[1] = wavefront_read (dev)) == -1) {
1898 snd_printk ("incorrect h/w response.\n");
1902 snd_printk ("hardware version %d.%d\n",
1912 #include <linux/fs.h>
1913 #include <linux/mm.h>
1914 #include <linux/slab.h>
1915 #include <linux/unistd.h>
1916 #include <linux/syscalls.h>
1917 #include <asm/uaccess.h>
1921 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1924 unsigned char section[WF_SECTION_MAX];
1925 char section_length; /* yes, just a char; max value is WF_SECTION_MAX */
1926 int section_cnt_downloaded = 0;
1932 /* This tries to be a bit cleverer than the stuff Alan Cox did for
1933 the generic sound firmware, in that it actually knows
1934 something about the structure of the Motorola firmware. In
1935 particular, it uses a version that has been stripped of the
1936 20K of useless header information, and had section lengths
1937 added, making it possible to load the entire OS without any
1938 [kv]malloc() activity, since the longest entity we ever read is
1939 42 bytes (well, WF_SECTION_MAX) long.
1945 if ((fd = sys_open (path, 0, 0)) < 0) {
1946 snd_printk ("Unable to load \"%s\".\n",
1954 if ((x = sys_read (fd, §ion_length, sizeof (section_length))) !=
1955 sizeof (section_length)) {
1956 snd_printk ("firmware read error.\n");
1960 if (section_length == 0) {
1964 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1965 snd_printk ("invalid firmware section length %d\n",
1970 if (sys_read (fd, section, section_length) != section_length) {
1971 snd_printk ("firmware section "
1978 if (wavefront_write (dev, WFC_DOWNLOAD_OS)) {
1982 for (i = 0; i < section_length; i++) {
1983 if (wavefront_write (dev, section[i])) {
1990 if (wavefront_wait (dev, STAT_CAN_READ)) {
1992 if ((c = inb (dev->data_port)) != WF_ACK) {
1994 snd_printk ("download "
1995 "of section #%d not "
1996 "acknowledged, ack = 0x%x\n",
1997 section_cnt_downloaded + 1, c);
2003 snd_printk ("time out for firmware ACK.\n");
2016 snd_printk ("firmware download failed!!!\n");
2022 wavefront_do_reset (snd_wavefront_t *dev)
2027 if (wavefront_reset_to_cleanliness (dev)) {
2028 snd_printk ("hw reset failed.\n");
2033 if (wavefront_download_firmware (dev, ospath)) {
2039 /* Wait for the OS to get running. The protocol for
2040 this is non-obvious, and was determined by
2041 using port-IO tracing in DOSemu and some
2042 experimentation here.
2044 Rather than using timed waits, use interrupts creatively.
2047 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2052 snd_printk ("no post-OS interrupt.\n");
2056 /* Now, do it again ! */
2058 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2059 dev->data_port, (10*HZ));
2062 snd_printk ("no post-OS interrupt(2).\n");
2066 /* OK, no (RX/TX) interrupts any more, but leave mute
2070 outb (0x80|0x40, dev->control_port);
2073 /* SETUPSND.EXE asks for sample memory config here, but since i
2074 have no idea how to interpret the result, we'll forget
2078 if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2082 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2084 if (wavefront_write (dev, 0xf0) ||
2085 wavefront_write (dev, 1) ||
2086 (wavefront_read (dev) < 0)) {
2088 snd_printk ("MPU emulation mode not set.\n");
2094 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2095 snd_printk ("cannot set number of voices to 32.\n");
2103 /* reset that sucker so that it doesn't bother us. */
2105 outb (0x0, dev->control_port);
2106 dev->interrupts_are_midi = 0;
2111 snd_wavefront_start (snd_wavefront_t *dev)
2114 int samples_are_from_rom;
2116 /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2117 wavefront_reset_to_cleanliness() has already been called
2121 samples_are_from_rom = 1;
2123 /* XXX is this always true ? */
2124 samples_are_from_rom = 0;
2127 if (dev->israw || fx_raw) {
2128 if (wavefront_do_reset (dev)) {
2132 /* Check for FX device, present only on Tropez+ */
2134 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2136 if (dev->has_fx && fx_raw) {
2137 snd_wavefront_fx_start (dev);
2140 wavefront_get_sample_status (dev, samples_are_from_rom);
2141 wavefront_get_program_status (dev);
2142 wavefront_get_patch_status (dev);
2144 /* Start normal operation: unreset, master interrupt enabled, no mute
2147 outb (0x80|0x40|0x20, dev->control_port);
2153 snd_wavefront_detect (snd_wavefront_card_t *card)
2156 unsigned char rbuf[4], wbuf[4];
2157 snd_wavefront_t *dev = &card->wavefront;
2159 /* returns zero if a WaveFront card is successfully detected.
2165 dev->debug = debug_default;
2166 dev->interrupts_are_midi = 0;
2168 dev->rom_samples_rdonly = 1;
2170 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2172 dev->fw_version[0] = rbuf[0];
2173 dev->fw_version[1] = rbuf[1];
2175 snd_printk ("firmware %d.%d already loaded.\n",
2178 /* check that a command actually works */
2180 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2182 dev->hw_version[0] = rbuf[0];
2183 dev->hw_version[1] = rbuf[1];
2185 snd_printk ("not raw, but no "
2186 "hardware version!\n");
2193 snd_printk ("reloading firmware as you requested.\n");
2200 snd_printk ("no response to firmware probe, assume raw.\n");