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