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