1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) by Paul Barton-Davis 1998-1999
4 * Some portions of this file are taken from work that is
5 * copyright (C) by Hannu Savolainen 1993-1996
9 * An ALSA lowlevel driver for Turtle Beach ICS2115 wavetable synth
10 * (Maui, Tropez, Tropez Plus)
12 * This driver supports the onboard wavetable synthesizer (an ICS2115),
13 * including patch, sample and program loading and unloading, conversion
14 * of GUS patches during loading, and full user-level access to all
15 * WaveFront commands. It tries to provide semi-intelligent patch and
16 * sample management as well.
21 #include <linux/interrupt.h>
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/time.h>
25 #include <linux/wait.h>
26 #include <linux/sched/signal.h>
27 #include <linux/firmware.h>
28 #include <linux/moduleparam.h>
29 #include <linux/slab.h>
30 #include <linux/module.h>
31 #include <sound/core.h>
32 #include <sound/snd_wavefront.h>
33 #include <sound/initval.h>
35 static 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 static 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 static 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 #define DEFAULT_OSPATH "wavefront.os"
57 static char *ospath = DEFAULT_OSPATH; /* the firmware file name */
59 static int wait_usecs = 150; /* This magic number seems to give pretty optimal
60 throughput based on my limited experimentation.
61 If you want to play around with it and find a better
62 value, be my guest. Remember, the idea is to
63 get a number that causes us to just busy wait
64 for as many WaveFront commands as possible, without
65 coming up with a number so large that we hog the
68 Specifically, with this number, out of about 134,000
69 status waits, only about 250 result in a sleep.
72 static int sleep_interval = 100; /* HZ/sleep_interval seconds per sleep */
73 static int sleep_tries = 50; /* number of times we'll try to sleep */
75 static int reset_time = 2; /* hundreths of a second we wait after a HW
76 reset for the expected interrupt.
79 static int ramcheck_time = 20; /* time in seconds to wait while ROM code
83 static int osrun_time = 10; /* time in seconds we wait for the OS to
86 module_param(wf_raw, int, 0444);
87 MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
88 module_param(fx_raw, int, 0444);
89 MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
90 module_param(debug_default, int, 0444);
91 MODULE_PARM_DESC(debug_default, "debug parameters for card initialization");
92 module_param(wait_usecs, int, 0444);
93 MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs");
94 module_param(sleep_interval, int, 0444);
95 MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply");
96 module_param(sleep_tries, int, 0444);
97 MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait");
98 module_param(ospath, charp, 0444);
99 MODULE_PARM_DESC(ospath, "pathname to processed ICS2115 OS firmware");
100 module_param(reset_time, int, 0444);
101 MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect");
102 module_param(ramcheck_time, int, 0444);
103 MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test");
104 module_param(osrun_time, int, 0444);
105 MODULE_PARM_DESC(osrun_time, "how many seconds to wait for the ICS2115 OS");
107 /* if WF_DEBUG not defined, no run-time debugging messages will
108 be available via the debug flag setting. Given the current
109 beta state of the driver, this will remain set until a future
117 #define DPRINT(cond, ...) \
118 if ((dev->debug & (cond)) == (cond)) { \
119 snd_printk (__VA_ARGS__); \
122 #define DPRINT(cond, args...)
123 #endif /* WF_DEBUG */
125 #define LOGNAME "WaveFront: "
127 /* bitmasks for WaveFront status port value */
129 #define STAT_RINTR_ENABLED 0x01
130 #define STAT_CAN_READ 0x02
131 #define STAT_INTR_READ 0x04
132 #define STAT_WINTR_ENABLED 0x10
133 #define STAT_CAN_WRITE 0x20
134 #define STAT_INTR_WRITE 0x40
136 static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
137 static int wavefront_find_free_sample (snd_wavefront_t *);
139 struct wavefront_command {
142 unsigned int read_cnt;
143 unsigned int write_cnt;
150 } wavefront_errors[] = {
151 { 0x01, "Bad sample number" },
152 { 0x02, "Out of sample memory" },
153 { 0x03, "Bad patch number" },
154 { 0x04, "Error in number of voices" },
155 { 0x06, "Sample load already in progress" },
156 { 0x0B, "No sample load request pending" },
157 { 0x0E, "Bad MIDI channel number" },
158 { 0x10, "Download Record Error" },
165 static struct wavefront_command wavefront_commands[] = {
166 { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK },
167 { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0},
168 { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK },
169 { WFC_GET_NVOICES, "get number of voices", 1, 0, 0 },
170 { WFC_SET_TUNING, "set synthesizer tuning", 0, 2, NEEDS_ACK },
171 { WFC_GET_TUNING, "get synthesizer tuning", 2, 0, 0 },
172 { WFC_DISABLE_CHANNEL, "disable synth channel", 0, 1, NEEDS_ACK },
173 { WFC_ENABLE_CHANNEL, "enable synth channel", 0, 1, NEEDS_ACK },
174 { WFC_GET_CHANNEL_STATUS, "get synth channel status", 3, 0, 0 },
175 { WFC_MISYNTH_OFF, "disable midi-in to synth", 0, 0, NEEDS_ACK },
176 { WFC_MISYNTH_ON, "enable midi-in to synth", 0, 0, NEEDS_ACK },
177 { WFC_VMIDI_ON, "enable virtual midi mode", 0, 0, NEEDS_ACK },
178 { WFC_VMIDI_OFF, "disable virtual midi mode", 0, 0, NEEDS_ACK },
179 { WFC_MIDI_STATUS, "report midi status", 1, 0, 0 },
180 { WFC_FIRMWARE_VERSION, "report firmware version", 2, 0, 0 },
181 { WFC_HARDWARE_VERSION, "report hardware version", 2, 0, 0 },
182 { WFC_GET_NSAMPLES, "report number of samples", 2, 0, 0 },
183 { WFC_INSTOUT_LEVELS, "report instantaneous output levels", 7, 0, 0 },
184 { WFC_PEAKOUT_LEVELS, "report peak output levels", 7, 0, 0 },
185 { WFC_DOWNLOAD_SAMPLE, "download sample",
186 0, WF_SAMPLE_BYTES, NEEDS_ACK },
187 { WFC_DOWNLOAD_BLOCK, "download block", 0, 0, NEEDS_ACK},
188 { WFC_DOWNLOAD_SAMPLE_HEADER, "download sample header",
189 0, WF_SAMPLE_HDR_BYTES, NEEDS_ACK },
190 { WFC_UPLOAD_SAMPLE_HEADER, "upload sample header", 13, 2, 0 },
192 /* This command requires a variable number of bytes to be written.
193 There is a hack in snd_wavefront_cmd() to support this. The actual
194 count is passed in as the read buffer ptr, cast appropriately.
198 { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
200 /* This one is a hack as well. We just read the first byte of the
201 response, don't fetch an ACK, and leave the rest to the
202 calling function. Ugly, ugly, ugly.
205 { WFC_UPLOAD_MULTISAMPLE, "upload multisample", 2, 1, 0 },
206 { WFC_DOWNLOAD_SAMPLE_ALIAS, "download sample alias",
207 0, WF_ALIAS_BYTES, NEEDS_ACK },
208 { WFC_UPLOAD_SAMPLE_ALIAS, "upload sample alias", WF_ALIAS_BYTES, 2, 0},
209 { WFC_DELETE_SAMPLE, "delete sample", 0, 2, NEEDS_ACK },
210 { WFC_IDENTIFY_SAMPLE_TYPE, "identify sample type", 5, 2, 0 },
211 { WFC_UPLOAD_SAMPLE_PARAMS, "upload sample parameters" },
212 { WFC_REPORT_FREE_MEMORY, "report free memory", 4, 0, 0 },
213 { WFC_DOWNLOAD_PATCH, "download patch", 0, 134, NEEDS_ACK },
214 { WFC_UPLOAD_PATCH, "upload patch", 132, 2, 0 },
215 { WFC_DOWNLOAD_PROGRAM, "download program", 0, 33, NEEDS_ACK },
216 { WFC_UPLOAD_PROGRAM, "upload program", 32, 1, 0 },
217 { WFC_DOWNLOAD_EDRUM_PROGRAM, "download enhanced drum program", 0, 9,
219 { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
220 { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
222 { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
223 { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
225 { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
230 wavefront_errorstr (int errnum)
235 for (i = 0; wavefront_errors[i].errstr; i++) {
236 if (wavefront_errors[i].errno == errnum) {
237 return wavefront_errors[i].errstr;
241 return "Unknown WaveFront error";
244 static struct wavefront_command *
245 wavefront_get_command (int cmd)
250 for (i = 0; wavefront_commands[i].cmd != 0; i++) {
251 if (cmd == wavefront_commands[i].cmd) {
252 return &wavefront_commands[i];
260 wavefront_status (snd_wavefront_t *dev)
263 return inb (dev->status_port);
267 wavefront_sleep (int limit)
270 schedule_timeout_interruptible(limit);
272 return signal_pending(current);
276 wavefront_wait (snd_wavefront_t *dev, int mask)
281 /* Spin for a short period of time, because >99% of all
282 requests to the WaveFront can be serviced inline like this.
285 for (i = 0; i < wait_usecs; i += 5) {
286 if (wavefront_status (dev) & mask) {
292 for (i = 0; i < sleep_tries; i++) {
294 if (wavefront_status (dev) & mask) {
298 if (wavefront_sleep (HZ/sleep_interval)) {
307 wavefront_read (snd_wavefront_t *dev)
310 if (wavefront_wait (dev, STAT_CAN_READ))
311 return inb (dev->data_port);
313 DPRINT (WF_DEBUG_DATA, "read timeout.\n");
319 wavefront_write (snd_wavefront_t *dev, unsigned char data)
322 if (wavefront_wait (dev, STAT_CAN_WRITE)) {
323 outb (data, dev->data_port);
327 DPRINT (WF_DEBUG_DATA, "write timeout.\n");
333 snd_wavefront_cmd (snd_wavefront_t *dev,
334 int cmd, unsigned char *rbuf, unsigned char *wbuf)
340 struct wavefront_command *wfcmd;
342 wfcmd = wavefront_get_command(cmd);
344 snd_printk ("command 0x%x not supported.\n",
349 /* Hack to handle the one variable-size write command. See
350 wavefront_send_multisample() for the other half of this
351 gross and ugly strategy.
354 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
355 wfcmd->write_cnt = (unsigned long) rbuf;
359 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
360 cmd, wfcmd->action, wfcmd->read_cnt,
361 wfcmd->write_cnt, wfcmd->need_ack);
363 if (wavefront_write (dev, cmd)) {
364 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
370 if (wfcmd->write_cnt > 0) {
371 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
373 wfcmd->write_cnt, cmd);
375 for (i = 0; i < wfcmd->write_cnt; i++) {
376 if (wavefront_write (dev, wbuf[i])) {
377 DPRINT (WF_DEBUG_IO, "bad write for byte "
378 "%d of 0x%x [%s].\n",
379 i, cmd, wfcmd->action);
383 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
388 if (wfcmd->read_cnt > 0) {
389 DPRINT (WF_DEBUG_DATA, "reading %d ints "
391 wfcmd->read_cnt, cmd);
393 for (i = 0; i < wfcmd->read_cnt; i++) {
395 c = wavefront_read(dev);
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 c = wavefront_read(dev);
408 DPRINT (WF_DEBUG_IO, "bad read for "
417 /* Can you believe this madness ? */
420 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
421 rbuf[0] = WF_ST_EMPTY;
425 wfcmd->cmd == WFC_UPLOAD_PATCH) {
430 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
436 DPRINT (WF_DEBUG_IO, "error %d (%s) "
442 wavefront_errorstr (c),
453 DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
457 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
459 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
461 /* Some commands need an ACK, but return zero instead
462 of the standard value.
465 ack = wavefront_read(dev);
471 DPRINT (WF_DEBUG_IO, "cannot read ack for "
477 int err = -1; /* something unknown */
479 if (ack == 0xff) { /* explicit error */
481 err = wavefront_read(dev);
483 DPRINT (WF_DEBUG_DATA,
490 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
491 "failed (0x%x, 0x%x, %s)\n",
492 cmd, wfcmd->action, ack, err,
493 wavefront_errorstr (err));
499 DPRINT (WF_DEBUG_DATA, "ack received "
504 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
506 cmd, wfcmd->action, wfcmd->read_cnt,
507 wfcmd->write_cnt, wfcmd->need_ack);
514 /***********************************************************************
515 WaveFront data munging
517 Things here are weird. All data written to the board cannot
518 have its most significant bit set. Any data item with values
519 potentially > 0x7F (127) must be split across multiple bytes.
521 Sometimes, we need to munge numeric values that are represented on
522 the x86 side as 8-32 bit values. Sometimes, we need to munge data
523 that is represented on the x86 side as an array of bytes. The most
524 efficient approach to handling both cases seems to be to use 2
525 different functions for munging and 2 for de-munging. This avoids
526 weird casting and worrying about bit-level offsets.
528 **********************************************************************/
530 static unsigned char *
531 munge_int32 (unsigned int src,
533 unsigned int dst_size)
537 for (i = 0; i < dst_size; i++) {
538 *dst = src & 0x7F; /* Mask high bit of LSB */
539 src = src >> 7; /* Rotate Right 7 bits */
540 /* Note: we leave the upper bits in place */
548 demunge_int32 (unsigned char* src, int src_size)
554 for (i = src_size - 1; i >= 0; i--) {
555 outval=(outval<<7)+src[i];
563 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
567 unsigned int last = dst_size / 2;
569 for (i = 0; i < last; i++) {
570 *dst++ = src[i] & 0x7f;
571 *dst++ = src[i] >> 7;
578 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
582 unsigned char *end = src + src_bytes;
584 end = src + src_bytes;
586 /* NOTE: src and dst *CAN* point to the same address */
588 for (i = 0; src != end; i++) {
590 dst[i] |= (*src++)<<7;
596 /***********************************************************************
597 WaveFront: sample, patch and program management.
598 ***********************************************************************/
601 wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
604 unsigned char wbuf[2];
607 wbuf[0] = sample_num & 0x7f;
608 wbuf[1] = sample_num >> 7;
610 x = snd_wavefront_cmd(dev, WFC_DELETE_SAMPLE, NULL, wbuf);
612 dev->sample_status[sample_num] = WF_ST_EMPTY;
618 wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
622 unsigned char rbuf[32], wbuf[32];
623 unsigned int sc_real, sc_alias, sc_multi;
625 /* check sample status */
627 if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
628 snd_printk ("cannot request sample count.\n");
632 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
634 for (i = 0; i < WF_MAX_SAMPLE; i++) {
639 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
640 snd_printk(KERN_WARNING "cannot identify sample "
641 "type of slot %d\n", i);
642 dev->sample_status[i] = WF_ST_EMPTY;
646 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
649 dev->sample_status[i] |= WF_SLOT_ROM;
652 switch (rbuf[0] & WF_ST_MASK) {
656 case WF_ST_MULTISAMPLE:
666 snd_printk ("unknown sample type for "
671 if (rbuf[0] != WF_ST_EMPTY) {
676 snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
677 "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
678 WF_MAX_SAMPLE - dev->samples_used);
686 wavefront_get_patch_status (snd_wavefront_t *dev)
689 unsigned char patchbuf[WF_PATCH_BYTES];
690 unsigned char patchnum[2];
694 for (i = 0; i < WF_MAX_PATCH; i++) {
695 patchnum[0] = i & 0x7f;
696 patchnum[1] = i >> 7;
698 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PATCH, patchbuf,
702 dev->patch_status[i] |= WF_SLOT_FILLED;
703 p = (wavefront_patch *) patchbuf;
705 [p->sample_number|(p->sample_msb<<7)] |=
708 } else if (x == 3) { /* Bad patch number */
709 dev->patch_status[i] = 0;
711 snd_printk ("upload patch "
713 dev->patch_status[i] = 0;
718 /* program status has already filled in slot_used bits */
720 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
721 if (dev->patch_status[i] & WF_SLOT_FILLED) {
724 if (dev->patch_status[i] & WF_SLOT_USED) {
729 snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
735 wavefront_get_program_status (snd_wavefront_t *dev)
738 unsigned char progbuf[WF_PROGRAM_BYTES];
739 wavefront_program prog;
740 unsigned char prognum;
743 for (i = 0; i < WF_MAX_PROGRAM; i++) {
746 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PROGRAM, progbuf,
750 dev->prog_status[i] |= WF_SLOT_USED;
752 demunge_buf (progbuf, (unsigned char *) &prog,
755 for (l = 0; l < WF_NUM_LAYERS; l++) {
756 if (prog.layer[l].mute) {
758 [prog.layer[l].patch_number] |=
762 } else if (x == 1) { /* Bad program number */
763 dev->prog_status[i] = 0;
765 snd_printk ("upload program "
767 dev->prog_status[i] = 0;
771 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
772 if (dev->prog_status[i]) {
777 snd_printk ("%d programs slots in use\n", cnt);
783 wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
786 unsigned char buf[WF_PATCH_BYTES+2];
789 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
792 if (header->number >= ARRAY_SIZE(dev->patch_status))
795 dev->patch_status[header->number] |= WF_SLOT_FILLED;
797 bptr = munge_int32 (header->number, buf, 2);
798 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
800 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
801 snd_printk ("download patch failed\n");
809 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
812 unsigned char buf[WF_PROGRAM_BYTES+1];
815 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
818 if (header->number >= ARRAY_SIZE(dev->prog_status))
821 dev->prog_status[header->number] = WF_SLOT_USED;
823 /* XXX need to zero existing SLOT_USED bit for program_status[i]
824 where `i' is the program that's being (potentially) overwritten.
827 for (i = 0; i < WF_NUM_LAYERS; i++) {
828 if (header->hdr.pr.layer[i].mute) {
829 dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
832 /* XXX need to mark SLOT_USED for sample used by
833 patch_number, but this means we have to load it. Ick.
838 buf[0] = header->number;
839 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
841 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
842 snd_printk ("download patch failed\n");
850 wavefront_freemem (snd_wavefront_t *dev)
855 if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
856 snd_printk ("can't get memory stats.\n");
859 return demunge_int32 (rbuf, 4);
864 wavefront_send_sample (snd_wavefront_t *dev,
865 wavefront_patch_info *header,
867 int data_is_unsigned)
870 /* samples are downloaded via a 16-bit wide i/o port
871 (you could think of it as 2 adjacent 8-bit wide ports
872 but its less efficient that way). therefore, all
873 the blocksizes and so forth listed in the documentation,
874 and used conventionally to refer to sample sizes,
875 which are given in 8-bit units (bytes), need to be
879 u16 sample_short = 0;
881 u16 __user *data_end = NULL;
883 const unsigned int max_blksize = 4096/2;
884 unsigned int written;
885 unsigned int blocksize;
888 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
889 unsigned char *shptr;
891 int initial_skip = 0;
893 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
894 "type %d, %d bytes from 0x%lx\n",
895 header->size ? "" : "header ",
896 header->number, header->subkey,
898 (unsigned long) header->dataptr);
900 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
903 x = wavefront_find_free_sample(dev);
906 snd_printk ("unspecified sample => %d\n", x);
910 if (header->number >= WF_MAX_SAMPLE)
915 /* XXX it's a debatable point whether or not RDONLY semantics
916 on the ROM samples should cover just the sample data or
917 the sample header. For now, it only covers the sample data,
918 so anyone is free at all times to rewrite sample headers.
920 My reason for this is that we have the sample headers
921 available in the WFB file for General MIDI, and so these
922 can always be reset if needed. The sample data, however,
923 cannot be recovered without a complete reset and firmware
924 reload of the ICS2115, which is a very expensive operation.
926 So, doing things this way allows us to honor the notion of
927 "RESETSAMPLES" reasonably cheaply. Note however, that this
928 is done purely at user level: there is no WFB parser in
929 this driver, and so a complete reset (back to General MIDI,
930 or theoretically some other configuration) is the
931 responsibility of the user level library.
933 To try to do this in the kernel would be a little
934 crazy: we'd need 158K of kernel space just to hold
935 a copy of the patch/program/sample header data.
938 if (dev->rom_samples_rdonly) {
939 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
940 snd_printk ("sample slot %d "
947 wavefront_delete_sample (dev, header->number);
951 dev->freemem = wavefront_freemem (dev);
953 if (dev->freemem < (int)header->size) {
954 snd_printk ("insufficient memory to "
955 "load %d byte sample.\n",
962 skip = WF_GET_CHANNEL(&header->hdr.s);
964 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
965 snd_printk ("channel selection only "
966 "possible on 16-bit samples");
1001 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
1002 "initial skip = %d, skip = %d\n",
1003 WF_GET_CHANNEL (&header->hdr.s),
1004 initial_skip, skip);
1006 /* Be safe, and zero the "Unused" bits ... */
1008 WF_SET_CHANNEL(&header->hdr.s, 0);
1010 /* adjust size for 16 bit samples by dividing by two. We always
1011 send 16 bits per write, even for 8 bit samples, so the length
1012 is always half the size of the sample data in bytes.
1015 length = header->size / 2;
1017 /* the data we're sent has not been munged, and in fact, the
1018 header we have to send isn't just a munged copy either.
1019 so, build the sample header right here.
1022 shptr = &sample_hdr[0];
1024 shptr = munge_int32 (header->number, shptr, 2);
1027 shptr = munge_int32 (length, shptr, 4);
1030 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1031 but the offset only uses 24 bits.
1034 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1036 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1038 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1040 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1043 /* This one is truly weird. What kind of weirdo decided that in
1044 a system dominated by 16 and 32 bit integers, they would use
1048 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1050 /* Why is this nybblified, when the MSB is *always* zero ?
1051 Anyway, we can't take address of bitfield, so make a
1052 good-faith guess at where it starts.
1055 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1058 if (snd_wavefront_cmd (dev,
1060 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1061 NULL, sample_hdr)) {
1062 snd_printk ("sample %sdownload refused.\n",
1063 header->size ? "" : "header ");
1067 if (header->size == 0) {
1068 goto sent; /* Sorry. Just had to have one somewhere */
1071 data_end = dataptr + length;
1073 /* Do any initial skip over an unused channel's data */
1075 dataptr += initial_skip;
1077 for (written = 0, blocknum = 0;
1078 written < length; written += max_blksize, blocknum++) {
1080 if ((length - written) > max_blksize) {
1081 blocksize = max_blksize;
1083 /* round to nearest 16-byte value */
1084 blocksize = ALIGN(length - written, 8);
1087 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1088 snd_printk ("download block "
1089 "request refused.\n");
1093 for (i = 0; i < blocksize; i++) {
1095 if (dataptr < data_end) {
1097 __get_user (sample_short, dataptr);
1100 if (data_is_unsigned) { /* GUS ? */
1102 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1110 &sample_short)[0] += 0x7f;
1112 &sample_short)[1] += 0x7f;
1121 sample_short += 0x7fff;
1127 /* In padding section of final block:
1129 Don't fetch unsupplied data from
1130 user space, just continue with
1131 whatever the final value was.
1135 if (i < blocksize - 1) {
1136 outw (sample_short, dev->block_port);
1138 outw (sample_short, dev->last_block_port);
1142 /* Get "DMA page acknowledge", even though its really
1143 nothing to do with DMA at all.
1146 dma_ack = wavefront_read(dev);
1147 if (dma_ack != WF_DMA_ACK) {
1148 if (dma_ack == -1) {
1149 snd_printk ("upload sample "
1150 "DMA ack timeout\n");
1153 snd_printk ("upload sample "
1154 "DMA ack error 0x%x\n",
1161 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1163 /* Note, label is here because sending the sample header shouldn't
1164 alter the sample_status info at all.
1172 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1175 unsigned char alias_hdr[WF_ALIAS_BYTES];
1177 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1180 header->hdr.a.OriginalSample);
1182 if (header->number >= WF_MAX_SAMPLE)
1185 munge_int32 (header->number, &alias_hdr[0], 2);
1186 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1187 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1189 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1191 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1193 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1195 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1196 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1198 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1199 snd_printk ("download alias failed.\n");
1203 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1209 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1213 unsigned char *msample_hdr;
1215 if (header->number >= WF_MAX_SAMPLE)
1218 msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1222 munge_int32 (header->number, &msample_hdr[0], 2);
1224 /* You'll recall at this point that the "number of samples" value
1225 in a wavefront_multisample struct is actually the log2 of the
1226 real number of samples.
1229 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1230 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1232 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1234 header->hdr.ms.NumberOfSamples,
1237 for (i = 0; i < num_samples; i++) {
1238 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1239 i, header->hdr.ms.SampleNumber[i]);
1240 munge_int32 (header->hdr.ms.SampleNumber[i],
1241 &msample_hdr[3+(i*2)], 2);
1244 /* Need a hack here to pass in the number of bytes
1245 to be written to the synth. This is ugly, and perhaps
1246 one day, I'll fix it.
1249 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1250 (unsigned char *) (long) ((num_samples*2)+3),
1252 snd_printk ("download of multisample failed.\n");
1257 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1264 wavefront_fetch_multisample (snd_wavefront_t *dev,
1265 wavefront_patch_info *header)
1268 unsigned char log_ns[1];
1269 unsigned char number[2];
1272 munge_int32 (header->number, number, 2);
1274 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1275 snd_printk ("upload multisample failed.\n");
1279 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1280 header->number, log_ns[0]);
1282 header->hdr.ms.NumberOfSamples = log_ns[0];
1284 /* get the number of samples ... */
1286 num_samples = (1 << log_ns[0]);
1288 for (i = 0; i < num_samples; i++) {
1292 val = wavefront_read(dev);
1294 snd_printk ("upload multisample failed "
1295 "during sample loop.\n");
1300 val = wavefront_read(dev);
1302 snd_printk ("upload multisample failed "
1303 "during sample loop.\n");
1308 header->hdr.ms.SampleNumber[i] =
1309 demunge_int32 ((unsigned char *) d, 2);
1311 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1312 i, header->hdr.ms.SampleNumber[i]);
1320 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1323 unsigned char drumbuf[WF_DRUM_BYTES];
1324 wavefront_drum *drum = &header->hdr.d;
1327 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1328 "note %d, patch = %d\n",
1329 header->number, drum->PatchNumber);
1331 drumbuf[0] = header->number & 0x7f;
1333 for (i = 0; i < 4; i++) {
1334 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1337 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1338 snd_printk ("download drum failed.\n");
1346 wavefront_find_free_sample (snd_wavefront_t *dev)
1351 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1352 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1356 snd_printk ("no free sample slots!\n");
1362 wavefront_find_free_patch (snd_wavefront_t *dev)
1367 for (i = 0; i < WF_MAX_PATCH; i++) {
1368 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1372 snd_printk ("no free patch slots!\n");
1378 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1380 wavefront_patch_info *header;
1383 header = kmalloc(sizeof(*header), GFP_KERNEL);
1387 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1388 sizeof(wavefront_any))) {
1389 snd_printk ("bad address for load patch.\n");
1394 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1396 "Sample number: %d "
1397 "Sample size: %d\n",
1402 switch (header->subkey) {
1403 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1405 if (copy_from_user (&header->hdr.s, header->hdrptr,
1406 sizeof (wavefront_sample))) {
1411 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1414 case WF_ST_MULTISAMPLE:
1416 if (copy_from_user (&header->hdr.s, header->hdrptr,
1417 sizeof (wavefront_multisample))) {
1422 err = wavefront_send_multisample (dev, header);
1427 if (copy_from_user (&header->hdr.a, header->hdrptr,
1428 sizeof (wavefront_alias))) {
1433 err = wavefront_send_alias (dev, header);
1437 if (copy_from_user (&header->hdr.d, header->hdrptr,
1438 sizeof (wavefront_drum))) {
1443 err = wavefront_send_drum (dev, header);
1447 if (copy_from_user (&header->hdr.p, header->hdrptr,
1448 sizeof (wavefront_patch))) {
1453 err = wavefront_send_patch (dev, header);
1457 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1458 sizeof (wavefront_program))) {
1463 err = wavefront_send_program (dev, header);
1467 snd_printk ("unknown patch type %d.\n",
1478 /***********************************************************************
1479 WaveFront: hardware-dependent interface
1480 ***********************************************************************/
1483 process_sample_hdr (u8 *buf)
1491 /* The board doesn't send us an exact copy of a "wavefront_sample"
1492 in response to an Upload Sample Header command. Instead, we
1493 have to convert the data format back into our data structure,
1494 just as in the Download Sample command, where we have to do
1495 something very similar in the reverse direction.
1498 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1499 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1500 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1501 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1502 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1504 s.SampleResolution = *ptr & 0x3;
1505 s.Loop = *ptr & 0x8;
1506 s.Bidirectional = *ptr & 0x10;
1507 s.Reverse = *ptr & 0x40;
1509 /* Now copy it back to where it came from */
1511 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1515 wavefront_synth_control (snd_wavefront_card_t *acard,
1516 wavefront_control *wc)
1519 snd_wavefront_t *dev = &acard->wavefront;
1520 unsigned char patchnumbuf[2];
1523 DPRINT (WF_DEBUG_CMD, "synth control with "
1524 "cmd 0x%x\n", wc->cmd);
1526 /* Pre-handling of or for various commands */
1530 case WFC_DISABLE_INTERRUPTS:
1531 snd_printk ("interrupts disabled.\n");
1532 outb (0x80|0x20, dev->control_port);
1533 dev->interrupts_are_midi = 1;
1536 case WFC_ENABLE_INTERRUPTS:
1537 snd_printk ("interrupts enabled.\n");
1538 outb (0x80|0x40|0x20, dev->control_port);
1539 dev->interrupts_are_midi = 1;
1542 case WFC_INTERRUPT_STATUS:
1543 wc->rbuf[0] = dev->interrupts_are_midi;
1546 case WFC_ROMSAMPLES_RDONLY:
1547 dev->rom_samples_rdonly = wc->wbuf[0];
1551 case WFC_IDENTIFY_SLOT_TYPE:
1552 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1553 if (i <0 || i >= WF_MAX_SAMPLE) {
1554 snd_printk ("invalid slot ID %d\n",
1556 wc->status = EINVAL;
1559 wc->rbuf[0] = dev->sample_status[i];
1563 case WFC_DEBUG_DRIVER:
1564 dev->debug = wc->wbuf[0];
1565 snd_printk ("debug = 0x%x\n", dev->debug);
1568 case WFC_UPLOAD_PATCH:
1569 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1570 memcpy (wc->wbuf, patchnumbuf, 2);
1573 case WFC_UPLOAD_MULTISAMPLE:
1574 /* multisamples have to be handled differently, and
1575 cannot be dealt with properly by snd_wavefront_cmd() alone.
1577 wc->status = wavefront_fetch_multisample
1578 (dev, (wavefront_patch_info *) wc->rbuf);
1581 case WFC_UPLOAD_SAMPLE_ALIAS:
1582 snd_printk ("support for sample alias upload "
1583 "being considered.\n");
1584 wc->status = EINVAL;
1588 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1590 /* Post-handling of certain commands.
1592 In particular, if the command was an upload, demunge the data
1593 so that the user-level doesn't have to think about it.
1596 if (wc->status == 0) {
1598 /* intercept any freemem requests so that we know
1599 we are always current with the user-level view
1603 case WFC_REPORT_FREE_MEMORY:
1604 dev->freemem = demunge_int32 (wc->rbuf, 4);
1607 case WFC_UPLOAD_PATCH:
1608 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1611 case WFC_UPLOAD_PROGRAM:
1612 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1615 case WFC_UPLOAD_EDRUM_PROGRAM:
1616 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1619 case WFC_UPLOAD_SAMPLE_HEADER:
1620 process_sample_hdr (wc->rbuf);
1623 case WFC_UPLOAD_SAMPLE_ALIAS:
1624 snd_printk ("support for "
1625 "sample aliases still "
1626 "being considered.\n");
1630 snd_wavefront_midi_disable_virtual (acard);
1634 snd_wavefront_midi_enable_virtual (acard);
1643 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1646 if (!try_module_get(hw->card->module))
1648 file->private_data = hw;
1653 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1656 module_put(hw->card->module);
1661 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1662 unsigned int cmd, unsigned long arg)
1665 struct snd_card *card;
1666 snd_wavefront_t *dev;
1667 snd_wavefront_card_t *acard;
1668 wavefront_control *wc;
1669 void __user *argp = (void __user *)arg;
1672 card = (struct snd_card *) hw->card;
1674 if (snd_BUG_ON(!card))
1676 if (snd_BUG_ON(!card->private_data))
1679 acard = card->private_data;
1680 dev = &acard->wavefront;
1683 case WFCTL_LOAD_SPP:
1684 if (wavefront_load_patch (dev, argp) != 0) {
1690 wc = memdup_user(argp, sizeof(*wc));
1694 if (wavefront_synth_control (acard, wc) < 0)
1696 else if (copy_to_user (argp, wc, sizeof (*wc)))
1711 /***********************************************************************/
1712 /* WaveFront: interface for card-level wavefront module */
1713 /***********************************************************************/
1716 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1718 snd_wavefront_t *dev = &card->wavefront;
1721 Some comments on interrupts. I attempted a version of this
1722 driver that used interrupts throughout the code instead of
1723 doing busy and/or sleep-waiting. Alas, it appears that once
1724 the Motorola firmware is downloaded, the card *never*
1725 generates an RX interrupt. These are successfully generated
1726 during firmware loading, and after that wavefront_status()
1727 reports that an interrupt is pending on the card from time
1728 to time, but it never seems to be delivered to this
1729 driver. Note also that wavefront_status() continues to
1730 report that RX interrupts are enabled, suggesting that I
1731 didn't goof up and disable them by mistake.
1733 Thus, I stepped back to a prior version of
1734 wavefront_wait(), the only place where this really
1735 matters. Its sad, but I've looked through the code to check
1736 on things, and I really feel certain that the Motorola
1737 firmware prevents RX-ready interrupts.
1740 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1744 spin_lock(&dev->irq_lock);
1747 spin_unlock(&dev->irq_lock);
1748 wake_up(&dev->interrupt_sleeper);
1753 0 Host Rx Interrupt Enable (1=Enabled)
1754 1 Host Rx Register Full (1=Full)
1755 2 Host Rx Interrupt Pending (1=Interrupt)
1757 4 Host Tx Interrupt (1=Enabled)
1758 5 Host Tx Register empty (1=Empty)
1759 6 Host Tx Interrupt Pending (1=Interrupt)
1764 snd_wavefront_interrupt_bits (int irq)
1784 snd_printk ("invalid IRQ %d\n", irq);
1792 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1793 int val, int port, unsigned long timeout)
1796 wait_queue_entry_t wait;
1798 init_waitqueue_entry(&wait, current);
1799 spin_lock_irq(&dev->irq_lock);
1800 add_wait_queue(&dev->interrupt_sleeper, &wait);
1803 spin_unlock_irq(&dev->irq_lock);
1804 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1805 schedule_timeout_uninterruptible(1);
1811 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1817 /* IRQ already checked */
1819 bits = snd_wavefront_interrupt_bits (dev->irq);
1821 /* try reset of port */
1823 outb (0x0, dev->control_port);
1825 /* At this point, the board is in reset, and the H/W initialization
1826 register is accessed at the same address as the data port.
1828 Bit 7 - Enable IRQ Driver
1829 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1830 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1832 Bit 6 - MIDI Interface Select
1834 0 - Use the MIDI Input from the 26-pin WaveBlaster
1835 compatible header as the serial MIDI source
1836 1 - Use the MIDI Input from the 9-pin D connector as the
1839 Bits 5:3 - IRQ Selection
1850 Bit 0 - Disable Boot ROM
1851 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1852 1 - memory accesses to 03FC30-03FFFFH are directed to external
1857 /* configure hardware: IRQ, enable interrupts,
1858 plus external 9-pin MIDI interface selected
1861 outb (0x80 | 0x40 | bits, dev->data_port);
1865 0 Host Rx Interrupt Enable (1=Enabled) 0x1
1869 4 Host Tx Interrupt Enable 0x10
1870 5 Mute (0=Mute; 1=Play) 0x20
1871 6 Master Interrupt Enable (1=Enabled) 0x40
1872 7 Master Reset (0=Reset; 1=Run) 0x80
1874 Take us out of reset, mute output, master + TX + RX interrupts on.
1876 We'll get an interrupt presumably to tell us that the TX
1880 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1882 (reset_time*HZ)/100);
1884 /* Note: data port is now the data port, not the h/w initialization
1889 snd_printk ("intr not received after h/w un-reset.\n");
1893 /* Note: data port is now the data port, not the h/w initialization
1896 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1897 will work. So, issue one of them, and wait for TX
1898 interrupt. This can take a *long* time after a cold boot,
1899 while the ISC ROM does its RAM test. The SDK says up to 4
1900 seconds - with 12MB of RAM on a Tropez+, it takes a lot
1901 longer than that (~16secs). Note that the card understands
1902 the difference between a warm and a cold boot, so
1903 subsequent ISC2115 reboots (say, caused by module
1904 reloading) will get through this much faster.
1906 XXX Interesting question: why is no RX interrupt received first ?
1909 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1910 dev->data_port, ramcheck_time*HZ);
1913 snd_printk ("post-RAM-check interrupt not received.\n");
1917 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1918 snd_printk ("no response to HW version cmd.\n");
1922 hwv[0] = wavefront_read(dev);
1924 snd_printk ("board not responding correctly.\n");
1928 if (hwv[0] == 0xFF) { /* NAK */
1930 /* Board's RAM test failed. Try to read error code,
1931 and tell us about it either way.
1934 hwv[0] = wavefront_read(dev);
1936 snd_printk ("on-board RAM test failed "
1937 "(bad error code).\n");
1939 snd_printk ("on-board RAM test failed "
1940 "(error code: 0x%x).\n",
1946 /* We're OK, just get the next byte of the HW version response */
1948 hwv[1] = wavefront_read(dev);
1950 snd_printk ("incorrect h/w response.\n");
1954 snd_printk ("hardware version %d.%d\n",
1965 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1968 const unsigned char *buf;
1970 int section_cnt_downloaded = 0;
1971 const struct firmware *firmware;
1973 err = request_firmware(&firmware, path, dev->card->dev);
1975 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1980 buf = firmware->data;
1982 int section_length = *(signed char *)buf;
1983 if (section_length == 0)
1985 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1987 "invalid firmware section length %d\n",
1994 if (firmware->size < len + section_length) {
1995 snd_printk(KERN_ERR "firmware section read error.\n");
2000 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
2003 for (; section_length; section_length--) {
2004 if (wavefront_write(dev, *buf))
2011 if (!wavefront_wait(dev, STAT_CAN_READ)) {
2012 snd_printk(KERN_ERR "time out for firmware ACK.\n");
2015 err = inb(dev->data_port);
2016 if (err != WF_ACK) {
2018 "download of section #%d not "
2019 "acknowledged, ack = 0x%x\n",
2020 section_cnt_downloaded + 1, err);
2024 section_cnt_downloaded++;
2027 release_firmware(firmware);
2031 release_firmware(firmware);
2032 snd_printk(KERN_ERR "firmware download failed!!!\n");
2038 wavefront_do_reset (snd_wavefront_t *dev)
2043 if (wavefront_reset_to_cleanliness (dev)) {
2044 snd_printk ("hw reset failed.\n");
2049 if (wavefront_download_firmware (dev, ospath)) {
2055 /* Wait for the OS to get running. The protocol for
2056 this is non-obvious, and was determined by
2057 using port-IO tracing in DOSemu and some
2058 experimentation here.
2060 Rather than using timed waits, use interrupts creatively.
2063 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2068 snd_printk ("no post-OS interrupt.\n");
2072 /* Now, do it again ! */
2074 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2075 dev->data_port, (10*HZ));
2078 snd_printk ("no post-OS interrupt(2).\n");
2082 /* OK, no (RX/TX) interrupts any more, but leave mute
2086 outb (0x80|0x40, dev->control_port);
2089 /* SETUPSND.EXE asks for sample memory config here, but since i
2090 have no idea how to interpret the result, we'll forget
2094 dev->freemem = wavefront_freemem(dev);
2095 if (dev->freemem < 0)
2098 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2100 if (wavefront_write (dev, 0xf0) ||
2101 wavefront_write (dev, 1) ||
2102 (wavefront_read (dev) < 0)) {
2104 snd_printk ("MPU emulation mode not set.\n");
2110 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2111 snd_printk ("cannot set number of voices to 32.\n");
2119 /* reset that sucker so that it doesn't bother us. */
2121 outb (0x0, dev->control_port);
2122 dev->interrupts_are_midi = 0;
2127 snd_wavefront_start (snd_wavefront_t *dev)
2130 int samples_are_from_rom;
2132 /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2133 wavefront_reset_to_cleanliness() has already been called
2137 samples_are_from_rom = 1;
2139 /* XXX is this always true ? */
2140 samples_are_from_rom = 0;
2143 if (dev->israw || fx_raw) {
2144 if (wavefront_do_reset (dev)) {
2148 /* Check for FX device, present only on Tropez+ */
2150 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2152 if (dev->has_fx && fx_raw) {
2153 snd_wavefront_fx_start (dev);
2156 wavefront_get_sample_status (dev, samples_are_from_rom);
2157 wavefront_get_program_status (dev);
2158 wavefront_get_patch_status (dev);
2160 /* Start normal operation: unreset, master interrupt enabled, no mute
2163 outb (0x80|0x40|0x20, dev->control_port);
2169 snd_wavefront_detect (snd_wavefront_card_t *card)
2172 unsigned char rbuf[4], wbuf[4];
2173 snd_wavefront_t *dev = &card->wavefront;
2175 /* returns zero if a WaveFront card is successfully detected.
2181 dev->debug = debug_default;
2182 dev->interrupts_are_midi = 0;
2184 dev->rom_samples_rdonly = 1;
2186 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2188 dev->fw_version[0] = rbuf[0];
2189 dev->fw_version[1] = rbuf[1];
2191 snd_printk ("firmware %d.%d already loaded.\n",
2194 /* check that a command actually works */
2196 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2198 dev->hw_version[0] = rbuf[0];
2199 dev->hw_version[1] = rbuf[1];
2201 snd_printk ("not raw, but no "
2202 "hardware version!\n");
2209 snd_printk ("reloading firmware as you requested.\n");
2216 snd_printk ("no response to firmware probe, assume raw.\n");
2223 MODULE_FIRMWARE(DEFAULT_OSPATH);