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