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

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

Version: ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ 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.78 ] ~ [ 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         if (header->number >= ARRAY_SIZE(dev->patch_status))
789                 return -EINVAL;
790 
791         dev->patch_status[header->number] |= WF_SLOT_FILLED;
792 
793         bptr = buf;
794         bptr = munge_int32 (header->number, buf, 2);
795         munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
796     
797         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
798                 snd_printk ("download patch failed\n");
799                 return -EIO;
800         }
801 
802         return (0);
803 }
804 
805 static int
806 wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header)
807 
808 {
809         unsigned char buf[WF_PROGRAM_BYTES+1];
810         int i;
811 
812         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
813                 header->number);
814 
815         if (header->number >= ARRAY_SIZE(dev->prog_status))
816                 return -EINVAL;
817 
818         dev->prog_status[header->number] = WF_SLOT_USED;
819 
820         /* XXX need to zero existing SLOT_USED bit for program_status[i]
821            where `i' is the program that's being (potentially) overwritten.
822         */
823     
824         for (i = 0; i < WF_NUM_LAYERS; i++) {
825                 if (header->hdr.pr.layer[i].mute) {
826                         dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
827                                 WF_SLOT_USED;
828 
829                         /* XXX need to mark SLOT_USED for sample used by
830                            patch_number, but this means we have to load it. Ick.
831                         */
832                 }
833         }
834 
835         buf[0] = header->number;
836         munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
837     
838         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
839                 snd_printk ("download patch failed\n"); 
840                 return -EIO;
841         }
842 
843         return (0);
844 }
845 
846 static int
847 wavefront_freemem (snd_wavefront_t *dev)
848 
849 {
850         char rbuf[8];
851 
852         if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) {
853                 snd_printk ("can't get memory stats.\n");
854                 return -1;
855         } else {
856                 return demunge_int32 (rbuf, 4);
857         }
858 }
859 
860 static int
861 wavefront_send_sample (snd_wavefront_t *dev, 
862                        wavefront_patch_info *header,
863                        u16 __user *dataptr,
864                        int data_is_unsigned)
865 
866 {
867         /* samples are downloaded via a 16-bit wide i/o port
868            (you could think of it as 2 adjacent 8-bit wide ports
869            but its less efficient that way). therefore, all
870            the blocksizes and so forth listed in the documentation,
871            and used conventionally to refer to sample sizes,
872            which are given in 8-bit units (bytes), need to be
873            divided by 2.
874         */
875 
876         u16 sample_short = 0;
877         u32 length;
878         u16 __user *data_end = NULL;
879         unsigned int i;
880         const unsigned int max_blksize = 4096/2;
881         unsigned int written;
882         unsigned int blocksize;
883         int dma_ack;
884         int blocknum;
885         unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES];
886         unsigned char *shptr;
887         int skip = 0;
888         int initial_skip = 0;
889 
890         DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, "
891                                       "type %d, %d bytes from 0x%lx\n",
892                                       header->size ? "" : "header ", 
893                                       header->number, header->subkey,
894                                       header->size,
895                                       (unsigned long) header->dataptr);
896 
897         if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
898                 int x;
899 
900                 if ((x = wavefront_find_free_sample (dev)) < 0) {
901                         return -ENOMEM;
902                 }
903                 snd_printk ("unspecified sample => %d\n", x);
904                 header->number = x;
905         }
906 
907         if (header->number >= WF_MAX_SAMPLE)
908                 return -EINVAL;
909 
910         if (header->size) {
911 
912                 /* XXX it's a debatable point whether or not RDONLY semantics
913                    on the ROM samples should cover just the sample data or
914                    the sample header. For now, it only covers the sample data,
915                    so anyone is free at all times to rewrite sample headers.
916 
917                    My reason for this is that we have the sample headers
918                    available in the WFB file for General MIDI, and so these
919                    can always be reset if needed. The sample data, however,
920                    cannot be recovered without a complete reset and firmware
921                    reload of the ICS2115, which is a very expensive operation.
922 
923                    So, doing things this way allows us to honor the notion of
924                    "RESETSAMPLES" reasonably cheaply. Note however, that this
925                    is done purely at user level: there is no WFB parser in
926                    this driver, and so a complete reset (back to General MIDI,
927                    or theoretically some other configuration) is the
928                    responsibility of the user level library. 
929 
930                    To try to do this in the kernel would be a little
931                    crazy: we'd need 158K of kernel space just to hold
932                    a copy of the patch/program/sample header data.
933                 */
934 
935                 if (dev->rom_samples_rdonly) {
936                         if (dev->sample_status[header->number] & WF_SLOT_ROM) {
937                                 snd_printk ("sample slot %d "
938                                             "write protected\n",
939                                             header->number);
940                                 return -EACCES;
941                         }
942                 }
943 
944                 wavefront_delete_sample (dev, header->number);
945         }
946 
947         if (header->size) {
948                 dev->freemem = wavefront_freemem (dev);
949 
950                 if (dev->freemem < (int)header->size) {
951                         snd_printk ("insufficient memory to "
952                                     "load %d byte sample.\n",
953                                     header->size);
954                         return -ENOMEM;
955                 }
956         
957         }
958 
959         skip = WF_GET_CHANNEL(&header->hdr.s);
960 
961         if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
962                 snd_printk ("channel selection only "
963                             "possible on 16-bit samples");
964                 return -EINVAL;
965         }
966 
967         switch (skip) {
968         case 0:
969                 initial_skip = 0;
970                 skip = 1;
971                 break;
972         case 1:
973                 initial_skip = 0;
974                 skip = 2;
975                 break;
976         case 2:
977                 initial_skip = 1;
978                 skip = 2;
979                 break;
980         case 3:
981                 initial_skip = 2;
982                 skip = 3;
983                 break;
984         case 4:
985                 initial_skip = 3;
986                 skip = 4;
987                 break;
988         case 5:
989                 initial_skip = 4;
990                 skip = 5;
991                 break;
992         case 6:
993                 initial_skip = 5;
994                 skip = 6;
995                 break;
996         }
997 
998         DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => "
999                                       "initial skip = %d, skip = %d\n",
1000                                       WF_GET_CHANNEL (&header->hdr.s),
1001                                       initial_skip, skip);
1002     
1003         /* Be safe, and zero the "Unused" bits ... */
1004 
1005         WF_SET_CHANNEL(&header->hdr.s, 0);
1006 
1007         /* adjust size for 16 bit samples by dividing by two.  We always
1008            send 16 bits per write, even for 8 bit samples, so the length
1009            is always half the size of the sample data in bytes.
1010         */
1011 
1012         length = header->size / 2;
1013 
1014         /* the data we're sent has not been munged, and in fact, the
1015            header we have to send isn't just a munged copy either.
1016            so, build the sample header right here.
1017         */
1018 
1019         shptr = &sample_hdr[0];
1020 
1021         shptr = munge_int32 (header->number, shptr, 2);
1022 
1023         if (header->size) {
1024                 shptr = munge_int32 (length, shptr, 4);
1025         }
1026 
1027         /* Yes, a 4 byte result doesn't contain all of the offset bits,
1028            but the offset only uses 24 bits.
1029         */
1030 
1031         shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1032                              shptr, 4);
1033         shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1034                              shptr, 4);
1035         shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1036                              shptr, 4);
1037         shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1038                              shptr, 4);
1039         
1040         /* This one is truly weird. What kind of weirdo decided that in
1041            a system dominated by 16 and 32 bit integers, they would use
1042            a just 12 bits ?
1043         */
1044         
1045         shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1046         
1047         /* Why is this nybblified, when the MSB is *always* zero ? 
1048            Anyway, we can't take address of bitfield, so make a
1049            good-faith guess at where it starts.
1050         */
1051         
1052         shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1053                              shptr, 2);
1054 
1055         if (snd_wavefront_cmd (dev, 
1056                            header->size ?
1057                            WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER,
1058                            NULL, sample_hdr)) {
1059                 snd_printk ("sample %sdownload refused.\n",
1060                             header->size ? "" : "header ");
1061                 return -EIO;
1062         }
1063 
1064         if (header->size == 0) {
1065                 goto sent; /* Sorry. Just had to have one somewhere */
1066         }
1067     
1068         data_end = dataptr + length;
1069 
1070         /* Do any initial skip over an unused channel's data */
1071 
1072         dataptr += initial_skip;
1073     
1074         for (written = 0, blocknum = 0;
1075              written < length; written += max_blksize, blocknum++) {
1076         
1077                 if ((length - written) > max_blksize) {
1078                         blocksize = max_blksize;
1079                 } else {
1080                         /* round to nearest 16-byte value */
1081                         blocksize = ALIGN(length - written, 8);
1082                 }
1083 
1084                 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) {
1085                         snd_printk ("download block "
1086                                     "request refused.\n");
1087                         return -EIO;
1088                 }
1089 
1090                 for (i = 0; i < blocksize; i++) {
1091 
1092                         if (dataptr < data_end) {
1093                 
1094                                 __get_user (sample_short, dataptr);
1095                                 dataptr += skip;
1096                 
1097                                 if (data_is_unsigned) { /* GUS ? */
1098 
1099                                         if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1100                         
1101                                                 /* 8 bit sample
1102                                                  resolution, sign
1103                                                  extend both bytes.
1104                                                 */
1105                         
1106                                                 ((unsigned char*)
1107                                                  &sample_short)[0] += 0x7f;
1108                                                 ((unsigned char*)
1109                                                  &sample_short)[1] += 0x7f;
1110                         
1111                                         } else {
1112                         
1113                                                 /* 16 bit sample
1114                                                  resolution, sign
1115                                                  extend the MSB.
1116                                                 */
1117                         
1118                                                 sample_short += 0x7fff;
1119                                         }
1120                                 }
1121 
1122                         } else {
1123 
1124                                 /* In padding section of final block:
1125 
1126                                    Don't fetch unsupplied data from
1127                                    user space, just continue with
1128                                    whatever the final value was.
1129                                 */
1130                         }
1131             
1132                         if (i < blocksize - 1) {
1133                                 outw (sample_short, dev->block_port);
1134                         } else {
1135                                 outw (sample_short, dev->last_block_port);
1136                         }
1137                 }
1138 
1139                 /* Get "DMA page acknowledge", even though its really
1140                    nothing to do with DMA at all.
1141                 */
1142         
1143                 if ((dma_ack = wavefront_read (dev)) != WF_DMA_ACK) {
1144                         if (dma_ack == -1) {
1145                                 snd_printk ("upload sample "
1146                                             "DMA ack timeout\n");
1147                                 return -EIO;
1148                         } else {
1149                                 snd_printk ("upload sample "
1150                                             "DMA ack error 0x%x\n",
1151                                             dma_ack);
1152                                 return -EIO;
1153                         }
1154                 }
1155         }
1156 
1157         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1158 
1159         /* Note, label is here because sending the sample header shouldn't
1160            alter the sample_status info at all.
1161         */
1162 
1163  sent:
1164         return (0);
1165 }
1166 
1167 static int
1168 wavefront_send_alias (snd_wavefront_t *dev, wavefront_patch_info *header)
1169 
1170 {
1171         unsigned char alias_hdr[WF_ALIAS_BYTES];
1172 
1173         DPRINT (WF_DEBUG_LOAD_PATCH, "download alias, %d is "
1174                                       "alias for %d\n",
1175                                       header->number,
1176                                       header->hdr.a.OriginalSample);
1177     
1178         munge_int32 (header->number, &alias_hdr[0], 2);
1179         munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1180         munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1181                      &alias_hdr[4], 4);
1182         munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1183                      &alias_hdr[8], 4);
1184         munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1185                      &alias_hdr[12], 4);
1186         munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1187                      &alias_hdr[16], 4);
1188         munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1189         munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1190 
1191         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
1192                 snd_printk ("download alias failed.\n");
1193                 return -EIO;
1194         }
1195 
1196         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1197 
1198         return (0);
1199 }
1200 
1201 static int
1202 wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header)
1203 {
1204         int i;
1205         int num_samples;
1206         unsigned char *msample_hdr;
1207 
1208         msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
1209         if (! msample_hdr)
1210                 return -ENOMEM;
1211 
1212         munge_int32 (header->number, &msample_hdr[0], 2);
1213 
1214         /* You'll recall at this point that the "number of samples" value
1215            in a wavefront_multisample struct is actually the log2 of the
1216            real number of samples.
1217         */
1218 
1219         num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1220         msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1221 
1222         DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n",
1223                                       header->number,
1224                                       header->hdr.ms.NumberOfSamples,
1225                                       num_samples);
1226 
1227         for (i = 0; i < num_samples; i++) {
1228                 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n",
1229                        i, header->hdr.ms.SampleNumber[i]);
1230                 munge_int32 (header->hdr.ms.SampleNumber[i],
1231                      &msample_hdr[3+(i*2)], 2);
1232         }
1233     
1234         /* Need a hack here to pass in the number of bytes
1235            to be written to the synth. This is ugly, and perhaps
1236            one day, I'll fix it.
1237         */
1238 
1239         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE, 
1240                            (unsigned char *) (long) ((num_samples*2)+3),
1241                            msample_hdr)) {
1242                 snd_printk ("download of multisample failed.\n");
1243                 kfree(msample_hdr);
1244                 return -EIO;
1245         }
1246 
1247         dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1248 
1249         kfree(msample_hdr);
1250         return (0);
1251 }
1252 
1253 static int
1254 wavefront_fetch_multisample (snd_wavefront_t *dev, 
1255                              wavefront_patch_info *header)
1256 {
1257         int i;
1258         unsigned char log_ns[1];
1259         unsigned char number[2];
1260         int num_samples;
1261 
1262         munge_int32 (header->number, number, 2);
1263     
1264         if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
1265                 snd_printk ("upload multisample failed.\n");
1266                 return -EIO;
1267         }
1268     
1269         DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n",
1270                                 header->number, log_ns[0]);
1271 
1272         header->hdr.ms.NumberOfSamples = log_ns[0];
1273 
1274         /* get the number of samples ... */
1275 
1276         num_samples = (1 << log_ns[0]);
1277     
1278         for (i = 0; i < num_samples; i++) {
1279                 char d[2];
1280                 int val;
1281         
1282                 if ((val = wavefront_read (dev)) == -1) {
1283                         snd_printk ("upload multisample failed "
1284                                     "during sample loop.\n");
1285                         return -EIO;
1286                 }
1287                 d[0] = val;
1288 
1289                 if ((val = wavefront_read (dev)) == -1) {
1290                         snd_printk ("upload multisample failed "
1291                                     "during sample loop.\n");
1292                         return -EIO;
1293                 }
1294                 d[1] = val;
1295         
1296                 header->hdr.ms.SampleNumber[i] =
1297                         demunge_int32 ((unsigned char *) d, 2);
1298         
1299                 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n",
1300                                         i, header->hdr.ms.SampleNumber[i]);
1301         }
1302 
1303         return (0);
1304 }
1305 
1306 
1307 static int
1308 wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header)
1309 
1310 {
1311         unsigned char drumbuf[WF_DRUM_BYTES];
1312         wavefront_drum *drum = &header->hdr.d;
1313         int i;
1314 
1315         DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI "
1316                 "note %d, patch = %d\n", 
1317                 header->number, drum->PatchNumber);
1318 
1319         drumbuf[0] = header->number & 0x7f;
1320 
1321         for (i = 0; i < 4; i++) {
1322                 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2);
1323         }
1324 
1325         if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
1326                 snd_printk ("download drum failed.\n");
1327                 return -EIO;
1328         }
1329 
1330         return (0);
1331 }
1332 
1333 static int 
1334 wavefront_find_free_sample (snd_wavefront_t *dev)
1335 
1336 {
1337         int i;
1338 
1339         for (i = 0; i < WF_MAX_SAMPLE; i++) {
1340                 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1341                         return i;
1342                 }
1343         }
1344         snd_printk ("no free sample slots!\n");
1345         return -1;
1346 }
1347 
1348 #if 0
1349 static int 
1350 wavefront_find_free_patch (snd_wavefront_t *dev)
1351 
1352 {
1353         int i;
1354 
1355         for (i = 0; i < WF_MAX_PATCH; i++) {
1356                 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1357                         return i;
1358                 }
1359         }
1360         snd_printk ("no free patch slots!\n");
1361         return -1;
1362 }
1363 #endif
1364 
1365 static int
1366 wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr)
1367 {
1368         wavefront_patch_info *header;
1369         int err;
1370         
1371         header = kmalloc(sizeof(*header), GFP_KERNEL);
1372         if (! header)
1373                 return -ENOMEM;
1374 
1375         if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1376                             sizeof(wavefront_any))) {
1377                 snd_printk ("bad address for load patch.\n");
1378                 err = -EFAULT;
1379                 goto __error;
1380         }
1381 
1382         DPRINT (WF_DEBUG_LOAD_PATCH, "download "
1383                                       "Sample type: %d "
1384                                       "Sample number: %d "
1385                                       "Sample size: %d\n",
1386                                       header->subkey,
1387                                       header->number,
1388                                       header->size);
1389 
1390         switch (header->subkey) {
1391         case WF_ST_SAMPLE:  /* sample or sample_header, based on patch->size */
1392 
1393                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1394                                     sizeof (wavefront_sample))) {
1395                         err = -EFAULT;
1396                         break;
1397                 }
1398 
1399                 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1400                 break;
1401 
1402         case WF_ST_MULTISAMPLE:
1403 
1404                 if (copy_from_user (&header->hdr.s, header->hdrptr,
1405                                     sizeof (wavefront_multisample))) {
1406                         err = -EFAULT;
1407                         break;
1408                 }
1409 
1410                 err = wavefront_send_multisample (dev, header);
1411                 break;
1412 
1413         case WF_ST_ALIAS:
1414 
1415                 if (copy_from_user (&header->hdr.a, header->hdrptr,
1416                                     sizeof (wavefront_alias))) {
1417                         err = -EFAULT;
1418                         break;
1419                 }
1420 
1421                 err = wavefront_send_alias (dev, header);
1422                 break;
1423 
1424         case WF_ST_DRUM:
1425                 if (copy_from_user (&header->hdr.d, header->hdrptr,
1426                                     sizeof (wavefront_drum))) {
1427                         err = -EFAULT;
1428                         break;
1429                 }
1430 
1431                 err = wavefront_send_drum (dev, header);
1432                 break;
1433 
1434         case WF_ST_PATCH:
1435                 if (copy_from_user (&header->hdr.p, header->hdrptr,
1436                                     sizeof (wavefront_patch))) {
1437                         err = -EFAULT;
1438                         break;
1439                 }
1440                 
1441                 err = wavefront_send_patch (dev, header);
1442                 break;
1443 
1444         case WF_ST_PROGRAM:
1445                 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1446                                     sizeof (wavefront_program))) {
1447                         err = -EFAULT;
1448                         break;
1449                 }
1450 
1451                 err = wavefront_send_program (dev, header);
1452                 break;
1453 
1454         default:
1455                 snd_printk ("unknown patch type %d.\n",
1456                             header->subkey);
1457                 err = -EINVAL;
1458                 break;
1459         }
1460 
1461  __error:
1462         kfree(header);
1463         return err;
1464 }
1465 
1466 /***********************************************************************
1467 WaveFront: hardware-dependent interface
1468 ***********************************************************************/
1469 
1470 static void
1471 process_sample_hdr (u8 *buf)
1472 
1473 {
1474         wavefront_sample s;
1475         u8 *ptr;
1476 
1477         ptr = buf;
1478 
1479         /* The board doesn't send us an exact copy of a "wavefront_sample"
1480            in response to an Upload Sample Header command. Instead, we 
1481            have to convert the data format back into our data structure,
1482            just as in the Download Sample command, where we have to do
1483            something very similar in the reverse direction.
1484         */
1485 
1486         *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1487         *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4;
1488         *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1489         *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4;
1490         *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3;
1491 
1492         s.SampleResolution = *ptr & 0x3;
1493         s.Loop = *ptr & 0x8;
1494         s.Bidirectional = *ptr & 0x10;
1495         s.Reverse = *ptr & 0x40;
1496 
1497         /* Now copy it back to where it came from */
1498 
1499         memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample));
1500 }
1501 
1502 static int
1503 wavefront_synth_control (snd_wavefront_card_t *acard, 
1504                          wavefront_control *wc)
1505 
1506 {
1507         snd_wavefront_t *dev = &acard->wavefront;
1508         unsigned char patchnumbuf[2];
1509         int i;
1510 
1511         DPRINT (WF_DEBUG_CMD, "synth control with "
1512                 "cmd 0x%x\n", wc->cmd);
1513 
1514         /* Pre-handling of or for various commands */
1515 
1516         switch (wc->cmd) {
1517                 
1518         case WFC_DISABLE_INTERRUPTS:
1519                 snd_printk ("interrupts disabled.\n");
1520                 outb (0x80|0x20, dev->control_port);
1521                 dev->interrupts_are_midi = 1;
1522                 return 0;
1523 
1524         case WFC_ENABLE_INTERRUPTS:
1525                 snd_printk ("interrupts enabled.\n");
1526                 outb (0x80|0x40|0x20, dev->control_port);
1527                 dev->interrupts_are_midi = 1;
1528                 return 0;
1529 
1530         case WFC_INTERRUPT_STATUS:
1531                 wc->rbuf[0] = dev->interrupts_are_midi;
1532                 return 0;
1533 
1534         case WFC_ROMSAMPLES_RDONLY:
1535                 dev->rom_samples_rdonly = wc->wbuf[0];
1536                 wc->status = 0;
1537                 return 0;
1538 
1539         case WFC_IDENTIFY_SLOT_TYPE:
1540                 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1541                 if (i <0 || i >= WF_MAX_SAMPLE) {
1542                         snd_printk ("invalid slot ID %d\n",
1543                                 i);
1544                         wc->status = EINVAL;
1545                         return -EINVAL;
1546                 }
1547                 wc->rbuf[0] = dev->sample_status[i];
1548                 wc->status = 0;
1549                 return 0;
1550 
1551         case WFC_DEBUG_DRIVER:
1552                 dev->debug = wc->wbuf[0];
1553                 snd_printk ("debug = 0x%x\n", dev->debug);
1554                 return 0;
1555 
1556         case WFC_UPLOAD_PATCH:
1557                 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1558                 memcpy (wc->wbuf, patchnumbuf, 2);
1559                 break;
1560 
1561         case WFC_UPLOAD_MULTISAMPLE:
1562                 /* multisamples have to be handled differently, and
1563                    cannot be dealt with properly by snd_wavefront_cmd() alone.
1564                 */
1565                 wc->status = wavefront_fetch_multisample
1566                         (dev, (wavefront_patch_info *) wc->rbuf);
1567                 return 0;
1568 
1569         case WFC_UPLOAD_SAMPLE_ALIAS:
1570                 snd_printk ("support for sample alias upload "
1571                         "being considered.\n");
1572                 wc->status = EINVAL;
1573                 return -EINVAL;
1574         }
1575 
1576         wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1577 
1578         /* Post-handling of certain commands.
1579 
1580            In particular, if the command was an upload, demunge the data
1581            so that the user-level doesn't have to think about it.
1582         */
1583 
1584         if (wc->status == 0) {
1585                 switch (wc->cmd) {
1586                         /* intercept any freemem requests so that we know
1587                            we are always current with the user-level view
1588                            of things.
1589                         */
1590 
1591                 case WFC_REPORT_FREE_MEMORY:
1592                         dev->freemem = demunge_int32 (wc->rbuf, 4);
1593                         break;
1594 
1595                 case WFC_UPLOAD_PATCH:
1596                         demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1597                         break;
1598 
1599                 case WFC_UPLOAD_PROGRAM:
1600                         demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1601                         break;
1602 
1603                 case WFC_UPLOAD_EDRUM_PROGRAM:
1604                         demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1605                         break;
1606 
1607                 case WFC_UPLOAD_SAMPLE_HEADER:
1608                         process_sample_hdr (wc->rbuf);
1609                         break;
1610 
1611                 case WFC_UPLOAD_SAMPLE_ALIAS:
1612                         snd_printk ("support for "
1613                                     "sample aliases still "
1614                                     "being considered.\n");
1615                         break;
1616 
1617                 case WFC_VMIDI_OFF:
1618                         snd_wavefront_midi_disable_virtual (acard);
1619                         break;
1620 
1621                 case WFC_VMIDI_ON:
1622                         snd_wavefront_midi_enable_virtual (acard);
1623                         break;
1624                 }
1625         }
1626 
1627         return 0;
1628 }
1629 
1630 int 
1631 snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file)
1632 
1633 {
1634         if (!try_module_get(hw->card->module))
1635                 return -EFAULT;
1636         file->private_data = hw;
1637         return 0;
1638 }
1639 
1640 int 
1641 snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file)
1642 
1643 {
1644         module_put(hw->card->module);
1645         return 0;
1646 }
1647 
1648 int
1649 snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
1650                            unsigned int cmd, unsigned long arg)
1651 
1652 {
1653         struct snd_card *card;
1654         snd_wavefront_t *dev;
1655         snd_wavefront_card_t *acard;
1656         wavefront_control *wc;
1657         void __user *argp = (void __user *)arg;
1658         int err;
1659 
1660         card = (struct snd_card *) hw->card;
1661 
1662         if (snd_BUG_ON(!card))
1663                 return -ENODEV;
1664         if (snd_BUG_ON(!card->private_data))
1665                 return -ENODEV;
1666 
1667         acard = card->private_data;
1668         dev = &acard->wavefront;
1669         
1670         switch (cmd) {
1671         case WFCTL_LOAD_SPP:
1672                 if (wavefront_load_patch (dev, argp) != 0) {
1673                         return -EIO;
1674                 }
1675                 break;
1676 
1677         case WFCTL_WFCMD:
1678                 wc = memdup_user(argp, sizeof(*wc));
1679                 if (IS_ERR(wc))
1680                         return PTR_ERR(wc);
1681 
1682                 if (wavefront_synth_control (acard, wc) < 0)
1683                         err = -EIO;
1684                 else if (copy_to_user (argp, wc, sizeof (*wc)))
1685                         err = -EFAULT;
1686                 else
1687                         err = 0;
1688                 kfree(wc);
1689                 return err;
1690 
1691         default:
1692                 return -EINVAL;
1693         }
1694 
1695         return 0;
1696 }
1697 
1698 
1699 /***********************************************************************/
1700 /*  WaveFront: interface for card-level wavefront module               */
1701 /***********************************************************************/
1702 
1703 void
1704 snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
1705 {
1706         snd_wavefront_t *dev = &card->wavefront;
1707 
1708         /*
1709            Some comments on interrupts. I attempted a version of this
1710            driver that used interrupts throughout the code instead of
1711            doing busy and/or sleep-waiting. Alas, it appears that once
1712            the Motorola firmware is downloaded, the card *never*
1713            generates an RX interrupt. These are successfully generated
1714            during firmware loading, and after that wavefront_status()
1715            reports that an interrupt is pending on the card from time
1716            to time, but it never seems to be delivered to this
1717            driver. Note also that wavefront_status() continues to
1718            report that RX interrupts are enabled, suggesting that I
1719            didn't goof up and disable them by mistake.
1720 
1721            Thus, I stepped back to a prior version of
1722            wavefront_wait(), the only place where this really
1723            matters. Its sad, but I've looked through the code to check
1724            on things, and I really feel certain that the Motorola
1725            firmware prevents RX-ready interrupts.
1726         */
1727 
1728         if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
1729                 return;
1730         }
1731 
1732         spin_lock(&dev->irq_lock);
1733         dev->irq_ok = 1;
1734         dev->irq_cnt++;
1735         spin_unlock(&dev->irq_lock);
1736         wake_up(&dev->interrupt_sleeper);
1737 }
1738 
1739 /* STATUS REGISTER 
1740 
1741 0 Host Rx Interrupt Enable (1=Enabled)
1742 1 Host Rx Register Full (1=Full)
1743 2 Host Rx Interrupt Pending (1=Interrupt)
1744 3 Unused
1745 4 Host Tx Interrupt (1=Enabled)
1746 5 Host Tx Register empty (1=Empty)
1747 6 Host Tx Interrupt Pending (1=Interrupt)
1748 7 Unused
1749 */
1750 
1751 static int
1752 snd_wavefront_interrupt_bits (int irq)
1753 
1754 {
1755         int bits;
1756 
1757         switch (irq) {
1758         case 9:
1759                 bits = 0x00;
1760                 break;
1761         case 5:
1762                 bits = 0x08;
1763                 break;
1764         case 12:
1765                 bits = 0x10;
1766                 break;
1767         case 15:
1768                 bits = 0x18;
1769                 break;
1770         
1771         default:
1772                 snd_printk ("invalid IRQ %d\n", irq);
1773                 bits = -1;
1774         }
1775 
1776         return bits;
1777 }
1778 
1779 static void
1780 wavefront_should_cause_interrupt (snd_wavefront_t *dev, 
1781                                   int val, int port, unsigned long timeout)
1782 
1783 {
1784         wait_queue_t wait;
1785 
1786         init_waitqueue_entry(&wait, current);
1787         spin_lock_irq(&dev->irq_lock);
1788         add_wait_queue(&dev->interrupt_sleeper, &wait);
1789         dev->irq_ok = 0;
1790         outb (val,port);
1791         spin_unlock_irq(&dev->irq_lock);
1792         while (!dev->irq_ok && time_before(jiffies, timeout)) {
1793                 schedule_timeout_uninterruptible(1);
1794                 barrier();
1795         }
1796 }
1797 
1798 static int
1799 wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
1800 
1801 {
1802         int bits;
1803         int hwv[2];
1804 
1805         /* IRQ already checked */
1806 
1807         bits = snd_wavefront_interrupt_bits (dev->irq);
1808 
1809         /* try reset of port */
1810 
1811         outb (0x0, dev->control_port); 
1812   
1813         /* At this point, the board is in reset, and the H/W initialization
1814            register is accessed at the same address as the data port.
1815      
1816            Bit 7 - Enable IRQ Driver    
1817            0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1818            1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1819      
1820            Bit 6 - MIDI Interface Select
1821 
1822            0 - Use the MIDI Input from the 26-pin WaveBlaster
1823            compatible header as the serial MIDI source
1824            1 - Use the MIDI Input from the 9-pin D connector as the
1825            serial MIDI source.
1826      
1827            Bits 5:3 - IRQ Selection
1828            0 0 0 - IRQ 2/9
1829            0 0 1 - IRQ 5
1830            0 1 0 - IRQ 12
1831            0 1 1 - IRQ 15
1832            1 0 0 - Reserved
1833            1 0 1 - Reserved
1834            1 1 0 - Reserved
1835            1 1 1 - Reserved
1836      
1837            Bits 2:1 - Reserved
1838            Bit 0 - Disable Boot ROM
1839            0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1840            1 - memory accesses to 03FC30-03FFFFH are directed to external 
1841            storage.
1842      
1843         */
1844 
1845         /* configure hardware: IRQ, enable interrupts, 
1846            plus external 9-pin MIDI interface selected
1847         */
1848 
1849         outb (0x80 | 0x40 | bits, dev->data_port);      
1850   
1851         /* CONTROL REGISTER
1852 
1853            0 Host Rx Interrupt Enable (1=Enabled)      0x1
1854            1 Unused                                    0x2
1855            2 Unused                                    0x4
1856            3 Unused                                    0x8
1857            4 Host Tx Interrupt Enable                 0x10
1858            5 Mute (0=Mute; 1=Play)                    0x20
1859            6 Master Interrupt Enable (1=Enabled)      0x40
1860            7 Master Reset (0=Reset; 1=Run)            0x80
1861 
1862            Take us out of reset, mute output, master + TX + RX interrupts on.
1863            
1864            We'll get an interrupt presumably to tell us that the TX
1865            register is clear.
1866         */
1867 
1868         wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1,
1869                                          dev->control_port,
1870                                          (reset_time*HZ)/100);
1871 
1872         /* Note: data port is now the data port, not the h/w initialization
1873            port.
1874          */
1875 
1876         if (!dev->irq_ok) {
1877                 snd_printk ("intr not received after h/w un-reset.\n");
1878                 goto gone_bad;
1879         } 
1880 
1881         /* Note: data port is now the data port, not the h/w initialization
1882            port.
1883 
1884            At this point, only "HW VERSION" or "DOWNLOAD OS" commands
1885            will work. So, issue one of them, and wait for TX
1886            interrupt. This can take a *long* time after a cold boot,
1887            while the ISC ROM does its RAM test. The SDK says up to 4
1888            seconds - with 12MB of RAM on a Tropez+, it takes a lot
1889            longer than that (~16secs). Note that the card understands
1890            the difference between a warm and a cold boot, so
1891            subsequent ISC2115 reboots (say, caused by module
1892            reloading) will get through this much faster.
1893 
1894            XXX Interesting question: why is no RX interrupt received first ?
1895         */
1896 
1897         wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION, 
1898                                          dev->data_port, ramcheck_time*HZ);
1899 
1900         if (!dev->irq_ok) {
1901                 snd_printk ("post-RAM-check interrupt not received.\n");
1902                 goto gone_bad;
1903         } 
1904 
1905         if (!wavefront_wait (dev, STAT_CAN_READ)) {
1906                 snd_printk ("no response to HW version cmd.\n");
1907                 goto gone_bad;
1908         }
1909         
1910         if ((hwv[0] = wavefront_read (dev)) == -1) {
1911                 snd_printk ("board not responding correctly.\n");
1912                 goto gone_bad;
1913         }
1914 
1915         if (hwv[0] == 0xFF) { /* NAK */
1916 
1917                 /* Board's RAM test failed. Try to read error code,
1918                    and tell us about it either way.
1919                 */
1920                 
1921                 if ((hwv[0] = wavefront_read (dev)) == -1) {
1922                         snd_printk ("on-board RAM test failed "
1923                                     "(bad error code).\n");
1924                 } else {
1925                         snd_printk ("on-board RAM test failed "
1926                                     "(error code: 0x%x).\n",
1927                                 hwv[0]);
1928                 }
1929                 goto gone_bad;
1930         }
1931 
1932         /* We're OK, just get the next byte of the HW version response */
1933 
1934         if ((hwv[1] = wavefront_read (dev)) == -1) {
1935                 snd_printk ("incorrect h/w response.\n");
1936                 goto gone_bad;
1937         }
1938 
1939         snd_printk ("hardware version %d.%d\n",
1940                     hwv[0], hwv[1]);
1941 
1942         return 0;
1943 
1944 
1945      gone_bad:
1946         return (1);
1947 }
1948 
1949 static int
1950 wavefront_download_firmware (snd_wavefront_t *dev, char *path)
1951 
1952 {
1953         const unsigned char *buf;
1954         int len, err;
1955         int section_cnt_downloaded = 0;
1956         const struct firmware *firmware;
1957 
1958         err = request_firmware(&firmware, path, dev->card->dev);
1959         if (err < 0) {
1960                 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
1961                 return 1;
1962         }
1963 
1964         len = 0;
1965         buf = firmware->data;
1966         for (;;) {
1967                 int section_length = *(signed char *)buf;
1968                 if (section_length == 0)
1969                         break;
1970                 if (section_length < 0 || section_length > WF_SECTION_MAX) {
1971                         snd_printk(KERN_ERR
1972                                    "invalid firmware section length %d\n",
1973                                    section_length);
1974                         goto failure;
1975                 }
1976                 buf++;
1977                 len++;
1978 
1979                 if (firmware->size < len + section_length) {
1980                         snd_printk(KERN_ERR "firmware section read error.\n");
1981                         goto failure;
1982                 }
1983 
1984                 /* Send command */
1985                 if (wavefront_write(dev, WFC_DOWNLOAD_OS))
1986                         goto failure;
1987         
1988                 for (; section_length; section_length--) {
1989                         if (wavefront_write(dev, *buf))
1990                                 goto failure;
1991                         buf++;
1992                         len++;
1993                 }
1994         
1995                 /* get ACK */
1996                 if (!wavefront_wait(dev, STAT_CAN_READ)) {
1997                         snd_printk(KERN_ERR "time out for firmware ACK.\n");
1998                         goto failure;
1999                 }
2000                 err = inb(dev->data_port);
2001                 if (err != WF_ACK) {
2002                         snd_printk(KERN_ERR
2003                                    "download of section #%d not "
2004                                    "acknowledged, ack = 0x%x\n",
2005                                    section_cnt_downloaded + 1, err);
2006                         goto failure;
2007                 }
2008 
2009                 section_cnt_downloaded++;
2010         }
2011 
2012         release_firmware(firmware);
2013         return 0;
2014 
2015  failure:
2016         release_firmware(firmware);
2017         snd_printk(KERN_ERR "firmware download failed!!!\n");
2018         return 1;
2019 }
2020 
2021 
2022 static int
2023 wavefront_do_reset (snd_wavefront_t *dev)
2024 
2025 {
2026         char voices[1];
2027 
2028         if (wavefront_reset_to_cleanliness (dev)) {
2029                 snd_printk ("hw reset failed.\n");
2030                 goto gone_bad;
2031         }
2032 
2033         if (dev->israw) {
2034                 if (wavefront_download_firmware (dev, ospath)) {
2035                         goto gone_bad;
2036                 }
2037 
2038                 dev->israw = 0;
2039 
2040                 /* Wait for the OS to get running. The protocol for
2041                    this is non-obvious, and was determined by
2042                    using port-IO tracing in DOSemu and some
2043                    experimentation here.
2044                    
2045                    Rather than using timed waits, use interrupts creatively.
2046                 */
2047 
2048                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2049                                                   dev->data_port,
2050                                                   (osrun_time*HZ));
2051 
2052                 if (!dev->irq_ok) {
2053                         snd_printk ("no post-OS interrupt.\n");
2054                         goto gone_bad;
2055                 }
2056                 
2057                 /* Now, do it again ! */
2058                 
2059                 wavefront_should_cause_interrupt (dev, WFC_NOOP,
2060                                                   dev->data_port, (10*HZ));
2061                 
2062                 if (!dev->irq_ok) {
2063                         snd_printk ("no post-OS interrupt(2).\n");
2064                         goto gone_bad;
2065                 }
2066 
2067                 /* OK, no (RX/TX) interrupts any more, but leave mute
2068                    in effect. 
2069                 */
2070                 
2071                 outb (0x80|0x40, dev->control_port); 
2072         }
2073 
2074         /* SETUPSND.EXE asks for sample memory config here, but since i
2075            have no idea how to interpret the result, we'll forget
2076            about it.
2077         */
2078         
2079         if ((dev->freemem = wavefront_freemem (dev)) < 0) {
2080                 goto gone_bad;
2081         }
2082                 
2083         snd_printk ("available DRAM %dk\n", dev->freemem / 1024);
2084 
2085         if (wavefront_write (dev, 0xf0) ||
2086             wavefront_write (dev, 1) ||
2087             (wavefront_read (dev) < 0)) {
2088                 dev->debug = 0;
2089                 snd_printk ("MPU emulation mode not set.\n");
2090                 goto gone_bad;
2091         }
2092 
2093         voices[0] = 32;
2094 
2095         if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) {
2096                 snd_printk ("cannot set number of voices to 32.\n");
2097                 goto gone_bad;
2098         }
2099 
2100 
2101         return 0;
2102 
2103  gone_bad:
2104         /* reset that sucker so that it doesn't bother us. */
2105 
2106         outb (0x0, dev->control_port);
2107         dev->interrupts_are_midi = 0;
2108         return 1;
2109 }
2110 
2111 int
2112 snd_wavefront_start (snd_wavefront_t *dev)
2113 
2114 {
2115         int samples_are_from_rom;
2116 
2117         /* IMPORTANT: assumes that snd_wavefront_detect() and/or
2118            wavefront_reset_to_cleanliness() has already been called 
2119         */
2120 
2121         if (dev->israw) {
2122                 samples_are_from_rom = 1;
2123         } else {
2124                 /* XXX is this always true ? */
2125                 samples_are_from_rom = 0;
2126         }
2127 
2128         if (dev->israw || fx_raw) {
2129                 if (wavefront_do_reset (dev)) {
2130                         return -1;
2131                 }
2132         }
2133         /* Check for FX device, present only on Tropez+ */
2134 
2135         dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2136 
2137         if (dev->has_fx && fx_raw) {
2138                 snd_wavefront_fx_start (dev);
2139         }
2140 
2141         wavefront_get_sample_status (dev, samples_are_from_rom);
2142         wavefront_get_program_status (dev);
2143         wavefront_get_patch_status (dev);
2144 
2145         /* Start normal operation: unreset, master interrupt enabled, no mute
2146         */
2147 
2148         outb (0x80|0x40|0x20, dev->control_port); 
2149 
2150         return (0);
2151 }
2152 
2153 int
2154 snd_wavefront_detect (snd_wavefront_card_t *card)
2155 
2156 {
2157         unsigned char   rbuf[4], wbuf[4];
2158         snd_wavefront_t *dev = &card->wavefront;
2159         
2160         /* returns zero if a WaveFront card is successfully detected.
2161            negative otherwise.
2162         */
2163 
2164         dev->israw = 0;
2165         dev->has_fx = 0;
2166         dev->debug = debug_default;
2167         dev->interrupts_are_midi = 0;
2168         dev->irq_cnt = 0;
2169         dev->rom_samples_rdonly = 1;
2170 
2171         if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) {
2172 
2173                 dev->fw_version[0] = rbuf[0];
2174                 dev->fw_version[1] = rbuf[1];
2175 
2176                 snd_printk ("firmware %d.%d already loaded.\n",
2177                             rbuf[0], rbuf[1]);
2178 
2179                 /* check that a command actually works */
2180       
2181                 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION,
2182                                        rbuf, wbuf) == 0) {
2183                         dev->hw_version[0] = rbuf[0];
2184                         dev->hw_version[1] = rbuf[1];
2185                 } else {
2186                         snd_printk ("not raw, but no "
2187                                     "hardware version!\n");
2188                         return -1;
2189                 }
2190 
2191                 if (!wf_raw) {
2192                         return 0;
2193                 } else {
2194                         snd_printk ("reloading firmware as you requested.\n");
2195                         dev->israw = 1;
2196                 }
2197 
2198         } else {
2199 
2200                 dev->israw = 1;
2201                 snd_printk ("no response to firmware probe, assume raw.\n");
2202 
2203         }
2204 
2205         return 0;
2206 }
2207 
2208 MODULE_FIRMWARE(DEFAULT_OSPATH);
2209 

~ [ 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