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