// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Copyright (c) 1998-2002 by Paul Davis <pbd@op.net>
 */

#include <linux/io.h>
#include <linux/init.h>
#include <linux/time.h>
#include <linux/wait.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/firmware.h>
#include <sound/core.h>
#include <sound/snd_wavefront.h>
#include <sound/initval.h>

/* Control bits for the Load Control Register
 */

#define FX_LSB_TRANSFER 0x01    /* transfer after DSP LSB byte written */
#define FX_MSB_TRANSFER 0x02    /* transfer after DSP MSB byte written */
#define FX_AUTO_INCR    0x04    /* auto-increment DSP address after transfer */

#define WAIT_IDLE 0xff

static int
wavefront_fx_idle (snd_wavefront_t *dev)

{
 int i;
 unsigned int x = 0x80;

 for (i = 0; i < 1000; i++) {
  x = inb (dev->fx_status);
  if ((x & 0x80) == 0) {
   break;
  }
 }

 if (x & 0x80) {
  dev_err(dev->card->dev, "FX device never idle.\n");
  return 0;
 }

 return (1);
}

static void
wavefront_fx_mute (snd_wavefront_t *dev, int onoff)

{
 if (!wavefront_fx_idle(dev)) {
  return;
 }

 outb (onoff ? 0x02 : 0x00, dev->fx_op);
}

static int
wavefront_fx_memset (snd_wavefront_t *dev,
       int page,
       int addr,
       int cnt,
       unsigned short *data)
{
 if (page < 0 || page > 7) {
  dev_err(dev->card->dev,
   "FX memset: page must be >= 0 and <= 7\n");
  return -EINVAL;
 }

 if (addr < 0 || addr > 0x7f) {
  dev_err(dev->card->dev,
   "FX memset: addr must be >= 0 and <= 7f\n");
  return -EINVAL;
 }

 if (cnt == 1) {

  outb (FX_LSB_TRANSFER, dev->fx_lcr);
  outb (page, dev->fx_dsp_page);
  outb (addr, dev->fx_dsp_addr);
  outb ((data[0] >> 8), dev->fx_dsp_msb);
  outb ((data[0] & 0xff), dev->fx_dsp_lsb);

  dev_err(dev->card->dev, "FX: addr %d:%x set to 0x%x\n",
   page, addr, data[0]);

 } else {
  int i;

  outb (FX_AUTO_INCR|FX_LSB_TRANSFER, dev->fx_lcr);
  outb (page, dev->fx_dsp_page);
  outb (addr, dev->fx_dsp_addr);

  for (i = 0; i < cnt; i++) {
   outb ((data[i] >> 8), dev->fx_dsp_msb);
   outb ((data[i] & 0xff), dev->fx_dsp_lsb);
   if (!wavefront_fx_idle (dev)) {
    break;
   }
  }

  if (i != cnt) {
   dev_err(dev->card->dev,
    "FX memset (0x%x, 0x%x, 0x%lx, %d) incomplete\n",
    page, addr, (unsigned long) data, cnt);
   return -EIO;
  }
 }

 return 0;
}

int
snd_wavefront_fx_detect (snd_wavefront_t *dev)

{
 /* This is a crude check, but its the best one I have for now.
    Certainly on the Maui and the Tropez, wavefront_fx_idle() will
    report "never idle", which suggests that this test should
    work OK.
*/

 if (inb (dev->fx_status) & 0x80) {
  dev_err(dev->card->dev, "Hmm, probably a Maui or Tropez.\n");
  return -1;
 }

 return 0;
}

int
snd_wavefront_fx_open (struct snd_hwdep *hw, struct file *file)

{
 if (!try_module_get(hw->card->module))
  return -EFAULT;
 file->private_data = hw;
 return 0;
}

int 
snd_wavefront_fx_release (struct snd_hwdep *hw, struct file *file)

{
 module_put(hw->card->module);
 return 0;
}

int
snd_wavefront_fx_ioctl (struct snd_hwdep *sdev, struct file *file,
   unsigned int cmd, unsigned long arg)

{
 struct snd_card *card;
 snd_wavefront_card_t *acard;
 snd_wavefront_t *dev;
 wavefront_fx_info r;
 unsigned short *page_data = NULL;
 unsigned short *pd;
 int err = 0;

 card = sdev->card;
 if (snd_BUG_ON(!card))
  return -ENODEV;
 if (snd_BUG_ON(!card->private_data))
  return -ENODEV;

 acard = card->private_data;
 dev = &acard->wavefront;

 if (copy_from_user (&r, (void __user *)arg, sizeof (wavefront_fx_info)))
  return -EFAULT;

 switch (r.request) {
 case WFFX_MUTE:
  wavefront_fx_mute (dev, r.data[0]);
  return -EIO;

 case WFFX_MEMSET:
  if (r.data[2] <= 0) {
   dev_err(dev->card->dev,
    "cannot write <= 0 bytes to FX\n");
   return -EIO;
  } else if (r.data[2] == 1) {
   pd = (unsigned short *) &r.data[3];
  } else {
   if (r.data[2] > 256) {
    dev_err(dev->card->dev,
     "cannot write > 512 bytes to FX\n");
    return -EIO;
   }
   page_data = memdup_array_user((unsigned char __user *)
            r.data[3],
            r.data[2], sizeof(short));
   if (IS_ERR(page_data))
    return PTR_ERR(page_data);
   pd = page_data;
  }

  err = wavefront_fx_memset (dev,
        r.data[0], /* page */
        r.data[1], /* addr */
        r.data[2], /* cnt */
        pd);
  kfree(page_data);
  break;

 default:
  dev_err(dev->card->dev, "FX: ioctl %d not yet supported\n",
   r.request);
  return -ENOTTY;
 }
 return err;
}

/* YSS225 initialization.

   This code was developed using DOSEMU. The Turtle Beach SETUPSND
   utility was run with I/O tracing in DOSEMU enabled, and a reconstruction
   of the port I/O done, using the Yamaha faxback document as a guide
   to add more logic to the code. Its really pretty weird.

   This is the approach of just dumping the whole I/O
   sequence as a series of port/value pairs and a simple loop
   that outputs it.
*/

int
snd_wavefront_fx_start (snd_wavefront_t *dev)
{
 unsigned int i;
 int err;
 const struct firmware *firmware = NULL;

 if (dev->fx_initialized)
  return 0;

 err = request_firmware(&firmware, "yamaha/yss225_registers.bin",
          dev->card->dev);
 if (err < 0) {
  err = -1;
  goto out;
 }

 for (i = 0; i + 1 < firmware->size; i += 2) {
  if (firmware->data[i] >= 8 && firmware->data[i] < 16) {
   outb(firmware->data[i + 1],
        dev->base + firmware->data[i]);
  } else if (firmware->data[i] == WAIT_IDLE) {
   if (!wavefront_fx_idle(dev)) {
    err = -1;
    goto out;
   }
  } else {
   dev_err(dev->card->dev,
    "invalid address in register data\n");
   err = -1;
   goto out;
  }
 }

 dev->fx_initialized = 1;
 err = 0;

out:
 release_firmware(firmware);
 return err;
}

MODULE_FIRMWARE("yamaha/yss225_registers.bin");