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