root/drivers/sound/dmabuf.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. reorganize_buffers
  2. dma_init_buffers
  3. open_dmap
  4. close_dmap
  5. DMAbuf_open
  6. dma_reset
  7. dma_reset_output
  8. dma_reset_input
  9. dma_sync
  10. DMAbuf_release
  11. activate_recording
  12. DMAbuf_getrdbuffer
  13. DMAbuf_rmchars
  14. dma_subdivide
  15. dma_set_fragment
  16. get_buffer_pointer
  17. DMAbuf_ioctl
  18. DMAbuf_start_devices
  19. space_in_queue
  20. DMAbuf_getwrbuffer
  21. DMAbuf_get_curr_buffer
  22. DMAbuf_set_count
  23. DMAbuf_start_output
  24. DMAbuf_start_dma
  25. DMAbuf_init
  26. polish_buffers
  27. DMAbuf_outputintr
  28. DMAbuf_inputintr
  29. DMAbuf_open_dma
  30. DMAbuf_close_dma
  31. DMAbuf_reset_dma
  32. DMAbuf_select
  33. DMAbuf_open
  34. DMAbuf_release
  35. DMAbuf_getwrbuffer
  36. DMAbuf_getrdbuffer
  37. DMAbuf_rmchars
  38. DMAbuf_start_output
  39. DMAbuf_ioctl
  40. DMAbuf_init
  41. DMAbuf_start_dma
  42. DMAbuf_open_dma
  43. DMAbuf_close_dma
  44. DMAbuf_reset_dma
  45. DMAbuf_inputintr
  46. DMAbuf_outputintr

   1 /*
   2  * sound/dmabuf.c
   3  *
   4  * The DMA buffer manager for digitized voice applications
   5  */
   6 /*
   7  * Copyright by Hannu Savolainen 1993-1996
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions are
  11  * met: 1. Redistributions of source code must retain the above copyright
  12  * notice, this list of conditions and the following disclaimer. 2.
  13  * Redistributions in binary form must reproduce the above copyright notice,
  14  * this list of conditions and the following disclaimer in the documentation
  15  * and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29 #include <linux/config.h>
  30 
  31 
  32 #include "sound_config.h"
  33 
  34 #if defined(CONFIG_AUDIO) || defined(CONFIG_GUS)
  35 
  36 static wait_handle *in_sleeper[MAX_AUDIO_DEV] =
  37 {NULL};
  38 static volatile struct snd_wait in_sleep_flag[MAX_AUDIO_DEV] =
  39 {
  40   {0}};
  41 static wait_handle *out_sleeper[MAX_AUDIO_DEV] =
  42 {NULL};
  43 static volatile struct snd_wait out_sleep_flag[MAX_AUDIO_DEV] =
  44 {
  45   {0}};
  46 
  47 #define NEUTRAL8        0x80
  48 #define NEUTRAL16       0x00
  49 
  50 static int      ndmaps = 0;
  51 
  52 #define MAX_DMAP (MAX_AUDIO_DEV*2)
  53 
  54 static struct dma_buffparms dmaps[MAX_DMAP] =
  55 {
  56   {0}};
  57 
  58 static int      space_in_queue (int dev);
  59 
  60 static void     dma_reset_output (int dev);
  61 static void     dma_reset_input (int dev);
  62 
  63 static void
  64 reorganize_buffers (int dev, struct dma_buffparms *dmap, int recording)
     /* [previous][next][first][last][top][bottom][index][help] */
  65 {
  66   /*
  67    * This routine breaks the physical device buffers to logical ones.
  68    */
  69 
  70   struct audio_operations *dsp_dev = audio_devs[dev];
  71 
  72   unsigned        i, n;
  73   unsigned        sr, nc, sz, bsz;
  74 
  75   if (dmap->fragment_size == 0)
  76     {                           /* Compute the fragment size using the default algorithm */
  77 
  78       sr = dsp_dev->ioctl (dev, SOUND_PCM_READ_RATE, 0, 1);
  79       nc = dsp_dev->ioctl (dev, SOUND_PCM_READ_CHANNELS, 0, 1);
  80       sz = dsp_dev->ioctl (dev, SOUND_PCM_READ_BITS, 0, 1);
  81 
  82       if (sz == 8)
  83         dmap->neutral_byte = NEUTRAL8;
  84       else
  85         dmap->neutral_byte = NEUTRAL16;
  86 
  87       if (sr < 1 || nc < 1 || sz < 1)
  88         {
  89           printk ("Warning: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%d\n",
  90                   dev, sr, nc, sz);
  91           sr = DSP_DEFAULT_SPEED;
  92           nc = 1;
  93           sz = 8;
  94         }
  95 
  96       sz = sr * nc * sz;
  97 
  98       sz /= 8;                  /* #bits -> #bytes */
  99 
 100       /*
 101          * Compute a buffer size for time not exeeding 1 second.
 102          * Usually this algorithm gives a buffer size for 0.5 to 1.0 seconds
 103          * of sound (using the current speed, sample size and #channels).
 104        */
 105 
 106       bsz = dsp_dev->buffsize;
 107       while (bsz > sz)
 108         bsz /= 2;
 109 
 110       if (bsz == dsp_dev->buffsize)
 111         bsz /= 2;               /* Needs at least 2 buffers */
 112 
 113 /*
 114  *    Split the computed fragment to smaller parts. After 3.5a9
 115  *      the default subdivision is 4 which should give better
 116  *      results when recording.
 117  */
 118 
 119       if (dmap->subdivision == 0)       /* Not already set */
 120         {
 121           dmap->subdivision = 1;        /* Init to the default value */
 122 #ifndef V35A9_COMPATIBLE
 123           if (recording)
 124             dmap->subdivision = 4;      /* Use shorter fragments when recording */
 125 #endif
 126         }
 127 
 128       bsz /= dmap->subdivision;
 129 
 130       if (bsz < 16)
 131         bsz = 16;               /* Just a sanity check */
 132 
 133       dmap->fragment_size = bsz;
 134     }
 135   else
 136     {
 137       /*
 138          * The process has specified the buffer sice with SNDCTL_DSP_SETFRAGMENT or
 139          * the buffer sice computation has already been done.
 140        */
 141       if (dmap->fragment_size > (audio_devs[dev]->buffsize / 2))
 142         dmap->fragment_size = (audio_devs[dev]->buffsize / 2);
 143       bsz = dmap->fragment_size;
 144     }
 145 
 146   bsz &= ~0x03;                 /* Force size which is multiple of 4 bytes */
 147 #ifdef OS_DMA_ALIGN_CHECK
 148   OS_DMA_ALIGN_CHECK (bsz);
 149 #endif
 150 
 151   n = dsp_dev->buffsize / bsz;
 152   if (n > MAX_SUB_BUFFERS)
 153     n = MAX_SUB_BUFFERS;
 154   if (n > dmap->max_fragments)
 155     n = dmap->max_fragments;
 156   dmap->nbufs = n;
 157   dmap->bytes_in_use = n * bsz;
 158 
 159   memset (dmap->raw_buf,
 160           dmap->neutral_byte,
 161           dmap->bytes_in_use);
 162 
 163   for (i = 0; i < dmap->nbufs; i++)
 164     {
 165       dmap->counts[i] = 0;
 166     }
 167 
 168   dmap->flags |= DMA_ALLOC_DONE | DMA_EMPTY;
 169 }
 170 
 171 static void
 172 dma_init_buffers (int dev, struct dma_buffparms *dmap)
     /* [previous][next][first][last][top][bottom][index][help] */
 173 {
 174   if (dmap == audio_devs[dev]->dmap_out)
 175     {
 176       out_sleep_flag[dev].mode = WK_NONE;
 177     }
 178   else
 179     {
 180       in_sleep_flag[dev].mode = WK_NONE;
 181     }
 182 
 183   dmap->flags = DMA_BUSY;       /* Other flags off */
 184   dmap->qlen = dmap->qhead = dmap->qtail = 0;
 185   dmap->nbufs = 1;
 186   dmap->bytes_in_use = audio_devs[dev]->buffsize;
 187 
 188   dmap->dma_mode = DMODE_NONE;
 189   dmap->mapping_flags = 0;
 190   dmap->neutral_byte = NEUTRAL8;
 191   dmap->cfrag = -1;
 192   dmap->closing = 0;
 193 }
 194 
 195 static int
 196 open_dmap (int dev, int mode, struct dma_buffparms *dmap, int chan)
     /* [previous][next][first][last][top][bottom][index][help] */
 197 {
 198   if (dmap->flags & DMA_BUSY)
 199     return -EBUSY;
 200 
 201   {
 202     int             err;
 203 
 204     if ((err = sound_alloc_dmap (dev, dmap, chan)) < 0)
 205       return err;
 206   }
 207 
 208   if (dmap->raw_buf == NULL)
 209     return -ENOSPC;             /* Memory allocation failed during boot */
 210 
 211   if (sound_open_dma (chan, audio_devs[dev]->name))
 212     {
 213       printk ("Unable to grab(2) DMA%d for the audio driver\n", chan);
 214       return -EBUSY;
 215     }
 216 
 217   dmap->open_mode = mode;
 218   dmap->subdivision = dmap->underrun_count = 0;
 219   dmap->fragment_size = 0;
 220   dmap->max_fragments = 65536;  /* Just a large value */
 221   dmap->byte_counter = 0;
 222 
 223   dma_init_buffers (dev, dmap);
 224 
 225   return 0;
 226 }
 227 
 228 static void
 229 close_dmap (int dev, struct dma_buffparms *dmap, int chan)
     /* [previous][next][first][last][top][bottom][index][help] */
 230 {
 231   sound_close_dma (chan);
 232 
 233   if (dmap->flags & DMA_BUSY)
 234     dmap->dma_mode = DMODE_NONE;
 235   dmap->flags &= ~DMA_BUSY;
 236 
 237   sound_free_dmap (dev, dmap);
 238 }
 239 
 240 int
 241 DMAbuf_open (int dev, int mode)
     /* [previous][next][first][last][top][bottom][index][help] */
 242 {
 243   int             retval;
 244   struct dma_buffparms *dmap_in = NULL;
 245   struct dma_buffparms *dmap_out = NULL;
 246 
 247   if (dev >= num_audiodevs)
 248     {
 249       printk ("PCM device %d not installed.\n", dev);
 250       return -ENXIO;
 251     }
 252 
 253   if (!audio_devs[dev])
 254     {
 255       printk ("PCM device %d not initialized\n", dev);
 256       return -ENXIO;
 257     }
 258 
 259   if (!(audio_devs[dev]->flags & DMA_DUPLEX))
 260     {
 261       audio_devs[dev]->dmap_in = audio_devs[dev]->dmap_out;
 262       audio_devs[dev]->dmachan2 = audio_devs[dev]->dmachan1;
 263     }
 264 
 265   if ((retval = audio_devs[dev]->open (dev, mode)) < 0)
 266     return retval;
 267 
 268   dmap_out = audio_devs[dev]->dmap_out;
 269   dmap_in = audio_devs[dev]->dmap_in;
 270 
 271   if ((retval = open_dmap (dev, mode, dmap_out, audio_devs[dev]->dmachan1)) < 0)
 272     {
 273       audio_devs[dev]->close (dev);
 274       return retval;
 275     }
 276 
 277   audio_devs[dev]->enable_bits = mode;
 278   if (audio_devs[dev]->flags & DMA_DUPLEX && dmap_out != dmap_in)
 279     if ((retval = open_dmap (dev, mode, dmap_in, audio_devs[dev]->dmachan2)) < 0)
 280       {
 281         audio_devs[dev]->close (dev);
 282         close_dmap (dev, dmap_out, audio_devs[dev]->dmachan1);
 283         return retval;
 284       }
 285   audio_devs[dev]->open_mode = mode;
 286   audio_devs[dev]->go = 1;
 287   in_sleep_flag[dev].mode = WK_NONE;
 288   out_sleep_flag[dev].mode = WK_NONE;
 289 
 290   audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_BITS, (caddr_t) 8, 1);
 291   audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_CHANNELS, (caddr_t) 1, 1);
 292   audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_RATE, (caddr_t) DSP_DEFAULT_SPEED, 1);
 293 
 294   return 0;
 295 }
 296 
 297 static void
 298 dma_reset (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 299 {
 300   unsigned long   flags;
 301 
 302   save_flags (flags);
 303   cli ();
 304   audio_devs[dev]->reset (dev);
 305   restore_flags (flags);
 306 
 307   dma_reset_output (dev);
 308 
 309   if (audio_devs[dev]->flags & DMA_DUPLEX)
 310     dma_reset_input (dev);
 311 }
 312 
 313 static void
 314 dma_reset_output (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 315 {
 316   unsigned long   flags;
 317 
 318   save_flags (flags);
 319   cli ();
 320   if (!(audio_devs[dev]->flags & DMA_DUPLEX) ||
 321       !audio_devs[dev]->halt_output)
 322     audio_devs[dev]->reset (dev);
 323   else
 324     audio_devs[dev]->halt_output (dev);
 325   restore_flags (flags);
 326 
 327   dma_init_buffers (dev, audio_devs[dev]->dmap_out);
 328   reorganize_buffers (dev, audio_devs[dev]->dmap_out, 0);
 329 }
 330 
 331 static void
 332 dma_reset_input (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 333 {
 334   unsigned long   flags;
 335 
 336   save_flags (flags);
 337   cli ();
 338   if (!(audio_devs[dev]->flags & DMA_DUPLEX) ||
 339       !audio_devs[dev]->halt_input)
 340     audio_devs[dev]->reset (dev);
 341   else
 342     audio_devs[dev]->halt_input (dev);
 343   restore_flags (flags);
 344 
 345   dma_init_buffers (dev, audio_devs[dev]->dmap_in);
 346   reorganize_buffers (dev, audio_devs[dev]->dmap_in, 1);
 347 }
 348 
 349 static int
 350 dma_sync (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 351 {
 352   unsigned long   flags;
 353 
 354   if (!audio_devs[dev]->go && (!audio_devs[dev]->enable_bits & PCM_ENABLE_OUTPUT))
 355     return 0;
 356 
 357   if (audio_devs[dev]->dmap_out->dma_mode == DMODE_OUTPUT)
 358     {
 359       save_flags (flags);
 360       cli ();
 361 
 362       audio_devs[dev]->dmap_out->underrun_count = 0;
 363       while (!current_got_fatal_signal ()
 364              && audio_devs[dev]->dmap_out->qlen
 365              && audio_devs[dev]->dmap_out->underrun_count == 0)
 366         {
 367 
 368           {
 369             unsigned long   tl;
 370 
 371             if (HZ)
 372               current_set_timeout (tl = jiffies + (HZ));
 373             else
 374               tl = (unsigned long) -1;
 375             out_sleep_flag[dev].mode = WK_SLEEP;
 376             module_interruptible_sleep_on (&out_sleeper[dev]);
 377             if (!(out_sleep_flag[dev].mode & WK_WAKEUP))
 378               {
 379                 if (jiffies >= tl)
 380                   out_sleep_flag[dev].mode |= WK_TIMEOUT;
 381               }
 382             out_sleep_flag[dev].mode &= ~WK_SLEEP;
 383           };
 384           if ((out_sleep_flag[dev].mode & WK_TIMEOUT))
 385             {
 386               restore_flags (flags);
 387               return audio_devs[dev]->dmap_out->qlen;
 388             }
 389         }
 390       restore_flags (flags);
 391 
 392       /*
 393        * Some devices such as GUS have huge amount of on board RAM for the
 394        * audio data. We have to wait until the device has finished playing.
 395        */
 396 
 397       save_flags (flags);
 398       cli ();
 399       if (audio_devs[dev]->local_qlen)  /* Device has hidden buffers */
 400         {
 401           while (!(current_got_fatal_signal ())
 402                  && audio_devs[dev]->local_qlen (dev))
 403             {
 404 
 405               {
 406                 unsigned long   tl;
 407 
 408                 if (HZ)
 409                   current_set_timeout (tl = jiffies + (HZ));
 410                 else
 411                   tl = (unsigned long) -1;
 412                 out_sleep_flag[dev].mode = WK_SLEEP;
 413                 module_interruptible_sleep_on (&out_sleeper[dev]);
 414                 if (!(out_sleep_flag[dev].mode & WK_WAKEUP))
 415                   {
 416                     if (jiffies >= tl)
 417                       out_sleep_flag[dev].mode |= WK_TIMEOUT;
 418                   }
 419                 out_sleep_flag[dev].mode &= ~WK_SLEEP;
 420               };
 421             }
 422         }
 423       restore_flags (flags);
 424     }
 425   return audio_devs[dev]->dmap_out->qlen;
 426 }
 427 
 428 int
 429 DMAbuf_release (int dev, int mode)
     /* [previous][next][first][last][top][bottom][index][help] */
 430 {
 431   unsigned long   flags;
 432 
 433   audio_devs[dev]->dmap_out->closing = 1;
 434   audio_devs[dev]->dmap_in->closing = 1;
 435 
 436   if (!(current_got_fatal_signal ())
 437       && (audio_devs[dev]->dmap_out->dma_mode == DMODE_OUTPUT))
 438     {
 439       dma_sync (dev);
 440 
 441       memset (audio_devs[dev]->dmap_out->raw_buf,
 442               audio_devs[dev]->dmap_out->neutral_byte,
 443               audio_devs[dev]->dmap_out->bytes_in_use);
 444     }
 445 
 446   save_flags (flags);
 447   cli ();
 448 
 449   audio_devs[dev]->close (dev);
 450 
 451   close_dmap (dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
 452 
 453   if (audio_devs[dev]->flags & DMA_DUPLEX)
 454     close_dmap (dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
 455   audio_devs[dev]->open_mode = 0;
 456 
 457   restore_flags (flags);
 458 
 459   return 0;
 460 }
 461 
 462 static int
 463 activate_recording (int dev, struct dma_buffparms *dmap)
     /* [previous][next][first][last][top][bottom][index][help] */
 464 {
 465   if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT))
 466     return 0;
 467 
 468   if (dmap->flags & DMA_RESTART)
 469     {
 470       dma_reset_input (dev);
 471       dmap->flags &= ~DMA_RESTART;
 472     }
 473 
 474   if (dmap->dma_mode == DMODE_OUTPUT)   /* Direction change */
 475     {
 476       dma_sync (dev);
 477       dma_reset (dev);
 478       dmap->dma_mode = DMODE_NONE;
 479     }
 480 
 481   if (!(dmap->flags & DMA_ALLOC_DONE))
 482     reorganize_buffers (dev, dmap, 1);
 483 
 484   if (!dmap->dma_mode)
 485     {
 486       int             err;
 487 
 488       if ((err = audio_devs[dev]->prepare_for_input (dev,
 489                                      dmap->fragment_size, dmap->nbufs)) < 0)
 490         {
 491           return err;
 492         }
 493       dmap->dma_mode = DMODE_INPUT;
 494     }
 495 
 496   if (!(dmap->flags & DMA_ACTIVE))
 497     {
 498       audio_devs[dev]->start_input (dev, dmap->raw_buf_phys +
 499                                     dmap->qtail * dmap->fragment_size,
 500                                     dmap->fragment_size, 0,
 501                                  !(audio_devs[dev]->flags & DMA_AUTOMODE) ||
 502                                     !(dmap->flags & DMA_STARTED));
 503       dmap->flags |= DMA_ACTIVE | DMA_STARTED;
 504       if (audio_devs[dev]->trigger)
 505         audio_devs[dev]->trigger (dev,
 506                         audio_devs[dev]->enable_bits * audio_devs[dev]->go);
 507     }
 508   return 0;
 509 }
 510 
 511 int
 512 DMAbuf_getrdbuffer (int dev, char **buf, int *len, int dontblock)
     /* [previous][next][first][last][top][bottom][index][help] */
 513 {
 514   unsigned long   flags;
 515   int             err = EIO;
 516   struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
 517 
 518   save_flags (flags);
 519   cli ();
 520   if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED)
 521     {
 522       printk ("Sound: Can't read from mmapped device (1)\n");
 523       return -EINVAL;
 524     }
 525   else if (!dmap->qlen)
 526     {
 527       int             tmout;
 528 
 529       if ((err = activate_recording (dev, dmap)) < 0)
 530         {
 531           restore_flags (flags);
 532           return err;
 533         }
 534 
 535       /* Wait for the next block */
 536 
 537       if (dontblock)
 538         {
 539           restore_flags (flags);
 540           return -EAGAIN;
 541         }
 542 
 543       if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT) &
 544           audio_devs[dev]->go)
 545         {
 546           restore_flags (flags);
 547           return -EAGAIN;
 548         }
 549 
 550       if (!audio_devs[dev]->go)
 551         tmout = 0;
 552       else
 553         tmout = 2 * HZ;
 554 
 555 
 556       {
 557         unsigned long   tl;
 558 
 559         if (tmout)
 560           current_set_timeout (tl = jiffies + (tmout));
 561         else
 562           tl = (unsigned long) -1;
 563         in_sleep_flag[dev].mode = WK_SLEEP;
 564         module_interruptible_sleep_on (&in_sleeper[dev]);
 565         if (!(in_sleep_flag[dev].mode & WK_WAKEUP))
 566           {
 567             if (jiffies >= tl)
 568               in_sleep_flag[dev].mode |= WK_TIMEOUT;
 569           }
 570         in_sleep_flag[dev].mode &= ~WK_SLEEP;
 571       };
 572       if ((in_sleep_flag[dev].mode & WK_TIMEOUT))
 573         {
 574           printk ("Sound: DMA (input) timed out - IRQ/DRQ config error?\n");
 575           err = EIO;
 576           audio_devs[dev]->reset (dev);
 577           ;
 578         }
 579       else
 580         err = EINTR;
 581     }
 582   restore_flags (flags);
 583 
 584   if (!dmap->qlen)
 585     return -err;
 586 
 587   *buf = &dmap->raw_buf[dmap->qhead * dmap->fragment_size + dmap->counts[dmap->qhead]];
 588   *len = dmap->fragment_size - dmap->counts[dmap->qhead];
 589 
 590   return dmap->qhead;
 591 }
 592 
 593 int
 594 DMAbuf_rmchars (int dev, int buff_no, int c)
     /* [previous][next][first][last][top][bottom][index][help] */
 595 {
 596   struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
 597 
 598   int             p = dmap->counts[dmap->qhead] + c;
 599 
 600   if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED)
 601     {
 602       printk ("Sound: Can't read from mmapped device (2)\n");
 603       return -EINVAL;
 604     }
 605   else if (p >= dmap->fragment_size)
 606     {                           /* This buffer is completely empty */
 607       dmap->counts[dmap->qhead] = 0;
 608       if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
 609         printk ("\nSound: Audio queue1 corrupted for dev%d (%d/%d)\n",
 610                 dev, dmap->qlen, dmap->nbufs);
 611       dmap->qlen--;
 612       dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
 613     }
 614   else
 615     dmap->counts[dmap->qhead] = p;
 616 
 617   return 0;
 618 }
 619 
 620 static int
 621 dma_subdivide (int dev, struct dma_buffparms *dmap, caddr_t arg, int fact)
     /* [previous][next][first][last][top][bottom][index][help] */
 622 {
 623   if (fact == 0)
 624     {
 625       fact = dmap->subdivision;
 626       if (fact == 0)
 627         fact = 1;
 628       return snd_ioctl_return ((int *) arg, fact);
 629     }
 630 
 631   if (dmap->subdivision != 0 ||
 632       dmap->fragment_size)      /* Loo late to change */
 633     return -EINVAL;
 634 
 635   if (fact > MAX_REALTIME_FACTOR)
 636     return -EINVAL;
 637 
 638   if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
 639     return -EINVAL;
 640 
 641   dmap->subdivision = fact;
 642   return snd_ioctl_return ((int *) arg, fact);
 643 }
 644 
 645 static int
 646 dma_set_fragment (int dev, struct dma_buffparms *dmap, caddr_t arg, int fact)
     /* [previous][next][first][last][top][bottom][index][help] */
 647 {
 648   int             bytes, count;
 649 
 650   if (fact == 0)
 651     return -EIO;
 652 
 653   if (dmap->subdivision != 0 ||
 654       dmap->fragment_size)      /* Loo late to change */
 655     return -EINVAL;
 656 
 657   bytes = fact & 0xffff;
 658   count = (fact >> 16) & 0xffff;
 659 
 660   if (count == 0)
 661     count = MAX_SUB_BUFFERS;
 662 
 663   if (bytes < 4 || bytes > 17)  /* <16 || > 128k */
 664     return -EINVAL;
 665 
 666   if (count < 2)
 667     return -EINVAL;
 668 
 669 #ifdef OS_DMA_MINBITS
 670   if (bytes < OS_DMA_MINBITS)
 671     bytes = OS_DMA_MINBITS;
 672 #endif
 673 
 674   dmap->fragment_size = (1 << bytes);
 675   dmap->max_fragments = count;
 676 
 677   if (dmap->fragment_size > audio_devs[dev]->buffsize)
 678     dmap->fragment_size = audio_devs[dev]->buffsize;
 679 
 680   if (dmap->fragment_size == audio_devs[dev]->buffsize &&
 681       audio_devs[dev]->flags & DMA_AUTOMODE)
 682     dmap->fragment_size /= 2;   /* Needs at least 2 buffers */
 683 
 684   dmap->subdivision = 1;        /* Disable SNDCTL_DSP_SUBDIVIDE */
 685   return snd_ioctl_return ((int *) arg, bytes | (count << 16));
 686 }
 687 
 688 static int
 689 get_buffer_pointer (int dev, int chan, struct dma_buffparms *dmap)
     /* [previous][next][first][last][top][bottom][index][help] */
 690 {
 691   int             pos;
 692   unsigned long   flags;
 693 
 694   save_flags (flags);
 695   cli ();
 696   if (!(dmap->flags & DMA_ACTIVE))
 697     pos = 0;
 698   else
 699     {
 700       clear_dma_ff (chan);
 701       disable_dma (chan);
 702       pos = get_dma_residue (chan);
 703       enable_dma (chan);
 704     }
 705   restore_flags (flags);
 706   /* printk ("%04x ", pos); */
 707 
 708   if (audio_devs[dev]->flags & DMA_AUTOMODE)
 709     return dmap->bytes_in_use - pos;
 710   else
 711     {
 712       pos = dmap->fragment_size - pos;
 713       if (pos < 0)
 714         return 0;
 715       return pos;
 716     }
 717 }
 718 
 719 
 720 int
 721 DMAbuf_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
     /* [previous][next][first][last][top][bottom][index][help] */
 722 {
 723   struct dma_buffparms *dmap_out = audio_devs[dev]->dmap_out;
 724   struct dma_buffparms *dmap_in = audio_devs[dev]->dmap_in;
 725 
 726   switch (cmd)
 727     {
 728     case SNDCTL_DSP_RESET:
 729       dma_reset (dev);
 730       return 0;
 731       break;
 732 
 733     case SNDCTL_DSP_SYNC:
 734       dma_sync (dev);
 735       dma_reset (dev);
 736       return 0;
 737       break;
 738 
 739     case SNDCTL_DSP_GETBLKSIZE:
 740       if (!(dmap_out->flags & DMA_ALLOC_DONE))
 741         reorganize_buffers (dev, dmap_out, 0);
 742 
 743       return snd_ioctl_return ((int *) arg, dmap_out->fragment_size);
 744       break;
 745 
 746     case SNDCTL_DSP_SUBDIVIDE:
 747       {
 748         int             fact = get_fs_long ((long *) arg);
 749         int             ret;
 750 
 751         ret = dma_subdivide (dev, dmap_out, arg, fact);
 752         if (ret < 0)
 753           return ret;
 754 
 755         if (audio_devs[dev]->flags & DMA_DUPLEX)
 756           ret = dma_subdivide (dev, dmap_in, arg, fact);
 757 
 758         return ret;
 759       }
 760       break;
 761 
 762     case SNDCTL_DSP_SETFRAGMENT:
 763       {
 764         int             fact = get_fs_long ((long *) arg);
 765         int             ret;
 766 
 767         ret = dma_set_fragment (dev, dmap_out, arg, fact);
 768         if (ret < 0)
 769           return ret;
 770 
 771         if (audio_devs[dev]->flags & DMA_DUPLEX)
 772           ret = dma_set_fragment (dev, dmap_in, arg, fact);
 773 
 774         return ret;
 775       }
 776       break;
 777 
 778     case SNDCTL_DSP_GETISPACE:
 779     case SNDCTL_DSP_GETOSPACE:
 780       if (!local)
 781         return -EINVAL;
 782       else
 783         {
 784           struct dma_buffparms *dmap = dmap_out;
 785 
 786           audio_buf_info *info = (audio_buf_info *) arg;
 787 
 788           if (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
 789             dmap = dmap_in;
 790 
 791           if (dmap->mapping_flags & DMA_MAP_MAPPED)
 792             return -EINVAL;
 793 
 794           if (!(dmap->flags & DMA_ALLOC_DONE))
 795             reorganize_buffers (dev, dmap, (cmd == SNDCTL_DSP_GETISPACE));
 796 
 797           info->fragstotal = dmap->nbufs;
 798 
 799           if (cmd == SNDCTL_DSP_GETISPACE)
 800             info->fragments = dmap->qlen;
 801           else
 802             {
 803               if (!space_in_queue (dev))
 804                 info->fragments = 0;
 805               else
 806                 {
 807                   info->fragments = dmap->nbufs - dmap->qlen;
 808                   if (audio_devs[dev]->local_qlen)
 809                     {
 810                       int             tmp = audio_devs[dev]->local_qlen (dev);
 811 
 812                       if (tmp && info->fragments)
 813                         tmp--;  /*
 814                                    * This buffer has been counted twice
 815                                  */
 816                       info->fragments -= tmp;
 817                     }
 818                 }
 819             }
 820 
 821           if (info->fragments < 0)
 822             info->fragments = 0;
 823           else if (info->fragments > dmap->nbufs)
 824             info->fragments = dmap->nbufs;
 825 
 826           info->fragsize = dmap->fragment_size;
 827           info->bytes = info->fragments * dmap->fragment_size;
 828 
 829           if (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
 830             info->bytes -= dmap->counts[dmap->qhead];
 831         }
 832       return 0;
 833 
 834     case SNDCTL_DSP_SETTRIGGER:
 835       {
 836         unsigned long   flags;
 837 
 838         int             bits = get_fs_long ((long *) arg) & audio_devs[dev]->open_mode;
 839         int             changed;
 840 
 841         if (audio_devs[dev]->trigger == NULL)
 842           return -EINVAL;
 843 
 844         if (!(audio_devs[dev]->flags & DMA_DUPLEX))
 845           if ((bits & PCM_ENABLE_INPUT) && (bits & PCM_ENABLE_OUTPUT))
 846             {
 847               printk ("Sound: Device doesn't have full duplex capability\n");
 848               return -EINVAL;
 849             }
 850 
 851         save_flags (flags);
 852         cli ();
 853         changed = audio_devs[dev]->enable_bits ^ bits;
 854 
 855         if ((changed & bits) & PCM_ENABLE_INPUT && audio_devs[dev]->go)
 856           {
 857             int             err;
 858 
 859             if (!(dmap_in->flags & DMA_ALLOC_DONE))
 860               {
 861                 reorganize_buffers (dev, dmap_in, 1);
 862               }
 863 
 864             if ((err = audio_devs[dev]->prepare_for_input (dev,
 865                                dmap_in->fragment_size, dmap_in->nbufs)) < 0)
 866               return -err;
 867 
 868             activate_recording (dev, dmap_in);
 869           }
 870 
 871         if ((changed & bits) & PCM_ENABLE_OUTPUT &&
 872             dmap_out->mapping_flags & DMA_MAP_MAPPED &&
 873             audio_devs[dev]->go)
 874           {
 875             int             err;
 876 
 877             if (!(dmap_out->flags & DMA_ALLOC_DONE))
 878               {
 879                 reorganize_buffers (dev, dmap_out, 0);
 880               }
 881 
 882             if ((err = audio_devs[dev]->prepare_for_output (dev,
 883                              dmap_out->fragment_size, dmap_out->nbufs)) < 0)
 884               return -err;
 885 
 886             dmap_out->counts[dmap_out->qhead] = dmap_out->fragment_size;
 887             DMAbuf_start_output (dev, 0, dmap_out->fragment_size);
 888           }
 889 
 890         audio_devs[dev]->enable_bits = bits;
 891         if (changed && audio_devs[dev]->trigger)
 892           audio_devs[dev]->trigger (dev, bits * audio_devs[dev]->go);
 893         restore_flags (flags);
 894       }
 895     case SNDCTL_DSP_GETTRIGGER:
 896       return snd_ioctl_return ((int *) arg, audio_devs[dev]->enable_bits);
 897       break;
 898 
 899     case SNDCTL_DSP_SETSYNCRO:
 900 
 901       if (!audio_devs[dev]->trigger)
 902         return -EINVAL;
 903 
 904       audio_devs[dev]->trigger (dev, 0);
 905       audio_devs[dev]->go = 0;
 906       return 0;
 907       break;
 908 
 909     case SNDCTL_DSP_GETIPTR:
 910       {
 911         count_info      info;
 912         unsigned long   flags;
 913 
 914         save_flags (flags);
 915         cli ();
 916         info.bytes = audio_devs[dev]->dmap_in->byte_counter;
 917         info.ptr = get_buffer_pointer (dev, audio_devs[dev]->dmachan2, audio_devs[dev]->dmap_in);
 918         info.blocks = audio_devs[dev]->dmap_in->qlen;
 919         info.bytes += info.ptr;
 920         memcpy_tofs ((&((char *) arg)[0]), (char *) &info, sizeof (info));
 921 
 922         if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED)
 923           audio_devs[dev]->dmap_in->qlen = 0;   /* Acknowledge interrupts */
 924         restore_flags (flags);
 925         return 0;
 926       }
 927       break;
 928 
 929     case SNDCTL_DSP_GETOPTR:
 930       {
 931         count_info      info;
 932         unsigned long   flags;
 933 
 934         save_flags (flags);
 935         cli ();
 936         info.bytes = audio_devs[dev]->dmap_out->byte_counter;
 937         info.ptr = get_buffer_pointer (dev, audio_devs[dev]->dmachan1, audio_devs[dev]->dmap_out);
 938         info.blocks = audio_devs[dev]->dmap_out->qlen;
 939         info.bytes += info.ptr;
 940         memcpy_tofs ((&((char *) arg)[0]), (char *) &info, sizeof (info));
 941 
 942         if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED)
 943           audio_devs[dev]->dmap_out->qlen = 0;  /* Acknowledge interrupts */
 944         restore_flags (flags);
 945         return 0;
 946       }
 947       break;
 948 
 949 
 950     default:
 951       return audio_devs[dev]->ioctl (dev, cmd, arg, local);
 952     }
 953 
 954 }
 955 
 956 /*
 957  * DMAbuf_start_devices() is called by the /dev/music driver to start
 958  * one or more audio devices at desired moment.
 959  */
 960 
 961 void
 962 DMAbuf_start_devices (unsigned int devmask)
     /* [previous][next][first][last][top][bottom][index][help] */
 963 {
 964   int             dev;
 965 
 966   for (dev = 0; dev < num_audiodevs; dev++)
 967     if (devmask & (1 << dev))
 968       if (audio_devs[dev]->open_mode != 0)
 969         if (!audio_devs[dev]->go)
 970           {
 971             /* OK to start the device */
 972             audio_devs[dev]->go = 1;
 973 
 974             if (audio_devs[dev]->trigger)
 975               audio_devs[dev]->trigger (dev,
 976                         audio_devs[dev]->enable_bits * audio_devs[dev]->go);
 977           }
 978 }
 979 
 980 static int
 981 space_in_queue (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 982 {
 983   int             len, max, tmp;
 984   struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
 985 
 986   if (dmap->qlen >= dmap->nbufs)        /* No space at all */
 987     return 0;
 988 
 989   /*
 990      * Verify that there are no more pending buffers than the limit
 991      * defined by the process.
 992    */
 993 
 994   max = dmap->max_fragments;
 995   len = dmap->qlen;
 996 
 997   if (audio_devs[dev]->local_qlen)
 998     {
 999       tmp = audio_devs[dev]->local_qlen (dev);
1000       if (tmp && len)
1001         tmp--;                  /*
1002                                    * This buffer has been counted twice
1003                                  */
1004       len += tmp;
1005     }
1006 
1007   if (len >= max)
1008     return 0;
1009   return 1;
1010 }
1011 
1012 int
1013 DMAbuf_getwrbuffer (int dev, char **buf, int *size, int dontblock)
     /* [previous][next][first][last][top][bottom][index][help] */
1014 {
1015   unsigned long   flags;
1016   int             abort, err = EIO;
1017   struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1018 
1019   if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED)
1020     {
1021       printk ("Sound: Can't write to mmapped device (3)\n");
1022       return -EINVAL;
1023     }
1024 
1025   if (dmap->dma_mode == DMODE_INPUT)    /* Direction change */
1026     {
1027       dma_reset (dev);
1028       dmap->dma_mode = DMODE_NONE;
1029     }
1030   else if (dmap->flags & DMA_RESTART)   /* Restart buffering */
1031     {
1032       dma_sync (dev);
1033       dma_reset_output (dev);
1034     }
1035 
1036   dmap->flags &= ~(DMA_RESTART | DMA_EMPTY);
1037 
1038   if (!(dmap->flags & DMA_ALLOC_DONE))
1039     reorganize_buffers (dev, dmap, 0);
1040 
1041   if (!dmap->dma_mode)
1042     {
1043       int             err;
1044 
1045       dmap->dma_mode = DMODE_OUTPUT;
1046       if ((err = audio_devs[dev]->prepare_for_output (dev,
1047                                      dmap->fragment_size, dmap->nbufs)) < 0)
1048         return err;
1049     }
1050 
1051   save_flags (flags);
1052   cli ();
1053 
1054   abort = 0;
1055   while (!space_in_queue (dev) &&
1056          !abort)
1057     {
1058       int             tmout;
1059 
1060       if (dontblock)
1061         {
1062           restore_flags (flags);
1063           return -EAGAIN;
1064         }
1065 
1066       if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_OUTPUT) &&
1067           audio_devs[dev]->go)
1068         {
1069           restore_flags (flags);
1070           return -EAGAIN;
1071         }
1072 
1073       /*
1074        * Wait for free space
1075        */
1076       if (!audio_devs[dev]->go)
1077         tmout = 0;
1078       else
1079         tmout = 2 * HZ;
1080 
1081 
1082       {
1083         unsigned long   tl;
1084 
1085         if (tmout)
1086           current_set_timeout (tl = jiffies + (tmout));
1087         else
1088           tl = (unsigned long) -1;
1089         out_sleep_flag[dev].mode = WK_SLEEP;
1090         module_interruptible_sleep_on (&out_sleeper[dev]);
1091         if (!(out_sleep_flag[dev].mode & WK_WAKEUP))
1092           {
1093             if (jiffies >= tl)
1094               out_sleep_flag[dev].mode |= WK_TIMEOUT;
1095           }
1096         out_sleep_flag[dev].mode &= ~WK_SLEEP;
1097       };
1098       if ((out_sleep_flag[dev].mode & WK_TIMEOUT))
1099         {
1100           printk ("Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
1101           err = EIO;
1102           abort = 1;
1103           ;
1104           audio_devs[dev]->reset (dev);
1105         }
1106       else if (current_got_fatal_signal ())
1107         {
1108           err = EINTR;
1109           abort = 1;
1110         }
1111     }
1112   restore_flags (flags);
1113 
1114   if (!space_in_queue (dev))
1115     {
1116       return -err;              /* Caught a signal ? */
1117     }
1118 
1119   *buf = dmap->raw_buf + dmap->qtail * dmap->fragment_size;
1120   *size = dmap->fragment_size;
1121   dmap->counts[dmap->qtail] = 0;
1122 
1123   return dmap->qtail;
1124 }
1125 
1126 int
1127 DMAbuf_get_curr_buffer (int dev, int *buf_no, char **dma_buf, int *buf_ptr, int *buf_size)
     /* [previous][next][first][last][top][bottom][index][help] */
