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