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