/*
 * Purpose: Client/server audio device pair for oss_userdev
 *
 * This file implements the actual client/server device pair. There will be
 * separate oss_userdev instance for each process that has opened the
 * client side.
 */
/*
 *
 * 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_userdev_cfg.h"
#include <oss_userdev_exports.h>
#include "userdev.h"
static void userdev_free_device_pair (userdev_devc_t *devc);

extern int userdev_visible_clientnodes;

static void
transfer_audio (userdev_portc_t * server_portc, dmap_t * dmap_from,
		dmap_t * dmap_to)
{
  int l = dmap_from->fragment_size;
  unsigned char *fromp, *top;

  if (dmap_to->fragment_size != l)
    {
      cmn_err (CE_WARN, "Fragment size mismatch (%d != %d)\n",
	       dmap_to->fragment_size, l);

      /* Perform emergency stop */
      server_portc->input_triggered = 0;
      server_portc->output_triggered = 0;
      server_portc->peer->input_triggered = 0;
      server_portc->peer->output_triggered = 0;
      return;
    }

  fromp =
    dmap_from->dmabuf + (dmap_from->byte_counter % dmap_from->bytes_in_use);
  top = dmap_to->dmabuf + (dmap_to->byte_counter % dmap_to->bytes_in_use);

  memcpy (top, fromp, l);

}

static void
handle_input (userdev_portc_t * server_portc)
{
  userdev_portc_t *client_portc = server_portc->peer;

  if (client_portc->output_triggered)
    {
      transfer_audio (server_portc,
		      audio_engines[client_portc->audio_dev]->dmap_out,
		      audio_engines[server_portc->audio_dev]->dmap_in);
      oss_audio_outputintr (client_portc->audio_dev, 0);
    }

  oss_audio_inputintr (server_portc->audio_dev, 0);
}

static void
handle_output (userdev_portc_t * server_portc)
{
  userdev_portc_t *client_portc = server_portc->peer;

  if (client_portc->input_triggered)
    {
      transfer_audio (server_portc,
		      audio_engines[server_portc->audio_dev]->dmap_out,
		      audio_engines[client_portc->audio_dev]->dmap_in);
      oss_audio_inputintr (client_portc->audio_dev, 0);
    }

  oss_audio_outputintr (server_portc->audio_dev, 0);
}

static void
userdev_cb (void *pc)
{
/*
 * This timer callback routine will get called 100 times/second. It handles
 * movement of audio data between the client and server sides.
 */
  userdev_portc_t *server_portc = pc;
  userdev_devc_t *devc = server_portc->devc;
  int tmout = devc->poll_ticks;

  if (tmout < 1)
    tmout = 1;

  devc->timeout_id = 0;	/* No longer valid */

  if (server_portc->input_triggered)
    handle_input (server_portc);

  if (server_portc->output_triggered)
    handle_output (server_portc);

  /* Retrigger timer callback */
  if (server_portc->input_triggered || server_portc->output_triggered)
    devc->timeout_id = timeout (userdev_cb, server_portc, tmout);
}

static int
userdev_check_input (int dev)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;
  if (!portc->peer->output_triggered)
    {
      return OSS_ECONNRESET;
    }
  return 0;
}

static int
userdev_check_output (int dev)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;

  if (!portc->peer->input_triggered)
    {
      return OSS_ECONNRESET;
    }

  if (portc->peer->open_mode == 0)
    return OSS_EIO;
  return 0;
}

static void
setup_sample_format (userdev_portc_t * portc)
{
  adev_t *adev;
  userdev_devc_t *devc = portc->devc;
  int fragsize, frame_size;

  frame_size = devc->channels * devc->fmt_bytes;
  if (frame_size == 0)
    frame_size = 4;

  fragsize = (devc->rate * frame_size * devc->poll_ticks) / OSS_HZ;	/* Number of bytes/fragment */
  devc->rate = fragsize * 100 / frame_size;

/* Setup the server side */
  adev = audio_engines[portc->audio_dev];
  adev->min_block = adev->max_block = fragsize;

/* Setup the client side */
  adev = audio_engines[portc->peer->audio_dev];
  adev->min_block = adev->max_block = fragsize;

  adev->max_rate = adev->min_rate = devc->rate;
  adev->iformat_mask = devc->fmt;
  adev->oformat_mask = devc->fmt;
  adev->xformat_mask = devc->fmt;
  adev->min_channels = adev->max_channels = devc->channels;
}

