[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / comedi / comedi_compat32.c

/*
    comedi/comedi_compat32.c
    32-bit ioctl compatibility for 64-bit comedi kernel module.

    Author: Ian Abbott, MEV Ltd. <abbotti@mev.co.uk>
    Copyright (C) 2007 MEV Ltd. <http://www.mev.co.uk/>

    COMEDI - Linux Control and Measurement Device Interface
    Copyright (C) 1997-2007 David A. Schleef <ds@schleef.org>

    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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#define __NO_VERSION__
#include <linux/uaccess.h>
#include "comedi.h"
#include "comedi_compat32.h"

#ifdef CONFIG_COMPAT

#define COMEDI32_CHANINFO _IOR(CIO, 3, struct comedi32_chaninfo_struct)
#define COMEDI32_RANGEINFO _IOR(CIO, 8, struct comedi32_rangeinfo_struct)
/* N.B. COMEDI32_CMD and COMEDI_CMD ought to use _IOWR, not _IOR.
 * It's too late to change it now, but it only affects the command number. */
#define COMEDI32_CMD _IOR(CIO, 9, struct comedi32_cmd_struct)
/* N.B. COMEDI32_CMDTEST and COMEDI_CMDTEST ought to use _IOWR, not _IOR.
 * It's too late to change it now, but it only affects the command number. */
#define COMEDI32_CMDTEST _IOR(CIO, 10, struct comedi32_cmd_struct)
#define COMEDI32_INSNLIST _IOR(CIO, 11, struct comedi32_insnlist_struct)
#define COMEDI32_INSN _IOR(CIO, 12, struct comedi32_insn_struct)

struct comedi32_chaninfo_struct {
	unsigned int subdev;
	compat_uptr_t maxdata_list;	/* 32-bit 'unsigned int *' */
	compat_uptr_t flaglist;	/* 32-bit 'unsigned int *' */
	compat_uptr_t rangelist;	/* 32-bit 'unsigned int *' */
	unsigned int unused[4];
};

struct comedi32_rangeinfo_struct {
	unsigned int range_type;
	compat_uptr_t range_ptr;	/* 32-bit 'void *' */
};

struct comedi32_cmd_struct {
	unsigned int subdev;
	unsigned int flags;
	unsigned int start_src;
	unsigned int start_arg;
	unsigned int scan_begin_src;
	unsigned int scan_begin_arg;
	unsigned int convert_src;
	unsigned int convert_arg;
	unsigned int scan_end_src;
	unsigned int scan_end_arg;
	unsigned int stop_src;
	unsigned int stop_arg;
	compat_uptr_t chanlist;	/* 32-bit 'unsigned int *' */
	unsigned int chanlist_len;
	compat_uptr_t data;	/* 32-bit 'short *' */
	unsigned int data_len;
};

struct comedi32_insn_struct {
	unsigned int insn;
	unsigned int n;
	compat_uptr_t data;	/* 32-bit 'unsigned int *' */
	unsigned int subdev;
	unsigned int chanspec;
	unsigned int unused[3];
};

struct comedi32_insnlist_struct {
	unsigned int n_insns;
	compat_uptr_t insns;	/* 32-bit 'struct comedi_insn *' */
};

/* Handle translated ioctl. */
static int translated_ioctl(struct file *file, unsigned int cmd,
			    unsigned long arg)
{
	if (!file->f_op)
		return -ENOTTY;

	if (file->f_op->unlocked_ioctl)
		return file->f_op->unlocked_ioctl(file, cmd, arg);

	return -ENOTTY;
}

/* Handle 32-bit COMEDI_CHANINFO ioctl. */
static int compat_chaninfo(struct file *file, unsigned long arg)
{
	struct comedi_chaninfo __user *chaninfo;
	struct comedi32_chaninfo_struct __user *chaninfo32;
	int err;
	union {
		unsigned int uint;
		compat_uptr_t uptr;
	} temp;

	chaninfo32 = compat_ptr(arg);
	chaninfo = compat_alloc_user_space(sizeof(*chaninfo));

	/* Copy chaninfo structure.  Ignore unused members. */
	if (!access_ok(VERIFY_READ, chaninfo32, sizeof(*chaninfo32))
	    || !access_ok(VERIFY_WRITE, chaninfo, sizeof(*chaninfo))) {
		return -EFAULT;
	}
	err = 0;
	err |= __get_user(temp.uint, &chaninfo32->subdev);
	err |= __put_user(temp.uint, &chaninfo->subdev);
	err |= __get_user(temp.uptr, &chaninfo32->maxdata_list);
	err |= __put_user(compat_ptr(temp.uptr), &chaninfo->maxdata_list);
	err |= __get_user(temp.uptr, &chaninfo32->flaglist);
	err |= __put_user(compat_ptr(temp.uptr), &chaninfo->flaglist);
	err |= __get_user(temp.uptr, &chaninfo32->rangelist);
	err |= __put_user(compat_ptr(temp.uptr), &chaninfo->rangelist);
	if (err)
		return -EFAULT;

	return translated_ioctl(file, COMEDI_CHANINFO, (unsigned long)chaninfo);
}

/* Handle 32-bit COMEDI_RANGEINFO ioctl. */
static int compat_rangeinfo(struct file *file, unsigned long arg)
{
	struct comedi_rangeinfo __user *rangeinfo;
	struct comedi32_rangeinfo_struct __user *rangeinfo32;
	int err;
	union {
		unsigned int uint;
		compat_uptr_t uptr;
	} temp;

	rangeinfo32 = compat_ptr(arg);
	rangeinfo = compat_alloc_user_space(sizeof(*rangeinfo));

	/* Copy rangeinfo structure. */
	if (!access_ok(VERIFY_READ, rangeinfo32, sizeof(*rangeinfo32))
	    || !access_ok(VERIFY_WRITE, rangeinfo, sizeof(*rangeinfo))) {
		return -EFAULT;
	}
	err = 0;
	err |= __get_user(temp.uint, &rangeinfo32->range_type);
	err |= __put_user(temp.uint, &rangeinfo->range_type);
	err |= __get_user(temp.uptr, &rangeinfo32->range_ptr);
	err |= __put_user(compat_ptr(temp.uptr), &rangeinfo->range_ptr);
	if (err)
		return -EFAULT;

	return translated_ioctl(file, COMEDI_RANGEINFO,
				(unsigned long)rangeinfo);
}

/* Copy 32-bit cmd structure to native cmd structure. */
static int get_compat_cmd(struct comedi_cmd __user *cmd,
			  struct comedi32_cmd_struct __user *cmd32)
{
	int err;
	union {
		unsigned int uint;
		compat_uptr_t uptr;
	} temp;

	/* Copy cmd structure. */
	if (!access_ok(VERIFY_READ, cmd32, sizeof(*cmd32))
	    || !access_ok(VERIFY_WRITE, cmd, sizeof(*cmd))) {
		return -EFAULT;
	}
	err = 0;
	err |= __get_user(temp.uint, &cmd32->subdev);
	err |= __put_user(temp.uint, &cmd->subdev);
	err |= __get_user(temp.uint, &cmd32->flags);
	err |= __put_user(temp.uint, &cmd->flags);
	err |= __get_user(temp.uint, &cmd32->start_src);
	err |= __put_user(temp.uint, &cmd->start_src);
	err |= __get_user(temp.uint, &cmd32->start_arg);
	err |= __put_user(temp.uint, &cmd->start_arg);
	err |= __get_user(temp.uint, &cmd32->scan_begin_src);
	err |= __put_user(temp.uint, &cmd->scan_begin_src);
	err |= __get_user(temp.uint, &cmd32->scan_begin_arg);
	err |= __put_user(temp.uint, &cmd->scan_begin_arg);
	err |= __get_user(temp.uint, &cmd32->convert_src);
	err |= __put_user(temp.uint, &cmd->convert_src);
	err |= __get_user(temp.uint, &cmd32->convert_arg);
	err |= __put_user(temp.uint, &cmd->convert_arg);
	err |= __get_user(temp.uint, &cmd32->scan_end_src);
	err |= __put_user(temp.uint, &cmd->scan_end_src);
	err |= __get_user(temp.uint, &cmd32->scan_end_arg);
	err |= __put_user(temp.uint, &cmd->scan_end_arg);
	err |= __get_user(temp.uint, &cmd32->stop_src);
	err |= __put_user(temp.uint, &cmd->stop_src);
	err |= __get_user(temp.uint, &cmd32->stop_arg);
	err |= __put_user(temp.uint, &cmd->stop_arg);
	err |= __get_user(temp.uptr, &cmd32->chanlist);
	err |= __put_user(compat_ptr(temp.uptr), &cmd->chanlist);
	err |= __get_user(temp.uint, &cmd32->chanlist_len);
	err |= __put_user(temp.uint, &cmd->chanlist_len);
	err |= __get_user(temp.uptr, &cmd32->data);
	err |= __put_user(compat_ptr(temp.uptr), &cmd->data);
	err |= __get_user(temp.uint, &cmd32->data_len);
	err |= __put_user(temp.uint, &cmd->data_len);
	return err ? -EFAULT : 0;
}

/* Copy native cmd structure to 32-bit cmd structure. */
static int put_compat_cmd(struct comedi32_cmd_struct __user *cmd32,
			  struct comedi_cmd __user *cmd)
{
	int err;
	unsigned int temp;

	/* Copy back most of cmd structure. */
	/* Assume the pointer values are already valid. */
	/* (Could use ptr_to_compat() to set them, but that wasn't implemented
	 * until kernel version 2.6.11.) */
	if (!access_ok(VERIFY_READ, cmd, sizeof(*cmd))
	    || !access_ok(VERIFY_WRITE, cmd32, sizeof(*cmd32))) {
		return -EFAULT;
	}
	err = 0;
	err |= __get_user(temp, &cmd->subdev);
	err |= __put_user(temp, &cmd32->subdev);
	err |= __get_user(temp, &cmd->flags);
	err |= __put_user(temp, &cmd32->flags);
	err |= __get_user(temp, &cmd->start_src);
	err |= __put_user(temp, &cmd32->start_src);
	err |= __get_user(temp, &cmd->start_arg);
	err |= __put_user(temp, &cmd32->start_arg);
	err |= __get_user(temp, &cmd->scan_begin_src);
	err |= __put_user(temp, &cmd32->scan_begin_src);
	err |= __get_user(temp, &cmd->scan_begin_arg);
	err |= __put_user(temp, &cmd32->scan_begin_arg);
	err |= __get_user(temp, &cmd->convert_src);
	err |= __put_user(temp, &cmd32->convert_src);
	err |= __get_user(temp, &cmd->convert_arg);
	err |= __put_user(temp, &cmd32->convert_arg);
	err |= __get_user(temp, &cmd->scan_end_src);
	err |= __put_user(temp, &cmd32->scan_end_src);
	err |= __get_user(temp, &cmd->scan_end_arg);
	err |= __put_user(temp, &cmd32->scan_end_arg);
	err |= __get_user(temp, &cmd->stop_src);
	err |= __put_user(temp, &cmd32->stop_src);
	err |= __get_user(temp, &cmd->stop_arg);
	err |= __put_user(temp, &cmd32->stop_arg);
	/* Assume chanlist pointer is unchanged. */
	err |= __get_user(temp, &cmd->chanlist_len);
	err |= __put_user(temp, &cmd32->chanlist_len);
	/* Assume data pointer is unchanged. */
	err |= __get_user(temp, &cmd->data_len);
	err |= __put_user(temp, &cmd32->data_len);
	return err ? -EFAULT : 0;
}

/* Handle 32-bit COMEDI_CMD ioctl. */
static int compat_cmd(struct file *file, unsigned long arg)
{
	struct comedi_cmd __user *cmd;
	struct comedi32_cmd_struct __user *cmd32;
	int rc;

	cmd32 = compat_ptr(arg);
	cmd = compat_alloc_user_space(sizeof(*cmd));

	rc = get_compat_cmd(cmd, cmd32);
	if (rc)
		return rc;

	return translated_ioctl(file, COMEDI_CMD, (unsigned long)cmd);
}

/* Handle 32-bit COMEDI_CMDTEST ioctl. */
static int compat_cmdtest(struct file *file, unsigned long arg)
{
	struct comedi_cmd __user *cmd;
	struct comedi32_cmd_struct __user *cmd32;
	int rc, err;

	cmd32 = compat_ptr(arg);
	cmd = compat_alloc_user_space(sizeof(*cmd));

	rc = get_compat_cmd(cmd, cmd32);
	if (rc)
		return rc;

	rc = translated_ioctl(file, COMEDI_CMDTEST, (unsigned long)cmd);
	if (rc < 0)
		return rc;

	err = put_compat_cmd(cmd32, cmd);
	if (err)
		rc = err;

	return rc;
}

/* Copy 32-bit insn structure to native insn structure. */
static int get_compat_insn(struct comedi_insn __user *insn,
			   struct comedi32_insn_struct __user *insn32)
{
	int err;
	union {
		unsigned int uint;
		compat_uptr_t uptr;
	} temp;

	/* Copy insn structure.  Ignore the unused members. */
	err = 0;
	if (!access_ok(VERIFY_READ, insn32, sizeof(*insn32))
	    || !access_ok(VERIFY_WRITE, insn, sizeof(*insn)))
		return -EFAULT;

	err |= __get_user(temp.uint, &insn32->insn);
	err |= __put_user(temp.uint, &insn->insn);
	err |= __get_user(temp.uint, &insn32->n);
	err |= __put_user(temp.uint, &insn->n);
	err |= __get_user(temp.uptr, &insn32->data);
	err |= __put_user(compat_ptr(temp.uptr), &insn->data);
	err |= __get_user(temp.uint, &insn32->subdev);
	err |= __put_user(temp.uint, &insn->subdev);
	err |= __get_user(temp.uint, &insn32->chanspec);
	err |= __put_user(temp.uint, &insn->chanspec);
	return err ? -EFAULT : 0;
}

/* Handle 32-bit COMEDI_INSNLIST ioctl. */
static int compat_insnlist(struct file *file, unsigned long arg)
{
	struct combined_insnlist {
		struct comedi_insnlist insnlist;
		struct comedi_insn insn[1];
	} __user *s;
	struct comedi32_insnlist_struct __user *insnlist32;
	struct comedi32_insn_struct __user *insn32;
	compat_uptr_t uptr;
	unsigned int n_insns, n;
	int err, rc;

	insnlist32 = compat_ptr(arg);

	/* Get 32-bit insnlist structure.  */
	if (!access_ok(VERIFY_READ, insnlist32, sizeof(*insnlist32)))
		return -EFAULT;

	err = 0;
	err |= __get_user(n_insns, &insnlist32->n_insns);
	err |= __get_user(uptr, &insnlist32->insns);
	insn32 = compat_ptr(uptr);
	if (err)
		return -EFAULT;

	/* Allocate user memory to copy insnlist and insns into. */
	s = compat_alloc_user_space(offsetof(struct combined_insnlist,
					     insn[n_insns]));

	/* Set native insnlist structure. */
	if (!access_ok(VERIFY_WRITE, &s->insnlist, sizeof(s->insnlist)))
		return -EFAULT;

	err |= __put_user(n_insns, &s->insnlist.n_insns);
	err |= __put_user(&s->insn[0], &s->insnlist.insns);
	if (err)
		return -EFAULT;

	/* Copy insn structures. */
	for (n = 0; n < n_insns; n++) {
		rc = get_compat_insn(&s->insn[n], &insn32[n]);
		if (rc)
			return rc;
	}

	return translated_ioctl(file, COMEDI_INSNLIST,
				(unsigned long)&s->insnlist);
}

/* Handle 32-bit COMEDI_INSN ioctl. */
static int compat_insn(struct file *file, unsigned long arg)
{
	struct comedi_insn __user *insn;
	struct comedi32_insn_struct __user *insn32;
	int rc;

	insn32 = compat_ptr(arg);
	insn = compat_alloc_user_space(sizeof(*insn));

	rc = get_compat_insn(insn, insn32);
	if (rc)
		return rc;

	return translated_ioctl(file, COMEDI_INSN, (unsigned long)insn);
}

/* Process untranslated ioctl. */
/* Returns -ENOIOCTLCMD for unrecognised ioctl codes. */
static inline int raw_ioctl(struct file *file, unsigned int cmd,
			    unsigned long arg)
{
	int rc;

	switch (cmd) {
	case COMEDI_DEVCONFIG:
	case COMEDI_DEVINFO:
	case COMEDI_SUBDINFO:
	case COMEDI_BUFCONFIG:
	case COMEDI_BUFINFO:
		/* Just need to translate the pointer argument. */
		arg = (unsigned long)compat_ptr(arg);
		rc = translated_ioctl(file, cmd, arg);
		break;
	case COMEDI_LOCK:
	case COMEDI_UNLOCK:
	case COMEDI_CANCEL:
	case COMEDI_POLL:
		/* No translation needed. */
		rc = translated_ioctl(file, cmd, arg);
		break;
	case COMEDI32_CHANINFO:
		rc = compat_chaninfo(file, arg);
		break;
	case COMEDI32_RANGEINFO:
		rc = compat_rangeinfo(file, arg);
		break;
	case COMEDI32_CMD:
		rc = compat_cmd(file, arg);
		break;
	case COMEDI32_CMDTEST:
		rc = compat_cmdtest(file, arg);
		break;
	case COMEDI32_INSNLIST:
		rc = compat_insnlist(file, arg);
		break;
	case COMEDI32_INSN:
		rc = compat_insn(file, arg);
		break;
	default:
		rc = -ENOIOCTLCMD;
		break;
	}
	return rc;
}

/* compat_ioctl file operation. */
/* Returns -ENOIOCTLCMD for unrecognised ioctl codes. */
long comedi_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	return raw_ioctl(file, cmd, arg);
}

