drivers/sound/dmabuf.c

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

DEFINITIONS
