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