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