/*
 * oss_vxworks.c: Common entry points for OSS under VxWorks.
 */

#include <oss_config.h>
#include <oss_pci.h>
#include <drv/pci/pciConfigLib.h>
#include <memLib.h>

#if 0
// TODO: Obsolete
typedef struct oss_device_handle
{
  DEV_HDR devHdr;
  int minor;
  int valid;			/* 1=valid, 0=undefined */
  struct fileinfo finfo;
}
oss_device_handle;
#endif
/*
 * Number of cards supported in the same system.
 */
#define MAX_CARDS 8

static oss_device_t *cards[MAX_CARDS];
int oss_num_cards = 0;

static int oss_driver_num = ERROR;
static int oss_expired = 0;
static oss_device_t *core_osdev = NULL;

int oss_hz = 100;

void
oss_cmn_err (int level, const char *s, ...)
{
  char tmp[1024], *a[6];
  va_list ap;
  int i, n = 0;

  va_start (ap, s);

  for (i = 0; i < strlen (s); i++)
    if (s[i] == '%')
      n++;

  for (i = 0; i < n && i < 6; i++)
    a[i] = ( (sizeof(char *) == 32) ? ( *((char * **)(ap += ((sizeof(char * *)+sizeof(int)-1) & ~(sizeof(int)-1))))[-1] ) : ( ((char * *)(ap += ((sizeof(char *)+sizeof(int)-1) & ~(sizeof(int)-1))))[-1] ));
    //a[i] = va_arg (ap, char *); // This was supposed to be used instead of above. Unfortunately va_arg() seems to be buggy

  for (i = n; i < 6; i++)
    a[i] = NULL;

  if (level == CE_CONT)
    {
      sprintf (tmp, s, a[0], a[1], a[2], a[3], a[4], a[5], NULL,
	       NULL, NULL, NULL);
      printf ("%s", tmp);
    }
  else
    {
      strcpy (tmp, "osscore: ");
      sprintf (tmp + strlen (tmp), s, a[0], a[1], a[2], a[3], a[4], a[5],
	       NULL, NULL, NULL, NULL);

      printf ("%s", tmp);
    }

  va_end (ap);
}

int
oss_uiomove (void *addr, size_t nbytes, enum uio_rw rwflag, uio_t * uio)
{
/*
 * NOTE! Returns 0 upon success and EFAULT on failure (instead of -EFAULT
 * (for Solaris/BSD compatibility)).
 */

  if (rwflag != uio->rw)
    {
      oss_cmn_err (CE_WARN, "uiomove: Bad direction\n");
      return EFAULT;
    }

  if (uio->resid < nbytes)
    {
      oss_cmn_err (CE_WARN, "uiomove: Bad count %d (%d)\n", nbytes,
		   uio->resid);
      return EFAULT;
    }

  if (uio->kernel_space)
    return EFAULT;

  switch (rwflag)
    {
    case UIO_READ:
      memcpy(uio->ptr, addr, nbytes);
      break;

    case UIO_WRITE:
      memcpy(addr, uio->ptr, nbytes);
      break;
    }

  uio->resid -= nbytes;
  uio->ptr += nbytes;

  return 0;
}

int
oss_create_uio (uio_t * uio, char *buf, size_t count, uio_rw_t rw,
		int is_kernel)
{
  memset (uio, 0, sizeof (*uio));

  if (is_kernel)
    {
      oss_cmn_err (CE_CONT,
		   "oss_create_uio: Kernel space buffers not supported\n");
      return -EIO;
    }

  uio->ptr = buf;
  uio->resid = count;
  uio->kernel_space = is_kernel;
  uio->rw = rw;

  return 0;
}

static int
grow_array(oss_device_t *osdev, oss_cdev_t ***arr, int *size, int increment)
{
	oss_cdev_t **old=*arr, **new = *arr;
	int old_size = *size;
	int new_size = *size;
		
	new_size += increment;

	if ((new=PMALLOC(osdev, new_size * sizeof (oss_cdev_t *)))==NULL)
	   return 0;

	memset(new, 0, new_size * sizeof(oss_cdev_t *));
	if (old != NULL)
	   memcpy(new, old, old_size * sizeof(oss_cdev_t *));

	*size = new_size;
	*arr = new;

	if (old != NULL)
	   PMFREE(osdev, old);

	return 1;
}

