Import of Linus's Linux 1.1.68

1 files changed, 964 insertions, 0 deletions

diff --git a/drivers/sound/dmabuf.c b/drivers/sound/dmabuf.c
new file mode 100644
index 000000000..6f0794824
--- /dev/null
+++ b/drivers/sound/dmabuf.c
@@ -0,0 +1,964 @@
+/*
+ * sound/dmabuf.c
+ *
+ * The DMA buffer manager for digitized voice applications
+ *
+ * Copyright by Hannu Savolainen 1993, 1994
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer. 2.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#include "sound_config.h"
+
+#ifdef CONFIGURE_SOUNDCARD
+
+#include "sound_calls.h"
+
+#if !defined(EXCLUDE_AUDIO) || !defined(EXCLUDE_GUS)
+
+DEFINE_WAIT_QUEUES (dev_sleeper[MAX_AUDIO_DEV], dev_sleep_flag[MAX_AUDIO_DEV]);
+
+static struct dma_buffparms dmaps[MAX_AUDIO_DEV] =
+{0};				/*
+		 * Primitive way to allocate
+		 * such a large array.
+		 * Needs dynamic run-time allocation.
+		 */
+
+static void
+reorganize_buffers (int dev)
+{
+  /*
+   * This routine breaks the physical device buffers to logical ones.
+   */
+
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+  struct audio_operations *dsp_dev = audio_devs[dev];
+
+  unsigned        i, p, n;
+  unsigned        sr, nc, sz, bsz;
+
+  if (dmap->fragment_size == 0)
+    {				/* Compute the fragment size using the default algorithm */
+
+      sr = dsp_dev->ioctl (dev, SOUND_PCM_READ_RATE, 0, 1);
+      nc = dsp_dev->ioctl (dev, SOUND_PCM_READ_CHANNELS, 0, 1);
+      sz = dsp_dev->ioctl (dev, SOUND_PCM_READ_BITS, 0, 1);
+
+      if (sr < 1 || nc < 1 || sz < 1)
+	{
+	  printk ("Warning: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%d\n",
+		  dev, sr, nc, sz);
+	  sr = DSP_DEFAULT_SPEED;
+	  nc = 1;
+	  sz = 8;
+	}
+
+      sz /= 8;			/* #bits -> #bytes */
+
+      sz = sr * nc * sz;
+
+      /*
+   * Compute a buffer size for time not exceeding 1 second.
+   * Usually this algorithm gives a buffer size for 0.5 to 1.0 seconds
+   * of sound (using the current speed, sample size and #channels).
+   */
+
+      bsz = dsp_dev->buffsize;
+      while (bsz > sz)
+	bsz /= 2;
+
+      if (dsp_dev->buffcount == 1 && bsz == dsp_dev->buffsize)
+	bsz /= 2;		/* Needs at least 2 buffers */
+
+      if (dmap->subdivision == 0)	/* Not already set */
+	dmap->subdivision = 1;	/* Init to default value */
+
+      bsz /= dmap->subdivision;
+
+      if (bsz < 64)
+	bsz = 4096;		/* Just a sanity check */
+
+      while ((dsp_dev->buffsize * dsp_dev->buffcount) / bsz > MAX_SUB_BUFFERS)
+	bsz *= 2;
+
+      dmap->fragment_size = bsz;
+    }
+  else
+    {
+      /*
+ * The process has specified the buffer size with SNDCTL_DSP_SETFRAGMENT or
+ * the buffer size computation has already been done.
+ */
+      if (dmap->fragment_size > audio_devs[dev]->buffsize)
+	dmap->fragment_size = audio_devs[dev]->buffsize;
+      bsz = dmap->fragment_size;
+    }
+
+  /*
+   * Now computing addresses for the logical buffers
+   */
+
+  n = 0;
+  for (i = 0; i < dmap->raw_count &&
+       n < dmap->max_fragments &&
+       n < MAX_SUB_BUFFERS; i++)
+    {
+      p = 0;
+
+      while ((p + bsz) <= dsp_dev->buffsize &&
+	     n < dmap->max_fragments &&
+	     n < MAX_SUB_BUFFERS)
+	{
+	  dmap->buf[n] = dmap->raw_buf[i] + p;
+	  dmap->buf_phys[n] = dmap->raw_buf_phys[i] + p;
+	  p += bsz;
+	  n++;
+	}
+    }
+
+  dmap->nbufs = n;
+  dmap->bytes_in_use = n * bsz;
+
+  for (i = 0; i < dmap->nbufs; i++)
+    {
+      dmap->counts[i] = 0;
+    }
+
+  dmap->flags |= DMA_ALLOC_DONE;
+}
+
+static void
+dma_init_buffers (int dev)
+{
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap = &dmaps[dev];
+
+  RESET_WAIT_QUEUE (dev_sleeper[dev], dev_sleep_flag[dev]);
+
+  dmap->flags = DMA_BUSY;	/* Other flags off */
+  dmap->qlen = dmap->qhead = dmap->qtail = 0;
+
+  dmap->qlen = dmap->qtail = dmap->qhead = 0;
+  dmap->dma_mode = DMODE_NONE;
+}
+
+int
+DMAbuf_open (int dev, int mode)
+{
+  int             retval;
+  struct dma_buffparms *dmap = NULL;
+
+  if (dev >= num_audiodevs)
+    {
+      printk ("PCM device %d not installed.\n", dev);
+      return RET_ERROR (ENXIO);
+    }
+
+  if (!audio_devs[dev])
+    {
+      printk ("PCM device %d not initialized\n", dev);
+      return RET_ERROR (ENXIO);
+    }
+
+  dmap = audio_devs[dev]->dmap = &dmaps[dev];
+
+  if (dmap->flags & DMA_BUSY)
+    return RET_ERROR (EBUSY);
+
+#ifdef USE_RUNTIME_DMAMEM
+  dmap->raw_buf[0] = NULL;
+  sound_dma_malloc (dev);
+#endif
+
+  if (dmap->raw_buf[0] == NULL)
+    return RET_ERROR (ENOSPC);	/* Memory allocation failed during boot */
+
+  if ((retval = audio_devs[dev]->open (dev, mode)) < 0)
+    return retval;
+
+  dmap->open_mode = mode;
+  dmap->subdivision = dmap->underrun_count = 0;
+  dmap->fragment_size = 0;
+  dmap->max_fragments = 65536;	/* Just a large value */
+
+  dma_init_buffers (dev);
+  audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_BITS, 8, 1);
+  audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_CHANNELS, 1, 1);
+  audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_RATE, DSP_DEFAULT_SPEED, 1);
+
+  return 0;
+}
+
+static void
+dma_reset (int dev)
+{
+  int             retval;
+  unsigned long   flags;
+
+  DISABLE_INTR (flags);
+
+  audio_devs[dev]->reset (dev);
+  audio_devs[dev]->close (dev);
+
+  if ((retval = audio_devs[dev]->open (dev, audio_devs[dev]->dmap->open_mode)) < 0)
+    printk ("Sound: Reset failed - Can't reopen device\n");
+  RESTORE_INTR (flags);
+
+  dma_init_buffers (dev);
+  reorganize_buffers (dev);
+}
+
+static int
+dma_sync (int dev)
+{
+  unsigned long   flags;
+
+  if (audio_devs[dev]->dmap->dma_mode == DMODE_OUTPUT)
+    {
+      DISABLE_INTR (flags);
+
+      while (!PROCESS_ABORTING (dev_sleeper[dev], dev_sleep_flag[dev])
+	     && audio_devs[dev]->dmap->qlen)
+	{
+	  DO_SLEEP (dev_sleeper[dev], dev_sleep_flag[dev], 10 * HZ);
+	  if (TIMED_OUT (dev_sleeper[dev], dev_sleep_flag[dev]))
+	    {
+	      RESTORE_INTR (flags);
+	      return audio_devs[dev]->dmap->qlen;
+	    }
+	}
+      RESTORE_INTR (flags);
+
+      /*
+       * Some devices such as GUS have huge amount of on board RAM for the
+       * audio data. We have to wait util the device has finished playing.
+       */
+
+      DISABLE_INTR (flags);
+      if (audio_devs[dev]->local_qlen)	/* Device has hidden buffers */
+	{
+	  while (!(PROCESS_ABORTING (dev_sleeper[dev], dev_sleep_flag[dev]))
+		 && audio_devs[dev]->local_qlen (dev))
+	    {
+	      DO_SLEEP (dev_sleeper[dev], dev_sleep_flag[dev], HZ);
+	    }
+	}
+      RESTORE_INTR (flags);
+    }
+  return audio_devs[dev]->dmap->qlen;
+}
+
+int
+DMAbuf_release (int dev, int mode)
+{
+  unsigned long   flags;
+
+  if (!(PROCESS_ABORTING (dev_sleeper[dev], dev_sleep_flag[dev]))
+      && (audio_devs[dev]->dmap->dma_mode == DMODE_OUTPUT))
+    {
+      dma_sync (dev);
+    }
+
+#ifdef USE_RUNTIME_DMAMEM
+  sound_dma_free (dev);
+#endif
+
+  DISABLE_INTR (flags);
+  audio_devs[dev]->reset (dev);
+
+  audio_devs[dev]->close (dev);
+
+  audio_devs[dev]->dmap->dma_mode = DMODE_NONE;
+  audio_devs[dev]->dmap->flags &= ~DMA_BUSY;
+  RESTORE_INTR (flags);
+
+  return 0;
+}
+
+int
+DMAbuf_getrdbuffer (int dev, char **buf, int *len)
+{
+  unsigned long   flags;
+  int             err = EIO;
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+
+  DISABLE_INTR (flags);
+  if (!dmap->qlen)
+    {
+      if (dmap->flags & DMA_RESTART)
+	{
+	  dma_reset (dev);
+	  dmap->flags &= ~DMA_RESTART;
+	}
+
+      if (dmap->dma_mode == DMODE_OUTPUT)	/* Direction change */
+	{
+	  dma_sync (dev);
+	  dma_reset (dev);
+	  dmap->dma_mode = DMODE_NONE;
+	}
+
+      if (!(dmap->flags & DMA_ALLOC_DONE))
+	reorganize_buffers (dev);
+
+      if (!dmap->dma_mode)
+	{
+	  int             err;
+
+	  if ((err = audio_devs[dev]->prepare_for_input (dev,
+				     dmap->fragment_size, dmap->nbufs)) < 0)
+	    {
+	      RESTORE_INTR (flags);
+	      return err;
+	    }
+	  dmap->dma_mode = DMODE_INPUT;
+	}
+
+      if (!(dmap->flags & DMA_ACTIVE))
+	{
+	  audio_devs[dev]->start_input (dev, dmap->buf_phys[dmap->qtail],
+					dmap->fragment_size, 0,
+				 !(audio_devs[dev]->flags & DMA_AUTOMODE) ||
+					!(dmap->flags & DMA_STARTED));
+	  dmap->flags |= DMA_ACTIVE | DMA_STARTED;
+	}
+
+      /* Wait for the next block */
+
+      DO_SLEEP (dev_sleeper[dev], dev_sleep_flag[dev], 2 * HZ);
+      if (TIMED_OUT (dev_sleeper[dev], dev_sleep_flag[dev]))
+	{
+	  printk ("Sound: DMA timed out - IRQ/DRQ config error?\n");
+	  err = EIO;
+	  SET_ABORT_FLAG (dev_sleeper[dev], dev_sleep_flag[dev]);
+	}
+      else
+	err = EINTR;
+    }
+  RESTORE_INTR (flags);
+
+  if (!dmap->qlen)
+    return RET_ERROR (err);
+
+  *buf = &dmap->buf[dmap->qhead][dmap->counts[dmap->qhead]];
+  *len = dmap->fragment_size - dmap->counts[dmap->qhead];
+
+  return dmap->qhead;
+}
+
+int
+DMAbuf_rmchars (int dev, int buff_no, int c)
+{
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+
+  int             p = dmap->counts[dmap->qhead] + c;
+
+  if (p >= dmap->fragment_size)
+    {				/* This buffer is completely empty */
+      dmap->counts[dmap->qhead] = 0;
+      if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
+	printk ("\nSound: Audio queue1 corrupted for dev%d (%d/%d)\n",
+		dev, dmap->qlen, dmap->nbufs);
+      dmap->qlen--;
+      dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
+    }
+  else
+    dmap->counts[dmap->qhead] = p;
+
+  return 0;
+}
+
+int
+DMAbuf_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
+{
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+
+  switch (cmd)
+    {
+    case SNDCTL_DSP_RESET:
+      dma_reset (dev);
+      return 0;
+      break;
+
+    case SNDCTL_DSP_SYNC:
+      dma_sync (dev);
+      dma_reset (dev);
+      return 0;
+      break;
+
+    case SNDCTL_DSP_GETBLKSIZE:
+      if (!(dmap->flags & DMA_ALLOC_DONE))
+	reorganize_buffers (dev);
+
+      return IOCTL_OUT (arg, dmap->fragment_size);
+      break;
+
+    case SNDCTL_DSP_SUBDIVIDE:
+      {
+	int             fact = IOCTL_IN (arg);
+
+	if (fact == 0)
+	  {
+	    fact = dmap->subdivision;
+	    if (fact == 0)
+	      fact = 1;
+	    return IOCTL_OUT (arg, fact);
+	  }
+
+	if (dmap->subdivision != 0 ||
+	    dmap->fragment_size)/* Too late to change */
+	  return RET_ERROR (EINVAL);
+
+	if (fact > MAX_REALTIME_FACTOR)
+	  return RET_ERROR (EINVAL);
+
+	if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
+	  return RET_ERROR (EINVAL);
+
+	dmap->subdivision = fact;
+	return IOCTL_OUT (arg, fact);
+      }
+      break;
+
+    case SNDCTL_DSP_SETFRAGMENT:
+      {
+	int             fact = IOCTL_IN (arg);
+	int             bytes, count;
+
+	if (fact == 0)
+	  return RET_ERROR (EIO);
+
+	if (dmap->subdivision != 0 ||
+	    dmap->fragment_size)/* Too late to change */
+	  return RET_ERROR (EINVAL);
+
+	bytes = fact & 0xffff;
+	count = (fact >> 16) & 0xffff;
+
+	if (count == 0)
+	  count = MAX_SUB_BUFFERS;
+
+	if (bytes < 7 || bytes > 17)	/* <64 || > 128k */
+	  return RET_ERROR (EINVAL);
+
+	if (count < 2)
+	  return RET_ERROR (EINVAL);
+
+	dmap->fragment_size = (1 << bytes);
+	dmap->max_fragments = count;
+
+	if (dmap->fragment_size > audio_devs[dev]->buffsize)
+	  dmap->fragment_size = audio_devs[dev]->buffsize;
+
+	if (dmap->fragment_size == audio_devs[dev]->buffsize &&
+	    audio_devs[dev]->flags & DMA_AUTOMODE)
+	  dmap->fragment_size /= 2;	/* Needs at least 2 buffers */
+
+	dmap->subdivision = 1;	/* Disable SNDCTL_DSP_SUBDIVIDE */
+	return IOCTL_OUT (arg, bytes | (count << 16));
+      }
+      break;
+
+    default:
+      return audio_devs[dev]->ioctl (dev, cmd, arg, local);
+    }
+
+  return RET_ERROR (EIO);
+}
+
+static int
+space_in_queue (int dev)
+{
+  int             len, max, tmp;
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+
+  if (dmap->qlen == dmap->nbufs)/* No space at all */
+    return 0;
+
+  /*
+  * Verify that there are no more pending buffers than the limit
+  * defined by the process.
+  */
+
+  max = dmap->max_fragments;
+  len = dmap->qlen;
+
+  if (audio_devs[dev]->local_qlen)
+    {
+      tmp = audio_devs[dev]->local_qlen (dev);
+      if (tmp & len)
+	tmp--;			/*
+			 * This buffer has been counted twice
+			 */
+      len += tmp;
+    }
+
+  if (len >= max)
+    return 0;
+  return 1;
+}
+
+int
+DMAbuf_getwrbuffer (int dev, char **buf, int *size)
+{
+  unsigned long   flags;
+  int             abort, err = EIO;
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+
+  if (dmap->dma_mode == DMODE_INPUT)	/* Direction change */
+    {
+      dma_reset (dev);
+      dmap->dma_mode = DMODE_NONE;
+    }
+  else if (dmap->flags & DMA_RESTART)	/* Restart buffering */
+    {
+      dma_sync (dev);
+      dma_reset (dev);
+    }
+
+  dmap->flags &= ~DMA_RESTART;
+
+  if (!(dmap->flags & DMA_ALLOC_DONE))
+    reorganize_buffers (dev);
+
+  if (!dmap->dma_mode)
+    {
+      int             err;
+
+      dmap->dma_mode = DMODE_OUTPUT;
+      if ((err = audio_devs[dev]->prepare_for_output (dev,
+				     dmap->fragment_size, dmap->nbufs)) < 0)
+	return err;
+    }
+
+
+  DISABLE_INTR (flags);
+
+  abort = 0;
+  while (!space_in_queue (dev) &&
+	 !abort)
+    {
+      /*
+       * Wait for free space
+       */
+      DO_SLEEP (dev_sleeper[dev], dev_sleep_flag[dev], 2 * HZ);
+      if (TIMED_OUT (dev_sleeper[dev], dev_sleep_flag[dev]))
+	{
+	  printk ("Sound: DMA timed out - IRQ/DRQ config error?\n");
+	  err = EIO;
+	  abort = 1;
+	  SET_ABORT_FLAG (dev_sleeper[dev], dev_sleep_flag[dev]);
+	}
+      else if (PROCESS_ABORTING (dev_sleeper[dev], dev_sleep_flag[dev]))
+	{
+	  err = EINTR;
+	  abort = 1;
+	}
+    }
+  RESTORE_INTR (flags);
+
+  if (!space_in_queue (dev))
+    {
+      return RET_ERROR (err);	/* Caught a signal ? */
+    }
+
+  *buf = dmap->buf[dmap->qtail];
+  *size = dmap->fragment_size;
+  dmap->counts[dmap->qtail] = 0;
+
+  return dmap->qtail;
+}
+
+int
+DMAbuf_start_output (int dev, int buff_no, int l)
+{
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+
+  if (buff_no != dmap->qtail)
+    printk ("Sound warning: DMA buffers out of sync %d != %d\n", buff_no, dmap->qtail);
+
+  dmap->qlen++;
+  if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
+    printk ("\nSound: Audio queue2 corrupted for dev%d (%d/%d)\n",
+	    dev, dmap->qlen, dmap->nbufs);
+
+  dmap->counts[dmap->qtail] = l;
+
+  if ((l != dmap->fragment_size) &&
+      ((audio_devs[dev]->flags & DMA_AUTOMODE) &&
+       audio_devs[dev]->flags & NEEDS_RESTART))
+    dmap->flags |= DMA_RESTART;
+  else
+    dmap->flags &= ~DMA_RESTART;
+
+  dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
+
+  if (!(dmap->flags & DMA_ACTIVE))
+    {
+      dmap->flags |= DMA_ACTIVE;
+      audio_devs[dev]->output_block (dev, dmap->buf_phys[dmap->qhead],
+				     dmap->counts[dmap->qhead], 0,
+				 !(audio_devs[dev]->flags & DMA_AUTOMODE) ||
+				     !(dmap->flags & DMA_STARTED));
+      dmap->flags |= DMA_STARTED;
+    }
+
+  return 0;
+}
+
+int
+DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
+{
+  int             chan = audio_devs[dev]->dmachan;
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+  unsigned long   flags;
+
+  /*
+   * This function is not as portable as it should be.
+   */
+
+  /*
+   * The count must be one less than the actual size. This is handled by
+   * set_dma_addr()
+   */
+
+  if (audio_devs[dev]->flags & DMA_AUTOMODE)
+    {				/*
+				 * Auto restart mode. Transfer the whole *
+				 * buffer
+				 */
+#ifdef linux
+      DISABLE_INTR (flags);
+      disable_dma (chan);
+      clear_dma_ff (chan);
+      set_dma_mode (chan, dma_mode | DMA_AUTOINIT);
+      set_dma_addr (chan, dmap->raw_buf_phys[0]);
+      set_dma_count (chan, dmap->bytes_in_use);
+      enable_dma (chan);
+      RESTORE_INTR (flags);
+#else
+
+#ifdef __386BSD__
+      printk ("sound: Invalid DMA mode for device %d\n", dev);
+
+      isa_dmastart ((dma_mode == DMA_MODE_READ) ? B_READ : B_WRITE,
+		    dmap->raw_buf_phys[0],
+		    dmap->bytes_in_use,
+		    chan);
+#else
+#if defined(GENERIC_SYSV)
+#ifndef DMAMODE_AUTO
+      printk ("sound: Invalid DMA mode for device %d\n", dev);
+#endif
+      dma_param (chan, ((dma_mode == DMA_MODE_READ) ? DMA_Rdmode : DMA_Wrmode)
+#ifdef DMAMODE_AUTO
+		 | DMAMODE_AUTO
+#endif
+		 ,
+		 dmap->raw_buf_phys[0], dmap->bytes_in_use);
+      dma_enable (chan);
+#else
+#error This routine is not valid for this OS.
+#endif
+#endif
+
+#endif
+    }
+  else
+    {
+#ifdef linux
+      DISABLE_INTR (flags);
+      disable_dma (chan);
+      clear_dma_ff (chan);
+      set_dma_mode (chan, dma_mode);
+      set_dma_addr (chan, physaddr);
+      set_dma_count (chan, count);
+      enable_dma (chan);
+      RESTORE_INTR (flags);
+#else
+#ifdef __386BSD__
+      isa_dmastart ((dma_mode == DMA_MODE_READ) ? B_READ : B_WRITE,
+		    physaddr,
+		    count,
+		    chan);
+#else
+
+#if defined(GENERIC_SYSV)
+      dma_param (chan, ((dma_mode == DMA_MODE_READ) ? DMA_Rdmode : DMA_Wrmode),
+		 physaddr, count);
+      dma_enable (chan);
+#else
+#error This routine is not valid for this OS.
+#endif /* GENERIC_SYSV */
+#endif
+
+#endif
+    }
+
+  return count;
+}
+
+long
+DMAbuf_init (long mem_start)
+{
+  int             dev;
+
+  /*
+ * NOTE! This routine could be called several times.
+ */
+
+  for (dev = 0; dev < num_audiodevs; dev++)
+    audio_devs[dev]->dmap = &dmaps[dev];
+  return mem_start;
+}
+
+void
+DMAbuf_outputintr (int dev, int event_type)
+{
+  /*
+ * Event types:
+ *	0 = DMA transfer done. Device still has more data in the local
+ *	    buffer.
+ *	1 = DMA transfer done. Device doesn't have local buffer or it's
+ *	    empty now.
+ *	2 = No DMA transfer but the device has now more space in it's local
+ *	    buffer.
+ */
+
+  unsigned long   flags;
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+
+  if (event_type != 2)
+    {
+      if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
+	{
+	  printk ("\nSound: Audio queue3 corrupted for dev%d (%d/%d)\n",
+		  dev, dmap->qlen, dmap->nbufs);
+	  return;
+	}
+
+      dmap->qlen--;
+      dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
+      dmap->flags &= ~DMA_ACTIVE;
+
+      if (dmap->qlen)
+	{
+	  audio_devs[dev]->output_block (dev, dmap->buf_phys[dmap->qhead],
+					 dmap->counts[dmap->qhead], 1,
+				  !(audio_devs[dev]->flags & DMA_AUTOMODE));
+	  dmap->flags |= DMA_ACTIVE;
+	}
+      else if (event_type == 1)
+	{
+	  dmap->underrun_count++;
+	  audio_devs[dev]->halt_xfer (dev);
+	  if ((audio_devs[dev]->flags & DMA_AUTOMODE) &&
+	      audio_devs[dev]->flags & NEEDS_RESTART)
+	    dmap->flags |= DMA_RESTART;
+	  else
+	    dmap->flags &= ~DMA_RESTART;
+	}
+    }				/* event_type != 2 */
+
+  DISABLE_INTR (flags);
+  if (SOMEONE_WAITING (dev_sleeper[dev], dev_sleep_flag[dev]))
+    {
+      WAKE_UP (dev_sleeper[dev], dev_sleep_flag[dev]);
+    }
+  RESTORE_INTR (flags);
+}
+
+void
+DMAbuf_inputintr (int dev)
+{
+  unsigned long   flags;
+  struct dma_buffparms *dmap = audio_devs[dev]->dmap;
+
+  if (dmap->qlen == (dmap->nbufs - 1))
+    {
+      printk ("Sound: Recording overrun\n");
+      dmap->underrun_count++;
+      audio_devs[dev]->halt_xfer (dev);
+      dmap->flags &= ~DMA_ACTIVE;
+      if (audio_devs[dev]->flags & DMA_AUTOMODE)
+	dmap->flags |= DMA_RESTART;
+      else
+	dmap->flags &= ~DMA_RESTART;
+    }
+  else
+    {
+      dmap->qlen++;
+      if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
+	printk ("\nSound: Audio queue4 corrupted for dev%d (%d/%d)\n",
+		dev, dmap->qlen, dmap->nbufs);
+      dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
+
+      audio_devs[dev]->start_input (dev, dmap->buf_phys[dmap->qtail],
+				    dmap->fragment_size, 1,
+				  !(audio_devs[dev]->flags & DMA_AUTOMODE));
+      dmap->flags |= DMA_ACTIVE;
+    }
+
+  DISABLE_INTR (flags);
+  if (SOMEONE_WAITING (dev_sleeper[dev], dev_sleep_flag[dev]))
+    {
+      WAKE_UP (dev_sleeper[dev], dev_sleep_flag[dev]);
+    }
+  RESTORE_INTR (flags);
+}
+
+int
+DMAbuf_open_dma (int dev)
+{
+  unsigned long   flags;
+  int             chan = audio_devs[dev]->dmachan;
+
+  if (ALLOC_DMA_CHN (chan,"audio"))
+    {
+      printk ("Unable to grab DMA%d for the audio driver\n", chan);
+      return RET_ERROR (EBUSY);
+    }
+
+  DISABLE_INTR (flags);
+#ifdef linux
+  disable_dma (chan);
+  clear_dma_ff (chan);
+#endif
+  RESTORE_INTR (flags);
+
+  return 0;
+}
+
+void
+DMAbuf_close_dma (int dev)
+{
+  int             chan = audio_devs[dev]->dmachan;
+
+  DMAbuf_reset_dma (chan);
+  RELEASE_DMA_CHN (chan);
+}
+
+void
+DMAbuf_reset_dma (int chan)
+{
+}
+
+/*
+ * The sound_mem_init() is called by mem_init() immediately after mem_map is
+ * initialized and before free_page_list is created.
+ *
+ * This routine allocates DMA buffers at the end of available physical memory (
+ * <16M) and marks pages reserved at mem_map.
+ */
+
+#else
+/*
+ * Stub versions if audio services not included
+ */
+
+int
+DMAbuf_open (int dev, int mode)
+{
+  return RET_ERROR (ENXIO);
+}
+
+int
+DMAbuf_release (int dev, int mode)
+{
+  return 0;
+}
+
+int
+DMAbuf_getwrbuffer (int dev, char **buf, int *size)
+{
+  return RET_ERROR (EIO);
+}
+
+int
+DMAbuf_getrdbuffer (int dev, char **buf, int *len)
+{
+  return RET_ERROR (EIO);
+}
+
+int
+DMAbuf_rmchars (int dev, int buff_no, int c)
+{
+  return RET_ERROR (EIO);
+}
+
+int
+DMAbuf_start_output (int dev, int buff_no, int l)
+{
+  return RET_ERROR (EIO);
+}
+
+int
+DMAbuf_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
+{
+  return RET_ERROR (EIO);
+}
+
+long
+DMAbuf_init (long mem_start)
+{
+  return mem_start;
+}
+
+int
+DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
+{
+  return RET_ERROR (EIO);
+}
+
+int
+DMAbuf_open_dma (int chan)
+{
+  return RET_ERROR (ENXIO);
+}
+
+void
+DMAbuf_close_dma (int chan)
+{
+  return;
+}
+
+void
+DMAbuf_reset_dma (int chan)
+{
+  return;
+}
+
+void
+DMAbuf_inputintr (int dev)
+{
+  return;
+}
+
+void
+DMAbuf_outputintr (int dev, int underrun_flag)
+{
+  return;
+}
+
+#endif
+
+#endif