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

DEFINITIONS
