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 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 static char *ospath = "/etc/sound/wavefront.os"; /* where to find a processed
57 version of the WaveFront OS
60 static 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 static int sleep_interval = 100; /* HZ/sleep_interval seconds per sleep */
74 static int sleep_tries = 50; /* number of times we'll try to sleep */
76 static int reset_time = 2; /* hundreths of a second we wait after a HW
77 reset for the expected interrupt.
80 static int ramcheck_time = 20; /* time in seconds to wait while ROM code
84 static 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 schedule_timeout_interruptible(limit);
280 return signal_pending(current);
284 wavefront_wait (snd_wavefront_t *dev, int mask)
289 /* Spin for a short period of time, because >99% of all
290 requests to the WaveFront can be serviced inline like this.
293 for (i = 0; i < wait_usecs; i += 5) {
294 if (wavefront_status (dev) & mask) {
300 for (i = 0; i < sleep_tries; i++) {
302 if (wavefront_status (dev) & mask) {
306 if (wavefront_sleep (HZ/sleep_interval)) {
315 wavefront_read (snd_wavefront_t *dev)
318 if (wavefront_wait (dev, STAT_CAN_READ))
319 return inb (dev->data_port);
321 DPRINT (WF_DEBUG_DATA, "read timeout.\n");
327 wavefront_write (snd_wavefront_t *dev, unsigned char data)
330 if (wavefront_wait (dev, STAT_CAN_WRITE)) {
331 outb (data, dev->data_port);
335 DPRINT (WF_DEBUG_DATA, "write timeout.\n");
341 snd_wavefront_cmd (snd_wavefront_t *dev,
342 int cmd, unsigned char *rbuf, unsigned char *wbuf)
348 wavefront_command *wfcmd;
350 if ((wfcmd = wavefront_get_command (cmd)) == (wavefront_command *) 0) {
351 snd_printk ("command 0x%x not supported.\n",
356 /* Hack to handle the one variable-size write command. See
357 wavefront_send_multisample() for the other half of this
358 gross and ugly strategy.
361 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
362 wfcmd->write_cnt = (unsigned long) rbuf;
366 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
367 cmd, wfcmd->action, wfcmd->read_cnt,
368 wfcmd->write_cnt, wfcmd->need_ack);
370 if (wavefront_write (dev, cmd)) {
371 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
377 if (wfcmd->write_cnt > 0) {
378 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
380 wfcmd->write_cnt, cmd);
382 for (i = 0; i < wfcmd->write_cnt; i++) {
383 if (wavefront_write (dev, wbuf[i])) {
384 DPRINT (WF_DEBUG_IO, "bad write for byte "
385 "%d of 0x%x [%s].\n",
386 i, cmd, wfcmd->action);
390 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
395 if (wfcmd->read_cnt > 0) {
396 DPRINT (WF_DEBUG_DATA, "reading %d ints "
398 wfcmd->read_cnt, cmd);
400 for (i = 0; i < wfcmd->read_cnt; i++) {
402 if ((c = wavefront_read (dev)) == -1) {
403 DPRINT (WF_DEBUG_IO, "bad read for byte "
404 "%d of 0x%x [%s].\n",
405 i, cmd, wfcmd->action);
409 /* Now handle errors. Lots of special cases here */
412 if ((c = wavefront_read (dev)) == -1) {
413 DPRINT (WF_DEBUG_IO, "bad read for "
422 /* Can you believe this madness ? */
425 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
426 rbuf[0] = WF_ST_EMPTY;
430 wfcmd->cmd == WFC_UPLOAD_PATCH) {
435 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
441 DPRINT (WF_DEBUG_IO, "error %d (%s) "
447 wavefront_errorstr (c),
458 DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
462 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
464 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
466 /* Some commands need an ACK, but return zero instead
467 of the standard value.
470 if ((ack = wavefront_read (dev)) == 0) {
476 DPRINT (WF_DEBUG_IO, "cannot read ack for "
482 int err = -1; /* something unknown */
484 if (ack == 0xff) { /* explicit error */
486 if ((err = wavefront_read (dev)) == -1) {
487 DPRINT (WF_DEBUG_DATA,
494 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
495 "failed (0x%x, 0x%x, %s)\n",
496 cmd, wfcmd->action, ack, err,
497 wavefront_errorstr (err));
503 DPRINT (WF_DEBUG_DATA, "ack received "
508 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
510 cmd, wfcmd->action, wfcmd->read_cnt,
511 wfcmd->write_cnt, wfcmd->need_ack);
518 /***********************************************************************
519 WaveFront data munging
521 Things here are weird. All data written to the board cannot
522 have its most significant bit set. Any data item with values
523 potentially > 0x7F (127) must be split across multiple bytes.
525 Sometimes, we need to munge numeric values that are represented on
526 the x86 side as 8-32 bit values. Sometimes, we need to munge data
527 that is represented on the x86 side as an array of bytes. The most
528 efficient approach to handling both cases seems to be to use 2
529 different functions for munging and 2 for de-munging. This avoids
530 weird casting and worrying about bit-level offsets.
532 **********************************************************************/
534 static unsigned char *
535 munge_int32 (unsigned int src,
537 unsigned int dst_size)
541 for (i = 0; i < dst_size; i++) {
542 *dst = src & 0x7F; /* Mask high bit of LSB */
543 src = src >> 7; /* Rotate Right 7 bits */
544 /* Note: we leave the upper bits in place */
552 demunge_int32 (unsigned char* src, int src_size)
558 for (i = src_size - 1; i >= 0; i--) {
559 outval=(outval<<7)+src[i];
567 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
571 unsigned int last = dst_size / 2;
573 for (i = 0; i < last; i++) {
574 *dst++ = src[i] & 0x7f;
575 *dst++ = src[i] >> 7;
582 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
586 unsigned char *end = src + src_bytes;
588 end = src + src_bytes;
590 /* NOTE: src and dst *CAN* point to the same address */
592 for (i = 0; src != end; i++) {
594 dst[i] |= (*src++)<<7;
600 /***********************************************************************
601 WaveFront: sample, patch and program management.
602 ***********************************************************************/
605 wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
608 unsigned char wbuf[2];
611 wbuf[0] = sample_num & 0x7f;
612 wbuf[1] = sample_num >> 7;
614 if ((x = snd_wavefront_cmd (dev, WFC_DELETE_SAMPLE, NULL, wbuf)) == 0) {
615 dev->sample_status[sample_num] = WF_ST_EMPTY;
622 wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
626 unsigned char rbuf[32], wbuf[32];
627 unsigned int sc_real, sc_alias, sc_multi;
629 /* check sample status */
631 if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
632 snd_printk ("cannot request sample count.\n");
636 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
638 for (i = 0; i < WF_MAX_SAMPLE; i++) {
643 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
644 snd_printk("cannot identify sample "
645 "type of slot %d\n", i);
646 dev->sample_status[i] = WF_ST_EMPTY;
650 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
653 dev->sample_status[i] |= WF_SLOT_ROM;
656 switch (rbuf[0] & WF_ST_MASK) {
660 case WF_ST_MULTISAMPLE:
670 snd_printk ("unknown sample type for "
675 if (rbuf[0] != WF_ST_EMPTY) {
680 snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
681 "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
682 WF_MAX_SAMPLE - dev->samples_used);
690 wavefront_get_patch_status (snd_wavefront_t *dev)
693 unsigned char patchbuf[WF_PATCH_BYTES];
694 unsigned char patchnum[2];
698 for (i = 0; i < WF_MAX_PATCH; i++) {
699 patchnum[0] = i & 0x7f;
700 patchnum[1] = i >> 7;
702 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PATCH, patchbuf,
705 dev->patch_status[i] |= WF_SLOT_FILLED;
706 p = (wavefront_patch *) patchbuf;
708 [p->sample_number|(p->sample_msb<<7)] |=
711 } else if (x == 3) { /* Bad patch number */
712 dev->patch_status[i] = 0;
714 snd_printk ("upload patch "
716 dev->patch_status[i] = 0;
721 /* program status has already filled in slot_used bits */
723 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
724 if (dev->patch_status[i] & WF_SLOT_FILLED) {
727 if (dev->patch_status[i] & WF_SLOT_USED) {
732 snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
738 wavefront_get_program_status (snd_wavefront_t *dev)
741 unsigned char progbuf[WF_PROGRAM_BYTES];
742 wavefront_program prog;
743 unsigned char prognum;
746 for (i = 0; i < WF_MAX_PROGRAM; i++) {
749 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PROGRAM, progbuf,
752 dev->prog_status[i] |= WF_SLOT_USED;
754 demunge_buf (progbuf, (unsigned char *) &prog,
757 for (l = 0; l < WF_NUM_LAYERS; l++) {
758 if (prog.layer[l].mute) {
760 [prog.layer[l].patch_number] |=
764 } else if (x == 1) { /* Bad program number */
765 dev->prog_status[i] = 0;
767 snd_printk ("upload program "
769 dev->prog_status[i] = 0;
773 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
774 if (dev->prog_status[i]) {
779 snd_printk ("%d programs slots in use\n", cnt);
785 wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
788 unsigned char buf[WF_PATCH_BYTES+2];
791 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
794 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 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
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);
909 /* XXX it's a debatable point whether or not RDONLY semantics
910 on the ROM samples should cover just the sample data or
911 the sample header. For now, it only covers the sample data,
912 so anyone is free at all times to rewrite sample headers.
914 My reason for this is that we have the sample headers
915 available in the WFB file for General MIDI, and so these
916 can always be reset if needed. The sample data, however,
917 cannot be recovered without a complete reset and firmware
918 reload of the ICS2115, which is a very expensive operation.
920 So, doing things this way allows us to honor the notion of
921 "RESETSAMPLES" reasonably cheaply. Note however, that this
922 is done purely at user level: there is no WFB parser in
923 this driver, and so a complete reset (back to General MIDI,
924 or theoretically some other configuration) is the
925 responsibility of the user level library.
927 To try to do this in the kernel would be a little
928 crazy: we'd need 158K of kernel space just to hold
929 a copy of the patch/program/sample header data.
932 if (dev->rom_samples_rdonly) {
933 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
934 snd_printk ("sample slot %d "
941 wavefront_delete_sample (dev, header->number);
945 dev->freemem = wavefront_freemem (dev);
947 if (dev->freemem < (int)header->size) {
948 snd_printk ("insufficient memory to "
949 "load %d byte sample.\n",
956 skip = WF_GET_CHANNEL(&header->hdr.s);
958 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
959 snd_printk ("channel selection only "
960 "possible on 16-bit samples");
995 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
996 "initial skip = %d, skip = %d\n",
997 WF_GET_CHANNEL (&header->hdr.s),
1000 /* Be safe, and zero the "Unused" bits ... */
1002 WF_SET_CHANNEL(&header->hdr.s, 0);
1004 /* adjust size for 16 bit samples by dividing by two. We always
1005 send 16 bits per write, even for 8 bit samples, so the length
1006 is always half the size of the sample data in bytes.
1009 length = header->size / 2;
1011 /* the data we're sent has not been munged, and in fact, the
1012 header we have to send isn't just a munged copy either.
1013 so, build the sample header right here.
1016 shptr = &sample_hdr[0];
1018 shptr = munge_int32 (header->number, shptr, 2);
1021 shptr = munge_int32 (length, shptr, 4);
1024 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1025 but the offset only uses 24 bits.
1028 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1030 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1032 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1034 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1037 /* This one is truly weird. What kind of weirdo decided that in
1038 a system dominated by 16 and 32 bit integers, they would use
1042 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1044 /* Why is this nybblified, when the MSB is *always* zero ?
1045 Anyway, we can't take address of bitfield, so make a
1046 good-faith guess at where it starts.
1049 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1052 if (snd_wavefront_cmd (dev,
1054 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1055 NULL, sample_hdr)) {
1056 snd_printk ("sample %sdownload refused.\n",
1057 header->size ? "" : "header ");
1061 if (header->size == 0) {
1062 goto sent; /* Sorry. Just had to have one somewhere */
1065 data_end = dataptr + length;
1067 /* Do any initial skip over an unused channel's data */
1069 dataptr += initial_skip;
1071 for (written = 0, blocknum = 0;
1072 written < length; written += max_blksize, blocknum++) {
1074 if ((length - written) > max_blksize) {
1075 blocksize = max_blksize;
1077 /* round to nearest 16-byte value */
1078 blocksize = ((length-written+7)&~0x7);
1081 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1082 snd_printk ("download block "
1083 "request refused.\n");
1087 for (i = 0; i < blocksize; i++) {
1089 if (dataptr < data_end) {
1091 __get_user (sample_short, dataptr);
1094 if (data_is_unsigned) { /* GUS ? */
1096 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1104 &sample_short)[0] += 0x7f;
1106 &sample_short)[1] += 0x7f;
1115 sample_short += 0x7fff;
1121 /* In padding section of final block:
1123 Don't fetch unsupplied data from
1124 user space, just continue with
1125 whatever the final value was.
1129 if (i < blocksize - 1) {
1130 outw (sample_short, dev->block_port);
1132 outw (sample_short, dev->last_block_port);
1136 /* Get "DMA page acknowledge", even though its really
1137 nothing to do with DMA at all.
1140 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1141 if (dma_ack == -1) {
1142 snd_printk ("upload sample "
1143 "DMA ack timeout\n");
1146 snd_printk ("upload sample "
1147 "DMA ack error 0x%x\n",
1154 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1156 /* Note, label is here because sending the sample header shouldn't
1157 alter the sample_status info at all.
1165 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1168 unsigned char alias_hdr[WF_ALIAS_BYTES];
1170 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1173 header->hdr.a.OriginalSample);
1175 munge_int32 (header->number, &alias_hdr[0], 2);
1176 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1177 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1179 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1181 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1183 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1185 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1186 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1188 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1189 snd_printk ("download alias failed.\n");
1193 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1199 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1203 unsigned char *msample_hdr;
1205 msample_hdr = kmalloc(sizeof(WF_MSAMPLE_BYTES), GFP_KERNEL);
1209 munge_int32 (header->number, &msample_hdr[0], 2);
1211 /* You'll recall at this point that the "number of samples" value
1212 in a wavefront_multisample struct is actually the log2 of the
1213 real number of samples.
1216 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1217 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1219 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1221 header->hdr.ms.NumberOfSamples,
1224 for (i = 0; i < num_samples; i++) {
1225 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1226 i, header->hdr.ms.SampleNumber[i]);
1227 munge_int32 (header->hdr.ms.SampleNumber[i],
1228 &msample_hdr[3+(i*2)], 2);
1231 /* Need a hack here to pass in the number of bytes
1232 to be written to the synth. This is ugly, and perhaps
1233 one day, I'll fix it.
1236 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1237 (unsigned char *) (long) ((num_samples*2)+3),
1239 snd_printk ("download of multisample failed.\n");
1244 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1251 wavefront_fetch_multisample (snd_wavefront_t *dev,
1252 wavefront_patch_info *header)
1255 unsigned char log_ns[1];
1256 unsigned char number[2];
1259 munge_int32 (header->number, number, 2);
1261 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1262 snd_printk ("upload multisample failed.\n");
1266 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1267 header->number, log_ns[0]);
1269 header->hdr.ms.NumberOfSamples = log_ns[0];
1271 /* get the number of samples ... */
1273 num_samples = (1 << log_ns[0]);
1275 for (i = 0; i < num_samples; i++) {
1279 if ((val = wavefront_read (dev)) == -1) {
1280 snd_printk ("upload multisample failed "
1281 "during sample loop.\n");
1286 if ((val = wavefront_read (dev)) == -1) {
1287 snd_printk ("upload multisample failed "
1288 "during sample loop.\n");
1293 header->hdr.ms.SampleNumber[i] =
1294 demunge_int32 ((unsigned char *) d, 2);
1296 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1297 i, header->hdr.ms.SampleNumber[i]);
1305 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1308 unsigned char drumbuf[WF_DRUM_BYTES];
1309 wavefront_drum *drum = &header->hdr.d;
1312 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1313 "note %d, patch = %d\n",
1314 header->number, drum->PatchNumber);
1316 drumbuf[0] = header->number & 0x7f;
1318 for (i = 0; i < 4; i++) {
1319 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1322 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1323 snd_printk ("download drum failed.\n");
1331 wavefront_find_free_sample (snd_wavefront_t *dev)
1336 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1337 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1341 snd_printk ("no free sample slots!\n");
1347 wavefront_find_free_patch (snd_wavefront_t *dev)
1352 for (i = 0; i < WF_MAX_PATCH; i++) {
1353 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1357 snd_printk ("no free patch slots!\n");
1363 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1365 wavefront_patch_info *header;
1368 header = kmalloc(sizeof(*header), GFP_KERNEL);
1372 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1373 sizeof(wavefront_any))) {
1374 snd_printk ("bad address for load patch.\n");
1379 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1381 "Sample number: %d "
1382 "Sample size: %d\n",
1387 switch (header->subkey) {
1388 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1390 if (copy_from_user (&header->hdr.s, header->hdrptr,
1391 sizeof (wavefront_sample))) {
1396 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1399 case WF_ST_MULTISAMPLE:
1401 if (copy_from_user (&header->hdr.s, header->hdrptr,
1402 sizeof (wavefront_multisample))) {
1407 err = wavefront_send_multisample (dev, header);
1412 if (copy_from_user (&header->hdr.a, header->hdrptr,
1413 sizeof (wavefront_alias))) {
1418 err = wavefront_send_alias (dev, header);
1422 if (copy_from_user (&header->hdr.d, header->hdrptr,
1423 sizeof (wavefront_drum))) {
1428 err = wavefront_send_drum (dev, header);
1432 if (copy_from_user (&header->hdr.p, header->hdrptr,
1433 sizeof (wavefront_patch))) {
1438 err = wavefront_send_patch (dev, header);
1442 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1443 sizeof (wavefront_program))) {
1448 err = wavefront_send_program (dev, header);
1452 snd_printk ("unknown patch type %d.\n",
1463 /***********************************************************************
1464 WaveFront: hardware-dependent interface
1465 ***********************************************************************/
1468 process_sample_hdr (u8 *buf)
1476 /* The board doesn't send us an exact copy of a "wavefront_sample"
1477 in response to an Upload Sample Header command. Instead, we
1478 have to convert the data format back into our data structure,
1479 just as in the Download Sample command, where we have to do
1480 something very similar in the reverse direction.
1483 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1484 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1485 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1486 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1487 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1489 s.SampleResolution = *ptr & 0x3;
1490 s.Loop = *ptr & 0x8;
1491 s.Bidirectional = *ptr & 0x10;
1492 s.Reverse = *ptr & 0x40;
1494 /* Now copy it back to where it came from */
1496 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1500 wavefront_synth_control (snd_wavefront_card_t *acard,
1501 wavefront_control *wc)
1504 snd_wavefront_t *dev = &acard->wavefront;
1505 unsigned char patchnumbuf[2];
1508 DPRINT (WF_DEBUG_CMD, "synth control with "
1509 "cmd 0x%x\n", wc->cmd);
1511 /* Pre-handling of or for various commands */
1515 case WFC_DISABLE_INTERRUPTS:
1516 snd_printk ("interrupts disabled.\n");
1517 outb (0x80|0x20, dev->control_port);
1518 dev->interrupts_are_midi = 1;
1521 case WFC_ENABLE_INTERRUPTS:
1522 snd_printk ("interrupts enabled.\n");
1523 outb (0x80|0x40|0x20, dev->control_port);
1524 dev->interrupts_are_midi = 1;
1527 case WFC_INTERRUPT_STATUS:
1528 wc->rbuf[0] = dev->interrupts_are_midi;
1531 case WFC_ROMSAMPLES_RDONLY:
1532 dev->rom_samples_rdonly = wc->wbuf[0];
1536 case WFC_IDENTIFY_SLOT_TYPE:
1537 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1538 if (i <0 || i >= WF_MAX_SAMPLE) {
1539 snd_printk ("invalid slot ID %d\n",
1541 wc->status = EINVAL;
1544 wc->rbuf[0] = dev->sample_status[i];
1548 case WFC_DEBUG_DRIVER:
1549 dev->debug = wc->wbuf[0];
1550 snd_printk ("debug = 0x%x\n", dev->debug);
1553 case WFC_UPLOAD_PATCH:
1554 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1555 memcpy (wc->wbuf, patchnumbuf, 2);
1558 case WFC_UPLOAD_MULTISAMPLE:
1559 /* multisamples have to be handled differently, and
1560 cannot be dealt with properly by snd_wavefront_cmd() alone.
1562 wc->status = wavefront_fetch_multisample
1563 (dev, (wavefront_patch_info *) wc->rbuf);
1566 case WFC_UPLOAD_SAMPLE_ALIAS:
1567 snd_printk ("support for sample alias upload "
1568 "being considered.\n");
1569 wc->status = EINVAL;
1573 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1575 /* Post-handling of certain commands.
1577 In particular, if the command was an upload, demunge the data
1578 so that the user-level doesn't have to think about it.
1581 if (wc->status == 0) {
1583 /* intercept any freemem requests so that we know
1584 we are always current with the user-level view
1588 case WFC_REPORT_FREE_MEMORY:
1589 dev->freemem = demunge_int32 (wc->rbuf, 4);
1592 case WFC_UPLOAD_PATCH:
1593 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1596 case WFC_UPLOAD_PROGRAM:
1597 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1600 case WFC_UPLOAD_EDRUM_PROGRAM:
1601 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1604 case WFC_UPLOAD_SAMPLE_HEADER:
1605 process_sample_hdr (wc->rbuf);
1608 case WFC_UPLOAD_SAMPLE_ALIAS:
1609 snd_printk ("support for "
1610 "sample aliases still "
1611 "being considered.\n");
1615 snd_wavefront_midi_disable_virtual (acard);
1619 snd_wavefront_midi_enable_virtual (acard);
1628 snd_wavefront_synth_open (snd_hwdep_t *hw, struct file *file)
1631 if (!try_module_get(hw->card->module))
1633 file->private_data = hw;
1638 snd_wavefront_synth_release (snd_hwdep_t *hw, struct file *file)
1641 module_put(hw->card->module);
1646 snd_wavefront_synth_ioctl (snd_hwdep_t *hw, struct file *file,
1647 unsigned int cmd, unsigned long arg)
1651 snd_wavefront_t *dev;
1652 snd_wavefront_card_t *acard;
1653 wavefront_control *wc;
1654 void __user *argp = (void __user *)arg;
1657 card = (snd_card_t *) hw->card;
1659 snd_assert(card != NULL, return -ENODEV);
1661 snd_assert(card->private_data != NULL, return -ENODEV);
1663 acard = card->private_data;
1664 dev = &acard->wavefront;
1667 case WFCTL_LOAD_SPP:
1668 if (wavefront_load_patch (dev, argp) != 0) {
1674 wc = kmalloc(sizeof(*wc), GFP_KERNEL);
1677 if (copy_from_user (wc, argp, sizeof (*wc)))
1679 else if (wavefront_synth_control (acard, wc) < 0)
1681 else if (copy_to_user (argp, wc, sizeof (*wc)))
1696 /***********************************************************************/
1697 /* WaveFront: interface for card-level wavefront module */
1698 /***********************************************************************/
1701 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1703 snd_wavefront_t *dev = &card->wavefront;
1706 Some comments on interrupts. I attempted a version of this
1707 driver that used interrupts throughout the code instead of
1708 doing busy and/or sleep-waiting. Alas, it appears that once
1709 the Motorola firmware is downloaded, the card *never*
1710 generates an RX interrupt. These are successfully generated
1711 during firmware loading, and after that wavefront_status()
1712 reports that an interrupt is pending on the card from time
1713 to time, but it never seems to be delivered to this
1714 driver. Note also that wavefront_status() continues to
1715 report that RX interrupts are enabled, suggesting that I
1716 didn't goof up and disable them by mistake.
1718 Thus, I stepped back to a prior version of
1719 wavefront_wait(), the only place where this really
1720 matters. Its sad, but I've looked through the code to check
1721 on things, and I really feel certain that the Motorola
1722 firmware prevents RX-ready interrupts.
1725 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1729 spin_lock(&dev->irq_lock);
1732 spin_unlock(&dev->irq_lock);
1733 wake_up(&dev->interrupt_sleeper);
1738 0 Host Rx Interrupt Enable (1=Enabled)
1739 1 Host Rx Register Full (1=Full)
1740 2 Host Rx Interrupt Pending (1=Interrupt)
1742 4 Host Tx Interrupt (1=Enabled)
1743 5 Host Tx Register empty (1=Empty)
1744 6 Host Tx Interrupt Pending (1=Interrupt)
1749 snd_wavefront_interrupt_bits (int irq)
1769 snd_printk ("invalid IRQ %d\n", irq);
1777 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1778 int val, int port, int timeout)
1783 init_waitqueue_entry(&wait, current);
1784 spin_lock_irq(&dev->irq_lock);
1785 add_wait_queue(&dev->interrupt_sleeper, &wait);
1788 spin_unlock_irq(&dev->irq_lock);
1790 if ((timeout = schedule_timeout_interruptible(timeout)) == 0)
1798 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1804 /* IRQ already checked */
1806 bits = snd_wavefront_interrupt_bits (dev->irq);
1808 /* try reset of port */
1810 outb (0x0, dev->control_port);
1812 /* At this point, the board is in reset, and the H/W initialization
1813 register is accessed at the same address as the data port.
1815 Bit 7 - Enable IRQ Driver
1816 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1817 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1819 Bit 6 - MIDI Interface Select
1821 0 - Use the MIDI Input from the 26-pin WaveBlaster
1822 compatible header as the serial MIDI source
1823 1 - Use the MIDI Input from the 9-pin D connector as the
1826 Bits 5:3 - IRQ Selection
1837 Bit 0 - Disable Boot ROM
1838 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1839 1 - memory accesses to 03FC30-03FFFFH are directed to external
1844 /* configure hardware: IRQ, enable interrupts,
1845 plus external 9-pin MIDI interface selected
1848 outb (0x80 | 0x40 | bits, dev->data_port);
1852 0 Host Rx Interrupt Enable (1=Enabled) 0x1
1856 4 Host Tx Interrupt Enable 0x10
1857 5 Mute (0=Mute; 1=Play) 0x20
1858 6 Master Interrupt Enable (1=Enabled) 0x40
1859 7 Master Reset (0=Reset; 1=Run) 0x80
1861 Take us out of reset, mute output, master + TX + RX interrupts on.
1863 We'll get an interrupt presumably to tell us that the TX
1867 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1869 (reset_time*HZ)/100);
1871 /* Note: data port is now the data port, not the h/w initialization
1876 snd_printk ("intr not received after h/w un-reset.\n");
1880 /* Note: data port is now the data port, not the h/w initialization
1883 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1884 will work. So, issue one of them, and wait for TX
1885 interrupt. This can take a *long* time after a cold boot,
1886 while the ISC ROM does its RAM test. The SDK says up to 4
1887 seconds - with 12MB of RAM on a Tropez+, it takes a lot
1888 longer than that (~16secs). Note that the card understands
1889 the difference between a warm and a cold boot, so
1890 subsequent ISC2115 reboots (say, caused by module
1891 reloading) will get through this much faster.
1893 XXX Interesting question: why is no RX interrupt received first ?
1896 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1897 dev->data_port, ramcheck_time*HZ);
1900 snd_printk ("post-RAM-check interrupt not received.\n");
1904 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1905 snd_printk ("no response to HW version cmd.\n");
1909 if ((hwv[0] = wavefront_read (dev)) == -1) {
1910 snd_printk ("board not responding correctly.\n");
1914 if (hwv[0] == 0xFF) { /* NAK */
1916 /* Board's RAM test failed. Try to read error code,
1917 and tell us about it either way.
1920 if ((hwv[0] = wavefront_read (dev)) == -1) {
1921 snd_printk ("on-board RAM test failed "
1922 "(bad error code).\n");
1924 snd_printk ("on-board RAM test failed "
1925 "(error code: 0x%x).\n",
1931 /* We're OK, just get the next byte of the HW version response */
1933 if ((hwv[1] = wavefront_read (dev)) == -1) {
1934 snd_printk ("incorrect h/w response.\n");
1938 snd_printk ("hardware version %d.%d\n",
1948 #include <linux/fs.h>
1949 #include <linux/mm.h>
1950 #include <linux/slab.h>
1951 #include <linux/unistd.h>
1952 #include <linux/syscalls.h>
1953 #include <asm/uaccess.h>
1957 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1960 unsigned char section[WF_SECTION_MAX];
1961 signed char section_length; /* yes, just a char; max value is WF_SECTION_MAX */
1962 int section_cnt_downloaded = 0;
1968 /* This tries to be a bit cleverer than the stuff Alan Cox did for
1969 the generic sound firmware, in that it actually knows
1970 something about the structure of the Motorola firmware. In
1971 particular, it uses a version that has been stripped of the
1972 20K of useless header information, and had section lengths
1973 added, making it possible to load the entire OS without any
1974 [kv]malloc() activity, since the longest entity we ever read is
1975 42 bytes (well, WF_SECTION_MAX) long.
1981 if ((fd = sys_open ((char __user *) path, 0, 0)) < 0) {
1982 snd_printk ("Unable to load \"%s\".\n",
1990 if ((x = sys_read (fd, (char __user *) §ion_length, sizeof (section_length))) !=
1991 sizeof (section_length)) {
1992 snd_printk ("firmware read error.\n");
1996 if (section_length == 0) {
2000 if (section_length < 0 || section_length > WF_SECTION_MAX) {
2001 snd_printk ("invalid firmware section length %d\n",
2006 if (sys_read (fd, (char __user *) section, section_length) != section_length) {
2007 snd_printk ("firmware section "
2014 if (wavefront_write (dev, WFC_DOWNLOAD_OS)) {
2018 for (i = 0; i < section_length; i++) {
2019 if (wavefront_write (dev, section[i])) {
2026 if (wavefront_wait (dev, STAT_CAN_READ)) {
2028 if ((c = inb (dev->data_port)) != WF_ACK) {
2030 snd_printk ("download "
2031 "of section #%d not "
2032 "acknowledged, ack = 0x%x\n",
2033 section_cnt_downloaded + 1, c);
2039 snd_printk ("time out for firmware ACK.\n");
2052 snd_printk ("firmware download failed!!!\n");
2058 wavefront_do_reset (snd_wavefront_t *dev)
2063 if (wavefront_reset_to_cleanliness (dev)) {
2064 snd_printk ("hw reset failed.\n");
2069 if (wavefront_download_firmware (dev, ospath)) {
2075 /* Wait for the OS to get running. The protocol for
2076 this is non-obvious, and was determined by
2077 using port-IO tracing in DOSemu and some
2078 experimentation here.
2080 Rather than using timed waits, use interrupts creatively.
2083 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2088 snd_printk ("no post-OS interrupt.\n");
2092 /* Now, do it again ! */
2094 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2095 dev->data_port, (10*HZ));
2098 snd_printk ("no post-OS interrupt(2).\n");
2102 /* OK, no (RX/TX) interrupts any more, but leave mute
2106 outb (0x80|0x40, dev->control_port);
2109 /* SETUPSND.EXE asks for sample memory config here, but since i
2110 have no idea how to interpret the result, we'll forget
2114 if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2118 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2120 if (wavefront_write (dev, 0xf0) ||
2121 wavefront_write (dev, 1) ||
2122 (wavefront_read (dev) < 0)) {
2124 snd_printk ("MPU emulation mode not set.\n");
2130 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2131 snd_printk ("cannot set number of voices to 32.\n");
2139 /* reset that sucker so that it doesn't bother us. */
2141 outb (0x0, dev->control_port);
2142 dev->interrupts_are_midi = 0;
2147 snd_wavefront_start (snd_wavefront_t *dev)
2150 int samples_are_from_rom;
2152 /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2153 wavefront_reset_to_cleanliness() has already been called
2157 samples_are_from_rom = 1;
2159 /* XXX is this always true ? */
2160 samples_are_from_rom = 0;
2163 if (dev->israw || fx_raw) {
2164 if (wavefront_do_reset (dev)) {
2168 /* Check for FX device, present only on Tropez+ */
2170 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2172 if (dev->has_fx && fx_raw) {
2173 snd_wavefront_fx_start (dev);
2176 wavefront_get_sample_status (dev, samples_are_from_rom);
2177 wavefront_get_program_status (dev);
2178 wavefront_get_patch_status (dev);
2180 /* Start normal operation: unreset, master interrupt enabled, no mute
2183 outb (0x80|0x40|0x20, dev->control_port);
2189 snd_wavefront_detect (snd_wavefront_card_t *card)
2192 unsigned char rbuf[4], wbuf[4];
2193 snd_wavefront_t *dev = &card->wavefront;
2195 /* returns zero if a WaveFront card is successfully detected.
2201 dev->debug = debug_default;
2202 dev->interrupts_are_midi = 0;
2204 dev->rom_samples_rdonly = 1;
2206 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2208 dev->fw_version[0] = rbuf[0];
2209 dev->fw_version[1] = rbuf[1];
2211 snd_printk ("firmware %d.%d already loaded.\n",
2214 /* check that a command actually works */
2216 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2218 dev->hw_version[0] = rbuf[0];
2219 dev->hw_version[1] = rbuf[1];
2221 snd_printk ("not raw, but no "
2222 "hardware version!\n");
2229 snd_printk ("reloading firmware as you requested.\n");
2236 snd_printk ("no response to firmware probe, assume raw.\n");