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

DEFINITIONS
