renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-21 03:33:59 +08:00
Code
d3c29a5c3f
linux-next/sound/oss/audio.c
Peter Senna Tschudin 395d9dd5dd sound: Remove unnecessary semicolon 
A simplified version of the semantic patch that finds this problem is as
follows: (http://coccinelle.lip6.fr/)

// <smpl>
@r1@
statement S;
position p,p1;
@@
S@p1;@p

@script:python r2@
p << r1.p;
p1 << r1.p1;
@@
if p[0].line != p1[0].line_end:
        cocci.include_match(False)
@@
position r1.p;
@@
-;@p
// </smpl>

Signed-off-by: Peter Senna Tschudin <peter.senna@gmail.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2012-10-06 16:47:53 +02:00

986 lines
25 KiB
C
Raw Blame History

/*
* sound/oss/audio.c
*
* Device file manager for /dev/audio
*/
/*
* Copyright (C) by Hannu Savolainen 1993-1997
*
* OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
* Version 2 (June 1991). See the "COPYING" file distributed with this software
* for more info.
*/
/*
* Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
* Thomas Sailer : moved several static variables into struct audio_operations
* (which is grossly misnamed btw.) because they have the same
* lifetime as the rest in there and dynamic allocation saves
* 12k or so
* Thomas Sailer : use more logical O_NONBLOCK semantics
* Daniel Rodriksson: reworked the use of the device specific copy_user
* still generic
* Horst von Brand: Add missing #include <linux/string.h>
* Chris Rankin : Update the module-usage counter for the coprocessor,
* and decrement the counters again if we cannot open
* the audio device.
*/
#include <linux/stddef.h>
#include <linux/string.h>
#include <linux/kmod.h>
#include "sound_config.h"
#include "ulaw.h"
#include "coproc.h"
#define NEUTRAL8 0x80
#define NEUTRAL16 0x00
static int dma_ioctl(int dev, unsigned int cmd, void __user *arg);
static int set_format(int dev, int fmt)
{
if (fmt != AFMT_QUERY)
{
audio_devs[dev]->local_conversion = 0;
if (!(audio_devs[dev]->format_mask & fmt)) /* Not supported */
{
if (fmt == AFMT_MU_LAW)
{
fmt = AFMT_U8;
audio_devs[dev]->local_conversion = CNV_MU_LAW;
}
else
fmt = AFMT_U8; /* This is always supported */
}
audio_devs[dev]->audio_format = audio_devs[dev]->d->set_bits(dev, fmt);
audio_devs[dev]->local_format = fmt;
}
else
return audio_devs[dev]->local_format;
if (audio_devs[dev]->local_conversion)
return audio_devs[dev]->local_conversion;
else
return audio_devs[dev]->local_format;
}
int audio_open(int dev, struct file *file)
{
int ret;
int bits;
int dev_type = dev & 0x0f;
int mode = translate_mode(file);
const struct audio_driver *driver;
const struct coproc_operations *coprocessor;
dev = dev >> 4;
if (dev_type == SND_DEV_DSP16)
bits = 16;
else
bits = 8;
if (dev < 0 || dev >= num_audiodevs)
return -ENXIO;
driver = audio_devs[dev]->d;
if (!try_module_get(driver->owner))
return -ENODEV;
if ((ret = DMAbuf_open(dev, mode)) < 0)
goto error_1;
if ( (coprocessor = audio_devs[dev]->coproc) != NULL ) {
if (!try_module_get(coprocessor->owner))
goto error_2;
if ((ret = coprocessor->open(coprocessor->devc, COPR_PCM)) < 0) {
printk(KERN_WARNING "Sound: Can't access coprocessor device\n");
goto error_3;
}
}
audio_devs[dev]->local_conversion = 0;
if (dev_type == SND_DEV_AUDIO)
set_format(dev, AFMT_MU_LAW);
else
set_format(dev, bits);
audio_devs[dev]->audio_mode = AM_NONE;
return 0;
/*
* Clean-up stack: this is what needs (un)doing if
* we can't open the audio device ...
*/
error_3:
module_put(coprocessor->owner);
error_2:
DMAbuf_release(dev, mode);
error_1:
module_put(driver->owner);
return ret;
}
static void sync_output(int dev)
{
int p, i;
int l;
struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
if (dmap->fragment_size <= 0)
return;
dmap->flags |= DMA_POST;
/* Align the write pointer with fragment boundaries */
if ((l = dmap->user_counter % dmap->fragment_size) > 0)
{
int len;
unsigned long offs = dmap->user_counter % dmap->bytes_in_use;
len = dmap->fragment_size - l;
memset(dmap->raw_buf + offs, dmap->neutral_byte, len);
DMAbuf_move_wrpointer(dev, len);
}
/*
* Clean all unused buffer fragments.
*/
p = dmap->qtail;
dmap->flags |= DMA_POST;
for (i = dmap->qlen + 1; i < dmap->nbufs; i++)
{
p = (p + 1) % dmap->nbufs;
if (((dmap->raw_buf + p * dmap->fragment_size) + dmap->fragment_size) >
(dmap->raw_buf + dmap->buffsize))
printk(KERN_ERR "audio: Buffer error 2\n");
memset(dmap->raw_buf + p * dmap->fragment_size,
dmap->neutral_byte,
dmap->fragment_size);
}
dmap->flags |= DMA_DIRTY;
}
void audio_release(int dev, struct file *file)
{
const struct coproc_operations *coprocessor;
int mode = translate_mode(file);
dev = dev >> 4;
/*
* We do this in DMAbuf_release(). Why are we doing it
* here? Why don't we test the file mode before setting
* both flags? DMAbuf_release() does.
* ...pester...pester...pester...
*/
audio_devs[dev]->dmap_out->closing = 1;
audio_devs[dev]->dmap_in->closing = 1;
/*
* We need to make sure we allocated the dmap_out buffer
* before we go mucking around with it in sync_output().
*/
if (mode & OPEN_WRITE)
sync_output(dev);
if ( (coprocessor = audio_devs[dev]->coproc) != NULL ) {
coprocessor->close(coprocessor->devc, COPR_PCM);
module_put(coprocessor->owner);
}
DMAbuf_release(dev, mode);
module_put(audio_devs[dev]->d->owner);
}
static void translate_bytes(const unsigned char *table, unsigned char *buff, int n)
{
unsigned long i;
if (n <= 0)
return;
for (i = 0; i < n; ++i)
buff[i] = table[buff[i]];
}
int audio_write(int dev, struct file *file, const char __user *buf, int count)
{
int c, p, l, buf_size, used, returned;
int err;
char *dma_buf;
dev = dev >> 4;
p = 0;
c = count;
if(count < 0)
return -EINVAL;
if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
return -EPERM;
if (audio_devs[dev]->flags & DMA_DUPLEX)
audio_devs[dev]->audio_mode |= AM_WRITE;
else
audio_devs[dev]->audio_mode = AM_WRITE;
if (!count) /* Flush output */
{
sync_output(dev);
return 0;
}
while (c)
{
if ((err = DMAbuf_getwrbuffer(dev, &dma_buf, &buf_size, !!(file->f_flags & O_NONBLOCK))) < 0)
{
/* Handle nonblocking mode */
if ((file->f_flags & O_NONBLOCK) && err == -EAGAIN)
return p? p : -EAGAIN; /* No more space. Return # of accepted bytes */
return err;
}
l = c;
if (l > buf_size)
l = buf_size;
returned = l;
used = l;
if (!audio_devs[dev]->d->copy_user)
{
if ((dma_buf + l) >
(audio_devs[dev]->dmap_out->raw_buf + audio_devs[dev]->dmap_out->buffsize))
{
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);
return -EDOM;
}
if (dma_buf < audio_devs[dev]->dmap_out->raw_buf)
{
printk(KERN_ERR "audio: Buffer error 13 (%lx<%lx)\n", (long) dma_buf, (long) audio_devs[dev]->dmap_out->raw_buf);
return -EDOM;
}
if(copy_from_user(dma_buf, &(buf)[p], l))
return -EFAULT;
}
else audio_devs[dev]->d->copy_user (dev,
dma_buf, 0,
buf, p,
c, buf_size,
&used, &returned,
l);
l = returned;
if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
{
translate_bytes(ulaw_dsp, (unsigned char *) dma_buf, l);
}
c -= used;
p += used;
DMAbuf_move_wrpointer(dev, l);
}
return count;
}
int audio_read(int dev, struct file *file, char __user *buf, int count)
{
int c, p, l;
char *dmabuf;
int buf_no;
dev = dev >> 4;
p = 0;
c = count;
if (!(audio_devs[dev]->open_mode & OPEN_READ))
return -EPERM;
if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
sync_output(dev);
if (audio_devs[dev]->flags & DMA_DUPLEX)
audio_devs[dev]->audio_mode |= AM_READ;
else
audio_devs[dev]->audio_mode = AM_READ;
while(c)
{
if ((buf_no = DMAbuf_getrdbuffer(dev, &dmabuf, &l, !!(file->f_flags & O_NONBLOCK))) < 0)
{
/*
* Nonblocking mode handling. Return current # of bytes
*/
if (p > 0) /* Avoid throwing away data */
return p; /* Return it instead */
if ((file->f_flags & O_NONBLOCK) && buf_no == -EAGAIN)
return -EAGAIN;
return buf_no;
}
if (l > c)
l = c;
/*
* Insert any local processing here.
*/
if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
{
translate_bytes(dsp_ulaw, (unsigned char *) dmabuf, l);
}
{
char *fixit = dmabuf;
if(copy_to_user(&(buf)[p], fixit, l))
return -EFAULT;
}
DMAbuf_rmchars(dev, buf_no, l);
p += l;
c -= l;
}
return count - c;
}
int audio_ioctl(int dev, struct file *file, unsigned int cmd, void __user *arg)
{
int val, count;
unsigned long flags;
struct dma_buffparms *dmap;
int __user *p = arg;
dev = dev >> 4;
if (_IOC_TYPE(cmd) == 'C') {
if (audio_devs[dev]->coproc) /* Coprocessor ioctl */
return audio_devs[dev]->coproc->ioctl(audio_devs[dev]->coproc->devc, cmd, arg, 0);
/* else
printk(KERN_DEBUG"/dev/dsp%d: No coprocessor for this device\n", dev); */
return -ENXIO;
}
else switch (cmd)
{
case SNDCTL_DSP_SYNC:
if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
return 0;
if (audio_devs[dev]->dmap_out->fragment_size == 0)
return 0;
sync_output(dev);
DMAbuf_sync(dev);
DMAbuf_reset(dev);
return 0;
case SNDCTL_DSP_POST:
if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
return 0;
if (audio_devs[dev]->dmap_out->fragment_size == 0)
return 0;
audio_devs[dev]->dmap_out->flags |= DMA_POST | DMA_DIRTY;
sync_output(dev);
dma_ioctl(dev, SNDCTL_DSP_POST, NULL);
return 0;
case SNDCTL_DSP_RESET:
audio_devs[dev]->audio_mode = AM_NONE;
DMAbuf_reset(dev);
return 0;
case SNDCTL_DSP_GETFMTS:
val = audio_devs[dev]->format_mask | AFMT_MU_LAW;
break;
case SNDCTL_DSP_SETFMT:
if (get_user(val, p))
return -EFAULT;
val = set_format(dev, val);
break;
case SNDCTL_DSP_GETISPACE:
if (!(audio_devs[dev]->open_mode & OPEN_READ))
return 0;
if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
return -EBUSY;
return dma_ioctl(dev, cmd, arg);
case SNDCTL_DSP_GETOSPACE:
if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
return -EPERM;
if ((audio_devs[dev]->audio_mode & AM_READ) && !(audio_devs[dev]->flags & DMA_DUPLEX))
return -EBUSY;
return dma_ioctl(dev, cmd, arg);
case SNDCTL_DSP_NONBLOCK:
spin_lock(&file->f_lock);
file->f_flags |= O_NONBLOCK;
spin_unlock(&file->f_lock);
return 0;
case SNDCTL_DSP_GETCAPS:
val = 1 | DSP_CAP_MMAP; /* Revision level of this ioctl() */
if (audio_devs[dev]->flags & DMA_DUPLEX &&
audio_devs[dev]->open_mode == OPEN_READWRITE)
val |= DSP_CAP_DUPLEX;
if (audio_devs[dev]->coproc)
val |= DSP_CAP_COPROC;
if (audio_devs[dev]->d->local_qlen) /* Device has hidden buffers */
val |= DSP_CAP_BATCH;
if (audio_devs[dev]->d->trigger) /* Supports SETTRIGGER */
val |= DSP_CAP_TRIGGER;
break;
case SOUND_PCM_WRITE_RATE:
if (get_user(val, p))
return -EFAULT;
val = audio_devs[dev]->d->set_speed(dev, val);
break;
case SOUND_PCM_READ_RATE:
val = audio_devs[dev]->d->set_speed(dev, 0);
break;
case SNDCTL_DSP_STEREO:
if (get_user(val, p))
return -EFAULT;
if (val > 1 || val < 0)
return -EINVAL;
val = audio_devs[dev]->d->set_channels(dev, val + 1) - 1;
break;
case SOUND_PCM_WRITE_CHANNELS:
if (get_user(val, p))
return -EFAULT;
val = audio_devs[dev]->d->set_channels(dev, val);
break;
case SOUND_PCM_READ_CHANNELS:
val = audio_devs[dev]->d->set_channels(dev, 0);
break;
case SOUND_PCM_READ_BITS:
val = audio_devs[dev]->d->set_bits(dev, 0);
break;
case SNDCTL_DSP_SETDUPLEX:
if (audio_devs[dev]->open_mode != OPEN_READWRITE)
return -EPERM;
return (audio_devs[dev]->flags & DMA_DUPLEX) ? 0 : -EIO;
case SNDCTL_DSP_PROFILE:
if (get_user(val, p))
return -EFAULT;
if (audio_devs[dev]->open_mode & OPEN_WRITE)
audio_devs[dev]->dmap_out->applic_profile = val;
if (audio_devs[dev]->open_mode & OPEN_READ)
audio_devs[dev]->dmap_in->applic_profile = val;
return 0;
case SNDCTL_DSP_GETODELAY:
dmap = audio_devs[dev]->dmap_out;
if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
return -EINVAL;
if (!(dmap->flags & DMA_ALLOC_DONE))
{
val=0;
break;
}
spin_lock_irqsave(&dmap->lock,flags);
/* Compute number of bytes that have been played */
count = DMAbuf_get_buffer_pointer (dev, dmap, DMODE_OUTPUT);
if (count < dmap->fragment_size && dmap->qhead != 0)
count += dmap->bytes_in_use; /* Pointer wrap not handled yet */
count += dmap->byte_counter;
/* Subtract current count from the number of bytes written by app */
count = dmap->user_counter - count;
if (count < 0)
count = 0;
spin_unlock_irqrestore(&dmap->lock,flags);
val = count;
break;
default:
return dma_ioctl(dev, cmd, arg);
}
return put_user(val, p);
}
void audio_init_devices(void)
{
/*
* NOTE! This routine could be called several times during boot.
*/
}
void reorganize_buffers(int dev, struct dma_buffparms *dmap, int recording)
{
/*
* This routine breaks the physical device buffers to logical ones.
*/
struct audio_operations *dsp_dev = audio_devs[dev];
unsigned i, n;
unsigned sr, nc, sz, bsz;
sr = dsp_dev->d->set_speed(dev, 0);
nc = dsp_dev->d->set_channels(dev, 0);
sz = dsp_dev->d->set_bits(dev, 0);
if (sz == 8)
dmap->neutral_byte = NEUTRAL8;
else
dmap->neutral_byte = NEUTRAL16;
if (sr < 1 || nc < 1 || sz < 1)
{
/* printk(KERN_DEBUG "Warning: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%d\n", dev, sr, nc, sz);*/
sr = DSP_DEFAULT_SPEED;
nc = 1;
sz = 8;
}
sz = sr * nc * sz;
sz /= 8; /* #bits -> #bytes */
dmap->data_rate = sz;
if (!dmap->needs_reorg)
return;
dmap->needs_reorg = 0;
if (dmap->fragment_size == 0)
{
/* Compute the fragment size using the default algorithm */
/*
* Compute a buffer size for time not exceeding 1 second.
* Usually this algorithm gives a buffer size for 0.5 to 1.0 seconds
* of sound (using the current speed, sample size and #channels).
*/
bsz = dmap->buffsize;
while (bsz > sz)
bsz /= 2;
if (bsz == dmap->buffsize)
bsz /= 2; /* Needs at least 2 buffers */
/*
* Split the computed fragment to smaller parts. After 3.5a9
* the default subdivision is 4 which should give better
* results when recording.
*/
if (dmap->subdivision == 0) /* Not already set */
{
dmap->subdivision = 4; /* Init to the default value */
if ((bsz / dmap->subdivision) > 4096)
dmap->subdivision *= 2;
if ((bsz / dmap->subdivision) < 4096)
dmap->subdivision = 1;
}
bsz /= dmap->subdivision;
if (bsz < 16)
bsz = 16; /* Just a sanity check */
dmap->fragment_size = bsz;
}
else
{
/*
* The process has specified the buffer size with SNDCTL_DSP_SETFRAGMENT or
* the buffer size computation has already been done.
*/
if (dmap->fragment_size > (dmap->buffsize / 2))
dmap->fragment_size = (dmap->buffsize / 2);
bsz = dmap->fragment_size;
}
if (audio_devs[dev]->min_fragment)
if (bsz < (1 << audio_devs[dev]->min_fragment))
bsz = 1 << audio_devs[dev]->min_fragment;
if (audio_devs[dev]->max_fragment)
if (bsz > (1 << audio_devs[dev]->max_fragment))
bsz = 1 << audio_devs[dev]->max_fragment;
bsz &= ~0x07; /* Force size which is multiple of 8 bytes */
#ifdef OS_DMA_ALIGN_CHECK
OS_DMA_ALIGN_CHECK(bsz);
#endif
n = dmap->buffsize / bsz;
if (n > MAX_SUB_BUFFERS)
n = MAX_SUB_BUFFERS;
if (n > dmap->max_fragments)
n = dmap->max_fragments;
if (n < 2)
{
n = 2;
bsz /= 2;
}
dmap->nbufs = n;
dmap->bytes_in_use = n * bsz;
dmap->fragment_size = bsz;
dmap->max_byte_counter = (dmap->data_rate * 60 * 60) +
dmap->bytes_in_use; /* Approximately one hour */
if (dmap->raw_buf)
{
memset(dmap->raw_buf, dmap->neutral_byte, dmap->bytes_in_use);
}
for (i = 0; i < dmap->nbufs; i++)
{
dmap->counts[i] = 0;
}
dmap->flags |= DMA_ALLOC_DONE | DMA_EMPTY;
}
static int dma_subdivide(int dev, struct dma_buffparms *dmap, int fact)
{
if (fact == 0)
{
fact = dmap->subdivision;
if (fact == 0)
fact = 1;
return fact;
}
if (dmap->subdivision != 0 || dmap->fragment_size) /* Too late to change */
return -EINVAL;
if (fact > MAX_REALTIME_FACTOR)
return -EINVAL;
if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
return -EINVAL;
dmap->subdivision = fact;
return fact;
}
static int dma_set_fragment(int dev, struct dma_buffparms *dmap, int fact)
{
int bytes, count;
if (fact == 0)
return -EIO;
if (dmap->subdivision != 0 ||
dmap->fragment_size) /* Too late to change */
return -EINVAL;
bytes = fact & 0xffff;
count = (fact >> 16) & 0x7fff;
if (count == 0)
count = MAX_SUB_BUFFERS;
else if (count < MAX_SUB_BUFFERS)
count++;
if (bytes < 4 || bytes > 17) /* <16 || > 512k */
return -EINVAL;
if (count < 2)
return -EINVAL;
if (audio_devs[dev]->min_fragment > 0)
if (bytes < audio_devs[dev]->min_fragment)
bytes = audio_devs[dev]->min_fragment;
if (audio_devs[dev]->max_fragment > 0)
if (bytes > audio_devs[dev]->max_fragment)
bytes = audio_devs[dev]->max_fragment;
#ifdef OS_DMA_MINBITS
if (bytes < OS_DMA_MINBITS)
bytes = OS_DMA_MINBITS;
#endif
dmap->fragment_size = (1 << bytes);
dmap->max_fragments = count;
if (dmap->fragment_size > dmap->buffsize)
dmap->fragment_size = dmap->buffsize;
if (dmap->fragment_size == dmap->buffsize &&
audio_devs[dev]->flags & DMA_AUTOMODE)
dmap->fragment_size /= 2; /* Needs at least 2 buffers */
dmap->subdivision = 1; /* Disable SNDCTL_DSP_SUBDIVIDE */
return bytes | ((count - 1) << 16);
}
static int dma_ioctl(int dev, unsigned int cmd, void __user *arg)
{
struct dma_buffparms *dmap_out = audio_devs[dev]->dmap_out;
struct dma_buffparms *dmap_in = audio_devs[dev]->dmap_in;
struct dma_buffparms *dmap;
audio_buf_info info;
count_info cinfo;
int fact, ret, changed, bits, count, err;
unsigned long flags;
switch (cmd)
{
case SNDCTL_DSP_SUBDIVIDE:
ret = 0;
if (get_user(fact, (int __user *)arg))
return -EFAULT;
if (audio_devs[dev]->open_mode & OPEN_WRITE)
ret = dma_subdivide(dev, dmap_out, fact);
if (ret < 0)
return ret;
if (audio_devs[dev]->open_mode != OPEN_WRITE ||
(audio_devs[dev]->flags & DMA_DUPLEX &&
audio_devs[dev]->open_mode & OPEN_READ))
ret = dma_subdivide(dev, dmap_in, fact);
if (ret < 0)
return ret;
break;
case SNDCTL_DSP_GETISPACE:
case SNDCTL_DSP_GETOSPACE:
dmap = dmap_out;
if (cmd == SNDCTL_DSP_GETISPACE && !(audio_devs[dev]->open_mode & OPEN_READ))
return -EINVAL;
if (cmd == SNDCTL_DSP_GETOSPACE && !(audio_devs[dev]->open_mode & OPEN_WRITE))
return -EINVAL;
if (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
dmap = dmap_in;
if (dmap->mapping_flags & DMA_MAP_MAPPED)
return -EINVAL;
if (!(dmap->flags & DMA_ALLOC_DONE))
reorganize_buffers(dev, dmap, (cmd == SNDCTL_DSP_GETISPACE));
info.fragstotal = dmap->nbufs;
if (cmd == SNDCTL_DSP_GETISPACE)
info.fragments = dmap->qlen;
else
{
if (!DMAbuf_space_in_queue(dev))
info.fragments = 0;
else
{
info.fragments = DMAbuf_space_in_queue(dev);
if (audio_devs[dev]->d->local_qlen)
{
int tmp = audio_devs[dev]->d->local_qlen(dev);
if (tmp && info.fragments)
tmp--; /*
* This buffer has been counted twice
*/
info.fragments -= tmp;
}
}
}
if (info.fragments < 0)
info.fragments = 0;
else if (info.fragments > dmap->nbufs)
info.fragments = dmap->nbufs;
info.fragsize = dmap->fragment_size;
info.bytes = info.fragments * dmap->fragment_size;
if (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
info.bytes -= dmap->counts[dmap->qhead];
else
{
info.fragments = info.bytes / dmap->fragment_size;
info.bytes -= dmap->user_counter % dmap->fragment_size;
}
if (copy_to_user(arg, &info, sizeof(info)))
return -EFAULT;
return 0;
case SNDCTL_DSP_SETTRIGGER:
if (get_user(bits, (int __user *)arg))
return -EFAULT;
bits &= audio_devs[dev]->open_mode;
if (audio_devs[dev]->d->trigger == NULL)
return -EINVAL;
if (!(audio_devs[dev]->flags & DMA_DUPLEX) && (bits & PCM_ENABLE_INPUT) &&
(bits & PCM_ENABLE_OUTPUT))
return -EINVAL;
if (bits & PCM_ENABLE_INPUT)
{
spin_lock_irqsave(&dmap_in->lock,flags);
changed = (audio_devs[dev]->enable_bits ^ bits) & PCM_ENABLE_INPUT;
if (changed && audio_devs[dev]->go)
{
reorganize_buffers(dev, dmap_in, 1);
if ((err = audio_devs[dev]->d->prepare_for_input(dev,
dmap_in->fragment_size, dmap_in->nbufs)) < 0) {
spin_unlock_irqrestore(&dmap_in->lock,flags);
return err;
}
dmap_in->dma_mode = DMODE_INPUT;
audio_devs[dev]->enable_bits |= PCM_ENABLE_INPUT;
DMAbuf_activate_recording(dev, dmap_in);
} else
audio_devs[dev]->enable_bits &= ~PCM_ENABLE_INPUT;
spin_unlock_irqrestore(&dmap_in->lock,flags);
}
if (bits & PCM_ENABLE_OUTPUT)
{
spin_lock_irqsave(&dmap_out->lock,flags);
changed = (audio_devs[dev]->enable_bits ^ bits) & PCM_ENABLE_OUTPUT;
if (changed &&
(dmap_out->mapping_flags & DMA_MAP_MAPPED || dmap_out->qlen > 0) &&
audio_devs[dev]->go)
{
if (!(dmap_out->flags & DMA_ALLOC_DONE))
reorganize_buffers(dev, dmap_out, 0);
dmap_out->dma_mode = DMODE_OUTPUT;
audio_devs[dev]->enable_bits |= PCM_ENABLE_OUTPUT;
dmap_out->counts[dmap_out->qhead] = dmap_out->fragment_size;
DMAbuf_launch_output(dev, dmap_out);
} else
audio_devs[dev]->enable_bits &= ~PCM_ENABLE_OUTPUT;
spin_unlock_irqrestore(&dmap_out->lock,flags);
}
#if 0
if (changed && audio_devs[dev]->d->trigger)
audio_devs[dev]->d->trigger(dev, bits * audio_devs[dev]->go);
#endif
/* Falls through... */
case SNDCTL_DSP_GETTRIGGER:
ret = audio_devs[dev]->enable_bits;
break;
case SNDCTL_DSP_SETSYNCRO:
if (!audio_devs[dev]->d->trigger)
return -EINVAL;
audio_devs[dev]->d->trigger(dev, 0);
audio_devs[dev]->go = 0;
return 0;
case SNDCTL_DSP_GETIPTR:
if (!(audio_devs[dev]->open_mode & OPEN_READ))
return -EINVAL;
spin_lock_irqsave(&dmap_in->lock,flags);
cinfo.bytes = dmap_in->byte_counter;
cinfo.ptr = DMAbuf_get_buffer_pointer(dev, dmap_in, DMODE_INPUT) & ~3;
if (cinfo.ptr < dmap_in->fragment_size && dmap_in->qtail != 0)
cinfo.bytes += dmap_in->bytes_in_use; /* Pointer wrap not handled yet */
cinfo.blocks = dmap_in->qlen;
cinfo.bytes += cinfo.ptr;
if (dmap_in->mapping_flags & DMA_MAP_MAPPED)
dmap_in->qlen = 0; /* Reset interrupt counter */
spin_unlock_irqrestore(&dmap_in->lock,flags);
if (copy_to_user(arg, &cinfo, sizeof(cinfo)))
return -EFAULT;
return 0;
case SNDCTL_DSP_GETOPTR:
if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
return -EINVAL;
spin_lock_irqsave(&dmap_out->lock,flags);
cinfo.bytes = dmap_out->byte_counter;
cinfo.ptr = DMAbuf_get_buffer_pointer(dev, dmap_out, DMODE_OUTPUT) & ~3;
if (cinfo.ptr < dmap_out->fragment_size && dmap_out->qhead != 0)
cinfo.bytes += dmap_out->bytes_in_use; /* Pointer wrap not handled yet */
cinfo.blocks = dmap_out->qlen;
cinfo.bytes += cinfo.ptr;
if (dmap_out->mapping_flags & DMA_MAP_MAPPED)
dmap_out->qlen = 0; /* Reset interrupt counter */
spin_unlock_irqrestore(&dmap_out->lock,flags);
if (copy_to_user(arg, &cinfo, sizeof(cinfo)))
return -EFAULT;
return 0;
case SNDCTL_DSP_GETODELAY:
if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
return -EINVAL;
if (!(dmap_out->flags & DMA_ALLOC_DONE))
{
ret=0;
break;
}
spin_lock_irqsave(&dmap_out->lock,flags);
/* Compute number of bytes that have been played */
count = DMAbuf_get_buffer_pointer (dev, dmap_out, DMODE_OUTPUT);
if (count < dmap_out->fragment_size && dmap_out->qhead != 0)
count += dmap_out->bytes_in_use; /* Pointer wrap not handled yet */
count += dmap_out->byte_counter;
/* Subtract current count from the number of bytes written by app */
count = dmap_out->user_counter - count;
if (count < 0)
count = 0;
spin_unlock_irqrestore(&dmap_out->lock,flags);
ret = count;
break;
case SNDCTL_DSP_POST:
if (audio_devs[dev]->dmap_out->qlen > 0)
if (!(audio_devs[dev]->dmap_out->flags & DMA_ACTIVE))
DMAbuf_launch_output(dev, audio_devs[dev]->dmap_out);
return 0;
case SNDCTL_DSP_GETBLKSIZE:
dmap = dmap_out;
if (audio_devs[dev]->open_mode & OPEN_WRITE)
reorganize_buffers(dev, dmap_out, (audio_devs[dev]->open_mode == OPEN_READ));
if (audio_devs[dev]->open_mode == OPEN_READ ||
(audio_devs[dev]->flags & DMA_DUPLEX &&
audio_devs[dev]->open_mode & OPEN_READ))
reorganize_buffers(dev, dmap_in, (audio_devs[dev]->open_mode == OPEN_READ));
if (audio_devs[dev]->open_mode == OPEN_READ)
dmap = dmap_in;
ret = dmap->fragment_size;
break;
case SNDCTL_DSP_SETFRAGMENT:
ret = 0;
if (get_user(fact, (int __user *)arg))
return -EFAULT;
if (audio_devs[dev]->open_mode & OPEN_WRITE)
ret = dma_set_fragment(dev, dmap_out, fact);
if (ret < 0)
return ret;
if (audio_devs[dev]->open_mode == OPEN_READ ||
(audio_devs[dev]->flags & DMA_DUPLEX &&
audio_devs[dev]->open_mode & OPEN_READ))
ret = dma_set_fragment(dev, dmap_in, fact);
if (ret < 0)
return ret;
if (!arg) /* don't know what this is good for, but preserve old semantics */
return 0;
break;
default:
if (!audio_devs[dev]->d->ioctl)
return -EINVAL;
return audio_devs[dev]->d->ioctl(dev, cmd, arg);
}
return put_user(ret, (int __user *)arg);
}
View Git Blame Copy Permalink