static int
userdev_server_set_rate (int dev, int arg)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;
  adev_t *client_adev = audio_engines[portc->peer->audio_dev];

  if (arg == 0)
    return devc->rate;

  if (portc->peer->input_triggered || portc->peer->output_triggered)
    return devc->rate;

  if (arg < 5000)
    arg = 5000;
  if (arg > MAX_RATE)
    arg = MAX_RATE;

  /* Force the sample rate to be multiple of 100 */
  arg = (arg / 100) * 100;

  devc->rate = arg;

  client_adev->min_rate = arg;
  client_adev->max_rate = arg;

  setup_sample_format (portc);

  return devc->rate = arg;
}

/*ARGSUSED*/
static int
userdev_client_set_rate (int dev, int arg)
{
  userdev_devc_t *devc = audio_engines[dev]->devc;

  return devc->rate;
}

static short
userdev_server_set_channels (int dev, short arg)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;
  adev_t *client_adev = audio_engines[portc->peer->audio_dev];

  if (arg == 0)
    return devc->channels;

  if (portc->peer->input_triggered || portc->peer->output_triggered)
    return devc->channels;

  if (arg < 1)
    arg = 1;
  if (arg > MAX_CHANNELS)
    arg = MAX_CHANNELS;

  devc->channels = arg;
  client_adev->min_channels=client_adev->max_channels=arg;

  setup_sample_format (portc);

  return devc->channels;
}

/*ARGSUSED*/
static short
userdev_client_set_channels (int dev, short arg)
{
  userdev_devc_t *devc = audio_engines[dev]->devc;

  return devc->channels;	/* Server side channels */
}

static unsigned int
userdev_server_set_format (int dev, unsigned int arg)
{
  userdev_devc_t *devc = audio_engines[dev]->devc;
  userdev_portc_t *portc = audio_engines[dev]->portc;
  adev_t *client_adev = audio_engines[portc->peer->audio_dev];

  if (arg == 0)
    return devc->fmt;

  if (portc->peer->input_triggered || portc->peer->output_triggered)
    return devc->fmt;

  switch (arg)
    {
    case AFMT_S16_NE:
      devc->fmt_bytes = 2;
      break;

    case AFMT_S32_NE:
      devc->fmt_bytes = 4;
      break;

    default:			/* Unsupported format */
      arg = AFMT_S16_NE;
      devc->fmt_bytes = 2;

    }

  devc->fmt = arg;

  client_adev->oformat_mask = arg;
  client_adev->iformat_mask = arg;

  setup_sample_format (portc);

  return devc->fmt;
}

/*ARGSUSED*/
static unsigned int
userdev_client_set_format (int dev, unsigned int arg)
{
  userdev_devc_t *devc = audio_engines[dev]->devc;

  return devc->fmt;	/* Server side sample format */
}

static void userdev_trigger (int dev, int state);

static void
userdev_reset (int dev)
{
  userdev_trigger (dev, 0);
}

/*ARGSUSED*/
static int
userdev_server_open (int dev, int mode, int open_flags)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;
  oss_native_word flags;

  if (portc == NULL || portc->peer == NULL)
    return OSS_ENXIO;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);

  if (portc->open_mode)
    {
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
      return OSS_EBUSY;
    }

  portc->open_mode = mode;

  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);

  devc->open_count++;

  return 0;
}

/*ARGSUSED*/
static int
userdev_client_open (int dev, int mode, int open_flags)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;
  oss_native_word flags;

  if (portc == NULL || portc->peer == NULL)
    return OSS_ENXIO;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);

  if (portc->open_mode)
    {
      MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
      return OSS_EBUSY;
    }

  portc->open_mode = mode;
  devc->open_count++;

  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
  return 0;
}