static void
register_chrdev(oss_cdev_t *cdev, char *name)
{
    if (iosDevAdd ((void *)cdev, name, oss_driver_num) == ERROR)
      {
	cmn_err (CE_WARN, "Failed to add device %s\n", name);
      }
}

void
oss_install_chrdev (oss_device_t * osdev, char *name, int dev_class,
		    int instance, oss_cdev_drv_t * drv, int flags)
{
/*
 * oss_install_chrdev creates a character device (minor). However if
 * name==NULL the device will not be exported (made visible to userland
 * clients).
 */

  int num;
  oss_cdev_t *cdev = NULL;

  if (dev_class != OSS_DEV_STATUS)
    if (oss_expired && instance > 0)
      return;

      if (oss_num_cdevs >= OSS_MAX_CDEVS)
	{
	   if (!grow_array(osdev, &oss_cdevs, &oss_max_cdevs, 100))
	   {
	  	cmn_err (CE_WARN, "Out of minor numbers.\n");
	  	return;
	   }
	}

      if ((cdev = PMALLOC (NULL, sizeof (*cdev))) == NULL)
	{
	  cmn_err (CE_WARN, "Cannot allocate character device desc.\n");
	  return;
	}

      num = oss_num_cdevs++;

  memset (cdev, 0, sizeof (*cdev));
  cdev->dev_class = dev_class;
  cdev->instance = instance;
  cdev->d = drv;
  cdev->osdev = osdev;
  if (name != NULL)
    strncpy (cdev->name, name, sizeof (cdev->name));
  else
    strcpy (cdev->name, "NONE");
  cdev->name[sizeof (cdev->name) - 1] = 0;
  oss_cdevs[num] = cdev;

/*
 * Export the device only if name != NULL
 */
  if (name != NULL)
    {
      strcpy (cdev->name, name);
      register_chrdev (cdev, name);
    }
}

int
oss_find_minor (int dev_class, int instance)
{
  int i;

  for (i = 0; i < oss_num_cdevs; i++)
    {
      if (oss_cdevs[i]->d != NULL && oss_cdevs[i]->dev_class == dev_class
	  && oss_cdevs[i]->instance == instance)
	return i;
    }

  return OSS_ENXIO;
}

static inline int
cpy_file (int mode, struct fileinfo *fi)
{
  fi->mode = 0;
  fi->acc_flags = mode;

  if ((fi->acc_flags & O_ACCMODE) == O_RDWR)
    fi->mode = OPEN_READWRITE;
  if ((fi->acc_flags & O_ACCMODE) == O_RDONLY)
    fi->mode = OPEN_READ;
  if ((fi->acc_flags & O_ACCMODE) == O_WRONLY)
    fi->mode = OPEN_WRITE;

  return fi->mode;
}

static void *
ossOpen (oss_cdev_t *cdev, char *reminder, int mode)
{
  int tmpdev, retval;
  struct fileinfo fi;

  cpy_file (mode, &fi);

  DDB (cmn_err
       (CE_CONT, "ossOpen(%p): %s, class=%d, instance=%d\n", cdev,
	cdev->name, cdev->dev_class, cdev->instance));

  if (cdev->d->open == NULL)
    {
      errnoSet(ENODEV);
      return (void*)ERROR;
    }

  tmpdev = -1;
  retval =
    cdev->d->open (cdev->instance, cdev->dev_class, &fi, 0, 0, &tmpdev);

  if (retval < 0)
    {
      errnoSet(-retval);
      return (void*)ERROR;
    }

  if (tmpdev != -1)
  {
     if (tmpdev >= 0 && tmpdev < oss_num_cdevs)
        {
	     cdev = oss_cdevs[tmpdev];
        }
     else
        {
      		errnoSet(ENODEV);
      		return (void*)ERROR;
	}
  }

  errnoSet (0);
  memcpy(&cdev->file, &fi, sizeof(struct fileinfo));

  return cdev;
}

static int
ossClose (oss_cdev_t *cdev)
{
  if (cdev->d->close == NULL)
    {
      return OK;
    }

  cdev->d->close (cdev->instance, &cdev->file);

  return OK;
}

