?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / sound / isa / wavefront / wavefront_synth.c
blob69faea7cd7deada1023d106faf927dc9dc4bffe5
1 /* Copyright (C) by Paul Barton-Davis 1998-1999
2 *
3 * Some portions of this file are taken from work that is
4 * copyright (C) by Hannu Savolainen 1993-1996
5 *
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
8 * for more info.
9 */
10
11 /*
12 * An ALSA lowlevel driver for Turtle Beach ICS2115 wavetable synth
13 * (Maui, Tropez, Tropez Plus)
14 *
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.
20 *
21 */
22
23 #include <asm/io.h>
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 <sound/core.h>
33 #include <sound/snd_wavefront.h>
34 #include <sound/initval.h>
35
36 static int wf_raw = 0; /* we normally check for "raw state" to firmware
37 loading. if non-zero, then during driver loading, the
38 state of the board is ignored, and we reset the
39 board and load the firmware anyway.
40 */
41
42 static int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
43 whatever state it is when the driver is loaded.
44 The default is to download the microprogram and
45 associated coefficients to set it up for "default"
46 operation, whatever that means.
47 */
48
49 static int debug_default = 0; /* you can set this to control debugging
50 during driver loading. it takes any combination
51 of the WF_DEBUG_* flags defined in
52 wavefront.h
53 */
54
55
56 #define DEFAULT_OSPATH "wavefront.os"
57 static char *ospath = DEFAULT_OSPATH; /* the firmware file name */
58
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
66 whole CPU.
67
68 Specifically, with this number, out of about 134,000
69 status waits, only about 250 result in a sleep.
70 */
71
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 */
74
75 static int reset_time = 2; /* hundreths of a second we wait after a HW
76 reset for the expected interrupt.
77 */
78
79 static int ramcheck_time = 20; /* time in seconds to wait while ROM code
80 checks on-board RAM.
81 */
82
83 static int osrun_time = 10; /* time in seconds we wait for the OS to
84 start running.
85 */
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");
106
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
110 version.
111 */
112
113 #define WF_DEBUG 1
114
115 #ifdef WF_DEBUG
116
117 #define DPRINT(cond, ...) \
118 if ((dev->debug & (cond)) == (cond)) { \
119 snd_printk (__VA_ARGS__); \
120 }
121 #else
122 #define DPRINT(cond, args...)
123 #endif /* WF_DEBUG */
124
125 #define LOGNAME "WaveFront: "
126
127 /* bitmasks for WaveFront status port value */
128
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
135
136 static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
137 static int wavefront_find_free_sample (snd_wavefront_t *);
138
139 struct wavefront_command {
140 int cmd;
141 char *action;
142 unsigned int read_cnt;
143 unsigned int write_cnt;
144 int need_ack;
145 };
146
147 static struct {
148 int errno;
149 const char *errstr;
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" },
159 { 0x80, "Success" },
160 { 0x0 }
161 };
162
163 #define NEEDS_ACK 1
164
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 },
191
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.
195 Ugh.
196 */
197
198 { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
199
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.
203 */
204
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,
218 NEEDS_ACK},
219 { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
220 { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
221 0, 1, NEEDS_ACK },
222 { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
223 { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
224 32, 0, 0 },
225 { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
226 { 0x00 }
227 };
228
229 static const char *
230 wavefront_errorstr (int errnum)
231
232 {
233 int i;
234
235 for (i = 0; wavefront_errors[i].errstr; i++) {
236 if (wavefront_errors[i].errno == errnum) {
237 return wavefront_errors[i].errstr;
238 }
239 }
240
241 return "Unknown WaveFront error";
242 }
243
244 static struct wavefront_command *
245 wavefront_get_command (int cmd)
246
247 {
248 int i;
249
250 for (i = 0; wavefront_commands[i].cmd != 0; i++) {
251 if (cmd == wavefront_commands[i].cmd) {
252 return &wavefront_commands[i];
253 }
254 }
255
256 return NULL;
257 }
258
259 static inline int
260 wavefront_status (snd_wavefront_t *dev)
261
262 {
263 return inb (dev->status_port);
264 }
265
266 static int
267 wavefront_sleep (int limit)
268
269 {
270 schedule_timeout_interruptible(limit);
271
272 return signal_pending(current);
273 }
274
275 static int
276 wavefront_wait (snd_wavefront_t *dev, int mask)
277
278 {
279 int i;
280
281 /* Spin for a short period of time, because >99% of all
282 requests to the WaveFront can be serviced inline like this.
283 */
284
285 for (i = 0; i < wait_usecs; i += 5) {
286 if (wavefront_status (dev) & mask) {
287 return 1;
288 }
289 udelay(5);
290 }
291
292 for (i = 0; i < sleep_tries; i++) {
293
294 if (wavefront_status (dev) & mask) {
295 return 1;
296 }
297
298 if (wavefront_sleep (HZ/sleep_interval)) {
299 return (0);
300 }
301 }
302
303 return (0);
304 }
305
306 static int
307 wavefront_read (snd_wavefront_t *dev)
308
309 {
310 if (wavefront_wait (dev, STAT_CAN_READ))
311 return inb (dev->data_port);
312
313 DPRINT (WF_DEBUG_DATA, "read timeout.\n");
314
315 return -1;
316 }
317
318 static int
319 wavefront_write (snd_wavefront_t *dev, unsigned char data)
320
321 {
322 if (wavefront_wait (dev, STAT_CAN_WRITE)) {
323 outb (data, dev->data_port);
324 return 0;
325 }
326
327 DPRINT (WF_DEBUG_DATA, "write timeout.\n");
328
329 return -1;
330 }
331
332 int
333 snd_wavefront_cmd (snd_wavefront_t *dev,
334 int cmd, unsigned char *rbuf, unsigned char *wbuf)
335
336 {
337 int ack;
338 unsigned int i;
339 int c;
340 struct wavefront_command *wfcmd;
341
342 if ((wfcmd = wavefront_get_command (cmd)) == NULL) {
343 snd_printk ("command 0x%x not supported.\n",
344 cmd);
345 return 1;
346 }
347
348 /* Hack to handle the one variable-size write command. See
349 wavefront_send_multisample() for the other half of this
350 gross and ugly strategy.
351 */
352
353 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
354 wfcmd->write_cnt = (unsigned long) rbuf;
355 rbuf = NULL;
356 }
357
358 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
359 cmd, wfcmd->action, wfcmd->read_cnt,
360 wfcmd->write_cnt, wfcmd->need_ack);
361
362 if (wavefront_write (dev, cmd)) {
363 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
364 "0x%x [%s].\n",
365 cmd, wfcmd->action);
366 return 1;
367 }
368
369 if (wfcmd->write_cnt > 0) {
370 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
371 "for 0x%x\n",
372 wfcmd->write_cnt, cmd);
373
374 for (i = 0; i < wfcmd->write_cnt; i++) {
375 if (wavefront_write (dev, wbuf[i])) {
376 DPRINT (WF_DEBUG_IO, "bad write for byte "
377 "%d of 0x%x [%s].\n",
378 i, cmd, wfcmd->action);
379 return 1;
380 }
381
382 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
383 i, wbuf[i]);
384 }
385 }
386
387 if (wfcmd->read_cnt > 0) {
388 DPRINT (WF_DEBUG_DATA, "reading %d ints "
389 "for 0x%x\n",
390 wfcmd->read_cnt, cmd);
391
392 for (i = 0; i < wfcmd->read_cnt; i++) {
393
394 if ((c = wavefront_read (dev)) == -1) {
395 DPRINT (WF_DEBUG_IO, "bad read for byte "
396 "%d of 0x%x [%s].\n",
397 i, cmd, wfcmd->action);
398 return 1;
399 }
400
401 /* Now handle errors. Lots of special cases here */
402
403 if (c == 0xff) {
404 if ((c = wavefront_read (dev)) == -1) {
405 DPRINT (WF_DEBUG_IO, "bad read for "
406 "error byte at "
407 "read byte %d "
408 "of 0x%x [%s].\n",
409 i, cmd,
410 wfcmd->action);
411 return 1;
412 }
413
414 /* Can you believe this madness ? */
415
416 if (c == 1 &&
417 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
418 rbuf[0] = WF_ST_EMPTY;
419 return (0);
420
421 } else if (c == 3 &&
422 wfcmd->cmd == WFC_UPLOAD_PATCH) {
423
424 return 3;
425
426 } else if (c == 1 &&
427 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
428
429 return 1;
430
431 } else {
432
433 DPRINT (WF_DEBUG_IO, "error %d (%s) "
434 "during "
435 "read for byte "
436 "%d of 0x%x "
437 "[%s].\n",
438 c,
439 wavefront_errorstr (c),
440 i, cmd,
441 wfcmd->action);
442 return 1;
443
444 }
445
446 } else {
447 rbuf[i] = c;
448 }
449
450 DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
451 }
452 }
453
454 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
455
456 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
457
458 /* Some commands need an ACK, but return zero instead
459 of the standard value.
460 */
461
462 if ((ack = wavefront_read (dev)) == 0) {
463 ack = WF_ACK;
464 }
465
466 if (ack != WF_ACK) {
467 if (ack == -1) {
468 DPRINT (WF_DEBUG_IO, "cannot read ack for "
469 "0x%x [%s].\n",
470 cmd, wfcmd->action);
471 return 1;
472
473 } else {
474 int err = -1; /* something unknown */
475
476 if (ack == 0xff) { /* explicit error */
477
478 if ((err = wavefront_read (dev)) == -1) {
479 DPRINT (WF_DEBUG_DATA,
480 "cannot read err "
481 "for 0x%x [%s].\n",
482 cmd, wfcmd->action);
483 }
484 }
485
486 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
487 "failed (0x%x, 0x%x, %s)\n",
488 cmd, wfcmd->action, ack, err,
489 wavefront_errorstr (err));
490
491 return -err;
492 }
493 }
494
495 DPRINT (WF_DEBUG_DATA, "ack received "
496 "for 0x%x [%s]\n",
497 cmd, wfcmd->action);
498 } else {
499
500 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
501 "ACK (%d,%d,%d)\n",
502 cmd, wfcmd->action, wfcmd->read_cnt,
503 wfcmd->write_cnt, wfcmd->need_ack);
504 }
505
506 return 0;
507
508 }
509 \f
510 /***********************************************************************
511 WaveFront data munging
512
513 Things here are weird. All data written to the board cannot
514 have its most significant bit set. Any data item with values
515 potentially > 0x7F (127) must be split across multiple bytes.
516
517 Sometimes, we need to munge numeric values that are represented on
518 the x86 side as 8-32 bit values. Sometimes, we need to munge data
519 that is represented on the x86 side as an array of bytes. The most
520 efficient approach to handling both cases seems to be to use 2
521 different functions for munging and 2 for de-munging. This avoids
522 weird casting and worrying about bit-level offsets.
523
524 **********************************************************************/
525
526 static unsigned char *
527 munge_int32 (unsigned int src,
528 unsigned char *dst,
529 unsigned int dst_size)
530 {
531 unsigned int i;
532
533 for (i = 0; i < dst_size; i++) {
534 *dst = src & 0x7F; /* Mask high bit of LSB */
535 src = src >> 7; /* Rotate Right 7 bits */
536 /* Note: we leave the upper bits in place */
537
538 dst++;
539 };
540 return dst;
541 };
542
543 static int
544 demunge_int32 (unsigned char* src, int src_size)
545
546 {
547 int i;
548 int outval = 0;
549
550 for (i = src_size - 1; i >= 0; i--) {
551 outval=(outval<<7)+src[i];
552 }
553
554 return outval;
555 };
556
557 static
558 unsigned char *
559 munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
560
561 {
562 unsigned int i;
563 unsigned int last = dst_size / 2;
564
565 for (i = 0; i < last; i++) {
566 *dst++ = src[i] & 0x7f;
567 *dst++ = src[i] >> 7;
568 }
569 return dst;
570 }
571
572 static
573 unsigned char *
574 demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
575
576 {
577 int i;
578 unsigned char *end = src + src_bytes;
579
580 end = src + src_bytes;
581
582 /* NOTE: src and dst *CAN* point to the same address */
583
584 for (i = 0; src != end; i++) {
585 dst[i] = *src++;
586 dst[i] |= (*src++)<<7;
587 }
588
589 return dst;
590 }
591 \f
592 /***********************************************************************
593 WaveFront: sample, patch and program management.
594 ***********************************************************************/
595
596 static int
597 wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
598
599 {
600 unsigned char wbuf[2];
601 int x;
602
603 wbuf[0] = sample_num & 0x7f;
604 wbuf[1] = sample_num >> 7;
605
606 if ((x = snd_wavefront_cmd (dev, WFC_DELETE_SAMPLE, NULL, wbuf)) == 0) {
607 dev->sample_status[sample_num] = WF_ST_EMPTY;
608 }
609
610 return x;
611 }
612
613 static int
614 wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
615
616 {
617 int i;
618 unsigned char rbuf[32], wbuf[32];
619 unsigned int sc_real, sc_alias, sc_multi;
620
621 /* check sample status */
622
623 if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
624 snd_printk ("cannot request sample count.\n");
625 return -1;
626 }
627
628 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
629
630 for (i = 0; i < WF_MAX_SAMPLE; i++) {
631
632 wbuf[0] = i & 0x7f;
633 wbuf[1] = i >> 7;
634
635 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
636 snd_printk(KERN_WARNING "cannot identify sample "
637 "type of slot %d\n", i);
638 dev->sample_status[i] = WF_ST_EMPTY;
639 continue;
640 }
641
642 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
643
644 if (assume_rom) {
645 dev->sample_status[i] |= WF_SLOT_ROM;
646 }
647
648 switch (rbuf[0] & WF_ST_MASK) {
649 case WF_ST_SAMPLE:
650 sc_real++;
651 break;
652 case WF_ST_MULTISAMPLE:
653 sc_multi++;
654 break;
655 case WF_ST_ALIAS:
656 sc_alias++;
657 break;
658 case WF_ST_EMPTY:
659 break;
660
661 default:
662 snd_printk ("unknown sample type for "
663 "slot %d (0x%x)\n",
664 i, rbuf[0]);
665 }
666
667 if (rbuf[0] != WF_ST_EMPTY) {
668 dev->samples_used++;
669 }
670 }
671
672 snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
673 "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
674 WF_MAX_SAMPLE - dev->samples_used);
675
676
677 return (0);
678
679 }
680
681 static int
682 wavefront_get_patch_status (snd_wavefront_t *dev)
683
684 {
685 unsigned char patchbuf[WF_PATCH_BYTES];
686 unsigned char patchnum[2];
687 wavefront_patch *p;
688 int i, x, cnt, cnt2;
689
690 for (i = 0; i < WF_MAX_PATCH; i++) {
691 patchnum[0] = i & 0x7f;
692 patchnum[1] = i >> 7;
693
694 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PATCH, patchbuf,
695 patchnum)) == 0) {
696
697 dev->patch_status[i] |= WF_SLOT_FILLED;
698 p = (wavefront_patch *) patchbuf;
699 dev->sample_status
700 [p->sample_number|(p->sample_msb<<7)] |=
701 WF_SLOT_USED;
702
703 } else if (x == 3) { /* Bad patch number */
704 dev->patch_status[i] = 0;
705 } else {
706 snd_printk ("upload patch "
707 "error 0x%x\n", x);
708 dev->patch_status[i] = 0;
709 return 1;
710 }
711 }
712
713 /* program status has already filled in slot_used bits */
714
715 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
716 if (dev->patch_status[i] & WF_SLOT_FILLED) {
717 cnt++;
718 }
719 if (dev->patch_status[i] & WF_SLOT_USED) {
720 cnt2++;
721 }
722
723 }
724 snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
725
726 return (0);
727 }
728
729 static int
730 wavefront_get_program_status (snd_wavefront_t *dev)
731
732 {
733 unsigned char progbuf[WF_PROGRAM_BYTES];
734 wavefront_program prog;
735 unsigned char prognum;
736 int i, x, l, cnt;
737
738 for (i = 0; i < WF_MAX_PROGRAM; i++) {
739 prognum = i;
740
741 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PROGRAM, progbuf,
742 &prognum)) == 0) {
743
744 dev->prog_status[i] |= WF_SLOT_USED;
745
746 demunge_buf (progbuf, (unsigned char *) &prog,
747 WF_PROGRAM_BYTES);
748
749 for (l = 0; l < WF_NUM_LAYERS; l++) {
750 if (prog.layer[l].mute) {
751 dev->patch_status
752 [prog.layer[l].patch_number] |=
753 WF_SLOT_USED;
754 }
755 }
756 } else if (x == 1) { /* Bad program number */
757 dev->prog_status[i] = 0;
758 } else {
759 snd_printk ("upload program "
760 "error 0x%x\n", x);
761 dev->prog_status[i] = 0;
762 }
763 }
764
765 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
766 if (dev->prog_status[i]) {
767 cnt++;
768 }
769 }
770
771 snd_printk ("%d programs slots in use\n", cnt);
772
773 return (0);
774 }
775
776 static int
777 wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
778
779 {
780 unsigned char buf[WF_PATCH_BYTES+2];
781 unsigned char *bptr;
782
783 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
784 header->number);
785
786 dev->patch_status[header->number] |= WF_SLOT_FILLED;
787
788 bptr = buf;
789 bptr = munge_int32 (header->number, buf, 2);
790 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
791
792 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
793 snd_printk ("download patch failed\n");
794 return -(EIO);
795 }
796
797 return (0);
798 }
799
800 static int
801 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
802
803 {
804 unsigned char buf[WF_PROGRAM_BYTES+1];
805 int i;
806
807 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
808 header->number);
809
810 dev->prog_status[header->number] = WF_SLOT_USED;
811
812
813 for (i = 0; i < WF_NUM_LAYERS; i++) {
814 if (header->hdr.pr.layer[i].mute) {
815 dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
816 WF_SLOT_USED;
817
818 }
819 }
820
821 buf[0] = header->number;
822 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
823
824 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
825 snd_printk ("download patch failed\n");
826 return -(EIO);
827 }
828
829 return (0);
830 }
831
832 static int
833 wavefront_freemem (snd_wavefront_t *dev)
834
835 {
836 char rbuf[8];
837
838 if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
839 snd_printk ("can't get memory stats.\n");
840 return -1;
841 } else {
842 return demunge_int32 (rbuf, 4);
843 }
844 }
845
846 static int
847 wavefront_send_sample (snd_wavefront_t *dev,
848 wavefront_patch_info *header,
849 u16 __user *dataptr,
850 int data_is_unsigned)
851
852 {
853 /* samples are downloaded via a 16-bit wide i/o port
854 (you could think of it as 2 adjacent 8-bit wide ports
855 but its less efficient that way). therefore, all
856 the blocksizes and so forth listed in the documentation,
857 and used conventionally to refer to sample sizes,
858 which are given in 8-bit units (bytes), need to be
859 divided by 2.
860 */
861
862 u16 sample_short = 0;
863 u32 length;
864 u16 __user *data_end = NULL;
865 unsigned int i;
866 const unsigned int max_blksize = 4096/2;
867 unsigned int written;
868 unsigned int blocksize;
869 int dma_ack;
870 int blocknum;
871 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
872 unsigned char *shptr;
873 int skip = 0;
874 int initial_skip = 0;
875
876 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
877 "type %d, %d bytes from 0x%lx\n",
878 header->size ? "" : "header ",
879 header->number, header->subkey,
880 header->size,
881 (unsigned long) header->dataptr);
882
883 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
884 int x;
885
886 if ((x = wavefront_find_free_sample (dev)) < 0) {
887 return -ENOMEM;
888 }
889 snd_printk ("unspecified sample => %d\n", x);
890 header->number = x;
891 }
892
893 if (header->size) {
894
895
896 if (dev->rom_samples_rdonly) {
897 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
898 snd_printk ("sample slot %d "
899 "write protected\n",
900 header->number);
901 return -EACCES;
902 }
903 }
904
905 wavefront_delete_sample (dev, header->number);
906 }
907
908 if (header->size) {
909 dev->freemem = wavefront_freemem (dev);
910
911 if (dev->freemem < (int)header->size) {
912 snd_printk ("insufficient memory to "
913 "load %d byte sample.\n",
914 header->size);
915 return -ENOMEM;
916 }
917
918 }
919
920 skip = WF_GET_CHANNEL(&header->hdr.s);
921
922 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
923 snd_printk ("channel selection only "
924 "possible on 16-bit samples");
925 return -(EINVAL);
926 }
927
928 switch (skip) {
929 case 0:
930 initial_skip = 0;
931 skip = 1;
932 break;
933 case 1:
934 initial_skip = 0;
935 skip = 2;
936 break;
937 case 2:
938 initial_skip = 1;
939 skip = 2;
940 break;
941 case 3:
942 initial_skip = 2;
943 skip = 3;
944 break;
945 case 4:
946 initial_skip = 3;
947 skip = 4;
948 break;
949 case 5:
950 initial_skip = 4;
951 skip = 5;
952 break;
953 case 6:
954 initial_skip = 5;
955 skip = 6;
956 break;
957 }
958
959 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
960 "initial skip = %d, skip = %d\n",
961 WF_GET_CHANNEL (&header->hdr.s),
962 initial_skip, skip);
963
964 /* Be safe, and zero the "Unused" bits ... */
965
966 WF_SET_CHANNEL(&header->hdr.s, 0);
967
968 /* adjust size for 16 bit samples by dividing by two. We always
969 send 16 bits per write, even for 8 bit samples, so the length
970 is always half the size of the sample data in bytes.
971 */
972
973 length = header->size / 2;
974
975 /* the data we're sent has not been munged, and in fact, the
976 header we have to send isn't just a munged copy either.
977 so, build the sample header right here.
978 */
979
980 shptr = &sample_hdr[0];
981
982 shptr = munge_int32 (header->number, shptr, 2);
983
984 if (header->size) {
985 shptr = munge_int32 (length, shptr, 4);
986 }
987
988 /* Yes, a 4 byte result doesn't contain all of the offset bits,
989 but the offset only uses 24 bits.
990 */
991
992 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
993 shptr, 4);
994 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
995 shptr, 4);
996 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
997 shptr, 4);
998 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
999 shptr, 4);
1000
1001 /* This one is truly weird. What kind of weirdo decided that in
1002 a system dominated by 16 and 32 bit integers, they would use
1003 a just 12 bits ?
1004 */
1005
1006 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1007
1008 /* Why is this nybblified, when the MSB is *always* zero ?
1009 Anyway, we can't take address of bitfield, so make a
1010 good-faith guess at where it starts.
1011 */
1012
1013 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1014 shptr, 2);
1015
1016 if (snd_wavefront_cmd (dev,
1017 header->size ?
1018 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1019 NULL, sample_hdr)) {
1020 snd_printk ("sample %sdownload refused.\n",
1021 header->size ? "" : "header ");
1022 return -(EIO);
1023 }
1024
1025 if (header->size == 0) {
1026 goto sent; /* Sorry. Just had to have one somewhere */
1027 }
1028
1029 data_end = dataptr + length;
1030
1031 /* Do any initial skip over an unused channel's data */
1032
1033 dataptr += initial_skip;
1034
1035 for (written = 0, blocknum = 0;
1036 written < length; written += max_blksize, blocknum++) {
1037
1038 if ((length - written) > max_blksize) {
1039 blocksize = max_blksize;
1040 } else {
1041 /* round to nearest 16-byte value */
1042 blocksize = ALIGN(length - written, 8);
1043 }
1044
1045 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1046 snd_printk ("download block "
1047 "request refused.\n");
1048 return -(EIO);
1049 }
1050
1051 for (i = 0; i < blocksize; i++) {
1052
1053 if (dataptr < data_end) {
1054
1055 __get_user (sample_short, dataptr);
1056 dataptr += skip;
1057
1058 if (data_is_unsigned) { /* GUS ? */
1059
1060 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1061
1062 /* 8 bit sample
1063 resolution, sign
1064 extend both bytes.
1065 */
1066
1067 ((unsigned char*)
1068 &sample_short)[0] += 0x7f;
1069 ((unsigned char*)
1070 &sample_short)[1] += 0x7f;
1071
1072 } else {
1073
1074 /* 16 bit sample
1075 resolution, sign
1076 extend the MSB.
1077 */
1078
1079 sample_short += 0x7fff;
1080 }
1081 }
1082
1083 } else {
1084
1085 /* In padding section of final block:
1086
1087 Don't fetch unsupplied data from
1088 user space, just continue with
1089 whatever the final value was.
1090 */
1091 }
1092
1093 if (i < blocksize - 1) {
1094 outw (sample_short, dev->block_port);
1095 } else {
1096 outw (sample_short, dev->last_block_port);
1097 }
1098 }
1099
1100 /* Get "DMA page acknowledge", even though its really
1101 nothing to do with DMA at all.
1102 */
1103
1104 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1105 if (dma_ack == -1) {
1106 snd_printk ("upload sample "
1107 "DMA ack timeout\n");
1108 return -(EIO);
1109 } else {
1110 snd_printk ("upload sample "
1111 "DMA ack error 0x%x\n",
1112 dma_ack);
1113 return -(EIO);
1114 }
1115 }
1116 }
1117
1118 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1119
1120 /* Note, label is here because sending the sample header shouldn't
1121 alter the sample_status info at all.
1122 */
1123
1124 sent:
1125 return (0);
1126 }
1127
1128 static int
1129 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1130
1131 {
1132 unsigned char alias_hdr[WF_ALIAS_BYTES];
1133
1134 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1135 "alias for %d\n",
1136 header->number,
1137 header->hdr.a.OriginalSample);
1138
1139 munge_int32 (header->number, &alias_hdr[0], 2);
1140 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1141 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1142 &alias_hdr[4], 4);
1143 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1144 &alias_hdr[8], 4);
1145 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1146 &alias_hdr[12], 4);
1147 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1148 &alias_hdr[16], 4);
1149 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1150 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1151
1152 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1153 snd_printk ("download alias failed.\n");
1154 return -(EIO);
1155 }
1156
1157 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1158
1159 return (0);
1160 }
1161
1162 static int
1163 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1164 {
1165 int i;
1166 int num_samples;
1167 unsigned char *msample_hdr;
1168
1169 msample_hdr = kmalloc(sizeof(WF_MSAMPLE_BYTES), GFP_KERNEL);
1170 if (! msample_hdr)
1171 return -ENOMEM;
1172
1173 munge_int32 (header->number, &msample_hdr[0], 2);
1174
1175 /* You'll recall at this point that the "number of samples" value
1176 in a wavefront_multisample struct is actually the log2 of the
1177 real number of samples.
1178 */
1179
1180 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1181 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1182
1183 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1184 header->number,
1185 header->hdr.ms.NumberOfSamples,
1186 num_samples);
1187
1188 for (i = 0; i < num_samples; i++) {
1189 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1190 i, header->hdr.ms.SampleNumber[i]);
1191 munge_int32 (header->hdr.ms.SampleNumber[i],
1192 &msample_hdr[3+(i*2)], 2);
1193 }
1194
1195 /* Need a hack here to pass in the number of bytes
1196 to be written to the synth. This is ugly, and perhaps
1197 one day, I'll fix it.
1198 */
1199
1200 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1201 (unsigned char *) (long) ((num_samples*2)+3),
1202 msample_hdr)) {
1203 snd_printk ("download of multisample failed.\n");
1204 kfree(msample_hdr);
1205 return -(EIO);
1206 }
1207
1208 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1209
1210 kfree(msample_hdr);
1211 return (0);
1212 }
1213
1214 static int
1215 wavefront_fetch_multisample (snd_wavefront_t *dev,
1216 wavefront_patch_info *header)
1217 {
1218 int i;
1219 unsigned char log_ns[1];
1220 unsigned char number[2];
1221 int num_samples;
1222
1223 munge_int32 (header->number, number, 2);
1224
1225 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1226 snd_printk ("upload multisample failed.\n");
1227 return -(EIO);
1228 }
1229
1230 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1231 header->number, log_ns[0]);
1232
1233 header->hdr.ms.NumberOfSamples = log_ns[0];
1234
1235 /* get the number of samples ... */
1236
1237 num_samples = (1 << log_ns[0]);
1238
1239 for (i = 0; i < num_samples; i++) {
1240 char d[2];
1241 int val;
1242
1243 if ((val = wavefront_read (dev)) == -1) {
1244 snd_printk ("upload multisample failed "
1245 "during sample loop.\n");
1246 return -(EIO);
1247 }
1248 d[0] = val;
1249
1250 if ((val = wavefront_read (dev)) == -1) {
1251 snd_printk ("upload multisample failed "
1252 "during sample loop.\n");
1253 return -(EIO);
1254 }
1255 d[1] = val;
1256
1257 header->hdr.ms.SampleNumber[i] =
1258 demunge_int32 ((unsigned char *) d, 2);
1259
1260 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1261 i, header->hdr.ms.SampleNumber[i]);
1262 }
1263
1264 return (0);
1265 }
1266
1267
1268 static int
1269 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1270
1271 {
1272 unsigned char drumbuf[WF_DRUM_BYTES];
1273 wavefront_drum *drum = &header->hdr.d;
1274 int i;
1275
1276 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1277 "note %d, patch = %d\n",
1278 header->number, drum->PatchNumber);
1279
1280 drumbuf[0] = header->number & 0x7f;
1281
1282 for (i = 0; i < 4; i++) {
1283 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1284 }
1285
1286 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1287 snd_printk ("download drum failed.\n");
1288 return -(EIO);
1289 }
1290
1291 return (0);
1292 }
1293
1294 static int
1295 wavefront_find_free_sample (snd_wavefront_t *dev)
1296
1297 {
1298 int i;
1299
1300 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1301 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1302 return i;
1303 }
1304 }
1305 snd_printk ("no free sample slots!\n");
1306 return -1;
1307 }
1308
1309
1310 static int
1311 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1312 {
1313 wavefront_patch_info *header;
1314 int err;
1315
1316 header = kmalloc(sizeof(*header), GFP_KERNEL);
1317 if (! header)
1318 return -ENOMEM;
1319
1320 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1321 sizeof(wavefront_any))) {
1322 snd_printk ("bad address for load patch.\n");
1323 err = -EFAULT;
1324 goto __error;
1325 }
1326
1327 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1328 "Sample type: %d "
1329 "Sample number: %d "
1330 "Sample size: %d\n",
1331 header->subkey,
1332 header->number,
1333 header->size);
1334
1335 switch (header->subkey) {
1336 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1337
1338 if (copy_from_user (&header->hdr.s, header->hdrptr,
1339 sizeof (wavefront_sample))) {
1340 err = -EFAULT;
1341 break;
1342 }
1343
1344 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1345 break;
1346
1347 case WF_ST_MULTISAMPLE:
1348
1349 if (copy_from_user (&header->hdr.s, header->hdrptr,
1350 sizeof (wavefront_multisample))) {
1351 err = -EFAULT;
1352 break;
1353 }
1354
1355 err = wavefront_send_multisample (dev, header);
1356 break;
1357
1358 case WF_ST_ALIAS:
1359
1360 if (copy_from_user (&header->hdr.a, header->hdrptr,
1361 sizeof (wavefront_alias))) {
1362 err = -EFAULT;
1363 break;
1364 }
1365
1366 err = wavefront_send_alias (dev, header);
1367 break;
1368
1369 case WF_ST_DRUM:
1370 if (copy_from_user (&header->hdr.d, header->hdrptr,
1371 sizeof (wavefront_drum))) {
1372 err = -EFAULT;
1373 break;
1374 }
1375
1376 err = wavefront_send_drum (dev, header);
1377 break;
1378
1379 case WF_ST_PATCH:
1380 if (copy_from_user (&header->hdr.p, header->hdrptr,
1381 sizeof (wavefront_patch))) {
1382 err = -EFAULT;
1383 break;
1384 }
1385
1386 err = wavefront_send_patch (dev, header);
1387 break;
1388
1389 case WF_ST_PROGRAM:
1390 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1391 sizeof (wavefront_program))) {
1392 err = -EFAULT;
1393 break;
1394 }
1395
1396 err = wavefront_send_program (dev, header);
1397 break;
1398
1399 default:
1400 snd_printk ("unknown patch type %d.\n",
1401 header->subkey);
1402 err = -EINVAL;
1403 break;
1404 }
1405
1406 __error:
1407 kfree(header);
1408 return err;
1409 }
1410 \f
1411 /***********************************************************************
1412 WaveFront: hardware-dependent interface
1413 ***********************************************************************/
1414
1415 static void
1416 process_sample_hdr (u8 *buf)
1417
1418 {
1419 wavefront_sample s;
1420 u8 *ptr;
1421
1422 ptr = buf;
1423
1424 /* The board doesn't send us an exact copy of a "wavefront_sample"
1425 in response to an Upload Sample Header command. Instead, we
1426 have to convert the data format back into our data structure,
1427 just as in the Download Sample command, where we have to do
1428 something very similar in the reverse direction.
1429 */
1430
1431 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1432 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1433 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1434 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1435 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1436
1437 s.SampleResolution = *ptr & 0x3;
1438 s.Loop = *ptr & 0x8;
1439 s.Bidirectional = *ptr & 0x10;
1440 s.Reverse = *ptr & 0x40;
1441
1442 /* Now copy it back to where it came from */
1443
1444 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1445 }
1446
1447 static int
1448 wavefront_synth_control (snd_wavefront_card_t *acard,
1449 wavefront_control *wc)
1450
1451 {
1452 snd_wavefront_t *dev = &acard->wavefront;
1453 unsigned char patchnumbuf[2];
1454 int i;
1455
1456 DPRINT (WF_DEBUG_CMD, "synth control with "
1457 "cmd 0x%x\n", wc->cmd);
1458
1459 /* Pre-handling of or for various commands */
1460
1461 switch (wc->cmd) {
1462
1463 case WFC_DISABLE_INTERRUPTS:
1464 snd_printk ("interrupts disabled.\n");
1465 outb (0x80|0x20, dev->control_port);
1466 dev->interrupts_are_midi = 1;
1467 return 0;
1468
1469 case WFC_ENABLE_INTERRUPTS:
1470 snd_printk ("interrupts enabled.\n");
1471 outb (0x80|0x40|0x20, dev->control_port);
1472 dev->interrupts_are_midi = 1;
1473 return 0;
1474
1475 case WFC_INTERRUPT_STATUS:
1476 wc->rbuf[0] = dev->interrupts_are_midi;
1477 return 0;
1478
1479 case WFC_ROMSAMPLES_RDONLY:
1480 dev->rom_samples_rdonly = wc->wbuf[0];
1481 wc->status = 0;
1482 return 0;
1483
1484 case WFC_IDENTIFY_SLOT_TYPE:
1485 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1486 if (i <0 || i >= WF_MAX_SAMPLE) {
1487 snd_printk ("invalid slot ID %d\n",
1488 i);
1489 wc->status = EINVAL;
1490 return -EINVAL;
1491 }
1492 wc->rbuf[0] = dev->sample_status[i];
1493 wc->status = 0;
1494 return 0;
1495
1496 case WFC_DEBUG_DRIVER:
1497 dev->debug = wc->wbuf[0];
1498 snd_printk ("debug = 0x%x\n", dev->debug);
1499 return 0;
1500
1501 case WFC_UPLOAD_PATCH:
1502 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1503 memcpy (wc->wbuf, patchnumbuf, 2);
1504 break;
1505
1506 case WFC_UPLOAD_MULTISAMPLE:
1507 /* multisamples have to be handled differently, and
1508 cannot be dealt with properly by snd_wavefront_cmd() alone.
1509 */
1510 wc->status = wavefront_fetch_multisample
1511 (dev, (wavefront_patch_info *) wc->rbuf);
1512 return 0;
1513
1514 case WFC_UPLOAD_SAMPLE_ALIAS:
1515 snd_printk ("support for sample alias upload "
1516 "being considered.\n");
1517 wc->status = EINVAL;
1518 return -EINVAL;
1519 }
1520
1521 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1522
1523 /* Post-handling of certain commands.
1524
1525 In particular, if the command was an upload, demunge the data
1526 so that the user-level doesn't have to think about it.
1527 */
1528
1529 if (wc->status == 0) {
1530 switch (wc->cmd) {
1531 /* intercept any freemem requests so that we know
1532 we are always current with the user-level view
1533 of things.
1534 */
1535
1536 case WFC_REPORT_FREE_MEMORY:
1537 dev->freemem = demunge_int32 (wc->rbuf, 4);
1538 break;
1539
1540 case WFC_UPLOAD_PATCH:
1541 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1542 break;
1543
1544 case WFC_UPLOAD_PROGRAM:
1545 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1546 break;
1547
1548 case WFC_UPLOAD_EDRUM_PROGRAM:
1549 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1550 break;
1551
1552 case WFC_UPLOAD_SAMPLE_HEADER:
1553 process_sample_hdr (wc->rbuf);
1554 break;
1555
1556 case WFC_UPLOAD_SAMPLE_ALIAS:
1557 snd_printk ("support for "
1558 "sample aliases still "
1559 "being considered.\n");
1560 break;
1561
1562 case WFC_VMIDI_OFF:
1563 snd_wavefront_midi_disable_virtual (acard);
1564 break;
1565
1566 case WFC_VMIDI_ON:
1567 snd_wavefront_midi_enable_virtual (acard);
1568 break;
1569 }
1570 }
1571
1572 return 0;
1573 }
1574
1575 int
1576 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1577
1578 {
1579 if (!try_module_get(hw->card->module))
1580 return -EFAULT;
1581 file->private_data = hw;
1582 return 0;
1583 }
1584
1585 int
1586 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1587
1588 {
1589 module_put(hw->card->module);
1590 return 0;
1591 }
1592
1593 int
1594 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1595 unsigned int cmd, unsigned long arg)
1596
1597 {
1598 struct snd_card *card;
1599 snd_wavefront_t *dev;
1600 snd_wavefront_card_t *acard;
1601 wavefront_control *wc;
1602 void __user *argp = (void __user *)arg;
1603 int err;
1604
1605 card = (struct snd_card *) hw->card;
1606
1607 if (snd_BUG_ON(!card))
1608 return -ENODEV;
1609 if (snd_BUG_ON(!card->private_data))
1610 return -ENODEV;
1611
1612 acard = card->private_data;
1613 dev = &acard->wavefront;
1614
1615 switch (cmd) {
1616 case WFCTL_LOAD_SPP:
1617 if (wavefront_load_patch (dev, argp) != 0) {
1618 return -EIO;
1619 }
1620 break;
1621
1622 case WFCTL_WFCMD:
1623 wc = memdup_user(argp, sizeof(*wc));
1624 if (IS_ERR(wc))
1625 return PTR_ERR(wc);
1626
1627 if (wavefront_synth_control (acard, wc) < 0)
1628 err = -EIO;
1629 else if (copy_to_user (argp, wc, sizeof (*wc)))
1630 err = -EFAULT;
1631 else
1632 err = 0;
1633 kfree(wc);
1634 return err;
1635
1636 default:
1637 return -EINVAL;
1638 }
1639
1640 return 0;
1641 }
1642
1643 \f
1644 /***********************************************************************/
1645 /* WaveFront: interface for card-level wavefront module */
1646 /***********************************************************************/
1647
1648 void
1649 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1650 {
1651 snd_wavefront_t *dev = &card->wavefront;
1652
1653 /*
1654 Some comments on interrupts. I attempted a version of this
1655 driver that used interrupts throughout the code instead of
1656 doing busy and/or sleep-waiting. Alas, it appears that once
1657 the Motorola firmware is downloaded, the card *never*
1658 generates an RX interrupt. These are successfully generated
1659 during firmware loading, and after that wavefront_status()
1660 reports that an interrupt is pending on the card from time
1661 to time, but it never seems to be delivered to this
1662 driver. Note also that wavefront_status() continues to
1663 report that RX interrupts are enabled, suggesting that I
1664 didn't goof up and disable them by mistake.
1665
1666 Thus, I stepped back to a prior version of
1667 wavefront_wait(), the only place where this really
1668 matters. Its sad, but I've looked through the code to check
1669 on things, and I really feel certain that the Motorola
1670 firmware prevents RX-ready interrupts.
1671 */
1672
1673 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1674 return;
1675 }
1676
1677 spin_lock(&dev->irq_lock);
1678 dev->irq_ok = 1;
1679 dev->irq_cnt++;
1680 spin_unlock(&dev->irq_lock);
1681 wake_up(&dev->interrupt_sleeper);
1682 }
1683
1684 /* STATUS REGISTER
1685
1686 0 Host Rx Interrupt Enable (1=Enabled)
1687 1 Host Rx Register Full (1=Full)
1688 2 Host Rx Interrupt Pending (1=Interrupt)
1689 3 Unused
1690 4 Host Tx Interrupt (1=Enabled)
1691 5 Host Tx Register empty (1=Empty)
1692 6 Host Tx Interrupt Pending (1=Interrupt)
1693 7 Unused
1694 */
1695
1696 static int __devinit
1697 snd_wavefront_interrupt_bits (int irq)
1698
1699 {
1700 int bits;
1701
1702 switch (irq) {
1703 case 9:
1704 bits = 0x00;
1705 break;
1706 case 5:
1707 bits = 0x08;
1708 break;
1709 case 12:
1710 bits = 0x10;
1711 break;
1712 case 15:
1713 bits = 0x18;
1714 break;
1715
1716 default:
1717 snd_printk ("invalid IRQ %d\n", irq);
1718 bits = -1;
1719 }
1720
1721 return bits;
1722 }
1723
1724 static void __devinit
1725 wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1726 int val, int port, unsigned long timeout)
1727
1728 {
1729 wait_queue_t wait;
1730
1731 init_waitqueue_entry(&wait, current);
1732 spin_lock_irq(&dev->irq_lock);
1733 add_wait_queue(&dev->interrupt_sleeper, &wait);
1734 dev->irq_ok = 0;
1735 outb (val,port);
1736 spin_unlock_irq(&dev->irq_lock);
1737 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1738 schedule_timeout_uninterruptible(1);
1739 barrier();
1740 }
1741 }
1742
1743 static int __devinit
1744 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1745
1746 {
1747 int bits;
1748 int hwv[2];
1749
1750 /* IRQ already checked */
1751
1752 bits = snd_wavefront_interrupt_bits (dev->irq);
1753
1754 /* try reset of port */
1755
1756 outb (0x0, dev->control_port);
1757
1758 /* At this point, the board is in reset, and the H/W initialization
1759 register is accessed at the same address as the data port.
1760
1761 Bit 7 - Enable IRQ Driver
1762 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1763 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1764
1765 Bit 6 - MIDI Interface Select
1766
1767 0 - Use the MIDI Input from the 26-pin WaveBlaster
1768 compatible header as the serial MIDI source
1769 1 - Use the MIDI Input from the 9-pin D connector as the
1770 serial MIDI source.
1771
1772 Bits 5:3 - IRQ Selection
1773 0 0 0 - IRQ 2/9
1774 0 0 1 - IRQ 5
1775 0 1 0 - IRQ 12
1776 0 1 1 - IRQ 15
1777 1 0 0 - Reserved
1778 1 0 1 - Reserved
1779 1 1 0 - Reserved
1780 1 1 1 - Reserved
1781
1782 Bits 2:1 - Reserved
1783 Bit 0 - Disable Boot ROM
1784 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1785 1 - memory accesses to 03FC30-03FFFFH are directed to external
1786 storage.
1787
1788 */
1789
1790 /* configure hardware: IRQ, enable interrupts,
1791 plus external 9-pin MIDI interface selected
1792 */
1793
1794 outb (0x80 | 0x40 | bits, dev->data_port);
1795
1796 /* CONTROL REGISTER
1797
1798 0 Host Rx Interrupt Enable (1=Enabled) 0x1
1799 1 Unused 0x2
1800 2 Unused 0x4
1801 3 Unused 0x8
1802 4 Host Tx Interrupt Enable 0x10
1803 5 Mute (0=Mute; 1=Play) 0x20
1804 6 Master Interrupt Enable (1=Enabled) 0x40
1805 7 Master Reset (0=Reset; 1=Run) 0x80
1806
1807 Take us out of reset, mute output, master + TX + RX interrupts on.
1808
1809 We'll get an interrupt presumably to tell us that the TX
1810 register is clear.
1811 */
1812
1813 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1814 dev->control_port,
1815 (reset_time*HZ)/100);
1816
1817 /* Note: data port is now the data port, not the h/w initialization
1818 port.
1819 */
1820
1821 if (!dev->irq_ok) {
1822 snd_printk ("intr not received after h/w un-reset.\n");
1823 goto gone_bad;
1824 }
1825
1826
1827 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1828 dev->data_port, ramcheck_time*HZ);
1829
1830 if (!dev->irq_ok) {
1831 snd_printk ("post-RAM-check interrupt not received.\n");
1832 goto gone_bad;
1833 }
1834
1835 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1836 snd_printk ("no response to HW version cmd.\n");
1837 goto gone_bad;
1838 }
1839
1840 if ((hwv[0] = wavefront_read (dev)) == -1) {
1841 snd_printk ("board not responding correctly.\n");
1842 goto gone_bad;
1843 }
1844
1845 if (hwv[0] == 0xFF) { /* NAK */
1846
1847 /* Board's RAM test failed. Try to read error code,
1848 and tell us about it either way.
1849 */
1850
1851 if ((hwv[0] = wavefront_read (dev)) == -1) {
1852 snd_printk ("on-board RAM test failed "
1853 "(bad error code).\n");
1854 } else {
1855 snd_printk ("on-board RAM test failed "
1856 "(error code: 0x%x).\n",
1857 hwv[0]);
1858 }
1859 goto gone_bad;
1860 }
1861
1862 /* We're OK, just get the next byte of the HW version response */
1863
1864 if ((hwv[1] = wavefront_read (dev)) == -1) {
1865 snd_printk ("incorrect h/w response.\n");
1866 goto gone_bad;
1867 }
1868
1869 snd_printk ("hardware version %d.%d\n",
1870 hwv[0], hwv[1]);
1871
1872 return 0;
1873
1874
1875 gone_bad:
1876 return (1);
1877 }
1878
1879 static int __devinit
1880 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1881
1882 {
1883 const unsigned char *buf;
1884 int len, err;
1885 int section_cnt_downloaded = 0;
1886 const struct firmware *firmware;
1887
1888 err = request_firmware(&firmware, path, dev->card->dev);
1889 if (err < 0) {
1890 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1891 return 1;
1892 }
1893
1894 len = 0;
1895 buf = firmware->data;
1896 for (;;) {
1897 int section_length = *(signed char *)buf;
1898 if (section_length == 0)
1899 break;
1900 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1901 snd_printk(KERN_ERR
1902 "invalid firmware section length %d\n",
1903 section_length);
1904 goto failure;
1905 }
1906 buf++;
1907 len++;
1908
1909 if (firmware->size < len + section_length) {
1910 snd_printk(KERN_ERR "firmware section read error.\n");
1911 goto failure;
1912 }
1913
1914 /* Send command */
1915 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1916 goto failure;
1917
1918 for (; section_length; section_length--) {
1919 if (wavefront_write(dev, *buf))
1920 goto failure;
1921 buf++;
1922 len++;
1923 }
1924
1925 /* get ACK */
1926 if (!wavefront_wait(dev, STAT_CAN_READ)) {
1927 snd_printk(KERN_ERR "time out for firmware ACK.\n");
1928 goto failure;
1929 }
1930 err = inb(dev->data_port);
1931 if (err != WF_ACK) {
1932 snd_printk(KERN_ERR
1933 "download of section #%d not "
1934 "acknowledged, ack = 0x%x\n",
1935 section_cnt_downloaded + 1, err);
1936 goto failure;
1937 }
1938
1939 section_cnt_downloaded++;
1940 }
1941
1942 release_firmware(firmware);
1943 return 0;
1944
1945 failure:
1946 release_firmware(firmware);
1947 snd_printk(KERN_ERR "firmware download failed!!!\n");
1948 return 1;
1949 }
1950
1951
1952 static int __devinit
1953 wavefront_do_reset (snd_wavefront_t *dev)
1954
1955 {
1956 char voices[1];
1957
1958 if (wavefront_reset_to_cleanliness (dev)) {
1959 snd_printk ("hw reset failed.\n");
1960 goto gone_bad;
1961 }
1962
1963 if (dev->israw) {
1964 if (wavefront_download_firmware (dev, ospath)) {
1965 goto gone_bad;
1966 }
1967
1968 dev->israw = 0;
1969
1970 /* Wait for the OS to get running. The protocol for
1971 this is non-obvious, and was determined by
1972 using port-IO tracing in DOSemu and some
1973 experimentation here.
1974
1975 Rather than using timed waits, use interrupts creatively.
1976 */
1977
1978 wavefront_should_cause_interrupt (dev, WFC_NOOP,
1979 dev->data_port,
1980 (osrun_time*HZ));
1981
1982 if (!dev->irq_ok) {
1983 snd_printk ("no post-OS interrupt.\n");
1984 goto gone_bad;
1985 }
1986
1987 /* Now, do it again ! */
1988
1989 wavefront_should_cause_interrupt (dev, WFC_NOOP,
1990 dev->data_port, (10*HZ));
1991
1992 if (!dev->irq_ok) {
1993 snd_printk ("no post-OS interrupt(2).\n");
1994 goto gone_bad;
1995 }
1996
1997 /* OK, no (RX/TX) interrupts any more, but leave mute
1998 in effect.
1999 */
2000
2001 outb (0x80|0x40, dev->control_port);
2002 }
2003
2004 /* SETUPSND.EXE asks for sample memory config here, but since i
2005 have no idea how to interpret the result, we'll forget
2006 about it.
2007 */
2008
2009 if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2010 goto gone_bad;
2011 }
2012
2013 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2014
2015 if (wavefront_write (dev, 0xf0) ||
2016 wavefront_write (dev, 1) ||
2017 (wavefront_read (dev) < 0)) {
2018 dev->debug = 0;
2019 snd_printk ("MPU emulation mode not set.\n");
2020 goto gone_bad;
2021 }
2022
2023 voices[0] = 32;
2024
2025 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2026 snd_printk ("cannot set number of voices to 32.\n");
2027 goto gone_bad;
2028 }
2029
2030
2031 return 0;
2032
2033 gone_bad:
2034 /* reset that sucker so that it doesn't bother us. */
2035
2036 outb (0x0, dev->control_port);
2037 dev->interrupts_are_midi = 0;
2038 return 1;
2039 }
2040
2041 int __devinit
2042 snd_wavefront_start (snd_wavefront_t *dev)
2043
2044 {
2045 int samples_are_from_rom;
2046
2047 /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2048 wavefront_reset_to_cleanliness() has already been called
2049 */
2050
2051 if (dev->israw) {
2052 samples_are_from_rom = 1;
2053 } else {
2054 samples_are_from_rom = 0;
2055 }
2056
2057 if (dev->israw || fx_raw) {
2058 if (wavefront_do_reset (dev)) {
2059 return -1;
2060 }
2061 }
2062 /* Check for FX device, present only on Tropez+ */
2063
2064 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2065
2066 if (dev->has_fx && fx_raw) {
2067 snd_wavefront_fx_start (dev);
2068 }
2069
2070 wavefront_get_sample_status (dev, samples_are_from_rom);
2071 wavefront_get_program_status (dev);
2072 wavefront_get_patch_status (dev);
2073
2074 /* Start normal operation: unreset, master interrupt enabled, no mute
2075 */
2076
2077 outb (0x80|0x40|0x20, dev->control_port);
2078
2079 return (0);
2080 }
2081
2082 int __devinit
2083 snd_wavefront_detect (snd_wavefront_card_t *card)
2084
2085 {
2086 unsigned char rbuf[4], wbuf[4];
2087 snd_wavefront_t *dev = &card->wavefront;
2088
2089 /* returns zero if a WaveFront card is successfully detected.
2090 negative otherwise.
2091 */
2092
2093 dev->israw = 0;
2094 dev->has_fx = 0;
2095 dev->debug = debug_default;
2096 dev->interrupts_are_midi = 0;
2097 dev->irq_cnt = 0;
2098 dev->rom_samples_rdonly = 1;
2099
2100 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2101
2102 dev->fw_version[0] = rbuf[0];
2103 dev->fw_version[1] = rbuf[1];
2104
2105 snd_printk ("firmware %d.%d already loaded.\n",
2106 rbuf[0], rbuf[1]);
2107
2108 /* check that a command actually works */
2109
2110 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2111 rbuf, wbuf) == 0) {
2112 dev->hw_version[0] = rbuf[0];
2113 dev->hw_version[1] = rbuf[1];
2114 } else {
2115 snd_printk ("not raw, but no "
2116 "hardware version!\n");
2117 return -1;
2118 }
2119
2120 if (!wf_raw) {
2121 return 0;
2122 } else {
2123 snd_printk ("reloading firmware as you requested.\n");
2124 dev->israw = 1;
2125 }
2126
2127 } else {
2128
2129 dev->israw = 1;
2130 snd_printk ("no response to firmware probe, assume raw.\n");
2131
2132 }
2133
2134 return 0;
2135 }
2136
2137 MODULE_FIRMWARE(DEFAULT_OSPATH);
Tomato firmware and modifications.