2 * Copyright (c) 2001 Paul Stewart
3 * Copyright (c) 2001 Vojtech Pavlik
5 * HID char devices, giving access to raw HID device events.
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.
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.
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
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>
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>
39 #ifdef CONFIG_USB_DYNAMIC_MINORS
40 #define HIDDEV_MINOR_BASE 0
41 #define HIDDEV_MINORS 256
43 #define HIDDEV_MINOR_BASE 96
44 #define HIDDEV_MINORS 16
46 #define HIDDEV_BUFFER_SIZE 64
51 wait_queue_head_t wait
;
52 struct hid_device
*hid
;
53 struct list_head list
;
57 struct hiddev_usage_ref buffer
[HIDDEV_BUFFER_SIZE
];
61 struct fasync_struct
*fasync
;
62 struct hiddev
*hiddev
;
63 struct list_head node
;
66 static struct hiddev
*hiddev_table
[HIDDEV_MINORS
];
69 * Find a report, given the report's type and ID. The ID can be specified
70 * indirectly by REPORT_ID_FIRST (which returns the first report of the given
71 * type) or by (REPORT_ID_NEXT | old_id), which returns the next report of the
72 * given type which follows old_id.
74 static struct hid_report
*
75 hiddev_lookup_report(struct hid_device
*hid
, struct hiddev_report_info
*rinfo
)
77 unsigned int flags
= rinfo
->report_id
& ~HID_REPORT_ID_MASK
;
78 unsigned int rid
= rinfo
->report_id
& HID_REPORT_ID_MASK
;
79 struct hid_report_enum
*report_enum
;
80 struct hid_report
*report
;
81 struct list_head
*list
;
83 if (rinfo
->report_type
< HID_REPORT_TYPE_MIN
||
84 rinfo
->report_type
> HID_REPORT_TYPE_MAX
)
87 report_enum
= hid
->report_enum
+
88 (rinfo
->report_type
- HID_REPORT_TYPE_MIN
);
91 case 0: /* Nothing to do -- report_id is already set correctly */
94 case HID_REPORT_ID_FIRST
:
95 if (list_empty(&report_enum
->report_list
))
98 list
= report_enum
->report_list
.next
;
99 report
= list_entry(list
, struct hid_report
, list
);
100 rinfo
->report_id
= report
->id
;
103 case HID_REPORT_ID_NEXT
:
104 report
= report_enum
->report_id_hash
[rid
];
108 list
= report
->list
.next
;
109 if (list
== &report_enum
->report_list
)
112 report
= list_entry(list
, struct hid_report
, list
);
113 rinfo
->report_id
= report
->id
;
120 return report_enum
->report_id_hash
[rinfo
->report_id
];
124 * Perform an exhaustive search of the report table for a usage, given its
127 static struct hid_field
*
128 hiddev_lookup_usage(struct hid_device
*hid
, struct hiddev_usage_ref
*uref
)
131 struct hid_report
*report
;
132 struct hid_report_enum
*report_enum
;
133 struct hid_field
*field
;
135 if (uref
->report_type
< HID_REPORT_TYPE_MIN
||
136 uref
->report_type
> HID_REPORT_TYPE_MAX
)
139 report_enum
= hid
->report_enum
+
140 (uref
->report_type
- HID_REPORT_TYPE_MIN
);
142 list_for_each_entry(report
, &report_enum
->report_list
, list
) {
143 for (i
= 0; i
< report
->maxfield
; i
++) {
144 field
= report
->field
[i
];
145 for (j
= 0; j
< field
->maxusage
; j
++) {
146 if (field
->usage
[j
].hid
== uref
->usage_code
) {
147 uref
->report_id
= report
->id
;
148 uref
->field_index
= i
;
149 uref
->usage_index
= j
;
159 static void hiddev_send_event(struct hid_device
*hid
,
160 struct hiddev_usage_ref
*uref
)
162 struct hiddev
*hiddev
= hid
->hiddev
;
163 struct hiddev_list
*list
;
165 list_for_each_entry(list
, &hiddev
->list
, node
) {
166 if (uref
->field_index
!= HID_FIELD_INDEX_NONE
||
167 (list
->flags
& HIDDEV_FLAG_REPORT
) != 0) {
168 list
->buffer
[list
->head
] = *uref
;
169 list
->head
= (list
->head
+ 1) &
170 (HIDDEV_BUFFER_SIZE
- 1);
171 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
175 wake_up_interruptible(&hiddev
->wait
);
179 * This is where hid.c calls into hiddev to pass an event that occurred over
182 void hiddev_hid_event(struct hid_device
*hid
, struct hid_field
*field
,
183 struct hid_usage
*usage
, __s32 value
)
185 unsigned type
= field
->report_type
;
186 struct hiddev_usage_ref uref
;
189 (type
== HID_INPUT_REPORT
) ? HID_REPORT_TYPE_INPUT
:
190 ((type
== HID_OUTPUT_REPORT
) ? HID_REPORT_TYPE_OUTPUT
:
191 ((type
== HID_FEATURE_REPORT
) ? HID_REPORT_TYPE_FEATURE
: 0));
192 uref
.report_id
= field
->report
->id
;
193 uref
.field_index
= field
->index
;
194 uref
.usage_index
= (usage
- field
->usage
);
195 uref
.usage_code
= usage
->hid
;
198 hiddev_send_event(hid
, &uref
);
200 EXPORT_SYMBOL_GPL(hiddev_hid_event
);
202 void hiddev_report_event(struct hid_device
*hid
, struct hid_report
*report
)
204 unsigned type
= report
->type
;
205 struct hiddev_usage_ref uref
;
207 memset(&uref
, 0, sizeof(uref
));
209 (type
== HID_INPUT_REPORT
) ? HID_REPORT_TYPE_INPUT
:
210 ((type
== HID_OUTPUT_REPORT
) ? HID_REPORT_TYPE_OUTPUT
:
211 ((type
== HID_FEATURE_REPORT
) ? HID_REPORT_TYPE_FEATURE
: 0));
212 uref
.report_id
= report
->id
;
213 uref
.field_index
= HID_FIELD_INDEX_NONE
;
215 hiddev_send_event(hid
, &uref
);
220 static int hiddev_fasync(int fd
, struct file
*file
, int on
)
223 struct hiddev_list
*list
= file
->private_data
;
225 retval
= fasync_helper(fd
, file
, on
, &list
->fasync
);
227 return retval
< 0 ? retval
: 0;
234 static int hiddev_release(struct inode
* inode
, struct file
* file
)
236 struct hiddev_list
*list
= file
->private_data
;
238 hiddev_fasync(-1, file
, 0);
239 list_del(&list
->node
);
241 if (!--list
->hiddev
->open
) {
242 if (list
->hiddev
->exist
)
243 hid_close(list
->hiddev
->hid
);
256 static int hiddev_open(struct inode
*inode
, struct file
*file
)
258 struct hiddev_list
*list
;
260 int i
= iminor(inode
) - HIDDEV_MINOR_BASE
;
262 if (i
>= HIDDEV_MINORS
|| !hiddev_table
[i
])
265 if (!(list
= kzalloc(sizeof(struct hiddev_list
), GFP_KERNEL
)))
268 list
->hiddev
= hiddev_table
[i
];
269 list_add_tail(&list
->node
, &hiddev_table
[i
]->list
);
270 file
->private_data
= list
;
272 if (!list
->hiddev
->open
++)
273 if (list
->hiddev
->exist
)
274 hid_open(hiddev_table
[i
]->hid
);
282 static ssize_t
hiddev_write(struct file
* file
, const char __user
* buffer
, size_t count
, loff_t
*ppos
)
290 static ssize_t
hiddev_read(struct file
* file
, char __user
* buffer
, size_t count
, loff_t
*ppos
)
292 DECLARE_WAITQUEUE(wait
, current
);
293 struct hiddev_list
*list
= file
->private_data
;
297 event_size
= ((list
->flags
& HIDDEV_FLAG_UREF
) != 0) ?
298 sizeof(struct hiddev_usage_ref
) : sizeof(struct hiddev_event
);
300 if (count
< event_size
)
303 while (retval
== 0) {
304 if (list
->head
== list
->tail
) {
305 add_wait_queue(&list
->hiddev
->wait
, &wait
);
306 set_current_state(TASK_INTERRUPTIBLE
);
308 while (list
->head
== list
->tail
) {
309 if (file
->f_flags
& O_NONBLOCK
) {
313 if (signal_pending(current
)) {
314 retval
= -ERESTARTSYS
;
317 if (!list
->hiddev
->exist
) {
323 set_current_state(TASK_INTERRUPTIBLE
);
326 set_current_state(TASK_RUNNING
);
327 remove_wait_queue(&list
->hiddev
->wait
, &wait
);
334 while (list
->head
!= list
->tail
&&
335 retval
+ event_size
<= count
) {
336 if ((list
->flags
& HIDDEV_FLAG_UREF
) == 0) {
337 if (list
->buffer
[list
->tail
].field_index
!=
338 HID_FIELD_INDEX_NONE
) {
339 struct hiddev_event event
;
340 event
.hid
= list
->buffer
[list
->tail
].usage_code
;
341 event
.value
= list
->buffer
[list
->tail
].value
;
342 if (copy_to_user(buffer
+ retval
, &event
, sizeof(struct hiddev_event
)))
344 retval
+= sizeof(struct hiddev_event
);
347 if (list
->buffer
[list
->tail
].field_index
!= HID_FIELD_INDEX_NONE
||
348 (list
->flags
& HIDDEV_FLAG_REPORT
) != 0) {
349 if (copy_to_user(buffer
+ retval
, list
->buffer
+ list
->tail
, sizeof(struct hiddev_usage_ref
)))
351 retval
+= sizeof(struct hiddev_usage_ref
);
354 list
->tail
= (list
->tail
+ 1) & (HIDDEV_BUFFER_SIZE
- 1);
364 * No kernel lock - fine
366 static unsigned int hiddev_poll(struct file
*file
, poll_table
*wait
)
368 struct hiddev_list
*list
= file
->private_data
;
370 poll_wait(file
, &list
->hiddev
->wait
, wait
);
371 if (list
->head
!= list
->tail
)
372 return POLLIN
| POLLRDNORM
;
373 if (!list
->hiddev
->exist
)
374 return POLLERR
| POLLHUP
;
381 static int hiddev_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
383 struct hiddev_list
*list
= file
->private_data
;
384 struct hiddev
*hiddev
= list
->hiddev
;
385 struct hid_device
*hid
= hiddev
->hid
;
386 struct usb_device
*dev
= hid
->dev
;
387 struct hiddev_collection_info cinfo
;
388 struct hiddev_report_info rinfo
;
389 struct hiddev_field_info finfo
;
390 struct hiddev_usage_ref_multi
*uref_multi
= NULL
;
391 struct hiddev_usage_ref
*uref
;
392 struct hiddev_devinfo dinfo
;
393 struct hid_report
*report
;
394 struct hid_field
*field
;
395 void __user
*user_arg
= (void __user
*)arg
;
404 return put_user(HID_VERSION
, (int __user
*)arg
);
406 case HIDIOCAPPLICATION
:
407 if (arg
< 0 || arg
>= hid
->maxapplication
)
410 for (i
= 0; i
< hid
->maxcollection
; i
++)
411 if (hid
->collection
[i
].type
==
412 HID_COLLECTION_APPLICATION
&& arg
-- == 0)
415 if (i
== hid
->maxcollection
)
418 return hid
->collection
[i
].usage
;
421 dinfo
.bustype
= BUS_USB
;
422 dinfo
.busnum
= dev
->bus
->busnum
;
423 dinfo
.devnum
= dev
->devnum
;
424 dinfo
.ifnum
= hid
->ifnum
;
425 dinfo
.vendor
= le16_to_cpu(dev
->descriptor
.idVendor
);
426 dinfo
.product
= le16_to_cpu(dev
->descriptor
.idProduct
);
427 dinfo
.version
= le16_to_cpu(dev
->descriptor
.bcdDevice
);
428 dinfo
.num_applications
= hid
->maxapplication
;
429 if (copy_to_user(user_arg
, &dinfo
, sizeof(dinfo
)))
435 if (put_user(list
->flags
, (int __user
*)arg
))
443 if (get_user(newflags
, (int __user
*)arg
))
446 if ((newflags
& ~HIDDEV_FLAGS
) != 0 ||
447 ((newflags
& HIDDEV_FLAG_REPORT
) != 0 &&
448 (newflags
& HIDDEV_FLAG_UREF
) == 0))
451 list
->flags
= newflags
;
461 if (get_user(idx
, (int __user
*)arg
))
464 if ((buf
= kmalloc(HID_STRING_SIZE
, GFP_KERNEL
)) == NULL
)
467 if ((len
= usb_string(dev
, idx
, buf
, HID_STRING_SIZE
-1)) < 0) {
472 if (copy_to_user(user_arg
+sizeof(int), buf
, len
+1)) {
482 case HIDIOCINITREPORT
:
483 hid_init_reports(hid
);
488 if (copy_from_user(&rinfo
, user_arg
, sizeof(rinfo
)))
491 if (rinfo
.report_type
== HID_REPORT_TYPE_OUTPUT
)
494 if ((report
= hiddev_lookup_report(hid
, &rinfo
)) == NULL
)
497 hid_submit_report(hid
, report
, USB_DIR_IN
);
503 if (copy_from_user(&rinfo
, user_arg
, sizeof(rinfo
)))
506 if (rinfo
.report_type
== HID_REPORT_TYPE_INPUT
)
509 if ((report
= hiddev_lookup_report(hid
, &rinfo
)) == NULL
)
512 hid_submit_report(hid
, report
, USB_DIR_OUT
);
517 case HIDIOCGREPORTINFO
:
518 if (copy_from_user(&rinfo
, user_arg
, sizeof(rinfo
)))
521 if ((report
= hiddev_lookup_report(hid
, &rinfo
)) == NULL
)
524 rinfo
.num_fields
= report
->maxfield
;
526 if (copy_to_user(user_arg
, &rinfo
, sizeof(rinfo
)))
531 case HIDIOCGFIELDINFO
:
532 if (copy_from_user(&finfo
, user_arg
, sizeof(finfo
)))
534 rinfo
.report_type
= finfo
.report_type
;
535 rinfo
.report_id
= finfo
.report_id
;
536 if ((report
= hiddev_lookup_report(hid
, &rinfo
)) == NULL
)
539 if (finfo
.field_index
>= report
->maxfield
)
542 field
= report
->field
[finfo
.field_index
];
543 memset(&finfo
, 0, sizeof(finfo
));
544 finfo
.report_type
= rinfo
.report_type
;
545 finfo
.report_id
= rinfo
.report_id
;
546 finfo
.field_index
= field
->report_count
- 1;
547 finfo
.maxusage
= field
->maxusage
;
548 finfo
.flags
= field
->flags
;
549 finfo
.physical
= field
->physical
;
550 finfo
.logical
= field
->logical
;
551 finfo
.application
= field
->application
;
552 finfo
.logical_minimum
= field
->logical_minimum
;
553 finfo
.logical_maximum
= field
->logical_maximum
;
554 finfo
.physical_minimum
= field
->physical_minimum
;
555 finfo
.physical_maximum
= field
->physical_maximum
;
556 finfo
.unit_exponent
= field
->unit_exponent
;
557 finfo
.unit
= field
->unit
;
559 if (copy_to_user(user_arg
, &finfo
, sizeof(finfo
)))
565 uref_multi
= kmalloc(sizeof(struct hiddev_usage_ref_multi
), GFP_KERNEL
);
568 uref
= &uref_multi
->uref
;
569 if (copy_from_user(uref
, user_arg
, sizeof(*uref
)))
572 rinfo
.report_type
= uref
->report_type
;
573 rinfo
.report_id
= uref
->report_id
;
574 if ((report
= hiddev_lookup_report(hid
, &rinfo
)) == NULL
)
577 if (uref
->field_index
>= report
->maxfield
)
580 field
= report
->field
[uref
->field_index
];
581 if (uref
->usage_index
>= field
->maxusage
)
584 uref
->usage_code
= field
->usage
[uref
->usage_index
].hid
;
586 if (copy_to_user(user_arg
, uref
, sizeof(*uref
)))
596 case HIDIOCGCOLLECTIONINDEX
:
597 uref_multi
= kmalloc(sizeof(struct hiddev_usage_ref_multi
), GFP_KERNEL
);
600 uref
= &uref_multi
->uref
;
601 if (cmd
== HIDIOCGUSAGES
|| cmd
== HIDIOCSUSAGES
) {
602 if (copy_from_user(uref_multi
, user_arg
,
603 sizeof(*uref_multi
)))
606 if (copy_from_user(uref
, user_arg
, sizeof(*uref
)))
610 if (cmd
!= HIDIOCGUSAGE
&&
611 cmd
!= HIDIOCGUSAGES
&&
612 uref
->report_type
== HID_REPORT_TYPE_INPUT
)
615 if (uref
->report_id
== HID_REPORT_ID_UNKNOWN
) {
616 field
= hiddev_lookup_usage(hid
, uref
);
620 rinfo
.report_type
= uref
->report_type
;
621 rinfo
.report_id
= uref
->report_id
;
622 if ((report
= hiddev_lookup_report(hid
, &rinfo
)) == NULL
)
625 if (uref
->field_index
>= report
->maxfield
)
628 field
= report
->field
[uref
->field_index
];
630 if (cmd
== HIDIOCGCOLLECTIONINDEX
) {
631 if (uref
->usage_index
>= field
->maxusage
)
633 } else if (uref
->usage_index
>= field
->report_count
)
636 else if ((cmd
== HIDIOCGUSAGES
|| cmd
== HIDIOCSUSAGES
) &&
637 (uref_multi
->num_values
> HID_MAX_MULTI_USAGES
||
638 uref
->usage_index
+ uref_multi
->num_values
> field
->report_count
))
644 uref
->value
= field
->value
[uref
->usage_index
];
645 if (copy_to_user(user_arg
, uref
, sizeof(*uref
)))
650 field
->value
[uref
->usage_index
] = uref
->value
;
653 case HIDIOCGCOLLECTIONINDEX
:
655 return field
->usage
[uref
->usage_index
].collection_index
;
657 for (i
= 0; i
< uref_multi
->num_values
; i
++)
658 uref_multi
->values
[i
] =
659 field
->value
[uref
->usage_index
+ i
];
660 if (copy_to_user(user_arg
, uref_multi
,
661 sizeof(*uref_multi
)))
665 for (i
= 0; i
< uref_multi
->num_values
; i
++)
666 field
->value
[uref
->usage_index
+ i
] =
667 uref_multi
->values
[i
];
681 case HIDIOCGCOLLECTIONINFO
:
682 if (copy_from_user(&cinfo
, user_arg
, sizeof(cinfo
)))
685 if (cinfo
.index
>= hid
->maxcollection
)
688 cinfo
.type
= hid
->collection
[cinfo
.index
].type
;
689 cinfo
.usage
= hid
->collection
[cinfo
.index
].usage
;
690 cinfo
.level
= hid
->collection
[cinfo
.index
].level
;
692 if (copy_to_user(user_arg
, &cinfo
, sizeof(cinfo
)))
698 if (_IOC_TYPE(cmd
) != 'H' || _IOC_DIR(cmd
) != _IOC_READ
)
701 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGNAME(0))) {
705 len
= strlen(hid
->name
) + 1;
706 if (len
> _IOC_SIZE(cmd
))
707 len
= _IOC_SIZE(cmd
);
708 return copy_to_user(user_arg
, hid
->name
, len
) ?
712 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGPHYS(0))) {
716 len
= strlen(hid
->phys
) + 1;
717 if (len
> _IOC_SIZE(cmd
))
718 len
= _IOC_SIZE(cmd
);
719 return copy_to_user(user_arg
, hid
->phys
, len
) ?
726 static const struct file_operations hiddev_fops
= {
727 .owner
= THIS_MODULE
,
729 .write
= hiddev_write
,
732 .release
= hiddev_release
,
733 .ioctl
= hiddev_ioctl
,
734 .fasync
= hiddev_fasync
,
737 static struct usb_class_driver hiddev_class
= {
739 .fops
= &hiddev_fops
,
740 .minor_base
= HIDDEV_MINOR_BASE
,
744 * This is where hid.c calls us to connect a hid device to the hiddev driver
746 int hiddev_connect(struct hid_device
*hid
)
748 struct hiddev
*hiddev
;
752 for (i
= 0; i
< hid
->maxcollection
; i
++)
753 if (hid
->collection
[i
].type
==
754 HID_COLLECTION_APPLICATION
&&
755 !IS_INPUT_APPLICATION(hid
->collection
[i
].usage
))
758 if (i
== hid
->maxcollection
&& (hid
->quirks
& HID_QUIRK_HIDDEV
) == 0)
761 if (!(hiddev
= kzalloc(sizeof(struct hiddev
), GFP_KERNEL
)))
764 retval
= usb_register_dev(hid
->intf
, &hiddev_class
);
766 err("Not able to get a minor for this device.");
771 init_waitqueue_head(&hiddev
->wait
);
772 INIT_LIST_HEAD(&hiddev
->list
);
776 hid
->minor
= hid
->intf
->minor
;
777 hid
->hiddev
= hiddev
;
779 hiddev_table
[hid
->intf
->minor
- HIDDEV_MINOR_BASE
] = hiddev
;
785 * This is where hid.c calls us to disconnect a hiddev device from the
786 * corresponding hid device (usually because the usb device has disconnected)
788 static struct usb_class_driver hiddev_class
;
789 void hiddev_disconnect(struct hid_device
*hid
)
791 struct hiddev
*hiddev
= hid
->hiddev
;
795 hiddev_table
[hiddev
->hid
->minor
- HIDDEV_MINOR_BASE
] = NULL
;
796 usb_deregister_dev(hiddev
->hid
->intf
, &hiddev_class
);
799 hid_close(hiddev
->hid
);
800 wake_up_interruptible(&hiddev
->wait
);
806 /* Currently this driver is a USB driver. It's not a conventional one in
807 * the sense that it doesn't probe at the USB level. Instead it waits to
808 * be connected by HID through the hiddev_connect / hiddev_disconnect
809 * routines. The reason to register as a USB device is to gain part of the
810 * minor number space from the USB major.
812 * In theory, should the HID code be generalized to more than one physical
813 * medium (say, IEEE 1384), this driver will probably need to register its
814 * own major number, and in doing so, no longer need to register with USB.
815 * At that point the probe routine and hiddev_driver struct below will no
820 /* We never attach in this manner, and rely on HID to connect us. This
821 * is why there is no disconnect routine defined in the usb_driver either.
823 static int hiddev_usbd_probe(struct usb_interface
*intf
,
824 const struct usb_device_id
*hiddev_info
)
830 static /* const */ struct usb_driver hiddev_driver
= {
832 .probe
= hiddev_usbd_probe
,
835 int __init
hiddev_init(void)
837 return usb_register(&hiddev_driver
);
840 void hiddev_exit(void)
842 usb_deregister(&hiddev_driver
);