/*
 * Purpose: USB audio streaming interface support
 */
/*
 *
 * This file is part of Open Sound System.
 *
 * Copyright (C) 4Front Technologies 1996-2008.
 *
 * This this source file is released under GPL v2 license (no other versions).
 * See the COPYING file included in the main directory of this source
 * distribution for the license terms and conditions.
 *
 */

#include "oss_config.h"
#include "ossusb.h"

#define SAMPLING_FREQ_CONTROL      0x01
#define PITCH_CONTROL              0x02

#define FORMAT_II_UNDEFINED		0x1000
#define FORMAT_II_MPEG			0x1001
#define FORMAT_II_AC3			0x1002

#define TMPBUF_SIZE	4096

#if 0
static int
read_control_value (ossusb_devc * devc, int endpoint, int ctl, int l)
{
  unsigned char buf[4];
  int len, i, v;

  memset (buf, 0, sizeof (buf));

  len = udi_usb_rcv_control_msg (devc->mixer_usbdev, 0,	// endpoint
				 GET_CUR, USB_RECIP_ENDPOINT | USB_TYPE_CLASS,	// rqtype
				 ctl << 8,	// value
				 endpoint,	// index
				 buf,	// buffer
				 l,	// buflen
				 OSS_HZ);
  if (len < 0)
    {
      cmn_err (CE_WARN, "Endpoint read error %d\n", len);
      return 0;
    }

  cmn_err (CE_CONT, "Read len %d (%d): ", len, l);
  for (i = 0; i < len; i++)
    cmn_err (CE_CONT, "%02x ", buf[i]);

  switch (len)
    {
    case 3:
      v = buf[0] | (buf[1] << 8) | (buf[2] << 16);
      break;

    default:
      cmn_err (CE_CONT, "oss usbaudio: Bad control read (%d)\n", l);
    }

  cmn_err (CE_CONT, "= %d\n", v);

  return v;
}
#endif

static int
write_control_value (ossusb_devc * devc, udi_endpoint_handle_t * endpoint,
		     int ctl, int l, unsigned int v)
{
  unsigned char buf[4];
  int len;

  memset (buf, 0, sizeof (buf));

  switch (l)
    {
    case 3:
      buf[0] = (v) & 0xff;
      buf[1] = (v >> 8) & 0xff;
      buf[2] = (v >> 16) & 0xff;
      break;

    default:
      cmn_err (CE_CONT, "oss usbaudio: Bad control size %d\n", l);
      return OSS_EIO;
    }

  len = udi_usb_snd_control_msg (devc->mixer_usbdev, 0,	// endpoint
				 SET_CUR, USB_RECIP_ENDPOINT | USB_TYPE_CLASS,	// rqtype
				 ctl << 8,	// value
				 udi_endpoint_get_num (endpoint),	// index
				 buf,	// buffer
				 l,	// buflen
				 OSS_HZ);
  if (len < 0)
    {
      cmn_err (CE_WARN, "Endpoint control write error %d\n", len);
      return OSS_EIO;
    }

  return len;
}

static void
set_fraglimits (adev_t * adev, ossusb_portc * portc)
{
  int l, m;

  if (portc->bytes_per_sample < 1)
    portc->bytes_per_sample = 1;

  l = portc->bytes_per_sample * adev->min_channels * portc->speed / 1000;
  l = (l / portc->bytes_per_sample) * portc->bytes_per_sample;

  m = 2;

  while (m < l)
    m *= 2;

  adev->min_block = m;
  adev->max_block = TMPBUF_SIZE / 2;
  portc->fragment_size = l;
}

static int
usbaudio_set_rate (int dev, int arg)
{
  adev_p adev = audio_engines[dev];
  ossusb_portc *portc = adev->portc;
  ossusb_devc *devc = adev->devc;

  int i, x, diff, bestdiff;

  if (devc->disabled)
    return OSS_EPIPE;

  if (arg == 0)
    return portc->speed;

  if (arg < adev->min_rate)
    arg = adev->min_rate;
  if (arg > adev->max_rate)
    arg = adev->max_rate;

  if (!(adev->caps & PCM_CAP_FREERATE))
    {
      /* Search for the nearest supported rate */
      bestdiff = 0x7fffffff;
      x = -1;

      for (i = 0; i < adev->nrates; i++)
	{
	  diff = arg - adev->rates[i];

	  if (diff < 0)
	    diff = -diff;	/* ABS */
	  if (diff < bestdiff)
	    {
	      x = i;
	      bestdiff = diff;
	    }
	}

      if (x > -1)
	arg = adev->rates[x];
    }

  portc->speed = arg;
  set_fraglimits (adev, portc);

  return portc->speed;
}

/*ARGSUSED*/
static short
usbaudio_set_channels (int dev, short arg)
{
  adev_p adev = audio_engines[dev];
  ossusb_devc *devc = adev->devc;

  if (devc->disabled)
    return OSS_EPIPE;

  return adev->min_channels;	/* max_channels should be the same too */
}