static void
wipe_audio_buffers(userdev_devc_t *devc)
{
/*
 * Write silence to the audio buffers when only one of the sides
 * is open. This prevents the device from looping the last fragments
 * written to the device.
 */
	dmap_t *dmap;

	dmap = audio_engines[devc->client_portc.audio_dev]->dmap_out;
	if (dmap != NULL && dmap->dmabuf != NULL)
	   memset(dmap->dmabuf, 0, dmap->buffsize);

	dmap = audio_engines[devc->client_portc.audio_dev]->dmap_in;
	if (dmap != NULL && dmap->dmabuf != NULL)
	   memset(dmap->dmabuf, 0, dmap->buffsize);

	dmap = audio_engines[devc->server_portc.audio_dev]->dmap_out;
	if (dmap != NULL && dmap->dmabuf != NULL)
	   memset(dmap->dmabuf, 0, dmap->buffsize);

	dmap = audio_engines[devc->server_portc.audio_dev]->dmap_in;
	if (dmap != NULL && dmap->dmabuf != NULL)
	   memset(dmap->dmabuf, 0, dmap->buffsize);
}

/*ARGSUSED*/
static void
userdev_server_close (int dev, int mode)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;
  oss_native_word flags;
  int open_count;

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

  /* Stop the client side because there is no server */
  portc->peer->input_triggered = 0;
  portc->peer->output_triggered = 0;
  open_count = --devc->open_count;

  if (open_count == 0)
     userdev_free_device_pair (devc);
  else
     wipe_audio_buffers(devc);
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
}

/*ARGSUSED*/
static void
userdev_client_close (int dev, int mode)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;
  oss_native_word flags;
  int open_count;

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

  open_count = --devc->open_count;

  if (open_count == 0)
     userdev_free_device_pair (devc);
  else
     wipe_audio_buffers(devc);

  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
}

/*ARGSUSED*/
static int
userdev_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
{
  switch (cmd)
    {
    case SNDCTL_GETLABEL:
      {
	/*
	 * Return an empty string so that this feature can be tested.
	 * Complete functionality is to be implemented later.
	 */
	oss_label_t *s = (oss_label_t *) arg;
	memset (s, 0, sizeof (oss_label_t));
	return 0;
      }
      break;

    case SNDCTL_GETSONG:
      {
	/*
	 * Return an empty string so that this feature can be tested.
	 * Complete functionality is to be implemented later.
	 */
	oss_longname_t *s = (oss_longname_t *) arg;
	memset (s, 0, sizeof (oss_longname_t));
	return 0;
      }
      break;
    }

  return OSS_EINVAL;
}

static void
set_adev_name(int dev, const char *name)
{
  adev_t *adev = audio_engines[dev];

  strcpy(adev->name, name);

#ifdef CONFIG_OSS_VMIX
  if (adev->vmix_mixer != NULL)
     vmix_change_devnames(adev->vmix_mixer, name);
#endif
	
}

static int
create_instance(int dev, userdev_create_t *crea)
{
  userdev_devc_t *devc = audio_engines[dev]->devc;
  char tmp_name[64];

  devc->match_method = crea->match_method;
  devc->match_key = crea->match_key;
  devc->create_flags = crea->flags;

  devc->poll_ticks = (crea->poll_interval * OSS_HZ) / 1000;

  if (devc->poll_ticks < 1) 
     devc->poll_ticks = 1;

  crea->poll_interval = (1000*devc->poll_ticks) / OSS_HZ;

  if (crea->poll_interval<1)
     crea->poll_interval = 1;

  crea->name[sizeof(crea->name)-1]=0; /* Overflow protectgion */

  sprintf(tmp_name, "%s (server)", crea->name);
  tmp_name[49]=0;
  set_adev_name (devc->client_portc.audio_dev, crea->name);
  set_adev_name (devc->server_portc.audio_dev, tmp_name);

  strcpy(crea->devnode, audio_engines[devc->client_portc.audio_dev]->devnode);

  return 0;
}

static int
userdev_set_control (int dev, int ctl, unsigned int cmd, int value)
{
  	userdev_devc_t *devc = mixer_devs[dev]->devc;

	if (ctl < 0 || ctl >= USERDEV_MAX_MIXERS)
	   return OSS_EINVAL;

	if (cmd == SNDCTL_MIX_READ)
	   {
		   return devc->mixer_values[ctl];
	   }

	devc->mixer_values[ctl] = value;
	devc->modify_counter++;

	return 0;
}

