[deliverable/linux.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.
*/

#include <linux/uaccess.h>
#include <linux/compat.h>
#include <linux/fs.h>
#include "comedi.h"
#include "comedi_compat32.h"

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