/*ARGSUSED*/
static unsigned int
usbaudio_set_format (int dev, unsigned int arg)
{
  adev_p adev = audio_engines[dev];
  ossusb_devc *devc = adev->devc;

  if (devc->disabled)
    return adev->oformat_mask;

  return adev->oformat_mask;	/* iformat_mask should be the same  too */
}

/*ARGSUSED*/
static int
usbaudio_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  if (devc->disabled)
    return OSS_EPIPE;

  return OSS_EINVAL;
}

/*ARGSUSED*/
static int
setup_format_I (ossusb_devc * devc, ossusb_portc * portc, adev_p adev,
		unsigned char *d, int l)
{
  int min_rate = 0, max_rate = 0;
  int i, n;
  int frame_size, bits, channels;
  unsigned int fmt = 0;

  if (usb_trace > 1)
    {
      cmn_err (CE_CONT,
	       "AS_FORMAT_TYPE: FORMAT_TYPE_I, #ch %d, framesize %d, bits %d, freq_type %02x, freq=",
	       d[4], d[5], d[6], d[7]);
      if (d[7] == 0)
	cmn_err (CE_CONT, "%d-%d ", ossusb_get_int (&d[8], 3),
		 ossusb_get_int (&d[11], 3));
      {
	for (i = 0; i < d[7]; i++)
	  cmn_err (CE_CONT, "%d ", ossusb_get_int (&d[8 + i * 3], 3));
	cmn_err (CE_CONT, " ");
      }

      switch (d[3])
	{
	case 0x00:
	  cmn_err (CE_CONT, "Undefined ");
	  break;
	case 0x01:
	  cmn_err (CE_CONT, "PCM ");
	  break;
	case 0x02:
	  cmn_err (CE_CONT, "PCM8 ");
	  break;
	case 0x03:
	  cmn_err (CE_CONT, "float ");
	  break;
	case 0x04:
	  cmn_err (CE_CONT, "A-Law ");
	  break;
	case 0x05:
	  cmn_err (CE_CONT, "u-Law ");
	  break;
	}
      cmn_err (CE_CONT, "\n");
    }

  channels = d[4];
  frame_size = d[5];
  bits = d[6];
  UDB (cmn_err (CE_CONT, "Channels %d, bits %d (%d bytes)\n", channels, bits,
		frame_size));

  adev->min_channels = adev->max_channels = channels;
  portc->convert_3byte = 0;

  switch (d[3])
    {
    case 0x01:
      fmt = AFMT_S16_LE;
      break;
    case 0x02:
      fmt = AFMT_U8;
      break;
    case 0x03:
      fmt = AFMT_FLOAT;
      break;
    case 0x04:
      fmt = AFMT_A_LAW;
      break;
    case 0x05:
      fmt = AFMT_MU_LAW;
      break;
    }

  if (fmt == AFMT_S16_LE)	/* Have to check the frame size too */
    {
      switch (frame_size)
	{
	case 1:
	  fmt = AFMT_S8;
	  break;
	case 2:
	  fmt = AFMT_S16_LE;
	  break;
	case 3:
	  fmt = AFMT_S32_LE;
	  frame_size = 4;
	  portc->convert_3byte = 1;
	  break;
	case 4:
	  fmt = AFMT_S32_LE;
	  break;
	}
    }

  portc->bytes_per_sample = frame_size;
  adev->oformat_mask = adev->iformat_mask = fmt;
  UDB (cmn_err (CE_CONT, "Format mask %08x\n", fmt));

  adev->caps &= ~PCM_CAP_FREERATE;
  n = d[7];
  if (n < 1)			/* Free rate selection between min (0) and max (1) */
    {
      n = 2;
      adev->caps |= PCM_CAP_FREERATE;
    }

  min_rate = 0x7fffffff;
  max_rate = 0;

  if (n > 20)
    {
      cmn_err (CE_WARN, "The device supports too many sample rates\n");
      n = 20;
    }

  adev->nrates = 0;

  for (i = 0; i < n; i++)
    {
      int rate = ossusb_get_int (&d[8 + i * 3], 3);

#if 0
      /* Skip rates that are not multiples of 1000 Hz */
      if (rate % 1000)
	continue;
#endif

      if (rate < min_rate)
	min_rate = rate;
      if (rate > max_rate)
	max_rate = rate;
      adev->rates[adev->nrates++] = rate;
    }

  adev->min_rate = min_rate;
  adev->max_rate = max_rate;
  UDB (cmn_err (CE_CONT, "Min rate %d, max rate %d\n", min_rate, max_rate));

  adev->caps &= ~DSP_CH_MASK;

  switch (channels)
    {
    case 1:
      adev->caps |= DSP_CH_MONO;
      break;
    case 2:
      adev->caps |= DSP_CH_STEREO;
      break;
    default:
      adev->caps |= DSP_CH_MULTI;
      break;
    }
  return 0;
}