static int
ossRead (oss_cdev_t *cdev, char *buf, int count)
{
  int err, len;
  uio_t uio;

  if (cdev->d->read == NULL)
    {
      errnoSet (ENXIO);
      return ERROR;
    }

  if ((err = oss_create_uio (&uio, buf, count, UIO_READ, 0)) < 0)
    {
      errnoSet (-err);
      return ERROR;
    }

  len = cdev->d->read (cdev->instance, &cdev->file, &uio, count);

  if (len >= 0)
     return len;

  errnoSet (-len);
  return ERROR;
}

static int
ossWrite (oss_cdev_t *cdev, char *buf, int count)
{
  int err, len;
  uio_t uio;

  if (cdev->d->write == NULL)
    {
      errnoSet (ENXIO);
      return ERROR;
    }

  if ((err = oss_create_uio (&uio, buf, count, UIO_WRITE, 0)) < 0)
    {
      errnoSet (-err);
      return ERROR;
    }

  len = cdev->d->write (cdev->instance, &cdev->file, &uio, count);

  if (len >= 0)
     return len;

  errnoSet (-len);
  return ERROR;
}

static int
ossIoctl (oss_cdev_t *cdev, int cmd, int *arg)
{
  int err;

  if (cdev->d->ioctl == NULL)
  {
      errnoSet (ENXIO);
      return ERROR;
  }

  if ((err = cdev->d->ioctl (cdev->instance, &cdev->file, cmd, (ioctl_arg) arg)) < 0)
    {
      errnoSet (-err);
      return ERROR;
    }
  return OK;
}

oss_device_t *
osdev_create (dev_info_t * dip, int dev_type,
	      int instance, const char *nick, const char *handle)
{
  oss_device_t *osdev;

  osdev = PMALLOC (NULL, sizeof (*osdev));
  if (osdev == NULL)
    {
      cmn_err (CE_WARN, "osdev_create: Out of memory\n");
      return NULL;
    }

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

  sprintf (osdev->nick, "%s%d", nick, instance);
  osdev->instance = instance;
  osdev->dip = dip;
  osdev->available = 1;
  osdev->first_mixer = -1;

  strcpy (osdev->modname, nick);

  if (handle == NULL)
    handle = nick;

  if (oss_num_cards >= MAX_CARDS)
    cmn_err (CE_WARN, "Too many OSS devices. At most %d permitted.\n",
	     MAX_CARDS);
  else
    {
      osdev->cardnum = oss_num_cards;
      cards[oss_num_cards++] = osdev;
    }
/*
 * Create the device handle
 */
  switch (dev_type)
    {
    case DRV_PCI:
      {
#if 0
	// TODO
	unsigned int subvendor;
	char *devpath;
	devpath = oss_pci_read_devpath (osdev->dip);
	oss_pci_read_config_dword (osdev, 0x2c, &subvendor);

	sprintf (osdev->handle, "PCI%08x-%s", subvendor, devpath);
#else
	strcpy(osdev->handle, "PCICARD");
#endif
      }
      break;

    case DRV_USB:
      // TODO: Get the vendor information
      sprintf (osdev->handle, "USB-%s%d", handle, instance);
      break;

    default:
      sprintf (osdev->handle, "%s%d", handle, instance);
    }

  return osdev;
}

oss_device_t *
osdev_clone (oss_device_t * orig_osdev, int new_instance)
{
  oss_device_t *osdev;

  osdev = PMALLOC (NULL, sizeof (*osdev));
  if (osdev == NULL)
    {
      cmn_err (CE_WARN, "osdev_create: Out of memory\n");
      return NULL;
    }
  memcpy (osdev, orig_osdev, sizeof (*osdev));
  osdev->dev_type = DRV_CLONE;
  osdev->instance = new_instance;
  sprintf (osdev->nick, "%s%d", orig_osdev->modname, new_instance);
  sprintf (osdev->handle, "%s%d", orig_osdev->modname, new_instance);

  return osdev;
}

