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 __get_user (sample_short, dataptr);
1098 dataptr += skip;
1099
1100 if (data_is_unsigned) {
1101
1102 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1103
1104
1105
1106
1107
1108
1109 ((unsigned char*)
1110 &sample_short)[0] += 0x7f;
1111 ((unsigned char*)
1112 &sample_short)[1] += 0x7f;
1113
1114 } else {
1115
1116
1117
1118
1119
1120
1121 sample_short += 0x7fff;
1122 }
1123 }
1124
1125 } else {
1126
1127
1128
1129
1130
1131
1132
1133 }
1134
1135 if (i < blocksize - 1) {
1136 outw (sample_short, dev->block_port);
1137 } else {
1138 outw (sample_short, dev->last_block_port);
1139 }
1140 }
1141
1142
1143
1144
1145
1146 dma_ack = wavefront_read(dev);
1147 if (dma_ack != WF_DMA_ACK) {
1148 if (dma_ack == -1) {
1149 snd_printk ("upload sample "
1150 "DMA ack timeout\n");
1151 return -EIO;
1152 } else {
1153 snd_printk ("upload sample "
1154 "DMA ack error 0x%x\n",
1155 dma_ack);
1156 return -EIO;
1157 }
1158 }
1159 }
1160
1161 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1162
1163
1164
1165
1166
1167 sent:
1168 return (0);
1169}
1170
1171static int
1172wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1173
1174{
1175 unsigned char alias_hdr[WF_ALIAS_BYTES];
1176
1177 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1178 "alias for %d\n",
1179 header->number,
1180 header->hdr.a.OriginalSample);
1181
1182 if (header->number >= WF_MAX_SAMPLE)
1183 return -EINVAL;
1184
1185 munge_int32 (header->number, &alias_hdr[0], 2);
1186 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1187 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1188 &alias_hdr[4], 4);
1189 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1190 &alias_hdr[8], 4);
1191 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1192 &alias_hdr[12], 4);
1193 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1194 &alias_hdr[16], 4);
1195 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1196 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1197
1198 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1199 snd_printk ("download alias failed.\n");
1200 return -EIO;
1201 }
1202
1203 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1204
1205 return (0);
1206}
1207
1208static int
1209wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1210{
1211 int i;
1212 int num_samples;
1213 unsigned char *msample_hdr;
1214
1215 if (header->number >= WF_MAX_SAMPLE)
1216 return -EINVAL;
1217
1218 msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1219 if (! msample_hdr)
1220 return -ENOMEM;
1221
1222 munge_int32 (header->number, &msample_hdr[0], 2);
1223
1224
1225
1226
1227
1228
1229 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1230 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1231
1232 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1233 header->number,
1234 header->hdr.ms.NumberOfSamples,
1235 num_samples);
1236
1237 for (i = 0; i < num_samples; i++) {
1238 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1239 i, header->hdr.ms.SampleNumber[i]);
1240 munge_int32 (header->hdr.ms.SampleNumber[i],
1241 &msample_hdr[3+(i*2)], 2);
1242 }
1243
1244
1245
1246
1247
1248
1249 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1250 (unsigned char *) (long) ((num_samples*2)+3),
1251 msample_hdr)) {
1252 snd_printk ("download of multisample failed.\n");
1253 kfree(msample_hdr);
1254 return -EIO;
1255 }
1256
1257 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1258
1259 kfree(msample_hdr);
1260 return (0);
1261}
1262
1263static int
1264wavefront_fetch_multisample (snd_wavefront_t *dev,
1265 wavefront_patch_info *header)
1266{
1267 int i;
1268 unsigned char log_ns[1];
1269 unsigned char number[2];
1270 int num_samples;
1271
1272 munge_int32 (header->number, number, 2);
1273
1274 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1275 snd_printk ("upload multisample failed.\n");
1276 return -EIO;
1277 }
1278
1279 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1280 header->number, log_ns[0]);
1281
1282 header->hdr.ms.NumberOfSamples = log_ns[0];
1283
1284
1285
1286 num_samples = (1 << log_ns[0]);
1287
1288 for (i = 0; i < num_samples; i++) {
1289 char d[2];
1290 int val;
1291
1292 val = wavefront_read(dev);
1293 if (val == -1) {
1294 snd_printk ("upload multisample failed "
1295 "during sample loop.\n");
1296 return -EIO;
1297 }
1298 d[0] = val;
1299
1300 val = wavefront_read(dev);
1301 if (val == -1) {
1302 snd_printk ("upload multisample failed "
1303 "during sample loop.\n");
1304 return -EIO;
1305 }
1306 d[1] = val;
1307
1308 header->hdr.ms.SampleNumber[i] =
1309 demunge_int32 ((unsigned char *) d, 2);
1310
1311 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1312 i, header->hdr.ms.SampleNumber[i]);
1313 }
1314
1315 return (0);
1316}
1317
1318
1319static int
1320wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1321
1322{
1323 unsigned char drumbuf[WF_DRUM_BYTES];
1324 wavefront_drum *drum = &header->hdr.d;
1325 int i;
1326
1327 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1328 "note %d, patch = %d\n",
1329 header->number, drum->PatchNumber);
1330
1331 drumbuf[0] = header->number & 0x7f;
1332
1333 for (i = 0; i < 4; i++) {
1334 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1335 }
1336
1337 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1338 snd_printk ("download drum failed.\n");
1339 return -EIO;
1340 }
1341
1342 return (0);
1343}
1344
1345static int
1346wavefront_find_free_sample (snd_wavefront_t *dev)
1347
1348{
1349 int i;
1350
1351 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1352 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1353 return i;
1354 }
1355 }
1356 snd_printk ("no free sample slots!\n");
1357 return -1;
1358}
1359
1360#if 0
1361static int
1362wavefront_find_free_patch (snd_wavefront_t *dev)
1363
1364{
1365 int i;
1366
1367 for (i = 0; i < WF_MAX_PATCH; i++) {
1368 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1369 return i;
1370 }
1371 }
1372 snd_printk ("no free patch slots!\n");
1373 return -1;
1374}
1375#endif
1376
1377static int
1378wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1379{
1380 wavefront_patch_info *header;
1381 int err;
1382
1383 header = kmalloc(sizeof(*header), GFP_KERNEL);
1384 if (! header)
1385 return -ENOMEM;
1386
1387 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1388 sizeof(wavefront_any))) {
1389 snd_printk ("bad address for load patch.\n");
1390 err = -EFAULT;
1391 goto __error;
1392 }
1393
1394 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1395 "Sample type: %d "
1396 "Sample number: %d "
1397 "Sample size: %d\n",
1398 header->subkey,
1399 header->number,
1400 header->size);
1401
1402 switch (header->subkey) {
1403 case WF_ST_SAMPLE:
1404
1405 if (copy_from_user (&header->hdr.s, header->hdrptr,
1406 sizeof (wavefront_sample))) {
1407 err = -EFAULT;
1408 break;
1409 }
1410
1411 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1412 break;
1413
1414 case WF_ST_MULTISAMPLE:
1415
1416 if (copy_from_user (&header->hdr.s, header->hdrptr,
1417 sizeof (wavefront_multisample))) {
1418 err = -EFAULT;
1419 break;
1420 }
1421
1422 err = wavefront_send_multisample (dev, header);
1423 break;
1424
1425 case WF_ST_ALIAS:
1426
1427 if (copy_from_user (&header->hdr.a, header->hdrptr,
1428 sizeof (wavefront_alias))) {
1429 err = -EFAULT;
1430 break;
1431 }
1432
1433 err = wavefront_send_alias (dev, header);
1434 break;
1435
1436 case WF_ST_DRUM:
1437 if (copy_from_user (&header->hdr.d, header->hdrptr,
1438 sizeof (wavefront_drum))) {
1439 err = -EFAULT;
1440 break;
1441 }
1442
1443 err = wavefront_send_drum (dev, header);
1444 break;
1445
1446 case WF_ST_PATCH:
1447 if (copy_from_user (&header->hdr.p, header->hdrptr,
1448 sizeof (wavefront_patch))) {
1449 err = -EFAULT;
1450 break;
1451 }
1452
1453 err = wavefront_send_patch (dev, header);
1454 break;
1455
1456 case WF_ST_PROGRAM:
1457 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1458 sizeof (wavefront_program))) {
1459 err = -EFAULT;
1460 break;
1461 }
1462
1463 err = wavefront_send_program (dev, header);
1464 break;
1465
1466 default:
1467 snd_printk ("unknown patch type %d.\n",
1468 header->subkey);
1469 err = -EINVAL;
1470 break;
1471 }
1472
1473 __error:
1474 kfree(header);
1475 return err;
1476}
1477
1478
1479
1480
1481
1482static void
1483process_sample_hdr (u8 *buf)
1484
1485{
1486 wavefront_sample s;
1487 u8 *ptr;
1488
1489 ptr = buf;
1490
1491
1492
1493
1494
1495
1496
1497
1498 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1499 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1500 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1501 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1502 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1503
1504 s.SampleResolution = *ptr & 0x3;
1505 s.Loop = *ptr & 0x8;
1506 s.Bidirectional = *ptr & 0x10;
1507 s.Reverse = *ptr & 0x40;
1508
1509
1510
1511 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1512}
1513
1514static int
1515wavefront_synth_control (snd_wavefront_card_t *acard,
1516 wavefront_control *wc)
1517
1518{
1519 snd_wavefront_t *dev = &acard->wavefront;
1520 unsigned char patchnumbuf[2];
1521 int i;
1522
1523 DPRINT (WF_DEBUG_CMD, "synth control with "
1524 "cmd 0x%x\n", wc->cmd);
1525
1526
1527
1528 switch (wc->cmd) {
1529
1530 case WFC_DISABLE_INTERRUPTS:
1531 snd_printk ("interrupts disabled.\n");
1532 outb (0x80|0x20, dev->control_port);
1533 dev->interrupts_are_midi = 1;
1534 return 0;
1535
1536 case WFC_ENABLE_INTERRUPTS:
1537 snd_printk ("interrupts enabled.\n");
1538 outb (0x80|0x40|0x20, dev->control_port);
1539 dev->interrupts_are_midi = 1;
1540 return 0;
1541
1542 case WFC_INTERRUPT_STATUS:
1543 wc->rbuf[0] = dev->interrupts_are_midi;
1544 return 0;
1545
1546 case WFC_ROMSAMPLES_RDONLY:
1547 dev->rom_samples_rdonly = wc->wbuf[0];
1548 wc->status = 0;
1549 return 0;
1550
1551 case WFC_IDENTIFY_SLOT_TYPE:
1552 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1553 if (i <0 || i >= WF_MAX_SAMPLE) {
1554 snd_printk ("invalid slot ID %d\n",
1555 i);
1556 wc->status = EINVAL;
1557 return -EINVAL;
1558 }
1559 wc->rbuf[0] = dev->sample_status[i];
1560 wc->status = 0;
1561 return 0;
1562
1563 case WFC_DEBUG_DRIVER:
1564 dev->debug = wc->wbuf[0];
1565 snd_printk ("debug = 0x%x\n", dev->debug);
1566 return 0;
1567
1568 case WFC_UPLOAD_PATCH:
1569 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1570 memcpy (wc->wbuf, patchnumbuf, 2);
1571 break;
1572
1573 case WFC_UPLOAD_MULTISAMPLE:
1574
1575
1576
1577 wc->status = wavefront_fetch_multisample
1578 (dev, (wavefront_patch_info *) wc->rbuf);
1579 return 0;
1580
1581 case WFC_UPLOAD_SAMPLE_ALIAS:
1582 snd_printk ("support for sample alias upload "
1583 "being considered.\n");
1584 wc->status = EINVAL;
1585 return -EINVAL;
1586 }
1587
1588 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1589
1590
1591
1592
1593
1594
1595
1596 if (wc->status == 0) {
1597 switch (wc->cmd) {
1598
1599
1600
1601
1602
1603 case WFC_REPORT_FREE_MEMORY:
1604 dev->freemem = demunge_int32 (wc->rbuf, 4);
1605 break;
1606
1607 case WFC_UPLOAD_PATCH:
1608 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1609 break;
1610
1611 case WFC_UPLOAD_PROGRAM:
1612 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1613 break;
1614
1615 case WFC_UPLOAD_EDRUM_PROGRAM:
1616 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1617 break;
1618
1619 case WFC_UPLOAD_SAMPLE_HEADER:
1620 process_sample_hdr (wc->rbuf);
1621 break;
1622
1623 case WFC_UPLOAD_SAMPLE_ALIAS:
1624 snd_printk ("support for "
1625 "sample aliases still "
1626 "being considered.\n");
1627 break;
1628
1629 case WFC_VMIDI_OFF:
1630 snd_wavefront_midi_disable_virtual (acard);
1631 break;
1632
1633 case WFC_VMIDI_ON:
1634 snd_wavefront_midi_enable_virtual (acard);
1635 break;
1636 }
1637 }
1638
1639 return 0;
1640}
1641
1642int
1643snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1644
1645{
1646 if (!try_module_get(hw->card->module))
1647 return -EFAULT;
1648 file->private_data = hw;
1649 return 0;
1650}
1651
1652int
1653snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1654
1655{
1656 module_put(hw->card->module);
1657 return 0;
1658}
1659
1660int
1661snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1662 unsigned int cmd, unsigned long arg)
1663
1664{
1665 struct snd_card *card;
1666 snd_wavefront_t *dev;
1667 snd_wavefront_card_t *acard;
1668 wavefront_control *wc;
1669 void __user *argp = (void __user *)arg;
1670 int err;
1671
1672 card = (struct snd_card *) hw->card;
1673
1674 if (snd_BUG_ON(!card))
1675 return -ENODEV;
1676 if (snd_BUG_ON(!card->private_data))
1677 return -ENODEV;
1678
1679 acard = card->private_data;
1680 dev = &acard->wavefront;
1681
1682 switch (cmd) {
1683 case WFCTL_LOAD_SPP:
1684 if (wavefront_load_patch (dev, argp) != 0) {
1685 return -EIO;
1686 }
1687 break;
1688
1689 case WFCTL_WFCMD:
1690 wc = memdup_user(argp, sizeof(*wc));
1691 if (IS_ERR(wc))
1692 return PTR_ERR(wc);
1693
1694 if (wavefront_synth_control (acard, wc) < 0)
1695 err = -EIO;
1696 else if (copy_to_user (argp, wc, sizeof (*wc)))
1697 err = -EFAULT;
1698 else
1699 err = 0;
1700 kfree(wc);
1701 return err;
1702
1703 default:
1704 return -EINVAL;
1705 }
1706
1707 return 0;
1708}
1709
1710
1711
1712
1713
1714
1715void
1716snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1717{
1718 snd_wavefront_t *dev = &card->wavefront;
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1741 return;
1742 }
1743
1744 spin_lock(&dev->irq_lock);
1745 dev->irq_ok = 1;
1746 dev->irq_cnt++;
1747 spin_unlock(&dev->irq_lock);
1748 wake_up(&dev->interrupt_sleeper);
1749}
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763static int
1764snd_wavefront_interrupt_bits (int irq)
1765
1766{
1767 int bits;
1768
1769 switch (irq) {
1770 case 9:
1771 bits = 0x00;
1772 break;
1773 case 5:
1774 bits = 0x08;
1775 break;
1776 case 12:
1777 bits = 0x10;
1778 break;
1779 case 15:
1780 bits = 0x18;
1781 break;
1782
1783 default:
1784 snd_printk ("invalid IRQ %d\n", irq);
1785 bits = -1;
1786 }
1787
1788 return bits;
1789}
1790
1791static void
1792wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1793 int val, int port, unsigned long timeout)
1794
1795{
1796 wait_queue_entry_t wait;
1797
1798 init_waitqueue_entry(&wait, current);
1799 spin_lock_irq(&dev->irq_lock);
1800 add_wait_queue(&dev->interrupt_sleeper, &wait);
1801 dev->irq_ok = 0;
1802 outb (val,port);
1803 spin_unlock_irq(&dev->irq_lock);
1804 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1805 schedule_timeout_uninterruptible(1);
1806 barrier();
1807 }
1808}
1809
1810static int
1811wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1812
1813{
1814 int bits;
1815 int hwv[2];
1816
1817
1818
1819 bits = snd_wavefront_interrupt_bits (dev->irq);
1820
1821
1822
1823 outb (0x0, dev->control_port);
1824
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 outb (0x80 | 0x40 | bits, dev->data_port);
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1881 dev->control_port,
1882 (reset_time*HZ)/100);
1883
1884
1885
1886
1887
1888 if (!dev->irq_ok) {
1889 snd_printk ("intr not received after h/w un-reset.\n");
1890 goto gone_bad;
1891 }
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1910 dev->data_port, ramcheck_time*HZ);
1911
1912 if (!dev->irq_ok) {
1913 snd_printk ("post-RAM-check interrupt not received.\n");
1914 goto gone_bad;
1915 }
1916
1917 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1918 snd_printk ("no response to HW version cmd.\n");
1919 goto gone_bad;
1920 }
1921
1922 hwv[0] = wavefront_read(dev);
1923 if (hwv[0] == -1) {
1924 snd_printk ("board not responding correctly.\n");
1925 goto gone_bad;
1926 }
1927
1928 if (hwv[0] == 0xFF) {
1929
1930
1931
1932
1933
1934 hwv[0] = wavefront_read(dev);
1935 if (hwv[0] == -1) {
1936 snd_printk ("on-board RAM test failed "
1937 "(bad error code).\n");
1938 } else {
1939 snd_printk ("on-board RAM test failed "
1940 "(error code: 0x%x).\n",
1941 hwv[0]);
1942 }
1943 goto gone_bad;
1944 }
1945
1946
1947
1948 hwv[1] = wavefront_read(dev);
1949 if (hwv[1] == -1) {
1950 snd_printk ("incorrect h/w response.\n");
1951 goto gone_bad;
1952 }
1953
1954 snd_printk ("hardware version %d.%d\n",
1955 hwv[0], hwv[1]);
1956
1957 return 0;
1958
1959
1960 gone_bad:
1961 return (1);
1962}
1963
1964static int
1965wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1966
1967{
1968 const unsigned char *buf;
1969 int len, err;
1970 int section_cnt_downloaded = 0;
1971 const struct firmware *firmware;
1972
1973 err = request_firmware(&firmware, path, dev->card->dev);
1974 if (err < 0) {
1975 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1976 return 1;
1977 }
1978
1979 len = 0;
1980 buf = firmware->data;
1981 for (;;) {
1982 int section_length = *(signed char *)buf;
1983 if (section_length == 0)
1984 break;
1985 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1986 snd_printk(KERN_ERR
1987 "invalid firmware section length %d\n",
1988 section_length);
1989 goto failure;
1990 }
1991 buf++;
1992 len++;
1993
1994 if (firmware->size < len + section_length) {
1995 snd_printk(KERN_ERR "firmware section read error.\n");
1996 goto failure;
1997 }
1998
1999
2000 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
2001 goto failure;
2002
2003 for (; section_length; section_length--) {
2004 if (wavefront_write(dev, *buf))
2005 goto failure;
2006 buf++;
2007 len++;
2008 }
2009
2010
2011 if (!wavefront_wait(dev, STAT_CAN_READ)) {
2012 snd_printk(KERN_ERR "time out for firmware ACK.\n");
2013 goto failure;
2014 }
2015 err = inb(dev->data_port);
2016 if (err != WF_ACK) {
2017 snd_printk(KERN_ERR
2018 "download of section #%d not "
2019 "acknowledged, ack = 0x%x\n",
2020 section_cnt_downloaded + 1, err);
2021 goto failure;
2022 }
2023
2024 section_cnt_downloaded++;
2025 }
2026
2027 release_firmware(firmware);
2028 return 0;
2029
2030 failure:
2031 release_firmware(firmware);
2032 snd_printk(KERN_ERR "firmware download failed!!!\n");
2033 return 1;
2034}
2035
2036
2037static int
2038wavefront_do_reset (snd_wavefront_t *dev)
2039
2040{
2041 char voices[1];
2042
2043 if (wavefront_reset_to_cleanliness (dev)) {
2044 snd_printk ("hw reset failed.\n");
2045 goto gone_bad;
2046 }
2047
2048 if (dev->israw) {
2049 if (wavefront_download_firmware (dev, ospath)) {
2050 goto gone_bad;
2051 }
2052
2053 dev->israw = 0;
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2064 dev->data_port,
2065 (osrun_time*HZ));
2066
2067 if (!dev->irq_ok) {
2068 snd_printk ("no post-OS interrupt.\n");
2069 goto gone_bad;
2070 }
2071
2072
2073
2074 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2075 dev->data_port, (10*HZ));
2076
2077 if (!dev->irq_ok) {
2078 snd_printk ("no post-OS interrupt(2).\n");
2079 goto gone_bad;
2080 }
2081
2082
2083
2084
2085
2086 outb (0x80|0x40, dev->control_port);
2087 }
2088
2089
2090
2091
2092
2093
2094 dev->freemem = wavefront_freemem(dev);
2095 if (dev->freemem < 0)
2096 goto gone_bad;
2097
2098 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2099
2100 if (wavefront_write (dev, 0xf0) ||
2101 wavefront_write (dev, 1) ||
2102 (wavefront_read (dev) < 0)) {
2103 dev->debug = 0;
2104 snd_printk ("MPU emulation mode not set.\n");
2105 goto gone_bad;
2106 }
2107
2108 voices[0] = 32;
2109
2110 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2111 snd_printk ("cannot set number of voices to 32.\n");
2112 goto gone_bad;
2113 }
2114
2115
2116 return 0;
2117
2118 gone_bad:
2119
2120
2121 outb (0x0, dev->control_port);
2122 dev->interrupts_are_midi = 0;
2123 return 1;
2124}
2125
2126int
2127snd_wavefront_start (snd_wavefront_t *dev)
2128
2129{
2130 int samples_are_from_rom;
2131
2132
2133
2134
2135
2136 if (dev->israw) {
2137 samples_are_from_rom = 1;
2138 } else {
2139
2140 samples_are_from_rom = 0;
2141 }
2142
2143 if (dev->israw || fx_raw) {
2144 if (wavefront_do_reset (dev)) {
2145 return -1;
2146 }
2147 }
2148
2149
2150 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2151
2152 if (dev->has_fx && fx_raw) {
2153 snd_wavefront_fx_start (dev);
2154 }
2155
2156 wavefront_get_sample_status (dev, samples_are_from_rom);
2157 wavefront_get_program_status (dev);
2158 wavefront_get_patch_status (dev);
2159
2160
2161
2162
2163 outb (0x80|0x40|0x20, dev->control_port);
2164
2165 return (0);
2166}
2167
2168int
2169snd_wavefront_detect (snd_wavefront_card_t *card)
2170
2171{
2172 unsigned char rbuf[4], wbuf[4];
2173 snd_wavefront_t *dev = &card->wavefront;
2174
2175
2176
2177
2178
2179 dev->israw = 0;
2180 dev->has_fx = 0;
2181 dev->debug = debug_default;
2182 dev->interrupts_are_midi = 0;
2183 dev->irq_cnt = 0;
2184 dev->rom_samples_rdonly = 1;
2185
2186 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2187
2188 dev->fw_version[0] = rbuf[0];
2189 dev->fw_version[1] = rbuf[1];
2190
2191 snd_printk ("firmware %d.%d already loaded.\n",
2192 rbuf[0], rbuf[1]);
2193
2194
2195
2196 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2197 rbuf, wbuf) == 0) {
2198 dev->hw_version[0] = rbuf[0];
2199 dev->hw_version[1] = rbuf[1];
2200 } else {
2201 snd_printk ("not raw, but no "
2202 "hardware version!\n");
2203 return -1;
2204 }
2205
2206 if (!wf_raw) {
2207 return 0;
2208 } else {
2209 snd_printk ("reloading firmware as you requested.\n");
2210 dev->israw = 1;
2211 }
2212
2213 } else {
2214
2215 dev->israw = 1;
2216 snd_printk ("no response to firmware probe, assume raw.\n");
2217
2218 }
2219
2220 return 0;
2221}
2222
2223MODULE_FIRMWARE(DEFAULT_OSPATH);
2224