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