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