/*ARGSUSED*/
static int
setup_format_II (ossusb_devc * devc, ossusb_portc * portc, adev_p adev,
		 unsigned char *d, int l)
{
  int min_rate = 0, max_rate = 0;
  int i;

  if (usb_trace > 1)
    {
      cmn_err (CE_CONT, "MaxBitRate %d ", d[4]);
      cmn_err (CE_CONT, "SamplesPerFrame %d ", d[5]);

      if (d[8] == 0)
	cmn_err (CE_CONT, "Sample Rates %d-%d ", ossusb_get_int (&d[9], 3),
		 ossusb_get_int (&d[12], 3));
      else
	{
	  int n;
	  int min_rate = 0x7fffffff;
	  int max_rate = 0;

	  n = d[8];

	  if (n > 20)
	    {
	      cmn_err (CE_CONT, "oss usbaudio: Too many sample rates (%d)\n",
		       n);
	      n = 20;
	    }

	  adev->nrates = 0;
	  cmn_err (CE_CONT, "Possible sample rates: ");
	  for (i = 0; i < d[8]; i++)
	    {
	      int rate = ossusb_get_int (&d[9 + i * 3], 3);

#if 0
	      /* Skip rates that are not multiples of 1000 Hz */
	      if (rate % 1000)
		continue;
#endif

	      if (rate < min_rate)
		min_rate = rate;
	      if (rate > max_rate)
		max_rate = rate;
	      cmn_err (CE_CONT, "%d ", rate);
	      adev->rates[adev->nrates++] = rate;
	    }
	  adev->min_rate = min_rate;
	  adev->max_rate = max_rate;
	}

      cmn_err (CE_CONT, "\n");
    }

  adev->caps &= ~PCM_CAP_FREERATE;
  if (d[8] == 0)
    {
      min_rate = ossusb_get_int (&d[9], 3);
      max_rate = ossusb_get_int (&d[12], 3);
      adev->caps |= PCM_CAP_FREERATE;
    }
  else
    {
      min_rate = 1 << 30;
      max_rate = 0;

      for (i = 0; i < d[8]; i++)
	{
	  int r = ossusb_get_int (&d[9 + i * 3], 3);

	  if (r < min_rate)
	    min_rate = r;
	  if (r > max_rate)
	    max_rate = r;
	}
    }

  adev->min_channels = adev->max_channels = 2;
  adev->oformat_mask = adev->iformat_mask = AFMT_AC3;
  adev->min_rate = min_rate;
  adev->max_rate = max_rate;

  return 0;
}

/*ARGSUSED*/
static int
setup_format_specific (ossusb_devc * devc, ossusb_portc * portc, adev_p adev,
		       unsigned char *d, int l)
{
  int fmt;

  fmt = ossusb_get_int (&d[3], 2);

  if (usb_trace > 1)
    cmn_err (CE_CONT, "Format specific: fmt=%04x\n", fmt);

  switch (fmt)
    {
    case FORMAT_II_MPEG:
      if (usb_trace > 1)
	cmn_err (CE_CONT, "MPEG format\n");
      adev->oformat_mask = adev->iformat_mask = AFMT_MPEG;
      break;

    case FORMAT_II_AC3:
      if (usb_trace > 1)
	cmn_err (CE_CONT, "AC3 format\n");
      adev->oformat_mask = adev->iformat_mask = AFMT_AC3;
#if 0
      cmn_err (CE_CONT, "BSID=%08x\n", ossusb_get_int (&d[5], 4));
      cmn_err (CE_CONT, "AC3Features %02x\n", d[9]);
#endif
      break;

    default:
      cmn_err (CE_CONT, "oss usbaudio: Unsupported FORMAT II tag %04x\n",
	       fmt);
      adev->enabled = 0;
      return OSS_ENXIO;
    }
  return 0;
}

