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 35static 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 41static 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 48static 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" 57static char *ospath = DEFAULT_OSPATH; /* the firmware file name */ 58 59static 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 72static int sleep_interval = 100; /* HZ/sleep_interval seconds per sleep */ 73static int sleep_tries = 50; /* number of times we'll try to sleep */ 74 75static int reset_time = 2; /* hundreths of a second we wait after a HW 76 reset for the expected interrupt. 77 */ 78 79static int ramcheck_time = 20; /* time in seconds to wait while ROM code 80 checks on-board RAM. 81 */ 82 83static int osrun_time = 10; /* time in seconds we wait for the OS to 84 start running. 85 */ 86module_param(wf_raw, int, 0444); 87MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS"); 88module_param(fx_raw, int, 0444); 89MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help"); 90module_param(debug_default, int, 0444); 91MODULE_PARM_DESC(debug_default, "debug parameters for card initialization"); 92module_param(wait_usecs, int, 0444); 93MODULE_PARM_DESC(wait_usecs, "how long to wait without sleeping, usecs"); 94module_param(sleep_interval, int, 0444); 95MODULE_PARM_DESC(sleep_interval, "how long to sleep when waiting for reply"); 96module_param(sleep_tries, int, 0444); 97MODULE_PARM_DESC(sleep_tries, "how many times to try sleeping during a wait"); 98module_param(ospath, charp, 0444); 99MODULE_PARM_DESC(ospath, "pathname to processed ICS2115 OS firmware"); 100module_param(reset_time, int, 0444); 101MODULE_PARM_DESC(reset_time, "how long to wait for a reset to take effect"); 102module_param(ramcheck_time, int, 0444); 103MODULE_PARM_DESC(ramcheck_time, "how many seconds to wait for the RAM test"); 104module_param(osrun_time, int, 0444); 105MODULE_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 136static int wavefront_delete_sample (snd_wavefront_t *, int sampnum); 137static int wavefront_find_free_sample (snd_wavefront_t *); 138 139struct wavefront_command { 140 int cmd; 141 char *action; 142 unsigned int read_cnt; 143 unsigned int write_cnt; 144 int need_ack; 145}; 146 147static 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 165static 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 229static const char * 230wavefront_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 244static struct wavefront_command * 245wavefront_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 259static inline int 260wavefront_status (snd_wavefront_t *dev) 261 262{ 263 return inb (dev->status_port); 264} 265 266static int 267wavefront_sleep (int limit) 268 269{ 270 schedule_timeout_interruptible(limit); 271 272 return signal_pending(current); 273} 274 275static int 276wavefront_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 306static int 307wavefront_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 318static int 319wavefront_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 332int 333snd_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/*********************************************************************** 511WaveFront data munging 512 513Things here are weird. All data written to the board cannot 514have its most significant bit set. Any data item with values 515potentially > 0x7F (127) must be split across multiple bytes. 516 517Sometimes, we need to munge numeric values that are represented on 518the x86 side as 8-32 bit values. Sometimes, we need to munge data 519that is represented on the x86 side as an array of bytes. The most 520efficient approach to handling both cases seems to be to use 2 521different functions for munging and 2 for de-munging. This avoids 522weird casting and worrying about bit-level offsets. 523 524**********************************************************************/ 525 526static unsigned char * 527munge_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 543static int 544demunge_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 557static 558unsigned char * 559munge_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 572static 573unsigned char * 574demunge_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/*********************************************************************** 593WaveFront: sample, patch and program management. 594***********************************************************************/ 595 596static int 597wavefront_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 613static int 614wavefront_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 681static int 682wavefront_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 729static int 730wavefront_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 776static int 777wavefront_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 = munge_int32 (header->number, buf, 2); 792 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES); 793 794 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) { 795 snd_printk ("download patch failed\n"); 796 return -EIO; 797 } 798 799 return (0); 800} 801 802static int 803wavefront_send_program (snd_wavefront_t *dev, wavefront_patch_info *header) 804 805{ 806 unsigned char buf[WF_PROGRAM_BYTES+1]; 807 int i; 808 809 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n", 810 header->number); 811 812 if (header->number >= ARRAY_SIZE(dev->prog_status)) 813 return -EINVAL; 814 815 dev->prog_status[header->number] = WF_SLOT_USED; 816 817 /* XXX need to zero existing SLOT_USED bit for program_status[i] 818 where `i' is the program that's being (potentially) overwritten. 819 */ 820 821 for (i = 0; i < WF_NUM_LAYERS; i++) { 822 if (header->hdr.pr.layer[i].mute) { 823 dev->patch_status[header->hdr.pr.layer[i].patch_number] |= 824 WF_SLOT_USED; 825 826 /* XXX need to mark SLOT_USED for sample used by 827 patch_number, but this means we have to load it. Ick. 828 */ 829 } 830 } 831 832 buf[0] = header->number; 833 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES); 834 835 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) { 836 snd_printk ("download patch failed\n"); 837 return -EIO; 838 } 839 840 return (0); 841} 842 843static int 844wavefront_freemem (snd_wavefront_t *dev) 845 846{ 847 char rbuf[8]; 848 849 if (snd_wavefront_cmd (dev, WFC_REPORT_FREE_MEMORY, rbuf, NULL)) { 850 snd_printk ("can't get memory stats.\n"); 851 return -1; 852 } else { 853 return demunge_int32 (rbuf, 4); 854 } 855} 856 857static int 858wavefront_send_sample (snd_wavefront_t *dev, 859 wavefront_patch_info *header, 860 u16 __user *dataptr, 861 int data_is_unsigned) 862 863{ 864 /* samples are downloaded via a 16-bit wide i/o port 865 (you could think of it as 2 adjacent 8-bit wide ports 866 but its less efficient that way). therefore, all 867 the blocksizes and so forth listed in the documentation, 868 and used conventionally to refer to sample sizes, 869 which are given in 8-bit units (bytes), need to be 870 divided by 2. 871 */ 872 873 u16 sample_short = 0; 874 u32 length; 875 u16 __user *data_end = NULL; 876 unsigned int i; 877 const unsigned int max_blksize = 4096/2; 878 unsigned int written; 879 unsigned int blocksize; 880 int dma_ack; 881 int blocknum; 882 unsigned char sample_hdr[WF_SAMPLE_HDR_BYTES]; 883 unsigned char *shptr; 884 int skip = 0; 885 int initial_skip = 0; 886 887 DPRINT (WF_DEBUG_LOAD_PATCH, "sample %sdownload for slot %d, " 888 "type %d, %d bytes from 0x%lx\n", 889 header->size ? "" : "header ", 890 header->number, header->subkey, 891 header->size, 892 (unsigned long) header->dataptr); 893 894 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) { 895 int x; 896 897 if ((x = wavefront_find_free_sample (dev)) < 0) { 898 return -ENOMEM; 899 } 900 snd_printk ("unspecified sample => %d\n", x); 901 header->number = x; 902 } 903 904 if (header->number >= WF_MAX_SAMPLE) 905 return -EINVAL; 906 907 if (header->size) { 908 909 /* XXX it's a debatable point whether or not RDONLY semantics 910 on the ROM samples should cover just the sample data or 911 the sample header. For now, it only covers the sample data, 912 so anyone is free at all times to rewrite sample headers. 913 914 My reason for this is that we have the sample headers 915 available in the WFB file for General MIDI, and so these 916 can always be reset if needed. The sample data, however, 917 cannot be recovered without a complete reset and firmware 918 reload of the ICS2115, which is a very expensive operation. 919 920 So, doing things this way allows us to honor the notion of 921 "RESETSAMPLES" reasonably cheaply. Note however, that this 922 is done purely at user level: there is no WFB parser in 923 this driver, and so a complete reset (back to General MIDI, 924 or theoretically some other configuration) is the 925 responsibility of the user level library. 926 927 To try to do this in the kernel would be a little 928 crazy: we'd need 158K of kernel space just to hold 929 a copy of the patch/program/sample header data. 930 */ 931 932 if (dev->rom_samples_rdonly) { 933 if (dev->sample_status[header->number] & WF_SLOT_ROM) { 934 snd_printk ("sample slot %d " 935 "write protected\n", 936 header->number); 937 return -EACCES; 938 } 939 } 940 941 wavefront_delete_sample (dev, header->number); 942 } 943 944 if (header->size) { 945 dev->freemem = wavefront_freemem (dev); 946 947 if (dev->freemem < (int)header->size) { 948 snd_printk ("insufficient memory to " 949 "load %d byte sample.\n", 950 header->size); 951 return -ENOMEM; 952 } 953 954 } 955 956 skip = WF_GET_CHANNEL(&header->hdr.s); 957 958 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) { 959 snd_printk ("channel selection only " 960 "possible on 16-bit samples"); 961 return -EINVAL; 962 } 963 964 switch (skip) { 965 case 0: 966 initial_skip = 0; 967 skip = 1; 968 break; 969 case 1: 970 initial_skip = 0; 971 skip = 2; 972 break; 973 case 2: 974 initial_skip = 1; 975 skip = 2; 976 break; 977 case 3: 978 initial_skip = 2; 979 skip = 3; 980 break; 981 case 4: 982 initial_skip = 3; 983 skip = 4; 984 break; 985 case 5: 986 initial_skip = 4; 987 skip = 5; 988 break; 989 case 6: 990 initial_skip = 5; 991 skip = 6; 992 break; 993 } 994 995 DPRINT (WF_DEBUG_LOAD_PATCH, "channel selection: %d => " 996 "initial skip = %d, skip = %d\n", 997 WF_GET_CHANNEL (&header->hdr.s), 998 initial_skip, skip); 999 1000 /* Be safe, and zero the "Unused" bits ... */ 1001 1002 WF_SET_CHANNEL(&header->hdr.s, 0); 1003 1004 /* adjust size for 16 bit samples by dividing by two. We always 1005 send 16 bits per write, even for 8 bit samples, so the length 1006 is always half the size of the sample data in bytes. 1007 */ 1008 1009 length = header->size / 2; 1010 1011 /* the data we're sent has not been munged, and in fact, the 1012 header we have to send isn't just a munged copy either. 1013 so, build the sample header right here. 1014 */ 1015 1016 shptr = &sample_hdr[0]; 1017 1018 shptr = munge_int32 (header->number, shptr, 2); 1019 1020 if (header->size) { 1021 shptr = munge_int32 (length, shptr, 4); 1022 } 1023 1024 /* Yes, a 4 byte result doesn't contain all of the offset bits, 1025 but the offset only uses 24 bits. 1026 */ 1027 1028 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset), 1029 shptr, 4); 1030 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset), 1031 shptr, 4); 1032 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset), 1033 shptr, 4); 1034 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset), 1035 shptr, 4); 1036 1037 /* This one is truly weird. What kind of weirdo decided that in 1038 a system dominated by 16 and 32 bit integers, they would use 1039 a just 12 bits ? 1040 */ 1041 1042 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3); 1043 1044 /* Why is this nybblified, when the MSB is *always* zero ? 1045 Anyway, we can't take address of bitfield, so make a 1046 good-faith guess at where it starts. 1047 */ 1048 1049 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1), 1050 shptr, 2); 1051 1052 if (snd_wavefront_cmd (dev, 1053 header->size ? 1054 WFC_DOWNLOAD_SAMPLE : WFC_DOWNLOAD_SAMPLE_HEADER, 1055 NULL, sample_hdr)) { 1056 snd_printk ("sample %sdownload refused.\n", 1057 header->size ? "" : "header "); 1058 return -EIO; 1059 } 1060 1061 if (header->size == 0) { 1062 goto sent; /* Sorry. Just had to have one somewhere */ 1063 } 1064 1065 data_end = dataptr + length; 1066 1067 /* Do any initial skip over an unused channel's data */ 1068 1069 dataptr += initial_skip; 1070 1071 for (written = 0, blocknum = 0; 1072 written < length; written += max_blksize, blocknum++) { 1073 1074 if ((length - written) > max_blksize) { 1075 blocksize = max_blksize; 1076 } else { 1077 /* round to nearest 16-byte value */ 1078 blocksize = ALIGN(length - written, 8); 1079 } 1080 1081 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_BLOCK, NULL, NULL)) { 1082 snd_printk ("download block " 1083 "request refused.\n"); 1084 return -EIO; 1085 } 1086 1087 for (i = 0; i < blocksize; i++) { 1088 1089 if (dataptr < data_end) { 1090 1091 if (get_user(sample_short, dataptr)) 1092 return -EFAULT; 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 1165static int 1166wavefront_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 if (header->number >= WF_MAX_SAMPLE) 1177 return -EINVAL; 1178 1179 munge_int32 (header->number, &alias_hdr[0], 2); 1180 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2); 1181 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset), 1182 &alias_hdr[4], 4); 1183 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset), 1184 &alias_hdr[8], 4); 1185 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset), 1186 &alias_hdr[12], 4); 1187 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset), 1188 &alias_hdr[16], 4); 1189 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3); 1190 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2); 1191 1192 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) { 1193 snd_printk ("download alias failed.\n"); 1194 return -EIO; 1195 } 1196 1197 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS); 1198 1199 return (0); 1200} 1201 1202static int 1203wavefront_send_multisample (snd_wavefront_t *dev, wavefront_patch_info *header) 1204{ 1205 int i; 1206 int num_samples; 1207 unsigned char *msample_hdr; 1208 1209 if (header->number >= WF_MAX_SAMPLE) 1210 return -EINVAL; 1211 1212 msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL); 1213 if (! msample_hdr) 1214 return -ENOMEM; 1215 1216 munge_int32 (header->number, &msample_hdr[0], 2); 1217 1218 /* You'll recall at this point that the "number of samples" value 1219 in a wavefront_multisample struct is actually the log2 of the 1220 real number of samples. 1221 */ 1222 1223 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7)); 1224 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples; 1225 1226 DPRINT (WF_DEBUG_LOAD_PATCH, "multi %d with %d=%d samples\n", 1227 header->number, 1228 header->hdr.ms.NumberOfSamples, 1229 num_samples); 1230 1231 for (i = 0; i < num_samples; i++) { 1232 DPRINT(WF_DEBUG_LOAD_PATCH|WF_DEBUG_DATA, "sample[%d] = %d\n", 1233 i, header->hdr.ms.SampleNumber[i]); 1234 munge_int32 (header->hdr.ms.SampleNumber[i], 1235 &msample_hdr[3+(i*2)], 2); 1236 } 1237 1238 /* Need a hack here to pass in the number of bytes 1239 to be written to the synth. This is ugly, and perhaps 1240 one day, I'll fix it. 1241 */ 1242 1243 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_MULTISAMPLE, 1244 (unsigned char *) (long) ((num_samples*2)+3), 1245 msample_hdr)) { 1246 snd_printk ("download of multisample failed.\n"); 1247 kfree(msample_hdr); 1248 return -EIO; 1249 } 1250 1251 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE); 1252 1253 kfree(msample_hdr); 1254 return (0); 1255} 1256 1257static int 1258wavefront_fetch_multisample (snd_wavefront_t *dev, 1259 wavefront_patch_info *header) 1260{ 1261 int i; 1262 unsigned char log_ns[1]; 1263 unsigned char number[2]; 1264 int num_samples; 1265 1266 munge_int32 (header->number, number, 2); 1267 1268 if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) { 1269 snd_printk ("upload multisample failed.\n"); 1270 return -EIO; 1271 } 1272 1273 DPRINT (WF_DEBUG_DATA, "msample %d has %d samples\n", 1274 header->number, log_ns[0]); 1275 1276 header->hdr.ms.NumberOfSamples = log_ns[0]; 1277 1278 /* get the number of samples ... */ 1279 1280 num_samples = (1 << log_ns[0]); 1281 1282 for (i = 0; i < num_samples; i++) { 1283 char d[2]; 1284 int val; 1285 1286 if ((val = wavefront_read (dev)) == -1) { 1287 snd_printk ("upload multisample failed " 1288 "during sample loop.\n"); 1289 return -EIO; 1290 } 1291 d[0] = val; 1292 1293 if ((val = wavefront_read (dev)) == -1) { 1294 snd_printk ("upload multisample failed " 1295 "during sample loop.\n"); 1296 return -EIO; 1297 } 1298 d[1] = val; 1299 1300 header->hdr.ms.SampleNumber[i] = 1301 demunge_int32 ((unsigned char *) d, 2); 1302 1303 DPRINT (WF_DEBUG_DATA, "msample sample[%d] = %d\n", 1304 i, header->hdr.ms.SampleNumber[i]); 1305 } 1306 1307 return (0); 1308} 1309 1310 1311static int 1312wavefront_send_drum (snd_wavefront_t *dev, wavefront_patch_info *header) 1313 1314{ 1315 unsigned char drumbuf[WF_DRUM_BYTES]; 1316 wavefront_drum *drum = &header->hdr.d; 1317 int i; 1318 1319 DPRINT (WF_DEBUG_LOAD_PATCH, "downloading edrum for MIDI " 1320 "note %d, patch = %d\n", 1321 header->number, drum->PatchNumber); 1322 1323 drumbuf[0] = header->number & 0x7f; 1324 1325 for (i = 0; i < 4; i++) { 1326 munge_int32 (((unsigned char *)drum)[i], &drumbuf[1+(i*2)], 2); 1327 } 1328 1329 if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) { 1330 snd_printk ("download drum failed.\n"); 1331 return -EIO; 1332 } 1333 1334 return (0); 1335} 1336 1337static int 1338wavefront_find_free_sample (snd_wavefront_t *dev) 1339 1340{ 1341 int i; 1342 1343 for (i = 0; i < WF_MAX_SAMPLE; i++) { 1344 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) { 1345 return i; 1346 } 1347 } 1348 snd_printk ("no free sample slots!\n"); 1349 return -1; 1350} 1351 1352#if 0 1353static int 1354wavefront_find_free_patch (snd_wavefront_t *dev) 1355 1356{ 1357 int i; 1358 1359 for (i = 0; i < WF_MAX_PATCH; i++) { 1360 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) { 1361 return i; 1362 } 1363 } 1364 snd_printk ("no free patch slots!\n"); 1365 return -1; 1366} 1367#endif 1368 1369static int 1370wavefront_load_patch (snd_wavefront_t *dev, const char __user *addr) 1371{ 1372 wavefront_patch_info *header; 1373 int err; 1374 1375 header = kmalloc(sizeof(*header), GFP_KERNEL); 1376 if (! header) 1377 return -ENOMEM; 1378 1379 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) - 1380 sizeof(wavefront_any))) { 1381 snd_printk ("bad address for load patch.\n"); 1382 err = -EFAULT; 1383 goto __error; 1384 } 1385 1386 DPRINT (WF_DEBUG_LOAD_PATCH, "download " 1387 "Sample type: %d " 1388 "Sample number: %d " 1389 "Sample size: %d\n", 1390 header->subkey, 1391 header->number, 1392 header->size); 1393 1394 switch (header->subkey) { 1395 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */ 1396 1397 if (copy_from_user (&header->hdr.s, header->hdrptr, 1398 sizeof (wavefront_sample))) { 1399 err = -EFAULT; 1400 break; 1401 } 1402 1403 err = wavefront_send_sample (dev, header, header->dataptr, 0); 1404 break; 1405 1406 case WF_ST_MULTISAMPLE: 1407 1408 if (copy_from_user (&header->hdr.s, header->hdrptr, 1409 sizeof (wavefront_multisample))) { 1410 err = -EFAULT; 1411 break; 1412 } 1413 1414 err = wavefront_send_multisample (dev, header); 1415 break; 1416 1417 case WF_ST_ALIAS: 1418 1419 if (copy_from_user (&header->hdr.a, header->hdrptr, 1420 sizeof (wavefront_alias))) { 1421 err = -EFAULT; 1422 break; 1423 } 1424 1425 err = wavefront_send_alias (dev, header); 1426 break; 1427 1428 case WF_ST_DRUM: 1429 if (copy_from_user (&header->hdr.d, header->hdrptr, 1430 sizeof (wavefront_drum))) { 1431 err = -EFAULT; 1432 break; 1433 } 1434 1435 err = wavefront_send_drum (dev, header); 1436 break; 1437 1438 case WF_ST_PATCH: 1439 if (copy_from_user (&header->hdr.p, header->hdrptr, 1440 sizeof (wavefront_patch))) { 1441 err = -EFAULT; 1442 break; 1443 } 1444 1445 err = wavefront_send_patch (dev, header); 1446 break; 1447 1448 case WF_ST_PROGRAM: 1449 if (copy_from_user (&header->hdr.pr, header->hdrptr, 1450 sizeof (wavefront_program))) { 1451 err = -EFAULT; 1452 break; 1453 } 1454 1455 err = wavefront_send_program (dev, header); 1456 break; 1457 1458 default: 1459 snd_printk ("unknown patch type %d.\n", 1460 header->subkey); 1461 err = -EINVAL; 1462 break; 1463 } 1464 1465 __error: 1466 kfree(header); 1467 return err; 1468} 1469 1470/*********************************************************************** 1471WaveFront: hardware-dependent interface 1472***********************************************************************/ 1473 1474static void 1475process_sample_hdr (u8 *buf) 1476 1477{ 1478 wavefront_sample s; 1479 u8 *ptr; 1480 1481 ptr = buf; 1482 1483 /* The board doesn't send us an exact copy of a "wavefront_sample" 1484 in response to an Upload Sample Header command. Instead, we 1485 have to convert the data format back into our data structure, 1486 just as in the Download Sample command, where we have to do 1487 something very similar in the reverse direction. 1488 */ 1489 1490 *((u32 *) &s.sampleStartOffset) = demunge_int32 (ptr, 4); ptr += 4; 1491 *((u32 *) &s.loopStartOffset) = demunge_int32 (ptr, 4); ptr += 4; 1492 *((u32 *) &s.loopEndOffset) = demunge_int32 (ptr, 4); ptr += 4; 1493 *((u32 *) &s.sampleEndOffset) = demunge_int32 (ptr, 4); ptr += 4; 1494 *((u32 *) &s.FrequencyBias) = demunge_int32 (ptr, 3); ptr += 3; 1495 1496 s.SampleResolution = *ptr & 0x3; 1497 s.Loop = *ptr & 0x8; 1498 s.Bidirectional = *ptr & 0x10; 1499 s.Reverse = *ptr & 0x40; 1500 1501 /* Now copy it back to where it came from */ 1502 1503 memcpy (buf, (unsigned char *) &s, sizeof (wavefront_sample)); 1504} 1505 1506static int 1507wavefront_synth_control (snd_wavefront_card_t *acard, 1508 wavefront_control *wc) 1509 1510{ 1511 snd_wavefront_t *dev = &acard->wavefront; 1512 unsigned char patchnumbuf[2]; 1513 int i; 1514 1515 DPRINT (WF_DEBUG_CMD, "synth control with " 1516 "cmd 0x%x\n", wc->cmd); 1517 1518 /* Pre-handling of or for various commands */ 1519 1520 switch (wc->cmd) { 1521 1522 case WFC_DISABLE_INTERRUPTS: 1523 snd_printk ("interrupts disabled.\n"); 1524 outb (0x80|0x20, dev->control_port); 1525 dev->interrupts_are_midi = 1; 1526 return 0; 1527 1528 case WFC_ENABLE_INTERRUPTS: 1529 snd_printk ("interrupts enabled.\n"); 1530 outb (0x80|0x40|0x20, dev->control_port); 1531 dev->interrupts_are_midi = 1; 1532 return 0; 1533 1534 case WFC_INTERRUPT_STATUS: 1535 wc->rbuf[0] = dev->interrupts_are_midi; 1536 return 0; 1537 1538 case WFC_ROMSAMPLES_RDONLY: 1539 dev->rom_samples_rdonly = wc->wbuf[0]; 1540 wc->status = 0; 1541 return 0; 1542 1543 case WFC_IDENTIFY_SLOT_TYPE: 1544 i = wc->wbuf[0] | (wc->wbuf[1] << 7); 1545 if (i <0 || i >= WF_MAX_SAMPLE) { 1546 snd_printk ("invalid slot ID %d\n", 1547 i); 1548 wc->status = EINVAL; 1549 return -EINVAL; 1550 } 1551 wc->rbuf[0] = dev->sample_status[i]; 1552 wc->status = 0; 1553 return 0; 1554 1555 case WFC_DEBUG_DRIVER: 1556 dev->debug = wc->wbuf[0]; 1557 snd_printk ("debug = 0x%x\n", dev->debug); 1558 return 0; 1559 1560 case WFC_UPLOAD_PATCH: 1561 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2); 1562 memcpy (wc->wbuf, patchnumbuf, 2); 1563 break; 1564 1565 case WFC_UPLOAD_MULTISAMPLE: 1566 /* multisamples have to be handled differently, and 1567 cannot be dealt with properly by snd_wavefront_cmd() alone. 1568 */ 1569 wc->status = wavefront_fetch_multisample 1570 (dev, (wavefront_patch_info *) wc->rbuf); 1571 return 0; 1572 1573 case WFC_UPLOAD_SAMPLE_ALIAS: 1574 snd_printk ("support for sample alias upload " 1575 "being considered.\n"); 1576 wc->status = EINVAL; 1577 return -EINVAL; 1578 } 1579 1580 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf); 1581 1582 /* Post-handling of certain commands. 1583 1584 In particular, if the command was an upload, demunge the data 1585 so that the user-level doesn't have to think about it. 1586 */ 1587 1588 if (wc->status == 0) { 1589 switch (wc->cmd) { 1590 /* intercept any freemem requests so that we know 1591 we are always current with the user-level view 1592 of things. 1593 */ 1594 1595 case WFC_REPORT_FREE_MEMORY: 1596 dev->freemem = demunge_int32 (wc->rbuf, 4); 1597 break; 1598 1599 case WFC_UPLOAD_PATCH: 1600 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES); 1601 break; 1602 1603 case WFC_UPLOAD_PROGRAM: 1604 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES); 1605 break; 1606 1607 case WFC_UPLOAD_EDRUM_PROGRAM: 1608 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1); 1609 break; 1610 1611 case WFC_UPLOAD_SAMPLE_HEADER: 1612 process_sample_hdr (wc->rbuf); 1613 break; 1614 1615 case WFC_UPLOAD_SAMPLE_ALIAS: 1616 snd_printk ("support for " 1617 "sample aliases still " 1618 "being considered.\n"); 1619 break; 1620 1621 case WFC_VMIDI_OFF: 1622 snd_wavefront_midi_disable_virtual (acard); 1623 break; 1624 1625 case WFC_VMIDI_ON: 1626 snd_wavefront_midi_enable_virtual (acard); 1627 break; 1628 } 1629 } 1630 1631 return 0; 1632} 1633 1634int 1635snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file) 1636 1637{ 1638 if (!try_module_get(hw->card->module)) 1639 return -EFAULT; 1640 file->private_data = hw; 1641 return 0; 1642} 1643 1644int 1645snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file) 1646 1647{ 1648 module_put(hw->card->module); 1649 return 0; 1650} 1651 1652int 1653snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file, 1654 unsigned int cmd, unsigned long arg) 1655 1656{ 1657 struct snd_card *card; 1658 snd_wavefront_t *dev; 1659 snd_wavefront_card_t *acard; 1660 wavefront_control *wc; 1661 void __user *argp = (void __user *)arg; 1662 int err; 1663 1664 card = (struct snd_card *) hw->card; 1665 1666 if (snd_BUG_ON(!card)) 1667 return -ENODEV; 1668 if (snd_BUG_ON(!card->private_data)) 1669 return -ENODEV; 1670 1671 acard = card->private_data; 1672 dev = &acard->wavefront; 1673 1674 switch (cmd) { 1675 case WFCTL_LOAD_SPP: 1676 if (wavefront_load_patch (dev, argp) != 0) { 1677 return -EIO; 1678 } 1679 break; 1680 1681 case WFCTL_WFCMD: 1682 wc = memdup_user(argp, sizeof(*wc)); 1683 if (IS_ERR(wc)) 1684 return PTR_ERR(wc); 1685 1686 if (wavefront_synth_control (acard, wc) < 0) 1687 err = -EIO; 1688 else if (copy_to_user (argp, wc, sizeof (*wc))) 1689 err = -EFAULT; 1690 else 1691 err = 0; 1692 kfree(wc); 1693 return err; 1694 1695 default: 1696 return -EINVAL; 1697 } 1698 1699 return 0; 1700} 1701 1702 1703/***********************************************************************/ 1704/* WaveFront: interface for card-level wavefront module */ 1705/***********************************************************************/ 1706 1707void 1708snd_wavefront_internal_interrupt (snd_wavefront_card_t *card) 1709{ 1710 snd_wavefront_t *dev = &card->wavefront; 1711 1712 /* 1713 Some comments on interrupts. I attempted a version of this 1714 driver that used interrupts throughout the code instead of 1715 doing busy and/or sleep-waiting. Alas, it appears that once 1716 the Motorola firmware is downloaded, the card *never* 1717 generates an RX interrupt. These are successfully generated 1718 during firmware loading, and after that wavefront_status() 1719 reports that an interrupt is pending on the card from time 1720 to time, but it never seems to be delivered to this 1721 driver. Note also that wavefront_status() continues to 1722 report that RX interrupts are enabled, suggesting that I 1723 didn't goof up and disable them by mistake. 1724 1725 Thus, I stepped back to a prior version of 1726 wavefront_wait(), the only place where this really 1727 matters. Its sad, but I've looked through the code to check 1728 on things, and I really feel certain that the Motorola 1729 firmware prevents RX-ready interrupts. 1730 */ 1731 1732 if ((wavefront_status(dev) & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) { 1733 return; 1734 } 1735 1736 spin_lock(&dev->irq_lock); 1737 dev->irq_ok = 1; 1738 dev->irq_cnt++; 1739 spin_unlock(&dev->irq_lock); 1740 wake_up(&dev->interrupt_sleeper); 1741} 1742 1743/* STATUS REGISTER 1744 17450 Host Rx Interrupt Enable (1=Enabled) 17461 Host Rx Register Full (1=Full) 17472 Host Rx Interrupt Pending (1=Interrupt) 17483 Unused 17494 Host Tx Interrupt (1=Enabled) 17505 Host Tx Register empty (1=Empty) 17516 Host Tx Interrupt Pending (1=Interrupt) 17527 Unused 1753*/ 1754 1755static int 1756snd_wavefront_interrupt_bits (int irq) 1757 1758{ 1759 int bits; 1760 1761 switch (irq) { 1762 case 9: 1763 bits = 0x00; 1764 break; 1765 case 5: 1766 bits = 0x08; 1767 break; 1768 case 12: 1769 bits = 0x10; 1770 break; 1771 case 15: 1772 bits = 0x18; 1773 break; 1774 1775 default: 1776 snd_printk ("invalid IRQ %d\n", irq); 1777 bits = -1; 1778 } 1779 1780 return bits; 1781} 1782 1783static void 1784wavefront_should_cause_interrupt (snd_wavefront_t *dev, 1785 int val, int port, unsigned long timeout) 1786 1787{ 1788 wait_queue_entry_t wait; 1789 1790 init_waitqueue_entry(&wait, current); 1791 spin_lock_irq(&dev->irq_lock); 1792 add_wait_queue(&dev->interrupt_sleeper, &wait); 1793 dev->irq_ok = 0; 1794 outb (val,port); 1795 spin_unlock_irq(&dev->irq_lock); 1796 while (!dev->irq_ok && time_before(jiffies, timeout)) { 1797 schedule_timeout_uninterruptible(1); 1798 barrier(); 1799 } 1800} 1801 1802static int 1803wavefront_reset_to_cleanliness (snd_wavefront_t *dev) 1804 1805{ 1806 int bits; 1807 int hwv[2]; 1808 1809 /* IRQ already checked */ 1810 1811 bits = snd_wavefront_interrupt_bits (dev->irq); 1812 1813 /* try reset of port */ 1814 1815 outb (0x0, dev->control_port); 1816 1817 /* At this point, the board is in reset, and the H/W initialization 1818 register is accessed at the same address as the data port. 1819 1820 Bit 7 - Enable IRQ Driver 1821 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs 1822 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus. 1823 1824 Bit 6 - MIDI Interface Select 1825 1826 0 - Use the MIDI Input from the 26-pin WaveBlaster 1827 compatible header as the serial MIDI source 1828 1 - Use the MIDI Input from the 9-pin D connector as the 1829 serial MIDI source. 1830 1831 Bits 5:3 - IRQ Selection 1832 0 0 0 - IRQ 2/9 1833 0 0 1 - IRQ 5 1834 0 1 0 - IRQ 12 1835 0 1 1 - IRQ 15 1836 1 0 0 - Reserved 1837 1 0 1 - Reserved 1838 1 1 0 - Reserved 1839 1 1 1 - Reserved 1840 1841 Bits 2:1 - Reserved 1842 Bit 0 - Disable Boot ROM 1843 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM 1844 1 - memory accesses to 03FC30-03FFFFH are directed to external 1845 storage. 1846 1847 */ 1848 1849 /* configure hardware: IRQ, enable interrupts, 1850 plus external 9-pin MIDI interface selected 1851 */ 1852 1853 outb (0x80 | 0x40 | bits, dev->data_port); 1854 1855 /* CONTROL REGISTER 1856 1857 0 Host Rx Interrupt Enable (1=Enabled) 0x1 1858 1 Unused 0x2 1859 2 Unused 0x4 1860 3 Unused 0x8 1861 4 Host Tx Interrupt Enable 0x10 1862 5 Mute (0=Mute; 1=Play) 0x20 1863 6 Master Interrupt Enable (1=Enabled) 0x40 1864 7 Master Reset (0=Reset; 1=Run) 0x80 1865 1866 Take us out of reset, mute output, master + TX + RX interrupts on. 1867 1868 We'll get an interrupt presumably to tell us that the TX 1869 register is clear. 1870 */ 1871 1872 wavefront_should_cause_interrupt(dev, 0x80|0x40|0x10|0x1, 1873 dev->control_port, 1874 (reset_time*HZ)/100); 1875 1876 /* Note: data port is now the data port, not the h/w initialization 1877 port. 1878 */ 1879 1880 if (!dev->irq_ok) { 1881 snd_printk ("intr not received after h/w un-reset.\n"); 1882 goto gone_bad; 1883 } 1884 1885 /* Note: data port is now the data port, not the h/w initialization 1886 port. 1887 1888 At this point, only "HW VERSION" or "DOWNLOAD OS" commands 1889 will work. So, issue one of them, and wait for TX 1890 interrupt. This can take a *long* time after a cold boot, 1891 while the ISC ROM does its RAM test. The SDK says up to 4 1892 seconds - with 12MB of RAM on a Tropez+, it takes a lot 1893 longer than that (~16secs). Note that the card understands 1894 the difference between a warm and a cold boot, so 1895 subsequent ISC2115 reboots (say, caused by module 1896 reloading) will get through this much faster. 1897 1898 XXX Interesting question: why is no RX interrupt received first ? 1899 */ 1900 1901 wavefront_should_cause_interrupt(dev, WFC_HARDWARE_VERSION, 1902 dev->data_port, ramcheck_time*HZ); 1903 1904 if (!dev->irq_ok) { 1905 snd_printk ("post-RAM-check interrupt not received.\n"); 1906 goto gone_bad; 1907 } 1908 1909 if (!wavefront_wait (dev, STAT_CAN_READ)) { 1910 snd_printk ("no response to HW version cmd.\n"); 1911 goto gone_bad; 1912 } 1913 1914 if ((hwv[0] = wavefront_read (dev)) == -1) { 1915 snd_printk ("board not responding correctly.\n"); 1916 goto gone_bad; 1917 } 1918 1919 if (hwv[0] == 0xFF) { /* NAK */ 1920 1921 /* Board's RAM test failed. Try to read error code, 1922 and tell us about it either way. 1923 */ 1924 1925 if ((hwv[0] = wavefront_read (dev)) == -1) { 1926 snd_printk ("on-board RAM test failed " 1927 "(bad error code).\n"); 1928 } else { 1929 snd_printk ("on-board RAM test failed " 1930 "(error code: 0x%x).\n", 1931 hwv[0]); 1932 } 1933 goto gone_bad; 1934 } 1935 1936 /* We're OK, just get the next byte of the HW version response */ 1937 1938 if ((hwv[1] = wavefront_read (dev)) == -1) { 1939 snd_printk ("incorrect h/w response.\n"); 1940 goto gone_bad; 1941 } 1942 1943 snd_printk ("hardware version %d.%d\n", 1944 hwv[0], hwv[1]); 1945 1946 return 0; 1947 1948 1949 gone_bad: 1950 return (1); 1951} 1952 1953static int 1954wavefront_download_firmware (snd_wavefront_t *dev, char *path) 1955 1956{ 1957 const unsigned char *buf; 1958 int len, err; 1959 int section_cnt_downloaded = 0; 1960 const struct firmware *firmware; 1961 1962 err = request_firmware(&firmware, path, dev->card->dev); 1963 if (err < 0) { 1964 snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path); 1965 return 1; 1966 } 1967 1968 len = 0; 1969 buf = firmware->data; 1970 for (;;) { 1971 int section_length = *(signed char *)buf; 1972 if (section_length == 0) 1973 break; 1974 if (section_length < 0 || section_length > WF_SECTION_MAX) { 1975 snd_printk(KERN_ERR 1976 "invalid firmware section length %d\n", 1977 section_length); 1978 goto failure; 1979 } 1980 buf++; 1981 len++; 1982 1983 if (firmware->size < len + section_length) { 1984 snd_printk(KERN_ERR "firmware section read error.\n"); 1985 goto failure; 1986 } 1987 1988 /* Send command */ 1989 if (wavefront_write(dev, WFC_DOWNLOAD_OS)) 1990 goto failure; 1991 1992 for (; section_length; section_length--) { 1993 if (wavefront_write(dev, *buf)) 1994 goto failure; 1995 buf++; 1996 len++; 1997 } 1998 1999 /* get ACK */ 2000 if (!wavefront_wait(dev, STAT_CAN_READ)) { 2001 snd_printk(KERN_ERR "time out for firmware ACK.\n"); 2002 goto failure; 2003 } 2004 err = inb(dev->data_port); 2005 if (err != WF_ACK) { 2006 snd_printk(KERN_ERR 2007 "download of section #%d not " 2008 "acknowledged, ack = 0x%x\n", 2009 section_cnt_downloaded + 1, err); 2010 goto failure; 2011 } 2012 2013 section_cnt_downloaded++; 2014 } 2015 2016 release_firmware(firmware); 2017 return 0; 2018 2019 failure: 2020 release_firmware(firmware); 2021 snd_printk(KERN_ERR "firmware download failed!!!\n"); 2022 return 1; 2023} 2024 2025 2026static int 2027wavefront_do_reset (snd_wavefront_t *dev) 2028 2029{ 2030 char voices[1]; 2031 2032 if (wavefront_reset_to_cleanliness (dev)) { 2033 snd_printk ("hw reset failed.\n"); 2034 goto gone_bad; 2035 } 2036 2037 if (dev->israw) { 2038 if (wavefront_download_firmware (dev, ospath)) { 2039 goto gone_bad; 2040 } 2041 2042 dev->israw = 0; 2043 2044 /* Wait for the OS to get running. The protocol for 2045 this is non-obvious, and was determined by 2046 using port-IO tracing in DOSemu and some 2047 experimentation here. 2048 2049 Rather than using timed waits, use interrupts creatively. 2050 */ 2051 2052 wavefront_should_cause_interrupt (dev, WFC_NOOP, 2053 dev->data_port, 2054 (osrun_time*HZ)); 2055 2056 if (!dev->irq_ok) { 2057 snd_printk ("no post-OS interrupt.\n"); 2058 goto gone_bad; 2059 } 2060 2061 /* Now, do it again ! */ 2062 2063 wavefront_should_cause_interrupt (dev, WFC_NOOP, 2064 dev->data_port, (10*HZ)); 2065 2066 if (!dev->irq_ok) { 2067 snd_printk ("no post-OS interrupt(2).\n"); 2068 goto gone_bad; 2069 } 2070 2071 /* OK, no (RX/TX) interrupts any more, but leave mute 2072 in effect. 2073 */ 2074 2075 outb (0x80|0x40, dev->control_port); 2076 } 2077 2078 /* SETUPSND.EXE asks for sample memory config here, but since i 2079 have no idea how to interpret the result, we'll forget 2080 about it. 2081 */ 2082 2083 if ((dev->freemem = wavefront_freemem (dev)) < 0) { 2084 goto gone_bad; 2085 } 2086 2087 snd_printk ("available DRAM %dk\n", dev->freemem / 1024); 2088 2089 if (wavefront_write (dev, 0xf0) || 2090 wavefront_write (dev, 1) || 2091 (wavefront_read (dev) < 0)) { 2092 dev->debug = 0; 2093 snd_printk ("MPU emulation mode not set.\n"); 2094 goto gone_bad; 2095 } 2096 2097 voices[0] = 32; 2098 2099 if (snd_wavefront_cmd (dev, WFC_SET_NVOICES, NULL, voices)) { 2100 snd_printk ("cannot set number of voices to 32.\n"); 2101 goto gone_bad; 2102 } 2103 2104 2105 return 0; 2106 2107 gone_bad: 2108 /* reset that sucker so that it doesn't bother us. */ 2109 2110 outb (0x0, dev->control_port); 2111 dev->interrupts_are_midi = 0; 2112 return 1; 2113} 2114 2115int 2116snd_wavefront_start (snd_wavefront_t *dev) 2117 2118{ 2119 int samples_are_from_rom; 2120 2121 /* IMPORTANT: assumes that snd_wavefront_detect() and/or 2122 wavefront_reset_to_cleanliness() has already been called 2123 */ 2124 2125 if (dev->israw) { 2126 samples_are_from_rom = 1; 2127 } else { 2128 /* XXX is this always true ? */ 2129 samples_are_from_rom = 0; 2130 } 2131 2132 if (dev->israw || fx_raw) { 2133 if (wavefront_do_reset (dev)) { 2134 return -1; 2135 } 2136 } 2137 /* Check for FX device, present only on Tropez+ */ 2138 2139 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0); 2140 2141 if (dev->has_fx && fx_raw) { 2142 snd_wavefront_fx_start (dev); 2143 } 2144 2145 wavefront_get_sample_status (dev, samples_are_from_rom); 2146 wavefront_get_program_status (dev); 2147 wavefront_get_patch_status (dev); 2148 2149 /* Start normal operation: unreset, master interrupt enabled, no mute 2150 */ 2151 2152 outb (0x80|0x40|0x20, dev->control_port); 2153 2154 return (0); 2155} 2156 2157int 2158snd_wavefront_detect (snd_wavefront_card_t *card) 2159 2160{ 2161 unsigned char rbuf[4], wbuf[4]; 2162 snd_wavefront_t *dev = &card->wavefront; 2163 2164 /* returns zero if a WaveFront card is successfully detected. 2165 negative otherwise. 2166 */ 2167 2168 dev->israw = 0; 2169 dev->has_fx = 0; 2170 dev->debug = debug_default; 2171 dev->interrupts_are_midi = 0; 2172 dev->irq_cnt = 0; 2173 dev->rom_samples_rdonly = 1; 2174 2175 if (snd_wavefront_cmd (dev, WFC_FIRMWARE_VERSION, rbuf, wbuf) == 0) { 2176 2177 dev->fw_version[0] = rbuf[0]; 2178 dev->fw_version[1] = rbuf[1]; 2179 2180 snd_printk ("firmware %d.%d already loaded.\n", 2181 rbuf[0], rbuf[1]); 2182 2183 /* check that a command actually works */ 2184 2185 if (snd_wavefront_cmd (dev, WFC_HARDWARE_VERSION, 2186 rbuf, wbuf) == 0) { 2187 dev->hw_version[0] = rbuf[0]; 2188 dev->hw_version[1] = rbuf[1]; 2189 } else { 2190 snd_printk ("not raw, but no " 2191 "hardware version!\n"); 2192 return -1; 2193 } 2194 2195 if (!wf_raw) { 2196 return 0; 2197 } else { 2198 snd_printk ("reloading firmware as you requested.\n"); 2199 dev->israw = 1; 2200 } 2201 2202 } else { 2203 2204 dev->israw = 1; 2205 snd_printk ("no response to firmware probe, assume raw.\n"); 2206 2207 } 2208 2209 return 0; 2210} 2211 2212MODULE_FIRMWARE(DEFAULT_OSPATH); 2213