/*ARGSUSED*/
static int
userdev_server_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
{
  switch (cmd)
    {
    case USERDEV_CREATE_INSTANCE:
	    {
		userdev_create_t *crea = (userdev_create_t *)arg;

	    	return create_instance(dev, crea);
	    }
	    break;

    case USERDEV_GET_CLIENTCOUNT:
	    {
  		userdev_devc_t *devc = audio_engines[dev]->devc;

		return *arg = (devc->client_portc.open_mode != 0);
	    }
	    break;

   /*
    * Mixer related ioctl calls
    */

    case USERDEV_CREATE_MIXGROUP:
	    {
  		userdev_devc_t *devc = audio_engines[dev]->devc;
		userdev_mixgroup_t *grp=(userdev_mixgroup_t*)arg;
		int group;

		grp->name[sizeof(grp->name)-1]=0; /* Buffer overflow protection */
		if ((group=mixer_ext_create_group(devc->mixer_dev, grp->parent, grp->name))<0)
			return group;
		grp->num = group;
		return 0;
	    }
	    break;

    case USERDEV_CREATE_MIXCTL:
	    {
  		userdev_devc_t *devc = audio_engines[dev]->devc;
		userdev_mixctl_t *c=(userdev_mixctl_t*)arg;
  		oss_mixext *ext;
		int ctl;

		c->name[sizeof(c->name)-1]=0; /* Buffer overflow protection */

		if (c->index < 0 || c->index >= USERDEV_MAX_MIXERS)
		   return OSS_EINVAL;

		if ((ctl = mixer_ext_create_control (devc->mixer_dev,
			       c->parent,
			       c->index,
			       userdev_set_control,
			       c->type,
			       c->name,
			       c->maxvalue,
			       c->flags)) < 0)
	    		return ctl;

		c->num = ctl;
  		ext = mixer_find_ext (devc->mixer_dev, ctl);

		ext->minvalue = c->offset;
		ext->control_no= c->control_no;
		ext->rgbcolor = c->rgbcolor;

		if (c->type == MIXT_ENUM)
		{
			memcpy(ext->enum_present, c->enum_present, sizeof(ext->enum_present));
  			mixer_ext_set_strings (devc->mixer_dev, ctl, c->enum_choises, 0);
		}

		return 0;
	    }
	    break;

    case USERDEV_GET_MIX_CHANGECOUNT:
	    {
  		userdev_devc_t *devc = audio_engines[dev]->devc;

		return *arg = devc->modify_counter;
	    }
	    break;

    case USERDEV_SET_MIXERS:
	    {
  		userdev_devc_t *devc = audio_engines[dev]->devc;

		memcpy(devc->mixer_values, arg, sizeof(devc->mixer_values));
		mixer_devs[devc->mixer_dev]->modify_counter++;
//cmn_err(CE_CONT, "Set %08x %08x\n", devc->mixer_values[0], devc->mixer_values[1]);
		return 0;
	    }
	    break;

    case USERDEV_GET_MIXERS:
	    {
  		userdev_devc_t *devc = audio_engines[dev]->devc;

		memcpy(arg, devc->mixer_values, sizeof(devc->mixer_values));
		return 0;
	    }
	    break;

    }

  return userdev_ioctl(dev, cmd, arg);
}

/*ARGSUSED*/
static void
userdev_output_block (int dev, oss_native_word buf, int count, int fragsize,
			int intrflag)
{
}

/*ARGSUSED*/
static void
userdev_start_input (int dev, oss_native_word buf, int count, int fragsize,
		       int intrflag)
{
}