static int
prepare_altsetting (ossusb_devc * devc, ossusb_portc * portc, int new_setting)
{
  int desc_len;
  unsigned char *desc, *d;
  int l, p;
  int err;
  adev_p adev;

  adev = audio_engines[portc->audio_dev];
  adev->enabled = 1;
  portc->disabled = 0;

  if (portc->act_setting == new_setting)	/* No need to change */
    return 0;

  if (new_setting < portc->num_settings)
    desc = udi_usbdev_get_altsetting (portc->usbdev, new_setting, &desc_len);
  else
    desc = NULL;

  if (desc == NULL || desc_len < 3)
    {
      cmn_err (CE_CONT,
	       "Audio device %d not available when altsetting=%d\n",
	       audio_engines[portc->audio_dev]->real_dev, new_setting);
      portc->disabled = 1;
      adev->enabled = 0;
      portc->act_setting = new_setting;
      return OSS_ENXIO;
    }

  UDB (cmn_err
       (CE_CONT, "Select active setting %d on interface %d (dsp%d)\n",
	new_setting, portc->if_number, adev->engine_num));
  portc->act_setting = new_setting;

  p = 0;
  while (p < desc_len)
    {
      int i;

      d = desc + p;
      l = *d;

      if (usb_trace > 1)
	{
	  cmn_err (CE_CONT, "Streaming desc: ");
	  for (i = 0; i < l; i++)
	    cmn_err (CE_CONT, "%02x ", d[i]);
	  cmn_err (CE_CONT, "\n");

	}

      if (d[1] != CS_INTERFACE)
	{
	UDB (cmn_err (CE_CONT, "Unknown descriptor type %02x\n", d[1]))}
      else
	switch (d[2])
	  {
	  case AS_GENERAL:
	    portc->terminal_link = d[3];
	    portc->pipeline_delay = d[4];

	    if (usb_trace > 1)
	      {
		cmn_err (CE_CONT, "AS_GENERAL ");
		cmn_err (CE_CONT, "Terminal link %d/%s ", d[3],
			 devc->units[d[3]].name);
		cmn_err (CE_CONT, "Delay %d ", d[4]);
		cmn_err (CE_CONT, "Format tag %02x%02x ", d[5], d[6]);
		cmn_err (CE_CONT, "\n");
	      }
	    break;

	  case AS_FORMAT_TYPE:
	    if (usb_trace > 1)
	      {
		cmn_err (CE_CONT, "AS_FORMAT_TYPE: FORMAT_TYPE_%d: ", d[3]);
	      }

	    switch (d[3])
	      {
	      case 1:		/* FORMAT_TYPE_I */
		if ((err = setup_format_I (devc, portc, adev, d, l)) < 0)
		  return err;
		break;

	      case 2:		/* FORMAT_TYPE_II */
		if ((err = setup_format_II (devc, portc, adev, d, l)) < 0)
		  return err;
		break;

	      default:
		cmn_err (CE_CONT,
			 "\noss usbaudio: Unsupported format type %d\n",
			 d[3]);
		adev->enabled = 0;
		return OSS_ENXIO;
	      }
	    break;

	  case AS_FORMAT_SPECIFIC:
	    if ((err = setup_format_specific (devc, portc, adev, d, l)) < 0)
	      return err;
	    break;

	  default:
	    UDB (cmn_err
		 (CE_CONT, "Unknown descriptor subtype %02x\n", d[2]));
	  }

      p += l;
    }

  desc = udi_usbdev_get_endpoint (portc->usbdev, portc->act_setting, 0, &l);
  if (desc == NULL)
    {
      cmn_err (CE_CONT, "oss usbaudio: Bad endpoint\n");
      return OSS_EIO;
    }

  portc->endpoint_desc = desc;

  desc = udi_usbdev_get_endpoint (portc->usbdev, portc->act_setting, 1, &l);
#if 0
  if (desc != NULL)
    {
      /* TODO: Handle sync endpoints */
      cmn_err (CE_CONT, "Sync Endpoint: ");
      ossusb_dump_desc (desc, l);
    }
#endif

  return 0;
}

static void usbaudio_close (int dev, int mode);

/*ARGSUSED*/
static int
usbaudio_open (int dev, int mode, int open_flags)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  ossusb_portc *portc = audio_engines[dev]->portc;
  oss_native_word flags, phaddr;
  int err;
  int i;

  if (devc->disabled)
    return OSS_EPIPE;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
  if (portc->open_mode != 0)
    {
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
      return OSS_EBUSY;
    }
  portc->open_mode = mode;
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);

  if ((err = prepare_altsetting (devc, portc, portc->act_setting)) < 0)
    {
      portc->open_mode = 0;
      return err;
    }

  {
    int i;

    for (i = 0; i < 2; i++)
      portc->tmp_buf[i] =
	CONTIG_MALLOC (devc->osdev, TMPBUF_SIZE, MEMLIMIT_32BITS, &phaddr, portc->tmpbuf_dma_handle[i]);
  }

  if ((err =
       udi_usbdev_set_interface (portc->usbdev, portc->if_number,
				 portc->act_setting)) < 0)
    {
      cmn_err (CE_NOTE,
	       "oss usbaudio: Failed to set interface mode, error %d - ignored\n",
	       err);
      // portc->open_mode = 0;
      //return err;
    }

  portc->curr_datapipe = 0;

  if ((portc->endpoint_handle =
       udi_open_endpoint (portc->usbdev, portc->endpoint_desc)) == NULL)
    {
      usbaudio_close (dev, mode);
      cmn_err (CE_WARN, "Cannot open audio pipe\n");
      return OSS_ENOMEM;
    }

  for (i = 0; i < 2; i++)
    {
      if ((portc->datapipe[i] =
	   udi_usb_alloc_request (portc->usbdev, portc->endpoint_handle, 1,
				  UDI_USBXFER_ISO_WRITE)) == NULL)
	{
	  usbaudio_close (dev, mode);
	  cmn_err (CE_WARN, "Cannot alloc isoc request\n");
	  return OSS_ENOMEM;
	}
    }

  set_fraglimits (audio_engines[dev], portc);
  return 0;
}

static void usbaudio_reset (int dev);

