sound/isa/wavefront/wavefront

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
wavefront_fx_idle
wavefront_fx_mute
wavefront_fx_memset
snd_wavefront_fx_detect
snd_wavefront_fx_open
snd_wavefront_fx_release
snd_wavefront_fx_ioctl
snd_wavefront_fx_start
   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (c) 1998-2002 by Paul Davis <pbd@op.net>
   4  */
   5 
   6 #include <linux/io.h>
   7 #include <linux/init.h>
   8 #include <linux/time.h>
   9 #include <linux/wait.h>
  10 #include <linux/slab.h>
  11 #include <linux/module.h>
  12 #include <linux/firmware.h>
  13 #include <sound/core.h>
  14 #include <sound/snd_wavefront.h>
  15 #include <sound/initval.h>
  16 
  17 /* Control bits for the Load Control Register
  18  */
  19 
  20 #define FX_LSB_TRANSFER 0x01    /* transfer after DSP LSB byte written */
  21 #define FX_MSB_TRANSFER 0x02    /* transfer after DSP MSB byte written */
  22 #define FX_AUTO_INCR    0x04    /* auto-increment DSP address after transfer */
  23 
  24 #define WAIT_IDLE       0xff
  25 
  26 static int
  27 wavefront_fx_idle (snd_wavefront_t *dev)
  28 
  29 {
  30         int i;
  31         unsigned int x = 0x80;
  32 
  33         for (i = 0; i < 1000; i++) {
  34                 x = inb (dev->fx_status);
  35                 if ((x & 0x80) == 0) {
  36                         break;
  37                 }
  38         }
  39 
  40         if (x & 0x80) {
  41                 snd_printk ("FX device never idle.\n");
  42                 return 0;
  43         }
  44 
  45         return (1);
  46 }
  47 
  48 static void
  49 wavefront_fx_mute (snd_wavefront_t *dev, int onoff)
  50 
  51 {
  52         if (!wavefront_fx_idle(dev)) {
  53                 return;
  54         }
  55 
  56         outb (onoff ? 0x02 : 0x00, dev->fx_op);
  57 }
  58 
  59 static int
  60 wavefront_fx_memset (snd_wavefront_t *dev,
  61                      int page,
  62                      int addr,
  63                      int cnt,
  64                      unsigned short *data)
  65 {
  66         if (page < 0 || page > 7) {
  67                 snd_printk ("FX memset: "
  68                         "page must be >= 0 and <= 7\n");
  69                 return -EINVAL;
  70         }
  71 
  72         if (addr < 0 || addr > 0x7f) {
  73                 snd_printk ("FX memset: "
  74                         "addr must be >= 0 and <= 7f\n");
  75                 return -EINVAL;
  76         }
  77 
  78         if (cnt == 1) {
  79 
  80                 outb (FX_LSB_TRANSFER, dev->fx_lcr);
  81                 outb (page, dev->fx_dsp_page);
  82                 outb (addr, dev->fx_dsp_addr);
  83                 outb ((data[0] >> 8), dev->fx_dsp_msb);
  84                 outb ((data[0] & 0xff), dev->fx_dsp_lsb);
  85 
  86                 snd_printk ("FX: addr %d:%x set to 0x%x\n",
  87                         page, addr, data[0]);
  88 
  89         } else {
  90                 int i;
  91 
  92                 outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev->fx_lcr);
  93                 outb (page, dev->fx_dsp_page);
  94                 outb (addr, dev->fx_dsp_addr);
  95 
  96                 for (i = 0; i < cnt; i++) {
  97                         outb ((data[i] >> 8), dev->fx_dsp_msb);
  98                         outb ((data[i] & 0xff), dev->fx_dsp_lsb);
  99                         if (!wavefront_fx_idle (dev)) {
 100                                 break;
 101                         }
 102                 }
 103 
 104                 if (i != cnt) {
 105                         snd_printk ("FX memset "
 106                                     "(0x%x, 0x%x, 0x%lx, %d) incomplete\n",
 107                                     page, addr, (unsigned long) data, cnt);
 108                         return -EIO;
 109                 }
 110         }
 111 
 112         return 0;
 113 }
 114 
 115 int
 116 snd_wavefront_fx_detect (snd_wavefront_t *dev)
 117 
 118 {
 119         /* This is a crude check, but its the best one I have for now.
 120            Certainly on the Maui and the Tropez, wavefront_fx_idle() will
 121            report "never idle", which suggests that this test should
 122            work OK.
 123         */
 124 
 125         if (inb (dev->fx_status) & 0x80) {
 126                 snd_printk ("Hmm, probably a Maui or Tropez.\n");
 127                 return -1;
 128         }
 129 
 130         return 0;
 131 }
 132 
 133 int
 134 snd_wavefront_fx_open (struct snd_hwdep *hw, struct file *file)
 135 
 136 {
 137         if (!try_module_get(hw->card->module))
 138                 return -EFAULT;
 139         file->private_data = hw;
 140         return 0;
 141 }
 142 
 143 int 
 144 snd_wavefront_fx_release (struct snd_hwdep *hw, struct file *file)
 145 
 146 {
 147         module_put(hw->card->module);
 148         return 0;
 149 }
 150 
 151 int
 152 snd_wavefront_fx_ioctl (struct snd_hwdep *sdev, struct file *file,
 153                         unsigned int cmd, unsigned long arg)
 154 
 155 {
 156         struct snd_card *card;
 157         snd_wavefront_card_t *acard;
 158         snd_wavefront_t *dev;
 159         wavefront_fx_info r;
 160         unsigned short *page_data = NULL;
 161         unsigned short *pd;
 162         int err = 0;
 163 
 164         card = sdev->card;
 165         if (snd_BUG_ON(!card))
 166                 return -ENODEV;
 167         if (snd_BUG_ON(!card->private_data))
 168                 return -ENODEV;
 169 
 170         acard = card->private_data;
 171         dev = &acard->wavefront;
 172 
 173         if (copy_from_user (&r, (void __user *)arg, sizeof (wavefront_fx_info)))
 174                 return -EFAULT;
 175 
 176         switch (r.request) {
 177         case WFFX_MUTE:
 178                 wavefront_fx_mute (dev, r.data[0]);
 179                 return -EIO;
 180 
 181         case WFFX_MEMSET:
 182                 if (r.data[2] <= 0) {
 183                         snd_printk ("cannot write "
 184                                 "<= 0 bytes to FX\n");
 185                         return -EIO;
 186                 } else if (r.data[2] == 1) {
 187                         pd = (unsigned short *) &r.data[3];
 188                 } else {
 189                         if (r.data[2] > 256) {
 190                                 snd_printk ("cannot write "
 191                                             "> 512 bytes to FX\n");
 192                                 return -EIO;
 193                         }
 194                         page_data = memdup_user((unsigned char __user *)
 195                                                 r.data[3],
 196                                                 r.data[2] * sizeof(short));
 197                         if (IS_ERR(page_data))
 198                                 return PTR_ERR(page_data);
 199                         pd = page_data;
 200                 }
 201 
 202                 err = wavefront_fx_memset (dev,
 203                              r.data[0], /* page */
 204                              r.data[1], /* addr */
 205                              r.data[2], /* cnt */
 206                              pd);
 207                 kfree(page_data);
 208                 break;
 209 
 210         default:
 211                 snd_printk ("FX: ioctl %d not yet supported\n",
 212                             r.request);
 213                 return -ENOTTY;
 214         }
 215         return err;
 216 }
 217 
 218 /* YSS225 initialization.
 219 
 220    This code was developed using DOSEMU. The Turtle Beach SETUPSND
 221    utility was run with I/O tracing in DOSEMU enabled, and a reconstruction
 222    of the port I/O done, using the Yamaha faxback document as a guide
 223    to add more logic to the code. Its really pretty weird.
 224 
 225    This is the approach of just dumping the whole I/O
 226    sequence as a series of port/value pairs and a simple loop
 227    that outputs it.
 228 */
 229 
 230 int
 231 snd_wavefront_fx_start (snd_wavefront_t *dev)
 232 {
 233         unsigned int i;
 234         int err;
 235         const struct firmware *firmware = NULL;
 236 
 237         if (dev->fx_initialized)
 238                 return 0;
 239 
 240         err = request_firmware(&firmware, "yamaha/yss225_registers.bin",
 241                                dev->card->dev);
 242         if (err < 0) {
 243                 err = -1;
 244                 goto out;
 245         }
 246 
 247         for (i = 0; i + 1 < firmware->size; i += 2) {
 248                 if (firmware->data[i] >= 8 && firmware->data[i] < 16) {
 249                         outb(firmware->data[i + 1],
 250                              dev->base + firmware->data[i]);
 251                 } else if (firmware->data[i] == WAIT_IDLE) {
 252                         if (!wavefront_fx_idle(dev)) {
 253                                 err = -1;
 254                                 goto out;
 255                         }
 256                 } else {
 257                         snd_printk(KERN_ERR "invalid address"
 258                                    " in register data\n");
 259                         err = -1;
 260                         goto out;
 261                 }
 262         }
 263 
 264         dev->fx_initialized = 1;
 265         err = 0;
 266 
 267 out:
 268         release_firmware(firmware);
 269         return err;
 270 }
 271 
 272 MODULE_FIRMWARE("yamaha/yss225_registers.bin");
/* [<][>][^][v][top][bottom][index][help] */
root/sound/isa/wavefront/wavefront_fx.c

DEFINITIONS