static void
userdev_trigger (int dev, int state)
{
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;

  if (portc->open_mode & OPEN_READ)	/* Handle input */
    {
      portc->input_triggered = !!(state & OPEN_READ);
    }

  if (portc->open_mode & OPEN_WRITE)	/* Handle output */
    {
      portc->output_triggered = !!(state & OPEN_WRITE);
    }

  if (portc->output_triggered || portc->input_triggered)	/* Something is going on */
    {
      int tmout = devc->poll_ticks;

      if (tmout < 1)
	tmout = 1;

      if (portc->port_type != PT_SERVER)
	portc = portc->peer;	/* Switch to the server side */

      if (portc->output_triggered || portc->input_triggered)	/* Something is going on */
	if (devc->timeout_id == 0)
	{
	  devc->timeout_id = timeout (userdev_cb, portc, tmout);
	}
    }
  else
    {
      if (portc->port_type == PT_SERVER)
	if (devc->timeout_id != 0)
	  {
	    untimeout (devc->timeout_id);
	    devc->timeout_id = 0;
	  }
    }
}

/*ARGSUSED*/
static int
userdev_server_prepare_for_input (int dev, int bsize, int bcount)
{
  oss_native_word flags;

  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
  portc->input_triggered = 0;
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);

  return 0;
}

/*ARGSUSED*/
static int
userdev_server_prepare_for_output (int dev, int bsize, int bcount)
{
  oss_native_word flags;

  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
  portc->output_triggered = 0;
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);

  return 0;
}

/*ARGSUSED*/
static int
userdev_client_prepare_for_input (int dev, int bsize, int bcount)
{
  oss_native_word flags;
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
  portc->input_triggered = 0;
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);

  return 0;
}

/*ARGSUSED*/
static int
userdev_client_prepare_for_output (int dev, int bsize, int bcount)
{
  oss_native_word flags;
  userdev_portc_t *portc = audio_engines[dev]->portc;
  userdev_devc_t *devc = audio_engines[dev]->devc;

  MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
  portc->output_triggered = 0;
  MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);

  return 0;
}

/*ARGSUSED*/
static int
userdev_alloc_buffer (int dev, dmap_t * dmap, int direction)
{
#define MY_BUFFSIZE (64*1024)
  if (dmap->dmabuf != NULL)
    return 0;
  dmap->dmabuf_phys = 0;	/* Not mmap() capable */
  dmap->dmabuf = KERNEL_MALLOC (MY_BUFFSIZE);
  if (dmap->dmabuf == NULL)
    return OSS_ENOSPC;
  dmap->buffsize = MY_BUFFSIZE;

  return 0;
}

/*ARGSUSED*/
static int
userdev_free_buffer (int dev, dmap_t * dmap, int direction)
{
  if (dmap->dmabuf == NULL)
    return 0;
  KERNEL_FREE (dmap->dmabuf);

  dmap->dmabuf = NULL;
  return 0;
}

#if 0
static int
userdev_get_buffer_pointer (int dev, dmap_t * dmap, int direction)
{
}
#endif

