[linux-2.6-block.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((unsigned int __force *)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.)
	 */
	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, 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_CMD, (unsigned long)cmd);
	if (rc == -EAGAIN) {
		/* Special case: copy cmd back to user. */
		err = put_compat_cmd(cmd32, cmd);
		if (err)
			rc = err;
	}

	return rc;
}

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

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