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.
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/time.h>
28 #include <linux/wait.h>
29 #include <linux/firmware.h>
30 #include <linux/moduleparam.h>
31 #include <linux/slab.h>
32 #include <linux/module.h>
33 #include <sound/core.h>
34 #include <sound/snd_wavefront.h>
35 #include <sound/initval.h>
37 static int wf_raw = 0; /* we normally check for "raw state" to firmware
38 loading. if non-zero, then during driver loading, the
39 state of the board is ignored, and we reset the
40 board and load the firmware anyway.
43 static int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
44 whatever state it is when the driver is loaded.
45 The default is to download the microprogram and
46 associated coefficients to set it up for "default"
47 operation, whatever that means.
50 static int debug_default = 0; /* you can set this to control debugging
51 during driver loading. it takes any combination
52 of the WF_DEBUG_* flags defined in
56 /* XXX this needs to be made firmware and hardware version dependent */
58 #define DEFAULT_OSPATH "/*(DEBLOBBED)*/"
59 static char *ospath = DEFAULT_OSPATH; /* the firmware file name */
61 static int wait_usecs = 150; /* This magic number seems to give pretty optimal
62 throughput based on my limited experimentation.
63 If you want to play around with it and find a better
64 value, be my guest. Remember, the idea is to
65 get a number that causes us to just busy wait
66 for as many WaveFront commands as possible, without
67 coming up with a number so large that we hog the
70 Specifically, with this number, out of about 134,000
71 status waits, only about 250 result in a sleep.
74 static int sleep_interval = 100; /* HZ/sleep_interval seconds per sleep */
75 static int sleep_tries = 50; /* number of times we'll try to sleep */
77 static int reset_time = 2; /* hundreths of a second we wait after a HW
78 reset for the expected interrupt.
81 static int ramcheck_time = 20; /* time in seconds to wait while ROM code
85 static int osrun_time = 10; /* time in seconds we wait for the OS to
88 module_param(wf_raw, int, 0444);
89 MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
90 module_param(fx_raw, int, 0444);
91 MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
92 module_param(debug_default, int, 0444);
93 MODULE_PARM_DESC(debug_default, "debug parameters for card initialization");
94 module_param(wait_usecs, int, 0444);
95 MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs");
96 module_param(sleep_interval, int, 0444);
97 MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply");
98 module_param(sleep_tries, int, 0444);
99 MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait");
100 module_param(ospath, charp, 0444);
101 MODULE_PARM_DESC(ospath, "pathname to processed ICS2115 OS firmware");
102 module_param(reset_time, int, 0444);
103 MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect");
104 module_param(ramcheck_time, int, 0444);
105 MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test");
106 module_param(osrun_time, int, 0444);
107 MODULE_PARM_DESC(osrun_time, "how many seconds to wait for the ICS2115 OS");
109 /* if WF_DEBUG not defined, no run-time debugging messages will
110 be available via the debug flag setting. Given the current
111 beta state of the driver, this will remain set until a future
119 #define DPRINT(cond, ...) \
120 if ((dev->debug & (cond)) == (cond)) { \
121 snd_printk (__VA_ARGS__); \
124 #define DPRINT(cond, args...)
125 #endif /* WF_DEBUG */
127 #define LOGNAME "WaveFront: "
129 /* bitmasks for WaveFront status port value */
131 #define STAT_RINTR_ENABLED 0x01
132 #define STAT_CAN_READ 0x02
133 #define STAT_INTR_READ 0x04
134 #define STAT_WINTR_ENABLED 0x10
135 #define STAT_CAN_WRITE 0x20
136 #define STAT_INTR_WRITE 0x40
138 static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
139 static int wavefront_find_free_sample (snd_wavefront_t *);
141 struct wavefront_command {
144 unsigned int read_cnt;
145 unsigned int write_cnt;
152 } wavefront_errors[] = {
153 { 0x01, "Bad sample number" },
154 { 0x02, "Out of sample memory" },
155 { 0x03, "Bad patch number" },
156 { 0x04, "Error in number of voices" },
157 { 0x06, "Sample load already in progress" },
158 { 0x0B, "No sample load request pending" },
159 { 0x0E, "Bad MIDI channel number" },
160 { 0x10, "Download Record Error" },
167 static struct wavefront_command wavefront_commands[] = {
168 { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK },
169 { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0},
170 { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK },
171 { WFC_GET_NVOICES, "get number of voices", 1, 0, 0 },
172 { WFC_SET_TUNING, "set synthesizer tuning", 0, 2, NEEDS_ACK },
173 { WFC_GET_TUNING, "get synthesizer tuning", 2, 0, 0 },
174 { WFC_DISABLE_CHANNEL, "disable synth channel", 0, 1, NEEDS_ACK },
175 { WFC_ENABLE_CHANNEL, "enable synth channel", 0, 1, NEEDS_ACK },
176 { WFC_GET_CHANNEL_STATUS, "get synth channel status", 3, 0, 0 },
177 { WFC_MISYNTH_OFF, "disable midi-in to synth", 0, 0, NEEDS_ACK },
178 { WFC_MISYNTH_ON, "enable midi-in to synth", 0, 0, NEEDS_ACK },
179 { WFC_VMIDI_ON, "enable virtual midi mode", 0, 0, NEEDS_ACK },
180 { WFC_VMIDI_OFF, "disable virtual midi mode", 0, 0, NEEDS_ACK },
181 { WFC_MIDI_STATUS, "report midi status", 1, 0, 0 },
182 { WFC_FIRMWARE_VERSION, "report firmware version", 2, 0, 0 },
183 { WFC_HARDWARE_VERSION, "report hardware version", 2, 0, 0 },
184 { WFC_GET_NSAMPLES, "report number of samples", 2, 0, 0 },
185 { WFC_INSTOUT_LEVELS, "report instantaneous output levels", 7, 0, 0 },
186 { WFC_PEAKOUT_LEVELS, "report peak output levels", 7, 0, 0 },
187 { WFC_DOWNLOAD_SAMPLE, "download sample",
188 0, WF_SAMPLE_BYTES, NEEDS_ACK },
189 { WFC_DOWNLOAD_BLOCK, "download block", 0, 0, NEEDS_ACK},
190 { WFC_DOWNLOAD_SAMPLE_HEADER, "download sample header",
191 0, WF_SAMPLE_HDR_BYTES, NEEDS_ACK },
192 { WFC_UPLOAD_SAMPLE_HEADER, "upload sample header", 13, 2, 0 },
194 /* This command requires a variable number of bytes to be written.
195 There is a hack in snd_wavefront_cmd() to support this. The actual
196 count is passed in as the read buffer ptr, cast appropriately.
200 { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
202 /* This one is a hack as well. We just read the first byte of the
203 response, don't fetch an ACK, and leave the rest to the
204 calling function. Ugly, ugly, ugly.
207 { WFC_UPLOAD_MULTISAMPLE, "upload multisample", 2, 1, 0 },
208 { WFC_DOWNLOAD_SAMPLE_ALIAS, "download sample alias",
209 0, WF_ALIAS_BYTES, NEEDS_ACK },
210 { WFC_UPLOAD_SAMPLE_ALIAS, "upload sample alias", WF_ALIAS_BYTES, 2, 0},
211 { WFC_DELETE_SAMPLE, "delete sample", 0, 2, NEEDS_ACK },
212 { WFC_IDENTIFY_SAMPLE_TYPE, "identify sample type", 5, 2, 0 },
213 { WFC_UPLOAD_SAMPLE_PARAMS, "upload sample parameters" },
214 { WFC_REPORT_FREE_MEMORY, "report free memory", 4, 0, 0 },
215 { WFC_DOWNLOAD_PATCH, "download patch", 0, 134, NEEDS_ACK },
216 { WFC_UPLOAD_PATCH, "upload patch", 132, 2, 0 },
217 { WFC_DOWNLOAD_PROGRAM, "download program", 0, 33, NEEDS_ACK },
218 { WFC_UPLOAD_PROGRAM, "upload program", 32, 1, 0 },
219 { WFC_DOWNLOAD_EDRUM_PROGRAM, "download enhanced drum program", 0, 9,
221 { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
222 { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
224 { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
225 { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
227 { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
232 wavefront_errorstr (int errnum)
237 for (i = 0; wavefront_errors[i].errstr; i++) {
238 if (wavefront_errors[i].errno == errnum) {
239 return wavefront_errors[i].errstr;
243 return "Unknown WaveFront error";
246 static struct wavefront_command *
247 wavefront_get_command (int cmd)
252 for (i = 0; wavefront_commands[i].cmd != 0; i++) {
253 if (cmd == wavefront_commands[i].cmd) {
254 return &wavefront_commands[i];
262 wavefront_status (snd_wavefront_t *dev)
265 return inb (dev->status_port);
269 wavefront_sleep (int limit)
272 schedule_timeout_interruptible(limit);
274 return signal_pending(current);
278 wavefront_wait (snd_wavefront_t *dev, int mask)
283 /* Spin for a short period of time, because >99% of all
284 requests to the WaveFront can be serviced inline like this.
287 for (i = 0; i < wait_usecs; i += 5) {
288 if (wavefront_status (dev) & mask) {
294 for (i = 0; i < sleep_tries; i++) {
296 if (wavefront_status (dev) & mask) {
300 if (wavefront_sleep (HZ/sleep_interval)) {
309 wavefront_read (snd_wavefront_t *dev)
312 if (wavefront_wait (dev, STAT_CAN_READ))
313 return inb (dev->data_port);
315 DPRINT (WF_DEBUG_DATA, "read timeout.\n");
321 wavefront_write (snd_wavefront_t *dev, unsigned char data)
324 if (wavefront_wait (dev, STAT_CAN_WRITE)) {
325 outb (data, dev->data_port);
329 DPRINT (WF_DEBUG_DATA, "write timeout.\n");
335 snd_wavefront_cmd (snd_wavefront_t *dev,
336 int cmd, unsigned char *rbuf, unsigned char *wbuf)
342 struct wavefront_command *wfcmd;
344 if ((wfcmd = wavefront_get_command (cmd)) == NULL) {
345 snd_printk ("command 0x%x not supported.\n",
350 /* Hack to handle the one variable-size write command. See
351 wavefront_send_multisample() for the other half of this
352 gross and ugly strategy.
355 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
356 wfcmd->write_cnt = (unsigned long) rbuf;
360 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
361 cmd, wfcmd->action, wfcmd->read_cnt,
362 wfcmd->write_cnt, wfcmd->need_ack);
364 if (wavefront_write (dev, cmd)) {
365 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
371 if (wfcmd->write_cnt > 0) {
372 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
374 wfcmd->write_cnt, cmd);
376 for (i = 0; i < wfcmd->write_cnt; i++) {
377 if (wavefront_write (dev, wbuf[i])) {
378 DPRINT (WF_DEBUG_IO, "bad write for byte "
379 "%d of 0x%x [%s].\n",
380 i, cmd, wfcmd->action);
384 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
389 if (wfcmd->read_cnt > 0) {
390 DPRINT (WF_DEBUG_DATA, "reading %d ints "
392 wfcmd->read_cnt, cmd);
394 for (i = 0; i < wfcmd->read_cnt; i++) {
396 if ((c = wavefront_read (dev)) == -1) {
397 DPRINT (WF_DEBUG_IO, "bad read for byte "
398 "%d of 0x%x [%s].\n",
399 i, cmd, wfcmd->action);
403 /* Now handle errors. Lots of special cases here */
406 if ((c = wavefront_read (dev)) == -1) {
407 DPRINT (WF_DEBUG_IO, "bad read for "
416 /* Can you believe this madness ? */
419 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
420 rbuf[0] = WF_ST_EMPTY;
424 wfcmd->cmd == WFC_UPLOAD_PATCH) {
429 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
435 DPRINT (WF_DEBUG_IO, "error %d (%s) "
441 wavefront_errorstr (c),
452 DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
456 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
458 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
460 /* Some commands need an ACK, but return zero instead
461 of the standard value.
464 if ((ack = wavefront_read (dev)) == 0) {
470 DPRINT (WF_DEBUG_IO, "cannot read ack for "
476 int err = -1; /* something unknown */
478 if (ack == 0xff) { /* explicit error */
480 if ((err = wavefront_read (dev)) == -1) {
481 DPRINT (WF_DEBUG_DATA,
488 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
489 "failed (0x%x, 0x%x, %s)\n",
490 cmd, wfcmd->action, ack, err,
491 wavefront_errorstr (err));
497 DPRINT (WF_DEBUG_DATA, "ack received "
502 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
504 cmd, wfcmd->action, wfcmd->read_cnt,
505 wfcmd->write_cnt, wfcmd->need_ack);
512 /***********************************************************************
513 WaveFront data munging
515 Things here are weird. All data written to the board cannot
516 have its most significant bit set. Any data item with values
517 potentially > 0x7F (127) must be split across multiple bytes.
519 Sometimes, we need to munge numeric values that are represented on
520 the x86 side as 8-32 bit values. Sometimes, we need to munge data
521 that is represented on the x86 side as an array of bytes. The most
522 efficient approach to handling both cases seems to be to use 2
523 different functions for munging and 2 for de-munging. This avoids
524 weird casting and worrying about bit-level offsets.
526 **********************************************************************/
528 static unsigned char *
529 munge_int32 (unsigned int src,
531 unsigned int dst_size)
535 for (i = 0; i < dst_size; i++) {
536 *dst = src & 0x7F; /* Mask high bit of LSB */
537 src = src >> 7; /* Rotate Right 7 bits */
538 /* Note: we leave the upper bits in place */
546 demunge_int32 (unsigned char* src, int src_size)
552 for (i = src_size - 1; i >= 0; i--) {
553 outval=(outval<<7)+src[i];
561 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
565 unsigned int last = dst_size / 2;
567 for (i = 0; i < last; i++) {
568 *dst++ = src[i] & 0x7f;
569 *dst++ = src[i] >> 7;
576 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
580 unsigned char *end = src + src_bytes;
582 end = src + src_bytes;
584 /* NOTE: src and dst *CAN* point to the same address */
586 for (i = 0; src != end; i++) {
588 dst[i] |= (*src++)<<7;
594 /***********************************************************************
595 WaveFront: sample, patch and program management.
596 ***********************************************************************/
599 wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
602 unsigned char wbuf[2];
605 wbuf[0] = sample_num & 0x7f;
606 wbuf[1] = sample_num >> 7;
608 if ((x = snd_wavefront_cmd (dev, WFC_DELETE_SAMPLE, NULL, wbuf)) == 0) {
609 dev->sample_status[sample_num] = WF_ST_EMPTY;
616 wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
620 unsigned char rbuf[32], wbuf[32];
621 unsigned int sc_real, sc_alias, sc_multi;
623 /* check sample status */
625 if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
626 snd_printk ("cannot request sample count.\n");
630 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
632 for (i = 0; i < WF_MAX_SAMPLE; i++) {
637 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
638 snd_printk(KERN_WARNING "cannot identify sample "
639 "type of slot %d\n", i);
640 dev->sample_status[i] = WF_ST_EMPTY;
644 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
647 dev->sample_status[i] |= WF_SLOT_ROM;
650 switch (rbuf[0] & WF_ST_MASK) {
654 case WF_ST_MULTISAMPLE:
664 snd_printk ("unknown sample type for "
669 if (rbuf[0] != WF_ST_EMPTY) {
674 snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
675 "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
676 WF_MAX_SAMPLE - dev->samples_used);
684 wavefront_get_patch_status (snd_wavefront_t *dev)
687 unsigned char patchbuf[WF_PATCH_BYTES];
688 unsigned char patchnum[2];
692 for (i = 0; i < WF_MAX_PATCH; i++) {
693 patchnum[0] = i & 0x7f;
694 patchnum[1] = i >> 7;
696 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PATCH, patchbuf,
699 dev->patch_status[i] |= WF_SLOT_FILLED;
700 p = (wavefront_patch *) patchbuf;
702 [p->sample_number|(p->sample_msb<<7)] |=
705 } else if (x == 3) { /* Bad patch number */
706 dev->patch_status[i] = 0;
708 snd_printk ("upload patch "
710 dev->patch_status[i] = 0;
715 /* program status has already filled in slot_used bits */
717 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
718 if (dev->patch_status[i] & WF_SLOT_FILLED) {
721 if (dev->patch_status[i] & WF_SLOT_USED) {
726 snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
732 wavefront_get_program_status (snd_wavefront_t *dev)
735 unsigned char progbuf[WF_PROGRAM_BYTES];
736 wavefront_program prog;
737 unsigned char prognum;
740 for (i = 0; i < WF_MAX_PROGRAM; i++) {
743 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PROGRAM, progbuf,
746 dev->prog_status[i] |= WF_SLOT_USED;
748 demunge_buf (progbuf, (unsigned char *) &prog,
751 for (l = 0; l < WF_NUM_LAYERS; l++) {
752 if (prog.layer[l].mute) {
754 [prog.layer[l].patch_number] |=
758 } else if (x == 1) { /* Bad program number */
759 dev->prog_status[i] = 0;
761 snd_printk ("upload program "
763 dev->prog_status[i] = 0;
767 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
768 if (dev->prog_status[i]) {
773 snd_printk ("%d programs slots in use\n", cnt);
779 wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
782 unsigned char buf[WF_PATCH_BYTES+2];
785 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
788 if (header->number >= ARRAY_SIZE(dev->patch_status))
791 dev->patch_status[header->number] |= WF_SLOT_FILLED;
794 bptr = munge_int32 (header->number, buf, 2);
795 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
797 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
798 snd_printk ("download patch failed\n");
806 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
809 unsigned char buf[WF_PROGRAM_BYTES+1];
812 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
815 if (header->number >= ARRAY_SIZE(dev->prog_status))
818 dev->prog_status[header->number] = WF_SLOT_USED;
820 /* XXX need to zero existing SLOT_USED bit for program_status[i]
821 where `i' is the program that's being (potentially) overwritten.
824 for (i = 0; i < WF_NUM_LAYERS; i++) {
825 if (header->hdr.pr.layer[i].mute) {
826 dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
829 /* XXX need to mark SLOT_USED for sample used by
830 patch_number, but this means we have to load it. Ick.
835 buf[0] = header->number;
836 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
838 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
839 snd_printk ("download patch failed\n");
847 wavefront_freemem (snd_wavefront_t *dev)
852 if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
853 snd_printk ("can't get memory stats.\n");
856 return demunge_int32 (rbuf, 4);
861 wavefront_send_sample (snd_wavefront_t *dev,
862 wavefront_patch_info *header,
864 int data_is_unsigned)
867 /* samples are downloaded via a 16-bit wide i/o port
868 (you could think of it as 2 adjacent 8-bit wide ports
869 but its less efficient that way). therefore, all
870 the blocksizes and so forth listed in the documentation,
871 and used conventionally to refer to sample sizes,
872 which are given in 8-bit units (bytes), need to be
876 u16 sample_short = 0;
878 u16 __user *data_end = NULL;
880 const unsigned int max_blksize = 4096/2;
881 unsigned int written;
882 unsigned int blocksize;
885 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
886 unsigned char *shptr;
888 int initial_skip = 0;
890 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
891 "type %d, %d bytes from 0x%lx\n",
892 header->size ? "" : "header ",
893 header->number, header->subkey,
895 (unsigned long) header->dataptr);
897 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
900 if ((x = wavefront_find_free_sample (dev)) < 0) {
903 snd_printk ("unspecified sample => %d\n", x);
907 if (header->number >= WF_MAX_SAMPLE)
912 /* XXX it's a debatable point whether or not RDONLY semantics
913 on the ROM samples should cover just the sample data or
914 the sample header. For now, it only covers the sample data,
915 so anyone is free at all times to rewrite sample headers.
917 My reason for this is that we have the sample headers
918 available in the WFB file for General MIDI, and so these
919 can always be reset if needed. The sample data, however,
920 cannot be recovered without a complete reset and firmware
921 reload of the ICS2115, which is a very expensive operation.
923 So, doing things this way allows us to honor the notion of
924 "RESETSAMPLES" reasonably cheaply. Note however, that this
925 is done purely at user level: there is no WFB parser in
926 this driver, and so a complete reset (back to General MIDI,
927 or theoretically some other configuration) is the
928 responsibility of the user level library.
930 To try to do this in the kernel would be a little
931 crazy: we'd need 158K of kernel space just to hold
932 a copy of the patch/program/sample header data.
935 if (dev->rom_samples_rdonly) {
936 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
937 snd_printk ("sample slot %d "
944 wavefront_delete_sample (dev, header->number);
948 dev->freemem = wavefront_freemem (dev);
950 if (dev->freemem < (int)header->size) {
951 snd_printk ("insufficient memory to "
952 "load %d byte sample.\n",
959 skip = WF_GET_CHANNEL(&header->hdr.s);
961 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
962 snd_printk ("channel selection only "
963 "possible on 16-bit samples");
998 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
999 "initial skip = %d, skip = %d\n",
1000 WF_GET_CHANNEL (&header->hdr.s),
1001 initial_skip, skip);
1003 /* Be safe, and zero the "Unused" bits ... */
1005 WF_SET_CHANNEL(&header->hdr.s, 0);
1007 /* adjust size for 16 bit samples by dividing by two. We always
1008 send 16 bits per write, even for 8 bit samples, so the length
1009 is always half the size of the sample data in bytes.
1012 length = header->size / 2;
1014 /* the data we're sent has not been munged, and in fact, the
1015 header we have to send isn't just a munged copy either.
1016 so, build the sample header right here.
1019 shptr = &sample_hdr[0];
1021 shptr = munge_int32 (header->number, shptr, 2);
1024 shptr = munge_int32 (length, shptr, 4);
1027 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1028 but the offset only uses 24 bits.
1031 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1033 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1035 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1037 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1040 /* This one is truly weird. What kind of weirdo decided that in
1041 a system dominated by 16 and 32 bit integers, they would use
1045 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1047 /* Why is this nybblified, when the MSB is *always* zero ?
1048 Anyway, we can't take address of bitfield, so make a
1049 good-faith guess at where it starts.
1052 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1055 if (snd_wavefront_cmd (dev,
1057 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1058 NULL, sample_hdr)) {
1059 snd_printk ("sample %sdownload refused.\n",
1060 header->size ? "" : "header ");
1064 if (header->size == 0) {
1065 goto sent; /* Sorry. Just had to have one somewhere */
1068 data_end = dataptr + length;
1070 /* Do any initial skip over an unused channel's data */
1072 dataptr += initial_skip;
1074 for (written = 0, blocknum = 0;
1075 written < length; written += max_blksize, blocknum++) {
1077 if ((length - written) > max_blksize) {
1078 blocksize = max_blksize;
1080 /* round to nearest 16-byte value */
1081 blocksize = ALIGN(length - written, 8);
1084 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1085 snd_printk ("download block "
1086 "request refused.\n");
1090 for (i = 0; i < blocksize; i++) {
1092 if (dataptr < data_end) {
1094 __get_user (sample_short, dataptr);
1097 if (data_is_unsigned) { /* GUS ? */
1099 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1107 &sample_short)[0] += 0x7f;
1109 &sample_short)[1] += 0x7f;
1118 sample_short += 0x7fff;
1124 /* In padding section of final block:
1126 Don't fetch unsupplied data from
1127 user space, just continue with
1128 whatever the final value was.
1132 if (i < blocksize - 1) {
1133 outw (sample_short, dev->block_port);
1135 outw (sample_short, dev->last_block_port);
1139 /* Get "DMA page acknowledge", even though its really
1140 nothing to do with DMA at all.
1143 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1144 if (dma_ack == -1) {
1145 snd_printk ("upload sample "
1146 "DMA ack timeout\n");
1149 snd_printk ("upload sample "
1150 "DMA ack error 0x%x\n",
1157 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1159 /* Note, label is here because sending the sample header shouldn't
1160 alter the sample_status info at all.
1168 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1171 unsigned char alias_hdr[WF_ALIAS_BYTES];
1173 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1176 header->hdr.a.OriginalSample);
1178 if (header->number >= WF_MAX_SAMPLE)
1181 munge_int32 (header->number, &alias_hdr[0], 2);
1182 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1183 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1185 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1187 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1189 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1191 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1192 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1194 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1195 snd_printk ("download alias failed.\n");
1199 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1205 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1209 unsigned char *msample_hdr;
1211 if (header->number >= WF_MAX_SAMPLE)
1214 msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1218 munge_int32 (header->number, &msample_hdr[0], 2);
1220 /* You'll recall at this point that the "number of samples" value
1221 in a wavefront_multisample struct is actually the log2 of the
1222 real number of samples.
1225 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1226 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1228 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1230 header->hdr.ms.NumberOfSamples,
1233 for (i = 0; i < num_samples; i++) {
1234 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1235 i, header->hdr.ms.SampleNumber[i]);
1236 munge_int32 (header->hdr.ms.SampleNumber[i],
1237 &msample_hdr[3+(i*2)], 2);
1240 /* Need a hack here to pass in the number of bytes
1241 to be written to the synth. This is ugly, and perhaps
1242 one day, I'll fix it.
1245 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1246 (unsigned char *) (long) ((num_samples*2)+3),
1248 snd_printk ("download of multisample failed.\n");
1253 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1260 wavefront_fetch_multisample (snd_wavefront_t *dev,
1261 wavefront_patch_info *header)
1264 unsigned char log_ns[1];
1265 unsigned char number[2];
1268 munge_int32 (header->number, number, 2);
1270 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1271 snd_printk ("upload multisample failed.\n");
1275 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1276 header->number, log_ns[0]);
1278 header->hdr.ms.NumberOfSamples = log_ns[0];
1280 /* get the number of samples ... */
1282 num_samples = (1 << log_ns[0]);
1284 for (i = 0; i < num_samples; i++) {
1288 if ((val = wavefront_read (dev)) == -1) {
1289 snd_printk ("upload multisample failed "
1290 "during sample loop.\n");
1295 if ((val = wavefront_read (dev)) == -1) {
1296 snd_printk ("upload multisample failed "
1297 "during sample loop.\n");
1302 header->hdr.ms.SampleNumber[i] =
1303 demunge_int32 ((unsigned char *) d, 2);
1305 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1306 i, header->hdr.ms.SampleNumber[i]);
1314 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1317 unsigned char drumbuf[WF_DRUM_BYTES];
1318 wavefront_drum *drum = &header->hdr.d;
1321 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1322 "note %d, patch = %d\n",
1323 header->number, drum->PatchNumber);
1325 drumbuf[0] = header->number & 0x7f;
1327 for (i = 0; i < 4; i++) {
1328 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1331 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1332 snd_printk ("download drum failed.\n");
1340 wavefront_find_free_sample (snd_wavefront_t *dev)
1345 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1346 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1350 snd_printk ("no free sample slots!\n");
1356 wavefront_find_free_patch (snd_wavefront_t *dev)
1361 for (i = 0; i < WF_MAX_PATCH; i++) {
1362 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1366 snd_printk ("no free patch slots!\n");
1372 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1374 wavefront_patch_info *header;
1377 header = kmalloc(sizeof(*header), GFP_KERNEL);
1381 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1382 sizeof(wavefront_any))) {
1383 snd_printk ("bad address for load patch.\n");
1388 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1390 "Sample number: %d "
1391 "Sample size: %d\n",
1396 switch (header->subkey) {
1397 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1399 if (copy_from_user (&header->hdr.s, header->hdrptr,
1400 sizeof (wavefront_sample))) {
1405 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1408 case WF_ST_MULTISAMPLE:
1410 if (copy_from_user (&header->hdr.s, header->hdrptr,
1411 sizeof (wavefront_multisample))) {
1416 err = wavefront_send_multisample (dev, header);
1421 if (copy_from_user (&header->hdr.a, header->hdrptr,
1422 sizeof (wavefront_alias))) {
1427 err = wavefront_send_alias (dev, header);
1431 if (copy_from_user (&header->hdr.d, header->hdrptr,
1432 sizeof (wavefront_drum))) {
1437 err = wavefront_send_drum (dev, header);
1441 if (copy_from_user (&header->hdr.p, header->hdrptr,
1442 sizeof (wavefront_patch))) {
1447 err = wavefront_send_patch (dev, header);
1451 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1452 sizeof (wavefront_program))) {
1457 err = wavefront_send_program (dev, header);
1461 snd_printk ("unknown patch type %d.\n",
1472 /***********************************************************************
1473 WaveFront: hardware-dependent interface
1474 ***********************************************************************/
1477 process_sample_hdr (u8 *buf)
1485 /* The board doesn't send us an exact copy of a "wavefront_sample"
1486 in response to an Upload Sample Header command. Instead, we
1487 have to convert the data format back into our data structure,
1488 just as in the Download Sample command, where we have to do
1489 something very similar in the reverse direction.
1492 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1493 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1494 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1495 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1496 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1498 s.SampleResolution = *ptr & 0x3;
1499 s.Loop = *ptr & 0x8;
1500 s.Bidirectional = *ptr & 0x10;
1501 s.Reverse = *ptr & 0x40;
1503 /* Now copy it back to where it came from */
1505 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1509 wavefront_synth_control (snd_wavefront_card_t *acard,
1510 wavefront_control *wc)
1513 snd_wavefront_t *dev = &acard->wavefront;
1514 unsigned char patchnumbuf[2];
1517 DPRINT (WF_DEBUG_CMD, "synth control with "
1518 "cmd 0x%x\n", wc->cmd);
1520 /* Pre-handling of or for various commands */
1524 case WFC_DISABLE_INTERRUPTS:
1525 snd_printk ("interrupts disabled.\n");
1526 outb (0x80|0x20, dev->control_port);
1527 dev->interrupts_are_midi = 1;
1530 case WFC_ENABLE_INTERRUPTS:
1531 snd_printk ("interrupts enabled.\n");
1532 outb (0x80|0x40|0x20, dev->control_port);
1533 dev->interrupts_are_midi = 1;
1536 case WFC_INTERRUPT_STATUS:
1537 wc->rbuf[0] = dev->interrupts_are_midi;
1540 case WFC_ROMSAMPLES_RDONLY:
1541 dev->rom_samples_rdonly = wc->wbuf[0];
1545 case WFC_IDENTIFY_SLOT_TYPE:
1546 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1547 if (i <0 || i >= WF_MAX_SAMPLE) {
1548 snd_printk ("invalid slot ID %d\n",
1550 wc->status = EINVAL;
1553 wc->rbuf[0] = dev->sample_status[i];
1557 case WFC_DEBUG_DRIVER:
1558 dev->debug = wc->wbuf[0];
1559 snd_printk ("debug = 0x%x\n", dev->debug);
1562 case WFC_UPLOAD_PATCH:
1563 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1564 memcpy (wc->wbuf, patchnumbuf, 2);
1567 case WFC_UPLOAD_MULTISAMPLE:
1568 /* multisamples have to be handled differently, and
1569 cannot be dealt with properly by snd_wavefront_cmd() alone.
1571 wc->status = wavefront_fetch_multisample
1572 (dev, (wavefront_patch_info *) wc->rbuf);
1575 case WFC_UPLOAD_SAMPLE_ALIAS:
1576 snd_printk ("support for sample alias upload "
1577 "being considered.\n");
1578 wc->status = EINVAL;
1582 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1584 /* Post-handling of certain commands.
1586 In particular, if the command was an upload, demunge the data
1587 so that the user-level doesn't have to think about it.
1590 if (wc->status == 0) {
1592 /* intercept any freemem requests so that we know
1593 we are always current with the user-level view
1597 case WFC_REPORT_FREE_MEMORY:
1598 dev->freemem = demunge_int32 (wc->rbuf, 4);
1601 case WFC_UPLOAD_PATCH:
1602 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1605 case WFC_UPLOAD_PROGRAM:
1606 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1609 case WFC_UPLOAD_EDRUM_PROGRAM:
1610 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1613 case WFC_UPLOAD_SAMPLE_HEADER:
1614 process_sample_hdr (wc->rbuf);
1617 case WFC_UPLOAD_SAMPLE_ALIAS:
1618 snd_printk ("support for "
1619 "sample aliases still "
1620 "being considered.\n");
1624 snd_wavefront_midi_disable_virtual (acard);
1628 snd_wavefront_midi_enable_virtual (acard);
1637 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1640 if (!try_module_get(hw->card->module))
1642 file->private_data = hw;
1647 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1650 module_put(hw->card->module);
1655 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1656 unsigned int cmd, unsigned long arg)
1659 struct snd_card *card;
1660 snd_wavefront_t *dev;
1661 snd_wavefront_card_t *acard;
1662 wavefront_control *wc;
1663 void __user *argp = (void __user *)arg;
1666 card = (struct snd_card *) hw->card;
1668 if (snd_BUG_ON(!card))
1670 if (snd_BUG_ON(!card->private_data))
1673 acard = card->private_data;
1674 dev = &acard->wavefront;
1677 case WFCTL_LOAD_SPP:
1678 if (wavefront_load_patch (dev, argp) != 0) {
1684 wc = memdup_user(argp, sizeof(*wc));
1688 if (wavefront_synth_control (acard, wc) < 0)
1690 else if (copy_to_user (argp, wc, sizeof (*wc)))
1705 /***********************************************************************/
1706 /* WaveFront: interface for card-level wavefront module */
1707 /***********************************************************************/
1710 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1712 snd_wavefront_t *dev = &card->wavefront;
1715 Some comments on interrupts. I attempted a version of this
1716 driver that used interrupts throughout the code instead of
1717 doing busy and/or sleep-waiting. Alas, it appears that once
1718 the Motorola firmware is downloaded, the card *never*
1719 generates an RX interrupt. These are successfully generated
1720 during firmware loading, and after that wavefront_status()
1721 reports that an interrupt is pending on the card from time
1722 to time, but it never seems to be delivered to this
1723 driver. Note also that wavefront_status() continues to
1724 report that RX interrupts are enabled, suggesting that I
1725 didn't goof up and disable them by mistake.
1727 Thus, I stepped back to a prior version of
1728 wavefront_wait(), the only place where this really
1729 matters. Its sad, but I've looked through the code to check
1730 on things, and I really feel certain that the Motorola
1731 firmware prevents RX-ready interrupts.
1734 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1738 spin_lock(&dev->irq_lock);
1741 spin_unlock(&dev->irq_lock);
1742 wake_up(&dev->interrupt_sleeper);
1747 0 Host Rx Interrupt Enable (1=Enabled)
1748 1 Host Rx Register Full (1=Full)
1749 2 Host Rx Interrupt Pending (1=Interrupt)
1751 4 Host Tx Interrupt (1=Enabled)
1752 5 Host Tx Register empty (1=Empty)
1753 6 Host Tx Interrupt Pending (1=Interrupt)
1758 snd_wavefront_interrupt_bits (int irq)
1778 snd_printk ("invalid IRQ %d\n", irq);
1786 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1787 int val, int port, unsigned long timeout)
1792 init_waitqueue_entry(&wait, current);
1793 spin_lock_irq(&dev->irq_lock);
1794 add_wait_queue(&dev->interrupt_sleeper, &wait);
1797 spin_unlock_irq(&dev->irq_lock);
1798 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1799 schedule_timeout_uninterruptible(1);
1805 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1811 /* IRQ already checked */
1813 bits = snd_wavefront_interrupt_bits (dev->irq);
1815 /* try reset of port */
1817 outb (0x0, dev->control_port);
1819 /* At this point, the board is in reset, and the H/W initialization
1820 register is accessed at the same address as the data port.
1822 Bit 7 - Enable IRQ Driver
1823 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1824 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1826 Bit 6 - MIDI Interface Select
1828 0 - Use the MIDI Input from the 26-pin WaveBlaster
1829 compatible header as the serial MIDI source
1830 1 - Use the MIDI Input from the 9-pin D connector as the
1833 Bits 5:3 - IRQ Selection
1844 Bit 0 - Disable Boot ROM
1845 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1846 1 - memory accesses to 03FC30-03FFFFH are directed to external
1851 /* configure hardware: IRQ, enable interrupts,
1852 plus external 9-pin MIDI interface selected
1855 outb (0x80 | 0x40 | bits, dev->data_port);
1859 0 Host Rx Interrupt Enable (1=Enabled) 0x1
1863 4 Host Tx Interrupt Enable 0x10
1864 5 Mute (0=Mute; 1=Play) 0x20
1865 6 Master Interrupt Enable (1=Enabled) 0x40
1866 7 Master Reset (0=Reset; 1=Run) 0x80
1868 Take us out of reset, mute output, master + TX + RX interrupts on.
1870 We'll get an interrupt presumably to tell us that the TX
1874 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1876 (reset_time*HZ)/100);
1878 /* Note: data port is now the data port, not the h/w initialization
1883 snd_printk ("intr not received after h/w un-reset.\n");
1887 /* Note: data port is now the data port, not the h/w initialization
1890 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1891 will work. So, issue one of them, and wait for TX
1892 interrupt. This can take a *long* time after a cold boot,
1893 while the ISC ROM does its RAM test. The SDK says up to 4
1894 seconds - with 12MB of RAM on a Tropez+, it takes a lot
1895 longer than that (~16secs). Note that the card understands
1896 the difference between a warm and a cold boot, so
1897 subsequent ISC2115 reboots (say, caused by module
1898 reloading) will get through this much faster.
1900 XXX Interesting question: why is no RX interrupt received first ?
1903 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1904 dev->data_port, ramcheck_time*HZ);
1907 snd_printk ("post-RAM-check interrupt not received.\n");
1911 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1912 snd_printk ("no response to HW version cmd.\n");
1916 if ((hwv[0] = wavefront_read (dev)) == -1) {
1917 snd_printk ("board not responding correctly.\n");
1921 if (hwv[0] == 0xFF) { /* NAK */
1923 /* Board's RAM test failed. Try to read error code,
1924 and tell us about it either way.
1927 if ((hwv[0] = wavefront_read (dev)) == -1) {
1928 snd_printk ("on-board RAM test failed "
1929 "(bad error code).\n");
1931 snd_printk ("on-board RAM test failed "
1932 "(error code: 0x%x).\n",
1938 /* We're OK, just get the next byte of the HW version response */
1940 if ((hwv[1] = wavefront_read (dev)) == -1) {
1941 snd_printk ("incorrect h/w response.\n");
1945 snd_printk ("hardware version %d.%d\n",
1956 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1959 const unsigned char *buf;
1961 int section_cnt_downloaded = 0;
1962 const struct firmware *firmware;
1964 err = reject_firmware(&firmware, path, dev->card->dev);
1966 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1971 buf = firmware->data;
1973 int section_length = *(signed char *)buf;
1974 if (section_length == 0)
1976 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1978 "invalid firmware section length %d\n",
1985 if (firmware->size < len + section_length) {
1986 snd_printk(KERN_ERR "firmware section read error.\n");
1991 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1994 for (; section_length; section_length--) {
1995 if (wavefront_write(dev, *buf))
2002 if (!wavefront_wait(dev, STAT_CAN_READ)) {
2003 snd_printk(KERN_ERR "time out for firmware ACK.\n");
2006 err = inb(dev->data_port);
2007 if (err != WF_ACK) {
2009 "download of section #%d not "
2010 "acknowledged, ack = 0x%x\n",
2011 section_cnt_downloaded + 1, err);
2015 section_cnt_downloaded++;
2018 release_firmware(firmware);
2022 release_firmware(firmware);
2023 snd_printk(KERN_ERR "firmware download failed!!!\n");
2029 wavefront_do_reset (snd_wavefront_t *dev)
2034 if (wavefront_reset_to_cleanliness (dev)) {
2035 snd_printk ("hw reset failed.\n");
2040 if (wavefront_download_firmware (dev, ospath)) {
2046 /* Wait for the OS to get running. The protocol for
2047 this is non-obvious, and was determined by
2048 using port-IO tracing in DOSemu and some
2049 experimentation here.
2051 Rather than using timed waits, use interrupts creatively.
2054 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2059 snd_printk ("no post-OS interrupt.\n");
2063 /* Now, do it again ! */
2065 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2066 dev->data_port, (10*HZ));
2069 snd_printk ("no post-OS interrupt(2).\n");
2073 /* OK, no (RX/TX) interrupts any more, but leave mute
2077 outb (0x80|0x40, dev->control_port);
2080 /* SETUPSND.EXE asks for sample memory config here, but since i
2081 have no idea how to interpret the result, we'll forget
2085 if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2089 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2091 if (wavefront_write (dev, 0xf0) ||
2092 wavefront_write (dev, 1) ||
2093 (wavefront_read (dev) < 0)) {
2095 snd_printk ("MPU emulation mode not set.\n");
2101 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2102 snd_printk ("cannot set number of voices to 32.\n");
2110 /* reset that sucker so that it doesn't bother us. */
2112 outb (0x0, dev->control_port);
2113 dev->interrupts_are_midi = 0;
2118 snd_wavefront_start (snd_wavefront_t *dev)
2121 int samples_are_from_rom;
2123 /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2124 wavefront_reset_to_cleanliness() has already been called
2128 samples_are_from_rom = 1;
2130 /* XXX is this always true ? */
2131 samples_are_from_rom = 0;
2134 if (dev->israw || fx_raw) {
2135 if (wavefront_do_reset (dev)) {
2139 /* Check for FX device, present only on Tropez+ */
2141 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2143 if (dev->has_fx && fx_raw) {
2144 snd_wavefront_fx_start (dev);
2147 wavefront_get_sample_status (dev, samples_are_from_rom);
2148 wavefront_get_program_status (dev);
2149 wavefront_get_patch_status (dev);
2151 /* Start normal operation: unreset, master interrupt enabled, no mute
2154 outb (0x80|0x40|0x20, dev->control_port);
2160 snd_wavefront_detect (snd_wavefront_card_t *card)
2163 unsigned char rbuf[4], wbuf[4];
2164 snd_wavefront_t *dev = &card->wavefront;
2166 /* returns zero if a WaveFront card is successfully detected.
2172 dev->debug = debug_default;
2173 dev->interrupts_are_midi = 0;
2175 dev->rom_samples_rdonly = 1;
2177 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2179 dev->fw_version[0] = rbuf[0];
2180 dev->fw_version[1] = rbuf[1];
2182 snd_printk ("firmware %d.%d already loaded.\n",
2185 /* check that a command actually works */
2187 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2189 dev->hw_version[0] = rbuf[0];
2190 dev->hw_version[1] = rbuf[1];
2192 snd_printk ("not raw, but no "
2193 "hardware version!\n");
2200 snd_printk ("reloading firmware as you requested.\n");
2207 snd_printk ("no response to firmware probe, assume raw.\n");