/*ARGSUSED*/
static void
usbaudio_close (int dev, int mode)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  ossusb_portc *portc = audio_engines[dev]->portc;
  int i;

  usbaudio_reset (dev);

  for (i = 0; i < 2; i++)
    {
      if (portc->datapipe[i] != NULL)
	{
	  udi_usb_free_request (portc->datapipe[i]);
	  portc->datapipe[i] = NULL;
	}

      if (portc->tmp_buf[i] != NULL)
	{
	  CONTIG_FREE (devc->osdev, portc->tmp_buf[i], TMPBUF_SIZE, portc->tmpbuf_dma_handle[i]);
	  portc->tmp_buf[i] = NULL;
	}
    }

  if (portc->endpoint_handle != NULL)
    udi_close_endpoint (portc->endpoint_handle);

  udi_usbdev_set_interface (portc->usbdev, portc->if_number, 0);
  portc->open_mode = 0;
}

/*ARGSUSED*/
static void
usbaudio_output_block (int dev, oss_native_word buf, int count,
		       int fragsize, int intrflag)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  if (devc->disabled)
    return;
}

/*ARGSUSED*/
static void
usbaudio_start_input (int dev, oss_native_word buf, int count, int fragsize,
		      int intrflag)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  if (devc->disabled)
    return;
}

static int feed_output (int dev, ossusb_devc * devc, ossusb_portc * portc);
static void start_input (int dev, ossusb_devc * devc, ossusb_portc * portc);

static int
copy_input (ossusb_portc * portc, dmap_t * dmap, unsigned char *buf, int len)
{
  int outlen = 0;
  int offs;

  offs = (int) (dmap->byte_counter % dmap->bytes_in_use);

  while (len > 0)
    {
      int l;
      l = len;

      if (portc->convert_3byte)
	{
	  int i, n;
	  int *dmabuf;

	  l = (l * 4) / 3;
	  /* Check for buffer wraparound */
	  if (offs + l > dmap->bytes_in_use)
	    l = dmap->bytes_in_use - offs;

	  n = (l / 4);

	  if (dmap == NULL || dmap->dmabuf == NULL)
	    return outlen;

	  dmabuf = (int *) (dmap->dmabuf + offs);

	  for (i = 0; i < n; i++)
	    {
	      int v;

	      v = buf[2] | (buf[1] << 8) | (buf[0] << 16);
	      *dmabuf++ = v;
	      buf += 3;
	    }

	  outlen += l;
	}
      else
	{
	  unsigned char *dmabuf;
	  dmabuf = dmap->dmabuf;

	  if (dmap == NULL || dmap->dmabuf == NULL)
	    return outlen;

	  /* Check for buffer wraparound */
	  if (offs + l > dmap->bytes_in_use)
	    l = dmap->bytes_in_use - offs;

	  memcpy (dmabuf + offs, buf, l);
	  outlen += l;
	  buf += l;
	}

      len -= l;
      offs = 0;
    }

  return outlen;
}

/*ARGSUSED*/
static void
play_callback (udi_usb_request_t * request, void *arg)
{
  ossusb_portc *portc = arg;

  feed_output (portc->audio_dev, portc->devc, portc);
  oss_audio_outputintr (portc->audio_dev,
			AINTR_NO_POINTER_UPDATES | AINTR_LOCALQUEUE);
}

static void
rec_callback (udi_usb_request_t * request, void *arg)
{
  ossusb_portc *portc = arg;
  dmap_t *dmap;
  int len;

  if (portc == NULL || (unsigned long) arg < 4096)
    {
      cmn_err (CE_WARN, "Bad portc\n");
      return;
    }

  dmap = audio_engines[portc->audio_dev]->dmap_in;
  len = udi_usb_request_actlen (request);

  if (len == 0)
    return;			/* No data so it looks like we are closing down */

  if ((len =
       copy_input (portc, dmap, udi_usb_request_actdata (request), len)) < 1)
    {
      cmn_err (CE_WARN, "Saving recorded data failed (%d)\n", len);
      return;
    }

  oss_audio_inc_byte_counter (dmap, len);
  oss_audio_inputintr (portc->audio_dev, AINTR_NO_POINTER_UPDATES);
#ifdef linux
  start_input (portc->audio_dev, portc->devc, portc);
#endif
}

#if 0
/*
 * Testing stuff only
 */
static int
sin_gen (void)
{

  static int phase = 0, v;

  static short sinebuf[48] = {
    0, 4276, 8480, 12539, 16383, 19947, 23169, 25995,
    28377, 30272, 31650, 32486, 32767, 32486, 31650, 30272,
    28377, 25995, 23169, 19947, 16383, 12539, 8480, 4276,
    0, -4276, -8480, -12539, -16383, -19947, -23169, -25995,
    -28377, -30272, -31650, -32486, -32767, -32486, -31650, -30272,
    -28377, -25995, -23169, -19947, -16383, -12539, -8480, -4276
  };
  v = sinebuf[phase] * 256;
  phase = (phase + 1) % 48;

  return v;
}
#endif

