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