1128 {
1129   struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1130 
1131   if (dmap->cfrag < 0)
1132     return -1;
1133 
1134   *dma_buf = dmap->raw_buf + dmap->qtail * dmap->fragment_size;
1135   *buf_ptr = dmap->counts[dmap->qtail];
1136   *buf_size = dmap->fragment_size;
1137   return *buf_no = dmap->cfrag;
1138 }
1139 
1140 int
1141 DMAbuf_set_count (int dev, int buff_no, int l)
     /* [previous][next][first][last][top][bottom][index][help] */
1142 {
1143   struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1144 
1145   if (buff_no == dmap->qtail)
1146     {
1147       dmap->cfrag = buff_no;
1148       dmap->counts[buff_no] = l;
1149     }
1150   else
1151     dmap->cfrag = -1;
1152   return 0;
1153 }
1154 
1155 int
1156 DMAbuf_start_output (int dev, int buff_no, int l)
     /* [previous][next][first][last][top][bottom][index][help] */
1157 {
1158   struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1159 
1160   dmap->cfrag = -1;
1161 /*
1162  * Bypass buffering if using mmaped access
1163  */
1164 
1165   if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED)
1166     {
1167       l = dmap->fragment_size;
1168       dmap->counts[dmap->qtail] = l;
1169       dmap->flags &= ~DMA_RESTART;
1170       dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1171     }
1172   else
1173     {
1174 
1175 
1176       dmap->qlen++;
1177       if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
1178         printk ("\nSound: Audio queue2 corrupted for dev%d (%d/%d)\n",
1179                 dev, dmap->qlen, dmap->nbufs);
1180 
1181       dmap->counts[dmap->qtail] = l;
1182       if (l < dmap->fragment_size)
1183         {
1184           int             p = dmap->fragment_size * dmap->qtail;
1185 
1186           memset (dmap->raw_buf + p + l,
1187                   dmap->neutral_byte,
1188                   dmap->fragment_size - l);
1189         }
1190 
1191       if ((l != dmap->fragment_size) &&
1192           ((audio_devs[dev]->flags & DMA_AUTOMODE) &&
1193            audio_devs[dev]->flags & NEEDS_RESTART))
1194         dmap->flags |= DMA_RESTART;
1195       else
1196         dmap->flags &= ~DMA_RESTART;
1197 
1198       dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1199     }
1200 
1201   if (!(dmap->flags & DMA_ACTIVE))
1202     {
1203       dmap->flags |= DMA_ACTIVE;
1204       audio_devs[dev]->output_block (dev, dmap->raw_buf_phys +
1205                                      dmap->qhead * dmap->fragment_size,
1206                                      dmap->counts[dmap->qhead], 0,
1207                                  !(audio_devs[dev]->flags & DMA_AUTOMODE) ||
1208                                      !(dmap->flags & DMA_STARTED));
1209       dmap->flags |= DMA_STARTED;
1210       if (audio_devs[dev]->trigger)
1211         audio_devs[dev]->trigger (dev,
1212                         audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1213     }
1214 
1215   return 0;
1216 }
1217 
1218 int
1219 DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
     /* [previous][next][first][last][top][bottom][index][help] */
