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