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