Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 3b6b25b5ddf4485e89432a35a7d79d371ba6eba1

Authored by Greg Kroah-Hartman 2010-05-04 06:50:09 +0800

Exists in master and in 7 other branches

Staging: comedi: range.c: properly mark up __user pointers

This is the start of cleaning up the user pointer markings
in the comedi core.

Cc: Ian Abbott <abbotti@mev.co.uk>
Cc: Frank Mori Hess <fmhess@users.sourceforge.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Showing 5 changed files with 10 additions and 8 deletions Inline Diff

drivers/staging/comedi/comedi.h
drivers/staging/comedi/comedi_compat32.c
drivers/staging/comedi/drivers/comedi_bond.c
drivers/staging/comedi/internal.h
drivers/staging/comedi/range.c

drivers/staging/comedi/comedi.h

Diff comments View file @ 3b6b25b

drivers/staging/comedi/comedi_compat32.c

Diff comments View file @ 3b6b25b

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

drivers/staging/comedi/drivers/comedi_bond.c

Diff comments View file @ 3b6b25b

 /*
     comedi/drivers/comedi_bond.c
     A Comedi driver to 'bond' or merge multiple drivers and devices as one.
     COMEDI - Linux Control and Measurement Device Interface
     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
     Copyright (C) 2005 Calin A. Culianu <calin@ajvar.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.
 */
 /*
 Driver: comedi_bond
 Description: A driver to 'bond' (merge) multiple subdevices from multiple
 	     devices together as one.
 Devices:
 Author: ds
 Updated: Mon, 10 Oct 00:18:25 -0500
 Status: works
 This driver allows you to 'bond' (merge) multiple comedi subdevices
 (coming from possibly difference boards and/or drivers) together.  For
 example, if you had a board with 2 different DIO subdevices, and
 another with 1 DIO subdevice, you could 'bond' them with this driver
 so that they look like one big fat DIO subdevice.  This makes writing
 applications slightly easier as you don't have to worry about managing
 different subdevices in the application -- you just worry about
 indexing one linear array of channel id's.
 Right now only DIO subdevices are supported as that's the personal itch
 I am scratching with this driver.  If you want to add support for AI and AO
 subdevs, go right on ahead and do so!
 Commands aren't supported -- although it would be cool if they were.
 Configuration Options:
   List of comedi-minors to bond.  All subdevices of the same type
   within each minor will be concatenated together in the order given here.
 */
 /*
  * The previous block comment is used to automatically generate
  * documentation in Comedi and Comedilib.  The fields:
  *
  * Driver: the name of the driver
  * Description: a short phrase describing the driver.  Don't list boards.
  * Devices: a full list of the boards that attempt to be supported by
  *   the driver.  Format is "(manufacturer) board name [comedi name]",
  *   where comedi_name is the name that is used to configure the board.
  *   See the comment near board_name: in the struct comedi_driver structure
  *   below.  If (manufacturer) or [comedi name] is missing, the previous
  *   value is used.
  * Author: you
  * Updated: date when the _documentation_ was last updated.  Use 'date -R'
  *   to get a value for this.
  * Status: a one-word description of the status.  Valid values are:
  *   works - driver works correctly on most boards supported, and
  *     passes comedi_test.
  *   unknown - unknown.  Usually put there by ds.
  *   experimental - may not work in any particular release.  Author
  *     probably wants assistance testing it.
  *   bitrotten - driver has not been update in a long time, probably
  *     doesn't work, and probably is missing support for significant
  *     Comedi interface features.
  *   untested - author probably wrote it "blind", and is believed to
  *     work, but no confirmation.
  *
  * These headers should be followed by a blank line, and any comments
  * you wish to say about the driver.  The comment area is the place
  * to put any known bugs, limitations, unsupported features, supported
  * command triggers, whether or not commands are supported on particular
  * subdevices, etc.
  *
  * Somewhere in the comment should be information about configuration
  * options that are used with comedi_config.
  */
+#include <linux/string.h>
+#include <linux/slab.h>
 #include "../comedi.h"
 #include "../comedilib.h"
 #include "../comedidev.h"
