4 * Device file manager for /dev/audio
8 * Copyright (C) by Hannu Savolainen 1993-1997
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
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
20 * Thomas Sailer : use more logical O_NONBLOCK semantics
21 * Daniel Rodriksson: reworked the use of the device specific copy_user
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
29 #include <linux/stddef.h>
30 #include <linux/string.h>
31 #include <linux/kmod.h>
33 #include "sound_config.h"
38 #define NEUTRAL16 0x00
41 int dma_ioctl(int dev, unsigned int cmd, caddr_t arg);
43 static int set_format(int dev, int fmt)
45 if (fmt != AFMT_QUERY)
47 audio_devs[dev]->local_conversion = 0;
49 if (!(audio_devs[dev]->format_mask & fmt)) /* Not supported */
51 if (fmt == AFMT_MU_LAW)
54 audio_devs[dev]->local_conversion = CNV_MU_LAW;
57 fmt = AFMT_U8; /* This is always supported */
59 audio_devs[dev]->audio_format = audio_devs[dev]->d->set_bits(dev, fmt);
60 audio_devs[dev]->local_format = fmt;
63 return audio_devs[dev]->local_format;
65 if (audio_devs[dev]->local_conversion)
66 return audio_devs[dev]->local_conversion;
68 return audio_devs[dev]->local_format;
71 int audio_open(int dev, struct file *file)
75 int dev_type = dev & 0x0f;
76 int mode = translate_mode(file);
77 const struct audio_driver *driver;
78 const struct coproc_operations *coprocessor;
82 if (dev_type == SND_DEV_DSP16)
87 if (dev < 0 || dev >= num_audiodevs)
90 driver = audio_devs[dev]->d;
92 if (!try_module_get(driver->owner))
95 if ((ret = DMAbuf_open(dev, mode)) < 0)
98 if ( (coprocessor = audio_devs[dev]->coproc) != NULL ) {
99 if (!try_module_get(coprocessor->owner))
102 if ((ret = coprocessor->open(coprocessor->devc, COPR_PCM)) < 0) {
103 printk(KERN_WARNING "Sound: Can't access coprocessor device\n");
108 audio_devs[dev]->local_conversion = 0;
110 if (dev_type == SND_DEV_AUDIO)
111 set_format(dev, AFMT_MU_LAW);
113 set_format(dev, bits);
115 audio_devs[dev]->audio_mode = AM_NONE;
120 * Clean-up stack: this is what needs (un)doing if
121 * we can't open the audio device ...
124 module_put(coprocessor->owner);
127 DMAbuf_release(dev, mode);
130 module_put(driver->owner);
135 static void sync_output(int dev)
139 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
141 if (dmap->fragment_size <= 0)
143 dmap->flags |= DMA_POST;
145 /* Align the write pointer with fragment boundaries */
147 if ((l = dmap->user_counter % dmap->fragment_size) > 0)
150 unsigned long offs = dmap->user_counter % dmap->bytes_in_use;
152 len = dmap->fragment_size - l;
153 memset(dmap->raw_buf + offs, dmap->neutral_byte, len);
154 DMAbuf_move_wrpointer(dev, len);
158 * Clean all unused buffer fragments.
162 dmap->flags |= DMA_POST;
164 for (i = dmap->qlen + 1; i < dmap->nbufs; i++)
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");
171 memset(dmap->raw_buf + p * dmap->fragment_size,
173 dmap->fragment_size);
176 dmap->flags |= DMA_DIRTY;
179 void audio_release(int dev, struct file *file)
181 const struct coproc_operations *coprocessor;
182 int mode = translate_mode(file);
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...
192 audio_devs[dev]->dmap_out->closing = 1;
193 audio_devs[dev]->dmap_in->closing = 1;
196 * We need to make sure we allocated the dmap_out buffer
197 * before we go mucking around with it in sync_output().
199 if (mode & OPEN_WRITE)
202 if ( (coprocessor = audio_devs[dev]->coproc) != NULL ) {
203 coprocessor->close(coprocessor->devc, COPR_PCM);
204 module_put(coprocessor->owner);
206 DMAbuf_release(dev, mode);
208 module_put(audio_devs[dev]->d->owner);
211 static void translate_bytes(const unsigned char *table, unsigned char *buff, int n)
218 for (i = 0; i < n; ++i)
219 buff[i] = table[buff[i]];
222 int audio_write(int dev, struct file *file, const char *buf, int count)
224 int c, p, l, buf_size, used, returned;
236 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
239 if (audio_devs[dev]->flags & DMA_DUPLEX)
240 audio_devs[dev]->audio_mode |= AM_WRITE;
242 audio_devs[dev]->audio_mode = AM_WRITE;
244 if (!count) /* Flush output */
252 if ((err = DMAbuf_getwrbuffer(dev, &dma_buf, &buf_size, !!(file->f_flags & O_NONBLOCK))) < 0)
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 */
266 if (!audio_devs[dev]->d->copy_user)
269 (audio_devs[dev]->dmap_out->raw_buf + audio_devs[dev]->dmap_out->buffsize))
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);
274 if (dma_buf < audio_devs[dev]->dmap_out->raw_buf)
276 printk(KERN_ERR "audio: Buffer error 13 (%lx<%lx)\n", (long) dma_buf, (long) audio_devs[dev]->dmap_out->raw_buf);
279 if(copy_from_user(dma_buf, &(buf)[p], l))
282 else audio_devs[dev]->d->copy_user (dev,
290 if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
292 translate_bytes(ulaw_dsp, (unsigned char *) dma_buf, l);
296 DMAbuf_move_wrpointer(dev, l);
303 int audio_read(int dev, struct file *file, char *buf, int count)
313 if (!(audio_devs[dev]->open_mode & OPEN_READ))
316 if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
319 if (audio_devs[dev]->flags & DMA_DUPLEX)
320 audio_devs[dev]->audio_mode |= AM_READ;
322 audio_devs[dev]->audio_mode = AM_READ;
326 if ((buf_no = DMAbuf_getrdbuffer(dev, &dmabuf, &l, !!(file->f_flags & O_NONBLOCK))) < 0)
329 * Nonblocking mode handling. Return current # of bytes
332 if (p > 0) /* Avoid throwing away data */
333 return p; /* Return it instead */
335 if ((file->f_flags & O_NONBLOCK) && buf_no == -EAGAIN)
344 * Insert any local processing here.
347 if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
349 translate_bytes(dsp_ulaw, (unsigned char *) dmabuf, l);
353 char *fixit = dmabuf;
355 if(copy_to_user(&(buf)[p], fixit, l))
359 DMAbuf_rmchars(dev, buf_no, l);
368 int audio_ioctl(int dev, struct file *file, unsigned int cmd, caddr_t arg)
372 struct dma_buffparms *dmap;
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);
380 printk(KERN_DEBUG"/dev/dsp%d: No coprocessor for this device\n", dev); */
385 case SNDCTL_DSP_SYNC:
386 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
388 if (audio_devs[dev]->dmap_out->fragment_size == 0)
395 case SNDCTL_DSP_POST:
396 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
398 if (audio_devs[dev]->dmap_out->fragment_size == 0)
400 audio_devs[dev]->dmap_out->flags |= DMA_POST | DMA_DIRTY;
402 dma_ioctl(dev, SNDCTL_DSP_POST, (caddr_t) 0);
405 case SNDCTL_DSP_RESET:
406 audio_devs[dev]->audio_mode = AM_NONE;
410 case SNDCTL_DSP_GETFMTS:
411 val = audio_devs[dev]->format_mask | AFMT_MU_LAW;
414 case SNDCTL_DSP_SETFMT:
415 if (get_user(val, (int *)arg))
417 val = set_format(dev, val);
420 case SNDCTL_DSP_GETISPACE:
421 if (!(audio_devs[dev]->open_mode & OPEN_READ))
423 if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
425 return dma_ioctl(dev, cmd, arg);
427 case SNDCTL_DSP_GETOSPACE:
428 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
430 if ((audio_devs[dev]->audio_mode & AM_READ) && !(audio_devs[dev]->flags & DMA_DUPLEX))
432 return dma_ioctl(dev, cmd, arg);
434 case SNDCTL_DSP_NONBLOCK:
435 file->f_flags |= O_NONBLOCK;
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;
451 case SOUND_PCM_WRITE_RATE:
452 if (get_user(val, (int *)arg))
454 val = audio_devs[dev]->d->set_speed(dev, val);
457 case SOUND_PCM_READ_RATE:
458 val = audio_devs[dev]->d->set_speed(dev, 0);
461 case SNDCTL_DSP_STEREO:
462 if (get_user(val, (int *)arg))
464 if (val > 1 || val < 0)
466 val = audio_devs[dev]->d->set_channels(dev, val + 1) - 1;
469 case SOUND_PCM_WRITE_CHANNELS:
470 if (get_user(val, (int *)arg))
472 val = audio_devs[dev]->d->set_channels(dev, val);
475 case SOUND_PCM_READ_CHANNELS:
476 val = audio_devs[dev]->d->set_channels(dev, 0);
479 case SOUND_PCM_READ_BITS:
480 val = audio_devs[dev]->d->set_bits(dev, 0);
483 case SNDCTL_DSP_SETDUPLEX:
484 if (audio_devs[dev]->open_mode != OPEN_READWRITE)
486 return (audio_devs[dev]->flags & DMA_DUPLEX) ? 0 : -EIO;
488 case SNDCTL_DSP_PROFILE:
489 if (get_user(val, (int *)arg))
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;
497 case SNDCTL_DSP_GETODELAY:
498 dmap = audio_devs[dev]->dmap_out;
499 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
501 if (!(dmap->flags & DMA_ALLOC_DONE))
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;
514 /* Substract current count from the number of bytes written by app */
515 count = dmap->user_counter - count;
518 spin_unlock_irqrestore(&dmap->lock,flags);
523 return dma_ioctl(dev, cmd, arg);
525 return put_user(val, (int *)arg);
528 void audio_init_devices(void)
531 * NOTE! This routine could be called several times during boot.
535 void reorganize_buffers(int dev, struct dma_buffparms *dmap, int recording)
538 * This routine breaks the physical device buffers to logical ones.
541 struct audio_operations *dsp_dev = audio_devs[dev];
544 unsigned sr, nc, sz, bsz;
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);
551 dmap->neutral_byte = NEUTRAL8;
553 dmap->neutral_byte = NEUTRAL16;
555 if (sr < 1 || nc < 1 || sz < 1)
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;
565 sz /= 8; /* #bits -> #bytes */
566 dmap->data_rate = sz;
568 if (!dmap->needs_reorg)
570 dmap->needs_reorg = 0;
572 if (dmap->fragment_size == 0)
574 /* Compute the fragment size using the default algorithm */
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).
582 bsz = dmap->buffsize;
586 if (bsz == dmap->buffsize)
587 bsz /= 2; /* Needs at least 2 buffers */
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.
595 if (dmap->subdivision == 0) /* Not already set */
597 dmap->subdivision = 4; /* Init to the default value */
599 if ((bsz / dmap->subdivision) > 4096)
600 dmap->subdivision *= 2;
601 if ((bsz / dmap->subdivision) < 4096)
602 dmap->subdivision = 1;
604 bsz /= dmap->subdivision;
607 bsz = 16; /* Just a sanity check */
609 dmap->fragment_size = bsz;
614 * The process has specified the buffer size with SNDCTL_DSP_SETFRAGMENT or
615 * the buffer size computation has already been done.
617 if (dmap->fragment_size > (dmap->buffsize / 2))
618 dmap->fragment_size = (dmap->buffsize / 2);
619 bsz = dmap->fragment_size;
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);
633 n = dmap->buffsize / bsz;
634 if (n > MAX_SUB_BUFFERS)
636 if (n > dmap->max_fragments)
637 n = dmap->max_fragments;
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 */
652 memset(dmap->raw_buf, dmap->neutral_byte, dmap->bytes_in_use);
655 for (i = 0; i < dmap->nbufs; i++)
660 dmap->flags |= DMA_ALLOC_DONE | DMA_EMPTY;
663 static int dma_subdivide(int dev, struct dma_buffparms *dmap, int fact)
667 fact = dmap->subdivision;
672 if (dmap->subdivision != 0 || dmap->fragment_size) /* Too late to change */
675 if (fact > MAX_REALTIME_FACTOR)
678 if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
681 dmap->subdivision = fact;
685 static int dma_set_fragment(int dev, struct dma_buffparms *dmap, int fact)
692 if (dmap->subdivision != 0 ||
693 dmap->fragment_size) /* Too late to change */
696 bytes = fact & 0xffff;
697 count = (fact >> 16) & 0x7fff;
700 count = MAX_SUB_BUFFERS;
701 else if (count < MAX_SUB_BUFFERS)
704 if (bytes < 4 || bytes > 17) /* <16 || > 512k */
710 if (audio_devs[dev]->min_fragment > 0)
711 if (bytes < audio_devs[dev]->min_fragment)
712 bytes = audio_devs[dev]->min_fragment;
714 if (audio_devs[dev]->max_fragment > 0)
715 if (bytes > audio_devs[dev]->max_fragment)
716 bytes = audio_devs[dev]->max_fragment;
718 #ifdef OS_DMA_MINBITS
719 if (bytes < OS_DMA_MINBITS)
720 bytes = OS_DMA_MINBITS;
723 dmap->fragment_size = (1 << bytes);
724 dmap->max_fragments = count;
726 if (dmap->fragment_size > dmap->buffsize)
727 dmap->fragment_size = dmap->buffsize;
729 if (dmap->fragment_size == dmap->buffsize &&
730 audio_devs[dev]->flags & DMA_AUTOMODE)
731 dmap->fragment_size /= 2; /* Needs at least 2 buffers */
733 dmap->subdivision = 1; /* Disable SNDCTL_DSP_SUBDIVIDE */
734 return bytes | ((count - 1) << 16);
737 int dma_ioctl(int dev, unsigned int cmd, caddr_t arg)
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;
744 int fact, ret, changed, bits, count, err;
749 case SNDCTL_DSP_SUBDIVIDE:
751 if (get_user(fact, (int *)arg))
753 if (audio_devs[dev]->open_mode & OPEN_WRITE)
754 ret = dma_subdivide(dev, dmap_out, fact);
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);
765 case SNDCTL_DSP_GETISPACE:
766 case SNDCTL_DSP_GETOSPACE:
768 if (cmd == SNDCTL_DSP_GETISPACE && !(audio_devs[dev]->open_mode & OPEN_READ))
770 if (cmd == SNDCTL_DSP_GETOSPACE && !(audio_devs[dev]->open_mode & OPEN_WRITE))
772 if (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
774 if (dmap->mapping_flags & DMA_MAP_MAPPED)
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;
783 if (!DMAbuf_space_in_queue(dev))
787 info.fragments = DMAbuf_space_in_queue(dev);
788 if (audio_devs[dev]->d->local_qlen)
790 int tmp = audio_devs[dev]->d->local_qlen(dev);
791 if (tmp && info.fragments)
793 * This buffer has been counted twice
795 info.fragments -= tmp;
799 if (info.fragments < 0)
801 else if (info.fragments > dmap->nbufs)
802 info.fragments = dmap->nbufs;
804 info.fragsize = dmap->fragment_size;
805 info.bytes = info.fragments * dmap->fragment_size;
807 if (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
808 info.bytes -= dmap->counts[dmap->qhead];
811 info.fragments = info.bytes / dmap->fragment_size;
812 info.bytes -= dmap->user_counter % dmap->fragment_size;
814 if (copy_to_user(arg, &info, sizeof(info)))
818 case SNDCTL_DSP_SETTRIGGER:
819 if (get_user(bits, (int *)arg))
821 bits &= audio_devs[dev]->open_mode;
822 if (audio_devs[dev]->d->trigger == NULL)
824 if (!(audio_devs[dev]->flags & DMA_DUPLEX) && (bits & PCM_ENABLE_INPUT) &&
825 (bits & PCM_ENABLE_OUTPUT))
828 if (bits & PCM_ENABLE_INPUT)
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)
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);
840 dmap_in->dma_mode = DMODE_INPUT;
841 audio_devs[dev]->enable_bits |= PCM_ENABLE_INPUT;
842 DMAbuf_activate_recording(dev, dmap_in);
844 audio_devs[dev]->enable_bits &= ~PCM_ENABLE_INPUT;
845 spin_unlock_irqrestore(&dmap_in->lock,flags);
847 if (bits & PCM_ENABLE_OUTPUT)
849 spin_lock_irqsave(&dmap_out->lock,flags);
850 changed = (audio_devs[dev]->enable_bits ^ bits) & PCM_ENABLE_OUTPUT;
852 (dmap_out->mapping_flags & DMA_MAP_MAPPED || dmap_out->qlen > 0) &&
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);
862 audio_devs[dev]->enable_bits &= ~PCM_ENABLE_OUTPUT;
863 spin_unlock_irqrestore(&dmap_out->lock,flags);
866 if (changed && audio_devs[dev]->d->trigger)
867 audio_devs[dev]->d->trigger(dev, bits * audio_devs[dev]->go);
869 /* Falls through... */
871 case SNDCTL_DSP_GETTRIGGER:
872 ret = audio_devs[dev]->enable_bits;
875 case SNDCTL_DSP_SETSYNCRO:
876 if (!audio_devs[dev]->d->trigger)
878 audio_devs[dev]->d->trigger(dev, 0);
879 audio_devs[dev]->go = 0;
882 case SNDCTL_DSP_GETIPTR:
883 if (!(audio_devs[dev]->open_mode & OPEN_READ))
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)))
899 case SNDCTL_DSP_GETOPTR:
900 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
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)))
917 case SNDCTL_DSP_GETODELAY:
918 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
920 if (!(dmap_out->flags & DMA_ALLOC_DONE))
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;
935 spin_unlock_irqrestore(&dmap_out->lock,flags);
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);
945 case SNDCTL_DSP_GETBLKSIZE:
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)
955 ret = dmap->fragment_size;
958 case SNDCTL_DSP_SETFRAGMENT:
960 if (get_user(fact, (int *)arg))
962 if (audio_devs[dev]->open_mode & OPEN_WRITE)
963 ret = dma_set_fragment(dev, dmap_out, fact);
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);
972 if (!arg) /* don't know what this is good for, but preserve old semantics */
977 if (!audio_devs[dev]->d->ioctl)
979 return audio_devs[dev]->d->ioctl(dev, cmd, arg);
981 return put_user(ret, (int *)arg);