/*ARGSUSED*/
static int
output_convert (ossusb_devc * devc, ossusb_portc * portc, dmap_p dmap,
		unsigned char *dmabuf, int pos, int pn, int total_len)
{
  unsigned char *tmpbuf = portc->tmp_buf[pn], *b;
  int i, n, len, out_size = 0;
  int err;

  while (total_len > 0)
    {
      int l = total_len;

      /* Check for buffer wraparound */
      if (pos + l > dmap->bytes_in_use)
	l = dmap->bytes_in_use - pos;

      total_len -= l;

      b = dmabuf + pos;

      if (portc->convert_3byte)
	{
	  int *buf;

	  n = l / sizeof (*buf);
	  buf = (int *) b;

	  len = n * 3;

	  for (i = 0; i < n; i++)
	    {
	      int val = (*buf++);

	      val /= 256;
	      // val=sin_gen();
	      *tmpbuf++ = (val) & 0xff;
	      *tmpbuf++ = (val >> 8) & 0xff;
	      *tmpbuf++ = (val >> 16) & 0xff;
	    }
	}
      else
	{
	  len = l;
	  memcpy (tmpbuf, b, l);
	  tmpbuf += l;
	}

      pos = 0;
      out_size += len;
    }

  if ((err =
       udi_usb_submit_request (portc->datapipe[pn], play_callback, portc,
			       portc->endpoint_handle, UDI_USBXFER_ISO_WRITE,
			       portc->tmp_buf[pn], out_size)) < 0)
    {
      //cmn_err(CE_CONT, "oss usbaudio: Write transfer eror %d\n", err);
      return err;
    }

  return 0;
}

static int
feed_output (int dev, ossusb_devc * devc, ossusb_portc * portc)
{
  int pn, pos, len;
  oss_native_word flags;
  adev_p adev = audio_engines[dev];
  dmap_p dmap = adev->dmap_out;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);

  if (portc->stopping)
    {
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
      return 0;
    }

  pn = portc->curr_datapipe;
  portc->curr_datapipe = (portc->curr_datapipe + 1) % NR_DATAPIPES;

  pos = (int) (dmap->byte_counter % dmap->bytes_in_use);
  len = portc->fragment_size;

  portc->overflow_samples += portc->overflow_size;
  if (portc->overflow_samples > 1000)
    {
      len += dmap->frame_size * (portc->overflow_samples / 1000);
      portc->overflow_samples = portc->overflow_samples % 1000;
    }

  output_convert (devc, portc, dmap, dmap->dmabuf, pos, pn, len);
  oss_audio_inc_byte_counter (dmap, len);
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
  return 0;
}

static void
start_input (int dev, ossusb_devc * devc, ossusb_portc * portc)
{
  int frag, err;
  oss_native_word flags;
  adev_p adev = audio_engines[dev];
  dmap_p dmap = adev->dmap_in;

  if (portc->stopping)
    return;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
  frag = 0;

  if ((err =
       udi_usb_submit_request (portc->datapipe[0], rec_callback, portc,
			       portc->endpoint_handle, UDI_USBXFER_ISO_READ,
			       dmap->dmabuf + frag * portc->fragment_size,
			       portc->fragment_size)) < 0)
    {
      cmn_err (CE_WARN, "oss usbaudio: Read transfer error %d\n", err);
      cmn_err (CE_CONT, "Endpoint %02x\n",
	       udi_endpoint_get_num (portc->endpoint_handle));
    }
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
}

static void
usbaudio_trigger (int dev, int state)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  ossusb_portc *portc = audio_engines[dev]->portc;

  if (devc->disabled)
    return;

  if (portc->open_mode & PCM_ENABLE_OUTPUT)
    {
      if ((portc->prepared_modes & PCM_ENABLE_OUTPUT)
	  && (state & PCM_ENABLE_OUTPUT))
	{
	  portc->prepared_modes &= ~PCM_ENABLE_OUTPUT;
	  portc->curr_datapipe = 0;
	  portc->stopping = 0;

	  feed_output (dev, devc, portc);
	  feed_output (dev, devc, portc);
	}
      else if (!(state & PCM_ENABLE_OUTPUT))
	{
	  portc->stopping = 1;
#if 1
	  udi_usb_cancel_request (portc->datapipe[0]);
	  udi_usb_cancel_request (portc->datapipe[1]);
#endif
	  portc->curr_datapipe = 0;
	}
    }

  if (portc->open_mode & PCM_ENABLE_INPUT)
    {
      if ((portc->prepared_modes & PCM_ENABLE_INPUT)
	  && (state & PCM_ENABLE_INPUT))
	{
	  portc->prepared_modes &= ~PCM_ENABLE_INPUT;
	  portc->stopping = 0;
	  start_input (dev, devc, portc);
	}
      else if (!(state & PCM_ENABLE_INPUT))
	{
	  portc->stopping = 1;
#if 0
	  udi_usb_cancel_request (portc->datapipe[0]);
	  udi_usb_cancel_request (portc->datapipe[1]);
#endif
	  portc->curr_datapipe = 0;
	}
    }
}

static void
usbaudio_reset (int dev)
{
  usbaudio_trigger (dev, 0);
}