#endif /* CONFIG_COMPAT */
Commit	Line	Data
ed9eccbe DS	1	/*
	2	comedi/comedi_compat32.c
	3	32-bit ioctl compatibility for 64-bit comedi kernel module.
	4
	5	Author: Ian Abbott, MEV Ltd. <abbotti@mev.co.uk>
	6	Copyright (C) 2007 MEV Ltd. <http://www.mev.co.uk/>
	7
	8	COMEDI - Linux Control and Measurement Device Interface
	9	Copyright (C) 1997-2007 David A. Schleef <ds@schleef.org>
	10
	11	This program is free software; you can redistribute it and/or modify
	12	it under the terms of the GNU General Public License as published by
	13	the Free Software Foundation; either version 2 of the License, or
	14	(at your option) any later version.
	15
	16	This program is distributed in the hope that it will be useful,
	17	but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	GNU General Public License for more details.
	20
	21	You should have received a copy of the GNU General Public License
	22	along with this program; if not, write to the Free Software
	23	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	24
	25	*/
	26
	27	#define __NO_VERSION__
f3662436	28	#include <linux/uaccess.h>
3b6b25b5	29	#include "comedi.h"
ed9eccbe DS	30	#include "comedi_compat32.h"
	31
	32	#ifdef CONFIG_COMPAT
	33
