~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/isa/wavefront/wavefront_synth.c

Version: ~ [ linux-5.6.3 ] ~ [ linux-5.5.16 ] ~ [ linux-5.4.31 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.114 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.175 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.218 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.218 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <linux/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(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
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
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
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
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
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
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
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);
2200 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp