projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: wavefront: remove redundant assignment to pointer end
[linux-2.6-block.git] / sound / isa / wavefront / wavefront_synth.c
CommitLineData
63682fb0 1// SPDX-License-Identifier: GPL-2.0-only
1da177e4
LT		 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
1da177e4
LT		 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
6cbbfe1c 20#include <linux/io.h>
1da177e4
LT		 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>
174cd4b1 26#include <linux/sched/signal.h>
c2b1239a 27#include <linux/firmware.h>
1da177e4 28#include <linux/moduleparam.h>
5a0e3ad6 29#include <linux/slab.h>
da155d5b 30#include <linux/module.h>
1da177e4
LT		 31#include <sound/core.h>
32#include <sound/snd_wavefront.h>
33#include <sound/initval.h>
34
35static 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
41static 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
48static 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
c2b1239a
TI		 56#define DEFAULT_OSPATH "wavefront.os"
57static char *ospath = DEFAULT_OSPATH; /* the firmware file name */
1da177e4
LT		 58
59static 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
72static int sleep_interval = 100; /* HZ/sleep_interval seconds per sleep */
73static int sleep_tries = 50; /* number of times we'll try to sleep */
74
75static int reset_time = 2; /* hundreths of a second we wait after a HW
76 reset for the expected interrupt.
77 */
78
79static int ramcheck_time = 20; /* time in seconds to wait while ROM code
80 checks on-board RAM.
81 */
82
83static int osrun_time = 10; /* time in seconds we wait for the OS to
84 start running.
85 */
86module_param(wf_raw, int, 0444);
87MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
88module_param(fx_raw, int, 0444);
89MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
90module_param(debug_default, int, 0444);
91MODULE_PARM_DESC(debug_default, "debug parameters for card initialization");
92module_param(wait_usecs, int, 0444);
93MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs");
94module_param(sleep_interval, int, 0444);
95MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply");
96module_param(sleep_tries, int, 0444);
97MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait");
98module_param(ospath, charp, 0444);
c2b1239a 99MODULE_PARM_DESC(ospath, "pathname to processed ICS2115 OS firmware");
1da177e4
LT		 100module_param(reset_time, int, 0444);
101MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect");
102module_param(ramcheck_time, int, 0444);
103MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test");
104module_param(osrun_time, int, 0444);
105MODULE_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
1da177e4
LT		 117#define DPRINT(cond, ...) \
118 if ((dev->debug & (cond)) == (cond)) { \
119 snd_printk (__VA_ARGS__); \
120 }
121#else
1da177e4
LT		 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
136static int wavefront_delete_sample (snd_wavefront_t *, int sampnum);
137static int wavefront_find_free_sample (snd_wavefront_t *);
138
542172f3 139struct wavefront_command {
1da177e4
LT		 140 int cmd;
141 char *action;
142 unsigned int read_cnt;
143 unsigned int write_cnt;
144 int need_ack;
542172f3 145};
1da177e4
LT		 146
147static 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
542172f3 165static struct wavefront_command wavefront_commands[] = {
1da177e4
LT		 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
229static const char *
230wavefront_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
542172f3 244static struct wavefront_command *
1da177e4
LT		 245wavefront_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
542172f3 256 return NULL;
1da177e4
LT		 257}
258
259static inline int
260wavefront_status (snd_wavefront_t *dev)
261
262{
263 return inb (dev->status_port);
264}
265
266static int
267wavefront_sleep (int limit)
268
269{
8433a509 270 schedule_timeout_interruptible(limit);
1da177e4
LT		 271
272 return signal_pending(current);
273}
274
275static int
276wavefront_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
306static int
307wavefront_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
318static int
319wavefront_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
332int
333snd_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;
542172f3 340 struct wavefront_command *wfcmd;
1da177e4 341
520226e9
TI		 342 wfcmd = wavefront_get_command(cmd);
343 if (!wfcmd) {
1da177e4
LT		 344 snd_printk ("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
520226e9
TI		 395 c = wavefront_read(dev);
396 if (c == -1) {
1da177e4
LT		 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) {
520226e9
TI		 406 c = wavefront_read(dev);
407 if (c == -1) {
1da177e4
LT		 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
520226e9
TI		 465 ack = wavefront_read(dev);
466 if (ack == 0)
1da177e4 467 ack = WF_ACK;
1da177e4
LT		 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
520226e9
TI		 481 err = wavefront_read(dev);
482 if (err == -1) {
1da177e4
LT		 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\f
514/***********************************************************************
515WaveFront data munging
516
517Things here are weird. All data written to the board cannot
518have its most significant bit set. Any data item with values
519potentially > 0x7F (127) must be split across multiple bytes.
520
521Sometimes, we need to munge numeric values that are represented on
522the x86 side as 8-32 bit values. Sometimes, we need to munge data
523that is represented on the x86 side as an array of bytes. The most
524efficient approach to handling both cases seems to be to use 2
525different functions for munging and 2 for de-munging. This avoids
526weird casting and worrying about bit-level offsets.
527
528**********************************************************************/
529
530static unsigned char *
531munge_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++;
395d9dd5 543 }
1da177e4
LT		 544 return dst;
545};
546
547static int
548demunge_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
561static
562unsigned char *
563munge_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
576static
577unsigned char *
578demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)
579
580{
581 int i;
582 unsigned char *end = src + src_bytes;
583
1da177e4
LT		 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\f
594/***********************************************************************
595WaveFront: sample, patch and program management.
596***********************************************************************/
597
598static int
599wavefront_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
520226e9
TI		 608 x = snd_wavefront_cmd(dev, WFC_DELETE_SAMPLE, NULL, wbuf);
609 if (!x)
1da177e4 610 dev->sample_status[sample_num] = WF_ST_EMPTY;
1da177e4
LT		 611
612 return x;
613}
614
615static int
616wavefront_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)) {
4c9f1d3e 638 snd_printk(KERN_WARNING "cannot identify sample "
1da177e4
LT		 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
683static int
684wavefront_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
520226e9
TI		 696 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PATCH, patchbuf,
697 patchnum);
698 if (x == 0) {
1da177e4
LT		 699
700 dev->patch_status[i] |= WF_SLOT_FILLED;
701 p = (wavefront_patch *) patchbuf;
702 dev->sample_status
703 [p->sample_number|(p->sample_msb<<7)] |=
704 WF_SLOT_USED;
705
706 } else if (x == 3) { /* Bad patch number */
707 dev->patch_status[i] = 0;
708 } else {
709 snd_printk ("upload patch "
710 "error 0x%x\n", x);
711 dev->patch_status[i] = 0;
712 return 1;
713 }
714 }
715
716 /* program status has already filled in slot_used bits */
717
718 for (i = 0, cnt = 0, cnt2 = 0; i < WF_MAX_PATCH; i++) {
719 if (dev->patch_status[i] & WF_SLOT_FILLED) {
720 cnt++;
721 }
722 if (dev->patch_status[i] & WF_SLOT_USED) {
723 cnt2++;
724 }
725
726 }
727 snd_printk ("%d patch slots filled, %d in use\n", cnt, cnt2);
728
729 return (0);
730}
731
732static int
733wavefront_get_program_status (snd_wavefront_t *dev)
734
735{
736 unsigned char progbuf[WF_PROGRAM_BYTES];
737 wavefront_program prog;
738 unsigned char prognum;
739 int i, x, l, cnt;
740
741 for (i = 0; i < WF_MAX_PROGRAM; i++) {
742 prognum = i;
743
520226e9
TI		 744 x = snd_wavefront_cmd(dev, WFC_UPLOAD_PROGRAM, progbuf,
745 &prognum);
746 if (x == 0) {
1da177e4
LT		 747
748 dev->prog_status[i] |= WF_SLOT_USED;
749
750 demunge_buf (progbuf, (unsigned char *) &prog,
751 WF_PROGRAM_BYTES);
752
753 for (l = 0; l < WF_NUM_LAYERS; l++) {
754 if (prog.layer[l].mute) {
755 dev->patch_status
756 [prog.layer[l].patch_number] |=
757 WF_SLOT_USED;
758 }
759 }
760 } else if (x == 1) { /* Bad program number */
761 dev->prog_status[i] = 0;
762 } else {
763 snd_printk ("upload program "
764 "error 0x%x\n", x);
765 dev->prog_status[i] = 0;
766 }
767 }
768
769 for (i = 0, cnt = 0; i < WF_MAX_PROGRAM; i++) {
770 if (dev->prog_status[i]) {
771 cnt++;
772 }
773 }
774
775 snd_printk ("%d programs slots in use\n", cnt);
776
777 return (0);
778}
779
780static int
781wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
782
783{
784 unsigned char buf[WF_PATCH_BYTES+2];
785 unsigned char *bptr;
786
787 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading patch %d\n",
788 header->number);
789
84d7a447
DC		 790 if (header->number >= ARRAY_SIZE(dev->patch_status))
791 return -EINVAL;
792
1da177e4
LT		 793 dev->patch_status[header->number] |= WF_SLOT_FILLED;
794
1da177e4
LT		 795 bptr = munge_int32 (header->number, buf, 2);
796 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
797
798 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
799 snd_printk ("download patch failed\n");
9a303dc7 800 return -EIO;
1da177e4
LT		 801 }
802
803 return (0);
804}
805
806static int
807wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
808
809{
810 unsigned char buf[WF_PROGRAM_BYTES+1];
811 int i;
812
813 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
814 header->number);
815
84d7a447
DC		 816 if (header->number >= ARRAY_SIZE(dev->prog_status))
817 return -EINVAL;
818
1da177e4
LT		 819 dev->prog_status[header->number] = WF_SLOT_USED;
820
821 /* XXX need to zero existing SLOT_USED bit for program_status[i]
822 where `i' is the program that's being (potentially) overwritten.
823 */
824
825 for (i = 0; i < WF_NUM_LAYERS; i++) {
826 if (header->hdr.pr.layer[i].mute) {
827 dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
828 WF_SLOT_USED;
829
830 /* XXX need to mark SLOT_USED for sample used by
831 patch_number, but this means we have to load it. Ick.
832 */
833 }
834 }
835
836 buf[0] = header->number;
837 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
838
839 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
840 snd_printk ("download patch failed\n");
9a303dc7 841 return -EIO;
1da177e4
LT		 842 }
843
844 return (0);
845}
846
847static int
848wavefront_freemem (snd_wavefront_t *dev)
849
850{
851 char rbuf[8];
852
853 if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
854 snd_printk ("can't get memory stats.\n");
855 return -1;
856 } else {
857 return demunge_int32 (rbuf, 4);
858 }
859}
860
861static int
862wavefront_send_sample (snd_wavefront_t *dev,
863 wavefront_patch_info *header,
864 u16 __user *dataptr,
865 int data_is_unsigned)
866
867{
868 /* samples are downloaded via a 16-bit wide i/o port
869 (you could think of it as 2 adjacent 8-bit wide ports
870 but its less efficient that way). therefore, all
871 the blocksizes and so forth listed in the documentation,
872 and used conventionally to refer to sample sizes,
873 which are given in 8-bit units (bytes), need to be
874 divided by 2.
875 */
876
fe25ad8a 877 u16 sample_short = 0;
1da177e4
LT		 878 u32 length;
879 u16 __user *data_end = NULL;
880 unsigned int i;
881 const unsigned int max_blksize = 4096/2;
882 unsigned int written;
883 unsigned int blocksize;
884 int dma_ack;
885 int blocknum;
886 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
887 unsigned char *shptr;
888 int skip = 0;
889 int initial_skip = 0;
890
891 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
892 "type %d, %d bytes from 0x%lx\n",
893 header->size ? "" : "header ",
894 header->number, header->subkey,
895 header->size,
896 (unsigned long) header->dataptr);
897
898 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
899 int x;
900
520226e9
TI		 901 x = wavefront_find_free_sample(dev);
902 if (x < 0)
1da177e4 903 return -ENOMEM;
1da177e4
LT		 904 snd_printk ("unspecified sample => %d\n", x);
905 header->number = x;
906 }
907
84d7a447
DC		 908 if (header->number >= WF_MAX_SAMPLE)
909 return -EINVAL;
910
1da177e4
LT		 911 if (header->size) {
912
913 /* XXX it's a debatable point whether or not RDONLY semantics
914 on the ROM samples should cover just the sample data or
915 the sample header. For now, it only covers the sample data,
916 so anyone is free at all times to rewrite sample headers.
917
918 My reason for this is that we have the sample headers
919 available in the WFB file for General MIDI, and so these
920 can always be reset if needed. The sample data, however,
921 cannot be recovered without a complete reset and firmware
922 reload of the ICS2115, which is a very expensive operation.
923
924 So, doing things this way allows us to honor the notion of
925 "RESETSAMPLES" reasonably cheaply. Note however, that this
926 is done purely at user level: there is no WFB parser in
927 this driver, and so a complete reset (back to General MIDI,
928 or theoretically some other configuration) is the
929 responsibility of the user level library.
930
931 To try to do this in the kernel would be a little
932 crazy: we'd need 158K of kernel space just to hold
933 a copy of the patch/program/sample header data.
934 */
935
936 if (dev->rom_samples_rdonly) {
937 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
938 snd_printk ("sample slot %d "
939 "write protected\n",
940 header->number);
941 return -EACCES;
942 }
943 }
944
945 wavefront_delete_sample (dev, header->number);
946 }
947
948 if (header->size) {
949 dev->freemem = wavefront_freemem (dev);
950
951 if (dev->freemem < (int)header->size) {
952 snd_printk ("insufficient memory to "
953 "load %d byte sample.\n",
954 header->size);
955 return -ENOMEM;
956 }
957
958 }
959
960 skip = WF_GET_CHANNEL(&header->hdr.s);
961
962 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
963 snd_printk ("channel selection only "
964 "possible on 16-bit samples");
9a303dc7 965 return -EINVAL;
1da177e4
LT		 966 }
967
968 switch (skip) {
969 case 0:
970 initial_skip = 0;
971 skip = 1;
972 break;
973 case 1:
974 initial_skip = 0;
975 skip = 2;
976 break;
977 case 2:
978 initial_skip = 1;
979 skip = 2;
980 break;
981 case 3:
982 initial_skip = 2;
983 skip = 3;
984 break;
985 case 4:
986 initial_skip = 3;
987 skip = 4;
988 break;
989 case 5:
990 initial_skip = 4;
991 skip = 5;
992 break;
993 case 6:
994 initial_skip = 5;
995 skip = 6;
996 break;
997 }
998
999 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
1000 "initial skip = %d, skip = %d\n",
1001 WF_GET_CHANNEL (&header->hdr.s),
1002 initial_skip, skip);
1003
1004 /* Be safe, and zero the "Unused" bits ... */
1005
1006 WF_SET_CHANNEL(&header->hdr.s, 0);
1007
1008 /* adjust size for 16 bit samples by dividing by two. We always
1009 send 16 bits per write, even for 8 bit samples, so the length
1010 is always half the size of the sample data in bytes.
1011 */
1012
1013 length = header->size / 2;
1014
1015 /* the data we're sent has not been munged, and in fact, the
1016 header we have to send isn't just a munged copy either.
1017 so, build the sample header right here.
1018 */
1019
1020 shptr = &sample_hdr[0];
1021
1022 shptr = munge_int32 (header->number, shptr, 2);
1023
1024 if (header->size) {
1025 shptr = munge_int32 (length, shptr, 4);
1026 }
1027
1028 /* Yes, a 4 byte result doesn't contain all of the offset bits,
1029 but the offset only uses 24 bits.
1030 */
1031
1032 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1033 shptr, 4);
1034 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1035 shptr, 4);
1036 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1037 shptr, 4);
1038 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1039 shptr, 4);
1040
1041 /* This one is truly weird. What kind of weirdo decided that in
1042 a system dominated by 16 and 32 bit integers, they would use
1043 a just 12 bits ?
1044 */
1045
1046 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1047
1048 /* Why is this nybblified, when the MSB is *always* zero ?
1049 Anyway, we can't take address of bitfield, so make a
1050 good-faith guess at where it starts.
1051 */
1052
1053 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1054 shptr, 2);
1055
1056 if (snd_wavefront_cmd (dev,
1057 header->size ?
1058 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1059 NULL, sample_hdr)) {
1060 snd_printk ("sample %sdownload refused.\n",
1061 header->size ? "" : "header ");
9a303dc7 1062 return -EIO;
1da177e4
LT		 1063 }
1064
1065 if (header->size == 0) {
1066 goto sent; /* Sorry. Just had to have one somewhere */
1067 }
1068
1069 data_end = dataptr + length;
1070
1071 /* Do any initial skip over an unused channel's data */
1072
1073 dataptr += initial_skip;
1074
1075 for (written = 0, blocknum = 0;
1076 written < length; written += max_blksize, blocknum++) {
1077
1078 if ((length - written) > max_blksize) {
1079 blocksize = max_blksize;
1080 } else {
1081 /* round to nearest 16-byte value */
7ab39926 1082 blocksize = ALIGN(length - written, 8);
1da177e4
LT		 1083 }
1084
1085 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1086 snd_printk ("download block "
1087 "request refused.\n");
9a303dc7 1088 return -EIO;
1da177e4
LT		 1089 }
1090
1091 for (i = 0; i < blocksize; i++) {
1092
1093 if (dataptr < data_end) {
1094
a34ae6c0
TI		 1095 if (get_user(sample_short, dataptr))
1096 return -EFAULT;
1da177e4
LT		 1097 dataptr += skip;
1098
1099 if (data_is_unsigned) { /* GUS ? */
1100
1101 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1102
1103 /* 8 bit sample
1104 resolution, sign
1105 extend both bytes.
1106 */
1107
1108 ((unsigned char*)
1109 &sample_short)[0] += 0x7f;
1110 ((unsigned char*)
1111 &sample_short)[1] += 0x7f;
1112
1113 } else {
1114
1115 /* 16 bit sample
1116 resolution, sign
1117 extend the MSB.
1118 */
1119
1120 sample_short += 0x7fff;
1121 }
1122 }
1123
1124 } else {
1125
1126 /* In padding section of final block:
1127
1128 Don't fetch unsupplied data from
1129 user space, just continue with
1130 whatever the final value was.
1131 */
1132 }
1133
1134 if (i < blocksize - 1) {
1135 outw (sample_short, dev->block_port);
1136 } else {
1137 outw (sample_short, dev->last_block_port);
1138 }
1139 }
1140
1141 /* Get "DMA page acknowledge", even though its really
1142 nothing to do with DMA at all.
1143 */
1144
520226e9
TI		 1145 dma_ack = wavefront_read(dev);
1146 if (dma_ack != WF_DMA_ACK) {
1da177e4
LT		 1147 if (dma_ack == -1) {
1148 snd_printk ("upload sample "
1149 "DMA ack timeout\n");
9a303dc7 1150 return -EIO;
1da177e4
LT		 1151 } else {
1152 snd_printk ("upload sample "
1153 "DMA ack error 0x%x\n",
1154 dma_ack);
9a303dc7 1155 return -EIO;
1da177e4
LT		 1156 }
1157 }
1158 }
1159
1160 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1161
1162 /* Note, label is here because sending the sample header shouldn't
1163 alter the sample_status info at all.
1164 */
1165
1166 sent:
1167 return (0);
1168}
1169
1170static int
1171wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1172
1173{
1174 unsigned char alias_hdr[WF_ALIAS_BYTES];
1175
1176 DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1177 "alias for %d\n",
1178 header->number,
1179 header->hdr.a.OriginalSample);
7f0d5053
DC		 1180
1181 if (header->number >= WF_MAX_SAMPLE)
1182 return -EINVAL;
1183
1da177e4
LT		 1184 munge_int32 (header->number, &alias_hdr[0], 2);
1185 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1186 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1187 &alias_hdr[4], 4);
1188 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1189 &alias_hdr[8], 4);
1190 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1191 &alias_hdr[12], 4);
1192 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1193 &alias_hdr[16], 4);
1194 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1195 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1196
1197 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1198 snd_printk ("download alias failed.\n");
9a303dc7 1199 return -EIO;
1da177e4
LT		 1200 }
1201
1202 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1203
1204 return (0);
1205}
1206
1207static int
1208wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1209{
1210 int i;
1211 int num_samples;
1212 unsigned char *msample_hdr;
1213
7f0d5053
DC		 1214 if (header->number >= WF_MAX_SAMPLE)
1215 return -EINVAL;
1216
8ede6651 1217 msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1da177e4
LT		 1218 if (! msample_hdr)
1219 return -ENOMEM;
1220
1221 munge_int32 (header->number, &msample_hdr[0], 2);
1222
1223 /* You'll recall at this point that the "number of samples" value
1224 in a wavefront_multisample struct is actually the log2 of the
1225 real number of samples.
1226 */
1227
1228 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1229 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1230
1231 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1232 header->number,
1233 header->hdr.ms.NumberOfSamples,
1234 num_samples);
1235
1236 for (i = 0; i < num_samples; i++) {
1237 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1238 i, header->hdr.ms.SampleNumber[i]);
1239 munge_int32 (header->hdr.ms.SampleNumber[i],
1240 &msample_hdr[3+(i*2)], 2);
1241 }
1242
1243 /* Need a hack here to pass in the number of bytes
1244 to be written to the synth. This is ugly, and perhaps
1245 one day, I'll fix it.
1246 */
1247
1248 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE,
1249 (unsigned char *) (long) ((num_samples*2)+3),
1250 msample_hdr)) {
1251 snd_printk ("download of multisample failed.\n");
1252 kfree(msample_hdr);
9a303dc7 1253 return -EIO;
1da177e4
LT		 1254 }
1255
1256 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1257
1258 kfree(msample_hdr);
1259 return (0);
1260}
1261
1262static int
1263wavefront_fetch_multisample (snd_wavefront_t *dev,
1264 wavefront_patch_info *header)
1265{
1266 int i;
1267 unsigned char log_ns[1];
1268 unsigned char number[2];
1269 int num_samples;
1270
1271 munge_int32 (header->number, number, 2);
1272
1273 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1274 snd_printk ("upload multisample failed.\n");
9a303dc7 1275 return -EIO;
1da177e4
LT		 1276 }
1277
1278 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1279 header->number, log_ns[0]);
1280
1281 header->hdr.ms.NumberOfSamples = log_ns[0];
1282
1283 /* get the number of samples ... */
1284
1285 num_samples = (1 << log_ns[0]);
1286
1287 for (i = 0; i < num_samples; i++) {
1288 char d[2];
1289 int val;
1290
520226e9
TI		 1291 val = wavefront_read(dev);
1292 if (val == -1) {
1da177e4
LT		 1293 snd_printk ("upload multisample failed "
1294 "during sample loop.\n");
9a303dc7 1295 return -EIO;
1da177e4
LT		 1296 }
1297 d[0] = val;
1298
520226e9
TI		 1299 val = wavefront_read(dev);
1300 if (val == -1) {
1da177e4
LT		 1301 snd_printk ("upload multisample failed "
1302 "during sample loop.\n");
9a303dc7 1303 return -EIO;
1da177e4
LT		 1304 }
1305 d[1] = val;
1306
1307 header->hdr.ms.SampleNumber[i] =
1308 demunge_int32 ((unsigned char *) d, 2);
1309
1310 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1311 i, header->hdr.ms.SampleNumber[i]);
1312 }
1313
1314 return (0);
1315}
1316
1317
1318static int
1319wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1320
1321{
1322 unsigned char drumbuf[WF_DRUM_BYTES];
1323 wavefront_drum *drum = &header->hdr.d;
1324 int i;
1325
1326 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1327 "note %d, patch = %d\n",
1328 header->number, drum->PatchNumber);
1329
1330 drumbuf[0] = header->number & 0x7f;
1331
1332 for (i = 0; i < 4; i++) {
1333 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1334 }
1335
1336 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1337 snd_printk ("download drum failed.\n");
9a303dc7 1338 return -EIO;
1da177e4
LT		 1339 }
1340
1341 return (0);
1342}
1343
1344static int
1345wavefront_find_free_sample (snd_wavefront_t *dev)
1346
1347{
1348 int i;
1349
1350 for (i = 0; i < WF_MAX_SAMPLE; i++) {
1351 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1352 return i;
1353 }
1354 }
1355 snd_printk ("no free sample slots!\n");
1356 return -1;
1357}
1358
1359#if 0
1360static int
1361wavefront_find_free_patch (snd_wavefront_t *dev)
1362
1363{
1364 int i;
1365
1366 for (i = 0; i < WF_MAX_PATCH; i++) {
1367 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1368 return i;
1369 }
1370 }
1371 snd_printk ("no free patch slots!\n");
1372 return -1;
1373}
1374#endif
1375
1376static int
1377wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1378{
1379 wavefront_patch_info *header;
1380 int err;
1381
1382 header = kmalloc(sizeof(*header), GFP_KERNEL);
1383 if (! header)
1384 return -ENOMEM;
1385
1386 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1387 sizeof(wavefront_any))) {
1388 snd_printk ("bad address for load patch.\n");
1389 err = -EFAULT;
1390 goto __error;
1391 }
1392
1393 DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1394 "Sample type: %d "
1395 "Sample number: %d "
1396 "Sample size: %d\n",
1397 header->subkey,
1398 header->number,
1399 header->size);
1400
1401 switch (header->subkey) {
1402 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1403
1404 if (copy_from_user (&header->hdr.s, header->hdrptr,
1405 sizeof (wavefront_sample))) {
1406 err = -EFAULT;
1407 break;
1408 }
1409
1410 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1411 break;
1412
1413 case WF_ST_MULTISAMPLE:
1414
1415 if (copy_from_user (&header->hdr.s, header->hdrptr,
1416 sizeof (wavefront_multisample))) {
1417 err = -EFAULT;
1418 break;
1419 }
1420
1421 err = wavefront_send_multisample (dev, header);
1422 break;
1423
1424 case WF_ST_ALIAS:
1425
1426 if (copy_from_user (&header->hdr.a, header->hdrptr,
1427 sizeof (wavefront_alias))) {
1428 err = -EFAULT;
1429 break;
1430 }
1431
1432 err = wavefront_send_alias (dev, header);
1433 break;
1434
1435 case WF_ST_DRUM:
1436 if (copy_from_user (&header->hdr.d, header->hdrptr,
1437 sizeof (wavefront_drum))) {
1438 err = -EFAULT;
1439 break;
1440 }
1441
1442 err = wavefront_send_drum (dev, header);
1443 break;
1444
1445 case WF_ST_PATCH:
1446 if (copy_from_user (&header->hdr.p, header->hdrptr,
1447 sizeof (wavefront_patch))) {
1448 err = -EFAULT;
1449 break;
1450 }
1451
1452 err = wavefront_send_patch (dev, header);
1453 break;
1454
1455 case WF_ST_PROGRAM:
1456 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1457 sizeof (wavefront_program))) {
1458 err = -EFAULT;
1459 break;
1460 }
1461
1462 err = wavefront_send_program (dev, header);
1463 break;
1464
1465 default:
1466 snd_printk ("unknown patch type %d.\n",
1467 header->subkey);
1468 err = -EINVAL;
1469 break;
1470 }
1471
1472 __error:
1473 kfree(header);
1474 return err;
1475}
1476\f
1477/***********************************************************************
1478WaveFront: hardware-dependent interface
1479***********************************************************************/
1480
1481static void
1482process_sample_hdr (u8 *buf)
1483
1484{
1485 wavefront_sample s;
1486 u8 *ptr;
1487
1488 ptr = buf;
1489
1490 /* The board doesn't send us an exact copy of a "wavefront_sample"
1491 in response to an Upload Sample Header command. Instead, we
1492 have to convert the data format back into our data structure,
1493 just as in the Download Sample command, where we have to do
1494 something very similar in the reverse direction.
1495 */
1496
1497 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1498 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1499 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1500 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1501 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1502
1503 s.SampleResolution = *ptr & 0x3;
1504 s.Loop = *ptr & 0x8;
1505 s.Bidirectional = *ptr & 0x10;
1506 s.Reverse = *ptr & 0x40;
1507
1508 /* Now copy it back to where it came from */
1509
1510 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1511}
1512
1513static int
1514wavefront_synth_control (snd_wavefront_card_t *acard,
1515 wavefront_control *wc)
1516
1517{
1518 snd_wavefront_t *dev = &acard->wavefront;
1519 unsigned char patchnumbuf[2];
1520 int i;
1521
1522 DPRINT (WF_DEBUG_CMD, "synth control with "
1523 "cmd 0x%x\n", wc->cmd);
1524
1525 /* Pre-handling of or for various commands */
1526
1527 switch (wc->cmd) {
1528
1529 case WFC_DISABLE_INTERRUPTS:
1530 snd_printk ("interrupts disabled.\n");
1531 outb (0x80|0x20, dev->control_port);
1532 dev->interrupts_are_midi = 1;
1533 return 0;
1534
1535 case WFC_ENABLE_INTERRUPTS:
1536 snd_printk ("interrupts enabled.\n");
1537 outb (0x80|0x40|0x20, dev->control_port);
1538 dev->interrupts_are_midi = 1;
1539 return 0;
1540
1541 case WFC_INTERRUPT_STATUS:
1542 wc->rbuf[0] = dev->interrupts_are_midi;
1543 return 0;
1544
1545 case WFC_ROMSAMPLES_RDONLY:
1546 dev->rom_samples_rdonly = wc->wbuf[0];
1547 wc->status = 0;
1548 return 0;
1549
1550 case WFC_IDENTIFY_SLOT_TYPE:
1551 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1552 if (i <0 || i >= WF_MAX_SAMPLE) {
1553 snd_printk ("invalid slot ID %d\n",
1554 i);
1555 wc->status = EINVAL;
1556 return -EINVAL;
1557 }
1558 wc->rbuf[0] = dev->sample_status[i];
1559 wc->status = 0;
1560 return 0;
1561
1562 case WFC_DEBUG_DRIVER:
1563 dev->debug = wc->wbuf[0];
1564 snd_printk ("debug = 0x%x\n", dev->debug);
1565 return 0;
1566
1567 case WFC_UPLOAD_PATCH:
1568 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1569 memcpy (wc->wbuf, patchnumbuf, 2);
1570 break;
1571
1572 case WFC_UPLOAD_MULTISAMPLE:
1573 /* multisamples have to be handled differently, and
1574 cannot be dealt with properly by snd_wavefront_cmd() alone.
1575 */
1576 wc->status = wavefront_fetch_multisample
1577 (dev, (wavefront_patch_info *) wc->rbuf);
1578 return 0;
1579
1580 case WFC_UPLOAD_SAMPLE_ALIAS:
1581 snd_printk ("support for sample alias upload "
1582 "being considered.\n");
1583 wc->status = EINVAL;
1584 return -EINVAL;
1585 }
1586
1587 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1588
1589 /* Post-handling of certain commands.
1590
1591 In particular, if the command was an upload, demunge the data
1592 so that the user-level doesn't have to think about it.
1593 */
1594
1595 if (wc->status == 0) {
1596 switch (wc->cmd) {
1597 /* intercept any freemem requests so that we know
1598 we are always current with the user-level view
1599 of things.
1600 */
1601
1602 case WFC_REPORT_FREE_MEMORY:
1603 dev->freemem = demunge_int32 (wc->rbuf, 4);
1604 break;
1605
1606 case WFC_UPLOAD_PATCH:
1607 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1608 break;
1609
1610 case WFC_UPLOAD_PROGRAM:
1611 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1612 break;
1613
1614 case WFC_UPLOAD_EDRUM_PROGRAM:
1615 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1616 break;
1617
1618 case WFC_UPLOAD_SAMPLE_HEADER:
1619 process_sample_hdr (wc->rbuf);
1620 break;
1621
1622 case WFC_UPLOAD_SAMPLE_ALIAS:
1623 snd_printk ("support for "
1624 "sample aliases still "
1625 "being considered.\n");
1626 break;
1627
1628 case WFC_VMIDI_OFF:
1629 snd_wavefront_midi_disable_virtual (acard);
1630 break;
1631
1632 case WFC_VMIDI_ON:
1633 snd_wavefront_midi_enable_virtual (acard);
1634 break;
1635 }
1636 }
1637
1638 return 0;
1639}
1640
1641int
542172f3 1642snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1da177e4
LT		 1643
1644{
1645 if (!try_module_get(hw->card->module))
1646 return -EFAULT;
1647 file->private_data = hw;
1648 return 0;
1649}
1650
1651int
542172f3 1652snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1da177e4
LT		 1653
1654{
1655 module_put(hw->card->module);
1656 return 0;
1657}
1658
1659int
542172f3 1660snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1da177e4
LT		 1661 unsigned int cmd, unsigned long arg)
1662
1663{
542172f3 1664 struct snd_card *card;
1da177e4
LT		 1665 snd_wavefront_t *dev;
1666 snd_wavefront_card_t *acard;
1667 wavefront_control *wc;
1668 void __user *argp = (void __user *)arg;
1669 int err;
1670
542172f3 1671 card = (struct snd_card *) hw->card;
1da177e4 1672
622207dc
TI		 1673 if (snd_BUG_ON(!card))
1674 return -ENODEV;
1675 if (snd_BUG_ON(!card->private_data))
1676 return -ENODEV;
1da177e4
LT		 1677
1678 acard = card->private_data;
1679 dev = &acard->wavefront;
1680
1681 switch (cmd) {
1682 case WFCTL_LOAD_SPP:
1683 if (wavefront_load_patch (dev, argp) != 0) {
1684 return -EIO;
1685 }
1686 break;
1687
1688 case WFCTL_WFCMD:
68425adc
LZ		 1689 wc = memdup_user(argp, sizeof(*wc));
1690 if (IS_ERR(wc))
1691 return PTR_ERR(wc);
1692
1693 if (wavefront_synth_control (acard, wc) < 0)
1da177e4
LT		 1694 err = -EIO;
1695 else if (copy_to_user (argp, wc, sizeof (*wc)))
1696 err = -EFAULT;
1697 else
1698 err = 0;
1699 kfree(wc);
1700 return err;
1701
1702 default:
1703 return -EINVAL;
1704 }
1705
1706 return 0;
1707}
1708
1709\f
1710/***********************************************************************/
1711/* WaveFront: interface for card-level wavefront module */
1712/***********************************************************************/
1713
1714void
1715snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1716{
1717 snd_wavefront_t *dev = &card->wavefront;
1718
1719 /*
1720 Some comments on interrupts. I attempted a version of this
1721 driver that used interrupts throughout the code instead of
1722 doing busy and/or sleep-waiting. Alas, it appears that once
1723 the Motorola firmware is downloaded, the card *never*
1724 generates an RX interrupt. These are successfully generated
1725 during firmware loading, and after that wavefront_status()
1726 reports that an interrupt is pending on the card from time
1727 to time, but it never seems to be delivered to this
1728 driver. Note also that wavefront_status() continues to
1729 report that RX interrupts are enabled, suggesting that I
1730 didn't goof up and disable them by mistake.
1731
1732 Thus, I stepped back to a prior version of
1733 wavefront_wait(), the only place where this really
1734 matters. Its sad, but I've looked through the code to check
1735 on things, and I really feel certain that the Motorola
1736 firmware prevents RX-ready interrupts.
1737 */
1738
1739 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1740 return;
1741 }
1742
1743 spin_lock(&dev->irq_lock);
1744 dev->irq_ok = 1;
1745 dev->irq_cnt++;
1746 spin_unlock(&dev->irq_lock);
1747 wake_up(&dev->interrupt_sleeper);
1748}
1749
1750/* STATUS REGISTER
1751
17520 Host Rx Interrupt Enable (1=Enabled)
17531 Host Rx Register Full (1=Full)
17542 Host Rx Interrupt Pending (1=Interrupt)
17553 Unused
17564 Host Tx Interrupt (1=Enabled)
17575 Host Tx Register empty (1=Empty)
17586 Host Tx Interrupt Pending (1=Interrupt)
17597 Unused
1760*/
1761
1bff292e 1762static int
1da177e4
LT		 1763snd_wavefront_interrupt_bits (int irq)
1764
1765{
1766 int bits;
1767
1768 switch (irq) {
1769 case 9:
1770 bits = 0x00;
1771 break;
1772 case 5:
1773 bits = 0x08;
1774 break;
1775 case 12:
1776 bits = 0x10;
1777 break;
1778 case 15:
1779 bits = 0x18;
1780 break;
1781
1782 default:
1783 snd_printk ("invalid IRQ %d\n", irq);
1784 bits = -1;
1785 }
1786
1787 return bits;
1788}
1789
1bff292e 1790static void
1da177e4 1791wavefront_should_cause_interrupt (snd_wavefront_t *dev,
d86d0193 1792 int val, int port, unsigned long timeout)
1da177e4
LT		 1793
1794{
ac6424b9 1795 wait_queue_entry_t wait;
1da177e4
LT		 1796
1797 init_waitqueue_entry(&wait, current);
1798 spin_lock_irq(&dev->irq_lock);
1799 add_wait_queue(&dev->interrupt_sleeper, &wait);
1800 dev->irq_ok = 0;
1801 outb (val,port);
1802 spin_unlock_irq(&dev->irq_lock);
d86d0193
RH		 1803 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1804 schedule_timeout_uninterruptible(1);
1805 barrier();
1da177e4
LT		 1806 }
1807}
1808
1bff292e 1809static int
1da177e4
LT		 1810wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1811
1812{
1813 int bits;
1814 int hwv[2];
1815
1816 /* IRQ already checked */
1817
1818 bits = snd_wavefront_interrupt_bits (dev->irq);
1819
1820 /* try reset of port */
1821
1822 outb (0x0, dev->control_port);
1823
1824 /* At this point, the board is in reset, and the H/W initialization
1825 register is accessed at the same address as the data port.
1826
1827 Bit 7 - Enable IRQ Driver
1828 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1829 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1830
1831 Bit 6 - MIDI Interface Select
1832
1833 0 - Use the MIDI Input from the 26-pin WaveBlaster
1834 compatible header as the serial MIDI source
1835 1 - Use the MIDI Input from the 9-pin D connector as the
1836 serial MIDI source.
1837
1838 Bits 5:3 - IRQ Selection
1839 0 0 0 - IRQ 2/9
1840 0 0 1 - IRQ 5
1841 0 1 0 - IRQ 12
1842 0 1 1 - IRQ 15
1843 1 0 0 - Reserved
1844 1 0 1 - Reserved
1845 1 1 0 - Reserved
1846 1 1 1 - Reserved
1847
1848 Bits 2:1 - Reserved
1849 Bit 0 - Disable Boot ROM
1850 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1851 1 - memory accesses to 03FC30-03FFFFH are directed to external
1852 storage.
1853
1854 */
1855
1856 /* configure hardware: IRQ, enable interrupts,
1857 plus external 9-pin MIDI interface selected
1858 */
1859
1860 outb (0x80 | 0x40 | bits, dev->data_port);
1861
1862 /* CONTROL REGISTER
1863
1864 0 Host Rx Interrupt Enable (1=Enabled) 0x1
1865 1 Unused 0x2
1866 2 Unused 0x4
1867 3 Unused 0x8
1868 4 Host Tx Interrupt Enable 0x10
1869 5 Mute (0=Mute; 1=Play) 0x20
1870 6 Master Interrupt Enable (1=Enabled) 0x40
1871 7 Master Reset (0=Reset; 1=Run) 0x80
1872
1873 Take us out of reset, mute output, master + TX + RX interrupts on.
1874
1875 We'll get an interrupt presumably to tell us that the TX
1876 register is clear.
1877 */
1878
1879 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1880 dev->control_port,
1881 (reset_time*HZ)/100);
1882
1883 /* Note: data port is now the data port, not the h/w initialization
1884 port.
1885 */
1886
1887 if (!dev->irq_ok) {
1888 snd_printk ("intr not received after h/w un-reset.\n");
1889 goto gone_bad;
1890 }
1891
1892 /* Note: data port is now the data port, not the h/w initialization
1893 port.
1894
1895 At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1896 will work. So, issue one of them, and wait for TX
1897 interrupt. This can take a *long* time after a cold boot,
1898 while the ISC ROM does its RAM test. The SDK says up to 4
1899 seconds - with 12MB of RAM on a Tropez+, it takes a lot
1900 longer than that (~16secs). Note that the card understands
1901 the difference between a warm and a cold boot, so
1902 subsequent ISC2115 reboots (say, caused by module
1903 reloading) will get through this much faster.
1904
1905 XXX Interesting question: why is no RX interrupt received first ?
1906 */
1907
1908 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION,
1909 dev->data_port, ramcheck_time*HZ);
1910
1911 if (!dev->irq_ok) {
1912 snd_printk ("post-RAM-check interrupt not received.\n");
1913 goto gone_bad;
1914 }
1915
1916 if (!wavefront_wait (dev, STAT_CAN_READ)) {
1917 snd_printk ("no response to HW version cmd.\n");
1918 goto gone_bad;
1919 }
1920
520226e9
TI		 1921 hwv[0] = wavefront_read(dev);
1922 if (hwv[0] == -1) {
1da177e4
LT		 1923 snd_printk ("board not responding correctly.\n");
1924 goto gone_bad;
1925 }
1926
1927 if (hwv[0] == 0xFF) { /* NAK */
1928
1929 /* Board's RAM test failed. Try to read error code,
1930 and tell us about it either way.
1931 */
1932
520226e9
TI		 1933 hwv[0] = wavefront_read(dev);
1934 if (hwv[0] == -1) {
1da177e4
LT		 1935 snd_printk ("on-board RAM test failed "
1936 "(bad error code).\n");
1937 } else {
1938 snd_printk ("on-board RAM test failed "
1939 "(error code: 0x%x).\n",
1940 hwv[0]);
1941 }
1942 goto gone_bad;
1943 }
1944
1945 /* We're OK, just get the next byte of the HW version response */
1946
520226e9
TI		 1947 hwv[1] = wavefront_read(dev);
1948 if (hwv[1] == -1) {
1da177e4
LT		 1949 snd_printk ("incorrect h/w response.\n");
1950 goto gone_bad;
1951 }
1952
1953 snd_printk ("hardware version %d.%d\n",
1954 hwv[0], hwv[1]);
1955
1956 return 0;
1957
1958
1959 gone_bad:
1960 return (1);
1961}
1962
1bff292e 1963static int
1da177e4
LT		 1964wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1965
1966{
af134528 1967 const unsigned char *buf;
c2b1239a 1968 int len, err;
1da177e4 1969 int section_cnt_downloaded = 0;
c2b1239a 1970 const struct firmware *firmware;
1da177e4 1971
c2b1239a
TI		 1972 err = request_firmware(&firmware, path, dev->card->dev);
1973 if (err < 0) {
1974 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1da177e4
LT		 1975 return 1;
1976 }
1977
c2b1239a
TI		 1978 len = 0;
1979 buf = firmware->data;
1980 for (;;) {
1981 int section_length = *(signed char *)buf;
1982 if (section_length == 0)
1da177e4 1983 break;
1da177e4 1984 if (section_length < 0 || section_length > WF_SECTION_MAX) {
c2b1239a
TI		 1985 snd_printk(KERN_ERR
1986 "invalid firmware section length %d\n",
1987 section_length);
1da177e4
LT		 1988 goto failure;
1989 }
c2b1239a
TI		 1990 buf++;
1991 len++;
1da177e4 1992
c2b1239a
TI		 1993 if (firmware->size < len + section_length) {
1994 snd_printk(KERN_ERR "firmware section read error.\n");
1da177e4
LT		 1995 goto failure;
1996 }
1997
1998 /* Send command */
c2b1239a 1999 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1da177e4 2000 goto failure;
1da177e4 2001
c2b1239a
TI		 2002 for (; section_length; section_length--) {
2003 if (wavefront_write(dev, *buf))
1da177e4 2004 goto failure;
c2b1239a
TI		 2005 buf++;
2006 len++;
1da177e4
LT		 2007 }
2008
2009 /* get ACK */
c2b1239a
TI		 2010 if (!wavefront_wait(dev, STAT_CAN_READ)) {
2011 snd_printk(KERN_ERR "time out for firmware ACK.\n");
2012 goto failure;
2013 }
2014 err = inb(dev->data_port);
2015 if (err != WF_ACK) {
2016 snd_printk(KERN_ERR
2017 "download of section #%d not "
2018 "acknowledged, ack = 0x%x\n",
2019 section_cnt_downloaded + 1, err);
1da177e4
LT		 2020 goto failure;
2021 }
2022
c2b1239a 2023 section_cnt_downloaded++;
1da177e4
LT		 2024 }
2025
c2b1239a 2026 release_firmware(firmware);
1da177e4
LT		 2027 return 0;
2028
2029 failure:
c2b1239a
TI		 2030 release_firmware(firmware);
2031 snd_printk(KERN_ERR "firmware download failed!!!\n");
1da177e4
LT		 2032 return 1;
2033}
2034
2035
1bff292e 2036static int
1da177e4
LT		 2037wavefront_do_reset (snd_wavefront_t *dev)
2038
2039{
2040 char voices[1];
2041
2042 if (wavefront_reset_to_cleanliness (dev)) {
2043 snd_printk ("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 snd_printk ("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 snd_printk ("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
520226e9
TI		 2093 dev->freemem = wavefront_freemem(dev);
2094 if (dev->freemem < 0)
1da177e4 2095 goto gone_bad;
1da177e4
LT		 2096
2097 snd_printk ("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 snd_printk ("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 snd_printk ("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
1bff292e 2125int
1da177e4
LT		 2126snd_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
1bff292e 2167int
1da177e4
LT		 2168snd_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 snd_printk ("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 snd_printk ("not raw, but no "
2201 "hardware version!\n");
2202 return -1;
2203 }
2204
2205 if (!wf_raw) {
2206 return 0;
2207 } else {
2208 snd_printk ("reloading firmware as you requested.\n");
2209 dev->israw = 1;
2210 }
2211
2212 } else {
2213
2214 dev->israw = 1;
2215 snd_printk ("no response to firmware probe, assume raw.\n");
2216
2217 }
2218
2219 return 0;
2220}
c2b1239a
TI		 2221
2222MODULE_FIRMWARE(DEFAULT_OSPATH);
Linux 6.x block layer and io_uring tree(s)