/*ARGSUSED*/
static int
usbaudio_prepare_for_input (int dev, int bsize, int bcount)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  ossusb_portc *portc = audio_engines[dev]->portc;
  adev_p adev = audio_engines[dev];

  if (devc->disabled)
    return OSS_EPIPE;


  if (adev->flags & ADEV_NOINPUT)
    return OSS_ENOTSUP;

  portc->stopping = 0;

  if (write_control_value
      (devc, portc->endpoint_handle, SAMPLING_FREQ_CONTROL, 3,
       portc->speed) < 0)
    {
      cmn_err (CE_CONT, "Failed to set %d Hz sampling rate\n", portc->speed);
      return OSS_EIO;
    }

  /*
   * Handle fractional samples that don't fit in the 1ms period.
   */
  portc->overflow_size = portc->speed % 1000;
  portc->overflow_samples = 0;

  portc->prepared_modes |= PCM_ENABLE_INPUT;
  return 0;
}

/*ARGSUSED*/
static int
usbaudio_prepare_for_output (int dev, int bsize, int bcount)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  ossusb_portc *portc = audio_engines[dev]->portc;
  adev_p adev = audio_engines[dev];

  if (devc->disabled)
    return OSS_EPIPE;

  if (adev->flags & ADEV_NOOUTPUT)
    return OSS_ENOTSUP;

  portc->stopping = 0;

  if (write_control_value
      (devc, portc->endpoint_handle, SAMPLING_FREQ_CONTROL, 3,
       portc->speed) < 0)
    {
      cmn_err (CE_CONT, "Failed to set %d Hz sampling rate\n", portc->speed);
      return OSS_EIO;
    }

  /*
   * Handle fractional samples that don't fit in the 1ms period.
   */
  portc->overflow_size = portc->speed % 1000;
  portc->overflow_samples = 0;

  portc->prepared_modes |= PCM_ENABLE_OUTPUT;
  return 0;
}

static int
usbaudio_check_input (int dev)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  if (devc->disabled)
    {
      cmn_err (CE_CONT,
	       "oss usbaudio: Audio device %d removed from the system.\n",
	       dev);
      return OSS_EPIPE;
    }

  cmn_err (CE_CONT, "oss usbaudio: Audio input timed out on device %d.\n",
	   dev);
  return OSS_EIO;
}

static int
usbaudio_check_output (int dev)
{
  ossusb_devc *devc = audio_engines[dev]->devc;
  if (devc->disabled)
    {
      cmn_err (CE_CONT,
	       "oss usbaudio: Audio device %d removed from the system.\n",
	       dev);
      return OSS_EPIPE;
    }

  cmn_err (CE_CONT, "oss usbaudio: Audio output timed out on device %d.\n",
	   dev);
  return OSS_EIO;
}

static int
usbaudio_local_qlen (int dev)
{
  ossusb_portc *portc = audio_engines[dev]->portc;
  dmap_p dmap = audio_engines[dev]->dmap_out;
  int delay = portc->pipeline_delay + 1;	/* Pipeline delay in 1 msec ticks */

  delay = delay * dmap->data_rate / 1000;	/* Bytes/msec */

  return delay;
}

static audiodrv_t usbaudio_driver = {
  usbaudio_open,
  usbaudio_close,
  usbaudio_output_block,
  usbaudio_start_input,
  usbaudio_ioctl,
  usbaudio_prepare_for_input,
  usbaudio_prepare_for_output,
  usbaudio_reset,
  usbaudio_local_qlen,
  NULL,
  NULL,
  NULL,
  usbaudio_trigger,
  usbaudio_set_rate,
  usbaudio_set_format,
  usbaudio_set_channels,
  NULL,
  NULL,
  usbaudio_check_input,
  usbaudio_check_output,
  NULL,				/* usbaudio_alloc_buffer */
  NULL,				/* usbaudio_free_buffer */
  NULL,
  NULL,
  NULL				/* usbaudio_get_buffer_pointer */
};

