xref: /openbmc/linux/drivers/hid/usbhid/hiddev.c (revision 9ac8d3fb)
1 /*
2  *  Copyright (c) 2001 Paul Stewart
3  *  Copyright (c) 2001 Vojtech Pavlik
4  *
5  *  HID char devices, giving access to raw HID device events.
6  *
7  */
8 
9 /*
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23  *
24  * Should you need to contact me, the author, you can do so either by
25  * e-mail - mail your message to Paul Stewart <stewart@wetlogic.net>
26  */
27 
28 #include <linux/poll.h>
29 #include <linux/slab.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/smp_lock.h>
33 #include <linux/input.h>
34 #include <linux/usb.h>
35 #include <linux/hid.h>
36 #include <linux/hiddev.h>
37 #include <linux/compat.h>
38 #include "usbhid.h"
39 
40 #ifdef CONFIG_USB_DYNAMIC_MINORS
41 #define HIDDEV_MINOR_BASE	0
42 #define HIDDEV_MINORS		256
43 #else
44 #define HIDDEV_MINOR_BASE	96
45 #define HIDDEV_MINORS		16
46 #endif
47 #define HIDDEV_BUFFER_SIZE	64
48 
49 struct hiddev {
50 	int exist;
51 	int open;
52 	wait_queue_head_t wait;
53 	struct hid_device *hid;
54 	struct list_head list;
55 	spinlock_t list_lock;
56 };
57 
58 struct hiddev_list {
59 	struct hiddev_usage_ref buffer[HIDDEV_BUFFER_SIZE];
60 	int head;
61 	int tail;
62 	unsigned flags;
63 	struct fasync_struct *fasync;
64 	struct hiddev *hiddev;
65 	struct list_head node;
66 };
67 
68 static struct hiddev *hiddev_table[HIDDEV_MINORS];
69 
70 /*
71  * Find a report, given the report's type and ID.  The ID can be specified
72  * indirectly by REPORT_ID_FIRST (which returns the first report of the given
73  * type) or by (REPORT_ID_NEXT | old_id), which returns the next report of the
74  * given type which follows old_id.
75  */
76 static struct hid_report *
77 hiddev_lookup_report(struct hid_device *hid, struct hiddev_report_info *rinfo)
78 {
79 	unsigned int flags = rinfo->report_id & ~HID_REPORT_ID_MASK;
80 	unsigned int rid = rinfo->report_id & HID_REPORT_ID_MASK;
81 	struct hid_report_enum *report_enum;
82 	struct hid_report *report;
83 	struct list_head *list;
84 
85 	if (rinfo->report_type < HID_REPORT_TYPE_MIN ||
86 	    rinfo->report_type > HID_REPORT_TYPE_MAX)
87 		return NULL;
88 
89 	report_enum = hid->report_enum +
90 		(rinfo->report_type - HID_REPORT_TYPE_MIN);
91 
92 	switch (flags) {
93 	case 0: /* Nothing to do -- report_id is already set correctly */
94 		break;
95 
96 	case HID_REPORT_ID_FIRST:
97 		if (list_empty(&report_enum->report_list))
98 			return NULL;
99 
100 		list = report_enum->report_list.next;
101 		report = list_entry(list, struct hid_report, list);
102 		rinfo->report_id = report->id;
103 		break;
104 
105 	case HID_REPORT_ID_NEXT:
106 		report = report_enum->report_id_hash[rid];
107 		if (!report)
108 			return NULL;
109 
110 		list = report->list.next;
111 		if (list == &report_enum->report_list)
112 			return NULL;
113 
114 		report = list_entry(list, struct hid_report, list);
115 		rinfo->report_id = report->id;
116 		break;
117 
118 	default:
119 		return NULL;
120 	}
121 
122 	return report_enum->report_id_hash[rinfo->report_id];
123 }
124 
125 /*
126  * Perform an exhaustive search of the report table for a usage, given its
127  * type and usage id.
128  */
129 static struct hid_field *
130 hiddev_lookup_usage(struct hid_device *hid, struct hiddev_usage_ref *uref)
131 {
132 	int i, j;
133 	struct hid_report *report;
134 	struct hid_report_enum *report_enum;
135 	struct hid_field *field;
136 
137 	if (uref->report_type < HID_REPORT_TYPE_MIN ||
138 	    uref->report_type > HID_REPORT_TYPE_MAX)
139 		return NULL;
140 
141 	report_enum = hid->report_enum +
142 		(uref->report_type - HID_REPORT_TYPE_MIN);
143 
144 	list_for_each_entry(report, &report_enum->report_list, list) {
145 		for (i = 0; i < report->maxfield; i++) {
146 			field = report->field[i];
147 			for (j = 0; j < field->maxusage; j++) {
148 				if (field->usage[j].hid == uref->usage_code) {
149 					uref->report_id = report->id;
150 					uref->field_index = i;
151 					uref->usage_index = j;
152 					return field;
153 				}
154 			}
155 		}
156 	}
157 
158 	return NULL;
159 }
160 
161 static void hiddev_send_event(struct hid_device *hid,
162 			      struct hiddev_usage_ref *uref)
163 {
164 	struct hiddev *hiddev = hid->hiddev;
165 	struct hiddev_list *list;
166 	unsigned long flags;
167 
168 	spin_lock_irqsave(&hiddev->list_lock, flags);
169 	list_for_each_entry(list, &hiddev->list, node) {
170 		if (uref->field_index != HID_FIELD_INDEX_NONE ||
171 		    (list->flags & HIDDEV_FLAG_REPORT) != 0) {
172 			list->buffer[list->head] = *uref;
173 			list->head = (list->head + 1) &
174 				(HIDDEV_BUFFER_SIZE - 1);
175 			kill_fasync(&list->fasync, SIGIO, POLL_IN);
176 		}
177 	}
178 	spin_unlock_irqrestore(&hiddev->list_lock, flags);
179 
180 	wake_up_interruptible(&hiddev->wait);
181 }
182 
183 /*
184  * This is where hid.c calls into hiddev to pass an event that occurred over
185  * the interrupt pipe
186  */
187 void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
188 		      struct hid_usage *usage, __s32 value)
189 {
190 	unsigned type = field->report_type;
191 	struct hiddev_usage_ref uref;
192 
193 	uref.report_type =
194 	  (type == HID_INPUT_REPORT) ? HID_REPORT_TYPE_INPUT :
195 	  ((type == HID_OUTPUT_REPORT) ? HID_REPORT_TYPE_OUTPUT :
196 	   ((type == HID_FEATURE_REPORT) ? HID_REPORT_TYPE_FEATURE : 0));
197 	uref.report_id = field->report->id;
198 	uref.field_index = field->index;
199 	uref.usage_index = (usage - field->usage);
200 	uref.usage_code = usage->hid;
201 	uref.value = value;
202 
203 	hiddev_send_event(hid, &uref);
204 }
205 EXPORT_SYMBOL_GPL(hiddev_hid_event);
206 
207 void hiddev_report_event(struct hid_device *hid, struct hid_report *report)
208 {
209 	unsigned type = report->type;
210 	struct hiddev_usage_ref uref;
211 
212 	memset(&uref, 0, sizeof(uref));
213 	uref.report_type =
214 	  (type == HID_INPUT_REPORT) ? HID_REPORT_TYPE_INPUT :
215 	  ((type == HID_OUTPUT_REPORT) ? HID_REPORT_TYPE_OUTPUT :
216 	   ((type == HID_FEATURE_REPORT) ? HID_REPORT_TYPE_FEATURE : 0));
217 	uref.report_id = report->id;
218 	uref.field_index = HID_FIELD_INDEX_NONE;
219 
220 	hiddev_send_event(hid, &uref);
221 }
222 
223 /*
224  * fasync file op
225  */
226 static int hiddev_fasync(int fd, struct file *file, int on)
227 {
228 	int retval;
229 	struct hiddev_list *list = file->private_data;
230 
231 	retval = fasync_helper(fd, file, on, &list->fasync);
232 
233 	return retval < 0 ? retval : 0;
234 }
235 
236 
237 /*
238  * release file op
239  */
240 static int hiddev_release(struct inode * inode, struct file * file)
241 {
242 	struct hiddev_list *list = file->private_data;
243 	unsigned long flags;
244 
245 	spin_lock_irqsave(&list->hiddev->list_lock, flags);
246 	list_del(&list->node);
247 	spin_unlock_irqrestore(&list->hiddev->list_lock, flags);
248 
249 	if (!--list->hiddev->open) {
250 		if (list->hiddev->exist)
251 			usbhid_close(list->hiddev->hid);
252 		else
253 			kfree(list->hiddev);
254 	}
255 
256 	kfree(list);
257 
258 	return 0;
259 }
260 
261 /*
262  * open file op
263  */
264 static int hiddev_open(struct inode *inode, struct file *file)
265 {
266 	struct hiddev_list *list;
267 	unsigned long flags;
268 
269 	int i = iminor(inode) - HIDDEV_MINOR_BASE;
270 
271 	if (i >= HIDDEV_MINORS || !hiddev_table[i])
272 		return -ENODEV;
273 
274 	if (!(list = kzalloc(sizeof(struct hiddev_list), GFP_KERNEL)))
275 		return -ENOMEM;
276 
277 	list->hiddev = hiddev_table[i];
278 
279 	spin_lock_irqsave(&list->hiddev->list_lock, flags);
280 	list_add_tail(&list->node, &hiddev_table[i]->list);
281 	spin_unlock_irqrestore(&list->hiddev->list_lock, flags);
282 
283 	file->private_data = list;
284 
285 	if (!list->hiddev->open++)
286 		if (list->hiddev->exist)
287 			usbhid_open(hiddev_table[i]->hid);
288 
289 	return 0;
290 }
291 
292 /*
293  * "write" file op
294  */
295 static ssize_t hiddev_write(struct file * file, const char __user * buffer, size_t count, loff_t *ppos)
296 {
297 	return -EINVAL;
298 }
299 
300 /*
301  * "read" file op
302  */
303 static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t count, loff_t *ppos)
304 {
305 	DECLARE_WAITQUEUE(wait, current);
306 	struct hiddev_list *list = file->private_data;
307 	int event_size;
308 	int retval = 0;
309 
310 	event_size = ((list->flags & HIDDEV_FLAG_UREF) != 0) ?
311 		sizeof(struct hiddev_usage_ref) : sizeof(struct hiddev_event);
312 
313 	if (count < event_size)
314 		return 0;
315 
316 	while (retval == 0) {
317 		if (list->head == list->tail) {
318 			add_wait_queue(&list->hiddev->wait, &wait);
319 			set_current_state(TASK_INTERRUPTIBLE);
320 
321 			while (list->head == list->tail) {
322 				if (file->f_flags & O_NONBLOCK) {
323 					retval = -EAGAIN;
324 					break;
325 				}
326 				if (signal_pending(current)) {
327 					retval = -ERESTARTSYS;
328 					break;
329 				}
330 				if (!list->hiddev->exist) {
331 					retval = -EIO;
332 					break;
333 				}
334 
335 				schedule();
336 				set_current_state(TASK_INTERRUPTIBLE);
337 			}
338 
339 			set_current_state(TASK_RUNNING);
340 			remove_wait_queue(&list->hiddev->wait, &wait);
341 		}
342 
343 		if (retval)
344 			return retval;
345 
346 
347 		while (list->head != list->tail &&
348 		       retval + event_size <= count) {
349 			if ((list->flags & HIDDEV_FLAG_UREF) == 0) {
350 				if (list->buffer[list->tail].field_index !=
351 				    HID_FIELD_INDEX_NONE) {
352 					struct hiddev_event event;
353 					event.hid = list->buffer[list->tail].usage_code;
354 					event.value = list->buffer[list->tail].value;
355 					if (copy_to_user(buffer + retval, &event, sizeof(struct hiddev_event)))
356 						return -EFAULT;
357 					retval += sizeof(struct hiddev_event);
358 				}
359 			} else {
360 				if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE ||
361 				    (list->flags & HIDDEV_FLAG_REPORT) != 0) {
362 					if (copy_to_user(buffer + retval, list->buffer + list->tail, sizeof(struct hiddev_usage_ref)))
363 						return -EFAULT;
364 					retval += sizeof(struct hiddev_usage_ref);
365 				}
366 			}
367 			list->tail = (list->tail + 1) & (HIDDEV_BUFFER_SIZE - 1);
368 		}
369 
370 	}
371 
372 	return retval;
373 }
374 
375 /*
376  * "poll" file op
377  * No kernel lock - fine
378  */
379 static unsigned int hiddev_poll(struct file *file, poll_table *wait)
380 {
381 	struct hiddev_list *list = file->private_data;
382 
383 	poll_wait(file, &list->hiddev->wait, wait);
384 	if (list->head != list->tail)
385 		return POLLIN | POLLRDNORM;
386 	if (!list->hiddev->exist)
387 		return POLLERR | POLLHUP;
388 	return 0;
389 }
390 
391 /*
392  * "ioctl" file op
393  */
394 static noinline int hiddev_ioctl_usage(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg)
395 {
396 	struct hid_device *hid = hiddev->hid;
397 	struct hiddev_report_info rinfo;
398 	struct hiddev_usage_ref_multi *uref_multi = NULL;
399 	struct hiddev_usage_ref *uref;
400 	struct hid_report *report;
401 	struct hid_field *field;
402 	int i;
403 
404 	uref_multi = kmalloc(sizeof(struct hiddev_usage_ref_multi), GFP_KERNEL);
405 	if (!uref_multi)
406 		return -ENOMEM;
407 	lock_kernel();
408 	uref = &uref_multi->uref;
409 	if (cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) {
410 		if (copy_from_user(uref_multi, user_arg,
411 				   sizeof(*uref_multi)))
412 			goto fault;
413 	} else {
414 		if (copy_from_user(uref, user_arg, sizeof(*uref)))
415 			goto fault;
416 	}
417 
418 	switch (cmd) {
419 	case HIDIOCGUCODE:
420 		rinfo.report_type = uref->report_type;
421 		rinfo.report_id = uref->report_id;
422 		if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
423 			goto inval;
424 
425 		if (uref->field_index >= report->maxfield)
426 			goto inval;
427 
428 		field = report->field[uref->field_index];
429 		if (uref->usage_index >= field->maxusage)
430 			goto inval;
431 
432 		uref->usage_code = field->usage[uref->usage_index].hid;
433 
434 		if (copy_to_user(user_arg, uref, sizeof(*uref)))
435 			goto fault;
436 
437 		goto goodreturn;
438 
439 	default:
440 		if (cmd != HIDIOCGUSAGE &&
441 		    cmd != HIDIOCGUSAGES &&
442 		    uref->report_type == HID_REPORT_TYPE_INPUT)
443 			goto inval;
444 
445 		if (uref->report_id == HID_REPORT_ID_UNKNOWN) {
446 			field = hiddev_lookup_usage(hid, uref);
447 			if (field == NULL)
448 				goto inval;
449 		} else {
450 			rinfo.report_type = uref->report_type;
451 			rinfo.report_id = uref->report_id;
452 			if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
453 				goto inval;
454 
455 			if (uref->field_index >= report->maxfield)
456 				goto inval;
457 
458 			field = report->field[uref->field_index];
459 
460 			if (cmd == HIDIOCGCOLLECTIONINDEX) {
461 				if (uref->usage_index >= field->maxusage)
462 					goto inval;
463 			} else if (uref->usage_index >= field->report_count)
464 				goto inval;
465 
466 			else if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) &&
467 				 (uref_multi->num_values > HID_MAX_MULTI_USAGES ||
468 				  uref->usage_index + uref_multi->num_values > field->report_count))
469 				goto inval;
470 			}
471 
472 		switch (cmd) {
473 		case HIDIOCGUSAGE:
474 			uref->value = field->value[uref->usage_index];
475 			if (copy_to_user(user_arg, uref, sizeof(*uref)))
476 				goto fault;
477 			goto goodreturn;
478 
479 		case HIDIOCSUSAGE:
480 			field->value[uref->usage_index] = uref->value;
481 			goto goodreturn;
482 
483 		case HIDIOCGCOLLECTIONINDEX:
484 			kfree(uref_multi);
485 			return field->usage[uref->usage_index].collection_index;
486 		case HIDIOCGUSAGES:
487 			for (i = 0; i < uref_multi->num_values; i++)
488 				uref_multi->values[i] =
489 				    field->value[uref->usage_index + i];
490 			if (copy_to_user(user_arg, uref_multi,
491 					 sizeof(*uref_multi)))
492 				goto fault;
493 			goto goodreturn;
494 		case HIDIOCSUSAGES:
495 			for (i = 0; i < uref_multi->num_values; i++)
496 				field->value[uref->usage_index + i] =
497 				    uref_multi->values[i];
498 			goto goodreturn;
499 		}
500 
501 goodreturn:
502 		unlock_kernel();
503 		kfree(uref_multi);
504 		return 0;
505 fault:
506 		unlock_kernel();
507 		kfree(uref_multi);
508 		return -EFAULT;
509 inval:
510 		unlock_kernel();
511 		kfree(uref_multi);
512 		return -EINVAL;
513 	}
514 }
515 
516 static noinline int hiddev_ioctl_string(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg)
517 {
518 	struct hid_device *hid = hiddev->hid;
519 	struct usb_device *dev = hid_to_usb_dev(hid);
520 	int idx, len;
521 	char *buf;
522 
523 	if (get_user(idx, (int __user *)user_arg))
524 		return -EFAULT;
525 
526 	if ((buf = kmalloc(HID_STRING_SIZE, GFP_KERNEL)) == NULL)
527 		return -ENOMEM;
528 
529 	if ((len = usb_string(dev, idx, buf, HID_STRING_SIZE-1)) < 0) {
530 		kfree(buf);
531 		return -EINVAL;
532 	}
533 
534 	if (copy_to_user(user_arg+sizeof(int), buf, len+1)) {
535 		kfree(buf);
536 		return -EFAULT;
537 	}
538 
539 	kfree(buf);
540 
541 	return len;
542 }
543 
544 static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
545 {
546 	struct hiddev_list *list = file->private_data;
547 	struct hiddev *hiddev = list->hiddev;
548 	struct hid_device *hid = hiddev->hid;
549 	struct usb_device *dev = hid_to_usb_dev(hid);
550 	struct hiddev_collection_info cinfo;
551 	struct hiddev_report_info rinfo;
552 	struct hiddev_field_info finfo;
553 	struct hiddev_devinfo dinfo;
554 	struct hid_report *report;
555 	struct hid_field *field;
556 	struct usbhid_device *usbhid = hid->driver_data;
557 	void __user *user_arg = (void __user *)arg;
558 	int i;
559 
560 	/* Called without BKL by compat methods so no BKL taken */
561 
562 	/* FIXME: Who or what stop this racing with a disconnect ?? */
563 	if (!hiddev->exist)
564 		return -EIO;
565 
566 	switch (cmd) {
567 
568 	case HIDIOCGVERSION:
569 		return put_user(HID_VERSION, (int __user *)arg);
570 
571 	case HIDIOCAPPLICATION:
572 		if (arg < 0 || arg >= hid->maxapplication)
573 			return -EINVAL;
574 
575 		for (i = 0; i < hid->maxcollection; i++)
576 			if (hid->collection[i].type ==
577 			    HID_COLLECTION_APPLICATION && arg-- == 0)
578 				break;
579 
580 		if (i == hid->maxcollection)
581 			return -EINVAL;
582 
583 		return hid->collection[i].usage;
584 
585 	case HIDIOCGDEVINFO:
586 		dinfo.bustype = BUS_USB;
587 		dinfo.busnum = dev->bus->busnum;
588 		dinfo.devnum = dev->devnum;
589 		dinfo.ifnum = usbhid->ifnum;
590 		dinfo.vendor = le16_to_cpu(dev->descriptor.idVendor);
591 		dinfo.product = le16_to_cpu(dev->descriptor.idProduct);
592 		dinfo.version = le16_to_cpu(dev->descriptor.bcdDevice);
593 		dinfo.num_applications = hid->maxapplication;
594 		if (copy_to_user(user_arg, &dinfo, sizeof(dinfo)))
595 			return -EFAULT;
596 
597 		return 0;
598 
599 	case HIDIOCGFLAG:
600 		if (put_user(list->flags, (int __user *)arg))
601 			return -EFAULT;
602 
603 		return 0;
604 
605 	case HIDIOCSFLAG:
606 		{
607 			int newflags;
608 			if (get_user(newflags, (int __user *)arg))
609 				return -EFAULT;
610 
611 			if ((newflags & ~HIDDEV_FLAGS) != 0 ||
612 			    ((newflags & HIDDEV_FLAG_REPORT) != 0 &&
613 			     (newflags & HIDDEV_FLAG_UREF) == 0))
614 				return -EINVAL;
615 
616 			list->flags = newflags;
617 
618 			return 0;
619 		}
620 
621 	case HIDIOCGSTRING:
622 		return hiddev_ioctl_string(hiddev, cmd, user_arg);
623 
624 	case HIDIOCINITREPORT:
625 		usbhid_init_reports(hid);
626 
627 		return 0;
628 
629 	case HIDIOCGREPORT:
630 		if (copy_from_user(&rinfo, user_arg, sizeof(rinfo)))
631 			return -EFAULT;
632 
633 		if (rinfo.report_type == HID_REPORT_TYPE_OUTPUT)
634 			return -EINVAL;
635 
636 		if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
637 			return -EINVAL;
638 
639 		usbhid_submit_report(hid, report, USB_DIR_IN);
640 		usbhid_wait_io(hid);
641 
642 		return 0;
643 
644 	case HIDIOCSREPORT:
645 		if (copy_from_user(&rinfo, user_arg, sizeof(rinfo)))
646 			return -EFAULT;
647 
648 		if (rinfo.report_type == HID_REPORT_TYPE_INPUT)
649 			return -EINVAL;
650 
651 		if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
652 			return -EINVAL;
653 
654 		usbhid_submit_report(hid, report, USB_DIR_OUT);
655 		usbhid_wait_io(hid);
656 
657 		return 0;
658 
659 	case HIDIOCGREPORTINFO:
660 		if (copy_from_user(&rinfo, user_arg, sizeof(rinfo)))
661 			return -EFAULT;
662 
663 		if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
664 			return -EINVAL;
665 
666 		rinfo.num_fields = report->maxfield;
667 
668 		if (copy_to_user(user_arg, &rinfo, sizeof(rinfo)))
669 			return -EFAULT;
670 
671 		return 0;
672 
673 	case HIDIOCGFIELDINFO:
674 		if (copy_from_user(&finfo, user_arg, sizeof(finfo)))
675 			return -EFAULT;
676 		rinfo.report_type = finfo.report_type;
677 		rinfo.report_id = finfo.report_id;
678 		if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
679 			return -EINVAL;
680 
681 		if (finfo.field_index >= report->maxfield)
682 			return -EINVAL;
683 
684 		field = report->field[finfo.field_index];
685 		memset(&finfo, 0, sizeof(finfo));
686 		finfo.report_type = rinfo.report_type;
687 		finfo.report_id = rinfo.report_id;
688 		finfo.field_index = field->report_count - 1;
689 		finfo.maxusage = field->maxusage;
690 		finfo.flags = field->flags;
691 		finfo.physical = field->physical;
692 		finfo.logical = field->logical;
693 		finfo.application = field->application;
694 		finfo.logical_minimum = field->logical_minimum;
695 		finfo.logical_maximum = field->logical_maximum;
696 		finfo.physical_minimum = field->physical_minimum;
697 		finfo.physical_maximum = field->physical_maximum;
698 		finfo.unit_exponent = field->unit_exponent;
699 		finfo.unit = field->unit;
700 
701 		if (copy_to_user(user_arg, &finfo, sizeof(finfo)))
702 			return -EFAULT;
703 
704 		return 0;
705 
706 	case HIDIOCGUCODE:
707 		/* fall through */
708 	case HIDIOCGUSAGE:
709 	case HIDIOCSUSAGE:
710 	case HIDIOCGUSAGES:
711 	case HIDIOCSUSAGES:
712 	case HIDIOCGCOLLECTIONINDEX:
713 		return hiddev_ioctl_usage(hiddev, cmd, user_arg);
714 
715 	case HIDIOCGCOLLECTIONINFO:
716 		if (copy_from_user(&cinfo, user_arg, sizeof(cinfo)))
717 			return -EFAULT;
718 
719 		if (cinfo.index >= hid->maxcollection)
720 			return -EINVAL;
721 
722 		cinfo.type = hid->collection[cinfo.index].type;
723 		cinfo.usage = hid->collection[cinfo.index].usage;
724 		cinfo.level = hid->collection[cinfo.index].level;
725 
726 		if (copy_to_user(user_arg, &cinfo, sizeof(cinfo)))
727 			return -EFAULT;
728 		return 0;
729 
730 	default:
731 
732 		if (_IOC_TYPE(cmd) != 'H' || _IOC_DIR(cmd) != _IOC_READ)
733 			return -EINVAL;
734 
735 		if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGNAME(0))) {
736 			int len;
737 			if (!hid->name)
738 				return 0;
739 			len = strlen(hid->name) + 1;
740 			if (len > _IOC_SIZE(cmd))
741 				 len = _IOC_SIZE(cmd);
742 			return copy_to_user(user_arg, hid->name, len) ?
743 				-EFAULT : len;
744 		}
745 
746 		if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGPHYS(0))) {
747 			int len;
748 			if (!hid->phys)
749 				return 0;
750 			len = strlen(hid->phys) + 1;
751 			if (len > _IOC_SIZE(cmd))
752 				len = _IOC_SIZE(cmd);
753 			return copy_to_user(user_arg, hid->phys, len) ?
754 				-EFAULT : len;
755 		}
756 	}
757 	return -EINVAL;
758 }
759 
760 #ifdef CONFIG_COMPAT
761 static long hiddev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
762 {
763 	return hiddev_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
764 }
765 #endif
766 
767 static const struct file_operations hiddev_fops = {
768 	.owner =	THIS_MODULE,
769 	.read =		hiddev_read,
770 	.write =	hiddev_write,
771 	.poll =		hiddev_poll,
772 	.open =		hiddev_open,
773 	.release =	hiddev_release,
774 	.unlocked_ioctl =	hiddev_ioctl,
775 	.fasync =	hiddev_fasync,
776 #ifdef CONFIG_COMPAT
777 	.compat_ioctl	= hiddev_compat_ioctl,
778 #endif
779 };
780 
781 static struct usb_class_driver hiddev_class = {
782 	.name =		"hiddev%d",
783 	.fops =		&hiddev_fops,
784 	.minor_base =	HIDDEV_MINOR_BASE,
785 };
786 
787 /*
788  * This is where hid.c calls us to connect a hid device to the hiddev driver
789  */
790 int hiddev_connect(struct hid_device *hid, unsigned int force)
791 {
792 	struct hiddev *hiddev;
793 	struct usbhid_device *usbhid = hid->driver_data;
794 	int retval;
795 
796 	if (!force) {
797 		unsigned int i;
798 		for (i = 0; i < hid->maxcollection; i++)
799 			if (hid->collection[i].type ==
800 			    HID_COLLECTION_APPLICATION &&
801 			    !IS_INPUT_APPLICATION(hid->collection[i].usage))
802 				break;
803 
804 		if (i == hid->maxcollection)
805 			return -1;
806 	}
807 
808 	if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL)))
809 		return -1;
810 
811 	retval = usb_register_dev(usbhid->intf, &hiddev_class);
812 	if (retval) {
813 		err_hid("Not able to get a minor for this device.");
814 		kfree(hiddev);
815 		return -1;
816 	}
817 
818 	init_waitqueue_head(&hiddev->wait);
819 	INIT_LIST_HEAD(&hiddev->list);
820 	spin_lock_init(&hiddev->list_lock);
821 	hiddev->hid = hid;
822 	hiddev->exist = 1;
823 
824 	hid->minor = usbhid->intf->minor;
825 	hid->hiddev = hiddev;
826 
827 	hiddev_table[usbhid->intf->minor - HIDDEV_MINOR_BASE] = hiddev;
828 
829 	return 0;
830 }
831 
832 /*
833  * This is where hid.c calls us to disconnect a hiddev device from the
834  * corresponding hid device (usually because the usb device has disconnected)
835  */
836 static struct usb_class_driver hiddev_class;
837 void hiddev_disconnect(struct hid_device *hid)
838 {
839 	struct hiddev *hiddev = hid->hiddev;
840 	struct usbhid_device *usbhid = hid->driver_data;
841 
842 	hiddev->exist = 0;
843 
844 	hiddev_table[hiddev->hid->minor - HIDDEV_MINOR_BASE] = NULL;
845 	usb_deregister_dev(usbhid->intf, &hiddev_class);
846 
847 	if (hiddev->open) {
848 		usbhid_close(hiddev->hid);
849 		wake_up_interruptible(&hiddev->wait);
850 	} else {
851 		kfree(hiddev);
852 	}
853 }
854 
855 /* Currently this driver is a USB driver.  It's not a conventional one in
856  * the sense that it doesn't probe at the USB level.  Instead it waits to
857  * be connected by HID through the hiddev_connect / hiddev_disconnect
858  * routines.  The reason to register as a USB device is to gain part of the
859  * minor number space from the USB major.
860  *
861  * In theory, should the HID code be generalized to more than one physical
862  * medium (say, IEEE 1384), this driver will probably need to register its
863  * own major number, and in doing so, no longer need to register with USB.
864  * At that point the probe routine and hiddev_driver struct below will no
865  * longer be useful.
866  */
867 
868 
869 /* We never attach in this manner, and rely on HID to connect us.  This
870  * is why there is no disconnect routine defined in the usb_driver either.
871  */
872 static int hiddev_usbd_probe(struct usb_interface *intf,
873 			     const struct usb_device_id *hiddev_info)
874 {
875 	return -ENODEV;
876 }
877 
878 
879 static /* const */ struct usb_driver hiddev_driver = {
880 	.name =		"hiddev",
881 	.probe =	hiddev_usbd_probe,
882 };
883 
884 int __init hiddev_init(void)
885 {
886 	return usb_register(&hiddev_driver);
887 }
888 
889 void hiddev_exit(void)
890 {
891 	usb_deregister(&hiddev_driver);
892 }
893