1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/io.h>
21#include <linux/interrupt.h>
22#include <linux/init.h>
23#include <linux/delay.h>
24#include <linux/time.h>
25#include <linux/wait.h>
26#include <linux/sched/signal.h>
27#include <linux/firmware.h>
28#include <linux/moduleparam.h>
29#include <linux/slab.h>
30#include <linux/module.h>
31#include <sound/core.h>
32#include <sound/snd_wavefront.h>
33#include <sound/initval.h>
34
35static int wf_raw = 0;
36
37
38
39
40
41static int fx_raw = 1;
42
43
44
45
46
47
48static int debug_default = 0;
49
50
51
52
53
54
55
56#define DEFAULT_OSPATH "wavefront.os"
57static char *ospath = DEFAULT_OSPATH;
58
59static int wait_usecs = 150;
60
61
62
63
64
65
66
67
68
69
70
71
72static int sleep_interval = 100;
73static int sleep_tries = 50;
74
75static int reset_time = 2;
76
77
78
79static int ramcheck_time = 20;
80
81
82
83static int osrun_time = 10;
84
85
86module_param(wf_raw, int, 0444);
87MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
88module_param(fx_raw, int, 0444);
89MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
90module_param(debug_default, int, 0444);
91MODULE_PARM_DESC(debug_default, "debug parameters for card initialization");
92module_param(wait_usecs, int, 0444);
93MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs");
94module_param(sleep_interval, int, 0444);
95MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply");
96module_param(sleep_tries, int, 0444);
97MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait");
98module_param(ospath, charp, 0444);
99MODULE_PARM_DESC(ospath, "pathname to processed ICS2115 OS firmware");
100module_param(reset_time, int, 0444);
101MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect");
102module_param(ramcheck_time, int, 0444);
103MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test");
104module_param(osrun_time, int, 0444);
105MODULE_PARM_DESC(osrun_time, "how many seconds to wait for the ICS2115 OS");
106
107
108
109
110
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
124
125#define LOGNAME "WaveFront: "
126
127
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
136static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
137static int wavefront_find_free_sample (snd_wavefront_t *);
138
139struct wavefront_command {
140 int cmd;
141 char *action;
142 unsigned int read_cnt;
143 unsigned int write_cnt;
144 int need_ack;
145};
146
147static 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
165static 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
193
194
195
196
197
198 { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
199
200
201
202
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
229static const char *
230wavefront_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
244static struct wavefront_command *
245wavefront_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
259static inline int
260wavefront_status (snd_wavefront_t *dev)
261
262{
263 return inb (dev->status_port);
264}
265
266static int
267wavefront_sleep (int limit)
268
269{
270 schedule_timeout_interruptible(limit);
271
272 return signal_pending(current);
273}
274
275static int
276wavefront_wait (snd_wavefront_t *dev, int mask)
277
278{
279 int i;
280
281
282
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
306static int
307wavefront_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
318static int
319wavefront_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
332int
333snd_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 wfcmd = wavefront_get_command(cmd);
343 if (!wfcmd) {
344 snd_printk ("command 0x%x not supported.\n",
345 cmd);
346 return 1;
347 }
348
349
350
351
352
353
354 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
355 wfcmd->write_cnt = (unsigned long) rbuf;
356 rbuf = NULL;
357 }
358
359 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
360 cmd, wfcmd->action, wfcmd->read_cnt,
361 wfcmd->write_cnt, wfcmd->need_ack);
362
363 if (wavefront_write (dev, cmd)) {
364 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
365 "0x%x [%s].\n",
366 cmd, wfcmd->action);
367 return 1;
368 }
369
370 if (wfcmd->write_cnt > 0) {
371 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
372 "for 0x%x\n",
373 wfcmd->write_cnt, cmd);
374
375 for (i = 0; i < wfcmd->write_cnt; i++) {
376 if (wavefront_write (dev, wbuf[i])) {
377 DPRINT (WF_DEBUG_IO, "bad write for byte "
378 "%d of 0x%x [%s].\n",
379 i, cmd, wfcmd->action);
380 return 1;
381 }
382
383 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
384 i, wbuf[i]);
385 }
386 }
387
388 if (wfcmd->read_cnt > 0) {
389 DPRINT (WF_DEBUG_DATA, "reading %d ints "
390 "for 0x%x\n",
391 wfcmd->read_cnt, cmd);
392
393 for (i = 0; i < wfcmd->read_cnt; i++) {
394
395 c = wavefront_read(dev);
396 if (c == -1) {
397 DPRINT (WF_DEBUG_IO, "bad read for byte "
398 "%d of 0x%x [%s].\n",
399 i, cmd, wfcmd->action);
400 return 1;
401 }
402
403
404
405 if (c == 0xff) {
406 c = wavefront_read(dev);
407 if (c == -1) {
408 DPRINT (WF_DEBUG_IO, "bad read for "
409 "error byte at "
410 "read byte %d "
411 "of 0x%x [%s].\n",
412 i, cmd,
413 wfcmd->action);
414 return 1;
415 }
416
417
418
419 if (c == 1 &&
420 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
421 rbuf[0] = WF_ST_EMPTY;
422 return (0);
423
424 } else if (c == 3 &&
425 wfcmd->cmd == WFC_UPLOAD_PATCH) {
426
427 return 3;
428
429 } else if (c == 1 &&
430 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
431
432 return 1;
433
434 } else {
435
436 DPRINT (WF_DEBUG_IO, "error %d (%s) "
437 "during "
438 "read for byte "
439 "%d of 0x%x "
440 "[%s].\n",
441 c,
442 wavefront_errorstr (c),
443 i, cmd,
444 wfcmd->action);
445 return 1;
446
447 }
448
449 } else {
450 rbuf[i] = c;
451 }
452
453 DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
454 }
455 }
456
457 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
458
459 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
460
461
462
463
464
465 ack = wavefront_read(dev);
466 if (ack == 0)
467 ack = WF_ACK;
468
469 if (ack != WF_ACK) {
470 if (ack == -1) {
471 DPRINT (WF_DEBUG_IO, "cannot read ack for "
472 "0x%x [%s].\n",
473 cmd, wfcmd->action);
474 return 1;
475
476 } else {
477 int err = -1;
478
479 if (ack == 0xff) {
480
481 err = wavefront_read(dev);
482 if (err == -1) {
483 DPRINT (WF_DEBUG_DATA,
484 "cannot read err "
485 "for 0x%x [%s].\n",
486 cmd, wfcmd->action);
487 }
488 }
489
490 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
491 "failed (0x%x, 0x%x, %s)\n",
492 cmd, wfcmd->action, ack, err,
493 wavefront_errorstr (err));
494
495 return -err;
496 }
497 }
498
499 DPRINT (WF_DEBUG_DATA, "ack received "
500 "for 0x%x [%s]\n",
501 cmd, wfcmd->action);
502 } else {
503
504 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
505 "ACK (%d,%d,%d)\n",
506 cmd, wfcmd->action, wfcmd->read_cnt,
507 wfcmd->write_cnt, wfcmd->need_ack);
508 }
509
510 return 0;
511
512}
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530static unsigned char *
531munge_int32 (unsigned int src,
532 unsigned char *dst,
533 unsigned int dst_size)
534{
535 unsigned int i;
536
537 for (i = 0; i < dst_size; i++) {
538 *dst = src & 0x7F;
539 src = src >> 7;
540
541
542 dst++;
543 }
544 return dst;
545};
546
547static int
548demunge_int32 (unsigned char* src, int src_size)
549
550{
551 int i;
552 int outval = 0;
553
554 for (i = src_size - 1; i >= 0; i--) {
555 outval=(outval<<7)+src[i];
556 }
557
558 return outval;
559};
560
561static
562unsigned char *
563munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
564
565{
566 unsigned int i;
567 unsigned int last = dst_size / 2;
568
569 for (i = 0; i < last; i++) {
570 *dst++ = src[i] & 0x7f;
571 *dst++ = src[i] >> 7;
572 }
573 return dst;
574}
575
576static
577unsigned char *
578demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
579
580{
581 int i;
582 unsigned char *end = src + src_bytes;
583
584 end = src + src_bytes;
585
586
587
588 for (i = 0; src != end; i++) {
589 dst[i] = *src++;
590 dst[i] |= (*src++)<<7;
591 }
592
593 return dst;
594}
595
596
597
598
599
600static int
601wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
602
603{
604 unsigned char wbuf[2];
605 int x;
606
607 wbuf[0] = sample_num & 0x7f;
608 wbuf[1] = sample_num >> 7;
609
610 x = snd_wavefront_cmd(dev, WFC_DELETE_SAMPLE, NULL, wbuf);
611 if (!x)
612 dev->sample_status[sample_num] = WF_ST_EMPTY;
613
614 return x;
615}
616
617static int
618wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
619
620{
621 int i;
622 unsigned char rbuf[32], wbuf[32];
623 unsigned int sc_real, sc_alias, sc_multi;
624
625
626
627 if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
628 snd_printk ("cannot request sample count.\n");
629 return -1;
630 }
631
632 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
633
634 for (i = 0; i < WF_MAX_SAMPLE; i++) {
635
636 wbuf[0] = i & 0x7f;
637 wbuf[1] = i >> 7;
638
639 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
640 snd_printk(KERN_WARNING "cannot identify sample "
641 "type of slot %d\n", i);
642 dev->sample_status[i] = WF_ST_EMPTY;
643 continue;
644 }
645
646 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
647
648 if (assume_rom) {
649 dev->sample_status[i] |= WF_SLOT_ROM;
650 }
651
652 switch (rbuf[0] & WF_ST_MASK) {
653 case WF_ST_SAMPLE:
654 sc_real++;
655 break;
656 case WF_ST_MULTISAMPLE:
657 sc_multi++;
658 break;
659 case WF_ST_ALIAS:
660 sc_alias++;
661 break;
662 case WF_ST_EMPTY:
663 break;
664
665 default:
666 snd_printk ("unknown sample type for "
667 "slot %d (0x%x)\n",
668 i, rbuf[0]);
669 }
670
671 if (rbuf[0] != WF_ST_EMPTY) {
672 dev->samples_used++;
673 }
674 }
675
676 snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
677 "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
678 WF_MAX_SAMPLE - dev->samples_used);
679
680
681 return (0);
682
683}
684
685static int
686wavefront_get_patch_status (snd_wavefront_t *dev)
687
688{
689 unsigned char patchbuf[WF_PATCH_BYTES];
690 unsigned char patchnum[2];
691 wavefront_patch *p;
692 int i, x, cnt, cnt2;
693
694 for (i = 0; i < WF_MAX_PATCH; i++) {
695 patchnum[0] = i & 0x7f;
696 patchnum[1] = i >> 7;
697
698 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PATCH, patchbuf,
699 patchnum);
700 if (x == 0) {
701
702 dev->patch_status[i] |= WF_SLOT_FILLED;
703 p = (wavefront_patch *) patchbuf;
704 dev->sample_status
705 [p->sample_number|(p->sample_msb<<7)] |=
706 WF_SLOT_USED;
707
708 } else if (x == 3) {
709 dev->patch_status[i] = 0;
710 } else {
711 snd_printk ("upload patch "
712 "error 0x%x\n", x);
713 dev->patch_status[i] = 0;
714 return 1;
715 }
716 }
717
718
719
720 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
721 if (dev->patch_status[i] & WF_SLOT_FILLED) {
722 cnt++;
723 }
724 if (dev->patch_status[i] & WF_SLOT_USED) {
725 cnt2++;
726 }
727
728 }
729 snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
730
731 return (0);
732}
733
734static int
735wavefront_get_program_status (snd_wavefront_t *dev)
736
737{
738 unsigned char progbuf[WF_PROGRAM_BYTES];
739 wavefront_program prog;
740 unsigned char prognum;
741 int i, x, l, cnt;
742
743 for (i = 0; i < WF_MAX_PROGRAM; i++) {
744 prognum = i;
745
746 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PROGRAM, progbuf,
747 &prognum);
748 if (x == 0) {
749
750 dev->prog_status[i] |= WF_SLOT_USED;
751
752 demunge_buf (progbuf, (unsigned char *) &prog,
753 WF_PROGRAM_BYTES);
754
755 for (l = 0; l < WF_NUM_LAYERS; l++) {
756 if (prog.layer[l].mute) {
757 dev->patch_status
758 [prog.layer[l].patch_number] |=
759 WF_SLOT_USED;
760 }
761 }
762 } else if (x == 1) {
763 dev->prog_status[i] = 0;
764 } else {
765 snd_printk ("upload program "
766 "error 0x%x\n", x);
767 dev->prog_status[i] = 0;
768 }
769 }
770
771 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
772 if (dev->prog_status[i]) {
773 cnt++;
774 }
775 }
776
777 snd_printk ("%d programs slots in use\n", cnt);
778
779 return (0);
780}
781
782static int
783wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
784
785{
786 unsigned char buf[WF_PATCH_BYTES+2];
787 unsigned char *bptr;
788
789 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
790 header->number);
791
792 if (header->number >= ARRAY_SIZE(dev->patch_status))
793 return -EINVAL;
794
795 dev->patch_status[header->number] |= WF_SLOT_FILLED;
796
797 bptr = munge_int32 (header->number, buf, 2);
798 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
799
800 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
801 snd_printk ("download patch failed\n");
802 return -EIO;
803 }
804
805 return (0);
806}
807
808static int
809wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
810
811{
812 unsigned char buf[WF_PROGRAM_BYTES+1];
813 int i;
814
815 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
816 header->number);
817
818 if (header->number >= ARRAY_SIZE(dev->prog_status))
819 return -EINVAL;
820
821 dev->prog_status[header->number] = WF_SLOT_USED;
822
823
824
825
826
827 for (i = 0; i < WF_NUM_LAYERS; i++) {
828 if (header->hdr.pr.layer[i].mute) {
829 dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
830 WF_SLOT_USED;
831
832
833
834
835 }
836 }
837
838 buf[0] = header->number;
839 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
840
841 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
842 snd_printk ("download patch failed\n");
843 return -EIO;
844 }
845
846 return (0);
847}
848
849static int
850wavefront_freemem (snd_wavefront_t *dev)
851
852{
853 char rbuf[8];
854
855 if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
856 snd_printk ("can't get memory stats.\n");
857 return -1;
858 } else {
859 return demunge_int32 (rbuf, 4);
860 }
861}
862
863static int
864wavefront_send_sample (snd_wavefront_t *dev,
865 wavefront_patch_info *header,
866 u16 __user *dataptr,
867 int data_is_unsigned)
868
869{
870
871
872
873
874
875
876
877
878
879 u16 sample_short = 0;
880 u32 length;
881 u16 __user *data_end = NULL;
882 unsigned int i;
883 const unsigned int max_blksize = 4096/2;
884 unsigned int written;
885 unsigned int blocksize;
886 int dma_ack;
887 int blocknum;
888 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
889 unsigned char *shptr;
890 int skip = 0;
891 int initial_skip = 0;
892
893 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
894 "type %d, %d bytes from 0x%lx\n",
895 header->size ? "" : "header ",
896 header->number, header->subkey,
897 header->size,
898 (unsigned long) header->dataptr);
899
900 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
901 int x;
902
903 x = wavefront_find_free_sample(dev);
904 if (x < 0)
905 return -ENOMEM;
906 snd_printk ("unspecified sample => %d\n", x);
907 header->number = x;
908 }
909
910 if (header->number >= WF_MAX_SAMPLE)
911 return -EINVAL;
912
913 if (header->size) {
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938 if (dev->rom_samples_rdonly) {
939 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
940 snd_printk ("sample slot %d "
941 "write protected\n",
942 header->number);
943 return -EACCES;
944 }
945 }
946
947 wavefront_delete_sample (dev, header->number);
948 }
949
950 if (header->size) {
951 dev->freemem = wavefront_freemem (dev);
952
953 if (dev->freemem < (int)header->size) {
954 snd_printk ("insufficient memory to "
955 "load %d byte sample.\n",
956 header->size);
957 return -ENOMEM;
958 }
959
960 }
961
962 skip = WF_GET_CHANNEL(&header->hdr.s);
963
964 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
965 snd_printk ("channel selection only "
966 "possible on 16-bit samples");
967 return -EINVAL;
968 }
969
970 switch (skip) {
971 case 0:
972 initial_skip = 0;
973 skip = 1;
974 break;
975 case 1:
976 initial_skip = 0;
977 skip = 2;
978 break;
979 case 2:
980 initial_skip = 1;
981 skip = 2;
982 break;
983 case 3:
984 initial_skip = 2;
985 skip = 3;
986 break;
987 case 4:
988 initial_skip = 3;
989 skip = 4;
990 break;
991 case 5:
992 initial_skip = 4;
993 skip = 5;
994 break;
995 case 6:
996 initial_skip = 5;
997 skip = 6;
998 break;
999 }
1000
1001 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
1002 "initial skip = %d, skip = %d\n",
1003 WF_GET_CHANNEL (&header->hdr.s),
1004 initial_skip, skip);
1005
1006
1007
1008 WF_SET_CHANNEL(&header->hdr.s, 0);
1009
1010
1011
1012
1013
1014
1015 length = header->size / 2;
1016
1017
1018
1019
1020
1021
1022 shptr = &sample_hdr[0];
1023
1024 shptr = munge_int32 (header->number, shptr, 2);
1025
1026 if (header->size) {
1027 shptr = munge_int32 (length, shptr, 4);
1028 }
1029
1030
1031
1032
1033
1034 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1035 shptr, 4);
1036 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1037 shptr, 4);
1038 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1039 shptr, 4);
1040 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1041 shptr, 4);
1042
1043
1044
1045
1046
1047
1048 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1049
1050
1051
1052
1053
1054
1055 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1056 shptr, 2);
1057
1058 if (snd_wavefront_cmd (dev,
1059 header->size ?
1060 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1061 NULL, sample_hdr)) {
1062 snd_printk ("sample %sdownload refused.\n",
1063 header->size ? "" : "header ");
1064 return -EIO;
1065 }
1066
1067 if (header->size == 0) {
1068 goto sent;
1069 }
1070
1071 data_end = dataptr + length;
1072
1073
1074
1075 dataptr += initial_skip;
1076
1077 for (written = 0, blocknum = 0;
1078 written < length; written += max_blksize, blocknum++) {
1079
1080 if ((length - written) > max_blksize) {
1081 blocksize = max_blksize;
1082 } else {
1083
1084 blocksize = ALIGN(length - written, 8);
1085 }
1086
1087 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1088 snd_printk ("download block "
1089 "request refused.\n");
1090 return -EIO;
1091 }
1092
1093 for (i = 0; i < blocksize; i++) {
1094
1095 if (dataptr < data_end) {
1096
1097 if (get_user(sample_short, dataptr))
1098 return -EFAULT;
1099 dataptr += skip;
1100
1101 if (data_is_unsigned) {
1102
1103 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1104
1105
1106
1107
1108
1109
1110 ((unsigned char*)
1111 &sample_short)[0] += 0x7f;
1112 ((unsigned char*)
1113 &sample_short)[1] += 0x7f;
1114
1115 } else {
1116
1117
1118
1119
1120
1121
1122 sample_short += 0x7fff;
1123 }
1124 }
1125
1126 } else {
1127
1128
1129
1130
1131
1132
1133
1134 }
1135
1136 if (i < blocksize - 1) {
1137 outw (sample_short, dev->block_port);
1138 } else {
1139 outw (sample_short, dev->last_block_port);
1140 }
1141 }
1142
1143
1144
1145
1146
1147 dma_ack = wavefront_read(dev);
1148 if (dma_ack != WF_DMA_ACK) {
1149 if (dma_ack == -1) {
1150 snd_printk ("upload sample "
1151 "DMA ack timeout\n");
1152 return -EIO;
1153 } else {
1154 snd_printk ("upload sample "
1155 "DMA ack error 0x%x\n",
1156 dma_ack);
1157 return -EIO;
1158 }
1159 }
1160 }
1161
1162 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1163
1164
1165
1166
1167
1168 sent:
1169 return (0);
1170}
1171
1172static int
1173wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1174
1175{
1176 unsigned char alias_hdr[WF_ALIAS_BYTES];
1177
1178 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1179 "alias for %d\n",
1180 header->number,
1181 header->hdr.a.OriginalSample);
1182
1183 if (header->number >= WF_MAX_SAMPLE)
1184 return -EINVAL;
1185
1186 munge_int32 (header->number, &alias_hdr[0], 2);
1187 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1188 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1189 &alias_hdr[4], 4);
1190 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1191 &alias_hdr[8], 4);
1192 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1193 &alias_hdr[12], 4);
1194 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1195 &alias_hdr[16], 4);
1196 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1197 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1198
1199 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1200 snd_printk ("download alias failed.\n");
1201 return -EIO;
1202 }
1203
1204 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1205
1206 return (0);
1207}
1208
1209static int
1210wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1211{
1212 int i;
1213 int num_samples;
1214 unsigned char *msample_hdr;
1215
1216 if (header->number >= WF_MAX_SAMPLE)
1217 return -EINVAL;
1218
1219 msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1220 if (! msample_hdr)
1221 return -ENOMEM;
1222
1223 munge_int32 (header->number, &msample_hdr[0], 2);
1224
1225
1226
1227
1228
1229
1230 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1231 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1232
1233 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1234 header->number,
1235 header->hdr.ms.NumberOfSamples,
1236 num_samples);
1237
1238 for (i = 0; i < num_samples; i++) {
1239 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1240 i, header->hdr.ms.SampleNumber[i]);
1241 munge_int32 (header->hdr.ms.SampleNumber[i],
1242 &msample_hdr[3+(i*2)], 2);
1243 }
1244
1245
1246
1247
1248
1249
1250 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1251 (unsigned char *) (long) ((num_samples*2)+3),
1252 msample_hdr)) {
1253 snd_printk ("download of multisample failed.\n");
1254 kfree(msample_hdr);
1255 return -EIO;
1256 }
1257
1258 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1259
1260 kfree(msample_hdr);
1261 return (0);
1262}
1263
1264static int
1265wavefront_fetch_multisample (snd_wavefront_t *dev,
1266 wavefront_patch_info *header)
1267{
1268 int i;
1269 unsigned char log_ns[1];
1270 unsigned char number[2];
1271 int num_samples;
1272
1273 munge_int32 (header->number, number, 2);
1274
1275 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1276 snd_printk ("upload multisample failed.\n");
1277 return -EIO;
1278 }
1279
1280 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1281 header->number, log_ns[0]);
1282
1283 header->hdr.ms.NumberOfSamples = log_ns[0];
1284
1285
1286
1287 num_samples = (1 << log_ns[0]);
1288
1289 for (i = 0; i < num_samples; i++) {
1290 char d[2];
1291 int val;
1292
1293 val = wavefront_read(dev);
1294 if (val == -1) {
1295 snd_printk ("upload multisample failed "
1296 "during sample loop.\n");
1297 return -EIO;
1298 }
1299 d[0] = val;
1300
1301 val = wavefront_read(dev);
1302 if (val == -1) {
1303 snd_printk ("upload multisample failed "
1304 "during sample loop.\n");
1305 return -EIO;
1306 }
1307 d[1] = val;
1308
1309 header->hdr.ms.SampleNumber[i] =
1310 demunge_int32 ((unsigned char *) d, 2);
1311
1312 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1313 i, header->hdr.ms.SampleNumber[i]);
1314 }
1315
1316 return (0);
1317}
1318
1319
1320static int
1321wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1322
1323{
1324 unsigned char drumbuf[WF_DRUM_BYTES];
1325 wavefront_drum *drum = &header->hdr.d;
1326 int i;
1327
1328 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1329 "note %d, patch = %d\n",
1330 header->number, drum->PatchNumber);
1331
1332 drumbuf[0] = header->number & 0x7f;
1333
1334 for (i = 0; i < 4; i++) {
1335 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1336 }
1337
1338 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1339 snd_printk ("download drum failed.\n");
1340 return -EIO;
1341 }
1342
1343 return (0);
1344}
1345
1346static int
1347wavefront_find_free_sample (snd_wavefront_t *dev)
1348
1349{
1350 int i;
1351
1352 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1353 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1354 return i;
1355 }
1356 }
1357 snd_printk ("no free sample slots!\n");
1358 return -1;
1359}
1360
1361#if 0
1362static int
1363wavefront_find_free_patch (snd_wavefront_t *dev)
1364
1365{
1366 int i;
1367
1368 for (i = 0; i < WF_MAX_PATCH; i++) {
1369 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1370 return i;
1371 }
1372 }
1373 snd_printk ("no free patch slots!\n");
1374 return -1;
1375}
1376#endif
1377
1378static int
1379wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1380{
1381 wavefront_patch_info *header;
1382 int err;
1383
1384 header = kmalloc(sizeof(*header), GFP_KERNEL);
1385 if (! header)
1386 return -ENOMEM;
1387
1388 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1389 sizeof(wavefront_any))) {
1390 snd_printk ("bad address for load patch.\n");
1391 err = -EFAULT;
1392 goto __error;
1393 }
1394
1395 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1396 "Sample type: %d "
1397 "Sample number: %d "
1398 "Sample size: %d\n",
1399 header->subkey,
1400 header->number,
1401 header->size);
1402
1403 switch (header->subkey) {
1404 case WF_ST_SAMPLE:
1405
1406 if (copy_from_user (&header->hdr.s, header->hdrptr,
1407 sizeof (wavefront_sample))) {
1408 err = -EFAULT;
1409 break;
1410 }
1411
1412 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1413 break;
1414
1415 case WF_ST_MULTISAMPLE:
1416
1417 if (copy_from_user (&header->hdr.s, header->hdrptr,
1418 sizeof (wavefront_multisample))) {
1419 err = -EFAULT;
1420 break;
1421 }
1422
1423 err = wavefront_send_multisample (dev, header);
1424 break;
1425
1426 case WF_ST_ALIAS:
1427
1428 if (copy_from_user (&header->hdr.a, header->hdrptr,
1429 sizeof (wavefront_alias))) {
1430 err = -EFAULT;
1431 break;
1432 }
1433
1434 err = wavefront_send_alias (dev, header);
1435 break;
1436
1437 case WF_ST_DRUM:
1438 if (copy_from_user (&header->hdr.d, header->hdrptr,
1439 sizeof (wavefront_drum))) {
1440 err = -EFAULT;
1441 break;
1442 }
1443
1444 err = wavefront_send_drum (dev, header);
1445 break;
1446
1447 case WF_ST_PATCH:
1448 if (copy_from_user (&header->hdr.p, header->hdrptr,
1449 sizeof (wavefront_patch))) {
1450 err = -EFAULT;
1451 break;
1452 }
1453
1454 err = wavefront_send_patch (dev, header);
1455 break;
1456
1457 case WF_ST_PROGRAM:
1458 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1459 sizeof (wavefront_program))) {
1460 err = -EFAULT;
1461 break;
1462 }
1463
1464 err = wavefront_send_program (dev, header);
1465 break;
1466
1467 default:
1468 snd_printk ("unknown patch type %d.\n",
1469 header->subkey);
1470 err = -EINVAL;
1471 break;
1472 }
1473
1474 __error:
1475 kfree(header);
1476 return err;
1477}
1478
1479
1480
1481
1482
1483static void
1484process_sample_hdr (u8 *buf)
1485
1486{
1487 wavefront_sample s;
1488 u8 *ptr;
1489
1490 ptr = buf;
1491
1492
1493
1494
1495
1496
1497
1498
1499 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1500 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1501 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1502 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1503 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1504
1505 s.SampleResolution = *ptr & 0x3;
1506 s.Loop = *ptr & 0x8;
1507 s.Bidirectional = *ptr & 0x10;
1508 s.Reverse = *ptr & 0x40;
1509
1510
1511
1512 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1513}
1514
1515static int
1516wavefront_synth_control (snd_wavefront_card_t *acard,
1517 wavefront_control *wc)
1518
1519{
1520 snd_wavefront_t *dev = &acard->wavefront;
1521 unsigned char patchnumbuf[2];
1522 int i;
1523
1524 DPRINT (WF_DEBUG_CMD, "synth control with "
1525 "cmd 0x%x\n", wc->cmd);
1526
1527
1528
1529 switch (wc->cmd) {
1530
1531 case WFC_DISABLE_INTERRUPTS:
1532 snd_printk ("interrupts disabled.\n");
1533 outb (0x80|0x20, dev->control_port);
1534 dev->interrupts_are_midi = 1;
1535 return 0;
1536
1537 case WFC_ENABLE_INTERRUPTS:
1538 snd_printk ("interrupts enabled.\n");
1539 outb (0x80|0x40|0x20, dev->control_port);
1540 dev->interrupts_are_midi = 1;
1541 return 0;
1542
1543 case WFC_INTERRUPT_STATUS:
1544 wc->rbuf[0] = dev->interrupts_are_midi;
1545 return 0;
1546
1547 case WFC_ROMSAMPLES_RDONLY:
1548 dev->rom_samples_rdonly = wc->wbuf[0];
1549 wc->status = 0;
1550 return 0;
1551
1552 case WFC_IDENTIFY_SLOT_TYPE:
1553 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1554 if (i <0 || i >= WF_MAX_SAMPLE) {
1555 snd_printk ("invalid slot ID %d\n",
1556 i);
1557 wc->status = EINVAL;
1558 return -EINVAL;
1559 }
1560 wc->rbuf[0] = dev->sample_status[i];
1561 wc->status = 0;
1562 return 0;
1563
1564 case WFC_DEBUG_DRIVER:
1565 dev->debug = wc->wbuf[0];
1566 snd_printk ("debug = 0x%x\n", dev->debug);
1567 return 0;
1568
1569 case WFC_UPLOAD_PATCH:
1570 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1571 memcpy (wc->wbuf, patchnumbuf, 2);
1572 break;
1573
1574 case WFC_UPLOAD_MULTISAMPLE:
1575
1576
1577
1578 wc->status = wavefront_fetch_multisample
1579 (dev, (wavefront_patch_info *) wc->rbuf);
1580 return 0;
1581
1582 case WFC_UPLOAD_SAMPLE_ALIAS:
1583 snd_printk ("support for sample alias upload "
1584 "being considered.\n");
1585 wc->status = EINVAL;
1586 return -EINVAL;
1587 }
1588
1589 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1590
1591
1592
1593
1594
1595
1596
1597 if (wc->status == 0) {
1598 switch (wc->cmd) {
1599
1600
1601
1602
1603
1604 case WFC_REPORT_FREE_MEMORY:
1605 dev->freemem = demunge_int32 (wc->rbuf, 4);
1606 break;
1607
1608 case WFC_UPLOAD_PATCH:
1609 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1610 break;
1611
1612 case WFC_UPLOAD_PROGRAM:
1613 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1614 break;
1615
1616 case WFC_UPLOAD_EDRUM_PROGRAM:
1617 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1618 break;
1619
1620 case WFC_UPLOAD_SAMPLE_HEADER:
1621 process_sample_hdr (wc->rbuf);
1622 break;
1623
1624 case WFC_UPLOAD_SAMPLE_ALIAS:
1625 snd_printk ("support for "
1626 "sample aliases still "
1627 "being considered.\n");
1628 break;
1629
1630 case WFC_VMIDI_OFF:
1631 snd_wavefront_midi_disable_virtual (acard);
1632 break;
1633
1634 case WFC_VMIDI_ON:
1635 snd_wavefront_midi_enable_virtual (acard);
1636 break;
1637 }
1638 }
1639
1640 return 0;
1641}
1642
1643int
1644snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1645
1646{
1647 if (!try_module_get(hw->card->module))
1648 return -EFAULT;
1649 file->private_data = hw;
1650 return 0;
1651}
1652
1653int
1654snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1655
1656{
1657 module_put(hw->card->module);
1658 return 0;
1659}
1660
1661int
1662snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1663 unsigned int cmd, unsigned long arg)
1664
1665{
1666 struct snd_card *card;
1667 snd_wavefront_t *dev;
1668 snd_wavefront_card_t *acard;
1669 wavefront_control *wc;
1670 void __user *argp = (void __user *)arg;
1671 int err;
1672
1673 card = (struct snd_card *) hw->card;
1674
1675 if (snd_BUG_ON(!card))
1676 return -ENODEV;
1677 if (snd_BUG_ON(!card->private_data))
1678 return -ENODEV;
1679
1680 acard = card->private_data;
1681 dev = &acard->wavefront;
1682
1683 switch (cmd) {
1684 case WFCTL_LOAD_SPP:
1685 if (wavefront_load_patch (dev, argp) != 0) {
1686 return -EIO;
1687 }
1688 break;
1689
1690 case WFCTL_WFCMD:
1691 wc = memdup_user(argp, sizeof(*wc));
1692 if (IS_ERR(wc))
1693 return PTR_ERR(wc);
1694
1695 if (wavefront_synth_control (acard, wc) < 0)
1696 err = -EIO;
1697 else if (copy_to_user (argp, wc, sizeof (*wc)))
1698 err = -EFAULT;
1699 else
1700 err = 0;
1701 kfree(wc);
1702 return err;
1703
1704 default:
1705 return -EINVAL;
1706 }
1707
1708 return 0;
1709}
1710
1711
1712
1713
1714
1715
1716void
1717snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1718{
1719 snd_wavefront_t *dev = &card->wavefront;
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1742 return;
1743 }
1744
1745 spin_lock(&dev->irq_lock);
1746 dev->irq_ok = 1;
1747 dev->irq_cnt++;
1748 spin_unlock(&dev->irq_lock);
1749 wake_up(&dev->interrupt_sleeper);
1750}
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764static int
1765snd_wavefront_interrupt_bits (int irq)
1766
1767{
1768 int bits;
1769
1770 switch (irq) {
1771 case 9:
1772 bits = 0x00;
1773 break;
1774 case 5:
1775 bits = 0x08;
1776 break;
1777 case 12:
1778 bits = 0x10;
1779 break;
1780 case 15:
1781 bits = 0x18;
1782 break;
1783
1784 default:
1785 snd_printk ("invalid IRQ %d\n", irq);
1786 bits = -1;
1787 }
1788
1789 return bits;
1790}
1791
1792static void
1793wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1794 int val, int port, unsigned long timeout)
1795
1796{
1797 wait_queue_entry_t wait;
1798
1799 init_waitqueue_entry(&wait, current);
1800 spin_lock_irq(&dev->irq_lock);
1801 add_wait_queue(&dev->interrupt_sleeper, &wait);
1802 dev->irq_ok = 0;
1803 outb (val,port);
1804 spin_unlock_irq(&dev->irq_lock);
1805 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1806 schedule_timeout_uninterruptible(1);
1807 barrier();
1808 }
1809}
1810
1811static int
1812wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1813
1814{
1815 int bits;
1816 int hwv[2];
1817
1818
1819
1820 bits = snd_wavefront_interrupt_bits (dev->irq);
1821
1822
1823
1824 outb (0x0, dev->control_port);
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862 outb (0x80 | 0x40 | bits, dev->data_port);
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1882 dev->control_port,
1883 (reset_time*HZ)/100);
1884
1885
1886
1887
1888
1889 if (!dev->irq_ok) {
1890 snd_printk ("intr not received after h/w un-reset.\n");
1891 goto gone_bad;
1892 }
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1911 dev->data_port, ramcheck_time*HZ);
1912
1913 if (!dev->irq_ok) {
1914 snd_printk ("post-RAM-check interrupt not received.\n");
1915 goto gone_bad;
1916 }
1917
1918 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1919 snd_printk ("no response to HW version cmd.\n");
1920 goto gone_bad;
1921 }
1922
1923 hwv[0] = wavefront_read(dev);
1924 if (hwv[0] == -1) {
1925 snd_printk ("board not responding correctly.\n");
1926 goto gone_bad;
1927 }
1928
1929 if (hwv[0] == 0xFF) {
1930
1931
1932
1933
1934
1935 hwv[0] = wavefront_read(dev);
1936 if (hwv[0] == -1) {
1937 snd_printk ("on-board RAM test failed "
1938 "(bad error code).\n");
1939 } else {
1940 snd_printk ("on-board RAM test failed "
1941 "(error code: 0x%x).\n",
1942 hwv[0]);
1943 }
1944 goto gone_bad;
1945 }
1946
1947
1948
1949 hwv[1] = wavefront_read(dev);
1950 if (hwv[1] == -1) {
1951 snd_printk ("incorrect h/w response.\n");
1952 goto gone_bad;
1953 }
1954
1955 snd_printk ("hardware version %d.%d\n",
1956 hwv[0], hwv[1]);
1957
1958 return 0;
1959
1960
1961 gone_bad:
1962 return (1);
1963}
1964
1965static int
1966wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1967
1968{
1969 const unsigned char *buf;
1970 int len, err;
1971 int section_cnt_downloaded = 0;
1972 const struct firmware *firmware;
1973
1974 err = request_firmware(&firmware, path, dev->card->dev);
1975 if (err < 0) {
1976 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1977 return 1;
1978 }
1979
1980 len = 0;
1981 buf = firmware->data;
1982 for (;;) {
1983 int section_length = *(signed char *)buf;
1984 if (section_length == 0)
1985 break;
1986 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1987 snd_printk(KERN_ERR
1988 "invalid firmware section length %d\n",
1989 section_length);
1990 goto failure;
1991 }
1992 buf++;
1993 len++;
1994
1995 if (firmware->size < len + section_length) {
1996 snd_printk(KERN_ERR "firmware section read error.\n");
1997 goto failure;
1998 }
1999
2000
2001 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
2002 goto failure;
2003
2004 for (; section_length; section_length--) {
2005 if (wavefront_write(dev, *buf))
2006 goto failure;
2007 buf++;
2008 len++;
2009 }
2010
2011
2012 if (!wavefront_wait(dev, STAT_CAN_READ)) {
2013 snd_printk(KERN_ERR "time out for firmware ACK.\n");
2014 goto failure;
2015 }
2016 err = inb(dev->data_port);
2017 if (err != WF_ACK) {
2018 snd_printk(KERN_ERR
2019 "download of section #%d not "
2020 "acknowledged, ack = 0x%x\n",
2021 section_cnt_downloaded + 1, err);
2022 goto failure;
2023 }
2024
2025 section_cnt_downloaded++;
2026 }
2027
2028 release_firmware(firmware);
2029 return 0;
2030
2031 failure:
2032 release_firmware(firmware);
2033 snd_printk(KERN_ERR "firmware download failed!!!\n");
2034 return 1;
2035}
2036
2037
2038static int
2039wavefront_do_reset (snd_wavefront_t *dev)
2040
2041{
2042 char voices[1];
2043
2044 if (wavefront_reset_to_cleanliness (dev)) {
2045 snd_printk ("hw reset failed.\n");
2046 goto gone_bad;
2047 }
2048
2049 if (dev->israw) {
2050 if (wavefront_download_firmware (dev, ospath)) {
2051 goto gone_bad;
2052 }
2053
2054 dev->israw = 0;
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2065 dev->data_port,
2066 (osrun_time*HZ));
2067
2068 if (!dev->irq_ok) {
2069 snd_printk ("no post-OS interrupt.\n");
2070 goto gone_bad;
2071 }
2072
2073
2074
2075 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2076 dev->data_port, (10*HZ));
2077
2078 if (!dev->irq_ok) {
2079 snd_printk ("no post-OS interrupt(2).\n");
2080 goto gone_bad;
2081 }
2082
2083
2084
2085
2086
2087 outb (0x80|0x40, dev->control_port);
2088 }
2089
2090
2091
2092
2093
2094
2095 dev->freemem = wavefront_freemem(dev);
2096 if (dev->freemem < 0)
2097 goto gone_bad;
2098
2099 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2100
2101 if (wavefront_write (dev, 0xf0) ||
2102 wavefront_write (dev, 1) ||
2103 (wavefront_read (dev) < 0)) {
2104 dev->debug = 0;
2105 snd_printk ("MPU emulation mode not set.\n");
2106 goto gone_bad;
2107 }
2108
2109 voices[0] = 32;
2110
2111 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2112 snd_printk ("cannot set number of voices to 32.\n");
2113 goto gone_bad;
2114 }
2115
2116
2117 return 0;
2118
2119 gone_bad:
2120
2121
2122 outb (0x0, dev->control_port);
2123 dev->interrupts_are_midi = 0;
2124 return 1;
2125}
2126
2127int
2128snd_wavefront_start (snd_wavefront_t *dev)
2129
2130{
2131 int samples_are_from_rom;
2132
2133
2134
2135
2136
2137 if (dev->israw) {
2138 samples_are_from_rom = 1;
2139 } else {
2140
2141 samples_are_from_rom = 0;
2142 }
2143
2144 if (dev->israw || fx_raw) {
2145 if (wavefront_do_reset (dev)) {
2146 return -1;
2147 }
2148 }
2149
2150
2151 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2152
2153 if (dev->has_fx && fx_raw) {
2154 snd_wavefront_fx_start (dev);
2155 }
2156
2157 wavefront_get_sample_status (dev, samples_are_from_rom);
2158 wavefront_get_program_status (dev);
2159 wavefront_get_patch_status (dev);
2160
2161
2162
2163
2164 outb (0x80|0x40|0x20, dev->control_port);
2165
2166 return (0);
2167}
2168
2169int
2170snd_wavefront_detect (snd_wavefront_card_t *card)
2171
2172{
2173 unsigned char rbuf[4], wbuf[4];
2174 snd_wavefront_t *dev = &card->wavefront;
2175
2176
2177
2178
2179
2180 dev->israw = 0;
2181 dev->has_fx = 0;
2182 dev->debug = debug_default;
2183 dev->interrupts_are_midi = 0;
2184 dev->irq_cnt = 0;
2185 dev->rom_samples_rdonly = 1;
2186
2187 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2188
2189 dev->fw_version[0] = rbuf[0];
2190 dev->fw_version[1] = rbuf[1];
2191
2192 snd_printk ("firmware %d.%d already loaded.\n",
2193 rbuf[0], rbuf[1]);
2194
2195
2196
2197 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2198 rbuf, wbuf) == 0) {
2199 dev->hw_version[0] = rbuf[0];
2200 dev->hw_version[1] = rbuf[1];
2201 } else {
2202 snd_printk ("not raw, but no "
2203 "hardware version!\n");
2204 return -1;
2205 }
2206
2207 if (!wf_raw) {
2208 return 0;
2209 } else {
2210 snd_printk ("reloading firmware as you requested.\n");
2211 dev->israw = 1;
2212 }
2213
2214 } else {
2215
2216 dev->israw = 1;
2217 snd_printk ("no response to firmware probe, assume raw.\n");
2218
2219 }
2220
2221 return 0;
2222}
2223
2224MODULE_FIRMWARE(DEFAULT_OSPATH);
2225