/*ARGSUSED*/
static int
userdev_ioctl_override (int dev, unsigned int cmd, ioctl_arg arg)
{
/*
 * Purpose of this ioctl override function is to intercept mixer
 * ioctl calls made on the client side and to hide everything
 * outside the userdev instance from the application.
 *
 * Note that this ioctl is related with the client side audio device. However
 * if /dev/mixer points to this (audio) device then all mixer acess will
 * be redirected too. Also the vmix driver will redirect mixer/system ioctl
 * calls to this function.
 */
  int err;
  userdev_devc_t *devc = audio_engines[dev]->devc;
  adev_t *adev = audio_engines[devc->client_portc.audio_dev];

  switch (cmd)
  {
  case SNDCTL_MIX_NRMIX:
	  return *arg=1;
	  break;

  case SNDCTL_MIX_NREXT:
	  *arg = devc->mixer_dev;
	  return OSS_EAGAIN; /* Continue with the default handler */
	  break;

  case SNDCTL_SYSINFO:
	  {
	  /*
	   * Fake SNDCTL_SYSINFO to report just one mixer device which is
	   * the one associated with the client.
	   */
	    oss_sysinfo *info = (oss_sysinfo *) arg;
	    int i;

	    if ((err=oss_mixer_ext(dev, OSS_DEV_DSP_ENGINE, cmd, arg))<0)
	       return err;

	    /*
	     * Hide all non-oss_userdev devices
	     */
	    strcpy (info->product, "OSS (userdev)");
	    info->nummixers = 1;
	    info->numcards = 1;
	    info->numaudios = 1;
	    for (i = 0; i < 8; i++)
	       info->openedaudio[i] = 0;

	    return 0;
	  }
	  break;

  case SNDCTL_MIXERINFO:
	{
		oss_mixerinfo *info = (oss_mixerinfo *) arg;

		info->dev = devc->mixer_dev; /* Redirect to oss_userdev mixer */

	    	if ((err=oss_mixer_ext(dev, OSS_DEV_DSP_ENGINE, cmd, arg))<0)
	           return err;

		strcpy(info->name, adev->name);
		info->card_number = 0;
		return 0;
	}

  case SNDCTL_AUDIOINFO:
  case SNDCTL_AUDIOINFO_EX:
	{
		oss_audioinfo *info = (oss_audioinfo *) arg;

		info->dev = devc->client_portc.audio_dev;

		cmd = SNDCTL_ENGINEINFO;

	    	if ((err=oss_mixer_ext(dev, OSS_DEV_DSP_ENGINE, cmd, arg))<0)
	           return err;

		info->card_number = 0;
		return 0;
	}

    case SNDCTL_CARDINFO:
      {
	oss_card_info *info = (oss_card_info *) arg;

	info->card = adev->card_number; /* Redirect to oss_userdev0 */

    	if ((err=oss_mixer_ext(dev, OSS_DEV_DSP_ENGINE, cmd, arg))<0)
           return err;

	info->card = 0;
	return 0;
      }

  case SNDCTL_MIX_EXTINFO:
      {
	      oss_mixext *ext = (oss_mixext*)arg;

	      ext->dev = devc->mixer_dev;

	      if ((err=oss_mixer_ext(dev, OSS_DEV_DSP_ENGINE, cmd, arg))<0)
	           return err;

	      if (ext->type == MIXT_DEVROOT)
	      {
		oss_mixext_root *root = (oss_mixext_root *) ext->data;
		strncpy(root->name, adev->name, 48);
		root->name[47]=0;
	      }

	      return 0;
      }
      break;

  case SNDCTL_MIX_READ:
  case SNDCTL_MIX_WRITE:
      {
	      oss_mixer_value *ent = (oss_mixer_value*)arg;

	      ent->dev = devc->mixer_dev;

	      return OSS_EAGAIN; 	/* Redirect */
      }
      break;

  default:
	  return OSS_EAGAIN;
  }
}

static audiodrv_t userdev_server_driver = {
  userdev_server_open,
  userdev_server_close,
  userdev_output_block,
  userdev_start_input,
  userdev_server_ioctl,
  userdev_server_prepare_for_input,
  userdev_server_prepare_for_output,
  userdev_reset,
  NULL,
  NULL,
  NULL,
  NULL,
  userdev_trigger,
  userdev_server_set_rate,
  userdev_server_set_format,
  userdev_server_set_channels,
  NULL,
  NULL,
  userdev_check_input,
  userdev_check_output,
  userdev_alloc_buffer,
  userdev_free_buffer,
  NULL,
  NULL,
  NULL				/* userdev_get_buffer_pointer */
};

static audiodrv_t userdev_client_driver = {
  userdev_client_open,
  userdev_client_close,
  userdev_output_block,
  userdev_start_input,
  userdev_ioctl,
  userdev_client_prepare_for_input,
  userdev_client_prepare_for_output,
  userdev_reset,
  NULL,
  NULL,
  NULL,
  NULL,
  userdev_trigger,
  userdev_client_set_rate,
  userdev_client_set_format,
  userdev_client_set_channels,
  NULL,
  NULL,
  userdev_check_input,
  userdev_check_output,
  userdev_alloc_buffer,
  userdev_free_buffer,
  NULL,
  NULL,
  NULL,	// userdev_get_buffer_pointer
  NULL,	// userdev_calibrate_speed
  NULL,	// userdev_sync_control
  NULL,	// userdev_prepare_to_stop
  NULL,	// userdev_get_input_pointer
  NULL,	// userdev_get_output_pointer
  NULL,	// userdev_bind
  NULL,	// userdev_setup_fragments
  NULL,	// userdev_redirect
  userdev_ioctl_override
};