ossusb_devc *
ossusb_init_audiostream (ossusb_devc * devc, udi_usb_devc * usbdev, int inum,
			 int reinit)
{
  int nsettings, actsetting = 0, desc_len;
  unsigned char *desc, *d;
  adev_p adev;
  int i, p, l;
  int portc_num;
  void *endpoint_desc;

  char dev_name[128];

  int opts = ADEV_AUTOMODE;

  ossusb_portc *portc;

  if (devc->num_audio_engines >= MAX_PORTC)
    {
      cmn_err (CE_CONT, "usbaudio: Too many audio streaming interfaces\n");
      return devc;
    }

  if (usbdev == NULL)
    {
      cmn_err (CE_CONT, "usbaudio: usbdev==NULL\n");
      return devc;
    }

  nsettings = udi_usbdev_get_num_altsettings (usbdev);
  desc = udi_usbdev_get_endpoint (usbdev, 1, 0, &l);
  if (desc != NULL)
    {
      /* cmn_err(CE_CONT, "Endpoint: ");ossusb_dump_desc(desc, l); */
      endpoint_desc = desc;
    }
  else
    endpoint_desc = NULL;

  if (reinit)
    for (i = 0; i < devc->num_audio_engines; i++)
      if (devc->portc[i].orig_endpoint_desc == endpoint_desc)	/* Already registered this */
	{
	  prepare_altsetting (devc, &devc->portc[i],
			      devc->portc[i].act_setting);
	  return devc;
	}

  portc = &devc->portc[devc->num_audio_engines];
  portc_num = devc->num_audio_engines;
  portc->if_number = inum;
  portc->endpoint_desc = portc->orig_endpoint_desc = endpoint_desc;
  portc->usbdev = usbdev;
  portc->act_setting = -1;	/* Set to an impossible value */
  devc->num_audio_engines++;

  memset (dev_name, 0, sizeof (dev_name));
  strncpy (dev_name, devc->dev_name, sizeof (dev_name) - 1);
  portc->num_settings = nsettings;

#if 1
  if (usb_trace > 2)
    for (i = 0; i < nsettings; i++)
      {
	desc = udi_usbdev_get_altsetting (usbdev, i, &desc_len);
	cmn_err (CE_CONT, "\nDumping altsetting %d (l=%d)\n", i, desc_len);
	if (usb_trace)
	  ossusb_dump_desc (desc, desc_len);
      }
#endif

  desc = udi_usbdev_get_altsetting (usbdev, actsetting, &desc_len);

  if (desc == NULL || desc_len < 1)
    for (i = 0; i < nsettings && (desc == NULL || desc_len < 1); i++)
      {
	UDB (cmn_err (CE_CONT, "Trying to read altsetting %d\n", i));
	desc = udi_usbdev_get_altsetting (usbdev, i, &desc_len);
	if (desc != NULL)
	  actsetting = i;
      }

  UDB (cmn_err (CE_CONT, "Altsetting %d, len %d\n", actsetting, desc_len));

  if (desc == NULL)
    {
      cmn_err (CE_WARN, "Can't read interface descriptors\n");
      return NULL;
    }

  if (usb_trace > 2)
    ossusb_dump_desc (desc, desc_len);

  p = 0;
  while (p < desc_len)
    {
      d = desc + p;
      l = *d;

      if (d[1] != CS_INTERFACE)
	{
	UDB (cmn_err (CE_CONT, "Unknown descriptor type %02x\n", d[1]))}
      else
	switch (d[2])
	  {
	  case AS_GENERAL:
	    portc->terminal_link = d[3];
	    break;
	  }

      p += l;
    }

  if (portc->terminal_link > 0 && portc->terminal_link <= devc->nunits)
    {
      char *s = dev_name + strlen (dev_name);

      sprintf (s, " %s", devc->units[portc->terminal_link].name);
      s += strlen (s);

      if (devc->units[portc->terminal_link].typ == TY_OUTPUT)	/* USB terminal type */
	{
	  opts |= ADEV_NOOUTPUT;
	}
      else
	{
	  opts |= ADEV_NOINPUT;
	}
    }

  if ((portc->audio_dev = oss_install_audiodev (OSS_AUDIO_DRIVER_VERSION,
						devc->osdev,
						devc->osdev,
						dev_name,
						&usbaudio_driver,
						sizeof (audiodrv_t),
						opts,
						AFMT_S16_NE, devc, -1)) < 0)
    {
      return devc;
    }

  portc->devc = devc;
  adev = audio_engines[portc->audio_dev];
  adev->portc = portc;
  adev->mixer_dev = devc->mixer_dev;
  adev->rate_source = devc->portc[0].audio_dev;
  adev->max_block = 256;
  adev->min_fragments = 4;	/* vmix needs this */

  prepare_altsetting (devc, portc, 1);

  if (portc->num_settings > 2)
    {
      char name[128];

      sprintf (name, "%s-altset", devc->units[portc->terminal_link].name);
      ossusb_create_altset_control (devc->mixer_dev, portc_num,
				    portc->num_settings, name);
    }

#if 0
  // TODO: This needs to be checked before vmix is enabled
#ifdef CONFIG_OSS_VMIX
  if (devc->units[portc->terminal_link].typ != TY_OUTPUT)
     vmix_attach_audiodev(devc->osdev, portc->audio_dev, -1, 0);
#endif
#endif
  return devc;
}

/*ARGSUSED*/
int
ossusb_change_altsetting (int dev, int ctrl, unsigned int cmd, int value)
{
  ossusb_devc *devc = mixer_devs[dev]->devc;
  ossusb_portc *portc;

  if (ctrl < 0 || ctrl >= devc->num_audio_engines)
    return OSS_ENXIO;

  portc = &devc->portc[ctrl];

  if (cmd == SNDCTL_MIX_READ)
    return portc->act_setting;

  if (value >= portc->num_settings)
    value = portc->num_settings - 1;

  if (portc->act_setting != value)
    {
      prepare_altsetting (devc, portc, value);
    }
  return value;
}