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