static int
userdev_mixer_ioctl (int dev, int audiodev, unsigned int cmd, ioctl_arg arg)
{

  if (cmd == SOUND_MIXER_READ_CAPS)
    return *arg = SOUND_CAP_NOLEGACY;

#if 0
  if (cmd == SOUND_MIXER_READ_DEVMASK ||
      cmd == SOUND_MIXER_READ_RECMASK || cmd == SOUND_MIXER_READ_RECSRC)
    return *arg = 0;

  if (cmd == SOUND_MIXER_READ_VOLUME || cmd == SOUND_MIXER_READ_PCM)
    return *arg = 100 | (100 << 8);
  if (cmd == SOUND_MIXER_WRITE_VOLUME || cmd == SOUND_MIXER_WRITE_PCM)
    return *arg = 100 | (100 << 8);
#endif
  return OSS_EINVAL;
}

static mixer_driver_t userdev_mixer_driver = {
  userdev_mixer_ioctl
};

static int
install_server (userdev_devc_t * devc)
{
  userdev_portc_t *portc = &devc->server_portc;
  int adev;

  int opts =
    ADEV_STEREOONLY | ADEV_16BITONLY | ADEV_VIRTUAL |
    ADEV_FIXEDRATE | ADEV_SPECIAL | ADEV_HIDDEN | ADEV_DUPLEX;

  memset (portc, 0, sizeof (*portc));

  portc->devc = devc;
  portc->port_type = PT_SERVER;

  if ((adev = oss_install_audiodev (OSS_AUDIO_DRIVER_VERSION,
				    devc->osdev,
				    devc->osdev,
				    "User space audio device server side",
				    &userdev_server_driver,
				    sizeof (audiodrv_t),
				    opts, SUPPORTED_FORMATS, devc, -1)) < 0)
    {
      return adev;
    }

  audio_engines[adev]->portc = portc;
  audio_engines[adev]->min_rate = 5000;
  audio_engines[adev]->max_rate = MAX_RATE;
  audio_engines[adev]->min_channels = 1;
  audio_engines[adev]->max_channels = MAX_CHANNELS;
  audio_engines[adev]->vmix_mixer=NULL;
  strcpy(audio_engines[adev]->devnode, userdev_server_devnode);

  portc->audio_dev = adev;

  return adev;
}

static int 
null_mixer_init(int de)
{
	return 0;
}

static void
userdev_create_mixer(userdev_devc_t * devc)
{
  if ((devc->mixer_dev = oss_install_mixer (OSS_MIXER_DRIVER_VERSION,
				     devc->osdev,
				     devc->osdev,
				     "OSS userdev mixer",
				     &userdev_mixer_driver,
				     sizeof (mixer_driver_t), devc)) < 0)
    {
	devc->mixer_dev = -1;
	return;
    }
  mixer_ext_set_init_fn (devc->mixer_dev, null_mixer_init, USERDEV_MAX_MIXERS*2);
}

static int
install_client (userdev_devc_t * devc)
{
  userdev_portc_t *portc = &devc->client_portc;
  int adev;

  int opts =
    ADEV_STEREOONLY | ADEV_16BITONLY | ADEV_VIRTUAL | ADEV_DUPLEX |
    ADEV_FIXEDRATE | ADEV_SPECIAL | ADEV_LOOP;

  memset (portc, 0, sizeof (*portc));

  userdev_create_mixer(devc);

  portc->devc = devc;
  portc->port_type = PT_CLIENT;

  if (!userdev_visible_clientnodes && !(devc->create_flags & USERDEV_F_VMIX_PRIVATENODE))
  {
     opts |= ADEV_HIDDEN;
  }

  if ((adev = oss_install_audiodev (OSS_AUDIO_DRIVER_VERSION,
				    devc->osdev,
				    devc->osdev,
				    "User space audio device",
				    &userdev_client_driver,
				    sizeof (audiodrv_t),
				    opts, SUPPORTED_FORMATS, devc, -1)) < 0)
    {
      return adev;
    }

  if (!userdev_visible_clientnodes) /* Invisible client device nodes */
     strcpy(audio_engines[adev]->devnode, userdev_client_devnode);

  audio_engines[adev]->portc = portc;
  audio_engines[adev]->mixer_dev = devc->mixer_dev;
  audio_engines[adev]->min_rate = 5000;
  audio_engines[adev]->max_rate = MAX_RATE;
  audio_engines[adev]->min_channels = 1;
  audio_engines[adev]->max_channels = MAX_CHANNELS;

  portc->audio_dev = adev;
#ifdef CONFIG_OSS_VMIX
  vmix_attach_audiodev(devc->osdev, adev, -1, 0);
#endif

  return adev;
}

