isa/wavefront/wavefront_fx.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (c) 1998-2002 by Paul Davis <pbd@op.net>
0004  */
0005
0006 #include <linux/io.h>
0007 #include <linux/init.h>
0008 #include <linux/time.h>
0009 #include <linux/wait.h>
0010 #include <linux/slab.h>
0011 #include <linux/module.h>
0012 #include <linux/firmware.h>
0013 #include <sound/core.h>
0014 #include <sound/snd_wavefront.h>
0015 #include <sound/initval.h>
0016
0017 /* Control bits for the Load Control Register
0018  */
0019
0020 #define FX_LSB_TRANSFER 0x01    /* transfer after DSP LSB byte written */
0021 #define FX_MSB_TRANSFER 0x02    /* transfer after DSP MSB byte written */
0022 #define FX_AUTO_INCR    0x04    /* auto-increment DSP address after transfer */
0023
0024 #define WAIT_IDLE   0xff
0025
0026 static int
0027 wavefront_fx_idle (snd_wavefront_t *dev)
0028
0029 {
0030     int i;
0031     unsigned int x = 0x80;
0032
0033     for (i = 0; i < 1000; i++) {
0034         x = inb (dev->fx_status);
0035         if ((x & 0x80) == 0) {
0036             break;
0037         }
0038     }
0039
0040     if (x & 0x80) {
0041         snd_printk ("FX device never idle.\n");
0042         return 0;
0043     }
0044
0045     return (1);
0046 }
0047
0048 static void
0049 wavefront_fx_mute (snd_wavefront_t *dev, int onoff)
0050
0051 {
0052     if (!wavefront_fx_idle(dev)) {
0053         return;
0054     }
0055
0056     outb (onoff ? 0x02 : 0x00, dev->fx_op);
0057 }
0058
0059 static int
0060 wavefront_fx_memset (snd_wavefront_t *dev,
0061              int page,
0062              int addr,
0063              int cnt,
0064              unsigned short *data)
0065 {
0066     if (page < 0 || page > 7) {
0067         snd_printk ("FX memset: "
0068             "page must be >= 0 and <= 7\n");
0069         return -EINVAL;
0070     }
0071
0072     if (addr < 0 || addr > 0x7f) {
0073         snd_printk ("FX memset: "
0074             "addr must be >= 0 and <= 7f\n");
0075         return -EINVAL;
0076     }
0077
0078     if (cnt == 1) {
0079
0080         outb (FX_LSB_TRANSFER, dev->fx_lcr);
0081         outb (page, dev->fx_dsp_page);
0082         outb (addr, dev->fx_dsp_addr);
0083         outb ((data[0] >> 8), dev->fx_dsp_msb);
0084         outb ((data[0] & 0xff), dev->fx_dsp_lsb);
0085
0086         snd_printk ("FX: addr %d:%x set to 0x%x\n",
0087             page, addr, data[0]);
0088
0089     } else {
0090         int i;
0091
0092         outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev->fx_lcr);
0093         outb (page, dev->fx_dsp_page);
0094         outb (addr, dev->fx_dsp_addr);
0095
0096         for (i = 0; i < cnt; i++) {
0097             outb ((data[i] >> 8), dev->fx_dsp_msb);
0098             outb ((data[i] & 0xff), dev->fx_dsp_lsb);
0099             if (!wavefront_fx_idle (dev)) {
0100                 break;
0101             }
0102         }
0103
0104         if (i != cnt) {
0105             snd_printk ("FX memset "
0106                     "(0x%x, 0x%x, 0x%lx, %d) incomplete\n",
0107                     page, addr, (unsigned long) data, cnt);
0108             return -EIO;
0109         }
0110     }
0111
0112     return 0;
0113 }
0114
0115 int
0116 snd_wavefront_fx_detect (snd_wavefront_t *dev)
0117
0118 {
0119     /* This is a crude check, but its the best one I have for now.
0120        Certainly on the Maui and the Tropez, wavefront_fx_idle() will
0121        report "never idle", which suggests that this test should
0122        work OK.
0123     */
0124
0125     if (inb (dev->fx_status) & 0x80) {
0126         snd_printk ("Hmm, probably a Maui or Tropez.\n");
0127         return -1;
0128     }
0129
0130     return 0;
0131 }
0132
0133 int
0134 snd_wavefront_fx_open (struct snd_hwdep *hw, struct file *file)
0135
0136 {
0137     if (!try_module_get(hw->card->module))
0138         return -EFAULT;
0139     file->private_data = hw;
0140     return 0;
0141 }
0142
0143 int
0144 snd_wavefront_fx_release (struct snd_hwdep *hw, struct file *file)
0145
0146 {
0147     module_put(hw->card->module);
0148     return 0;
0149 }
0150
0151 int
0152 snd_wavefront_fx_ioctl (struct snd_hwdep *sdev, struct file *file,
0153             unsigned int cmd, unsigned long arg)
0154
0155 {
0156     struct snd_card *card;
0157     snd_wavefront_card_t *acard;
0158     snd_wavefront_t *dev;
0159     wavefront_fx_info r;
0160     unsigned short *page_data = NULL;
0161     unsigned short *pd;
0162     int err = 0;
0163
0164     card = sdev->card;
0165     if (snd_BUG_ON(!card))
0166         return -ENODEV;
0167     if (snd_BUG_ON(!card->private_data))
0168         return -ENODEV;
0169
0170     acard = card->private_data;
0171     dev = &acard->wavefront;
0172
0173     if (copy_from_user (&r, (void __user *)arg, sizeof (wavefront_fx_info)))
0174         return -EFAULT;
0175
0176     switch (r.request) {
0177     case WFFX_MUTE:
0178         wavefront_fx_mute (dev, r.data[0]);
0179         return -EIO;
0180
0181     case WFFX_MEMSET:
0182         if (r.data[2] <= 0) {
0183             snd_printk ("cannot write "
0184                 "<= 0 bytes to FX\n");
0185             return -EIO;
0186         } else if (r.data[2] == 1) {
0187             pd = (unsigned short *) &r.data[3];
0188         } else {
0189             if (r.data[2] > 256) {
0190                 snd_printk ("cannot write "
0191                         "> 512 bytes to FX\n");
0192                 return -EIO;
0193             }
0194             page_data = memdup_user((unsigned char __user *)
0195                         r.data[3],
0196                         r.data[2] * sizeof(short));
0197             if (IS_ERR(page_data))
0198                 return PTR_ERR(page_data);
0199             pd = page_data;
0200         }
0201
0202         err = wavefront_fx_memset (dev,
0203                  r.data[0], /* page */
0204                  r.data[1], /* addr */
0205                  r.data[2], /* cnt */
0206                  pd);
0207         kfree(page_data);
0208         break;
0209
0210     default:
0211         snd_printk ("FX: ioctl %d not yet supported\n",
0212                 r.request);
0213         return -ENOTTY;
0214     }
0215     return err;
0216 }
0217
0218 /* YSS225 initialization.
0219
0220    This code was developed using DOSEMU. The Turtle Beach SETUPSND
0221    utility was run with I/O tracing in DOSEMU enabled, and a reconstruction
0222    of the port I/O done, using the Yamaha faxback document as a guide
0223    to add more logic to the code. Its really pretty weird.
0224
0225    This is the approach of just dumping the whole I/O
0226    sequence as a series of port/value pairs and a simple loop
0227    that outputs it.
0228 */
0229
0230 int
0231 snd_wavefront_fx_start (snd_wavefront_t *dev)
0232 {
0233     unsigned int i;
0234     int err;
0235     const struct firmware *firmware = NULL;
0236
0237     if (dev->fx_initialized)
0238         return 0;
0239
0240     err = request_firmware(&firmware, "yamaha/yss225_registers.bin",
0241                    dev->card->dev);
0242     if (err < 0) {
0243         err = -1;
0244         goto out;
0245     }
0246
0247     for (i = 0; i + 1 < firmware->size; i += 2) {
0248         if (firmware->data[i] >= 8 && firmware->data[i] < 16) {
0249             outb(firmware->data[i + 1],
0250                  dev->base + firmware->data[i]);
0251         } else if (firmware->data[i] == WAIT_IDLE) {
0252             if (!wavefront_fx_idle(dev)) {
0253                 err = -1;
0254                 goto out;
0255             }
0256         } else {
0257             snd_printk(KERN_ERR "invalid address"
0258                    " in register data\n");
0259             err = -1;
0260             goto out;
0261         }
0262     }
0263
0264     dev->fx_initialized = 1;
0265     err = 0;
0266
0267 out:
0268     release_firmware(firmware);
0269     return err;
0270 }
0271
0272 MODULE_FIRMWARE("yamaha/yss225_registers.bin");