void
osdev_delete (oss_device_t * osdev)
{
  int i;

  if (osdev == NULL)
    return;

  osdev->available = 0;
/*
 * Mark all minor nodes for this module as invalid.
 */
  for (i = 0; i < oss_num_cdevs; i++)
    if (oss_cdevs[i]->osdev == osdev)
      {
	oss_cdevs[i]->d = NULL;
	oss_cdevs[i]->osdev = NULL;
	strcpy (oss_cdevs[i]->name, "Removed device");
      }
}

void *
oss_get_osid (oss_device_t * osdev)
{
  return NULL;			// TODO
}

int
oss_register_device (oss_device_t * osdev, const char *name)
{
  if (name == NULL)
    {
      cmn_err (CE_WARN, "oss_register_device: name==NULL\n");
      osdev->name = "Undefined name";
      return 0;
    }

  if ((osdev->name = PMALLOC (NULL, strlen (name) + 1)) == NULL)
    {
      cmn_err (CE_WARN, "Cannot allocate memory for device name\n");
      osdev->name = "Unknown device";
    }
  strcpy (osdev->name, name);
  return 0;
}

void
oss_unregister_device (oss_device_t * osdev)
{
/*
 * Notice! The driver calling this routine (the owner of the osdev parameter)
 * has already uninitialized itself. Do not do any actions that may call this
 * driver directly or indirectly.
 */

// TODO: Move this to some common OSS module (also under Solaris)
}

int
oss_get_cardinfo (int cardnum, oss_card_info * ci)
{
/*
 * Print information about a 'card' in a format suitable for /dev/sndstat
 */

  if (cardnum < 0 || cardnum >= oss_num_cards)
    return OSS_ENXIO;

  if (cards[cardnum]->name != NULL)
    strncpy (ci->longname, cards[cardnum]->name, 128);
  ci->longname[127] = 0;

  if (cards[cardnum]->nick != NULL)
    strncpy (ci->shortname, cards[cardnum]->nick, 16);
  ci->shortname[15] = 0;

  if (cards[cardnum]->hw_info != NULL)
    strncpy (ci->hw_info, cards[cardnum]->hw_info, sizeof (ci->hw_info));
  ci->hw_info[sizeof (ci->hw_info) - 1] = 0;
  ci->intr_count = cards[cardnum]->intrcount;
  ci->ack_count = cards[cardnum]->ackcount;

  return 0;
}

int
ossDrv (void)
{
  oss_hz = sysClkRateGet();

  if (oss_driver_num != ERROR)
    {
      cmn_err (CE_WARN, "OSS is already running\n");
      return -1;
    }

#ifdef LICENSED_VERSION
  if (!oss_license_handle_time (oss_get_time ()))
    {
      cmn_err (CE_WARN, "This version of Open Sound System has expired\n");
      cmn_err (CE_CONT,
	       "Please download the latest version from www.opensound.com\n");
      oss_expired = 1;
      return -1;
    }
#endif

  oss_driver_num = iosDrvInstall ((FUNCPTR) NULL,	/* create */
				  (FUNCPTR) NULL,	/* delete */
				  (FUNCPTR) ossOpen, (FUNCPTR) ossClose, (FUNCPTR) ossRead, (FUNCPTR) ossWrite, (FUNCPTR) ossIoctl	/* ioctl */
    );
  if (oss_driver_num == ERROR)
    {
      cmn_err (CE_WARN, "Module osscore failed to install\n");
      return -1;
    }

  if ((core_osdev =
       osdev_create (NULL, DRV_UNKNOWN, 0, "osscore", NULL)) == NULL)
    {
      oss_cmn_err (CE_WARN, "Failed to allocate OSDEV structure\n");
      return -1;
    }
  oss_register_device (core_osdev, "OSS core services");

  oss_common_init (core_osdev);

  return oss_driver_num;
}

int
ossDrvRemove (void)
{
#if 1

  return ERROR;
#else
  int i;

  if (oss_driver_num == ERROR)
    return 0;

  for (i = 0; i < SND_NDEVS; i++)
    if (oss_files[i].valid)
      {
	iosDevDelete (&oss_files[i].devHdr);
	oss_files[i].valid = 0;
      }

  if (iosDrvRemove (oss_driver_num, FALSE) == ERROR)
    {
      cmn_err (CE_WARN, "Driver busy - cannot remove.\n");
      return ERROR;
    }

  // TODO
  oss_unload_drivers ();

  oss_driver_num = ERROR;	/* Mark it free */
  return OK;
#endif
}

