Lines Matching +full:pc +full:- +full:ack
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) by Paul Barton-Davis 1998-1999
5 * copyright (C) by Hannu Savolainen 1993-1996
14 * of GUS patches during loading, and full user-level access to all
15 * WaveFront commands. It tries to provide semi-intelligent patch and
36 loading. if non-zero, then during driver loading, the
80 checks on-board RAM.
87 MODULE_PARM_DESC(wf_raw, "if non-zero, assume that we need to boot the OS");
89 MODULE_PARM_DESC(fx_raw, "if non-zero, assume that the FX process needs help");
107 /* if WF_DEBUG not defined, no run-time debugging messages will
118 if ((dev->debug & (cond)) == (cond)) { \
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 },
201 response, don't fetch an ACK, and leave the rest to the
225 { WFC_NOOP, "the no-op command", 0, 0, NEEDS_ACK },
263 return inb (dev->status_port);
311 return inb (dev->data_port);
315 return -1;
323 outb (data, dev->data_port);
329 return -1;
337 int ack;
344 dev_err(dev->card->dev, "command 0x%x not supported.\n",
349 /* Hack to handle the one variable-size write command. See
355 wfcmd->write_cnt = (unsigned long) rbuf;
360 cmd, wfcmd->action, wfcmd->read_cnt,
361 wfcmd->write_cnt, wfcmd->need_ack);
366 cmd, wfcmd->action);
370 if (wfcmd->write_cnt > 0) {
373 wfcmd->write_cnt, cmd);
375 for (i = 0; i < wfcmd->write_cnt; i++) {
379 i, cmd, wfcmd->action);
388 if (wfcmd->read_cnt > 0) {
391 wfcmd->read_cnt, cmd);
393 for (i = 0; i < wfcmd->read_cnt; i++) {
396 if (c == -1) {
399 i, cmd, wfcmd->action);
407 if (c == -1) {
413 wfcmd->action);
420 wfcmd->cmd == WFC_IDENTIFY_SAMPLE_TYPE) {
425 wfcmd->cmd == WFC_UPLOAD_PATCH) {
430 wfcmd->cmd == WFC_UPLOAD_PROGRAM) {
444 wfcmd->action);
457 if ((wfcmd->read_cnt == 0 && wfcmd->write_cnt == 0) || wfcmd->need_ack) {
459 DPRINT (WF_DEBUG_CMD, "reading ACK for 0x%x\n", cmd);
461 /* Some commands need an ACK, but return zero instead
465 ack = wavefront_read(dev);
466 if (ack == 0)
467 ack = WF_ACK;
469 if (ack != WF_ACK) {
470 if (ack == -1) {
471 DPRINT (WF_DEBUG_IO, "cannot read ack for "
473 cmd, wfcmd->action);
477 int err = -1; /* something unknown */
479 if (ack == 0xff) { /* explicit error */
482 if (err == -1) {
486 cmd, wfcmd->action);
492 cmd, wfcmd->action, ack, err,
495 return -err;
499 DPRINT (WF_DEBUG_DATA, "ack received "
501 cmd, wfcmd->action);
505 "ACK (%d,%d,%d)\n",
506 cmd, wfcmd->action, wfcmd->read_cnt,
507 wfcmd->write_cnt, wfcmd->need_ack);
523 the x86 side as 8-32 bit values. Sometimes, we need to munge data
526 different functions for munging and 2 for de-munging. This avoids
527 weird casting and worrying about bit-level offsets.
555 for (i = src_size - 1; i >= 0; i--) {
612 dev->sample_status[sample_num] = WF_ST_EMPTY;
628 dev_err(dev->card->dev, "cannot request sample count.\n");
629 return -1;
632 sc_real = sc_alias = sc_multi = dev->samples_used = 0;
640 dev_warn(dev->card->dev,
642 dev->sample_status[i] = WF_ST_EMPTY;
646 dev->sample_status[i] = (WF_SLOT_FILLED|rbuf[0]);
649 dev->sample_status[i] |= WF_SLOT_ROM;
666 dev_err(dev->card->dev,
672 dev->samples_used++;
676 dev_info(dev->card->dev,
678 dev->samples_used, sc_real, sc_alias, sc_multi,
679 WF_MAX_SAMPLE - dev->samples_used);
703 dev->patch_status[i] |= WF_SLOT_FILLED;
705 dev->sample_status
706 [p->sample_number|(p->sample_msb<<7)] |=
710 dev->patch_status[i] = 0;
712 dev_err(dev->card->dev,
714 dev->patch_status[i] = 0;
722 if (dev->patch_status[i] & WF_SLOT_FILLED) {
725 if (dev->patch_status[i] & WF_SLOT_USED) {
730 dev_info(dev->card->dev, "%d patch slots filled, %d in use\n",
752 dev->prog_status[i] |= WF_SLOT_USED;
759 dev->patch_status
765 dev->prog_status[i] = 0;
767 dev_err(dev->card->dev,
769 dev->prog_status[i] = 0;
774 if (dev->prog_status[i]) {
779 dev_info(dev->card->dev, "%d programs slots in use\n", cnt);
792 header->number);
794 if (header->number >= ARRAY_SIZE(dev->patch_status))
795 return -EINVAL;
797 dev->patch_status[header->number] |= WF_SLOT_FILLED;
799 bptr = munge_int32 (header->number, buf, 2);
800 munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
803 dev_err(dev->card->dev, "download patch failed\n");
804 return -EIO;
818 header->number);
820 if (header->number >= ARRAY_SIZE(dev->prog_status))
821 return -EINVAL;
823 dev->prog_status[header->number] = WF_SLOT_USED;
830 if (header->hdr.pr.layer[i].mute) {
831 dev->patch_status[header->hdr.pr.layer[i].patch_number] |=
840 buf[0] = header->number;
841 munge_buf ((unsigned char *)&header->hdr.pr, &buf[1], WF_PROGRAM_BYTES);
844 dev_err(dev->card->dev, "download patch failed\n");
845 return -EIO;
858 dev_err(dev->card->dev, "can't get memory stats.\n");
859 return -1;
872 /* samples are downloaded via a 16-bit wide i/o port
873 (you could think of it as 2 adjacent 8-bit wide ports
877 which are given in 8-bit units (bytes), need to be
897 header->size ? "" : "header ",
898 header->number, header->subkey,
899 header->size,
900 (unsigned long) header->dataptr);
902 if (header->number == WAVEFRONT_FIND_FREE_SAMPLE_SLOT) {
907 return -ENOMEM;
908 dev_info(dev->card->dev, "unspecified sample => %d\n", x);
909 header->number = x;
912 if (header->number >= WF_MAX_SAMPLE)
913 return -EINVAL;
915 if (header->size) {
940 if (dev->rom_samples_rdonly) {
941 if (dev->sample_status[header->number] & WF_SLOT_ROM) {
942 dev_err(dev->card->dev,
944 header->number);
945 return -EACCES;
949 wavefront_delete_sample (dev, header->number);
952 if (header->size) {
953 dev->freemem = wavefront_freemem (dev);
955 if (dev->freemem < (int)header->size) {
956 dev_err(dev->card->dev,
958 header->size);
959 return -ENOMEM;
964 skip = WF_GET_CHANNEL(&header->hdr.s);
966 if (skip > 0 && header->hdr.s.SampleResolution != LINEAR_16BIT) {
967 dev_err(dev->card->dev,
968 "channel selection only possible on 16-bit samples");
969 return -EINVAL;
1005 WF_GET_CHANNEL (&header->hdr.s),
1010 WF_SET_CHANNEL(&header->hdr.s, 0);
1017 length = header->size / 2;
1026 shptr = munge_int32 (header->number, shptr, 2);
1028 if (header->size) {
1036 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleStartOffset),
1038 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopStartOffset),
1040 shptr = munge_int32 (*((u32 *) &header->hdr.s.loopEndOffset),
1042 shptr = munge_int32 (*((u32 *) &header->hdr.s.sampleEndOffset),
1050 shptr = munge_int32 (header->hdr.s.FrequencyBias, shptr, 3);
1054 good-faith guess at where it starts.
1057 shptr = munge_int32 (*(&header->hdr.s.FrequencyBias+1),
1061 header->size ?
1064 dev_err(dev->card->dev, "sample %sdownload refused.\n",
1065 header->size ? "" : "header ");
1066 return -EIO;
1069 if (header->size == 0) {
1082 if ((length - written) > max_blksize) {
1085 /* round to nearest 16-byte value */
1086 blocksize = ALIGN(length - written, 8);
1090 dev_err(dev->card->dev,
1092 return -EIO;
1100 return -EFAULT;
1105 if (WF_SAMPLE_IS_8BIT(&header->hdr.s)) {
1138 if (i < blocksize - 1) {
1139 outw (sample_short, dev->block_port);
1141 outw (sample_short, dev->last_block_port);
1151 if (dma_ack == -1) {
1152 dev_err(dev->card->dev,
1153 "upload sample DMA ack timeout\n");
1154 return -EIO;
1156 dev_err(dev->card->dev,
1157 "upload sample DMA ack error 0x%x\n",
1159 return -EIO;
1164 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_SAMPLE);
1182 header->number,
1183 header->hdr.a.OriginalSample);
1185 if (header->number >= WF_MAX_SAMPLE)
1186 return -EINVAL;
1188 munge_int32 (header->number, &alias_hdr[0], 2);
1189 munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
1190 munge_int32 (*((unsigned int *)&header->hdr.a.sampleStartOffset),
1192 munge_int32 (*((unsigned int *)&header->hdr.a.loopStartOffset),
1194 munge_int32 (*((unsigned int *)&header->hdr.a.loopEndOffset),
1196 munge_int32 (*((unsigned int *)&header->hdr.a.sampleEndOffset),
1198 munge_int32 (header->hdr.a.FrequencyBias, &alias_hdr[20], 3);
1199 munge_int32 (*(&header->hdr.a.FrequencyBias+1), &alias_hdr[23], 2);
1202 dev_err(dev->card->dev, "download alias failed.\n");
1203 return -EIO;
1206 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_ALIAS);
1218 if (header->number >= WF_MAX_SAMPLE)
1219 return -EINVAL;
1223 return -ENOMEM;
1225 munge_int32 (header->number, &msample_hdr[0], 2);
1232 num_samples = (1<<(header->hdr.ms.NumberOfSamples&7));
1233 msample_hdr[2] = (unsigned char) header->hdr.ms.NumberOfSamples;
1236 header->number,
1237 header->hdr.ms.NumberOfSamples,
1242 i, header->hdr.ms.SampleNumber[i]);
1243 munge_int32 (header->hdr.ms.SampleNumber[i],
1255 dev_err(dev->card->dev, "download of multisample failed.\n");
1257 return -EIO;
1260 dev->sample_status[header->number] = (WF_SLOT_FILLED|WF_ST_MULTISAMPLE);
1275 munge_int32 (header->number, number, 2);
1278 dev_err(dev->card->dev, "upload multisample failed.\n");
1279 return -EIO;
1283 header->number, log_ns[0]);
1285 header->hdr.ms.NumberOfSamples = log_ns[0];
1296 if (val == -1) {
1297 dev_err(dev->card->dev,
1299 return -EIO;
1304 if (val == -1) {
1305 dev_err(dev->card->dev,
1307 return -EIO;
1311 header->hdr.ms.SampleNumber[i] =
1315 i, header->hdr.ms.SampleNumber[i]);
1327 wavefront_drum *drum = &header->hdr.d;
1332 header->number, drum->PatchNumber);
1334 drumbuf[0] = header->number & 0x7f;
1341 dev_err(dev->card->dev, "download drum failed.\n");
1342 return -EIO;
1355 if (!(dev->sample_status[i] & WF_SLOT_FILLED)) {
1359 dev_err(dev->card->dev, "no free sample slots!\n");
1360 return -1;
1371 if (!(dev->patch_status[i] & WF_SLOT_FILLED)) {
1375 dev_err(dev->card->dev, "no free patch slots!\n");
1376 return -1;
1388 return -ENOMEM;
1390 if (copy_from_user (header, addr, sizeof(wavefront_patch_info) -
1392 dev_err(dev->card->dev, "bad address for load patch.\n");
1393 err = -EFAULT;
1401 header->subkey,
1402 header->number,
1403 header->size);
1405 switch (header->subkey) {
1406 case WF_ST_SAMPLE: /* sample or sample_header, based on patch->size */
1408 if (copy_from_user (&header->hdr.s, header->hdrptr,
1410 err = -EFAULT;
1414 err = wavefront_send_sample (dev, header, header->dataptr, 0);
1419 if (copy_from_user (&header->hdr.s, header->hdrptr,
1421 err = -EFAULT;
1430 if (copy_from_user (&header->hdr.a, header->hdrptr,
1432 err = -EFAULT;
1440 if (copy_from_user (&header->hdr.d, header->hdrptr,
1442 err = -EFAULT;
1450 if (copy_from_user (&header->hdr.p, header->hdrptr,
1452 err = -EFAULT;
1460 if (copy_from_user (&header->hdr.pr, header->hdrptr,
1462 err = -EFAULT;
1470 dev_err(dev->card->dev, "unknown patch type %d.\n",
1471 header->subkey);
1472 err = -EINVAL;
1483 WaveFront: hardware-dependent interface
1523 snd_wavefront_t *dev = &acard->wavefront;
1528 "cmd 0x%x\n", wc->cmd);
1530 /* Pre-handling of or for various commands */
1532 switch (wc->cmd) {
1535 dev_dbg(dev->card->dev, "interrupts disabled.\n");
1536 outb (0x80|0x20, dev->control_port);
1537 dev->interrupts_are_midi = 1;
1541 dev_dbg(dev->card->dev, "interrupts enabled.\n");
1542 outb (0x80|0x40|0x20, dev->control_port);
1543 dev->interrupts_are_midi = 1;
1547 wc->rbuf[0] = dev->interrupts_are_midi;
1551 dev->rom_samples_rdonly = wc->wbuf[0];
1552 wc->status = 0;
1556 i = wc->wbuf[0] | (wc->wbuf[1] << 7);
1558 dev_err(dev->card->dev, "invalid slot ID %d\n",
1560 wc->status = EINVAL;
1561 return -EINVAL;
1563 wc->rbuf[0] = dev->sample_status[i];
1564 wc->status = 0;
1568 dev->debug = wc->wbuf[0];
1569 dev_dbg(dev->card->dev, "debug = 0x%x\n", dev->debug);
1573 munge_int32 (*((u32 *) wc->wbuf), patchnumbuf, 2);
1574 memcpy (wc->wbuf, patchnumbuf, 2);
1581 wc->status = wavefront_fetch_multisample
1582 (dev, (wavefront_patch_info *) wc->rbuf);
1586 dev_err(dev->card->dev,
1588 wc->status = EINVAL;
1589 return -EINVAL;
1592 wc->status = snd_wavefront_cmd (dev, wc->cmd, wc->rbuf, wc->wbuf);
1594 /* Post-handling of certain commands.
1597 so that the user-level doesn't have to think about it.
1600 if (wc->status == 0) {
1601 switch (wc->cmd) {
1603 we are always current with the user-level view
1608 dev->freemem = demunge_int32 (wc->rbuf, 4);
1612 demunge_buf (wc->rbuf, wc->rbuf, WF_PATCH_BYTES);
1616 demunge_buf (wc->rbuf, wc->rbuf, WF_PROGRAM_BYTES);
1620 demunge_buf (wc->rbuf, wc->rbuf, WF_DRUM_BYTES - 1);
1624 process_sample_hdr (wc->rbuf);
1628 dev_err(dev->card->dev,
1649 if (!try_module_get(hw->card->module))
1650 return -EFAULT;
1651 file->private_data = hw;
1659 module_put(hw->card->module);
1675 card = (struct snd_card *) hw->card;
1678 return -ENODEV;
1679 if (snd_BUG_ON(!card->private_data))
1680 return -ENODEV;
1682 acard = card->private_data;
1683 dev = &acard->wavefront;
1688 return -EIO;
1698 err = -EIO;
1700 err = -EFAULT;
1707 return -EINVAL;
1716 /* WaveFront: interface for card-level wavefront module */
1722 snd_wavefront_t *dev = &card->wavefront;
1727 doing busy and/or sleep-waiting. Alas, it appears that once
1741 firmware prevents RX-ready interrupts.
1748 scoped_guard(spinlock, &dev->irq_lock) {
1749 dev->irq_ok = 1;
1750 dev->irq_cnt++;
1752 wake_up(&dev->interrupt_sleeper);
1788 dev_err(dev->card->dev, "invalid IRQ %d\n", irq);
1789 bits = -1;
1803 scoped_guard(spinlock_irq, &dev->irq_lock) {
1804 add_wait_queue(&dev->interrupt_sleeper, &wait);
1805 dev->irq_ok = 0;
1808 while (!dev->irq_ok && time_before(jiffies, timeout)) {
1823 bits = snd_wavefront_interrupt_bits(dev, dev->irq);
1827 outb (0x0, dev->control_port);
1832 Bit 7 - Enable IRQ Driver
1833 0 - Tri-state the Wave-Board drivers for the PC Bus IRQs
1834 1 - Enable IRQ selected by bits 5:3 to be driven onto the PC Bus.
1836 Bit 6 - MIDI Interface Select
1838 0 - Use the MIDI Input from the 26-pin WaveBlaster
1840 1 - Use the MIDI Input from the 9-pin D connector as the
1843 Bits 5:3 - IRQ Selection
1844 0 0 0 - IRQ 2/9
1845 0 0 1 - IRQ 5
1846 0 1 0 - IRQ 12
1847 0 1 1 - IRQ 15
1848 1 0 0 - Reserved
1849 1 0 1 - Reserved
1850 1 1 0 - Reserved
1851 1 1 1 - Reserved
1853 Bits 2:1 - Reserved
1854 Bit 0 - Disable Boot ROM
1855 0 - memory accesses to 03FC30-03FFFFH utilize the internal Boot ROM
1856 1 - memory accesses to 03FC30-03FFFFH are directed to external
1862 plus external 9-pin MIDI interface selected
1865 outb (0x80 | 0x40 | bits, dev->data_port);
1885 dev->control_port,
1892 if (!dev->irq_ok) {
1893 dev_err(dev->card->dev, "intr not received after h/w un-reset.\n");
1904 seconds - with 12MB of RAM on a Tropez+, it takes a lot
1914 dev->data_port, ramcheck_time*HZ);
1916 if (!dev->irq_ok) {
1917 dev_err(dev->card->dev, "post-RAM-check interrupt not received.\n");
1922 dev_err(dev->card->dev, "no response to HW version cmd.\n");
1927 if (hwv[0] == -1) {
1928 dev_err(dev->card->dev, "board not responding correctly.\n");
1939 if (hwv[0] == -1) {
1940 dev_err(dev->card->dev,
1941 "on-board RAM test failed (bad error code).\n");
1943 dev_err(dev->card->dev,
1944 "on-board RAM test failed (error code: 0x%x).\n",
1953 if (hwv[1] == -1) {
1954 dev_err(dev->card->dev, "incorrect h/w response.\n");
1958 dev_info(dev->card->dev, "hardware version %d.%d\n",
1977 err = request_firmware(&firmware, path, dev->card->dev);
1979 dev_err(dev->card->dev, "firmware (%s) download failed!!!\n", path);
1984 buf = firmware->data;
1990 dev_err(dev->card->dev,
1998 if (firmware->size < len + section_length) {
1999 dev_err(dev->card->dev, "firmware section read error.\n");
2007 for (; section_length; section_length--) {
2014 /* get ACK */
2016 dev_err(dev->card->dev, "time out for firmware ACK.\n");
2019 err = inb(dev->data_port);
2021 dev_err(dev->card->dev,
2022 "download of section #%d not acknowledged, ack = 0x%x\n",
2035 dev_err(dev->card->dev, "firmware download failed!!!\n");
2047 dev_err(dev->card->dev, "hw reset failed.\n");
2051 if (dev->israw) {
2056 dev->israw = 0;
2059 this is non-obvious, and was determined by
2060 using port-IO tracing in DOSemu and some
2067 dev->data_port,
2070 if (!dev->irq_ok) {
2071 dev_err(dev->card->dev, "no post-OS interrupt.\n");
2078 dev->data_port, (10*HZ));
2080 if (!dev->irq_ok) {
2081 dev_err(dev->card->dev, "no post-OS interrupt(2).\n");
2089 outb (0x80|0x40, dev->control_port);
2097 dev->freemem = wavefront_freemem(dev);
2098 if (dev->freemem < 0)
2101 dev_info(dev->card->dev, "available DRAM %dk\n", dev->freemem / 1024);
2106 dev->debug = 0;
2107 dev_err(dev->card->dev, "MPU emulation mode not set.\n");
2114 dev_err(dev->card->dev, "cannot set number of voices to 32.\n");
2124 outb (0x0, dev->control_port);
2125 dev->interrupts_are_midi = 0;
2139 if (dev->israw) {
2146 if (dev->israw || fx_raw) {
2148 return -1;
2153 dev->has_fx = (snd_wavefront_fx_detect (dev) == 0);
2155 if (dev->has_fx && fx_raw) {
2166 outb (0x80|0x40|0x20, dev->control_port);
2176 snd_wavefront_t *dev = &card->wavefront;
2182 dev->israw = 0;
2183 dev->has_fx = 0;
2184 dev->debug = debug_default;
2185 dev->interrupts_are_midi = 0;
2186 dev->irq_cnt = 0;
2187 dev->rom_samples_rdonly = 1;
2191 dev->fw_version[0] = rbuf[0];
2192 dev->fw_version[1] = rbuf[1];
2194 dev_info(dev->card->dev, "firmware %d.%d already loaded.\n",
2201 dev->hw_version[0] = rbuf[0];
2202 dev->hw_version[1] = rbuf[1];
2204 dev_err(dev->card->dev,
2206 return -1;
2212 dev_info(dev->card->dev,
2214 dev->israw = 1;
2219 dev->israw = 1;
2220 dev_info(dev->card->dev,