sound/core/ioctl32/ioctl32.c - linux - Git at Google

 /*
  *   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)
	/*
	* 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)