#ifdef CONFIG_OSS_VMIX_FLOAT

#undef FP_SAVE
#undef FP_RESTORE
#define FP_SAVE(envbuf)		asm ("fnsave %0":"=m" (*envbuf));
#define FP_RESTORE(envbuf)		asm ("frstor %0":"=m" (*envbuf));

/* SSE/SSE2 compatible macros */
#define FX_SAVE(envbuf)		asm ("fxsave %0":"=m" (*envbuf));
#define FX_RESTORE(envbuf)		asm ("fxrstor %0":"=m" (*envbuf));

static int old_arch = 0;	/* No SSE/SSE2 instructions */

#if defined(__amd64__)
#define AMD64
#endif

static inline void
cpuid (int op, int *eax, int *ebx, int *ecx, int *edx)
{
__asm__ ("cpuid": "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx):"0" (op), "c"
	   (0));
}

#ifdef AMD64
#  define local_save_flags(x)     asm volatile("pushfq ; popq %0":"=g" (x):)
#  define local_restore_flags(x)  asm volatile("pushq %0 ; popfq"::"g" (x):"memory", "cc")
#else
#  define local_save_flags(x)     asm volatile("pushfl ; popl %0":"=g" (x):)
#  define local_restore_flags(x)  asm volatile("pushl %0 ; popfl"::"g" (x):"memory", "cc")
#endif

static inline unsigned long
read_cr0 (void)
{
  unsigned long cr0;
#ifdef AMD64
asm ("movq %%cr0,%0":"=r" (cr0));
#else
asm ("movl %%cr0,%0":"=r" (cr0));
#endif
  return cr0;
}

static inline void
write_cr0 (unsigned long val)
{
#ifdef AMD64
  asm ("movq %0,%%cr0"::"r" (val));
#else
  asm ("movl %0,%%cr0"::"r" (val));
#endif
}

static inline unsigned long
read_cr4 (void)
{
  unsigned long cr4;
#ifdef AMD64
asm ("movq %%cr4,%0":"=r" (cr4));
#else
asm ("movl %%cr4,%0":"=r" (cr4));
#endif
  return cr4;
}

static inline void
write_cr4 (unsigned long val)
{
#ifdef AMD64
  asm ("movq %0,%%cr4"::"r" (val));
#else
  asm ("movl %0,%%cr4"::"r" (val));
#endif
}
static inline unsigned long long
read_mxcsr (void)
{
  unsigned long long mxcsr;
  asm volatile ("stmxcsr %0":"=m" (mxcsr));
  return mxcsr;
}

static inline void
write_mxcsr (unsigned long long val)
{
  asm volatile ("ldmxcsr %0"::"m" (val));
}

int
oss_fp_check (void)
{
  int eax, ebx, ecx, edx;
#define FLAGS_ID (1<<21)

  oss_native_word flags_reg;

  local_save_flags (flags_reg);
  flags_reg &= ~FLAGS_ID;
  local_restore_flags (flags_reg);

  local_save_flags (flags_reg);
  if (flags_reg & FLAGS_ID)
    return 0;

  flags_reg |= FLAGS_ID;
  local_restore_flags (flags_reg);

  local_save_flags (flags_reg);
  if (!(flags_reg & FLAGS_ID))
    return 0;

//#define CPUID_FXSR	(1<<24)
//#define CPUID_SSE	(1<<25)
//#define CPUID_SSE2	(1<<26)

  cpuid (1, &eax, &ebx, &ecx, &edx);

  if (!(edx & CPUID_FXSR))
    return -1;

  /*
   * Older machines require different FP handling than the latest ones. Use the SSE
   * instruction set as an indicator.
   */
  if (!(edx & CPUID_SSE))
    old_arch = 1;

  return 1;
}

