/*
* 32bit -> 64bit ioctl wrapper for control API
* Copyright (c) by Takashi Iwai <tiwai@suse.de>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <sound/driver.h>
#include <linux/sched.h>
#include <linux/smp_lock.h>
#include <linux/init.h>
#include <linux/time.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <sound/core.h>
#include <sound/control.h>
#include <sound/minors.h>
#include <asm/uaccess.h>
#include "ioctl32.h"
/*
* register/unregister mappers
* exported for other modules
*/
MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("ioctl32 wrapper for ALSA");
MODULE_LICENSE("GPL");
int register_ioctl32_conversion(unsigned int cmd, int (*handler)(unsigned int, unsigned int, unsigned long, struct file *));
int unregister_ioctl32_conversion(unsigned int cmd);
int snd_ioctl32_register(struct ioctl32_mapper *mappers)
{
int err;
struct ioctl32_mapper *m;
for (m = mappers; m->cmd; m++) {
err = register_ioctl32_conversion(m->cmd, m->handler);
if (err >= 0)
m->registered++;
}
return 0;
}
void snd_ioctl32_unregister(struct ioctl32_mapper *mappers)
{
struct ioctl32_mapper *m;
for (m = mappers; m->cmd; m++) {
if (m->registered) {
unregister_ioctl32_conversion(m->cmd);
m->registered = 0;
}
}
}
/*
* compatible wrapper
*/
int snd_ioctl32_compat(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *filp)
{
if (! filp->f_op || ! filp->f_op->ioctl)
return -ENOTTY;
return filp->f_op->ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
}
/*
* Controls
*/
struct sndrv_ctl_elem_list32 {
u32 offset;
u32 space;
u32 used;
u32 count;
u32 pids;
unsigned char reserved[50];
} /* don't set packed attribute here */;
static inline int _snd_ioctl32_ctl_elem_list(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
{
struct sndrv_ctl_elem_list32 __user *data32;
struct sndrv_ctl_elem_list __user *data;
compat_caddr_t ptr;
int err;
data32 = compat_ptr(arg);
data = compat_alloc_user_space(sizeof(*data));
/* offset, space, used, count */
if (copy_in_user(data, data32, 4 * sizeof(u32)))
return -EFAULT;
/* pids */
if (__get_user(ptr, &data32->pids) ||
__put_user(compat_ptr(ptr), &data->pids))
return -EFAULT;
err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
if (err < 0)
return err;
/* copy the result */
if (copy_in_user(data32, data, 4 * sizeof(u32)))
return -EFAULT;
return 0;
}
DEFINE_ALSA_IOCTL_ENTRY(ctl_elem_list, ctl_elem_list, SNDRV_CTL_IOCTL_ELEM_LIST);
/*
* control element info
* it uses union, so the things are not easy..
*/
struct sndrv_ctl_elem_info32 {
struct sndrv_ctl_elem_id id; // the size of struct is same
s32 type;
u32 access;
u32 count;
s32 owner;
union {
struct {
s32 min;
s32 max;
s32 step;
} integer;
struct {
u64 min;
u64 max;
u64 step;
} integer64;
struct {
u32 items;
u32 item;
char name[64];
} enumerated;
unsigned char reserved[128];
} value;
unsigned char reserved[64];
} __attribute__((packed));
static inline int _snd_ioctl32_ctl_elem_info(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
{
struct sndrv_ctl_elem_info __user *data, *src;
struct sndrv_ctl_elem_info32 __user *data32, *dst;
unsigned int type;
int err;
data32 = compat_ptr(arg);
data = compat_alloc_user_space(sizeof(*data));
/* copy id */
if (copy_in_user(&data->id, &data32->id, sizeof(data->id)))
return -EFAULT;
/* we need to copy the item index.
* hope this doesn't break anything..
*/
if (copy_in_user(&data->value.enumerated.item,
&data32->value.enumerated.item,
sizeof(data->value.enumerated.item)))
return -EFAULT;
err = file->f_op->ioctl(file->f_dentry->d_inode, file, native_ctl, (unsigned long)data);
if (err < 0)
return err;
/* restore info to 32bit */
/* for COPY_CVT macro */
src = data;
dst = data32;
/* id, type, access, count */
if (copy_in_user(&data32->id, &data->id, sizeof(data->id)) ||
copy_in_user(&data32->type, &data->type, 3 * sizeof(u32)))
return -EFAULT;
COPY_CVT(owner);
__get_user(type, &data->type);
switch (type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
case SNDRV_CTL_ELEM_TYPE_INTEGER:
COPY_CVT(value.integer.min);
COPY_CVT(value.integer.max);
COPY_CVT(value.integer.step);
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER64:
if (copy_in_user(&data32->value.integer64,
&data->value.integer64,
sizeof(data->value.integer64)))
return -EFAULT;
break;
case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
if (copy_in_user(&data32->value.enumerated,
&data->value.enumerated,
sizeof(data->value.enumerated)))
return -EFAULT;
break;
default:
break;
}
return 0;
}
DEFINE_ALSA_IOCTL_ENTRY(ctl_elem_info, ctl_elem_info, SNDRV_CTL_IOCTL_ELEM_INFO);
struct sndrv_ctl_elem_value32 {
struct sndrv_ctl_elem_id id;
unsigned int indirect; /* bit-field causes misalignment */
union {
s32 integer[128]; /* integer and boolean need conversion */
#ifndef CONFIG_X86_64
s64 integer64[64]; /* for alignment */
#endif
unsigned char data[512]; /* others should be compatible */
} value;
unsigned char reserved[128]; /* not used */
};
/* hmm, it's so hard to retrieve the value type from the control id.. */
static int get_ctl_type(snd_card_t *card, snd_ctl_elem_id_t *id)
{
snd_kcontrol_t *kctl;
snd_ctl_elem_info_t info;
int err;
down_read(&card->controls_rwsem);
kctl = snd_ctl_find_id(card, id);
if (! kctl) {
up_read(&card->controls_rwsem);
return -ENXIO;
}
info.id = *id;
err = kctl->info(kctl, &info);
up_read(&card->controls_rwsem);
if (err >= 0)
err = info.type;
return err;
}
extern int snd_major;
static inline int _snd_ioctl32_ctl_elem_value(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *file, unsigned int native_ctl)
{
struct sndrv_ctl_elem_value *data;
struct sndrv_ctl_elem_value32 __user *data32;
snd_ctl_file_t *ctl;
int err, i, indirect;
int type;
/* sanity check */
if (imajor(file->f_dentry->d_inode) != snd_major ||
SNDRV_MINOR_DEVICE(iminor(file->f_dentry->d_inode)) != SNDRV_MINOR_CONTROL)
return -ENOTTY;
if ((ctl = file->private_data) == NULL)
return -ENOTTY;
data32 = compat_ptr(arg);
data = kcalloc(1, sizeof(*data), GFP_KERNEL);
if (data == NULL)
return -ENOMEM;
if (copy_from_user(&data->id, &data32->id, sizeof(data->id))) {
err = -EFAULT;
goto __end;
}
if (__get_user(indirect, &data32->indirect)) {
err = -EFAULT;
goto __end;
}
/* FIXME: indirect access is not supported */
if (indirect) {
err = -EINVAL;
goto __end;
}
type = get_ctl_type(ctl->card, &data->id);
if (type < 0) {
err = type;
goto __end;
}
switch (type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
case SNDRV_CTL_ELEM_TYPE_INTEGER:
for (i = 0; i < 128; i++) {
int val;
if (__get_user(val, &data32->value.integer[i])) {
err = -EFAULT;
goto __end;
}
data->value.integer.value[i] = val;
}
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER64:
case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
case SNDRV_CTL_ELEM_TYPE_BYTES:
case SNDRV_CTL_ELEM_TYPE_IEC958:
if (__copy_from_user(data->value.bytes.data,
data32->value.data,
sizeof(data32->value.data))) {
err = -EFAULT;
goto __end;
}
break;
default:
printk(KERN_ERR "snd_ioctl32_ctl_elem_value: unknown type %d\n", type);
err = -EINVAL;
goto __end;
}
if (native_ctl == SNDRV_CTL_IOCTL_ELEM_READ)
err = snd_ctl_elem_read(ctl->card, data);
else
err = snd_ctl_elem_write(ctl->card, ctl, data);
if (err < 0)
goto __end;
/* restore info to 32bit */
switch (type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
case SNDRV_CTL_ELEM_TYPE_INTEGER:
for (i = 0; i < 128; i++) {
int val;
val = data->value.integer.value[i];
if (__put_user(val, &data32->value.integer[i])) {
err = -EFAULT;
goto __end;
}
}
break;
default:
if (__copy_to_user(data32->value.data,
data->value.bytes.data,
sizeof(data32->value.data))) {
err = -EFAULT;
goto __end;
}
break;
break;
}
err = 0;
__end:
kfree(data);
return err;
}
DEFINE_ALSA_IOCTL_ENTRY(ctl_elem_read, ctl_elem_value, SNDRV_CTL_IOCTL_ELEM_READ);
DEFINE_ALSA_IOCTL_ENTRY(ctl_elem_write, ctl_elem_value, SNDRV_CTL_IOCTL_ELEM_WRITE);
/*
*/
#define AP(x) snd_ioctl32_##x
enum {
SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct sndrv_ctl_elem_list32),
SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct sndrv_ctl_elem_info32),
SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct sndrv_ctl_elem_value32),
SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct sndrv_ctl_elem_value32),
};
static struct ioctl32_mapper control_mappers[] = {
/* controls (without rawmidi, hwdep, timer releated ones) */
MAP_COMPAT(SNDRV_CTL_IOCTL_PVERSION),
MAP_COMPAT(SNDRV_CTL_IOCTL_CARD_INFO),
{ SNDRV_CTL_IOCTL_ELEM_LIST32, AP(ctl_elem_list) },
{ SNDRV_CTL_IOCTL_ELEM_INFO32, AP(ctl_elem_info) },
{ SNDRV_CTL_IOCTL_ELEM_READ32, AP(ctl_elem_read) },
{ SNDRV_CTL_IOCTL_ELEM_WRITE32, AP(ctl_elem_write) },
MAP_COMPAT(SNDRV_CTL_IOCTL_ELEM_LOCK),
MAP_COMPAT(SNDRV_CTL_IOCTL_ELEM_UNLOCK),
MAP_COMPAT(SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS),
MAP_COMPAT(SNDRV_CTL_IOCTL_HWDEP_INFO),
MAP_COMPAT(SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE),
MAP_COMPAT(SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE),
MAP_COMPAT(SNDRV_CTL_IOCTL_PCM_INFO),
MAP_COMPAT(SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE),
MAP_COMPAT(SNDRV_CTL_IOCTL_POWER),
MAP_COMPAT(SNDRV_CTL_IOCTL_POWER_STATE),
{ 0 }
};
/*
*/
extern struct ioctl32_mapper pcm_mappers[];
extern struct ioctl32_mapper rawmidi_mappers[];
extern struct ioctl32_mapper timer_mappers[];
extern struct ioctl32_mapper hwdep_mappers[];
#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
extern struct ioctl32_mapper seq_mappers[];
#endif
static void snd_ioctl32_done(void)
{
#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
snd_ioctl32_unregister(seq_mappers);
#endif
snd_ioctl32_unregister(hwdep_mappers);
snd_ioctl32_unregister(timer_mappers);
snd_ioctl32_unregister(rawmidi_mappers);
snd_ioctl32_unregister(pcm_mappers);
snd_ioctl32_unregister(control_mappers);
}
static int __init snd_ioctl32_init(void)
{
snd_ioctl32_register(control_mappers);
snd_ioctl32_register(pcm_mappers);
snd_ioctl32_register(rawmidi_mappers);
snd_ioctl32_register(timer_mappers);
snd_ioctl32_register(hwdep_mappers);
#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
snd_ioctl32_register(seq_mappers);
#endif
return 0;
}
module_init(snd_ioctl32_init)
module_exit(snd_ioctl32_done)
![[BACK]](/icons/back.gif){kind=icon}
Return to ioctl32.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / linux-2.6-xfs / sound / core / ioctl32