1220 {
1221   int             chan;
1222   struct dma_buffparms *dmap;
1223   unsigned long   flags;
1224 
1225   if (dma_mode == DMA_MODE_WRITE)
1226     {
1227       chan = audio_devs[dev]->dmachan1;
1228       dmap = audio_devs[dev]->dmap_out;
1229     }
1230   else
1231     {
1232       chan = audio_devs[dev]->dmachan2;
1233       dmap = audio_devs[dev]->dmap_in;
1234     }
1235 
1236   /*
1237    * The count must be one less than the actual size. This is handled by
1238    * set_dma_addr()
1239    */
1240 
1241   if (audio_devs[dev]->flags & DMA_AUTOMODE)
1242     {                           /*
1243                                  * Auto restart mode. Transfer the whole *
1244                                  * buffer
1245                                  */
1246       save_flags (flags);
1247       cli ();
1248       disable_dma (chan);
1249       clear_dma_ff (chan);
1250       set_dma_mode (chan, dma_mode | DMA_AUTOINIT);
1251       set_dma_addr (chan, dmap->raw_buf_phys);
1252       set_dma_count (chan, dmap->bytes_in_use);
1253       enable_dma (chan);
1254       restore_flags (flags);
1255     }
1256   else
1257     {
1258       save_flags (flags);
1259       cli ();
1260       disable_dma (chan);
1261       clear_dma_ff (chan);
1262       set_dma_mode (chan, dma_mode);
1263       set_dma_addr (chan, physaddr);
1264       set_dma_count (chan, count);
1265       enable_dma (chan);
1266       restore_flags (flags);
1267     }
1268 
1269   return count;
1270 }
1271 
1272 long
1273 DMAbuf_init (long mem_start)
     /* [previous][next][first][last][top][bottom][index][help] */
