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