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