01914923 GKH	34	#define COMEDI32_CHANINFO _IOR(CIO, 3, struct comedi32_chaninfo_struct)
01914923 GKH	35	#define COMEDI32_RANGEINFO _IOR(CIO, 8, struct comedi32_rangeinfo_struct)
ed9eccbe DS	36	/* N.B. COMEDI32_CMD and COMEDI_CMD ought to use _IOWR, not _IOR.
ed9eccbe DS	37	* It's too late to change it now, but it only affects the command number. */
01914923	38	#define COMEDI32_CMD _IOR(CIO, 9, struct comedi32_cmd_struct)
ed9eccbe DS	39	/* N.B. COMEDI32_CMDTEST and COMEDI_CMDTEST ought to use _IOWR, not _IOR.
ed9eccbe DS	40	* It's too late to change it now, but it only affects the command number. */
01914923 GKH	41	#define COMEDI32_CMDTEST _IOR(CIO, 10, struct comedi32_cmd_struct)
	42	#define COMEDI32_INSNLIST _IOR(CIO, 11, struct comedi32_insnlist_struct)
	43	#define COMEDI32_INSN _IOR(CIO, 12, struct comedi32_insn_struct)
ed9eccbe	44
bf8db92e	45	struct comedi32_chaninfo_struct {
ed9eccbe	46	unsigned int subdev;
790c5541	47	compat_uptr_t maxdata_list; /* 32-bit 'unsigned int ' /
0a85b6f0	48	compat_uptr_t flaglist; /* 32-bit 'unsigned int ' /
ed9eccbe DS	49	compat_uptr_t rangelist; /* 32-bit 'unsigned int ' /
ed9eccbe DS	50	unsigned int unused[4];
bf8db92e	51	};
ed9eccbe	52
bf8db92e	53	struct comedi32_rangeinfo_struct {
ed9eccbe DS	54	unsigned int range_type;
ed9eccbe DS	55	compat_uptr_t range_ptr; /* 32-bit 'void ' /
bf8db92e	56	};
ed9eccbe	57
bf8db92e	58	struct comedi32_cmd_struct {
ed9eccbe DS	59	unsigned int subdev;
	60	unsigned int flags;
	61	unsigned int start_src;
	62	unsigned int start_arg;
	63	unsigned int scan_begin_src;
	64	unsigned int scan_begin_arg;
	65	unsigned int convert_src;
	66	unsigned int convert_arg;
	67	unsigned int scan_end_src;
	68	unsigned int scan_end_arg;
	69	unsigned int stop_src;
	70	unsigned int stop_arg;
0a85b6f0	71	compat_uptr_t chanlist; /* 32-bit 'unsigned int ' /
ed9eccbe	72	unsigned int chanlist_len;
0a85b6f0	73	compat_uptr_t data; /* 32-bit 'short ' /
ed9eccbe	74	unsigned int data_len;
bf8db92e	75	};
ed9eccbe	76
bf8db92e	77	struct comedi32_insn_struct {
ed9eccbe DS	78	unsigned int insn;
ed9eccbe DS	79	unsigned int n;
0a85b6f0	80	compat_uptr_t data; /* 32-bit 'unsigned int ' /
ed9eccbe DS	81	unsigned int subdev;
	82	unsigned int chanspec;
	83	unsigned int unused[3];
bf8db92e	84	};
ed9eccbe	85
bf8db92e	86	struct comedi32_insnlist_struct {
ed9eccbe	87	unsigned int n_insns;
0a85b6f0	88	compat_uptr_t insns; /* 32-bit 'struct comedi_insn ' /
bf8db92e	89	};
ed9eccbe DS	90
	91	/* Handle translated ioctl. */
	92	static int translated_ioctl(struct file *file, unsigned int cmd,
0a85b6f0	93	unsigned long arg)
ed9eccbe	94	{
82675f35	95	if (!file->f_op)
ed9eccbe	96	return -ENOTTY;
82675f35	97
a6279bc9 SB	98	if (file->f_op->unlocked_ioctl)
	99	return file->f_op->unlocked_ioctl(file, cmd, arg);
	100
ed9eccbe DS	101	return -ENOTTY;
	102	}
	103
	104	/* Handle 32-bit COMEDI_CHANINFO ioctl. */
	105	static int compat_chaninfo(struct file *file, unsigned long arg)
	106	{
01914923	107	struct comedi_chaninfo __user *chaninfo;
bf8db92e	108	struct comedi32_chaninfo_struct __user *chaninfo32;
ed9eccbe DS	109	int err;
	110	union {
	111	unsigned int uint;
	112	compat_uptr_t uptr;
	113	} temp;
	114
	115	chaninfo32 = compat_ptr(arg);
	116	chaninfo = compat_alloc_user_space(sizeof(*chaninfo));
	117
	118	/* Copy chaninfo structure. Ignore unused members. */
	119	if (!access_ok(VERIFY_READ, chaninfo32, sizeof(*chaninfo32))
0a85b6f0	120	\|\| !access_ok(VERIFY_WRITE, chaninfo, sizeof(*chaninfo))) {
ed9eccbe DS	121	return -EFAULT;
	122	}
	123	err = 0;
	124	err \|= __get_user(temp.uint, &chaninfo32->subdev);
	125	err \|= __put_user(temp.uint, &chaninfo->subdev);
	126	err \|= __get_user(temp.uptr, &chaninfo32->maxdata_list);
	127	err \|= __put_user(compat_ptr(temp.uptr), &chaninfo->maxdata_list);
	128	err \|= __get_user(temp.uptr, &chaninfo32->flaglist);
	129	err \|= __put_user(compat_ptr(temp.uptr), &chaninfo->flaglist);
	130	err \|= __get_user(temp.uptr, &chaninfo32->rangelist);
	131	err \|= __put_user(compat_ptr(temp.uptr), &chaninfo->rangelist);
82675f35	132	if (err)
ed9eccbe	133	return -EFAULT;
ed9eccbe DS	134
	135	return translated_ioctl(file, COMEDI_CHANINFO, (unsigned long)chaninfo);
	136	}
	137
	138	/* Handle 32-bit COMEDI_RANGEINFO ioctl. */
	139	static int compat_rangeinfo(struct file *file, unsigned long arg)
	140	{
d0a353f6	141	struct comedi_rangeinfo __user *rangeinfo;
bf8db92e	142	struct comedi32_rangeinfo_struct __user *rangeinfo32;
ed9eccbe DS	143	int err;
	144	union {
	145	unsigned int uint;
	146	compat_uptr_t uptr;
	147	} temp;
	148
	149	rangeinfo32 = compat_ptr(arg);
	150	rangeinfo = compat_alloc_user_space(sizeof(*rangeinfo));
	151
	152	/* Copy rangeinfo structure. */
	153	if (!access_ok(VERIFY_READ, rangeinfo32, sizeof(*rangeinfo32))
0a85b6f0	154	\|\| !access_ok(VERIFY_WRITE, rangeinfo, sizeof(*rangeinfo))) {
ed9eccbe DS	155	return -EFAULT;
	156	}
	157	err = 0;
	158	err \|= __get_user(temp.uint, &rangeinfo32->range_type);
	159	err \|= __put_user(temp.uint, &rangeinfo->range_type);
	160	err \|= __get_user(temp.uptr, &rangeinfo32->range_ptr);
	161	err \|= __put_user(compat_ptr(temp.uptr), &rangeinfo->range_ptr);
82675f35	162	if (err)
ed9eccbe	163	return -EFAULT;
ed9eccbe DS	164
ed9eccbe DS	165	return translated_ioctl(file, COMEDI_RANGEINFO,
0a85b6f0	166	(unsigned long)rangeinfo);
ed9eccbe DS	167	}
	168
	169	/* Copy 32-bit cmd structure to native cmd structure. */
f3662436 SW	170	static int get_compat_cmd(struct comedi_cmd __user *cmd,
f3662436 SW	171	struct comedi32_cmd_struct __user *cmd32)
ed9eccbe DS	172	{
	173	int err;
	174	union {
	175	unsigned int uint;
	176	compat_uptr_t uptr;
	177	} temp;
	178
	179	/* Copy cmd structure. */
	180	if (!access_ok(VERIFY_READ, cmd32, sizeof(*cmd32))
0a85b6f0	181	\|\| !access_ok(VERIFY_WRITE, cmd, sizeof(*cmd))) {
ed9eccbe DS	182	return -EFAULT;
	183	}
	184	err = 0;
	185	err \|= __get_user(temp.uint, &cmd32->subdev);
	186	err \|= __put_user(temp.uint, &cmd->subdev);
	187	err \|= __get_user(temp.uint, &cmd32->flags);
	188	err \|= __put_user(temp.uint, &cmd->flags);
	189	err \|= __get_user(temp.uint, &cmd32->start_src);
	190	err \|= __put_user(temp.uint, &cmd->start_src);
	191	err \|= __get_user(temp.uint, &cmd32->start_arg);
	192	err \|= __put_user(temp.uint, &cmd->start_arg);
	193	err \|= __get_user(temp.uint, &cmd32->scan_begin_src);
	194	err \|= __put_user(temp.uint, &cmd->scan_begin_src);
	195	err \|= __get_user(temp.uint, &cmd32->scan_begin_arg);
	196	err \|= __put_user(temp.uint, &cmd->scan_begin_arg);
	197	err \|= __get_user(temp.uint, &cmd32->convert_src);
	198	err \|= __put_user(temp.uint, &cmd->convert_src);
	199	err \|= __get_user(temp.uint, &cmd32->convert_arg);
	200	err \|= __put_user(temp.uint, &cmd->convert_arg);
	201	err \|= __get_user(temp.uint, &cmd32->scan_end_src);
	202	err \|= __put_user(temp.uint, &cmd->scan_end_src);
	203	err \|= __get_user(temp.uint, &cmd32->scan_end_arg);
	204	err \|= __put_user(temp.uint, &cmd->scan_end_arg);
	205	err \|= __get_user(temp.uint, &cmd32->stop_src);
	206	err \|= __put_user(temp.uint, &cmd->stop_src);
	207	err \|= __get_user(temp.uint, &cmd32->stop_arg);
	208	err \|= __put_user(temp.uint, &cmd->stop_arg);
	209	err \|= __get_user(temp.uptr, &cmd32->chanlist);
	210	err \|= __put_user(compat_ptr(temp.uptr), &cmd->chanlist);
	211	err \|= __get_user(temp.uint, &cmd32->chanlist_len);
	212	err \|= __put_user(temp.uint, &cmd->chanlist_len);
	213	err \|= __get_user(temp.uptr, &cmd32->data);
	214	err \|= __put_user(compat_ptr(temp.uptr), &cmd->data);
	215	err \|= __get_user(temp.uint, &cmd32->data_len);
	216	err \|= __put_user(temp.uint, &cmd->data_len);
	217	return err ? -EFAULT : 0;
	218	}
	219
	220	/* Copy native cmd structure to 32-bit cmd structure. */
f3662436 SW	221	static int put_compat_cmd(struct comedi32_cmd_struct __user *cmd32,
f3662436 SW	222	struct comedi_cmd __user *cmd)
ed9eccbe DS	223	{
	224	int err;
	225	unsigned int temp;
	226
	227	/* Copy back most of cmd structure. */
	228	/* Assume the pointer values are already valid. */
	229	/* (Could use ptr_to_compat() to set them, but that wasn't implemented
	230	* until kernel version 2.6.11.) */
	231	if (!access_ok(VERIFY_READ, cmd, sizeof(*cmd))
0a85b6f0	232	\|\| !access_ok(VERIFY_WRITE, cmd32, sizeof(*cmd32))) {
ed9eccbe DS	233	return -EFAULT;
	234	}
	235	err = 0;
	236	err \|= __get_user(temp, &cmd->subdev);
	237	err \|= __put_user(temp, &cmd32->subdev);
	238	err \|= __get_user(temp, &cmd->flags);
	239	err \|= __put_user(temp, &cmd32->flags);
	240	err \|= __get_user(temp, &cmd->start_src);
	241	err \|= __put_user(temp, &cmd32->start_src);
	242	err \|= __get_user(temp, &cmd->start_arg);
	243	err \|= __put_user(temp, &cmd32->start_arg);
	244	err \|= __get_user(temp, &cmd->scan_begin_src);
	245	err \|= __put_user(temp, &cmd32->scan_begin_src);
	246	err \|= __get_user(temp, &cmd->scan_begin_arg);
	247	err \|= __put_user(temp, &cmd32->scan_begin_arg);
	248	err \|= __get_user(temp, &cmd->convert_src);
	249	err \|= __put_user(temp, &cmd32->convert_src);
	250	err \|= __get_user(temp, &cmd->convert_arg);
	251	err \|= __put_user(temp, &cmd32->convert_arg);
	252	err \|= __get_user(temp, &cmd->scan_end_src);
	253	err \|= __put_user(temp, &cmd32->scan_end_src);
	254	err \|= __get_user(temp, &cmd->scan_end_arg);
	255	err \|= __put_user(temp, &cmd32->scan_end_arg);
	256	err \|= __get_user(temp, &cmd->stop_src);
	257	err \|= __put_user(temp, &cmd32->stop_src);
	258	err \|= __get_user(temp, &cmd->stop_arg);
	259	err \|= __put_user(temp, &cmd32->stop_arg);
	260	/* Assume chanlist pointer is unchanged. */
	261	err \|= __get_user(temp, &cmd->chanlist_len);
	262	err \|= __put_user(temp, &cmd32->chanlist_len);
	263	/* Assume data pointer is unchanged. */
	264	err \|= __get_user(temp, &cmd->data_len);
	265	err \|= __put_user(temp, &cmd32->data_len);
	266	return err ? -EFAULT : 0;
	267	}
	268
	269	/* Handle 32-bit COMEDI_CMD ioctl. */
	270	static int compat_cmd(struct file *file, unsigned long arg)
	271	{
ea6d0d4c	272	struct comedi_cmd __user *cmd;
bf8db92e	273	struct comedi32_cmd_struct __user *cmd32;
ed9eccbe DS	274	int rc;
	275
	276	cmd32 = compat_ptr(arg);
	277	cmd = compat_alloc_user_space(sizeof(*cmd));
	278
	279	rc = get_compat_cmd(cmd, cmd32);
82675f35	280	if (rc)
ed9eccbe	281	return rc;
ed9eccbe DS	282
	283	return translated_ioctl(file, COMEDI_CMD, (unsigned long)cmd);
	284	}
	285
	286	/* Handle 32-bit COMEDI_CMDTEST ioctl. */
	287	static int compat_cmdtest(struct file *file, unsigned long arg)
	288	{
ea6d0d4c	289	struct comedi_cmd __user *cmd;
bf8db92e	290	struct comedi32_cmd_struct __user *cmd32;
ed9eccbe DS	291	int rc, err;
	292
	293	cmd32 = compat_ptr(arg);
	294	cmd = compat_alloc_user_space(sizeof(*cmd));
	295
	296	rc = get_compat_cmd(cmd, cmd32);
82675f35	297	if (rc)
ed9eccbe	298	return rc;
ed9eccbe DS	299
ed9eccbe DS	300	rc = translated_ioctl(file, COMEDI_CMDTEST, (unsigned long)cmd);
82675f35	301	if (rc < 0)
ed9eccbe	302	return rc;
ed9eccbe DS	303
ed9eccbe DS	304	err = put_compat_cmd(cmd32, cmd);
82675f35	305	if (err)
ed9eccbe	306	rc = err;
82675f35	307
ed9eccbe DS	308	return rc;
	309	}
	310
	311	/* Copy 32-bit insn structure to native insn structure. */
f3662436 SW	312	static int get_compat_insn(struct comedi_insn __user *insn,
f3662436 SW	313	struct comedi32_insn_struct __user *insn32)
ed9eccbe DS	314	{
	315	int err;
	316	union {
	317	unsigned int uint;
	318	compat_uptr_t uptr;
	319	} temp;
	320
	321	/* Copy insn structure. Ignore the unused members. */
	322	err = 0;
	323	if (!access_ok(VERIFY_READ, insn32, sizeof(*insn32))
0a85b6f0	324	\|\| !access_ok(VERIFY_WRITE, insn, sizeof(*insn)))
ed9eccbe	325	return -EFAULT;
82675f35	326
ed9eccbe DS	327	err \|= __get_user(temp.uint, &insn32->insn);
	328	err \|= __put_user(temp.uint, &insn->insn);
	329	err \|= __get_user(temp.uint, &insn32->n);
	330	err \|= __put_user(temp.uint, &insn->n);
	331	err \|= __get_user(temp.uptr, &insn32->data);
	332	err \|= __put_user(compat_ptr(temp.uptr), &insn->data);
	333	err \|= __get_user(temp.uint, &insn32->subdev);
	334	err \|= __put_user(temp.uint, &insn->subdev);
	335	err \|= __get_user(temp.uint, &insn32->chanspec);
	336	err \|= __put_user(temp.uint, &insn->chanspec);
	337	return err ? -EFAULT : 0;
	338	}
	339
	340	/* Handle 32-bit COMEDI_INSNLIST ioctl. */
	341	static int compat_insnlist(struct file *file, unsigned long arg)
	342	{
	343	struct combined_insnlist {
da613f4f	344	struct comedi_insnlist insnlist;
90035c08	345	struct comedi_insn insn[1];
ed9eccbe	346	} __user *s;
bf8db92e BP	347	struct comedi32_insnlist_struct __user *insnlist32;
bf8db92e BP	348	struct comedi32_insn_struct __user *insn32;
ed9eccbe DS	349	compat_uptr_t uptr;
	350	unsigned int n_insns, n;
	351	int err, rc;
	352
	353	insnlist32 = compat_ptr(arg);
	354
	355	/* Get 32-bit insnlist structure. */
f3662436	356	if (!access_ok(VERIFY_READ, insnlist32, sizeof(*insnlist32)))
ed9eccbe	357	return -EFAULT;
f3662436	358
ed9eccbe DS	359	err = 0;
	360	err \|= __get_user(n_insns, &insnlist32->n_insns);
	361	err \|= __get_user(uptr, &insnlist32->insns);
	362	insn32 = compat_ptr(uptr);
82675f35	363	if (err)
ed9eccbe	364	return -EFAULT;
ed9eccbe DS	365
	366	/* Allocate user memory to copy insnlist and insns into. */
	367	s = compat_alloc_user_space(offsetof(struct combined_insnlist,
0a85b6f0	368	insn[n_insns]));
ed9eccbe DS	369
ed9eccbe DS	370	/* Set native insnlist structure. */
f3662436	371	if (!access_ok(VERIFY_WRITE, &s->insnlist, sizeof(s->insnlist)))
ed9eccbe	372	return -EFAULT;
f3662436	373
ed9eccbe DS	374	err \|= __put_user(n_insns, &s->insnlist.n_insns);
ed9eccbe DS	375	err \|= __put_user(&s->insn[0], &s->insnlist.insns);
82675f35	376	if (err)
ed9eccbe	377	return -EFAULT;
ed9eccbe DS	378
	379	/* Copy insn structures. */
	380	for (n = 0; n < n_insns; n++) {
	381	rc = get_compat_insn(&s->insn[n], &insn32[n]);
82675f35	382	if (rc)
ed9eccbe	383	return rc;
ed9eccbe DS	384	}
	385
	386	return translated_ioctl(file, COMEDI_INSNLIST,
0a85b6f0	387	(unsigned long)&s->insnlist);
ed9eccbe DS	388	}
	389
	390	/* Handle 32-bit COMEDI_INSN ioctl. */
	391	static int compat_insn(struct file *file, unsigned long arg)
	392	{
90035c08	393	struct comedi_insn __user *insn;
bf8db92e	394	struct comedi32_insn_struct __user *insn32;
ed9eccbe DS	395	int rc;
	396
	397	insn32 = compat_ptr(arg);
	398	insn = compat_alloc_user_space(sizeof(*insn));
	399
	400	rc = get_compat_insn(insn, insn32);
82675f35	401	if (rc)
ed9eccbe	402	return rc;
ed9eccbe DS	403
	404	return translated_ioctl(file, COMEDI_INSN, (unsigned long)insn);
	405	}
	406
	407	/* Process untranslated ioctl. */
	408	/* Returns -ENOIOCTLCMD for unrecognised ioctl codes. */
	409	static inline int raw_ioctl(struct file *file, unsigned int cmd,
0a85b6f0	410	unsigned long arg)
ed9eccbe DS	411	{
	412	int rc;
	413
	414	switch (cmd) {
	415	case COMEDI_DEVCONFIG:
	416	case COMEDI_DEVINFO:
	417	case COMEDI_SUBDINFO:
	418	case COMEDI_BUFCONFIG:
	419	case COMEDI_BUFINFO:
	420	/* Just need to translate the pointer argument. */
	421	arg = (unsigned long)compat_ptr(arg);
	422	rc = translated_ioctl(file, cmd, arg);
	423	break;
	424	case COMEDI_LOCK:
	425	case COMEDI_UNLOCK:
	426	case COMEDI_CANCEL:
	427	case COMEDI_POLL:
	428	/* No translation needed. */
	429	rc = translated_ioctl(file, cmd, arg);
	430	break;
	431	case COMEDI32_CHANINFO:
	432	rc = compat_chaninfo(file, arg);
	433	break;
	434	case COMEDI32_RANGEINFO:
	435	rc = compat_rangeinfo(file, arg);
	436	break;
	437	case COMEDI32_CMD:
	438	rc = compat_cmd(file, arg);
	439	break;
	440	case COMEDI32_CMDTEST:
	441	rc = compat_cmdtest(file, arg);
	442	break;
	443	case COMEDI32_INSNLIST:
	444	rc = compat_insnlist(file, arg);
	445	break;
	446	case COMEDI32_INSN:
	447	rc = compat_insn(file, arg);
	448	break;
	449	default:
	450	rc = -ENOIOCTLCMD;
	451	break;
	452	}
	453	return rc;
	454	}
	455
ed9eccbe DS	456	/* compat_ioctl file operation. */
ed9eccbe DS	457	/* Returns -ENOIOCTLCMD for unrecognised ioctl codes. */
0a85b6f0	458	long comedi_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
ed9eccbe DS	459	{
	460	return raw_ioctl(file, cmd, arg);
	461	}
	462
0a85b6f0	463	#endif /* CONFIG_COMPAT */