void
oss_fp_save (short *envbuf, unsigned int flags[])
{
  flags[0] = read_cr0 ();
  write_cr0 (flags[0] & ~0x0e);	/* Clear CR0.TS/MP/EM */

  if (old_arch)
    {
      FP_SAVE (envbuf);
    }
  else
    {
      flags[1] = read_cr4 ();
      write_cr4 (flags[1] | 0x600);	/* Set OSFXSR & OSXMMEXCEPT */
      FX_SAVE (envbuf);
      asm ("fninit");
      asm ("fwait");
      write_mxcsr (0x1f80);
    }
  flags[2] = read_cr0 ();
}

void
oss_fp_restore (short *envbuf, unsigned int flags[])
{
  asm ("fwait");
  if (old_arch)
    {
      FP_RESTORE (envbuf);
    }
  else
    {
      FX_RESTORE (envbuf);
      write_cr4 (flags[1]);	/* Restore cr4 */
    }
  write_cr0 (flags[0]);		/* Restore cr0 */
}
#endif

typedef struct tmout_desc
{
  volatile int active;
  int timestamp;
  void (*func) (void *);
  void *arg;

  WDOG_ID id;

} tmout_desc_t;

static volatile int next_id = 0;
#define MAX_TMOUTS 128

tmout_desc_t tmouts[MAX_TMOUTS] = { {0} };

int timeout_random = 0x12123400;

void
oss_timer_callback (int id)
{
  tmout_desc_t *tmout;
  int ix;
  void *arg;

  timeout_random++;

  ix = id & 0xff;
  if (ix < 0 || ix >= MAX_TMOUTS)
    return;
  tmout = &tmouts[ix];

  if (tmout->timestamp != id)	/* Expired timer */
    return;

  if (!tmout->active)
    return;

  arg = tmout->arg;
  tmout->active = 0;
  tmout->timestamp = 0;

  tmout->func (arg);
  wdDelete(tmout->id);
}

timeout_id_t
oss_timeout (void (*func) (void *), void *arg,
				 unsigned long long ticks)
{

  tmout_desc_t *tmout = NULL;
  int id, n;

  timeout_random++;

  n = 0;
  id = -1;

  while (id == -1 && n < MAX_TMOUTS)
    {
      if (!tmouts[next_id].active)
	{
	  tmouts[next_id].active = 1;
	  id = next_id++;
	  tmout = &tmouts[id];
	  break;
	}

      next_id = (next_id + 1) % MAX_TMOUTS;
    }

  if (id == -1)			/* No timer slots available */
    {
      oss_cmn_err (CE_WARN, "Timeout table full\n");
      return 0;
    }

  tmout->func = func;
  tmout->arg = arg;
  tmout->timestamp = id | (timeout_random & ~0xff);

  if ((tmout->id=wdCreate()) == NULL)
     return 0;

  wdStart(tmout->id, ticks, (FUNCPTR)oss_timer_callback, (int)tmout->timestamp);
  return id | (timeout_random & ~0xff);
}

void
oss_untimeout (timeout_id_t id)
{
  tmout_desc_t *tmout;
  int ix;

  ix = id & 0xff;
  if (ix < 0 || ix >= MAX_TMOUTS)
    return;

  timeout_random++;
  tmout = &tmouts[ix];

  if (tmout->timestamp != id)	/* Expired timer */
    return;
  if (tmout->active)
     {
	wdCancel(tmout->id);
	wdDelete(tmout->id);
     }

  tmout->active = 0;
  tmout->timestamp = 0;
}

void
oss_udelay(unsigned long ticks)
{
	// TODO
}

void *
oss_contig_malloc (oss_device_t * osdev, int buffsize, oss_uint64_t memlimit,
		   oss_native_word * phaddr)
{
  char *start_addr, *end_addr;

  *phaddr = 0;

  start_addr = NULL;

  // TODO: See if there is a previously freed buffer available

  start_addr = (char *) valloc (buffsize);

  if (start_addr == NULL)
    {
      cmn_err (CE_NOTE, "Failed to allocate memory buffer of %d bytes\n",
	       buffsize);
      return NULL;
    }
  else
    {
      /* make some checks */
      end_addr = start_addr + buffsize - 1;
    }

  *phaddr = (oss_native_word)start_addr;
  return start_addr;
}

void
oss_contig_free (oss_device_t * osdev, void *p, int buffsize)
{
  if (p == NULL)
    return;

  // TODO: Put the freed memory block to available list
  cmn_err (CE_WARN, "Cannot free %d bytes of DMA buffer\n", buffsize);
}

