sound/oss/audio.c

   1 /*
   2  * sound/audio.c
   3  *
   4  * Device file manager for /dev/audio
   5  */
   6
   7 /*
   8  * Copyright (C) by Hannu Savolainen 1993-1997
   9  *
  10  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  11  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  12  * for more info.
  13  */
  14 /*
  15  * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
  16  * Thomas Sailer   : moved several static variables into struct audio_operations
  17  *                   (which is grossly misnamed btw.) because they have the same
  18  *                   lifetime as the rest in there and dynamic allocation saves
  19  *                   12k or so
  20  * Thomas Sailer   : use more logical O_NONBLOCK semantics
  21  * Daniel Rodriksson: reworked the use of the device specific copy_user
  22  *                    still generic
  23  * Horst von Brand:  Add missing #include <linux/string.h>
  24  * Chris Rankin    : Update the module-usage counter for the coprocessor,
  25  *                   and decrement the counters again if we cannot open
  26  *                   the audio device.
  27  */
  28
  29 #include <linux/stddef.h>
  30 #include <linux/string.h>
  31 #include <linux/kmod.h>
  32
  33 #include "sound_config.h"
  34 #include "ulaw.h"
  35 #include "coproc.h"
  36
  37 #define NEUTRAL8        0x80
  38 #define NEUTRAL16       0x00
  39
  40
  41 int             dma_ioctl(int dev, unsigned int cmd, caddr_t arg);
  42
  43 static int set_format(int dev, int fmt)
  44 {
  45         if (fmt != AFMT_QUERY)
  46         {
  47                 audio_devs[dev]->local_conversion = 0;
  48
  49                 if (!(audio_devs[dev]->format_mask & fmt))      /* Not supported */
  50                 {
  51                         if (fmt == AFMT_MU_LAW)
  52                         {
  53                                 fmt = AFMT_U8;
  54                                 audio_devs[dev]->local_conversion = CNV_MU_LAW;
  55                         }
  56                         else
  57                                 fmt = AFMT_U8;  /* This is always supported */
  58                 }
  59                 audio_devs[dev]->audio_format = audio_devs[dev]->d->set_bits(dev, fmt);
  60                 audio_devs[dev]->local_format = fmt;
  61         }
  62         else
  63                 return audio_devs[dev]->local_format;
  64
  65         if (audio_devs[dev]->local_conversion)
  66                 return audio_devs[dev]->local_conversion;
  67         else
  68                 return audio_devs[dev]->local_format;
  69 }
  70
  71 int audio_open(int dev, struct file *file)
  72 {
  73         int ret;
  74         int bits;
  75         int dev_type = dev & 0x0f;
  76         int mode = translate_mode(file);
  77         const struct audio_driver *driver;
  78         const struct coproc_operations *coprocessor;
  79
  80         dev = dev >> 4;
  81
  82         if (dev_type == SND_DEV_DSP16)
  83                 bits = 16;
  84         else
  85                 bits = 8;
  86
  87         if (dev < 0 || dev >= num_audiodevs)
  88                 return -ENXIO;
  89
  90         driver = audio_devs[dev]->d;
  91
  92         if (!try_module_get(driver->owner))
  93                 return -ENODEV;
  94
  95         if ((ret = DMAbuf_open(dev, mode)) < 0)
  96                 goto error_1;
  97
  98         if ( (coprocessor = audio_devs[dev]->coproc) != NULL ) {
  99                 if (!try_module_get(coprocessor->owner))
 100                         goto error_2;
 101
 102                 if ((ret = coprocessor->open(coprocessor->devc, COPR_PCM)) < 0) {
 103                         printk(KERN_WARNING "Sound: Can't access coprocessor device\n");
 104                         goto error_3;
 105                 }
 106         }
 107
 108         audio_devs[dev]->local_conversion = 0;
 109
 110         if (dev_type == SND_DEV_AUDIO)
 111                 set_format(dev, AFMT_MU_LAW);
 112         else
 113                 set_format(dev, bits);
 114
 115         audio_devs[dev]->audio_mode = AM_NONE;
 116
 117         return 0;
 118
 119         /*
 120          * Clean-up stack: this is what needs (un)doing if
 121          * we can't open the audio device ...
 122          */
 123         error_3:
 124         module_put(coprocessor->owner);
 125
 126         error_2:
 127         DMAbuf_release(dev, mode);
 128
 129         error_1:
 130         module_put(driver->owner);
 131
 132         return ret;
 133 }
 134
 135 static void sync_output(int dev)
 136 {
 137         int             p, i;
 138         int             l;
 139         struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
 140
 141         if (dmap->fragment_size <= 0)
 142                 return;
 143         dmap->flags |= DMA_POST;
 144
 145         /* Align the write pointer with fragment boundaries */
 146
 147         if ((l = dmap->user_counter % dmap->fragment_size) > 0)
 148         {
 149                 int len;
 150                 unsigned long offs = dmap->user_counter % dmap->bytes_in_use;
 151
 152                 len = dmap->fragment_size - l;
 153                 memset(dmap->raw_buf + offs, dmap->neutral_byte, len);
 154                 DMAbuf_move_wrpointer(dev, len);
 155         }
 156
 157         /*
 158          * Clean all unused buffer fragments.
 159          */
 160
 161         p = dmap->qtail;
 162         dmap->flags |= DMA_POST;
 163
 164         for (i = dmap->qlen + 1; i < dmap->nbufs; i++)
 165         {
 166                 p = (p + 1) % dmap->nbufs;
 167                 if (((dmap->raw_buf + p * dmap->fragment_size) + dmap->fragment_size) >
 168                         (dmap->raw_buf + dmap->buffsize))
 169                                 printk(KERN_ERR "audio: Buffer error 2\n");
 170
 171                 memset(dmap->raw_buf + p * dmap->fragment_size,
 172                         dmap->neutral_byte,
 173                         dmap->fragment_size);
 174         }
 175
 176         dmap->flags |= DMA_DIRTY;
 177 }
 178
 179 void audio_release(int dev, struct file *file)
 180 {
 181         const struct coproc_operations *coprocessor;
 182         int mode = translate_mode(file);
 183
 184         dev = dev >> 4;
 185
 186         /*
 187          * We do this in DMAbuf_release(). Why are we doing it
 188          * here? Why don't we test the file mode before setting
 189          * both flags? DMAbuf_release() does.
 190          * ...pester...pester...pester...
 191          */
 192         audio_devs[dev]->dmap_out->closing = 1;
 193         audio_devs[dev]->dmap_in->closing = 1;
 194
 195         /*
 196          * We need to make sure we allocated the dmap_out buffer
 197          * before we go mucking around with it in sync_output().
 198          */
 199         if (mode & OPEN_WRITE)
 200                 sync_output(dev);
 201
 202         if ( (coprocessor = audio_devs[dev]->coproc) != NULL ) {
 203                 coprocessor->close(coprocessor->devc, COPR_PCM);
 204                 module_put(coprocessor->owner);
 205         }
 206         DMAbuf_release(dev, mode);
 207
 208         module_put(audio_devs[dev]->d->owner);
 209 }
 210
 211 static void translate_bytes(const unsigned char *table, unsigned char *buff, int n)
 212 {
 213         unsigned long   i;
 214
 215         if (n <= 0)
 216                 return;
 217
 218         for (i = 0; i < n; ++i)
 219                 buff[i] = table[buff[i]];
 220 }
 221
 222 int audio_write(int dev, struct file *file, const char *buf, int count)
 223 {
 224         int c, p, l, buf_size, used, returned;
 225         int err;
 226         char *dma_buf;
 227
 228         dev = dev >> 4;
 229
 230         p = 0;
 231         c = count;
 232
 233         if(count < 0)
 234                 return -EINVAL;
 235
 236         if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
 237                 return -EPERM;
 238
 239         if (audio_devs[dev]->flags & DMA_DUPLEX)
 240                 audio_devs[dev]->audio_mode |= AM_WRITE;
 241         else
 242                 audio_devs[dev]->audio_mode = AM_WRITE;
 243
 244         if (!count)             /* Flush output */
 245         {
 246                   sync_output(dev);
 247                   return 0;
 248         }
 249
 250         while (c)
 251         {
 252                 if ((err = DMAbuf_getwrbuffer(dev, &dma_buf, &buf_size, !!(file->f_flags & O_NONBLOCK))) < 0)
 253                 {
 254                             /* Handle nonblocking mode */
 255                         if ((file->f_flags & O_NONBLOCK) && err == -EAGAIN)
 256                                 return p? p : -EAGAIN;  /* No more space. Return # of accepted bytes */
 257                         return err;
 258                 }
 259                 l = c;
 260
 261                 if (l > buf_size)
 262                         l = buf_size;
 263
 264                 returned = l;
 265                 used = l;
 266                 if (!audio_devs[dev]->d->copy_user)
 267                 {
 268                         if ((dma_buf + l) >
 269                                 (audio_devs[dev]->dmap_out->raw_buf + audio_devs[dev]->dmap_out->buffsize))
 270                         {
 271                                 printk(KERN_ERR "audio: Buffer error 3 (%lx,%d), (%lx, %d)\n", (long) dma_buf, l, (long) audio_devs[dev]->dmap_out->raw_buf, (int) audio_devs[dev]->dmap_out->buffsize);
 272                                 return -EDOM;
 273                         }
 274                         if (dma_buf < audio_devs[dev]->dmap_out->raw_buf)
 275                         {
 276                                 printk(KERN_ERR "audio: Buffer error 13 (%lx<%lx)\n", (long) dma_buf, (long) audio_devs[dev]->dmap_out->raw_buf);
 277                                 return -EDOM;
 278                         }
 279                         if(copy_from_user(dma_buf, &(buf)[p], l))
 280                                 return -EFAULT;
 281                 }
 282                 else audio_devs[dev]->d->copy_user (dev,
 283                                                 dma_buf, 0,
 284                                                 buf, p,
 285                                                 c, buf_size,
 286                                                 &used, &returned,
 287                                                 l);
 288                 l = returned;
 289
 290                 if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
 291                 {
 292                         translate_bytes(ulaw_dsp, (unsigned char *) dma_buf, l);
 293                 }
 294                 c -= used;
 295                 p += used;
 296                 DMAbuf_move_wrpointer(dev, l);
 297
 298         }
 299
 300         return count;
 301 }
 302
 303 int audio_read(int dev, struct file *file, char *buf, int count)
 304 {
 305         int             c, p, l;
 306         char           *dmabuf;
 307         int             buf_no;
 308
 309         dev = dev >> 4;
 310         p = 0;
 311         c = count;
 312
 313         if (!(audio_devs[dev]->open_mode & OPEN_READ))
 314                 return -EPERM;
 315
 316         if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
 317                 sync_output(dev);
 318
 319         if (audio_devs[dev]->flags & DMA_DUPLEX)
 320                 audio_devs[dev]->audio_mode |= AM_READ;
 321         else
 322                 audio_devs[dev]->audio_mode = AM_READ;
 323
 324         while(c)
 325         {
 326                 if ((buf_no = DMAbuf_getrdbuffer(dev, &dmabuf, &l, !!(file->f_flags & O_NONBLOCK))) < 0)
 327                 {
 328                         /*
 329                          *      Nonblocking mode handling. Return current # of bytes
 330                          */
 331
 332                         if (p > 0)              /* Avoid throwing away data */
 333                                 return p;       /* Return it instead */
 334
 335                         if ((file->f_flags & O_NONBLOCK) && buf_no == -EAGAIN)
 336                                 return -EAGAIN;
 337
 338                         return buf_no;
 339                 }
 340                 if (l > c)
 341                         l = c;
 342
 343                 /*
 344                  * Insert any local processing here.
 345                  */
 346
 347                 if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
 348                 {
 349                         translate_bytes(dsp_ulaw, (unsigned char *) dmabuf, l);
 350                 }
 351
 352                 {
 353                         char           *fixit = dmabuf;
 354
 355                         if(copy_to_user(&(buf)[p], fixit, l))
 356                                 return -EFAULT;
 357                 };
 358
 359                 DMAbuf_rmchars(dev, buf_no, l);
 360
 361                 p += l;
 362                 c -= l;
 363         }
 364
 365         return count - c;
 366 }
 367
 368 int audio_ioctl(int dev, struct file *file, unsigned int cmd, caddr_t arg)
 369 {
 370         int val, count;
 371         unsigned long flags;
 372         struct dma_buffparms *dmap;
 373
 374         dev = dev >> 4;
 375
 376         if (_IOC_TYPE(cmd) == 'C')      {
 377                 if (audio_devs[dev]->coproc)    /* Coprocessor ioctl */
 378                         return audio_devs[dev]->coproc->ioctl(audio_devs[dev]->coproc->devc, cmd, arg, 0);
 379                 /* else
 380                         printk(KERN_DEBUG"/dev/dsp%d: No coprocessor for this device\n", dev); */
 381                 return -ENXIO;
 382         }
 383         else switch (cmd)
 384         {
 385                 case SNDCTL_DSP_SYNC:
 386                         if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
 387                                 return 0;
 388                         if (audio_devs[dev]->dmap_out->fragment_size == 0)
 389                                 return 0;
 390                         sync_output(dev);
 391                         DMAbuf_sync(dev);
 392                         DMAbuf_reset(dev);
 393                         return 0;
 394
 395                 case SNDCTL_DSP_POST:
 396                         if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
 397                                 return 0;
 398                         if (audio_devs[dev]->dmap_out->fragment_size == 0)
 399                                 return 0;
 400                         audio_devs[dev]->dmap_out->flags |= DMA_POST | DMA_DIRTY;
 401                         sync_output(dev);
 402                         dma_ioctl(dev, SNDCTL_DSP_POST, (caddr_t) 0);
 403                         return 0;
 404
 405                 case SNDCTL_DSP_RESET:
 406                         audio_devs[dev]->audio_mode = AM_NONE;
 407                         DMAbuf_reset(dev);
 408                         return 0;
 409
 410                 case SNDCTL_DSP_GETFMTS:
 411                         val = audio_devs[dev]->format_mask | AFMT_MU_LAW;
 412                         break;
 413
 414                 case SNDCTL_DSP_SETFMT:
 415                         if (get_user(val, (int *)arg))
 416                                 return -EFAULT;
 417                         val = set_format(dev, val);
 418                         break;
 419
 420                 case SNDCTL_DSP_GETISPACE:
 421                         if (!(audio_devs[dev]->open_mode & OPEN_READ))
 422                                 return 0;
 423                         if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
 424                                 return -EBUSY;
 425                         return dma_ioctl(dev, cmd, arg);
 426
 427                 case SNDCTL_DSP_GETOSPACE:
 428                         if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
 429                                 return -EPERM;
 430                         if ((audio_devs[dev]->audio_mode & AM_READ) && !(audio_devs[dev]->flags & DMA_DUPLEX))
 431                                 return -EBUSY;
 432                         return dma_ioctl(dev, cmd, arg);
 433
 434                 case SNDCTL_DSP_NONBLOCK:
 435                         file->f_flags |= O_NONBLOCK;
 436                         return 0;
 437
 438                 case SNDCTL_DSP_GETCAPS:
 439                                 val = 1 | DSP_CAP_MMAP; /* Revision level of this ioctl() */
 440                                 if (audio_devs[dev]->flags & DMA_DUPLEX &&
 441                                         audio_devs[dev]->open_mode == OPEN_READWRITE)
 442                                         val |= DSP_CAP_DUPLEX;
 443                                 if (audio_devs[dev]->coproc)
 444                                         val |= DSP_CAP_COPROC;
 445                                 if (audio_devs[dev]->d->local_qlen)     /* Device has hidden buffers */
 446                                         val |= DSP_CAP_BATCH;
 447                                 if (audio_devs[dev]->d->trigger)        /* Supports SETTRIGGER */
 448                                         val |= DSP_CAP_TRIGGER;
 449                                 break;
 450
 451                 case SOUND_PCM_WRITE_RATE:
 452                         if (get_user(val, (int *)arg))
 453                                 return -EFAULT;
 454                         val = audio_devs[dev]->d->set_speed(dev, val);
 455                         break;
 456
 457                 case SOUND_PCM_READ_RATE:
 458                         val = audio_devs[dev]->d->set_speed(dev, 0);
 459                         break;
 460
 461                 case SNDCTL_DSP_STEREO:
 462                         if (get_user(val, (int *)arg))
 463                                 return -EFAULT;
 464                         if (val > 1 || val < 0)
 465                                 return -EINVAL;
 466                         val = audio_devs[dev]->d->set_channels(dev, val + 1) - 1;
 467                         break;
 468
 469                 case SOUND_PCM_WRITE_CHANNELS:
 470                         if (get_user(val, (int *)arg))
 471                                 return -EFAULT;
 472                         val = audio_devs[dev]->d->set_channels(dev, val);
 473                         break;
 474
 475                 case SOUND_PCM_READ_CHANNELS:
 476                         val = audio_devs[dev]->d->set_channels(dev, 0);
 477                         break;
 478
 479                 case SOUND_PCM_READ_BITS:
 480                         val = audio_devs[dev]->d->set_bits(dev, 0);
 481                         break;
 482
 483                 case SNDCTL_DSP_SETDUPLEX:
 484                         if (audio_devs[dev]->open_mode != OPEN_READWRITE)
 485                                 return -EPERM;
 486                         return (audio_devs[dev]->flags & DMA_DUPLEX) ? 0 : -EIO;
 487
 488                 case SNDCTL_DSP_PROFILE:
 489                         if (get_user(val, (int *)arg))
 490                                 return -EFAULT;
 491                         if (audio_devs[dev]->open_mode & OPEN_WRITE)
 492                                 audio_devs[dev]->dmap_out->applic_profile = val;
 493                         if (audio_devs[dev]->open_mode & OPEN_READ)
 494                                 audio_devs[dev]->dmap_in->applic_profile = val;
 495                         return 0;
 496
 497                 case SNDCTL_DSP_GETODELAY:
 498                         dmap = audio_devs[dev]->dmap_out;
 499                         if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
 500                                 return -EINVAL;
 501                         if (!(dmap->flags & DMA_ALLOC_DONE))
 502                         {
 503                                 val=0;
 504                                 break;
 505                         }
 506
 507                         spin_lock_irqsave(&dmap->lock,flags);
 508                         /* Compute number of bytes that have been played */
 509                         count = DMAbuf_get_buffer_pointer (dev, dmap, DMODE_OUTPUT);
 510                         if (count < dmap->fragment_size && dmap->qhead != 0)
 511                                 count += dmap->bytes_in_use;    /* Pointer wrap not handled yet */
 512                         count += dmap->byte_counter;
 513
 514                         /* Substract current count from the number of bytes written by app */
 515                         count = dmap->user_counter - count;
 516                         if (count < 0)
 517                                 count = 0;
 518                         spin_unlock_irqrestore(&dmap->lock,flags);
 519                         val = count;
 520                         break;
 521
 522                 default:
 523                         return dma_ioctl(dev, cmd, arg);
 524         }
 525         return put_user(val, (int *)arg);
 526 }
 527
 528 void audio_init_devices(void)
 529 {
 530         /*
 531          * NOTE! This routine could be called several times during boot.
 532          */
 533 }
 534
 535 void reorganize_buffers(int dev, struct dma_buffparms *dmap, int recording)
 536 {
 537         /*
 538          * This routine breaks the physical device buffers to logical ones.
 539          */
 540
 541         struct audio_operations *dsp_dev = audio_devs[dev];
 542
 543         unsigned i, n;
 544         unsigned sr, nc, sz, bsz;
 545
 546         sr = dsp_dev->d->set_speed(dev, 0);
 547         nc = dsp_dev->d->set_channels(dev, 0);
 548         sz = dsp_dev->d->set_bits(dev, 0);
 549
 550         if (sz == 8)
 551                 dmap->neutral_byte = NEUTRAL8;
 552         else
 553                 dmap->neutral_byte = NEUTRAL16;
 554
 555         if (sr < 1 || nc < 1 || sz < 1)
 556         {
 557 /*              printk(KERN_DEBUG "Warning: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%d\n", dev, sr, nc, sz);*/
 558                 sr = DSP_DEFAULT_SPEED;
 559                 nc = 1;
 560                 sz = 8;
 561         }
 562
 563         sz = sr * nc * sz;
 564
 565         sz /= 8;                /* #bits -> #bytes */
 566         dmap->data_rate = sz;
 567
 568         if (!dmap->needs_reorg)
 569                 return;
 570         dmap->needs_reorg = 0;
 571
 572         if (dmap->fragment_size == 0)
 573         {
 574                 /* Compute the fragment size using the default algorithm */
 575
 576                 /*
 577                  * Compute a buffer size for time not exceeding 1 second.
 578                  * Usually this algorithm gives a buffer size for 0.5 to 1.0 seconds
 579                  * of sound (using the current speed, sample size and #channels).
 580                  */
 581
 582                 bsz = dmap->buffsize;
 583                 while (bsz > sz)
 584                         bsz /= 2;
 585
 586                 if (bsz == dmap->buffsize)
 587                         bsz /= 2;       /* Needs at least 2 buffers */
 588
 589                 /*
 590                  *    Split the computed fragment to smaller parts. After 3.5a9
 591                  *      the default subdivision is 4 which should give better
 592                  *      results when recording.
 593                  */
 594
 595                 if (dmap->subdivision == 0)     /* Not already set */
 596                 {
 597                         dmap->subdivision = 4;  /* Init to the default value */
 598
 599                         if ((bsz / dmap->subdivision) > 4096)
 600                                 dmap->subdivision *= 2;
 601                         if ((bsz / dmap->subdivision) < 4096)
 602                                 dmap->subdivision = 1;
 603                 }
 604                 bsz /= dmap->subdivision;
 605
 606                 if (bsz < 16)
 607                         bsz = 16;       /* Just a sanity check */
 608
 609                 dmap->fragment_size = bsz;
 610         }
 611         else
 612         {
 613                 /*
 614                  * The process has specified the buffer size with SNDCTL_DSP_SETFRAGMENT or
 615                  * the buffer size computation has already been done.
 616                  */
 617                 if (dmap->fragment_size > (dmap->buffsize / 2))
 618                         dmap->fragment_size = (dmap->buffsize / 2);
 619                 bsz = dmap->fragment_size;
 620         }
 621
 622         if (audio_devs[dev]->min_fragment)
 623                 if (bsz < (1 << audio_devs[dev]->min_fragment))
 624                         bsz = 1 << audio_devs[dev]->min_fragment;
 625         if (audio_devs[dev]->max_fragment)
 626                 if (bsz > (1 << audio_devs[dev]->max_fragment))
 627                         bsz = 1 << audio_devs[dev]->max_fragment;
 628         bsz &= ~0x07;           /* Force size which is multiple of 8 bytes */
 629 #ifdef OS_DMA_ALIGN_CHECK
 630         OS_DMA_ALIGN_CHECK(bsz);
 631 #endif
 632
 633         n = dmap->buffsize / bsz;
 634         if (n > MAX_SUB_BUFFERS)
 635                 n = MAX_SUB_BUFFERS;
 636         if (n > dmap->max_fragments)
 637                 n = dmap->max_fragments;
 638
 639         if (n < 2)
 640         {
 641                 n = 2;
 642                 bsz /= 2;
 643         }
 644         dmap->nbufs = n;
 645         dmap->bytes_in_use = n * bsz;
 646         dmap->fragment_size = bsz;
 647         dmap->max_byte_counter = (dmap->data_rate * 60 * 60) +
 648                         dmap->bytes_in_use;     /* Approximately one hour */
 649
 650         if (dmap->raw_buf)
 651         {
 652                 memset(dmap->raw_buf, dmap->neutral_byte, dmap->bytes_in_use);
 653         }
 654
 655         for (i = 0; i < dmap->nbufs; i++)
 656         {
 657                 dmap->counts[i] = 0;
 658         }
 659
 660         dmap->flags |= DMA_ALLOC_DONE | DMA_EMPTY;
 661 }
 662
 663 static int dma_subdivide(int dev, struct dma_buffparms *dmap, int fact)
 664 {
 665         if (fact == 0)
 666         {
 667                 fact = dmap->subdivision;
 668                 if (fact == 0)
 669                         fact = 1;
 670                 return fact;
 671         }
 672         if (dmap->subdivision != 0 || dmap->fragment_size)      /* Too late to change */
 673                 return -EINVAL;
 674
 675         if (fact > MAX_REALTIME_FACTOR)
 676                 return -EINVAL;
 677
 678         if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
 679                 return -EINVAL;
 680
 681         dmap->subdivision = fact;
 682         return fact;
 683 }
 684
 685 static int dma_set_fragment(int dev, struct dma_buffparms *dmap, int fact)
 686 {
 687         int bytes, count;
 688
 689         if (fact == 0)
 690                 return -EIO;
 691
 692         if (dmap->subdivision != 0 ||
 693             dmap->fragment_size)        /* Too late to change */
 694                 return -EINVAL;
 695
 696         bytes = fact & 0xffff;
 697         count = (fact >> 16) & 0x7fff;
 698
 699         if (count == 0)
 700                 count = MAX_SUB_BUFFERS;
 701         else if (count < MAX_SUB_BUFFERS)
 702                 count++;
 703
 704         if (bytes < 4 || bytes > 17)    /* <16 || > 512k */
 705                 return -EINVAL;
 706
 707         if (count < 2)
 708                 return -EINVAL;
 709
 710         if (audio_devs[dev]->min_fragment > 0)
 711                 if (bytes < audio_devs[dev]->min_fragment)
 712                         bytes = audio_devs[dev]->min_fragment;
 713
 714         if (audio_devs[dev]->max_fragment > 0)
 715                 if (bytes > audio_devs[dev]->max_fragment)
 716                         bytes = audio_devs[dev]->max_fragment;
 717
 718 #ifdef OS_DMA_MINBITS
 719         if (bytes < OS_DMA_MINBITS)
 720                 bytes = OS_DMA_MINBITS;
 721 #endif
 722
 723         dmap->fragment_size = (1 << bytes);
 724         dmap->max_fragments = count;
 725
 726         if (dmap->fragment_size > dmap->buffsize)
 727                 dmap->fragment_size = dmap->buffsize;
 728
 729         if (dmap->fragment_size == dmap->buffsize &&
 730             audio_devs[dev]->flags & DMA_AUTOMODE)
 731                 dmap->fragment_size /= 2;       /* Needs at least 2 buffers */
 732
 733         dmap->subdivision = 1;  /* Disable SNDCTL_DSP_SUBDIVIDE */
 734         return bytes | ((count - 1) << 16);
 735 }
 736
 737 int dma_ioctl(int dev, unsigned int cmd, caddr_t arg)
 738 {
 739         struct dma_buffparms *dmap_out = audio_devs[dev]->dmap_out;
 740         struct dma_buffparms *dmap_in = audio_devs[dev]->dmap_in;
 741         struct dma_buffparms *dmap;
 742         audio_buf_info info;
 743         count_info cinfo;
 744         int fact, ret, changed, bits, count, err;
 745         unsigned long flags;
 746
 747         switch (cmd)
 748         {
 749                 case SNDCTL_DSP_SUBDIVIDE:
 750                         ret = 0;
 751                         if (get_user(fact, (int *)arg))
 752                                 return -EFAULT;
 753                         if (audio_devs[dev]->open_mode & OPEN_WRITE)
 754                                 ret = dma_subdivide(dev, dmap_out, fact);
 755                         if (ret < 0)
 756                                 return ret;
 757                         if (audio_devs[dev]->open_mode != OPEN_WRITE ||
 758                                 (audio_devs[dev]->flags & DMA_DUPLEX &&
 759                                         audio_devs[dev]->open_mode & OPEN_READ))
 760                                 ret = dma_subdivide(dev, dmap_in, fact);
 761                         if (ret < 0)
 762                                 return ret;
 763                         break;
 764
 765                 case SNDCTL_DSP_GETISPACE:
 766                 case SNDCTL_DSP_GETOSPACE:
 767                         dmap = dmap_out;
 768                         if (cmd == SNDCTL_DSP_GETISPACE && !(audio_devs[dev]->open_mode & OPEN_READ))
 769                                 return -EINVAL;
 770                         if (cmd == SNDCTL_DSP_GETOSPACE && !(audio_devs[dev]->open_mode & OPEN_WRITE))
 771                                 return -EINVAL;
 772                         if (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
 773                                 dmap = dmap_in;
 774                         if (dmap->mapping_flags & DMA_MAP_MAPPED)
 775                                 return -EINVAL;
 776                         if (!(dmap->flags & DMA_ALLOC_DONE))
 777                                 reorganize_buffers(dev, dmap, (cmd == SNDCTL_DSP_GETISPACE));
 778                         info.fragstotal = dmap->nbufs;
 779                         if (cmd == SNDCTL_DSP_GETISPACE)
 780                                 info.fragments = dmap->qlen;
 781                         else
 782                         {
 783                                 if (!DMAbuf_space_in_queue(dev))
 784                                         info.fragments = 0;
 785                                 else
 786                                 {
 787                                         info.fragments = DMAbuf_space_in_queue(dev);
 788                                         if (audio_devs[dev]->d->local_qlen)
 789                                         {
 790                                                 int tmp = audio_devs[dev]->d->local_qlen(dev);
 791                                                 if (tmp && info.fragments)
 792                                                         tmp--;  /*
 793                                                                  * This buffer has been counted twice
 794                                                                  */
 795                                                 info.fragments -= tmp;
 796                                         }
 797                                 }
 798                         }
 799                         if (info.fragments < 0)
 800                                 info.fragments = 0;
 801                         else if (info.fragments > dmap->nbufs)
 802                                 info.fragments = dmap->nbufs;
 803
 804                         info.fragsize = dmap->fragment_size;
 805                         info.bytes = info.fragments * dmap->fragment_size;
 806
 807                         if (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
 808                                 info.bytes -= dmap->counts[dmap->qhead];
 809                         else
 810                         {
 811                                 info.fragments = info.bytes / dmap->fragment_size;
 812                                 info.bytes -= dmap->user_counter % dmap->fragment_size;
 813                         }
 814                         if (copy_to_user(arg, &info, sizeof(info)))
 815                                 return -EFAULT;
 816                         return 0;
 817
 818                 case SNDCTL_DSP_SETTRIGGER:
 819                         if (get_user(bits, (int *)arg))
 820                                 return -EFAULT;
 821                         bits &= audio_devs[dev]->open_mode;
 822                         if (audio_devs[dev]->d->trigger == NULL)
 823                                 return -EINVAL;
 824                         if (!(audio_devs[dev]->flags & DMA_DUPLEX) && (bits & PCM_ENABLE_INPUT) &&
 825                                 (bits & PCM_ENABLE_OUTPUT))
 826                                 return -EINVAL;
 827
 828                         if (bits & PCM_ENABLE_INPUT)
 829                         {
 830                                 spin_lock_irqsave(&dmap_in->lock,flags);
 831                                 changed = (audio_devs[dev]->enable_bits ^ bits) & PCM_ENABLE_INPUT;
 832                                 if (changed && audio_devs[dev]->go)
 833                                 {
 834                                         reorganize_buffers(dev, dmap_in, 1);
 835                                         if ((err = audio_devs[dev]->d->prepare_for_input(dev,
 836                                                      dmap_in->fragment_size, dmap_in->nbufs)) < 0) {
 837                                                 spin_unlock_irqrestore(&dmap_in->lock,flags);
 838                                                 return -err;
 839                                         }
 840                                         dmap_in->dma_mode = DMODE_INPUT;
 841                                         audio_devs[dev]->enable_bits |= PCM_ENABLE_INPUT;
 842                                         DMAbuf_activate_recording(dev, dmap_in);
 843                                 } else
 844                                         audio_devs[dev]->enable_bits &= ~PCM_ENABLE_INPUT;
 845                                 spin_unlock_irqrestore(&dmap_in->lock,flags);
 846                         }
 847                         if (bits & PCM_ENABLE_OUTPUT)
 848                         {
 849                                 spin_lock_irqsave(&dmap_out->lock,flags);
 850                                 changed = (audio_devs[dev]->enable_bits ^ bits) & PCM_ENABLE_OUTPUT;
 851                                 if (changed &&
 852                                     (dmap_out->mapping_flags & DMA_MAP_MAPPED || dmap_out->qlen > 0) &&
 853                                     audio_devs[dev]->go)
 854                                 {
 855                                         if (!(dmap_out->flags & DMA_ALLOC_DONE))
 856                                                 reorganize_buffers(dev, dmap_out, 0);
 857                                         dmap_out->dma_mode = DMODE_OUTPUT;
 858                                         audio_devs[dev]->enable_bits |= PCM_ENABLE_OUTPUT;
 859                                         dmap_out->counts[dmap_out->qhead] = dmap_out->fragment_size;
 860                                         DMAbuf_launch_output(dev, dmap_out);
 861                                 } else
 862                                         audio_devs[dev]->enable_bits &= ~PCM_ENABLE_OUTPUT;
 863                                 spin_unlock_irqrestore(&dmap_out->lock,flags);
 864                         }
 865 #if 0
 866                         if (changed && audio_devs[dev]->d->trigger)
 867                                 audio_devs[dev]->d->trigger(dev, bits * audio_devs[dev]->go);
 868 #endif
 869                         /* Falls through... */
 870
 871                 case SNDCTL_DSP_GETTRIGGER:
 872                         ret = audio_devs[dev]->enable_bits;
 873                         break;
 874
 875                 case SNDCTL_DSP_SETSYNCRO:
 876                         if (!audio_devs[dev]->d->trigger)
 877                                 return -EINVAL;
 878                         audio_devs[dev]->d->trigger(dev, 0);
 879                         audio_devs[dev]->go = 0;
 880                         return 0;
 881
 882                 case SNDCTL_DSP_GETIPTR:
 883                         if (!(audio_devs[dev]->open_mode & OPEN_READ))
 884                                 return -EINVAL;
 885                         spin_lock_irqsave(&dmap_in->lock,flags);
 886                         cinfo.bytes = dmap_in->byte_counter;
 887                         cinfo.ptr = DMAbuf_get_buffer_pointer(dev, dmap_in, DMODE_INPUT) & ~3;
 888                         if (cinfo.ptr < dmap_in->fragment_size && dmap_in->qtail != 0)
 889                                 cinfo.bytes += dmap_in->bytes_in_use;   /* Pointer wrap not handled yet */
 890                         cinfo.blocks = dmap_in->qlen;
 891                         cinfo.bytes += cinfo.ptr;
 892                         if (dmap_in->mapping_flags & DMA_MAP_MAPPED)
 893                                 dmap_in->qlen = 0;      /* Reset interrupt counter */
 894                         spin_unlock_irqrestore(&dmap_in->lock,flags);
 895                         if (copy_to_user(arg, &cinfo, sizeof(cinfo)))
 896                                 return -EFAULT;
 897                         return 0;
 898
 899                 case SNDCTL_DSP_GETOPTR:
 900                         if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
 901                                 return -EINVAL;
 902
 903                         spin_lock_irqsave(&dmap_out->lock,flags);
 904                         cinfo.bytes = dmap_out->byte_counter;
 905                         cinfo.ptr = DMAbuf_get_buffer_pointer(dev, dmap_out, DMODE_OUTPUT) & ~3;
 906                         if (cinfo.ptr < dmap_out->fragment_size && dmap_out->qhead != 0)
 907                                 cinfo.bytes += dmap_out->bytes_in_use;  /* Pointer wrap not handled yet */
 908                         cinfo.blocks = dmap_out->qlen;
 909                         cinfo.bytes += cinfo.ptr;
 910                         if (dmap_out->mapping_flags & DMA_MAP_MAPPED)
 911                                 dmap_out->qlen = 0;     /* Reset interrupt counter */
 912                         spin_unlock_irqrestore(&dmap_out->lock,flags);
 913                         if (copy_to_user(arg, &cinfo, sizeof(cinfo)))
 914                                 return -EFAULT;
 915                         return 0;
 916
 917                 case SNDCTL_DSP_GETODELAY:
 918                         if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
 919                                 return -EINVAL;
 920                         if (!(dmap_out->flags & DMA_ALLOC_DONE))
 921                         {
 922                                 ret=0;
 923                                 break;
 924                         }
 925                         spin_lock_irqsave(&dmap_out->lock,flags);
 926                         /* Compute number of bytes that have been played */
 927                         count = DMAbuf_get_buffer_pointer (dev, dmap_out, DMODE_OUTPUT);
 928                         if (count < dmap_out->fragment_size && dmap_out->qhead != 0)
 929                                 count += dmap_out->bytes_in_use;        /* Pointer wrap not handled yet */
 930                         count += dmap_out->byte_counter;
 931                         /* Substract current count from the number of bytes written by app */
 932                         count = dmap_out->user_counter - count;
 933                         if (count < 0)
 934                                 count = 0;
 935                         spin_unlock_irqrestore(&dmap_out->lock,flags);
 936                         ret = count;
 937                         break;
 938
 939                 case SNDCTL_DSP_POST:
 940                         if (audio_devs[dev]->dmap_out->qlen > 0)
 941                                 if (!(audio_devs[dev]->dmap_out->flags & DMA_ACTIVE))
 942                                         DMAbuf_launch_output(dev, audio_devs[dev]->dmap_out);
 943                         return 0;
 944
 945                 case SNDCTL_DSP_GETBLKSIZE:
 946                         dmap = dmap_out;
 947                         if (audio_devs[dev]->open_mode & OPEN_WRITE)
 948                                 reorganize_buffers(dev, dmap_out, (audio_devs[dev]->open_mode == OPEN_READ));
 949                         if (audio_devs[dev]->open_mode == OPEN_READ ||
 950                             (audio_devs[dev]->flags & DMA_DUPLEX &&
 951                              audio_devs[dev]->open_mode & OPEN_READ))
 952                                 reorganize_buffers(dev, dmap_in, (audio_devs[dev]->open_mode == OPEN_READ));
 953                         if (audio_devs[dev]->open_mode == OPEN_READ)
 954                                 dmap = dmap_in;
 955                         ret = dmap->fragment_size;
 956                         break;
 957
 958                 case SNDCTL_DSP_SETFRAGMENT:
 959                         ret = 0;
 960                         if (get_user(fact, (int *)arg))
 961                                 return -EFAULT;
 962                         if (audio_devs[dev]->open_mode & OPEN_WRITE)
 963                                 ret = dma_set_fragment(dev, dmap_out, fact);
 964                         if (ret < 0)
 965                                 return ret;
 966                         if (audio_devs[dev]->open_mode == OPEN_READ ||
 967                             (audio_devs[dev]->flags & DMA_DUPLEX &&
 968                              audio_devs[dev]->open_mode & OPEN_READ))
 969                                 ret = dma_set_fragment(dev, dmap_in, fact);
 970                         if (ret < 0)
 971                                 return ret;
 972                         if (!arg) /* don't know what this is good for, but preserve old semantics */
 973                                 return 0;
 974                         break;
 975
 976                 default:
 977                         if (!audio_devs[dev]->d->ioctl)
 978                                 return -EINVAL;
 979                         return audio_devs[dev]->d->ioctl(dev, cmd, arg);
 980         }
 981         return put_user(ret, (int *)arg);
 982 }