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