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/sched/signal.h>
31 #include <linux/module.h>
32 #include <linux/init.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 <linux/vmalloc.h>
39 #include <linux/nospec.h>
42 #ifdef CONFIG_USB_DYNAMIC_MINORS
43 #define HIDDEV_MINOR_BASE 0
44 #define HIDDEV_MINORS 256
46 #define HIDDEV_MINOR_BASE 96
47 #define HIDDEV_MINORS 16
49 #define HIDDEV_BUFFER_SIZE 2048
52 struct hiddev_usage_ref buffer
[HIDDEV_BUFFER_SIZE
];
56 struct fasync_struct
*fasync
;
57 struct hiddev
*hiddev
;
58 struct list_head node
;
59 struct mutex thread_lock
;
63 * Find a report, given the report's type and ID. The ID can be specified
64 * indirectly by REPORT_ID_FIRST (which returns the first report of the given
65 * type) or by (REPORT_ID_NEXT | old_id), which returns the next report of the
66 * given type which follows old_id.
68 static struct hid_report
*
69 hiddev_lookup_report(struct hid_device
*hid
, struct hiddev_report_info
*rinfo
)
71 unsigned int flags
= rinfo
->report_id
& ~HID_REPORT_ID_MASK
;
72 unsigned int rid
= rinfo
->report_id
& HID_REPORT_ID_MASK
;
73 struct hid_report_enum
*report_enum
;
74 struct hid_report
*report
;
75 struct list_head
*list
;
77 if (rinfo
->report_type
< HID_REPORT_TYPE_MIN
||
78 rinfo
->report_type
> HID_REPORT_TYPE_MAX
)
81 report_enum
= hid
->report_enum
+
82 (rinfo
->report_type
- HID_REPORT_TYPE_MIN
);
85 case 0: /* Nothing to do -- report_id is already set correctly */
88 case HID_REPORT_ID_FIRST
:
89 if (list_empty(&report_enum
->report_list
))
92 list
= report_enum
->report_list
.next
;
93 report
= list_entry(list
, struct hid_report
, list
);
94 rinfo
->report_id
= report
->id
;
97 case HID_REPORT_ID_NEXT
:
98 report
= report_enum
->report_id_hash
[rid
];
102 list
= report
->list
.next
;
103 if (list
== &report_enum
->report_list
)
106 report
= list_entry(list
, struct hid_report
, list
);
107 rinfo
->report_id
= report
->id
;
114 return report_enum
->report_id_hash
[rinfo
->report_id
];
118 * Perform an exhaustive search of the report table for a usage, given its
121 static struct hid_field
*
122 hiddev_lookup_usage(struct hid_device
*hid
, struct hiddev_usage_ref
*uref
)
125 struct hid_report
*report
;
126 struct hid_report_enum
*report_enum
;
127 struct hid_field
*field
;
129 if (uref
->report_type
< HID_REPORT_TYPE_MIN
||
130 uref
->report_type
> HID_REPORT_TYPE_MAX
)
133 report_enum
= hid
->report_enum
+
134 (uref
->report_type
- HID_REPORT_TYPE_MIN
);
136 list_for_each_entry(report
, &report_enum
->report_list
, list
) {
137 for (i
= 0; i
< report
->maxfield
; i
++) {
138 field
= report
->field
[i
];
139 for (j
= 0; j
< field
->maxusage
; j
++) {
140 if (field
->usage
[j
].hid
== uref
->usage_code
) {
141 uref
->report_id
= report
->id
;
142 uref
->field_index
= i
;
143 uref
->usage_index
= j
;
153 static void hiddev_send_event(struct hid_device
*hid
,
154 struct hiddev_usage_ref
*uref
)
156 struct hiddev
*hiddev
= hid
->hiddev
;
157 struct hiddev_list
*list
;
160 spin_lock_irqsave(&hiddev
->list_lock
, flags
);
161 list_for_each_entry(list
, &hiddev
->list
, node
) {
162 if (uref
->field_index
!= HID_FIELD_INDEX_NONE
||
163 (list
->flags
& HIDDEV_FLAG_REPORT
) != 0) {
164 list
->buffer
[list
->head
] = *uref
;
165 list
->head
= (list
->head
+ 1) &
166 (HIDDEV_BUFFER_SIZE
- 1);
167 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
170 spin_unlock_irqrestore(&hiddev
->list_lock
, flags
);
172 wake_up_interruptible(&hiddev
->wait
);
176 * This is where hid.c calls into hiddev to pass an event that occurred over
179 void hiddev_hid_event(struct hid_device
*hid
, struct hid_field
*field
,
180 struct hid_usage
*usage
, __s32 value
)
182 unsigned type
= field
->report_type
;
183 struct hiddev_usage_ref uref
;
186 (type
== HID_INPUT_REPORT
) ? HID_REPORT_TYPE_INPUT
:
187 ((type
== HID_OUTPUT_REPORT
) ? HID_REPORT_TYPE_OUTPUT
:
188 ((type
== HID_FEATURE_REPORT
) ? HID_REPORT_TYPE_FEATURE
: 0));
189 uref
.report_id
= field
->report
->id
;
190 uref
.field_index
= field
->index
;
191 uref
.usage_index
= (usage
- field
->usage
);
192 uref
.usage_code
= usage
->hid
;
195 hiddev_send_event(hid
, &uref
);
197 EXPORT_SYMBOL_GPL(hiddev_hid_event
);
199 void hiddev_report_event(struct hid_device
*hid
, struct hid_report
*report
)
201 unsigned type
= report
->type
;
202 struct hiddev_usage_ref uref
;
204 memset(&uref
, 0, sizeof(uref
));
206 (type
== HID_INPUT_REPORT
) ? HID_REPORT_TYPE_INPUT
:
207 ((type
== HID_OUTPUT_REPORT
) ? HID_REPORT_TYPE_OUTPUT
:
208 ((type
== HID_FEATURE_REPORT
) ? HID_REPORT_TYPE_FEATURE
: 0));
209 uref
.report_id
= report
->id
;
210 uref
.field_index
= HID_FIELD_INDEX_NONE
;
212 hiddev_send_event(hid
, &uref
);
218 static int hiddev_fasync(int fd
, struct file
*file
, int on
)
220 struct hiddev_list
*list
= file
->private_data
;
222 return fasync_helper(fd
, file
, on
, &list
->fasync
);
229 static int hiddev_release(struct inode
* inode
, struct file
* file
)
231 struct hiddev_list
*list
= file
->private_data
;
234 spin_lock_irqsave(&list
->hiddev
->list_lock
, flags
);
235 list_del(&list
->node
);
236 spin_unlock_irqrestore(&list
->hiddev
->list_lock
, flags
);
238 mutex_lock(&list
->hiddev
->existancelock
);
239 if (!--list
->hiddev
->open
) {
240 if (list
->hiddev
->exist
) {
241 hid_hw_close(list
->hiddev
->hid
);
242 hid_hw_power(list
->hiddev
->hid
, PM_HINT_NORMAL
);
244 mutex_unlock(&list
->hiddev
->existancelock
);
251 mutex_unlock(&list
->hiddev
->existancelock
);
260 static int hiddev_open(struct inode
*inode
, struct file
*file
)
262 struct hiddev_list
*list
;
263 struct usb_interface
*intf
;
264 struct hid_device
*hid
;
265 struct hiddev
*hiddev
;
268 intf
= usbhid_find_interface(iminor(inode
));
271 hid
= usb_get_intfdata(intf
);
272 hiddev
= hid
->hiddev
;
274 if (!(list
= vzalloc(sizeof(struct hiddev_list
))))
276 mutex_init(&list
->thread_lock
);
277 list
->hiddev
= hiddev
;
278 file
->private_data
= list
;
281 * no need for locking because the USB major number
282 * is shared which usbcore guards against disconnect
284 if (list
->hiddev
->exist
) {
285 if (!list
->hiddev
->open
++) {
286 res
= hid_hw_open(hiddev
->hid
);
295 spin_lock_irq(&list
->hiddev
->list_lock
);
296 list_add_tail(&list
->node
, &hiddev
->list
);
297 spin_unlock_irq(&list
->hiddev
->list_lock
);
299 mutex_lock(&hiddev
->existancelock
);
301 * recheck exist with existance lock held to
302 * avoid opening a disconnected device
304 if (!list
->hiddev
->exist
) {
308 if (!list
->hiddev
->open
++)
309 if (list
->hiddev
->exist
) {
310 struct hid_device
*hid
= hiddev
->hid
;
311 res
= hid_hw_power(hid
, PM_HINT_FULLON
);
314 res
= hid_hw_open(hid
);
316 goto bail_normal_power
;
318 mutex_unlock(&hiddev
->existancelock
);
321 hid_hw_power(hid
, PM_HINT_NORMAL
);
323 mutex_unlock(&hiddev
->existancelock
);
325 file
->private_data
= NULL
;
333 static ssize_t
hiddev_write(struct file
* file
, const char __user
* buffer
, size_t count
, loff_t
*ppos
)
341 static ssize_t
hiddev_read(struct file
* file
, char __user
* buffer
, size_t count
, loff_t
*ppos
)
344 struct hiddev_list
*list
= file
->private_data
;
348 event_size
= ((list
->flags
& HIDDEV_FLAG_UREF
) != 0) ?
349 sizeof(struct hiddev_usage_ref
) : sizeof(struct hiddev_event
);
351 if (count
< event_size
)
354 /* lock against other threads */
355 retval
= mutex_lock_interruptible(&list
->thread_lock
);
359 while (retval
== 0) {
360 if (list
->head
== list
->tail
) {
361 prepare_to_wait(&list
->hiddev
->wait
, &wait
, TASK_INTERRUPTIBLE
);
363 while (list
->head
== list
->tail
) {
364 if (signal_pending(current
)) {
365 retval
= -ERESTARTSYS
;
368 if (!list
->hiddev
->exist
) {
372 if (file
->f_flags
& O_NONBLOCK
) {
377 /* let O_NONBLOCK tasks run */
378 mutex_unlock(&list
->thread_lock
);
380 if (mutex_lock_interruptible(&list
->thread_lock
)) {
381 finish_wait(&list
->hiddev
->wait
, &wait
);
384 set_current_state(TASK_INTERRUPTIBLE
);
386 finish_wait(&list
->hiddev
->wait
, &wait
);
391 mutex_unlock(&list
->thread_lock
);
396 while (list
->head
!= list
->tail
&&
397 retval
+ event_size
<= count
) {
398 if ((list
->flags
& HIDDEV_FLAG_UREF
) == 0) {
399 if (list
->buffer
[list
->tail
].field_index
!= HID_FIELD_INDEX_NONE
) {
400 struct hiddev_event event
;
402 event
.hid
= list
->buffer
[list
->tail
].usage_code
;
403 event
.value
= list
->buffer
[list
->tail
].value
;
404 if (copy_to_user(buffer
+ retval
, &event
, sizeof(struct hiddev_event
))) {
405 mutex_unlock(&list
->thread_lock
);
408 retval
+= sizeof(struct hiddev_event
);
411 if (list
->buffer
[list
->tail
].field_index
!= HID_FIELD_INDEX_NONE
||
412 (list
->flags
& HIDDEV_FLAG_REPORT
) != 0) {
414 if (copy_to_user(buffer
+ retval
, list
->buffer
+ list
->tail
, sizeof(struct hiddev_usage_ref
))) {
415 mutex_unlock(&list
->thread_lock
);
418 retval
+= sizeof(struct hiddev_usage_ref
);
421 list
->tail
= (list
->tail
+ 1) & (HIDDEV_BUFFER_SIZE
- 1);
425 mutex_unlock(&list
->thread_lock
);
432 * No kernel lock - fine
434 static unsigned int hiddev_poll(struct file
*file
, poll_table
*wait
)
436 struct hiddev_list
*list
= file
->private_data
;
438 poll_wait(file
, &list
->hiddev
->wait
, wait
);
439 if (list
->head
!= list
->tail
)
440 return POLLIN
| POLLRDNORM
;
441 if (!list
->hiddev
->exist
)
442 return POLLERR
| POLLHUP
;
449 static noinline
int hiddev_ioctl_usage(struct hiddev
*hiddev
, unsigned int cmd
, void __user
*user_arg
)
451 struct hid_device
*hid
= hiddev
->hid
;
452 struct hiddev_report_info rinfo
;
453 struct hiddev_usage_ref_multi
*uref_multi
= NULL
;
454 struct hiddev_usage_ref
*uref
;
455 struct hid_report
*report
;
456 struct hid_field
*field
;
459 uref_multi
= kmalloc(sizeof(struct hiddev_usage_ref_multi
), GFP_KERNEL
);
462 uref
= &uref_multi
->uref
;
463 if (cmd
== HIDIOCGUSAGES
|| cmd
== HIDIOCSUSAGES
) {
464 if (copy_from_user(uref_multi
, user_arg
,
465 sizeof(*uref_multi
)))
468 if (copy_from_user(uref
, user_arg
, sizeof(*uref
)))
474 rinfo
.report_type
= uref
->report_type
;
475 rinfo
.report_id
= uref
->report_id
;
476 if ((report
= hiddev_lookup_report(hid
, &rinfo
)) == NULL
)
479 if (uref
->field_index
>= report
->maxfield
)
481 uref
->field_index
= array_index_nospec(uref
->field_index
,
484 field
= report
->field
[uref
->field_index
];
485 if (uref
->usage_index
>= field
->maxusage
)
487 uref
->usage_index
= array_index_nospec(uref
->usage_index
,
490 uref
->usage_code
= field
->usage
[uref
->usage_index
].hid
;
492 if (copy_to_user(user_arg
, uref
, sizeof(*uref
)))
498 if (cmd
!= HIDIOCGUSAGE
&&
499 cmd
!= HIDIOCGUSAGES
&&
500 uref
->report_type
== HID_REPORT_TYPE_INPUT
)
503 if (uref
->report_id
== HID_REPORT_ID_UNKNOWN
) {
504 field
= hiddev_lookup_usage(hid
, uref
);
508 rinfo
.report_type
= uref
->report_type
;
509 rinfo
.report_id
= uref
->report_id
;
510 if ((report
= hiddev_lookup_report(hid
, &rinfo
)) == NULL
)
513 if (uref
->field_index
>= report
->maxfield
)
515 uref
->field_index
= array_index_nospec(uref
->field_index
,
518 field
= report
->field
[uref
->field_index
];
520 if (cmd
== HIDIOCGCOLLECTIONINDEX
) {
521 if (uref
->usage_index
>= field
->maxusage
)
524 array_index_nospec(uref
->usage_index
,
526 } else if (uref
->usage_index
>= field
->report_count
)
530 if (cmd
== HIDIOCGUSAGES
|| cmd
== HIDIOCSUSAGES
) {
531 if (uref_multi
->num_values
> HID_MAX_MULTI_USAGES
||
532 uref
->usage_index
+ uref_multi
->num_values
>
537 array_index_nospec(uref
->usage_index
,
538 field
->report_count
-
539 uref_multi
->num_values
);
544 uref
->value
= field
->value
[uref
->usage_index
];
545 if (copy_to_user(user_arg
, uref
, sizeof(*uref
)))
550 field
->value
[uref
->usage_index
] = uref
->value
;
553 case HIDIOCGCOLLECTIONINDEX
:
554 i
= field
->usage
[uref
->usage_index
].collection_index
;
558 for (i
= 0; i
< uref_multi
->num_values
; i
++)
559 uref_multi
->values
[i
] =
560 field
->value
[uref
->usage_index
+ i
];
561 if (copy_to_user(user_arg
, uref_multi
,
562 sizeof(*uref_multi
)))
566 for (i
= 0; i
< uref_multi
->num_values
; i
++)
567 field
->value
[uref
->usage_index
+ i
] =
568 uref_multi
->values
[i
];
584 static noinline
int hiddev_ioctl_string(struct hiddev
*hiddev
, unsigned int cmd
, void __user
*user_arg
)
586 struct hid_device
*hid
= hiddev
->hid
;
587 struct usb_device
*dev
= hid_to_usb_dev(hid
);
591 if (get_user(idx
, (int __user
*)user_arg
))
594 if ((buf
= kmalloc(HID_STRING_SIZE
, GFP_KERNEL
)) == NULL
)
597 if ((len
= usb_string(dev
, idx
, buf
, HID_STRING_SIZE
-1)) < 0) {
602 if (copy_to_user(user_arg
+sizeof(int), buf
, len
+1)) {
612 static long hiddev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
614 struct hiddev_list
*list
= file
->private_data
;
615 struct hiddev
*hiddev
= list
->hiddev
;
616 struct hid_device
*hid
;
617 struct hiddev_collection_info cinfo
;
618 struct hiddev_report_info rinfo
;
619 struct hiddev_field_info finfo
;
620 struct hiddev_devinfo dinfo
;
621 struct hid_report
*report
;
622 struct hid_field
*field
;
623 void __user
*user_arg
= (void __user
*)arg
;
626 /* Called without BKL by compat methods so no BKL taken */
628 mutex_lock(&hiddev
->existancelock
);
629 if (!hiddev
->exist
) {
639 r
= put_user(HID_VERSION
, (int __user
*)arg
) ?
643 case HIDIOCAPPLICATION
:
644 if (arg
>= hid
->maxapplication
)
647 for (i
= 0; i
< hid
->maxcollection
; i
++)
648 if (hid
->collection
[i
].type
==
649 HID_COLLECTION_APPLICATION
&& arg
-- == 0)
652 if (i
< hid
->maxcollection
)
653 r
= hid
->collection
[i
].usage
;
658 struct usb_device
*dev
= hid_to_usb_dev(hid
);
659 struct usbhid_device
*usbhid
= hid
->driver_data
;
661 memset(&dinfo
, 0, sizeof(dinfo
));
663 dinfo
.bustype
= BUS_USB
;
664 dinfo
.busnum
= dev
->bus
->busnum
;
665 dinfo
.devnum
= dev
->devnum
;
666 dinfo
.ifnum
= usbhid
->ifnum
;
667 dinfo
.vendor
= le16_to_cpu(dev
->descriptor
.idVendor
);
668 dinfo
.product
= le16_to_cpu(dev
->descriptor
.idProduct
);
669 dinfo
.version
= le16_to_cpu(dev
->descriptor
.bcdDevice
);
670 dinfo
.num_applications
= hid
->maxapplication
;
672 r
= copy_to_user(user_arg
, &dinfo
, sizeof(dinfo
)) ?
678 r
= put_user(list
->flags
, (int __user
*)arg
) ?
686 if (get_user(newflags
, (int __user
*)arg
)) {
691 if ((newflags
& ~HIDDEV_FLAGS
) != 0 ||
692 ((newflags
& HIDDEV_FLAG_REPORT
) != 0 &&
693 (newflags
& HIDDEV_FLAG_UREF
) == 0))
696 list
->flags
= newflags
;
703 r
= hiddev_ioctl_string(hiddev
, cmd
, user_arg
);
706 case HIDIOCINITREPORT
:
707 usbhid_init_reports(hid
);
708 hiddev
->initialized
= true;
713 if (copy_from_user(&rinfo
, user_arg
, sizeof(rinfo
))) {
718 if (rinfo
.report_type
== HID_REPORT_TYPE_OUTPUT
)
721 report
= hiddev_lookup_report(hid
, &rinfo
);
725 hid_hw_request(hid
, report
, HID_REQ_GET_REPORT
);
732 if (copy_from_user(&rinfo
, user_arg
, sizeof(rinfo
))) {
737 if (rinfo
.report_type
== HID_REPORT_TYPE_INPUT
)
740 report
= hiddev_lookup_report(hid
, &rinfo
);
744 hid_hw_request(hid
, report
, HID_REQ_SET_REPORT
);
750 case HIDIOCGREPORTINFO
:
751 if (copy_from_user(&rinfo
, user_arg
, sizeof(rinfo
))) {
756 report
= hiddev_lookup_report(hid
, &rinfo
);
760 rinfo
.num_fields
= report
->maxfield
;
762 r
= copy_to_user(user_arg
, &rinfo
, sizeof(rinfo
)) ?
766 case HIDIOCGFIELDINFO
:
767 if (copy_from_user(&finfo
, user_arg
, sizeof(finfo
))) {
772 rinfo
.report_type
= finfo
.report_type
;
773 rinfo
.report_id
= finfo
.report_id
;
775 report
= hiddev_lookup_report(hid
, &rinfo
);
779 if (finfo
.field_index
>= report
->maxfield
)
781 finfo
.field_index
= array_index_nospec(finfo
.field_index
,
784 field
= report
->field
[finfo
.field_index
];
785 memset(&finfo
, 0, sizeof(finfo
));
786 finfo
.report_type
= rinfo
.report_type
;
787 finfo
.report_id
= rinfo
.report_id
;
788 finfo
.field_index
= field
->report_count
- 1;
789 finfo
.maxusage
= field
->maxusage
;
790 finfo
.flags
= field
->flags
;
791 finfo
.physical
= field
->physical
;
792 finfo
.logical
= field
->logical
;
793 finfo
.application
= field
->application
;
794 finfo
.logical_minimum
= field
->logical_minimum
;
795 finfo
.logical_maximum
= field
->logical_maximum
;
796 finfo
.physical_minimum
= field
->physical_minimum
;
797 finfo
.physical_maximum
= field
->physical_maximum
;
798 finfo
.unit_exponent
= field
->unit_exponent
;
799 finfo
.unit
= field
->unit
;
801 r
= copy_to_user(user_arg
, &finfo
, sizeof(finfo
)) ?
811 case HIDIOCGCOLLECTIONINDEX
:
812 if (!hiddev
->initialized
) {
813 usbhid_init_reports(hid
);
814 hiddev
->initialized
= true;
816 r
= hiddev_ioctl_usage(hiddev
, cmd
, user_arg
);
819 case HIDIOCGCOLLECTIONINFO
:
820 if (copy_from_user(&cinfo
, user_arg
, sizeof(cinfo
))) {
825 if (cinfo
.index
>= hid
->maxcollection
)
827 cinfo
.index
= array_index_nospec(cinfo
.index
,
830 cinfo
.type
= hid
->collection
[cinfo
.index
].type
;
831 cinfo
.usage
= hid
->collection
[cinfo
.index
].usage
;
832 cinfo
.level
= hid
->collection
[cinfo
.index
].level
;
834 r
= copy_to_user(user_arg
, &cinfo
, sizeof(cinfo
)) ?
839 if (_IOC_TYPE(cmd
) != 'H' || _IOC_DIR(cmd
) != _IOC_READ
)
842 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGNAME(0))) {
843 int len
= strlen(hid
->name
) + 1;
844 if (len
> _IOC_SIZE(cmd
))
845 len
= _IOC_SIZE(cmd
);
846 r
= copy_to_user(user_arg
, hid
->name
, len
) ?
851 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGPHYS(0))) {
852 int len
= strlen(hid
->phys
) + 1;
853 if (len
> _IOC_SIZE(cmd
))
854 len
= _IOC_SIZE(cmd
);
855 r
= copy_to_user(user_arg
, hid
->phys
, len
) ?
862 mutex_unlock(&hiddev
->existancelock
);
867 static long hiddev_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
869 return hiddev_ioctl(file
, cmd
, (unsigned long)compat_ptr(arg
));
873 static const struct file_operations hiddev_fops
= {
874 .owner
= THIS_MODULE
,
876 .write
= hiddev_write
,
879 .release
= hiddev_release
,
880 .unlocked_ioctl
= hiddev_ioctl
,
881 .fasync
= hiddev_fasync
,
883 .compat_ioctl
= hiddev_compat_ioctl
,
885 .llseek
= noop_llseek
,
888 static char *hiddev_devnode(struct device
*dev
, umode_t
*mode
)
890 return kasprintf(GFP_KERNEL
, "usb/%s", dev_name(dev
));
893 static struct usb_class_driver hiddev_class
= {
895 .devnode
= hiddev_devnode
,
896 .fops
= &hiddev_fops
,
897 .minor_base
= HIDDEV_MINOR_BASE
,
901 * This is where hid.c calls us to connect a hid device to the hiddev driver
903 int hiddev_connect(struct hid_device
*hid
, unsigned int force
)
905 struct hiddev
*hiddev
;
906 struct usbhid_device
*usbhid
= hid
->driver_data
;
911 for (i
= 0; i
< hid
->maxcollection
; i
++)
912 if (hid
->collection
[i
].type
==
913 HID_COLLECTION_APPLICATION
&&
914 !IS_INPUT_APPLICATION(hid
->collection
[i
].usage
))
917 if (i
== hid
->maxcollection
)
921 if (!(hiddev
= kzalloc(sizeof(struct hiddev
), GFP_KERNEL
)))
924 init_waitqueue_head(&hiddev
->wait
);
925 INIT_LIST_HEAD(&hiddev
->list
);
926 spin_lock_init(&hiddev
->list_lock
);
927 mutex_init(&hiddev
->existancelock
);
928 hid
->hiddev
= hiddev
;
931 retval
= usb_register_dev(usbhid
->intf
, &hiddev_class
);
933 hid_err(hid
, "Not able to get a minor for this device\n");
940 * If HID_QUIRK_NO_INIT_REPORTS is set, make sure we don't initialize
943 hiddev
->initialized
= hid
->quirks
& HID_QUIRK_NO_INIT_REPORTS
;
945 hiddev
->minor
= usbhid
->intf
->minor
;
951 * This is where hid.c calls us to disconnect a hiddev device from the
952 * corresponding hid device (usually because the usb device has disconnected)
954 static struct usb_class_driver hiddev_class
;
955 void hiddev_disconnect(struct hid_device
*hid
)
957 struct hiddev
*hiddev
= hid
->hiddev
;
958 struct usbhid_device
*usbhid
= hid
->driver_data
;
960 usb_deregister_dev(usbhid
->intf
, &hiddev_class
);
962 mutex_lock(&hiddev
->existancelock
);
966 mutex_unlock(&hiddev
->existancelock
);
967 hid_hw_close(hiddev
->hid
);
968 wake_up_interruptible(&hiddev
->wait
);
970 mutex_unlock(&hiddev
->existancelock
);