1274 {
1275   int             dev;
1276 
1277 
1278   /*
1279      * NOTE! This routine could be called several times.
1280    */
1281 
1282   for (dev = 0; dev < num_audiodevs; dev++)
1283     if (audio_devs[dev]->dmap_out == NULL)
1284       {
1285         audio_devs[dev]->dmap_out =
1286           audio_devs[dev]->dmap_in =
1287           &dmaps[ndmaps++];
1288 
1289         if (audio_devs[dev]->flags & DMA_DUPLEX)
1290           audio_devs[dev]->dmap_in =
1291             &dmaps[ndmaps++];
1292       }
1293   return mem_start;
1294 }
1295 
1296 static void
1297 polish_buffers (struct dma_buffparms *dmap)
     /* [previous][next][first][last][top][bottom][index][help] */
1298 {
1299   int             i;
1300 
1301   if (dmap->cfrag < 0)
1302     {
1303       memset (dmap->raw_buf,
1304               dmap->neutral_byte,
1305               dmap->bytes_in_use);
1306       return;
1307     }
1308 
1309   for (i = 0; i < dmap->nbufs; i++)
1310     {
1311       int             p, l;
1312 
1313       p = dmap->fragment_size * i;
1314 
1315       if (i == dmap->cfrag)
1316         {
1317           l = dmap->fragment_size - dmap->counts[i];
1318         }
1319       else
1320         l = dmap->fragment_size;
1321 
1322       if (l)
1323         {
1324           memset (dmap->raw_buf + p,
1325                   dmap->neutral_byte,
1326                   l);
1327         }
1328     }
1329 }
1330 
1331 void
1332 DMAbuf_outputintr (int dev, int event_type)
     /* [previous][next][first][last][top][bottom][index][help] */