int
__oss_alloc_dmabuf (int dev, dmap_p dmap, unsigned int alloc_flags,
		    oss_uint64_t maxaddr, int direction)
{
  void *buf;
  int err;
  oss_native_word phaddr;
  int size = 64 * 1024;
  extern int dma_buffsize;

  if (dma_buffsize > 16 && dma_buffsize <= 128)
    size = dma_buffsize * 1024;

  if (dmap->dmabuf != NULL)
    return 0;			/* Already done */

  if (dmap == NULL)
    {
      cmn_err (CE_WARN, "oss_alloc_dmabuf: dmap==NULL\n");
      return OSS_EIO;
    }

/*
 * Some applications and virtual drivers need shorter buffer.
 */
  if (dmap->flags & DMAP_SMALLBUF)
    {
      size = SMALL_DMABUF_SIZE;
    }
  else if (dmap->flags & DMAP_MEDIUMBUF)
    {
      size = MEDIUM_DMABUF_SIZE;
    }

  if ((alloc_flags & DMABUF_SIZE_16BITS) && size > 32 * 1024)
    size = 32 * 1024;

  dmap->dmabuf = NULL;
  dmap->buffsize = size;

  err = -1;

  while (err < 0 && dmap->dmabuf == NULL && dmap->buffsize >= 4 * 1024)
    {
      if ((buf =
	   oss_contig_malloc (dmap->osdev, dmap->buffsize, maxaddr,
			      &phaddr)) == NULL)
	{
	  if ((dmap->buffsize = (dmap->buffsize / 2)) < 8 * 1024)
	    return OSS_ENOMEM;
	  cmn_err (CE_CONT, "Dropping DMA buffer size to %d bytes.\n",
		   dmap->buffsize);
	  continue;
	}

      dmap->dmabuf = buf;
      dmap->dmabuf_phys = phaddr;

      return 0;
    }

  return OSS_ENOMEM;
}

void
oss_free_dmabuf (int dev, dmap_p dmap)
{
  void *buf = dmap->dmabuf;

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

  dmap->dmabuf = NULL;
  oss_contig_free (NULL, buf, dmap->buffsize);
  dmap->dmabuf_phys = 0;
}

/*
 * Sleep/wakeup
 */

struct oss_wait_queue
{
  volatile int flags;
  SEM_ID wq;
};

struct oss_wait_queue *
oss_create_wait_queue (oss_device_t * osdev, const char *name)
{
  struct oss_wait_queue *wq;

  if ((wq = malloc (sizeof (*wq))) == NULL)
    {
      oss_cmn_err (CE_WARN, "vmalloc(%d) failed (wq)\n", sizeof (*wq));
      return NULL;
    }
  wq->wq = semBCreate(SEM_Q_FIFO, SEM_EMPTY);

  return wq;
}

void
oss_reset_wait_queue (struct oss_wait_queue *wq)
{
	// TODO: ?
}

void
oss_remove_wait_queue (struct oss_wait_queue *wq)
{
  free (wq);
}

int
oss_sleep (struct oss_wait_queue *wq, oss_mutex_t * mutex, int ticks,
	   oss_native_word * flags, unsigned int *status)
{
  int result;

  *status = 0;

  if (wq == NULL)
    return 0;

  wq->flags = 0;

  if (ticks <= 0)
     ticks = WAIT_FOREVER;

    result =
	    semTake(wq->wq, ticks);

  if (result == ERROR)		/* Signal received */
    {
      *status |= WK_SIGNAL;
      return 1;
    }

  if (!(wq->flags & WK_WAKEUP))	/* Timeout */
    {
      return 0;
    }

  return 1;
}

int
oss_register_poll (struct oss_wait_queue *wq, oss_mutex_t * mutex,
		   oss_native_word * flags, oss_poll_event_t * ev)
{
  // TODO: ?
  return 0;
}

void
oss_wakeup (struct oss_wait_queue *wq, oss_mutex_t * mutex,
	    oss_native_word * flags, short events)
{
  if (wq == NULL)
    return;

  wq->flags |= WK_WAKEUP;
  semFlush(wq->wq);
}