int
userdev_create_device_pair(void)
{
  int client_engine, server_engine;
  userdev_devc_t *devc;
  oss_native_word flags;

  if ((devc=PMALLOC(userdev_osdev, sizeof (*devc))) == NULL)
     return OSS_ENOMEM;
  memset(devc, 0, sizeof(*devc));

  devc->osdev = userdev_osdev;
  MUTEX_INIT (devc->osdev, devc->mutex, MH_DRV);
  devc->active=1;

  devc->rate = 48000;
  devc->fmt = AFMT_S16_NE;
  devc->fmt_bytes = 2;
  devc->channels = 2;
  devc->poll_ticks = 10;

  if ((server_engine=install_server (devc)) < 0)
     return server_engine;

  if ((client_engine=install_client (devc)) < 0)
	return client_engine;

  devc->client_portc.peer = &devc->server_portc;
  devc->server_portc.peer = &devc->client_portc;

  /*
   * Insert the device to the list of available devices
   */
  MUTEX_ENTER_IRQDISABLE(userdev_global_mutex, flags);
  devc->next_instance = userdev_active_device_list;
  userdev_active_device_list = devc;
  MUTEX_EXIT_IRQRESTORE(userdev_global_mutex, flags);

  return server_engine;
}

static void
userdev_free_device_pair (userdev_devc_t *devc)
{
  oss_native_word flags;

  set_adev_name(devc->client_portc.audio_dev, "User space audio device");
  set_adev_name(devc->server_portc.audio_dev, "User space audio device server side");

  MUTEX_ENTER_IRQDISABLE(userdev_global_mutex, flags);

  devc->match_method = 0;
  devc->match_key = 0;

  /*
   * Add to the free device pair list.
   */
  devc->next_instance = userdev_free_device_list;
  userdev_free_device_list = devc;

  /*
   * Remove the device pair from the active device list.
   */

  if (userdev_active_device_list == devc) /* First device in the list */
     {
	     userdev_active_device_list = userdev_active_device_list->next_instance;
     }
  else
     {
	     userdev_devc_t *this = userdev_active_device_list, *prev = NULL;

	     while (this != NULL)
	     {
		     if (this == devc)
			{
				prev->next_instance = this->next_instance; /* Remove */
				break;
			}

		     prev = this;
		     this = this->next_instance;
	     }
     }
  MUTEX_EXIT_IRQRESTORE(userdev_global_mutex, flags);
}

void
userdev_reinit_instance(userdev_devc_t *devc)
{
	if (devc->mixer_dev < 0)
	   return;

  mixer_ext_rebuild_all (devc->mixer_dev, null_mixer_init, USERDEV_MAX_MIXERS*2);
}

void
userdev_delete_device_pair(userdev_devc_t *devc)
{
  if (!devc->active)
     return;

  devc->active = 0;
  MUTEX_CLEANUP(devc->mutex);
}

int
usrdev_find_free_device_pair(void)
{
  oss_native_word flags;
  userdev_devc_t *devc;

  MUTEX_ENTER_IRQDISABLE(userdev_global_mutex, flags);

  if (userdev_free_device_list != NULL)
     {
	devc = userdev_free_device_list;
	userdev_free_device_list = userdev_free_device_list->next_instance;

  	devc->next_instance = userdev_active_device_list;
  	userdev_active_device_list = devc;

  	MUTEX_EXIT_IRQRESTORE(userdev_global_mutex, flags);
	return devc->server_portc.audio_dev;
     }
  MUTEX_EXIT_IRQRESTORE(userdev_global_mutex, flags);

  return OSS_ENXIO;
}