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