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