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