1333 {
1334   /*
1335      * Event types:
1336      *  0 = DMA transfer done. Device still has more data in the local
1337      *      buffer.
1338      *  1 = DMA transfer done. Device doesn't have local buffer or it's
1339      *      empty now.
1340      *  2 = No DMA transfer but the device has now more space in it's local
1341      *      buffer.
1342    */
1343 
1344   unsigned long   flags;
1345   struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1346 
1347   dmap->byte_counter += dmap->counts[dmap->qhead];
1348 
1349 #ifdef OS_DMA_INTR
1350   sound_dma_intr (dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
1351 #endif
1352 
1353   if (dmap->mapping_flags & DMA_MAP_MAPPED)
1354     {
1355       /* mmapped access */
1356 
1357       dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
1358       dmap->qlen++;             /* Yes increment it (don't decrement) */
1359       dmap->flags &= ~DMA_ACTIVE;
1360       dmap->counts[dmap->qhead] = dmap->fragment_size;
1361 
1362       if (!(audio_devs[dev]->flags & DMA_AUTOMODE))
1363         {
1364           audio_devs[dev]->output_block (dev, dmap->raw_buf_phys +
1365                                          dmap->qhead * dmap->fragment_size,
1366                                          dmap->counts[dmap->qhead], 1,
1367                                   !(audio_devs[dev]->flags & DMA_AUTOMODE));
1368           if (audio_devs[dev]->trigger)
1369             audio_devs[dev]->trigger (dev,
1370                         audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1371         }
1372       dmap->flags |= DMA_ACTIVE;
1373     }
1374   else if (event_type != 2)
1375     {
1376       if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
1377         {
1378           printk ("\nSound: Audio queue3 corrupted for dev%d (%d/%d)\n",
1379                   dev, dmap->qlen, dmap->nbufs);
1380           return;
1381         }
1382 
1383       dmap->qlen--;
1384       dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
1385       dmap->flags &= ~DMA_ACTIVE;
1386 
1387       if (event_type == 1 && dmap->qlen < 1)
1388         {
1389           dmap->underrun_count++;
1390           /* Ignore underrun. Just move the tail pointer forward and go */
1391           if (dmap->closing)
1392             {
1393               polish_buffers (dmap);
1394               audio_devs[dev]->halt_xfer (dev);
1395             }
1396           else
1397             {
1398               dmap->qlen++;
1399               dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1400 
1401               if (!(dmap->flags & DMA_EMPTY))
1402                 polish_buffers (dmap);
1403 
1404               dmap->cfrag = -1;
1405               dmap->flags |= DMA_EMPTY;
1406             }
1407         }
1408 
1409       if (dmap->qlen)
1410         {
1411           if (!(audio_devs[dev]->flags & DMA_AUTOMODE))
1412             {
1413               audio_devs[dev]->output_block (dev, dmap->raw_buf_phys +
1414                                           dmap->qhead * dmap->fragment_size,
1415                                              dmap->counts[dmap->qhead], 1,
1416                                   !(audio_devs[dev]->flags & DMA_AUTOMODE));
1417               if (audio_devs[dev]->trigger)
1418                 audio_devs[dev]->trigger (dev,
1419                         audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1420             }
1421           dmap->flags |= DMA_ACTIVE;
1422         }
1423     }                           /* event_type != 2 */
1424 
1425   save_flags (flags);
1426   cli ();
1427   if ((out_sleep_flag[dev].mode & WK_SLEEP))
1428     {
1429       {
1430         out_sleep_flag[dev].mode = WK_WAKEUP;
1431         module_wake_up (&out_sleeper[dev]);
1432       };
1433     }
1434   restore_flags (flags);
1435 }
1436 
1437 void
1438 DMAbuf_inputintr (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1439 {
1440   unsigned long   flags;
1441   struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
1442 
1443   dmap->byte_counter += dmap->fragment_size;
1444 
1445 #ifdef OS_DMA_INTR
1446   sound_dma_intr (dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
1447 #endif
1448 
1449   if (dmap->mapping_flags & DMA_MAP_MAPPED)
1450     {
1451       dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1452       dmap->qlen++;
1453 
1454       if (!(audio_devs[dev]->flags & DMA_AUTOMODE))
1455         {
1456           audio_devs[dev]->start_input (dev, dmap->raw_buf_phys +
1457                                         dmap->qtail * dmap->fragment_size,
1458                                         dmap->fragment_size, 1,
1459                                   !(audio_devs[dev]->flags & DMA_AUTOMODE));
1460           if (audio_devs[dev]->trigger)
1461             audio_devs[dev]->trigger (dev,
1462                         audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1463         }
1464 
1465       dmap->flags |= DMA_ACTIVE;
1466     }
1467   else if (dmap->qlen == (dmap->nbufs - 1))
1468     {
1469       printk ("Sound: Recording overrun\n");
1470       dmap->underrun_count++;
1471 
1472       if (audio_devs[dev]->flags & DMA_AUTOMODE)
1473         {
1474           /* Force restart on next write */
1475           if ((audio_devs[dev]->flags & DMA_DUPLEX) &&
1476               audio_devs[dev]->halt_input)
1477             audio_devs[dev]->halt_input (dev);
1478           else
1479             audio_devs[dev]->halt_xfer (dev);
1480 
1481           dmap->flags &= ~DMA_ACTIVE;
1482           if (audio_devs[dev]->flags & DMA_AUTOMODE)
1483             dmap->flags |= DMA_RESTART;
1484           else
1485             dmap->flags &= ~DMA_RESTART;
1486         }
1487     }
1488   else
1489     {
1490       dmap->qlen++;
1491       if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
1492         printk ("\nSound: Audio queue4 corrupted for dev%d (%d/%d)\n",
1493                 dev, dmap->qlen, dmap->nbufs);
1494       dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1495     }
1496 
1497   if (!(audio_devs[dev]->flags & DMA_AUTOMODE))
1498     {
1499       audio_devs[dev]->start_input (dev, dmap->raw_buf_phys +
1500                                     dmap->qtail * dmap->fragment_size,
1501                                     dmap->fragment_size, 1,
1502                                   !(audio_devs[dev]->flags & DMA_AUTOMODE));
1503       if (audio_devs[dev]->trigger)
1504         audio_devs[dev]->trigger (dev,
1505                         audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1506     }
1507 
1508   dmap->flags |= DMA_ACTIVE;
1509 
1510   save_flags (flags);
1511   cli ();
1512   if ((in_sleep_flag[dev].mode & WK_SLEEP))
1513     {
1514       {
1515         in_sleep_flag[dev].mode = WK_WAKEUP;
1516         module_wake_up (&in_sleeper[dev]);
1517       };
1518     }
1519   restore_flags (flags);
1520 }
1521 
1522 int
1523 DMAbuf_open_dma (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1524 {
1525   int             chan = audio_devs[dev]->dmachan1;
1526   int             err;
1527   unsigned long   flags;
1528 
1529   if ((err = open_dmap (dev, OPEN_READWRITE, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1)) < 0)
1530     {
1531       return -EBUSY;
1532     }
1533   dma_init_buffers (dev, audio_devs[dev]->dmap_out);
1534   audio_devs[dev]->dmap_out->flags |= DMA_ALLOC_DONE;
1535   audio_devs[dev]->dmap_out->fragment_size = audio_devs[dev]->buffsize;
1536   /* reorganize_buffers (dev, audio_devs[dev]->dmap_out); */
1537 
1538   if (audio_devs[dev]->flags & DMA_DUPLEX)
1539     {
1540       if ((err = open_dmap (dev, OPEN_READWRITE, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2)) < 0)
1541         {
1542           printk ("Unable to grab DMA%d for the audio driver\n",
1543                   audio_devs[dev]->dmachan2);
1544           close_dmap (dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
1545           return -EBUSY;
1546         }
1547       dma_init_buffers (dev, audio_devs[dev]->dmap_in);
1548       audio_devs[dev]->dmap_in->flags |= DMA_ALLOC_DONE;
1549       audio_devs[dev]->dmap_in->fragment_size = audio_devs[dev]->buffsize;
1550       /* reorganize_buffers (dev, audio_devs[dev]->dmap_in); */
1551     }
1552   else
1553     {
1554       audio_devs[dev]->dmap_in = audio_devs[dev]->dmap_out;
1555       audio_devs[dev]->dmachan2 = audio_devs[dev]->dmachan1;
1556     }
1557 
1558 
1559   save_flags (flags);
1560   cli ();
1561   disable_dma (chan);
1562   clear_dma_ff (chan);
1563   restore_flags (flags);
1564 
1565   return 0;
1566 }
1567 
1568 void
1569 DMAbuf_close_dma (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1570 {
1571   DMAbuf_reset_dma (dev);
1572   close_dmap (dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
1573 
1574   if (audio_devs[dev]->flags & DMA_DUPLEX)
1575     close_dmap (dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
1576 
1577 }
1578 
1579 void
1580 DMAbuf_reset_dma (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1581 {
1582 }
1583 
1584 int
1585 DMAbuf_select (int dev, struct fileinfo *file, int sel_type, select_table_handle * wait)
     /* [previous][next][first][last][top][bottom][index][help] */
1586 {
1587   struct dma_buffparms *dmap;
1588   unsigned long   flags;
1589 
1590   switch (sel_type)
1591     {
1592     case SEL_IN:
1593       dmap = audio_devs[dev]->dmap_in;
1594 
1595       if (dmap->mapping_flags & DMA_MAP_MAPPED)
1596         {
1597           if (dmap->qlen)
1598             return 1;
1599 
1600           save_flags (flags);
1601           cli ();
1602           in_sleep_flag[dev].mode = WK_SLEEP;
1603           module_select_wait (&in_sleeper[dev], wait);
1604           restore_flags (flags);
1605           return 0;
1606         }
1607 
1608       if (dmap->dma_mode != DMODE_INPUT)
1609         {
1610           if ((audio_devs[dev]->flags & DMA_DUPLEX) && !dmap->qlen &&
1611               audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT &&
1612               audio_devs[dev]->go)
1613             {
1614               unsigned long   flags;
1615 
1616               save_flags (flags);
1617               cli ();
1618               activate_recording (dev, dmap);
1619               restore_flags (flags);
1620             }
1621           return 0;
1622         }
1623 
1624       if (!dmap->qlen)
1625         {
1626           save_flags (flags);
1627           cli ();
1628           in_sleep_flag[dev].mode = WK_SLEEP;
1629           module_select_wait (&in_sleeper[dev], wait);
1630           restore_flags (flags);
1631           return 0;
1632         }
1633       return 1;
1634       break;
1635 
1636     case SEL_OUT:
1637       dmap = audio_devs[dev]->dmap_out;
1638 
1639       if (dmap->mapping_flags & DMA_MAP_MAPPED)
1640         {
1641           if (dmap->qlen)
1642             return 1;
1643 
1644           save_flags (flags);
1645           cli ();
1646           out_sleep_flag[dev].mode = WK_SLEEP;
1647           module_select_wait (&out_sleeper[dev], wait);
1648           restore_flags (flags);
1649           return 0;
1650         }
1651 
1652       if (dmap->dma_mode == DMODE_INPUT)
1653         {
1654           return 0;
1655         }
1656 
1657       if (dmap->dma_mode == DMODE_NONE)
1658         {
1659           return 1;
1660         }
1661 
1662       if (!space_in_queue (dev))
1663         {
1664           save_flags (flags);
1665           cli ();
1666           out_sleep_flag[dev].mode = WK_SLEEP;
1667           module_select_wait (&out_sleeper[dev], wait);
1668           restore_flags (flags);
1669           return 0;
1670         }
1671       return 1;
1672       break;
1673 
1674     case SEL_EX:
1675       return 0;
1676     }
1677 
1678   return 0;
1679 }
1680 
1681 
1682 #else /* CONFIG_AUDIO */
1683 /*
1684  * Stub versions if audio services not included
1685  */
1686 
1687 int
1688 DMAbuf_open (int dev, int mode)
     /* [previous][next][first][last][top][bottom][index][help] */
1689 {
1690   return -ENXIO;
1691 }
1692 
1693 int
1694 DMAbuf_release (int dev, int mode)
     /* [previous][next][first][last][top][bottom][index][help] */
1695 {
1696   return 0;
1697 }
1698 
1699 int
1700 DMAbuf_getwrbuffer (int dev, char **buf, int *size, int dontblock)
     /* [previous][next][first][last][top][bottom][index][help] */
1701 {
1702   return -EIO;
1703 }
1704 
1705 int
1706 DMAbuf_getrdbuffer (int dev, char **buf, int *len, int dontblock)
     /* [previous][next][first][last][top][bottom][index][help] */
1707 {
1708   return -EIO;
1709 }
1710 
1711 int
1712 DMAbuf_rmchars (int dev, int buff_no, int c)
     /* [previous][next][first][last][top][bottom][index][help] */
1713 {
1714   return -EIO;
1715 }
1716 
1717 int
1718 DMAbuf_start_output (int dev, int buff_no, int l)
     /* [previous][next][first][last][top][bottom][index][help] */
1719 {
1720   return -EIO;
1721 }
1722 
1723 int
1724 DMAbuf_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
     /* [previous][next][first][last][top][bottom][index][help] */
1725 {
1726   return -EIO;
1727 }
1728 
1729 long
1730 DMAbuf_init (long mem_start)
     /* [previous][next][first][last][top][bottom][index][help] */
1731 {
1732   return mem_start;
1733 }
1734 
1735 int
1736 DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
     /* [previous][next][first][last][top][bottom][index][help] */
1737 {
1738   return -EIO;
1739 }
1740 
1741 int
1742 DMAbuf_open_dma (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1743 {
1744   return -ENXIO;
1745 }
1746 
1747 void
1748 DMAbuf_close_dma (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1749 {
1750   return;
1751 }
1752 
1753 void
1754 DMAbuf_reset_dma (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1755 {
1756   return;
1757 }
1758 
1759 void
1760 DMAbuf_inputintr (int dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1761 {
1762   return;
1763 }
1764 
1765 void
1766 DMAbuf_outputintr (int dev, int underrun_flag)
     /* [previous][next][first][last][top][bottom][index][help] */
1767 {
1768   return;
1769 }
1770 #endif

/* [previous][next][first][last][top][bottom][index][help] */