Loading...
1/* Copyright (C) by Paul Barton-Davis 1998-1999
2 *
3 * Some portions of this file are taken from work that is
4 * copyright (C) by Hannu Savolainen 1993-1996
5 *
6 * This program is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
7 * Version 2 (June 1991). See the "COPYING" file distributed with this software
8 * for more info.
9 */
10
11/*
12 * An ALSA lowlevel driver for Turtle Beach ICS2115 wavetable synth
13 * (Maui, Tropez, Tropez Plus)
14 *
15 * This driver supports the onboard wavetable synthesizer (an ICS2115),
16 * including patch, sample and program loading and unloading, conversion
17 * of GUS patches during loading, and full user-level access to all
18 * WaveFront commands. It tries to provide semi-intelligent patch and
19 * sample management as well.
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/firmware.h>
30#include <linux/moduleparam.h>
31#include <linux/slab.h>
32#include <linux/module.h>
33#include <sound/core.h>
34#include <sound/snd_wavefront.h>
35#include <sound/initval.h>
36
37static int wf_raw = 0; /* we normally check for "raw state" to firmware
38 loading. if non-zero, then during driver loading, the
39 state of the board is ignored, and we reset the
40 board and load the firmware anyway.
41 */
42
43static int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
44 whatever state it is when the driver is loaded.
45 The default is to download the microprogram and
46 associated coefficients to set it up for "default"
47 operation, whatever that means.
48 */
49
50static int debug_default = 0; /* you can set this to control debugging
51 during driver loading. it takes any combination
52 of the WF_DEBUG_* flags defined in
53 wavefront.h
54 */
55
56/* XXX this needs to be made firmware and hardware version dependent */
57
58#define DEFAULT_OSPATH "wavefront.os"
59static char *ospath = DEFAULT_OSPATH; /* the firmware file name */
60
61static int wait_usecs = 150; /* This magic number seems to give pretty optimal
62 throughput based on my limited experimentation.
63 If you want to play around with it and find a better
64 value, be my guest. Remember, the idea is to
65 get a number that causes us to just busy wait
66 for as many WaveFront commands as possible, without
67 coming up with a number so large that we hog the
68 whole CPU.
69
70 Specifically, with this number, out of about 134,000
71 status waits, only about 250 result in a sleep.
72 */
73
74static int sleep_interval = 100; /* HZ/sleep_interval seconds per sleep */
75static int sleep_tries = 50; /* number of times we'll try to sleep */
76
77static int reset_time = 2; /* hundreths of a second we wait after a HW
78 reset for the expected interrupt.
79 */
80
81static int ramcheck_time = 20; /* time in seconds to wait while ROM code
82 checks on-board RAM.
83 */
84
85static int osrun_time = 10; /* time in seconds we wait for the OS to
86 start running.
87 */
88module_param(wf_raw, int, 0444);
89MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
90module_param(fx_raw, int, 0444);
91MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
92module_param(debug_default, int, 0444);
93MODULE_PARM_DESC(debug_default, "debug parameters for card initialization");
94module_param(wait_usecs, int, 0444);
95MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs");
96module_param(sleep_interval, int, 0444);
97MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply");
98module_param(sleep_tries, int, 0444);
99MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait");
100module_param(ospath, charp, 0444);
101MODULE_PARM_DESC(ospath, "pathname to processed ICS2115 OS firmware");
102module_param(reset_time, int, 0444);
103MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect");
104module_param(ramcheck_time, int, 0444);
105MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test");
106module_param(osrun_time, int, 0444);
107MODULE_PARM_DESC(osrun_time, "how many seconds to wait for the ICS2115 OS");
108
109/* if WF_DEBUG not defined, no run-time debugging messages will
110 be available via the debug flag setting. Given the current
111 beta state of the driver, this will remain set until a future
112 version.
113*/
114
115#define WF_DEBUG 1
116
117#ifdef WF_DEBUG
118
119#define DPRINT(cond, ...) \
120 if ((dev->debug & (cond)) == (cond)) { \
121 snd_printk (__VA_ARGS__); \
122 }
123#else
124#define DPRINT(cond, args...)
125#endif /* WF_DEBUG */
126
127#define LOGNAME "WaveFront: "
128
129/* bitmasks for WaveFront status port value */
130
131#define STAT_RINTR_ENABLED 0x01
132#define STAT_CAN_READ 0x02
133#define STAT_INTR_READ 0x04
134#define STAT_WINTR_ENABLED 0x10
135#define STAT_CAN_WRITE 0x20
136#define STAT_INTR_WRITE 0x40
137
138static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
139static int wavefront_find_free_sample (snd_wavefront_t *);
140
141struct wavefront_command {
142 int cmd;
143 char *action;
144 unsigned int read_cnt;
145 unsigned int write_cnt;
146 int need_ack;
147};
148
149static struct {
150 int errno;
151 const char *errstr;
152} wavefront_errors[] = {
153 { 0x01, "Bad sample number" },
154 { 0x02, "Out of sample memory" },
155 { 0x03, "Bad patch number" },
156 { 0x04, "Error in number of voices" },
157 { 0x06, "Sample load already in progress" },
158 { 0x0B, "No sample load request pending" },
159 { 0x0E, "Bad MIDI channel number" },
160 { 0x10, "Download Record Error" },
161 { 0x80, "Success" },
162 { 0x0 }
163};
164
165#define NEEDS_ACK 1
166
167static struct wavefront_command wavefront_commands[] = {
168 { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK },
169 { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0},
170 { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK },
171 { WFC_GET_NVOICES, "get number of voices", 1, 0, 0 },
172 { WFC_SET_TUNING, "set synthesizer tuning", 0, 2, NEEDS_ACK },
173 { WFC_GET_TUNING, "get synthesizer tuning", 2, 0, 0 },
174 { WFC_DISABLE_CHANNEL, "disable synth channel", 0, 1, NEEDS_ACK },
175 { WFC_ENABLE_CHANNEL, "enable synth channel", 0, 1, NEEDS_ACK },
176 { WFC_GET_CHANNEL_STATUS, "get synth channel status", 3, 0, 0 },
177 { WFC_MISYNTH_OFF, "disable midi-in to synth", 0, 0, NEEDS_ACK },
178 { WFC_MISYNTH_ON, "enable midi-in to synth", 0, 0, NEEDS_ACK },
179 { WFC_VMIDI_ON, "enable virtual midi mode", 0, 0, NEEDS_ACK },
180 { WFC_VMIDI_OFF, "disable virtual midi mode", 0, 0, NEEDS_ACK },
181 { WFC_MIDI_STATUS, "report midi status", 1, 0, 0 },
182 { WFC_FIRMWARE_VERSION, "report firmware version", 2, 0, 0 },
183 { WFC_HARDWARE_VERSION, "report hardware version", 2, 0, 0 },
184 { WFC_GET_NSAMPLES, "report number of samples", 2, 0, 0 },
185 { WFC_INSTOUT_LEVELS, "report instantaneous output levels", 7, 0, 0 },
186 { WFC_PEAKOUT_LEVELS, "report peak output levels", 7, 0, 0 },
187 { WFC_DOWNLOAD_SAMPLE, "download sample",
188 0, WF_SAMPLE_BYTES, NEEDS_ACK },
189 { WFC_DOWNLOAD_BLOCK, "download block", 0, 0, NEEDS_ACK},
190 { WFC_DOWNLOAD_SAMPLE_HEADER, "download sample header",
191 0, WF_SAMPLE_HDR_BYTES, NEEDS_ACK },
192 { WFC_UPLOAD_SAMPLE_HEADER, "upload sample header", 13, 2, 0 },
193
194 /* This command requires a variable number of bytes to be written.
195 There is a hack in snd_wavefront_cmd() to support this. The actual
196 count is passed in as the read buffer ptr, cast appropriately.
197 Ugh.
198 */
199
200 { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
201
202 /* This one is a hack as well. We just read the first byte of the
203 response, don't fetch an ACK, and leave the rest to the
204 calling function. Ugly, ugly, ugly.
205 */
206
207 { WFC_UPLOAD_MULTISAMPLE, "upload multisample", 2, 1, 0 },
208 { WFC_DOWNLOAD_SAMPLE_ALIAS, "download sample alias",
209 0, WF_ALIAS_BYTES, NEEDS_ACK },
210 { WFC_UPLOAD_SAMPLE_ALIAS, "upload sample alias", WF_ALIAS_BYTES, 2, 0},
211 { WFC_DELETE_SAMPLE, "delete sample", 0, 2, NEEDS_ACK },
212 { WFC_IDENTIFY_SAMPLE_TYPE, "identify sample type", 5, 2, 0 },
213 { WFC_UPLOAD_SAMPLE_PARAMS, "upload sample parameters" },
214 { WFC_REPORT_FREE_MEMORY, "report free memory", 4, 0, 0 },
215 { WFC_DOWNLOAD_PATCH, "download patch", 0, 134, NEEDS_ACK },
216 { WFC_UPLOAD_PATCH, "upload patch", 132, 2, 0 },
217 { WFC_DOWNLOAD_PROGRAM, "download program", 0, 33, NEEDS_ACK },
218 { WFC_UPLOAD_PROGRAM, "upload program", 32, 1, 0 },
219 { WFC_DOWNLOAD_EDRUM_PROGRAM, "download enhanced drum program", 0, 9,
220 NEEDS_ACK},
221 { WFC_UPLOAD_EDRUM_PROGRAM, "upload enhanced drum program", 8, 1, 0},
222 { WFC_SET_EDRUM_CHANNEL, "set enhanced drum program channel",
223 0, 1, NEEDS_ACK },
224 { WFC_DISABLE_DRUM_PROGRAM, "disable drum program", 0, 1, NEEDS_ACK },
225 { WFC_REPORT_CHANNEL_PROGRAMS, "report channel program numbers",
226 32, 0, 0 },
227 { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
228 { 0x00 }
229};
230
231static const char *
232wavefront_errorstr (int errnum)
233
234{
235 int i;
236
237 for (i = 0; wavefront_errors[i].errstr; i++) {
238 if (wavefront_errors[i].errno == errnum) {
239 return wavefront_errors[i].errstr;
240 }
241 }
242
243 return "Unknown WaveFront error";
244}
245
246static struct wavefront_command *
247wavefront_get_command (int cmd)
248
249{
250 int i;
251
252 for (i = 0; wavefront_commands[i].cmd != 0; i++) {
253 if (cmd == wavefront_commands[i].cmd) {
254 return &wavefront_commands[i];
255 }
256 }
257
258 return NULL;
259}
260
261static inline int
262wavefront_status (snd_wavefront_t *dev)
263
264{
265 return inb (dev->status_port);
266}
267
268static int
269wavefront_sleep (int limit)
270
271{
272 schedule_timeout_interruptible(limit);
273
274 return signal_pending(current);
275}
276
277static int
278wavefront_wait (snd_wavefront_t *dev, int mask)
279
280{
281 int i;
282
283 /* Spin for a short period of time, because >99% of all
284 requests to the WaveFront can be serviced inline like this.
285 */
286
287 for (i = 0; i < wait_usecs; i += 5) {
288 if (wavefront_status (dev) & mask) {
289 return 1;
290 }
291 udelay(5);
292 }
293
294 for (i = 0; i < sleep_tries; i++) {
295
296 if (wavefront_status (dev) & mask) {
297 return 1;
298 }
299
300 if (wavefront_sleep (HZ/sleep_interval)) {
301 return (0);
302 }
303 }
304
305 return (0);
306}
307
308static int
309wavefront_read (snd_wavefront_t *dev)
310
311{
312 if (wavefront_wait (dev, STAT_CAN_READ))
313 return inb (dev->data_port);
314
315 DPRINT (WF_DEBUG_DATA, "read timeout.\n");
316
317 return -1;
318}
319
320static int
321wavefront_write (snd_wavefront_t *dev, unsigned char data)
322
323{
324 if (wavefront_wait (dev, STAT_CAN_WRITE)) {
325 outb (data, dev->data_port);
326 return 0;
327 }
328
329 DPRINT (WF_DEBUG_DATA, "write timeout.\n");
330
331 return -1;
332}
333
334int
335snd_wavefront_cmd (snd_wavefront_t *dev,
336 int cmd, unsigned char *rbuf, unsigned char *wbuf)
337
338{
339 int ack;
340 unsigned int i;
341 int c;
342 struct wavefront_command *wfcmd;
343
344 if ((wfcmd = wavefront_get_command (cmd)) == NULL) {
345 snd_printk ("command 0x%x not supported.\n",
346 cmd);
347 return 1;
348 }
349
350 /* Hack to handle the one variable-size write command. See
351 wavefront_send_multisample() for the other half of this
352 gross and ugly strategy.
353 */
354
355 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
356 wfcmd->write_cnt = (unsigned long) rbuf;
357 rbuf = NULL;
358 }
359
360 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
361 cmd, wfcmd->action, wfcmd->read_cnt,
362 wfcmd->write_cnt, wfcmd->need_ack);
363
364 if (wavefront_write (dev, cmd)) {
365 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
366 "0x%x [%s].\n",
367 cmd, wfcmd->action);
368 return 1;
369 }
370
371 if (wfcmd->write_cnt > 0) {
372 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
373 "for 0x%x\n",
374 wfcmd->write_cnt, cmd);
375
376 for (i = 0; i < wfcmd->write_cnt; i++) {
377 if (wavefront_write (dev, wbuf[i])) {
378 DPRINT (WF_DEBUG_IO, "bad write for byte "
379 "%d of 0x%x [%s].\n",
380 i, cmd, wfcmd->action);
381 return 1;
382 }
383
384 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
385 i, wbuf[i]);
386 }
387 }
388
389 if (wfcmd->read_cnt > 0) {
390 DPRINT (WF_DEBUG_DATA, "reading %d ints "
391 "for 0x%x\n",
392 wfcmd->read_cnt, cmd);
393
394 for (i = 0; i < wfcmd->read_cnt; i++) {
395
396 if ((c = wavefront_read (dev)) == -1) {
397 DPRINT (WF_DEBUG_IO, "bad read for byte "
398 "%d of 0x%x [%s].\n",
399 i, cmd, wfcmd->action);
400 return 1;
401 }
402
403 /* Now handle errors. Lots of special cases here */
404
405 if (c == 0xff) {
406 if ((c = wavefront_read (dev)) == -1) {
407 DPRINT (WF_DEBUG_IO, "bad read for "
408 "error byte at "
409 "read byte %d "
410 "of 0x%x [%s].\n",
411 i, cmd,
412 wfcmd->action);
413 return 1;
414 }
415
416 /* Can you believe this madness ? */
417
418 if (c == 1 &&
419 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
420 rbuf[0] = WF_ST_EMPTY;
421 return (0);
422
423 } else if (c == 3 &&
424 wfcmd->cmd == WFC_UPLOAD_PATCH) {
425
426 return 3;
427
428 } else if (c == 1 &&
429 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
430
431 return 1;
432
433 } else {
434
435 DPRINT (WF_DEBUG_IO, "error %d (%s) "
436 "during "
437 "read for byte "
438 "%d of 0x%x "
439 "[%s].\n",
440 c,
441 wavefront_errorstr (c),
442 i, cmd,
443 wfcmd->action);
444 return 1;
445
446 }
447
448 } else {
449 rbuf[i] = c;
450 }
451
452 DPRINT (WF_DEBUG_DATA, "read[%d] = 0x%x\n",i, rbuf[i]);
453 }
454 }
455
456 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
457
458 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
459
460 /* Some commands need an ACK, but return zero instead
461 of the standard value.
462 */
463
464 if ((ack = wavefront_read (dev)) == 0) {
465 ack = WF_ACK;
466 }
467
468 if (ack != WF_ACK) {
469 if (ack == -1) {
470 DPRINT (WF_DEBUG_IO, "cannot read ack for "
471 "0x%x [%s].\n",
472 cmd, wfcmd->action);
473 return 1;
474
475 } else {
476 int err = -1; /* something unknown */
477
478 if (ack == 0xff) { /* explicit error */
479
480 if ((err = wavefront_read (dev)) == -1) {
481 DPRINT (WF_DEBUG_DATA,
482 "cannot read err "
483 "for 0x%x [%s].\n",
484 cmd, wfcmd->action);
485 }
486 }
487
488 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
489 "failed (0x%x, 0x%x, %s)\n",
490 cmd, wfcmd->action, ack, err,
491 wavefront_errorstr (err));
492
493 return -err;
494 }
495 }
496
497 DPRINT (WF_DEBUG_DATA, "ack received "
498 "for 0x%x [%s]\n",
499 cmd, wfcmd->action);
500 } else {
501
502 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
503 "ACK (%d,%d,%d)\n",
504 cmd, wfcmd->action, wfcmd->read_cnt,
505 wfcmd->write_cnt, wfcmd->need_ack);
506 }
507
508 return 0;
509
510}
511
512/***********************************************************************
513WaveFront data munging
514
515Things here are weird. All data written to the board cannot
516have its most significant bit set. Any data item with values
517potentially > 0x7F (127) must be split across multiple bytes.
518
519Sometimes, we need to munge numeric values that are represented on
520the x86 side as 8-32 bit values. Sometimes, we need to munge data
521that is represented on the x86 side as an array of bytes. The most
522efficient approach to handling both cases seems to be to use 2
523different functions for munging and 2 for de-munging. This avoids
524weird casting and worrying about bit-level offsets.
525
526**********************************************************************/
527
528static unsigned char *
529munge_int32 (unsigned int src,
530 unsigned char *dst,
531 unsigned int dst_size)
532{
533 unsigned int i;
534
535 for (i = 0; i < dst_size; i++) {
536 *dst = src & 0x7F; /* Mask high bit of LSB */
537 src = src >> 7; /* Rotate Right 7 bits */
538 /* Note: we leave the upper bits in place */
539
540 dst++;
541 }
542 return dst;
543};
544
545static int
546demunge_int32 (unsigned char* src, int src_size)
547
548{
549 int i;
550 int outval = 0;
551
552 for (i = src_size - 1; i >= 0; i--) {
553 outval=(outval<<7)+src[i];
554 }
555
556 return outval;
557};
558
559static
560unsigned char *
561munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
562
563{
564 unsigned int i;
565 unsigned int last = dst_size / 2;
566
567 for (i = 0; i < last; i++) {
568 *dst++ = src[i] & 0x7f;
569 *dst++ = src[i] >> 7;
570 }
571 return dst;
572}
573
574static
575unsigned char *
576demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
577
578{
579 int i;
580 unsigned char *end = src + src_bytes;
581
582 end = src + src_bytes;
583
584 /* NOTE: src and dst *CAN* point to the same address */
585
586 for (i = 0; src != end; i++) {
587 dst[i] = *src++;
588 dst[i] |= (*src++)<<7;
589 }
590
591 return dst;
592}
593
594/***********************************************************************
595WaveFront: sample, patch and program management.
596***********************************************************************/
597
598static int
599wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
600
601{
602 unsigned char wbuf[2];
603 int x;
604
605 wbuf[0] = sample_num & 0x7f;
606 wbuf[1] = sample_num >> 7;
607
608 if ((x = snd_wavefront_cmd (dev, WFC_DELETE_SAMPLE, NULL, wbuf)) == 0) {
609 dev->sample_status[sample_num] = WF_ST_EMPTY;
610 }
611
612 return x;
613}
614
615static int
616wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
617
618{
619 int i;
620 unsigned char rbuf[32], wbuf[32];
621 unsigned int sc_real, sc_alias, sc_multi;
622
623 /* check sample status */
624
625 if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
626 snd_printk ("cannot request sample count.\n");
627 return -1;
628 }
629
630 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
631
632 for (i = 0; i < WF_MAX_SAMPLE; i++) {
633
634 wbuf[0] = i & 0x7f;
635 wbuf[1] = i >> 7;
636
637 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
638 snd_printk(KERN_WARNING "cannot identify sample "
639 "type of slot %d\n", i);
640 dev->sample_status[i] = WF_ST_EMPTY;
641 continue;
642 }
643
644 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
645
646 if (assume_rom) {
647 dev->sample_status[i] |= WF_SLOT_ROM;
648 }
649
650 switch (rbuf[0] & WF_ST_MASK) {
651 case WF_ST_SAMPLE:
652 sc_real++;
653 break;
654 case WF_ST_MULTISAMPLE:
655 sc_multi++;
656 break;
657 case WF_ST_ALIAS:
658 sc_alias++;
659 break;
660 case WF_ST_EMPTY:
661 break;
662
663 default:
664 snd_printk ("unknown sample type for "
665 "slot %d (0x%x)\n",
666 i, rbuf[0]);
667 }
668
669 if (rbuf[0] != WF_ST_EMPTY) {
670 dev->samples_used++;
671 }
672 }
673
674 snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
675 "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
676 WF_MAX_SAMPLE - dev->samples_used);
677
678
679 return (0);
680
681}
682
683static int
684wavefront_get_patch_status (snd_wavefront_t *dev)
685
686{
687 unsigned char patchbuf[WF_PATCH_BYTES];
688 unsigned char patchnum[2];
689 wavefront_patch *p;
690 int i, x, cnt, cnt2;
691
692 for (i = 0; i < WF_MAX_PATCH; i++) {
693 patchnum[0] = i & 0x7f;
694 patchnum[1] = i >> 7;
695
696 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PATCH, patchbuf,
697 patchnum)) == 0) {
698
699 dev->patch_status[i] |= WF_SLOT_FILLED;
700 p = (wavefront_patch *) patchbuf;
701 dev->sample_status
702 [p->sample_number|(p->sample_msb<<7)] |=
703 WF_SLOT_USED;
704
705 } else if (x == 3) { /* Bad patch number */
706 dev->patch_status[i] = 0;
707 } else {
708 snd_printk ("upload patch "
709 "error 0x%x\n", x);
710 dev->patch_status[i] = 0;
711 return 1;
712 }
713 }
714
715 /* program status has already filled in slot_used bits */
716
717 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
718 if (dev->patch_status[i] & WF_SLOT_FILLED) {
719 cnt++;
720 }
721 if (dev->patch_status[i] & WF_SLOT_USED) {
722 cnt2++;
723 }
724
725 }
726 snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
727
728 return (0);
729}
730
731static int
732wavefront_get_program_status (snd_wavefront_t *dev)
733
734{
735 unsigned char progbuf[WF_PROGRAM_BYTES];
736 wavefront_program prog;
737 unsigned char prognum;
738 int i, x, l, cnt;
739
740 for (i = 0; i < WF_MAX_PROGRAM; i++) {
741 prognum = i;
742
743 if ((x = snd_wavefront_cmd (dev, WFC_UPLOAD_PROGRAM, progbuf,
744 &prognum)) == 0) {
745
746 dev->prog_status[i] |= WF_SLOT_USED;
747
748 demunge_buf (progbuf, (unsigned char *) &prog,
749 WF_PROGRAM_BYTES);
750
751 for (l = 0; l < WF_NUM_LAYERS; l++) {
752 if (prog.layer[l].mute) {
753 dev->patch_status
754 [prog.layer[l].patch_number] |=
755 WF_SLOT_USED;
756 }
757 }
758 } else if (x == 1) { /* Bad program number */
759 dev->prog_status[i] = 0;
760 } else {
761 snd_printk ("upload program "
762 "error 0x%x\n", x);
763 dev->prog_status[i] = 0;
764 }
765 }
766
767 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
768 if (dev->prog_status[i]) {
769 cnt++;
770 }
771 }
772
773 snd_printk ("%d programs slots in use\n", cnt);
774
775 return (0);
776}
777
778static int
779wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
780
781{
782 unsigned char buf[WF_PATCH_BYTES+2];
783 unsigned char *bptr;
784
785 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
786 header->number);
787
788 dev->patch_status[header->number] |= WF_SLOT_FILLED;
789
790 bptr = buf;
791 bptr = munge_int32 (header->number, buf, 2);
792 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
793
794 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
795 snd_printk ("download patch failed\n");
796 return -EIO;
797 }
798
799 return (0);
800}
801
802static int
803wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
804
805{
806 unsigned char buf[WF_PROGRAM_BYTES+1];
807 int i;
808
809 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
810 header->number);
811
812 dev->prog_status[header->number] = WF_SLOT_USED;
813
814 /* XXX need to zero existing SLOT_USED bit for program_status[i]
815 where `i' is the program that's being (potentially) overwritten.
816 */
817
818 for (i = 0; i < WF_NUM_LAYERS; i++) {
819 if (header->hdr.pr.layer[i].mute) {
820 dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
821 WF_SLOT_USED;
822
823 /* XXX need to mark SLOT_USED for sample used by
824 patch_number, but this means we have to load it. Ick.
825 */
826 }
827 }
828
829 buf[0] = header->number;
830 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
831
832 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
833 snd_printk ("download patch failed\n");
834 return -EIO;
835 }
836
837 return (0);
838}
839
840static int
841wavefront_freemem (snd_wavefront_t *dev)
842
843{
844 char rbuf[8];
845
846 if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
847 snd_printk ("can't get memory stats.\n");
848 return -1;
849 } else {
850 return demunge_int32 (rbuf, 4);
851 }
852}
853
854static int
855wavefront_send_sample (snd_wavefront_t *dev,
856 wavefront_patch_info *header,
857 u16 __user *dataptr,
858 int data_is_unsigned)
859
860{
861 /* samples are downloaded via a 16-bit wide i/o port
862 (you could think of it as 2 adjacent 8-bit wide ports
863 but its less efficient that way). therefore, all
864 the blocksizes and so forth listed in the documentation,
865 and used conventionally to refer to sample sizes,
866 which are given in 8-bit units (bytes), need to be
867 divided by 2.
868 */
869
870 u16 sample_short = 0;
871 u32 length;
872 u16 __user *data_end = NULL;
873 unsigned int i;
874 const unsigned int max_blksize = 4096/2;
875 unsigned int written;
876 unsigned int blocksize;
877 int dma_ack;
878 int blocknum;
879 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
880 unsigned char *shptr;
881 int skip = 0;
882 int initial_skip = 0;
883
884 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
885 "type %d, %d bytes from 0x%lx\n",
886 header->size ? "" : "header ",
887 header->number, header->subkey,
888 header->size,
889 (unsigned long) header->dataptr);
890
891 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
892 int x;
893
894 if ((x = wavefront_find_free_sample (dev)) < 0) {
895 return -ENOMEM;
896 }
897 snd_printk ("unspecified sample => %d\n", x);
898 header->number = x;
899 }
900
901 if (header->size) {
902
903 /* XXX it's a debatable point whether or not RDONLY semantics
904 on the ROM samples should cover just the sample data or
905 the sample header. For now, it only covers the sample data,
906 so anyone is free at all times to rewrite sample headers.
907
908 My reason for this is that we have the sample headers
909 available in the WFB file for General MIDI, and so these
910 can always be reset if needed. The sample data, however,
911 cannot be recovered without a complete reset and firmware
912 reload of the ICS2115, which is a very expensive operation.
913
914 So, doing things this way allows us to honor the notion of
915 "RESETSAMPLES" reasonably cheaply. Note however, that this
916 is done purely at user level: there is no WFB parser in
917 this driver, and so a complete reset (back to General MIDI,
918 or theoretically some other configuration) is the
919 responsibility of the user level library.
920
921 To try to do this in the kernel would be a little
922 crazy: we'd need 158K of kernel space just to hold
923 a copy of the patch/program/sample header data.
924 */
925
926 if (dev->rom_samples_rdonly) {
927 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
928 snd_printk ("sample slot %d "
929 "write protected\n",
930 header->number);
931 return -EACCES;
932 }
933 }
934
935 wavefront_delete_sample (dev, header->number);
936 }
937
938 if (header->size) {
939 dev->freemem = wavefront_freemem (dev);
940
941 if (dev->freemem < (int)header->size) {
942 snd_printk ("insufficient memory to "
943 "load %d byte sample.\n",
944 header->size);
945 return -ENOMEM;
946 }
947
948 }
949
950 skip = WF_GET_CHANNEL(&header->hdr.s);
951
952 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
953 snd_printk ("channel selection only "
954 "possible on 16-bit samples");
955 return -EINVAL;
956 }
957
958 switch (skip) {
959 case 0:
960 initial_skip = 0;
961 skip = 1;
962 break;
963 case 1:
964 initial_skip = 0;
965 skip = 2;
966 break;
967 case 2:
968 initial_skip = 1;
969 skip = 2;
970 break;
971 case 3:
972 initial_skip = 2;
973 skip = 3;
974 break;
975 case 4:
976 initial_skip = 3;
977 skip = 4;
978 break;
979 case 5:
980 initial_skip = 4;
981 skip = 5;
982 break;
983 case 6:
984 initial_skip = 5;
985 skip = 6;
986 break;
987 }
988
989 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
990 "initial skip = %d, skip = %d\n",
991 WF_GET_CHANNEL (&header->hdr.s),
992 initial_skip, skip);
993
994 /* Be safe, and zero the "Unused" bits ... */
995
996 WF_SET_CHANNEL(&header->hdr.s, 0);
997
998 /* adjust size for 16 bit samples by dividing by two. We always
999 send 16 bits per write, even for 8 bit samples, so the length
1000 is always half the size of the sample data in bytes.
1001 */
1002
1003 length = header->size / 2;
1004
1005 /* the data we're sent has not been munged, and in fact, the
1006 header we have to send isn't just a munged copy either.
1007 so, build the sample header right here.
1008 */
1009
1010 shptr = &sample_hdr[0];
1011
1012 shptr = munge_int32 (header->number, shptr, 2);
1013
1014 if (header->size) {
1015 shptr = munge_int32 (length, shptr, 4);
1016 }
1017
1018 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1019 but the offset only uses 24 bits.
1020 */
1021
1022 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1023 shptr, 4);
1024 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1025 shptr, 4);
1026 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1027 shptr, 4);
1028 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1029 shptr, 4);
1030
1031 /* This one is truly weird. What kind of weirdo decided that in
1032 a system dominated by 16 and 32 bit integers, they would use
1033 a just 12 bits ?
1034 */
1035
1036 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1037
1038 /* Why is this nybblified, when the MSB is *always* zero ?
1039 Anyway, we can't take address of bitfield, so make a
1040 good-faith guess at where it starts.
1041 */
1042
1043 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1044 shptr, 2);
1045
1046 if (snd_wavefront_cmd (dev,
1047 header->size ?
1048 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1049 NULL, sample_hdr)) {
1050 snd_printk ("sample %sdownload refused.\n",
1051 header->size ? "" : "header ");
1052 return -EIO;
1053 }
1054
1055 if (header->size == 0) {
1056 goto sent; /* Sorry. Just had to have one somewhere */
1057 }
1058
1059 data_end = dataptr + length;
1060
1061 /* Do any initial skip over an unused channel's data */
1062
1063 dataptr += initial_skip;
1064
1065 for (written = 0, blocknum = 0;
1066 written < length; written += max_blksize, blocknum++) {
1067
1068 if ((length - written) > max_blksize) {
1069 blocksize = max_blksize;
1070 } else {
1071 /* round to nearest 16-byte value */
1072 blocksize = ALIGN(length - written, 8);
1073 }
1074
1075 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1076 snd_printk ("download block "
1077 "request refused.\n");
1078 return -EIO;
1079 }
1080
1081 for (i = 0; i < blocksize; i++) {
1082
1083 if (dataptr < data_end) {
1084
1085 __get_user (sample_short, dataptr);
1086 dataptr += skip;
1087
1088 if (data_is_unsigned) { /* GUS ? */
1089
1090 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1091
1092 /* 8 bit sample
1093 resolution, sign
1094 extend both bytes.
1095 */
1096
1097 ((unsigned char*)
1098 &sample_short)[0] += 0x7f;
1099 ((unsigned char*)
1100 &sample_short)[1] += 0x7f;
1101
1102 } else {
1103
1104 /* 16 bit sample
1105 resolution, sign
1106 extend the MSB.
1107 */
1108
1109 sample_short += 0x7fff;
1110 }
1111 }
1112
1113 } else {
1114
1115 /* In padding section of final block:
1116
1117 Don't fetch unsupplied data from
1118 user space, just continue with
1119 whatever the final value was.
1120 */
1121 }
1122
1123 if (i < blocksize - 1) {
1124 outw (sample_short, dev->block_port);
1125 } else {
1126 outw (sample_short, dev->last_block_port);
1127 }
1128 }
1129
1130 /* Get "DMA page acknowledge", even though its really
1131 nothing to do with DMA at all.
1132 */
1133
1134 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1135 if (dma_ack == -1) {
1136 snd_printk ("upload sample "
1137 "DMA ack timeout\n");
1138 return -EIO;
1139 } else {
1140 snd_printk ("upload sample "
1141 "DMA ack error 0x%x\n",
1142 dma_ack);
1143 return -EIO;
1144 }
1145 }
1146 }
1147
1148 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1149
1150 /* Note, label is here because sending the sample header shouldn't
1151 alter the sample_status info at all.
1152 */
1153
1154 sent:
1155 return (0);
1156}
1157
1158static int
1159wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1160
1161{
1162 unsigned char alias_hdr[WF_ALIAS_BYTES];
1163
1164 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1165 "alias for %d\n",
1166 header->number,
1167 header->hdr.a.OriginalSample);
1168
1169 munge_int32 (header->number, &alias_hdr[0], 2);
1170 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1171 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1172 &alias_hdr[4], 4);
1173 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1174 &alias_hdr[8], 4);
1175 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1176 &alias_hdr[12], 4);
1177 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1178 &alias_hdr[16], 4);
1179 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1180 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1181
1182 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1183 snd_printk ("download alias failed.\n");
1184 return -EIO;
1185 }
1186
1187 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1188
1189 return (0);
1190}
1191
1192static int
1193wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1194{
1195 int i;
1196 int num_samples;
1197 unsigned char *msample_hdr;
1198
1199 msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1200 if (! msample_hdr)
1201 return -ENOMEM;
1202
1203 munge_int32 (header->number, &msample_hdr[0], 2);
1204
1205 /* You'll recall at this point that the "number of samples" value
1206 in a wavefront_multisample struct is actually the log2 of the
1207 real number of samples.
1208 */
1209
1210 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1211 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1212
1213 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1214 header->number,
1215 header->hdr.ms.NumberOfSamples,
1216 num_samples);
1217
1218 for (i = 0; i < num_samples; i++) {
1219 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1220 i, header->hdr.ms.SampleNumber[i]);
1221 munge_int32 (header->hdr.ms.SampleNumber[i],
1222 &msample_hdr[3+(i*2)], 2);
1223 }
1224
1225 /* Need a hack here to pass in the number of bytes
1226 to be written to the synth. This is ugly, and perhaps
1227 one day, I'll fix it.
1228 */
1229
1230 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1231 (unsigned char *) (long) ((num_samples*2)+3),
1232 msample_hdr)) {
1233 snd_printk ("download of multisample failed.\n");
1234 kfree(msample_hdr);
1235 return -EIO;
1236 }
1237
1238 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1239
1240 kfree(msample_hdr);
1241 return (0);
1242}
1243
1244static int
1245wavefront_fetch_multisample (snd_wavefront_t *dev,
1246 wavefront_patch_info *header)
1247{
1248 int i;
1249 unsigned char log_ns[1];
1250 unsigned char number[2];
1251 int num_samples;
1252
1253 munge_int32 (header->number, number, 2);
1254
1255 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1256 snd_printk ("upload multisample failed.\n");
1257 return -EIO;
1258 }
1259
1260 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1261 header->number, log_ns[0]);
1262
1263 header->hdr.ms.NumberOfSamples = log_ns[0];
1264
1265 /* get the number of samples ... */
1266
1267 num_samples = (1 << log_ns[0]);
1268
1269 for (i = 0; i < num_samples; i++) {
1270 char d[2];
1271 int val;
1272
1273 if ((val = wavefront_read (dev)) == -1) {
1274 snd_printk ("upload multisample failed "
1275 "during sample loop.\n");
1276 return -EIO;
1277 }
1278 d[0] = val;
1279
1280 if ((val = wavefront_read (dev)) == -1) {
1281 snd_printk ("upload multisample failed "
1282 "during sample loop.\n");
1283 return -EIO;
1284 }
1285 d[1] = val;
1286
1287 header->hdr.ms.SampleNumber[i] =
1288 demunge_int32 ((unsigned char *) d, 2);
1289
1290 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1291 i, header->hdr.ms.SampleNumber[i]);
1292 }
1293
1294 return (0);
1295}
1296
1297
1298static int
1299wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1300
1301{
1302 unsigned char drumbuf[WF_DRUM_BYTES];
1303 wavefront_drum *drum = &header->hdr.d;
1304 int i;
1305
1306 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1307 "note %d, patch = %d\n",
1308 header->number, drum->PatchNumber);
1309
1310 drumbuf[0] = header->number & 0x7f;
1311
1312 for (i = 0; i < 4; i++) {
1313 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1314 }
1315
1316 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1317 snd_printk ("download drum failed.\n");
1318 return -EIO;
1319 }
1320
1321 return (0);
1322}
1323
1324static int
1325wavefront_find_free_sample (snd_wavefront_t *dev)
1326
1327{
1328 int i;
1329
1330 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1331 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1332 return i;
1333 }
1334 }
1335 snd_printk ("no free sample slots!\n");
1336 return -1;
1337}
1338
1339#if 0
1340static int
1341wavefront_find_free_patch (snd_wavefront_t *dev)
1342
1343{
1344 int i;
1345
1346 for (i = 0; i < WF_MAX_PATCH; i++) {
1347 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1348 return i;
1349 }
1350 }
1351 snd_printk ("no free patch slots!\n");
1352 return -1;
1353}
1354#endif
1355
1356static int
1357wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1358{
1359 wavefront_patch_info *header;
1360 int err;
1361
1362 header = kmalloc(sizeof(*header), GFP_KERNEL);
1363 if (! header)
1364 return -ENOMEM;
1365
1366 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1367 sizeof(wavefront_any))) {
1368 snd_printk ("bad address for load patch.\n");
1369 err = -EFAULT;
1370 goto __error;
1371 }
1372
1373 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1374 "Sample type: %d "
1375 "Sample number: %d "
1376 "Sample size: %d\n",
1377 header->subkey,
1378 header->number,
1379 header->size);
1380
1381 switch (header->subkey) {
1382 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1383
1384 if (copy_from_user (&header->hdr.s, header->hdrptr,
1385 sizeof (wavefront_sample))) {
1386 err = -EFAULT;
1387 break;
1388 }
1389
1390 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1391 break;
1392
1393 case WF_ST_MULTISAMPLE:
1394
1395 if (copy_from_user (&header->hdr.s, header->hdrptr,
1396 sizeof (wavefront_multisample))) {
1397 err = -EFAULT;
1398 break;
1399 }
1400
1401 err = wavefront_send_multisample (dev, header);
1402 break;
1403
1404 case WF_ST_ALIAS:
1405
1406 if (copy_from_user (&header->hdr.a, header->hdrptr,
1407 sizeof (wavefront_alias))) {
1408 err = -EFAULT;
1409 break;
1410 }
1411
1412 err = wavefront_send_alias (dev, header);
1413 break;
1414
1415 case WF_ST_DRUM:
1416 if (copy_from_user (&header->hdr.d, header->hdrptr,
1417 sizeof (wavefront_drum))) {
1418 err = -EFAULT;
1419 break;
1420 }
1421
1422 err = wavefront_send_drum (dev, header);
1423 break;
1424
1425 case WF_ST_PATCH:
1426 if (copy_from_user (&header->hdr.p, header->hdrptr,
1427 sizeof (wavefront_patch))) {
1428 err = -EFAULT;
1429 break;
1430 }
1431
1432 err = wavefront_send_patch (dev, header);
1433 break;
1434
1435 case WF_ST_PROGRAM:
1436 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1437 sizeof (wavefront_program))) {
1438 err = -EFAULT;
1439 break;
1440 }
1441
1442 err = wavefront_send_program (dev, header);
1443 break;
1444
1445 default:
1446 snd_printk ("unknown patch type %d.\n",
1447 header->subkey);
1448 err = -EINVAL;
1449 break;
1450 }
1451
1452 __error:
1453 kfree(header);
1454 return err;
1455}
1456
1457/***********************************************************************
1458WaveFront: hardware-dependent interface
1459***********************************************************************/
1460
1461static void
1462process_sample_hdr (u8 *buf)
1463
1464{
1465 wavefront_sample s;
1466 u8 *ptr;
1467
1468 ptr = buf;
1469
1470 /* The board doesn't send us an exact copy of a "wavefront_sample"
1471 in response to an Upload Sample Header command. Instead, we
1472 have to convert the data format back into our data structure,
1473 just as in the Download Sample command, where we have to do
1474 something very similar in the reverse direction.
1475 */
1476
1477 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1478 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1479 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1480 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1481 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1482
1483 s.SampleResolution = *ptr & 0x3;
1484 s.Loop = *ptr & 0x8;
1485 s.Bidirectional = *ptr & 0x10;
1486 s.Reverse = *ptr & 0x40;
1487
1488 /* Now copy it back to where it came from */
1489
1490 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1491}
1492
1493static int
1494wavefront_synth_control (snd_wavefront_card_t *acard,
1495 wavefront_control *wc)
1496
1497{
1498 snd_wavefront_t *dev = &acard->wavefront;
1499 unsigned char patchnumbuf[2];
1500 int i;
1501
1502 DPRINT (WF_DEBUG_CMD, "synth control with "
1503 "cmd 0x%x\n", wc->cmd);
1504
1505 /* Pre-handling of or for various commands */
1506
1507 switch (wc->cmd) {
1508
1509 case WFC_DISABLE_INTERRUPTS:
1510 snd_printk ("interrupts disabled.\n");
1511 outb (0x80|0x20, dev->control_port);
1512 dev->interrupts_are_midi = 1;
1513 return 0;
1514
1515 case WFC_ENABLE_INTERRUPTS:
1516 snd_printk ("interrupts enabled.\n");
1517 outb (0x80|0x40|0x20, dev->control_port);
1518 dev->interrupts_are_midi = 1;
1519 return 0;
1520
1521 case WFC_INTERRUPT_STATUS:
1522 wc->rbuf[0] = dev->interrupts_are_midi;
1523 return 0;
1524
1525 case WFC_ROMSAMPLES_RDONLY:
1526 dev->rom_samples_rdonly = wc->wbuf[0];
1527 wc->status = 0;
1528 return 0;
1529
1530 case WFC_IDENTIFY_SLOT_TYPE:
1531 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1532 if (i <0 || i >= WF_MAX_SAMPLE) {
1533 snd_printk ("invalid slot ID %d\n",
1534 i);
1535 wc->status = EINVAL;
1536 return -EINVAL;
1537 }
1538 wc->rbuf[0] = dev->sample_status[i];
1539 wc->status = 0;
1540 return 0;
1541
1542 case WFC_DEBUG_DRIVER:
1543 dev->debug = wc->wbuf[0];
1544 snd_printk ("debug = 0x%x\n", dev->debug);
1545 return 0;
1546
1547 case WFC_UPLOAD_PATCH:
1548 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1549 memcpy (wc->wbuf, patchnumbuf, 2);
1550 break;
1551
1552 case WFC_UPLOAD_MULTISAMPLE:
1553 /* multisamples have to be handled differently, and
1554 cannot be dealt with properly by snd_wavefront_cmd() alone.
1555 */
1556 wc->status = wavefront_fetch_multisample
1557 (dev, (wavefront_patch_info *) wc->rbuf);
1558 return 0;
1559
1560 case WFC_UPLOAD_SAMPLE_ALIAS:
1561 snd_printk ("support for sample alias upload "
1562 "being considered.\n");
1563 wc->status = EINVAL;
1564 return -EINVAL;
1565 }
1566
1567 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1568
1569 /* Post-handling of certain commands.
1570
1571 In particular, if the command was an upload, demunge the data
1572 so that the user-level doesn't have to think about it.
1573 */
1574
1575 if (wc->status == 0) {
1576 switch (wc->cmd) {
1577 /* intercept any freemem requests so that we know
1578 we are always current with the user-level view
1579 of things.
1580 */
1581
1582 case WFC_REPORT_FREE_MEMORY:
1583 dev->freemem = demunge_int32 (wc->rbuf, 4);
1584 break;
1585
1586 case WFC_UPLOAD_PATCH:
1587 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1588 break;
1589
1590 case WFC_UPLOAD_PROGRAM:
1591 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1592 break;
1593
1594 case WFC_UPLOAD_EDRUM_PROGRAM:
1595 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1596 break;
1597
1598 case WFC_UPLOAD_SAMPLE_HEADER:
1599 process_sample_hdr (wc->rbuf);
1600 break;
1601
1602 case WFC_UPLOAD_SAMPLE_ALIAS:
1603 snd_printk ("support for "
1604 "sample aliases still "
1605 "being considered.\n");
1606 break;
1607
1608 case WFC_VMIDI_OFF:
1609 snd_wavefront_midi_disable_virtual (acard);
1610 break;
1611
1612 case WFC_VMIDI_ON:
1613 snd_wavefront_midi_enable_virtual (acard);
1614 break;
1615 }
1616 }
1617
1618 return 0;
1619}
1620
1621int
1622snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1623
1624{
1625 if (!try_module_get(hw->card->module))
1626 return -EFAULT;
1627 file->private_data = hw;
1628 return 0;
1629}
1630
1631int
1632snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1633
1634{
1635 module_put(hw->card->module);
1636 return 0;
1637}
1638
1639int
1640snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1641 unsigned int cmd, unsigned long arg)
1642
1643{
1644 struct snd_card *card;
1645 snd_wavefront_t *dev;
1646 snd_wavefront_card_t *acard;
1647 wavefront_control *wc;
1648 void __user *argp = (void __user *)arg;
1649 int err;
1650
1651 card = (struct snd_card *) hw->card;
1652
1653 if (snd_BUG_ON(!card))
1654 return -ENODEV;
1655 if (snd_BUG_ON(!card->private_data))
1656 return -ENODEV;
1657
1658 acard = card->private_data;
1659 dev = &acard->wavefront;
1660
1661 switch (cmd) {
1662 case WFCTL_LOAD_SPP:
1663 if (wavefront_load_patch (dev, argp) != 0) {
1664 return -EIO;
1665 }
1666 break;
1667
1668 case WFCTL_WFCMD:
1669 wc = memdup_user(argp, sizeof(*wc));
1670 if (IS_ERR(wc))
1671 return PTR_ERR(wc);
1672
1673 if (wavefront_synth_control (acard, wc) < 0)
1674 err = -EIO;
1675 else if (copy_to_user (argp, wc, sizeof (*wc)))
1676 err = -EFAULT;
1677 else
1678 err = 0;
1679 kfree(wc);
1680 return err;
1681
1682 default:
1683 return -EINVAL;
1684 }
1685
1686 return 0;
1687}
1688
1689
1690/***********************************************************************/
1691/* WaveFront: interface for card-level wavefront module */
1692/***********************************************************************/
1693
1694void
1695snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1696{
1697 snd_wavefront_t *dev = &card->wavefront;
1698
1699 /*
1700 Some comments on interrupts. I attempted a version of this
1701 driver that used interrupts throughout the code instead of
1702 doing busy and/or sleep-waiting. Alas, it appears that once
1703 the Motorola firmware is downloaded, the card *never*
1704 generates an RX interrupt. These are successfully generated
1705 during firmware loading, and after that wavefront_status()
1706 reports that an interrupt is pending on the card from time
1707 to time, but it never seems to be delivered to this
1708 driver. Note also that wavefront_status() continues to
1709 report that RX interrupts are enabled, suggesting that I
1710 didn't goof up and disable them by mistake.
1711
1712 Thus, I stepped back to a prior version of
1713 wavefront_wait(), the only place where this really
1714 matters. Its sad, but I've looked through the code to check
1715 on things, and I really feel certain that the Motorola
1716 firmware prevents RX-ready interrupts.
1717 */
1718
1719 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1720 return;
1721 }
1722
1723 spin_lock(&dev->irq_lock);
1724 dev->irq_ok = 1;
1725 dev->irq_cnt++;
1726 spin_unlock(&dev->irq_lock);
1727 wake_up(&dev->interrupt_sleeper);
1728}
1729
1730/* STATUS REGISTER
1731
17320 Host Rx Interrupt Enable (1=Enabled)
17331 Host Rx Register Full (1=Full)
17342 Host Rx Interrupt Pending (1=Interrupt)
17353 Unused
17364 Host Tx Interrupt (1=Enabled)
17375 Host Tx Register empty (1=Empty)
17386 Host Tx Interrupt Pending (1=Interrupt)
17397 Unused
1740*/
1741
1742static int
1743snd_wavefront_interrupt_bits (int irq)
1744
1745{
1746 int bits;
1747
1748 switch (irq) {
1749 case 9:
1750 bits = 0x00;
1751 break;
1752 case 5:
1753 bits = 0x08;
1754 break;
1755 case 12:
1756 bits = 0x10;
1757 break;
1758 case 15:
1759 bits = 0x18;
1760 break;
1761
1762 default:
1763 snd_printk ("invalid IRQ %d\n", irq);
1764 bits = -1;
1765 }
1766
1767 return bits;
1768}
1769
1770static void
1771wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1772 int val, int port, unsigned long timeout)
1773
1774{
1775 wait_queue_t wait;
1776
1777 init_waitqueue_entry(&wait, current);
1778 spin_lock_irq(&dev->irq_lock);
1779 add_wait_queue(&dev->interrupt_sleeper, &wait);
1780 dev->irq_ok = 0;
1781 outb (val,port);
1782 spin_unlock_irq(&dev->irq_lock);
1783 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1784 schedule_timeout_uninterruptible(1);
1785 barrier();
1786 }
1787}
1788
1789static int
1790wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1791
1792{
1793 int bits;
1794 int hwv[2];
1795
1796 /* IRQ already checked */
1797
1798 bits = snd_wavefront_interrupt_bits (dev->irq);
1799
1800 /* try reset of port */
1801
1802 outb (0x0, dev->control_port);
1803
1804 /* At this point, the board is in reset, and the H/W initialization
1805 register is accessed at the same address as the data port.
1806
1807 Bit 7 - Enable IRQ Driver
1808 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1809 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1810
1811 Bit 6 - MIDI Interface Select
1812
1813 0 - Use the MIDI Input from the 26-pin WaveBlaster
1814 compatible header as the serial MIDI source
1815 1 - Use the MIDI Input from the 9-pin D connector as the
1816 serial MIDI source.
1817
1818 Bits 5:3 - IRQ Selection
1819 0 0 0 - IRQ 2/9
1820 0 0 1 - IRQ 5
1821 0 1 0 - IRQ 12
1822 0 1 1 - IRQ 15
1823 1 0 0 - Reserved
1824 1 0 1 - Reserved
1825 1 1 0 - Reserved
1826 1 1 1 - Reserved
1827
1828 Bits 2:1 - Reserved
1829 Bit 0 - Disable Boot ROM
1830 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1831 1 - memory accesses to 03FC30-03FFFFH are directed to external
1832 storage.
1833
1834 */
1835
1836 /* configure hardware: IRQ, enable interrupts,
1837 plus external 9-pin MIDI interface selected
1838 */
1839
1840 outb (0x80 | 0x40 | bits, dev->data_port);
1841
1842 /* CONTROL REGISTER
1843
1844 0 Host Rx Interrupt Enable (1=Enabled) 0x1
1845 1 Unused 0x2
1846 2 Unused 0x4
1847 3 Unused 0x8
1848 4 Host Tx Interrupt Enable 0x10
1849 5 Mute (0=Mute; 1=Play) 0x20
1850 6 Master Interrupt Enable (1=Enabled) 0x40
1851 7 Master Reset (0=Reset; 1=Run) 0x80
1852
1853 Take us out of reset, mute output, master + TX + RX interrupts on.
1854
1855 We'll get an interrupt presumably to tell us that the TX
1856 register is clear.
1857 */
1858
1859 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1860 dev->control_port,
1861 (reset_time*HZ)/100);
1862
1863 /* Note: data port is now the data port, not the h/w initialization
1864 port.
1865 */
1866
1867 if (!dev->irq_ok) {
1868 snd_printk ("intr not received after h/w un-reset.\n");
1869 goto gone_bad;
1870 }
1871
1872 /* Note: data port is now the data port, not the h/w initialization
1873 port.
1874
1875 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1876 will work. So, issue one of them, and wait for TX
1877 interrupt. This can take a *long* time after a cold boot,
1878 while the ISC ROM does its RAM test. The SDK says up to 4
1879 seconds - with 12MB of RAM on a Tropez+, it takes a lot
1880 longer than that (~16secs). Note that the card understands
1881 the difference between a warm and a cold boot, so
1882 subsequent ISC2115 reboots (say, caused by module
1883 reloading) will get through this much faster.
1884
1885 XXX Interesting question: why is no RX interrupt received first ?
1886 */
1887
1888 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1889 dev->data_port, ramcheck_time*HZ);
1890
1891 if (!dev->irq_ok) {
1892 snd_printk ("post-RAM-check interrupt not received.\n");
1893 goto gone_bad;
1894 }
1895
1896 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1897 snd_printk ("no response to HW version cmd.\n");
1898 goto gone_bad;
1899 }
1900
1901 if ((hwv[0] = wavefront_read (dev)) == -1) {
1902 snd_printk ("board not responding correctly.\n");
1903 goto gone_bad;
1904 }
1905
1906 if (hwv[0] == 0xFF) { /* NAK */
1907
1908 /* Board's RAM test failed. Try to read error code,
1909 and tell us about it either way.
1910 */
1911
1912 if ((hwv[0] = wavefront_read (dev)) == -1) {
1913 snd_printk ("on-board RAM test failed "
1914 "(bad error code).\n");
1915 } else {
1916 snd_printk ("on-board RAM test failed "
1917 "(error code: 0x%x).\n",
1918 hwv[0]);
1919 }
1920 goto gone_bad;
1921 }
1922
1923 /* We're OK, just get the next byte of the HW version response */
1924
1925 if ((hwv[1] = wavefront_read (dev)) == -1) {
1926 snd_printk ("incorrect h/w response.\n");
1927 goto gone_bad;
1928 }
1929
1930 snd_printk ("hardware version %d.%d\n",
1931 hwv[0], hwv[1]);
1932
1933 return 0;
1934
1935
1936 gone_bad:
1937 return (1);
1938}
1939
1940static int
1941wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1942
1943{
1944 const unsigned char *buf;
1945 int len, err;
1946 int section_cnt_downloaded = 0;
1947 const struct firmware *firmware;
1948
1949 err = request_firmware(&firmware, path, dev->card->dev);
1950 if (err < 0) {
1951 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1952 return 1;
1953 }
1954
1955 len = 0;
1956 buf = firmware->data;
1957 for (;;) {
1958 int section_length = *(signed char *)buf;
1959 if (section_length == 0)
1960 break;
1961 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1962 snd_printk(KERN_ERR
1963 "invalid firmware section length %d\n",
1964 section_length);
1965 goto failure;
1966 }
1967 buf++;
1968 len++;
1969
1970 if (firmware->size < len + section_length) {
1971 snd_printk(KERN_ERR "firmware section read error.\n");
1972 goto failure;
1973 }
1974
1975 /* Send command */
1976 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1977 goto failure;
1978
1979 for (; section_length; section_length--) {
1980 if (wavefront_write(dev, *buf))
1981 goto failure;
1982 buf++;
1983 len++;
1984 }
1985
1986 /* get ACK */
1987 if (!wavefront_wait(dev, STAT_CAN_READ)) {
1988 snd_printk(KERN_ERR "time out for firmware ACK.\n");
1989 goto failure;
1990 }
1991 err = inb(dev->data_port);
1992 if (err != WF_ACK) {
1993 snd_printk(KERN_ERR
1994 "download of section #%d not "
1995 "acknowledged, ack = 0x%x\n",
1996 section_cnt_downloaded + 1, err);
1997 goto failure;
1998 }
1999
2000 section_cnt_downloaded++;
2001 }
2002
2003 release_firmware(firmware);
2004 return 0;
2005
2006 failure:
2007 release_firmware(firmware);
2008 snd_printk(KERN_ERR "firmware download failed!!!\n");
2009 return 1;
2010}
2011
2012
2013static int
2014wavefront_do_reset (snd_wavefront_t *dev)
2015
2016{
2017 char voices[1];
2018
2019 if (wavefront_reset_to_cleanliness (dev)) {
2020 snd_printk ("hw reset failed.\n");
2021 goto gone_bad;
2022 }
2023
2024 if (dev->israw) {
2025 if (wavefront_download_firmware (dev, ospath)) {
2026 goto gone_bad;
2027 }
2028
2029 dev->israw = 0;
2030
2031 /* Wait for the OS to get running. The protocol for
2032 this is non-obvious, and was determined by
2033 using port-IO tracing in DOSemu and some
2034 experimentation here.
2035
2036 Rather than using timed waits, use interrupts creatively.
2037 */
2038
2039 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2040 dev->data_port,
2041 (osrun_time*HZ));
2042
2043 if (!dev->irq_ok) {
2044 snd_printk ("no post-OS interrupt.\n");
2045 goto gone_bad;
2046 }
2047
2048 /* Now, do it again ! */
2049
2050 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2051 dev->data_port, (10*HZ));
2052
2053 if (!dev->irq_ok) {
2054 snd_printk ("no post-OS interrupt(2).\n");
2055 goto gone_bad;
2056 }
2057
2058 /* OK, no (RX/TX) interrupts any more, but leave mute
2059 in effect.
2060 */
2061
2062 outb (0x80|0x40, dev->control_port);
2063 }
2064
2065 /* SETUPSND.EXE asks for sample memory config here, but since i
2066 have no idea how to interpret the result, we'll forget
2067 about it.
2068 */
2069
2070 if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2071 goto gone_bad;
2072 }
2073
2074 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2075
2076 if (wavefront_write (dev, 0xf0) ||
2077 wavefront_write (dev, 1) ||
2078 (wavefront_read (dev) < 0)) {
2079 dev->debug = 0;
2080 snd_printk ("MPU emulation mode not set.\n");
2081 goto gone_bad;
2082 }
2083
2084 voices[0] = 32;
2085
2086 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2087 snd_printk ("cannot set number of voices to 32.\n");
2088 goto gone_bad;
2089 }
2090
2091
2092 return 0;
2093
2094 gone_bad:
2095 /* reset that sucker so that it doesn't bother us. */
2096
2097 outb (0x0, dev->control_port);
2098 dev->interrupts_are_midi = 0;
2099 return 1;
2100}
2101
2102int
2103snd_wavefront_start (snd_wavefront_t *dev)
2104
2105{
2106 int samples_are_from_rom;
2107
2108 /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2109 wavefront_reset_to_cleanliness() has already been called
2110 */
2111
2112 if (dev->israw) {
2113 samples_are_from_rom = 1;
2114 } else {
2115 /* XXX is this always true ? */
2116 samples_are_from_rom = 0;
2117 }
2118
2119 if (dev->israw || fx_raw) {
2120 if (wavefront_do_reset (dev)) {
2121 return -1;
2122 }
2123 }
2124 /* Check for FX device, present only on Tropez+ */
2125
2126 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2127
2128 if (dev->has_fx && fx_raw) {
2129 snd_wavefront_fx_start (dev);
2130 }
2131
2132 wavefront_get_sample_status (dev, samples_are_from_rom);
2133 wavefront_get_program_status (dev);
2134 wavefront_get_patch_status (dev);
2135
2136 /* Start normal operation: unreset, master interrupt enabled, no mute
2137 */
2138
2139 outb (0x80|0x40|0x20, dev->control_port);
2140
2141 return (0);
2142}
2143
2144int
2145snd_wavefront_detect (snd_wavefront_card_t *card)
2146
2147{
2148 unsigned char rbuf[4], wbuf[4];
2149 snd_wavefront_t *dev = &card->wavefront;
2150
2151 /* returns zero if a WaveFront card is successfully detected.
2152 negative otherwise.
2153 */
2154
2155 dev->israw = 0;
2156 dev->has_fx = 0;
2157 dev->debug = debug_default;
2158 dev->interrupts_are_midi = 0;
2159 dev->irq_cnt = 0;
2160 dev->rom_samples_rdonly = 1;
2161
2162 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2163
2164 dev->fw_version[0] = rbuf[0];
2165 dev->fw_version[1] = rbuf[1];
2166
2167 snd_printk ("firmware %d.%d already loaded.\n",
2168 rbuf[0], rbuf[1]);
2169
2170 /* check that a command actually works */
2171
2172 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2173 rbuf, wbuf) == 0) {
2174 dev->hw_version[0] = rbuf[0];
2175 dev->hw_version[1] = rbuf[1];
2176 } else {
2177 snd_printk ("not raw, but no "
2178 "hardware version!\n");
2179 return -1;
2180 }
2181
2182 if (!wf_raw) {
2183 return 0;
2184 } else {
2185 snd_printk ("reloading firmware as you requested.\n");
2186 dev->israw = 1;
2187 }
2188
2189 } else {
2190
2191 dev->israw = 1;
2192 snd_printk ("no response to firmware probe, assume raw.\n");
2193
2194 }
2195
2196 return 0;
2197}
2198
2199MODULE_FIRMWARE(DEFAULT_OSPATH);
1// SPDX-License-Identifier: GPL-2.0-only
2/* Copyright (C) by Paul Barton-Davis 1998-1999
3 *
4 * Some portions of this file are taken from work that is
5 * copyright (C) by Hannu Savolainen 1993-1996
6 */
7
8/*
9 * An ALSA lowlevel driver for Turtle Beach ICS2115 wavetable synth
10 * (Maui, Tropez, Tropez Plus)
11 *
12 * This driver supports the onboard wavetable synthesizer (an ICS2115),
13 * including patch, sample and program loading and unloading, conversion
14 * of GUS patches during loading, and full user-level access to all
15 * WaveFront commands. It tries to provide semi-intelligent patch and
16 * sample management as well.
17 *
18 */
19
20#include <linux/io.h>
21#include <linux/interrupt.h>
22#include <linux/init.h>
23#include <linux/delay.h>
24#include <linux/time.h>
25#include <linux/wait.h>
26#include <linux/sched/signal.h>
27#include <linux/firmware.h>
28#include <linux/moduleparam.h>
29#include <linux/slab.h>
30#include <linux/module.h>
31#include <sound/core.h>
32#include <sound/snd_wavefront.h>
33#include <sound/initval.h>
34
35static int wf_raw = 0; /* we normally check for "raw state" to firmware
36 loading. if non-zero, then during driver loading, the
37 state of the board is ignored, and we reset the
38 board and load the firmware anyway.
39 */
40
41static int fx_raw = 1; /* if this is zero, we'll leave the FX processor in
42 whatever state it is when the driver is loaded.
43 The default is to download the microprogram and
44 associated coefficients to set it up for "default"
45 operation, whatever that means.
46 */
47
48static int debug_default = 0; /* you can set this to control debugging
49 during driver loading. it takes any combination
50 of the WF_DEBUG_* flags defined in
51 wavefront.h
52 */
53
54/* XXX this needs to be made firmware and hardware version dependent */
55
56#define DEFAULT_OSPATH "wavefront.os"
57static char *ospath = DEFAULT_OSPATH; /* the firmware file name */
58
59static int wait_usecs = 150; /* This magic number seems to give pretty optimal
60 throughput based on my limited experimentation.
61 If you want to play around with it and find a better
62 value, be my guest. Remember, the idea is to
63 get a number that causes us to just busy wait
64 for as many WaveFront commands as possible, without
65 coming up with a number so large that we hog the
66 whole CPU.
67
68 Specifically, with this number, out of about 134,000
69 status waits, only about 250 result in a sleep.
70 */
71
72static int sleep_interval = 100; /* HZ/sleep_interval seconds per sleep */
73static int sleep_tries = 50; /* number of times we'll try to sleep */
74
75static int reset_time = 2; /* hundreths of a second we wait after a HW
76 reset for the expected interrupt.
77 */
78
79static int ramcheck_time = 20; /* time in seconds to wait while ROM code
80 checks on-board RAM.
81 */
82
83static int osrun_time = 10; /* time in seconds we wait for the OS to
84 start running.
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/* if WF_DEBUG not defined, no run-time debugging messages will
108 be available via the debug flag setting. Given the current
109 beta state of the driver, this will remain set until a future
110 version.
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 /* WF_DEBUG */
124
125#define LOGNAME "WaveFront: "
126
127/* bitmasks for WaveFront status port value */
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 /* This command requires a variable number of bytes to be written.
193 There is a hack in snd_wavefront_cmd() to support this. The actual
194 count is passed in as the read buffer ptr, cast appropriately.
195 Ugh.
196 */
197
198 { WFC_DOWNLOAD_MULTISAMPLE, "download multisample", 0, 0, NEEDS_ACK },
199
200 /* This one is a hack as well. We just read the first byte of the
201 response, don't fetch an ACK, and leave the rest to the
202 calling function. Ugly, ugly, ugly.
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 /* Spin for a short period of time, because >99% of all
282 requests to the WaveFront can be serviced inline like this.
283 */
284
285 for (i = 0; i < wait_usecs; i += 5) {
286 if (wavefront_status (dev) & mask) {
287 return 1;
288 }
289 udelay(5);
290 }
291
292 for (i = 0; i < sleep_tries; i++) {
293
294 if (wavefront_status (dev) & mask) {
295 return 1;
296 }
297
298 if (wavefront_sleep (HZ/sleep_interval)) {
299 return (0);
300 }
301 }
302
303 return (0);
304}
305
306static int
307wavefront_read (snd_wavefront_t *dev)
308
309{
310 if (wavefront_wait (dev, STAT_CAN_READ))
311 return inb (dev->data_port);
312
313 DPRINT (WF_DEBUG_DATA, "read timeout.\n");
314
315 return -1;
316}
317
318static int
319wavefront_write (snd_wavefront_t *dev, unsigned char data)
320
321{
322 if (wavefront_wait (dev, STAT_CAN_WRITE)) {
323 outb (data, dev->data_port);
324 return 0;
325 }
326
327 DPRINT (WF_DEBUG_DATA, "write timeout.\n");
328
329 return -1;
330}
331
332int
333snd_wavefront_cmd (snd_wavefront_t *dev,
334 int cmd, unsigned char *rbuf, unsigned char *wbuf)
335
336{
337 int ack;
338 unsigned int i;
339 int c;
340 struct wavefront_command *wfcmd;
341
342 wfcmd = wavefront_get_command(cmd);
343 if (!wfcmd) {
344 snd_printk ("command 0x%x not supported.\n",
345 cmd);
346 return 1;
347 }
348
349 /* Hack to handle the one variable-size write command. See
350 wavefront_send_multisample() for the other half of this
351 gross and ugly strategy.
352 */
353
354 if (cmd == WFC_DOWNLOAD_MULTISAMPLE) {
355 wfcmd->write_cnt = (unsigned long) rbuf;
356 rbuf = NULL;
357 }
358
359 DPRINT (WF_DEBUG_CMD, "0x%x [%s] (%d,%d,%d)\n",
360 cmd, wfcmd->action, wfcmd->read_cnt,
361 wfcmd->write_cnt, wfcmd->need_ack);
362
363 if (wavefront_write (dev, cmd)) {
364 DPRINT ((WF_DEBUG_IO|WF_DEBUG_CMD), "cannot request "
365 "0x%x [%s].\n",
366 cmd, wfcmd->action);
367 return 1;
368 }
369
370 if (wfcmd->write_cnt > 0) {
371 DPRINT (WF_DEBUG_DATA, "writing %d bytes "
372 "for 0x%x\n",
373 wfcmd->write_cnt, cmd);
374
375 for (i = 0; i < wfcmd->write_cnt; i++) {
376 if (wavefront_write (dev, wbuf[i])) {
377 DPRINT (WF_DEBUG_IO, "bad write for byte "
378 "%d of 0x%x [%s].\n",
379 i, cmd, wfcmd->action);
380 return 1;
381 }
382
383 DPRINT (WF_DEBUG_DATA, "write[%d] = 0x%x\n",
384 i, wbuf[i]);
385 }
386 }
387
388 if (wfcmd->read_cnt > 0) {
389 DPRINT (WF_DEBUG_DATA, "reading %d ints "
390 "for 0x%x\n",
391 wfcmd->read_cnt, cmd);
392
393 for (i = 0; i < wfcmd->read_cnt; i++) {
394
395 c = wavefront_read(dev);
396 if (c == -1) {
397 DPRINT (WF_DEBUG_IO, "bad read for byte "
398 "%d of 0x%x [%s].\n",
399 i, cmd, wfcmd->action);
400 return 1;
401 }
402
403 /* Now handle errors. Lots of special cases here */
404
405 if (c == 0xff) {
406 c = wavefront_read(dev);
407 if (c == -1) {
408 DPRINT (WF_DEBUG_IO, "bad read for "
409 "error byte at "
410 "read byte %d "
411 "of 0x%x [%s].\n",
412 i, cmd,
413 wfcmd->action);
414 return 1;
415 }
416
417 /* Can you believe this madness ? */
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 /* Some commands need an ACK, but return zero instead
462 of the standard value.
463 */
464
465 ack = wavefront_read(dev);
466 if (ack == 0)
467 ack = WF_ACK;
468
469 if (ack != WF_ACK) {
470 if (ack == -1) {
471 DPRINT (WF_DEBUG_IO, "cannot read ack for "
472 "0x%x [%s].\n",
473 cmd, wfcmd->action);
474 return 1;
475
476 } else {
477 int err = -1; /* something unknown */
478
479 if (ack == 0xff) { /* explicit error */
480
481 err = wavefront_read(dev);
482 if (err == -1) {
483 DPRINT (WF_DEBUG_DATA,
484 "cannot read err "
485 "for 0x%x [%s].\n",
486 cmd, wfcmd->action);
487 }
488 }
489
490 DPRINT (WF_DEBUG_IO, "0x%x [%s] "
491 "failed (0x%x, 0x%x, %s)\n",
492 cmd, wfcmd->action, ack, err,
493 wavefront_errorstr (err));
494
495 return -err;
496 }
497 }
498
499 DPRINT (WF_DEBUG_DATA, "ack received "
500 "for 0x%x [%s]\n",
501 cmd, wfcmd->action);
502 } else {
503
504 DPRINT (WF_DEBUG_CMD, "0x%x [%s] does not need "
505 "ACK (%d,%d,%d)\n",
506 cmd, wfcmd->action, wfcmd->read_cnt,
507 wfcmd->write_cnt, wfcmd->need_ack);
508 }
509
510 return 0;
511
512}
513
514/***********************************************************************
515WaveFront data munging
516
517Things here are weird. All data written to the board cannot
518have its most significant bit set. Any data item with values
519potentially > 0x7F (127) must be split across multiple bytes.
520
521Sometimes, we need to munge numeric values that are represented on
522the x86 side as 8-32 bit values. Sometimes, we need to munge data
523that is represented on the x86 side as an array of bytes. The most
524efficient approach to handling both cases seems to be to use 2
525different functions for munging and 2 for de-munging. This avoids
526weird casting and worrying about bit-level offsets.
527
528**********************************************************************/
529
530static unsigned char *
531munge_int32 (unsigned int src,
532 unsigned char *dst,
533 unsigned int dst_size)
534{
535 unsigned int i;
536
537 for (i = 0; i < dst_size; i++) {
538 *dst = src & 0x7F; /* Mask high bit of LSB */
539 src = src >> 7; /* Rotate Right 7 bits */
540 /* Note: we leave the upper bits in place */
541
542 dst++;
543 }
544 return dst;
545};
546
547static int
548demunge_int32 (unsigned char* src, int src_size)
549
550{
551 int i;
552 int outval = 0;
553
554 for (i = src_size - 1; i >= 0; i--) {
555 outval=(outval<<7)+src[i];
556 }
557
558 return outval;
559};
560
561static
562unsigned char *
563munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)
564
565{
566 unsigned int i;
567 unsigned int last = dst_size / 2;
568
569 for (i = 0; i < last; i++) {
570 *dst++ = src[i] & 0x7f;
571 *dst++ = src[i] >> 7;
572 }
573 return dst;
574}
575
576static
577unsigned char *
578demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
579
580{
581 int i;
582 unsigned char *end = src + src_bytes;
583
584 /* NOTE: src and dst *CAN* point to the same address */
585
586 for (i = 0; src != end; i++) {
587 dst[i] = *src++;
588 dst[i] |= (*src++)<<7;
589 }
590
591 return dst;
592}
593
594/***********************************************************************
595WaveFront: sample, patch and program management.
596***********************************************************************/
597
598static int
599wavefront_delete_sample (snd_wavefront_t *dev, int sample_num)
600
601{
602 unsigned char wbuf[2];
603 int x;
604
605 wbuf[0] = sample_num & 0x7f;
606 wbuf[1] = sample_num >> 7;
607
608 x = snd_wavefront_cmd(dev, WFC_DELETE_SAMPLE, NULL, wbuf);
609 if (!x)
610 dev->sample_status[sample_num] = WF_ST_EMPTY;
611
612 return x;
613}
614
615static int
616wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
617
618{
619 int i;
620 unsigned char rbuf[32], wbuf[32];
621 unsigned int sc_real, sc_alias, sc_multi;
622
623 /* check sample status */
624
625 if (snd_wavefront_cmd (dev, WFC_GET_NSAMPLES, rbuf, wbuf)) {
626 snd_printk ("cannot request sample count.\n");
627 return -1;
628 }
629
630 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
631
632 for (i = 0; i < WF_MAX_SAMPLE; i++) {
633
634 wbuf[0] = i & 0x7f;
635 wbuf[1] = i >> 7;
636
637 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
638 snd_printk(KERN_WARNING "cannot identify sample "
639 "type of slot %d\n", i);
640 dev->sample_status[i] = WF_ST_EMPTY;
641 continue;
642 }
643
644 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
645
646 if (assume_rom) {
647 dev->sample_status[i] |= WF_SLOT_ROM;
648 }
649
650 switch (rbuf[0] & WF_ST_MASK) {
651 case WF_ST_SAMPLE:
652 sc_real++;
653 break;
654 case WF_ST_MULTISAMPLE:
655 sc_multi++;
656 break;
657 case WF_ST_ALIAS:
658 sc_alias++;
659 break;
660 case WF_ST_EMPTY:
661 break;
662
663 default:
664 snd_printk ("unknown sample type for "
665 "slot %d (0x%x)\n",
666 i, rbuf[0]);
667 }
668
669 if (rbuf[0] != WF_ST_EMPTY) {
670 dev->samples_used++;
671 }
672 }
673
674 snd_printk ("%d samples used (%d real, %d aliases, %d multi), "
675 "%d empty\n", dev->samples_used, sc_real, sc_alias, sc_multi,
676 WF_MAX_SAMPLE - dev->samples_used);
677
678
679 return (0);
680
681}
682
683static int
684wavefront_get_patch_status (snd_wavefront_t *dev)
685
686{
687 unsigned char patchbuf[WF_PATCH_BYTES];
688 unsigned char patchnum[2];
689 wavefront_patch *p;
690 int i, x, cnt, cnt2;
691
692 for (i = 0; i < WF_MAX_PATCH; i++) {
693 patchnum[0] = i & 0x7f;
694 patchnum[1] = i >> 7;
695
696 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PATCH, patchbuf,
697 patchnum);
698 if (x == 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) { /* Bad patch number */
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 /* program status has already filled in slot_used bits */
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 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PROGRAM, progbuf,
745 &prognum);
746 if (x == 0) {
747
748 dev->prog_status[i] |= WF_SLOT_USED;
749
750 demunge_buf (progbuf, (unsigned char *) &prog,
751 WF_PROGRAM_BYTES);
752
753 for (l = 0; l < WF_NUM_LAYERS; l++) {
754 if (prog.layer[l].mute) {
755 dev->patch_status
756 [prog.layer[l].patch_number] |=
757 WF_SLOT_USED;
758 }
759 }
760 } else if (x == 1) { /* Bad program number */
761 dev->prog_status[i] = 0;
762 } else {
763 snd_printk ("upload program "
764 "error 0x%x\n", x);
765 dev->prog_status[i] = 0;
766 }
767 }
768
769 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
770 if (dev->prog_status[i]) {
771 cnt++;
772 }
773 }
774
775 snd_printk ("%d programs slots in use\n", cnt);
776
777 return (0);
778}
779
780static int
781wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
782
783{
784 unsigned char buf[WF_PATCH_BYTES+2];
785 unsigned char *bptr;
786
787 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
788 header->number);
789
790 if (header->number >= ARRAY_SIZE(dev->patch_status))
791 return -EINVAL;
792
793 dev->patch_status[header->number] |= WF_SLOT_FILLED;
794
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 /* XXX need to zero existing SLOT_USED bit for program_status[i]
822 where `i' is the program that's being (potentially) overwritten.
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 /* XXX need to mark SLOT_USED for sample used by
831 patch_number, but this means we have to load it. Ick.
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 /* samples are downloaded via a 16-bit wide i/o port
869 (you could think of it as 2 adjacent 8-bit wide ports
870 but its less efficient that way). therefore, all
871 the blocksizes and so forth listed in the documentation,
872 and used conventionally to refer to sample sizes,
873 which are given in 8-bit units (bytes), need to be
874 divided by 2.
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 x = wavefront_find_free_sample(dev);
902 if (x < 0)
903 return -ENOMEM;
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 /* XXX it's a debatable point whether or not RDONLY semantics
914 on the ROM samples should cover just the sample data or
915 the sample header. For now, it only covers the sample data,
916 so anyone is free at all times to rewrite sample headers.
917
918 My reason for this is that we have the sample headers
919 available in the WFB file for General MIDI, and so these
920 can always be reset if needed. The sample data, however,
921 cannot be recovered without a complete reset and firmware
922 reload of the ICS2115, which is a very expensive operation.
923
924 So, doing things this way allows us to honor the notion of
925 "RESETSAMPLES" reasonably cheaply. Note however, that this
926 is done purely at user level: there is no WFB parser in
927 this driver, and so a complete reset (back to General MIDI,
928 or theoretically some other configuration) is the
929 responsibility of the user level library.
930
931 To try to do this in the kernel would be a little
932 crazy: we'd need 158K of kernel space just to hold
933 a copy of the patch/program/sample header data.
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 /* Be safe, and zero the "Unused" bits ... */
1005
1006 WF_SET_CHANNEL(&header->hdr.s, 0);
1007
1008 /* adjust size for 16 bit samples by dividing by two. We always
1009 send 16 bits per write, even for 8 bit samples, so the length
1010 is always half the size of the sample data in bytes.
1011 */
1012
1013 length = header->size / 2;
1014
1015 /* the data we're sent has not been munged, and in fact, the
1016 header we have to send isn't just a munged copy either.
1017 so, build the sample header right here.
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 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1029 but the offset only uses 24 bits.
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 /* This one is truly weird. What kind of weirdo decided that in
1042 a system dominated by 16 and 32 bit integers, they would use
1043 a just 12 bits ?
1044 */
1045
1046 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1047
1048 /* Why is this nybblified, when the MSB is *always* zero ?
1049 Anyway, we can't take address of bitfield, so make a
1050 good-faith guess at where it starts.
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; /* Sorry. Just had to have one somewhere */
1067 }
1068
1069 data_end = dataptr + length;
1070
1071 /* Do any initial skip over an unused channel's data */
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 /* round to nearest 16-byte value */
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 if (get_user(sample_short, dataptr))
1096 return -EFAULT;
1097 dataptr += skip;
1098
1099 if (data_is_unsigned) { /* GUS ? */
1100
1101 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1102
1103 /* 8 bit sample
1104 resolution, sign
1105 extend both bytes.
1106 */
1107
1108 ((unsigned char*)
1109 &sample_short)[0] += 0x7f;
1110 ((unsigned char*)
1111 &sample_short)[1] += 0x7f;
1112
1113 } else {
1114
1115 /* 16 bit sample
1116 resolution, sign
1117 extend the MSB.
1118 */
1119
1120 sample_short += 0x7fff;
1121 }
1122 }
1123
1124 } else {
1125
1126 /* In padding section of final block:
1127
1128 Don't fetch unsupplied data from
1129 user space, just continue with
1130 whatever the final value was.
1131 */
1132 }
1133
1134 if (i < blocksize - 1) {
1135 outw (sample_short, dev->block_port);
1136 } else {
1137 outw (sample_short, dev->last_block_port);
1138 }
1139 }
1140
1141 /* Get "DMA page acknowledge", even though its really
1142 nothing to do with DMA at all.
1143 */
1144
1145 dma_ack = wavefront_read(dev);
1146 if (dma_ack != WF_DMA_ACK) {
1147 if (dma_ack == -1) {
1148 snd_printk ("upload sample "
1149 "DMA ack timeout\n");
1150 return -EIO;
1151 } else {
1152 snd_printk ("upload sample "
1153 "DMA ack error 0x%x\n",
1154 dma_ack);
1155 return -EIO;
1156 }
1157 }
1158 }
1159
1160 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1161
1162 /* Note, label is here because sending the sample header shouldn't
1163 alter the sample_status info at all.
1164 */
1165
1166 sent:
1167 return (0);
1168}
1169
1170static int
1171wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1172
1173{
1174 unsigned char alias_hdr[WF_ALIAS_BYTES];
1175
1176 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1177 "alias for %d\n",
1178 header->number,
1179 header->hdr.a.OriginalSample);
1180
1181 if (header->number >= WF_MAX_SAMPLE)
1182 return -EINVAL;
1183
1184 munge_int32 (header->number, &alias_hdr[0], 2);
1185 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1186 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1187 &alias_hdr[4], 4);
1188 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1189 &alias_hdr[8], 4);
1190 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1191 &alias_hdr[12], 4);
1192 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1193 &alias_hdr[16], 4);
1194 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1195 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1196
1197 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1198 snd_printk ("download alias failed.\n");
1199 return -EIO;
1200 }
1201
1202 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1203
1204 return (0);
1205}
1206
1207static int
1208wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1209{
1210 int i;
1211 int num_samples;
1212 unsigned char *msample_hdr;
1213
1214 if (header->number >= WF_MAX_SAMPLE)
1215 return -EINVAL;
1216
1217 msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1218 if (! msample_hdr)
1219 return -ENOMEM;
1220
1221 munge_int32 (header->number, &msample_hdr[0], 2);
1222
1223 /* You'll recall at this point that the "number of samples" value
1224 in a wavefront_multisample struct is actually the log2 of the
1225 real number of samples.
1226 */
1227
1228 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1229 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1230
1231 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1232 header->number,
1233 header->hdr.ms.NumberOfSamples,
1234 num_samples);
1235
1236 for (i = 0; i < num_samples; i++) {
1237 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1238 i, header->hdr.ms.SampleNumber[i]);
1239 munge_int32 (header->hdr.ms.SampleNumber[i],
1240 &msample_hdr[3+(i*2)], 2);
1241 }
1242
1243 /* Need a hack here to pass in the number of bytes
1244 to be written to the synth. This is ugly, and perhaps
1245 one day, I'll fix it.
1246 */
1247
1248 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1249 (unsigned char *) (long) ((num_samples*2)+3),
1250 msample_hdr)) {
1251 snd_printk ("download of multisample failed.\n");
1252 kfree(msample_hdr);
1253 return -EIO;
1254 }
1255
1256 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1257
1258 kfree(msample_hdr);
1259 return (0);
1260}
1261
1262static int
1263wavefront_fetch_multisample (snd_wavefront_t *dev,
1264 wavefront_patch_info *header)
1265{
1266 int i;
1267 unsigned char log_ns[1];
1268 unsigned char number[2];
1269 int num_samples;
1270
1271 munge_int32 (header->number, number, 2);
1272
1273 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1274 snd_printk ("upload multisample failed.\n");
1275 return -EIO;
1276 }
1277
1278 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1279 header->number, log_ns[0]);
1280
1281 header->hdr.ms.NumberOfSamples = log_ns[0];
1282
1283 /* get the number of samples ... */
1284
1285 num_samples = (1 << log_ns[0]);
1286
1287 for (i = 0; i < num_samples; i++) {
1288 char d[2];
1289 int val;
1290
1291 val = wavefront_read(dev);
1292 if (val == -1) {
1293 snd_printk ("upload multisample failed "
1294 "during sample loop.\n");
1295 return -EIO;
1296 }
1297 d[0] = val;
1298
1299 val = wavefront_read(dev);
1300 if (val == -1) {
1301 snd_printk ("upload multisample failed "
1302 "during sample loop.\n");
1303 return -EIO;
1304 }
1305 d[1] = val;
1306
1307 header->hdr.ms.SampleNumber[i] =
1308 demunge_int32 ((unsigned char *) d, 2);
1309
1310 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1311 i, header->hdr.ms.SampleNumber[i]);
1312 }
1313
1314 return (0);
1315}
1316
1317
1318static int
1319wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1320
1321{
1322 unsigned char drumbuf[WF_DRUM_BYTES];
1323 wavefront_drum *drum = &header->hdr.d;
1324 int i;
1325
1326 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1327 "note %d, patch = %d\n",
1328 header->number, drum->PatchNumber);
1329
1330 drumbuf[0] = header->number & 0x7f;
1331
1332 for (i = 0; i < 4; i++) {
1333 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1334 }
1335
1336 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1337 snd_printk ("download drum failed.\n");
1338 return -EIO;
1339 }
1340
1341 return (0);
1342}
1343
1344static int
1345wavefront_find_free_sample (snd_wavefront_t *dev)
1346
1347{
1348 int i;
1349
1350 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1351 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1352 return i;
1353 }
1354 }
1355 snd_printk ("no free sample slots!\n");
1356 return -1;
1357}
1358
1359#if 0
1360static int
1361wavefront_find_free_patch (snd_wavefront_t *dev)
1362
1363{
1364 int i;
1365
1366 for (i = 0; i < WF_MAX_PATCH; i++) {
1367 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1368 return i;
1369 }
1370 }
1371 snd_printk ("no free patch slots!\n");
1372 return -1;
1373}
1374#endif
1375
1376static int
1377wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1378{
1379 wavefront_patch_info *header;
1380 int err;
1381
1382 header = kmalloc(sizeof(*header), GFP_KERNEL);
1383 if (! header)
1384 return -ENOMEM;
1385
1386 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1387 sizeof(wavefront_any))) {
1388 snd_printk ("bad address for load patch.\n");
1389 err = -EFAULT;
1390 goto __error;
1391 }
1392
1393 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1394 "Sample type: %d "
1395 "Sample number: %d "
1396 "Sample size: %d\n",
1397 header->subkey,
1398 header->number,
1399 header->size);
1400
1401 switch (header->subkey) {
1402 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1403
1404 if (copy_from_user (&header->hdr.s, header->hdrptr,
1405 sizeof (wavefront_sample))) {
1406 err = -EFAULT;
1407 break;
1408 }
1409
1410 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1411 break;
1412
1413 case WF_ST_MULTISAMPLE:
1414
1415 if (copy_from_user (&header->hdr.s, header->hdrptr,
1416 sizeof (wavefront_multisample))) {
1417 err = -EFAULT;
1418 break;
1419 }
1420
1421 err = wavefront_send_multisample (dev, header);
1422 break;
1423
1424 case WF_ST_ALIAS:
1425
1426 if (copy_from_user (&header->hdr.a, header->hdrptr,
1427 sizeof (wavefront_alias))) {
1428 err = -EFAULT;
1429 break;
1430 }
1431
1432 err = wavefront_send_alias (dev, header);
1433 break;
1434
1435 case WF_ST_DRUM:
1436 if (copy_from_user (&header->hdr.d, header->hdrptr,
1437 sizeof (wavefront_drum))) {
1438 err = -EFAULT;
1439 break;
1440 }
1441
1442 err = wavefront_send_drum (dev, header);
1443 break;
1444
1445 case WF_ST_PATCH:
1446 if (copy_from_user (&header->hdr.p, header->hdrptr,
1447 sizeof (wavefront_patch))) {
1448 err = -EFAULT;
1449 break;
1450 }
1451
1452 err = wavefront_send_patch (dev, header);
1453 break;
1454
1455 case WF_ST_PROGRAM:
1456 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1457 sizeof (wavefront_program))) {
1458 err = -EFAULT;
1459 break;
1460 }
1461
1462 err = wavefront_send_program (dev, header);
1463 break;
1464
1465 default:
1466 snd_printk ("unknown patch type %d.\n",
1467 header->subkey);
1468 err = -EINVAL;
1469 break;
1470 }
1471
1472 __error:
1473 kfree(header);
1474 return err;
1475}
1476
1477/***********************************************************************
1478WaveFront: hardware-dependent interface
1479***********************************************************************/
1480
1481static void
1482process_sample_hdr (u8 *buf)
1483
1484{
1485 wavefront_sample s;
1486 u8 *ptr;
1487
1488 ptr = buf;
1489
1490 /* The board doesn't send us an exact copy of a "wavefront_sample"
1491 in response to an Upload Sample Header command. Instead, we
1492 have to convert the data format back into our data structure,
1493 just as in the Download Sample command, where we have to do
1494 something very similar in the reverse direction.
1495 */
1496
1497 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1498 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1499 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1500 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1501 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1502
1503 s.SampleResolution = *ptr & 0x3;
1504 s.Loop = *ptr & 0x8;
1505 s.Bidirectional = *ptr & 0x10;
1506 s.Reverse = *ptr & 0x40;
1507
1508 /* Now copy it back to where it came from */
1509
1510 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1511}
1512
1513static int
1514wavefront_synth_control (snd_wavefront_card_t *acard,
1515 wavefront_control *wc)
1516
1517{
1518 snd_wavefront_t *dev = &acard->wavefront;
1519 unsigned char patchnumbuf[2];
1520 int i;
1521
1522 DPRINT (WF_DEBUG_CMD, "synth control with "
1523 "cmd 0x%x\n", wc->cmd);
1524
1525 /* Pre-handling of or for various commands */
1526
1527 switch (wc->cmd) {
1528
1529 case WFC_DISABLE_INTERRUPTS:
1530 snd_printk ("interrupts disabled.\n");
1531 outb (0x80|0x20, dev->control_port);
1532 dev->interrupts_are_midi = 1;
1533 return 0;
1534
1535 case WFC_ENABLE_INTERRUPTS:
1536 snd_printk ("interrupts enabled.\n");
1537 outb (0x80|0x40|0x20, dev->control_port);
1538 dev->interrupts_are_midi = 1;
1539 return 0;
1540
1541 case WFC_INTERRUPT_STATUS:
1542 wc->rbuf[0] = dev->interrupts_are_midi;
1543 return 0;
1544
1545 case WFC_ROMSAMPLES_RDONLY:
1546 dev->rom_samples_rdonly = wc->wbuf[0];
1547 wc->status = 0;
1548 return 0;
1549
1550 case WFC_IDENTIFY_SLOT_TYPE:
1551 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1552 if (i <0 || i >= WF_MAX_SAMPLE) {
1553 snd_printk ("invalid slot ID %d\n",
1554 i);
1555 wc->status = EINVAL;
1556 return -EINVAL;
1557 }
1558 wc->rbuf[0] = dev->sample_status[i];
1559 wc->status = 0;
1560 return 0;
1561
1562 case WFC_DEBUG_DRIVER:
1563 dev->debug = wc->wbuf[0];
1564 snd_printk ("debug = 0x%x\n", dev->debug);
1565 return 0;
1566
1567 case WFC_UPLOAD_PATCH:
1568 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1569 memcpy (wc->wbuf, patchnumbuf, 2);
1570 break;
1571
1572 case WFC_UPLOAD_MULTISAMPLE:
1573 /* multisamples have to be handled differently, and
1574 cannot be dealt with properly by snd_wavefront_cmd() alone.
1575 */
1576 wc->status = wavefront_fetch_multisample
1577 (dev, (wavefront_patch_info *) wc->rbuf);
1578 return 0;
1579
1580 case WFC_UPLOAD_SAMPLE_ALIAS:
1581 snd_printk ("support for sample alias upload "
1582 "being considered.\n");
1583 wc->status = EINVAL;
1584 return -EINVAL;
1585 }
1586
1587 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1588
1589 /* Post-handling of certain commands.
1590
1591 In particular, if the command was an upload, demunge the data
1592 so that the user-level doesn't have to think about it.
1593 */
1594
1595 if (wc->status == 0) {
1596 switch (wc->cmd) {
1597 /* intercept any freemem requests so that we know
1598 we are always current with the user-level view
1599 of things.
1600 */
1601
1602 case WFC_REPORT_FREE_MEMORY:
1603 dev->freemem = demunge_int32 (wc->rbuf, 4);
1604 break;
1605
1606 case WFC_UPLOAD_PATCH:
1607 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1608 break;
1609
1610 case WFC_UPLOAD_PROGRAM:
1611 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1612 break;
1613
1614 case WFC_UPLOAD_EDRUM_PROGRAM:
1615 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1616 break;
1617
1618 case WFC_UPLOAD_SAMPLE_HEADER:
1619 process_sample_hdr (wc->rbuf);
1620 break;
1621
1622 case WFC_UPLOAD_SAMPLE_ALIAS:
1623 snd_printk ("support for "
1624 "sample aliases still "
1625 "being considered.\n");
1626 break;
1627
1628 case WFC_VMIDI_OFF:
1629 snd_wavefront_midi_disable_virtual (acard);
1630 break;
1631
1632 case WFC_VMIDI_ON:
1633 snd_wavefront_midi_enable_virtual (acard);
1634 break;
1635 }
1636 }
1637
1638 return 0;
1639}
1640
1641int
1642snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1643
1644{
1645 if (!try_module_get(hw->card->module))
1646 return -EFAULT;
1647 file->private_data = hw;
1648 return 0;
1649}
1650
1651int
1652snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1653
1654{
1655 module_put(hw->card->module);
1656 return 0;
1657}
1658
1659int
1660snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1661 unsigned int cmd, unsigned long arg)
1662
1663{
1664 struct snd_card *card;
1665 snd_wavefront_t *dev;
1666 snd_wavefront_card_t *acard;
1667 wavefront_control *wc;
1668 void __user *argp = (void __user *)arg;
1669 int err;
1670
1671 card = (struct snd_card *) hw->card;
1672
1673 if (snd_BUG_ON(!card))
1674 return -ENODEV;
1675 if (snd_BUG_ON(!card->private_data))
1676 return -ENODEV;
1677
1678 acard = card->private_data;
1679 dev = &acard->wavefront;
1680
1681 switch (cmd) {
1682 case WFCTL_LOAD_SPP:
1683 if (wavefront_load_patch (dev, argp) != 0) {
1684 return -EIO;
1685 }
1686 break;
1687
1688 case WFCTL_WFCMD:
1689 wc = memdup_user(argp, sizeof(*wc));
1690 if (IS_ERR(wc))
1691 return PTR_ERR(wc);
1692
1693 if (wavefront_synth_control (acard, wc) < 0)
1694 err = -EIO;
1695 else if (copy_to_user (argp, wc, sizeof (*wc)))
1696 err = -EFAULT;
1697 else
1698 err = 0;
1699 kfree(wc);
1700 return err;
1701
1702 default:
1703 return -EINVAL;
1704 }
1705
1706 return 0;
1707}
1708
1709
1710/***********************************************************************/
1711/* WaveFront: interface for card-level wavefront module */
1712/***********************************************************************/
1713
1714void
1715snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1716{
1717 snd_wavefront_t *dev = &card->wavefront;
1718
1719 /*
1720 Some comments on interrupts. I attempted a version of this
1721 driver that used interrupts throughout the code instead of
1722 doing busy and/or sleep-waiting. Alas, it appears that once
1723 the Motorola firmware is downloaded, the card *never*
1724 generates an RX interrupt. These are successfully generated
1725 during firmware loading, and after that wavefront_status()
1726 reports that an interrupt is pending on the card from time
1727 to time, but it never seems to be delivered to this
1728 driver. Note also that wavefront_status() continues to
1729 report that RX interrupts are enabled, suggesting that I
1730 didn't goof up and disable them by mistake.
1731
1732 Thus, I stepped back to a prior version of
1733 wavefront_wait(), the only place where this really
1734 matters. Its sad, but I've looked through the code to check
1735 on things, and I really feel certain that the Motorola
1736 firmware prevents RX-ready interrupts.
1737 */
1738
1739 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1740 return;
1741 }
1742
1743 spin_lock(&dev->irq_lock);
1744 dev->irq_ok = 1;
1745 dev->irq_cnt++;
1746 spin_unlock(&dev->irq_lock);
1747 wake_up(&dev->interrupt_sleeper);
1748}
1749
1750/* STATUS REGISTER
1751
17520 Host Rx Interrupt Enable (1=Enabled)
17531 Host Rx Register Full (1=Full)
17542 Host Rx Interrupt Pending (1=Interrupt)
17553 Unused
17564 Host Tx Interrupt (1=Enabled)
17575 Host Tx Register empty (1=Empty)
17586 Host Tx Interrupt Pending (1=Interrupt)
17597 Unused
1760*/
1761
1762static int
1763snd_wavefront_interrupt_bits (int irq)
1764
1765{
1766 int bits;
1767
1768 switch (irq) {
1769 case 9:
1770 bits = 0x00;
1771 break;
1772 case 5:
1773 bits = 0x08;
1774 break;
1775 case 12:
1776 bits = 0x10;
1777 break;
1778 case 15:
1779 bits = 0x18;
1780 break;
1781
1782 default:
1783 snd_printk ("invalid IRQ %d\n", irq);
1784 bits = -1;
1785 }
1786
1787 return bits;
1788}
1789
1790static void
1791wavefront_should_cause_interrupt (snd_wavefront_t *dev,
1792 int val, int port, unsigned long timeout)
1793
1794{
1795 wait_queue_entry_t wait;
1796
1797 init_waitqueue_entry(&wait, current);
1798 spin_lock_irq(&dev->irq_lock);
1799 add_wait_queue(&dev->interrupt_sleeper, &wait);
1800 dev->irq_ok = 0;
1801 outb (val,port);
1802 spin_unlock_irq(&dev->irq_lock);
1803 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1804 schedule_timeout_uninterruptible(1);
1805 barrier();
1806 }
1807}
1808
1809static int
1810wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1811
1812{
1813 int bits;
1814 int hwv[2];
1815
1816 /* IRQ already checked */
1817
1818 bits = snd_wavefront_interrupt_bits (dev->irq);
1819
1820 /* try reset of port */
1821
1822 outb (0x0, dev->control_port);
1823
1824 /* At this point, the board is in reset, and the H/W initialization
1825 register is accessed at the same address as the data port.
1826
1827 Bit 7 - Enable IRQ Driver
1828 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1829 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1830
1831 Bit 6 - MIDI Interface Select
1832
1833 0 - Use the MIDI Input from the 26-pin WaveBlaster
1834 compatible header as the serial MIDI source
1835 1 - Use the MIDI Input from the 9-pin D connector as the
1836 serial MIDI source.
1837
1838 Bits 5:3 - IRQ Selection
1839 0 0 0 - IRQ 2/9
1840 0 0 1 - IRQ 5
1841 0 1 0 - IRQ 12
1842 0 1 1 - IRQ 15
1843 1 0 0 - Reserved
1844 1 0 1 - Reserved
1845 1 1 0 - Reserved
1846 1 1 1 - Reserved
1847
1848 Bits 2:1 - Reserved
1849 Bit 0 - Disable Boot ROM
1850 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1851 1 - memory accesses to 03FC30-03FFFFH are directed to external
1852 storage.
1853
1854 */
1855
1856 /* configure hardware: IRQ, enable interrupts,
1857 plus external 9-pin MIDI interface selected
1858 */
1859
1860 outb (0x80 | 0x40 | bits, dev->data_port);
1861
1862 /* CONTROL REGISTER
1863
1864 0 Host Rx Interrupt Enable (1=Enabled) 0x1
1865 1 Unused 0x2
1866 2 Unused 0x4
1867 3 Unused 0x8
1868 4 Host Tx Interrupt Enable 0x10
1869 5 Mute (0=Mute; 1=Play) 0x20
1870 6 Master Interrupt Enable (1=Enabled) 0x40
1871 7 Master Reset (0=Reset; 1=Run) 0x80
1872
1873 Take us out of reset, mute output, master + TX + RX interrupts on.
1874
1875 We'll get an interrupt presumably to tell us that the TX
1876 register is clear.
1877 */
1878
1879 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1880 dev->control_port,
1881 (reset_time*HZ)/100);
1882
1883 /* Note: data port is now the data port, not the h/w initialization
1884 port.
1885 */
1886
1887 if (!dev->irq_ok) {
1888 snd_printk ("intr not received after h/w un-reset.\n");
1889 goto gone_bad;
1890 }
1891
1892 /* Note: data port is now the data port, not the h/w initialization
1893 port.
1894
1895 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1896 will work. So, issue one of them, and wait for TX
1897 interrupt. This can take a *long* time after a cold boot,
1898 while the ISC ROM does its RAM test. The SDK says up to 4
1899 seconds - with 12MB of RAM on a Tropez+, it takes a lot
1900 longer than that (~16secs). Note that the card understands
1901 the difference between a warm and a cold boot, so
1902 subsequent ISC2115 reboots (say, caused by module
1903 reloading) will get through this much faster.
1904
1905 XXX Interesting question: why is no RX interrupt received first ?
1906 */
1907
1908 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1909 dev->data_port, ramcheck_time*HZ);
1910
1911 if (!dev->irq_ok) {
1912 snd_printk ("post-RAM-check interrupt not received.\n");
1913 goto gone_bad;
1914 }
1915
1916 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1917 snd_printk ("no response to HW version cmd.\n");
1918 goto gone_bad;
1919 }
1920
1921 hwv[0] = wavefront_read(dev);
1922 if (hwv[0] == -1) {
1923 snd_printk ("board not responding correctly.\n");
1924 goto gone_bad;
1925 }
1926
1927 if (hwv[0] == 0xFF) { /* NAK */
1928
1929 /* Board's RAM test failed. Try to read error code,
1930 and tell us about it either way.
1931 */
1932
1933 hwv[0] = wavefront_read(dev);
1934 if (hwv[0] == -1) {
1935 snd_printk ("on-board RAM test failed "
1936 "(bad error code).\n");
1937 } else {
1938 snd_printk ("on-board RAM test failed "
1939 "(error code: 0x%x).\n",
1940 hwv[0]);
1941 }
1942 goto gone_bad;
1943 }
1944
1945 /* We're OK, just get the next byte of the HW version response */
1946
1947 hwv[1] = wavefront_read(dev);
1948 if (hwv[1] == -1) {
1949 snd_printk ("incorrect h/w response.\n");
1950 goto gone_bad;
1951 }
1952
1953 snd_printk ("hardware version %d.%d\n",
1954 hwv[0], hwv[1]);
1955
1956 return 0;
1957
1958
1959 gone_bad:
1960 return (1);
1961}
1962
1963static int
1964wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1965
1966{
1967 const unsigned char *buf;
1968 int len, err;
1969 int section_cnt_downloaded = 0;
1970 const struct firmware *firmware;
1971
1972 err = request_firmware(&firmware, path, dev->card->dev);
1973 if (err < 0) {
1974 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1975 return 1;
1976 }
1977
1978 len = 0;
1979 buf = firmware->data;
1980 for (;;) {
1981 int section_length = *(signed char *)buf;
1982 if (section_length == 0)
1983 break;
1984 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1985 snd_printk(KERN_ERR
1986 "invalid firmware section length %d\n",
1987 section_length);
1988 goto failure;
1989 }
1990 buf++;
1991 len++;
1992
1993 if (firmware->size < len + section_length) {
1994 snd_printk(KERN_ERR "firmware section read error.\n");
1995 goto failure;
1996 }
1997
1998 /* Send command */
1999 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
2000 goto failure;
2001
2002 for (; section_length; section_length--) {
2003 if (wavefront_write(dev, *buf))
2004 goto failure;
2005 buf++;
2006 len++;
2007 }
2008
2009 /* get ACK */
2010 if (!wavefront_wait(dev, STAT_CAN_READ)) {
2011 snd_printk(KERN_ERR "time out for firmware ACK.\n");
2012 goto failure;
2013 }
2014 err = inb(dev->data_port);
2015 if (err != WF_ACK) {
2016 snd_printk(KERN_ERR
2017 "download of section #%d not "
2018 "acknowledged, ack = 0x%x\n",
2019 section_cnt_downloaded + 1, err);
2020 goto failure;
2021 }
2022
2023 section_cnt_downloaded++;
2024 }
2025
2026 release_firmware(firmware);
2027 return 0;
2028
2029 failure:
2030 release_firmware(firmware);
2031 snd_printk(KERN_ERR "firmware download failed!!!\n");
2032 return 1;
2033}
2034
2035
2036static int
2037wavefront_do_reset (snd_wavefront_t *dev)
2038
2039{
2040 char voices[1];
2041
2042 if (wavefront_reset_to_cleanliness (dev)) {
2043 snd_printk ("hw reset failed.\n");
2044 goto gone_bad;
2045 }
2046
2047 if (dev->israw) {
2048 if (wavefront_download_firmware (dev, ospath)) {
2049 goto gone_bad;
2050 }
2051
2052 dev->israw = 0;
2053
2054 /* Wait for the OS to get running. The protocol for
2055 this is non-obvious, and was determined by
2056 using port-IO tracing in DOSemu and some
2057 experimentation here.
2058
2059 Rather than using timed waits, use interrupts creatively.
2060 */
2061
2062 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2063 dev->data_port,
2064 (osrun_time*HZ));
2065
2066 if (!dev->irq_ok) {
2067 snd_printk ("no post-OS interrupt.\n");
2068 goto gone_bad;
2069 }
2070
2071 /* Now, do it again ! */
2072
2073 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2074 dev->data_port, (10*HZ));
2075
2076 if (!dev->irq_ok) {
2077 snd_printk ("no post-OS interrupt(2).\n");
2078 goto gone_bad;
2079 }
2080
2081 /* OK, no (RX/TX) interrupts any more, but leave mute
2082 in effect.
2083 */
2084
2085 outb (0x80|0x40, dev->control_port);
2086 }
2087
2088 /* SETUPSND.EXE asks for sample memory config here, but since i
2089 have no idea how to interpret the result, we'll forget
2090 about it.
2091 */
2092
2093 dev->freemem = wavefront_freemem(dev);
2094 if (dev->freemem < 0)
2095 goto gone_bad;
2096
2097 snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2098
2099 if (wavefront_write (dev, 0xf0) ||
2100 wavefront_write (dev, 1) ||
2101 (wavefront_read (dev) < 0)) {
2102 dev->debug = 0;
2103 snd_printk ("MPU emulation mode not set.\n");
2104 goto gone_bad;
2105 }
2106
2107 voices[0] = 32;
2108
2109 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2110 snd_printk ("cannot set number of voices to 32.\n");
2111 goto gone_bad;
2112 }
2113
2114
2115 return 0;
2116
2117 gone_bad:
2118 /* reset that sucker so that it doesn't bother us. */
2119
2120 outb (0x0, dev->control_port);
2121 dev->interrupts_are_midi = 0;
2122 return 1;
2123}
2124
2125int
2126snd_wavefront_start (snd_wavefront_t *dev)
2127
2128{
2129 int samples_are_from_rom;
2130
2131 /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2132 wavefront_reset_to_cleanliness() has already been called
2133 */
2134
2135 if (dev->israw) {
2136 samples_are_from_rom = 1;
2137 } else {
2138 /* XXX is this always true ? */
2139 samples_are_from_rom = 0;
2140 }
2141
2142 if (dev->israw || fx_raw) {
2143 if (wavefront_do_reset (dev)) {
2144 return -1;
2145 }
2146 }
2147 /* Check for FX device, present only on Tropez+ */
2148
2149 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2150
2151 if (dev->has_fx && fx_raw) {
2152 snd_wavefront_fx_start (dev);
2153 }
2154
2155 wavefront_get_sample_status (dev, samples_are_from_rom);
2156 wavefront_get_program_status (dev);
2157 wavefront_get_patch_status (dev);
2158
2159 /* Start normal operation: unreset, master interrupt enabled, no mute
2160 */
2161
2162 outb (0x80|0x40|0x20, dev->control_port);
2163
2164 return (0);
2165}
2166
2167int
2168snd_wavefront_detect (snd_wavefront_card_t *card)
2169
2170{
2171 unsigned char rbuf[4], wbuf[4];
2172 snd_wavefront_t *dev = &card->wavefront;
2173
2174 /* returns zero if a WaveFront card is successfully detected.
2175 negative otherwise.
2176 */
2177
2178 dev->israw = 0;
2179 dev->has_fx = 0;
2180 dev->debug = debug_default;
2181 dev->interrupts_are_midi = 0;
2182 dev->irq_cnt = 0;
2183 dev->rom_samples_rdonly = 1;
2184
2185 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2186
2187 dev->fw_version[0] = rbuf[0];
2188 dev->fw_version[1] = rbuf[1];
2189
2190 snd_printk ("firmware %d.%d already loaded.\n",
2191 rbuf[0], rbuf[1]);
2192
2193 /* check that a command actually works */
2194
2195 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2196 rbuf, wbuf) == 0) {
2197 dev->hw_version[0] = rbuf[0];
2198 dev->hw_version[1] = rbuf[1];
2199 } else {
2200 snd_printk ("not raw, but no "
2201 "hardware version!\n");
2202 return -1;
2203 }
2204
2205 if (!wf_raw) {
2206 return 0;
2207 } else {
2208 snd_printk ("reloading firmware as you requested.\n");
2209 dev->israw = 1;
2210 }
2211
2212 } else {
2213
2214 dev->israw = 1;
2215 snd_printk ("no response to firmware probe, assume raw.\n");
2216
2217 }
2218
2219 return 0;
2220}
2221
2222MODULE_FIRMWARE(DEFAULT_OSPATH);