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