-#include <linux/string.h>
-#include <linux/slab.h>
 /* The maxiumum number of channels per subdevice. */
 #define MAX_CHANS 256
 #define MODULE_NAME "comedi_bond"
 MODULE_LICENSE("GPL");
 #ifndef STR
 #  define STR1(x) #x
 #  define STR(x) STR1(x)
 #endif
 static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "If true, print extra cryptic debugging output useful"
 		 "only to developers.");
 #define LOG_MSG(x...) printk(KERN_INFO MODULE_NAME": "x)
 #define DEBUG(x...)							\
 	do {								\
 		if (debug)						\
 			printk(KERN_DEBUG MODULE_NAME": DEBUG: "x);	\
 	} while (0)
 #define WARNING(x...)  printk(KERN_WARNING MODULE_NAME ": WARNING: "x)
 #define ERROR(x...)  printk(KERN_ERR MODULE_NAME ": INTERNAL ERROR: "x)
 MODULE_AUTHOR("Calin A. Culianu");
 MODULE_DESCRIPTION(MODULE_NAME "A driver for COMEDI to bond multiple COMEDI "
 		   "devices together as one.  In the words of John Lennon: "
 		   "'And the world will live as one...'");
 /*
  * Board descriptions for two imaginary boards.  Describing the
  * boards in this way is optional, and completely driver-dependent.
  * Some drivers use arrays such as this, other do not.
  */
 struct BondingBoard {
 	const char *name;
 };
 static const struct BondingBoard bondingBoards[] = {
 	{
 	 .name = MODULE_NAME,
 	 },
 };
 /*
  * Useful for shorthand access to the particular board structure
  */
 #define thisboard ((const struct BondingBoard *)dev->board_ptr)
 struct BondedDevice {
 	struct comedi_device *dev;
 	unsigned minor;
 	unsigned subdev;
 	unsigned subdev_type;
 	unsigned nchans;
 	unsigned chanid_offset;	/* The offset into our unified linear
 				   channel-id's of chanid 0 on this
 				   subdevice. */
 };
 /* this structure is for data unique to this hardware driver.  If
    several hardware drivers keep similar information in this structure,
    feel free to suggest moving the variable to the struct comedi_device struct.  */
 struct Private {
 # define MAX_BOARD_NAME 256
 	char name[MAX_BOARD_NAME];
 	struct BondedDevice **devs;
 	unsigned ndevs;
 	struct BondedDevice *chanIdDevMap[MAX_CHANS];
 	unsigned nchans;
 };
 /*
  * most drivers define the following macro to make it easy to
  * access the private structure.
  */
 #define devpriv ((struct Private *)dev->private)
 /*
  * The struct comedi_driver structure tells the Comedi core module
  * which functions to call to configure/deconfigure (attach/detach)
  * the board, and also about the kernel module that contains
  * the device code.
  */
 static int bonding_attach(struct comedi_device *dev,
 			  struct comedi_devconfig *it);
 static int bonding_detach(struct comedi_device *dev);
 /** Build Private array of all devices.. */
 static int doDevConfig(struct comedi_device *dev, struct comedi_devconfig *it);
 static void doDevUnconfig(struct comedi_device *dev);
 /* Ugly implementation of realloc that always copies memory around -- I'm lazy,
  * what can I say?  I like to do wasteful memcopies.. :) */
 static void *Realloc(const void *ptr, size_t len, size_t old_len);
 static struct comedi_driver driver_bonding = {
 	.driver_name = MODULE_NAME,
 	.module = THIS_MODULE,
 	.attach = bonding_attach,
 	.detach = bonding_detach,
 	/* It is not necessary to implement the following members if you are
 	 * writing a driver for a ISA PnP or PCI card */
 	/* Most drivers will support multiple types of boards by
 	 * having an array of board structures.  These were defined
 	 * in skel_boards[] above.  Note that the element 'name'
 	 * was first in the structure -- Comedi uses this fact to
 	 * extract the name of the board without knowing any details
 	 * about the structure except for its length.
 	 * When a device is attached (by comedi_config), the name
 	 * of the device is given to Comedi, and Comedi tries to
 	 * match it by going through the list of board names.  If
 	 * there is a match, the address of the pointer is put
 	 * into dev->board_ptr and driver->attach() is called.
 	 *
 	 * Note that these are not necessary if you can determine
 	 * the type of board in software.  ISA PnP, PCI, and PCMCIA
 	 * devices are such boards.
 	 */
 	.board_name = &bondingBoards[0].name,
 	.offset = sizeof(struct BondingBoard),
 	.num_names = ARRAY_SIZE(bondingBoards),
 };
 static int bonding_dio_insn_bits(struct comedi_device *dev,
 				 struct comedi_subdevice *s,
 				 struct comedi_insn *insn, unsigned int *data);
 static int bonding_dio_insn_config(struct comedi_device *dev,
 				   struct comedi_subdevice *s,
 				   struct comedi_insn *insn,
 				   unsigned int *data);
 /*
  * Attach is called by the Comedi core to configure the driver
  * for a particular board.  If you specified a board_name array
  * in the driver structure, dev->board_ptr contains that
  * address.
  */
 static int bonding_attach(struct comedi_device *dev,
 			  struct comedi_devconfig *it)
 {
 	struct comedi_subdevice *s;
 	LOG_MSG("comedi%d\n", dev->minor);
 	/*
 	 * Allocate the private structure area.  alloc_private() is a
 	 * convenient macro defined in comedidev.h.
 	 */
 	if (alloc_private(dev, sizeof(struct Private)) < 0)
 		return -ENOMEM;
 	/*
 	 * Setup our bonding from config params.. sets up our Private struct..
 	 */
 	if (!doDevConfig(dev, it))
 		return -EINVAL;
 	/*
 	 * Initialize dev->board_name.  Note that we can use the "thisboard"
 	 * macro now, since we just initialized it in the last line.
 	 */
 	dev->board_name = devpriv->name;
 	/*
 	 * Allocate the subdevice structures.  alloc_subdevice() is a
 	 * convenient macro defined in comedidev.h.
 	 */
 	if (alloc_subdevices(dev, 1) < 0)
 		return -ENOMEM;
 	s = dev->subdevices + 0;
 	s->type = COMEDI_SUBD_DIO;
 	s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 	s->n_chan = devpriv->nchans;
 	s->maxdata = 1;
 	s->range_table = &range_digital;
 	s->insn_bits = bonding_dio_insn_bits;
 	s->insn_config = bonding_dio_insn_config;
 	LOG_MSG("attached with %u DIO channels coming from %u different "
 		"subdevices all bonded together.  "
 		"John Lennon would be proud!\n",
 		devpriv->nchans, devpriv->ndevs);
 	return 1;
 }
 /*
  * _detach is called to deconfigure a device.  It should deallocate
  * resources.
  * This function is also called when _attach() fails, so it should be
  * careful not to release resources that were not necessarily
  * allocated by _attach().  dev->private and dev->subdevices are
  * deallocated automatically by the core.
  */
 static int bonding_detach(struct comedi_device *dev)
 {
 	LOG_MSG("comedi%d: remove\n", dev->minor);
 	doDevUnconfig(dev);
 	return 0;
 }
 /* DIO devices are slightly special.  Although it is possible to
  * implement the insn_read/insn_write interface, it is much more
  * useful to applications if you implement the insn_bits interface.
  * This allows packed reading/writing of the DIO channels.  The
  * comedi core can convert between insn_bits and insn_read/write */
 static int bonding_dio_insn_bits(struct comedi_device *dev,
 				 struct comedi_subdevice *s,
 				 struct comedi_insn *insn, unsigned int *data)
 {
 #define LSAMPL_BITS (sizeof(unsigned int)*8)
 	unsigned nchans = LSAMPL_BITS, num_done = 0, i;
 	if (insn->n != 2)
 		return -EINVAL;
 	if (devpriv->nchans < nchans)
 		nchans = devpriv->nchans;
 	/* The insn data is a mask in data[0] and the new data
 	 * in data[1], each channel cooresponding to a bit. */
 	for (i = 0; num_done < nchans && i < devpriv->ndevs; ++i) {
 		struct BondedDevice *bdev = devpriv->devs[i];
 		/* Grab the channel mask and data of only the bits corresponding
 		   to this subdevice.. need to shift them to zero position of
 		   course. */
 		/* Bits corresponding to this subdev. */
 		unsigned int subdevMask = ((1 << bdev->nchans) - 1);
 		unsigned int writeMask, dataBits;
 		/* Argh, we have >= LSAMPL_BITS chans.. take all bits */
 		if (bdev->nchans >= LSAMPL_BITS)
 			subdevMask = (unsigned int)(-1);
 		writeMask = (data[0] >> num_done) & subdevMask;
 		dataBits = (data[1] >> num_done) & subdevMask;
 		/* Read/Write the new digital lines */
 		if (comedi_dio_bitfield(bdev->dev, bdev->subdev, writeMask,
 					&dataBits) != 2)
 			return -EINVAL;
 		/* Make room for the new bits in data[1], the return value */
 		data[1] &= ~(subdevMask << num_done);
 		/* Put the bits in the return value */
 		data[1] |= (dataBits & subdevMask) << num_done;
 		/* Save the new bits to the saved state.. */
 		s->state = data[1];
 		num_done += bdev->nchans;
 	}
 	return insn->n;
 }
 static int bonding_dio_insn_config(struct comedi_device *dev,
 				   struct comedi_subdevice *s,
 				   struct comedi_insn *insn, unsigned int *data)
 {
 	int chan = CR_CHAN(insn->chanspec), ret, io_bits = s->io_bits;
 	unsigned int io;
 	struct BondedDevice *bdev;
 	if (chan < 0 || chan >= devpriv->nchans)
 		return -EINVAL;
 	bdev = devpriv->chanIdDevMap[chan];
 	/* The input or output configuration of each digital line is
 	 * configured by a special insn_config instruction.  chanspec
 	 * contains the channel to be changed, and data[0] contains the
 	 * value COMEDI_INPUT or COMEDI_OUTPUT. */
 	switch (data[0]) {
 	case INSN_CONFIG_DIO_OUTPUT:
 		io = COMEDI_OUTPUT;	/* is this really necessary? */
 		io_bits |= 1 << chan;
 		break;
 	case INSN_CONFIG_DIO_INPUT:
 		io = COMEDI_INPUT;	/* is this really necessary? */
 		io_bits &= ~(1 << chan);
 		break;
 	case INSN_CONFIG_DIO_QUERY:
 		data[1] =
 		    (io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
 		return insn->n;
 		break;
 	default:
 		return -EINVAL;
 		break;
 	}
 	/* 'real' channel id for this subdev.. */
 	chan -= bdev->chanid_offset;
 	ret = comedi_dio_config(bdev->dev, bdev->subdev, chan, io);
 	if (ret != 1)
 		return -EINVAL;
 	/* Finally, save the new io_bits values since we didn't get
 	   an error above. */
 	s->io_bits = io_bits;
 	return insn->n;
 }
 static void *Realloc(const void *oldmem, size_t newlen, size_t oldlen)
 {
 	void *newmem = kmalloc(newlen, GFP_KERNEL);
 	if (newmem && oldmem)
 		memcpy(newmem, oldmem, min(oldlen, newlen));
 	kfree(oldmem);
 	return newmem;
 }
 static int doDevConfig(struct comedi_device *dev, struct comedi_devconfig *it)
 {
 	int i;
 	struct comedi_device *devs_opened[COMEDI_NUM_BOARD_MINORS];
 	memset(devs_opened, 0, sizeof(devs_opened));
 	devpriv->name[0] = 0;;
 	/* Loop through all comedi devices specified on the command-line,
 	   building our device list */
 	for (i = 0; i < COMEDI_NDEVCONFOPTS && (!i || it->options[i]); ++i) {
 		char file[] = "/dev/comediXXXXXX";
 		int minor = it->options[i];
 		struct comedi_device *d;
 		int sdev = -1, nchans, tmp;
 		struct BondedDevice *bdev = NULL;
 		if (minor < 0 || minor >= COMEDI_NUM_BOARD_MINORS) {
 			ERROR("Minor %d is invalid!\n", minor);
 			return 0;
 		}
 		if (minor == dev->minor) {
 			ERROR("Cannot bond this driver to itself!\n");
 			return 0;
 		}
 		if (devs_opened[minor]) {
 			ERROR("Minor %d specified more than once!\n", minor);
 			return 0;
 		}
 		snprintf(file, sizeof(file), "/dev/comedi%u", minor);
 		file[sizeof(file) - 1] = 0;
 		d = devs_opened[minor] = comedi_open(file);
 		if (!d) {
 			ERROR("Minor %u could not be opened\n", minor);
 			return 0;
 		}
 		/* Do DIO, as that's all we support now.. */
 		while ((sdev = comedi_find_subdevice_by_type(d, COMEDI_SUBD_DIO,
 							     sdev + 1)) > -1) {
 			nchans = comedi_get_n_channels(d, sdev);
 			if (nchans <= 0) {
 				ERROR("comedi_get_n_channels() returned %d "
 				      "on minor %u subdev %d!\n",
 				      nchans, minor, sdev);
 				return 0;
 			}
 			bdev = kmalloc(sizeof(*bdev), GFP_KERNEL);
 			if (!bdev) {
 				ERROR("Out of memory.\n");
 				return 0;
 			}
 			bdev->dev = d;
 			bdev->minor = minor;
 			bdev->subdev = sdev;
 			bdev->subdev_type = COMEDI_SUBD_DIO;
 			bdev->nchans = nchans;
 			bdev->chanid_offset = devpriv->nchans;
 			/* map channel id's to BondedDevice * pointer.. */
 			while (nchans--)
 				devpriv->chanIdDevMap[devpriv->nchans++] = bdev;
 			/* Now put bdev pointer at end of devpriv->devs array
 			 * list.. */
 			/* ergh.. ugly.. we need to realloc :(  */
 			tmp = devpriv->ndevs * sizeof(bdev);
 			devpriv->devs =
 			    Realloc(devpriv->devs,
 				    ++devpriv->ndevs * sizeof(bdev), tmp);
 			if (!devpriv->devs) {
 				ERROR("Could not allocate memory. "
 				      "Out of memory?");
 				return 0;
 			}
 			devpriv->devs[devpriv->ndevs - 1] = bdev;
 			{
 	/** Append dev:subdev to devpriv->name */
 				char buf[20];
 				int left =
 				    MAX_BOARD_NAME - strlen(devpriv->name) - 1;
 				snprintf(buf, sizeof(buf), "%d:%d ", dev->minor,
 					 bdev->subdev);
 				buf[sizeof(buf) - 1] = 0;
 				strncat(devpriv->name, buf, left);
 			}
 		}
 	}
 	if (!devpriv->nchans) {
 		ERROR("No channels found!\n");
 		return 0;
 	}
 	return 1;
 }
 static void doDevUnconfig(struct comedi_device *dev)
 {
 	unsigned long devs_closed = 0;
 	if (devpriv) {
 		while (devpriv->ndevs-- && devpriv->devs) {
 			struct BondedDevice *bdev;
 			bdev = devpriv->devs[devpriv->ndevs];
 			if (!bdev)
 				continue;
 			if (!(devs_closed & (0x1 << bdev->minor))) {
 				comedi_close(bdev->dev);
 				devs_closed |= (0x1 << bdev->minor);
 			}
 			kfree(bdev);
 		}
 		kfree(devpriv->devs);
 		devpriv->devs = NULL;
 		kfree(devpriv);
 		dev->private = NULL;
 	}
 }
 static int __init init(void)
 {
 	return comedi_driver_register(&driver_bonding);
 }
 static void __exit cleanup(void)
 {
 	comedi_driver_unregister(&driver_bonding);
 }
 module_init(init);

drivers/staging/comedi/internal.h

Diff comments View file @ 3b6b25b

 /*
  * various internal comedi functions
  */
-int do_rangeinfo_ioctl(struct comedi_device *dev, struct comedi_rangeinfo *arg);
+int do_rangeinfo_ioctl(struct comedi_device *dev,
+		       struct comedi_rangeinfo __user *arg);
 int insn_inval(struct comedi_device *dev, struct comedi_subdevice *s,
 	       struct comedi_insn *insn, unsigned int *data);
 int comedi_alloc_board_minor(struct device *hardware_device);
 void comedi_free_board_minor(unsigned minor);
 void comedi_reset_async_buf(struct comedi_async *async);

drivers/staging/comedi/range.c

Diff comments View file @ 3b6b25b

 /*
     module/range.c
     comedi routines for voltage ranges
     COMEDI - Linux Control and Measurement Device Interface
     Copyright (C) 1997-8 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.
 */
-#include "comedidev.h"
 #include <linux/uaccess.h>
+#include "comedidev.h"
+#include "internal.h"
 const struct comedi_lrange range_bipolar10 = { 1, {BIP_RANGE(10)} };
 EXPORT_SYMBOL(range_bipolar10);
 const struct comedi_lrange range_bipolar5 = { 1, {BIP_RANGE(5)} };
 EXPORT_SYMBOL(range_bipolar5);
 const struct comedi_lrange range_bipolar2_5 = { 1, {BIP_RANGE(2.5)} };
 EXPORT_SYMBOL(range_bipolar2_5);
 const struct comedi_lrange range_unipolar10 = { 1, {UNI_RANGE(10)} };
 EXPORT_SYMBOL(range_unipolar10);
 const struct comedi_lrange range_unipolar5 = { 1, {UNI_RANGE(5)} };
 EXPORT_SYMBOL(range_unipolar5);
 const struct comedi_lrange range_unknown = { 1, {{0, 1000000, UNIT_none} } };
 EXPORT_SYMBOL(range_unknown);
 /*
 	COMEDI_RANGEINFO
 	range information ioctl
 	arg:
 		pointer to rangeinfo structure
 	reads:
 		range info structure
 	writes:
 		n struct comedi_krange structures to rangeinfo->range_ptr
 */
-int do_rangeinfo_ioctl(struct comedi_device *dev, struct comedi_rangeinfo *arg)
+int do_rangeinfo_ioctl(struct comedi_device *dev,
+		       struct comedi_rangeinfo __user *arg)
 {
 	struct comedi_rangeinfo it;
 	int subd, chan;
 	const struct comedi_lrange *lr;
 	struct comedi_subdevice *s;
 	if (copy_from_user(&it, arg, sizeof(struct comedi_rangeinfo)))
 		return -EFAULT;
 	subd = (it.range_type >> 24) & 0xf;
 	chan = (it.range_type >> 16) & 0xff;
 	if (!dev->attached)
 		return -EINVAL;
 	if (subd >= dev->n_subdevices)
 		return -EINVAL;
 	s = dev->subdevices + subd;
 	if (s->range_table) {
 		lr = s->range_table;
 	} else if (s->range_table_list) {
 		if (chan >= s->n_chan)
 			return -EINVAL;
 		lr = s->range_table_list[chan];
 	} else {
 		return -EINVAL;
 	}
 	if (RANGE_LENGTH(it.range_type) != lr->length) {
 		DPRINTK("wrong length %d should be %d (0x%08x)\n",
 			RANGE_LENGTH(it.range_type), lr->length, it.range_type);
 		return -EINVAL;
 	}
 	if (copy_to_user(it.range_ptr, lr->range,
 			 sizeof(struct comedi_krange) * lr->length))
 		return -EFAULT;
 	return 0;
 }
 static int aref_invalid(struct comedi_subdevice *s, unsigned int chanspec)
 {
 	unsigned int aref;
 	/*  disable reporting invalid arefs... maybe someday */
 	return 0;
 	aref = CR_AREF(chanspec);
 	switch (aref) {
 	case AREF_DIFF:
 		if (s->subdev_flags & SDF_DIFF)
 			return 0;
 		break;
 	case AREF_COMMON:
 		if (s->subdev_flags & SDF_COMMON)
 			return 0;
 		break;
 	case AREF_GROUND:
 		if (s->subdev_flags & SDF_GROUND)
 			return 0;
 		break;
 	case AREF_OTHER:
 		if (s->subdev_flags & SDF_OTHER)
 			return 0;
 		break;
 	default:
 		break;
 	}
 	DPRINTK("subdevice does not support aref %i", aref);
 	return 1;
 }
 /*
    This function checks each element in a channel/gain list to make
    make sure it is valid.
 */
 int comedi_check_chanlist(struct comedi_subdevice *s, int n,
 			  unsigned int *chanlist)
 {
 	int i;
 	int chan;
 	if (s->range_table) {
 		for (i = 0; i < n; i++)
 			if (CR_CHAN(chanlist[i]) >= s->n_chan ||
 			    CR_RANGE(chanlist[i]) >= s->range_table->length
 			    || aref_invalid(s, chanlist[i])) {
 				printk(KERN_ERR "bad chanlist[%d]=0x%08x "
 				       "in_chan=%d range length=%d\n", i,
 				       chanlist[i], s->n_chan,
 				       s->range_table->length);
 				return -EINVAL;
 			}
 	} else if (s->range_table_list) {
 		for (i = 0; i < n; i++) {
 			chan = CR_CHAN(chanlist[i]);
 			if (chan >= s->n_chan ||
 			    CR_RANGE(chanlist[i]) >=
 			    s->range_table_list[chan]->length
 			    || aref_invalid(s, chanlist[i])) {
 				printk(KERN_ERR "bad chanlist[%d]=0x%08x\n",
 				       i, chanlist[i]);
 				return -EINVAL;
 			}
 		}
 	} else {
 		printk(KERN_ERR "comedi: (bug) no range type list!\n");
 		return -EINVAL;
 	}
 	return 0;
 }
 EXPORT_SYMBOL(comedi_check_chanlist);

1	/*	1	/*
2	include/comedi.h (installed as /usr/include/comedi.h)	2	include/comedi.h (installed as /usr/include/comedi.h)
3	header file for comedi	3	header file for comedi
4		4
5	COMEDI - Linux Control and Measurement Device Interface	5	COMEDI - Linux Control and Measurement Device Interface
6	Copyright (C) 1998-2001 David A. Schleef <ds@schleef.org>	6	Copyright (C) 1998-2001 David A. Schleef <ds@schleef.org>
7		7
8	This program is free software; you can redistribute it and/or modify	8	This program is free software; you can redistribute it and/or modify
9	it under the terms of the GNU Lesser General Public License as published by	9	it under the terms of the GNU Lesser General Public License as published by
10	the Free Software Foundation; either version 2 of the License, or	10	the Free Software Foundation; either version 2 of the License, or
11	(at your option) any later version.	11	(at your option) any later version.
12		12
13	This program is distributed in the hope that it will be useful,	13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.	16	GNU General Public License for more details.
17		17
18	You should have received a copy of the GNU General Public License	18	You should have received a copy of the GNU General Public License
19	along with this program; if not, write to the Free Software	19	along with this program; if not, write to the Free Software
20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21		21
22	*/	22	*/
23		23
24	#ifndef _COMEDI_H	24	#ifndef _COMEDI_H
25	#define _COMEDI_H	25	#define _COMEDI_H
26		26
27	#define COMEDI_MAJORVERSION 0	27	#define COMEDI_MAJORVERSION 0
28	#define COMEDI_MINORVERSION 7	28	#define COMEDI_MINORVERSION 7
29	#define COMEDI_MICROVERSION 76	29	#define COMEDI_MICROVERSION 76
30	#define VERSION "0.7.76"	30	#define VERSION "0.7.76"
31		31
32	/* comedi's major device number */	32	/* comedi's major device number */
33	#define COMEDI_MAJOR 98	33	#define COMEDI_MAJOR 98
34		34
35	/*	35	/*
36	maximum number of minor devices. This can be increased, although	36	maximum number of minor devices. This can be increased, although
37	kernel structures are currently statically allocated, thus you	37	kernel structures are currently statically allocated, thus you
38	don't want this to be much more than you actually use.	38	don't want this to be much more than you actually use.
39	*/	39	*/
40	#define COMEDI_NDEVICES 16	40	#define COMEDI_NDEVICES 16