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