2 * HID raw devices, giving access to raw HID events.
4 * In comparison to hiddev, this device does not process the
5 * hid events at all (no parsing, no lookups). This lets applications
6 * to work on raw hid events as they want to, and avoids a need to
7 * use a transport-specific userspace libhid/libusb libraries.
9 * Copyright (c) 2007-2014 Jiri Kosina
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms and conditions of the GNU General Public License,
15 * version 2, as published by the Free Software Foundation.
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/module.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/init.h>
29 #include <linux/cdev.h>
30 #include <linux/poll.h>
31 #include <linux/device.h>
32 #include <linux/major.h>
33 #include <linux/slab.h>
34 #include <linux/hid.h>
35 #include <linux/mutex.h>
36 #include <linux/sched/signal.h>
37 #include <linux/string.h>
39 #include <linux/hidraw.h>
41 static int hidraw_major
;
42 static struct cdev hidraw_cdev
;
43 static struct class *hidraw_class
;
44 static struct hidraw
*hidraw_table
[HIDRAW_MAX_DEVICES
];
45 static DEFINE_MUTEX(minors_lock
);
47 static ssize_t
hidraw_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
49 struct hidraw_list
*list
= file
->private_data
;
51 DECLARE_WAITQUEUE(wait
, current
);
53 mutex_lock(&list
->read_mutex
);
56 if (list
->head
== list
->tail
) {
57 add_wait_queue(&list
->hidraw
->wait
, &wait
);
58 set_current_state(TASK_INTERRUPTIBLE
);
60 while (list
->head
== list
->tail
) {
61 if (signal_pending(current
)) {
65 if (!list
->hidraw
->exist
) {
69 if (file
->f_flags
& O_NONBLOCK
) {
74 /* allow O_NONBLOCK to work well from other threads */
75 mutex_unlock(&list
->read_mutex
);
77 mutex_lock(&list
->read_mutex
);
78 set_current_state(TASK_INTERRUPTIBLE
);
81 set_current_state(TASK_RUNNING
);
82 remove_wait_queue(&list
->hidraw
->wait
, &wait
);
88 len
= list
->buffer
[list
->tail
].len
> count
?
89 count
: list
->buffer
[list
->tail
].len
;
91 if (list
->buffer
[list
->tail
].value
) {
92 if (copy_to_user(buffer
, list
->buffer
[list
->tail
].value
, len
)) {
99 kfree(list
->buffer
[list
->tail
].value
);
100 list
->buffer
[list
->tail
].value
= NULL
;
101 list
->tail
= (list
->tail
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
104 mutex_unlock(&list
->read_mutex
);
109 * The first byte of the report buffer is expected to be a report number.
111 * This function is to be called with the minors_lock mutex held.
113 static ssize_t
hidraw_send_report(struct file
*file
, const char __user
*buffer
, size_t count
, unsigned char report_type
)
115 unsigned int minor
= iminor(file_inode(file
));
116 struct hid_device
*dev
;
120 if (!hidraw_table
[minor
] || !hidraw_table
[minor
]->exist
) {
125 dev
= hidraw_table
[minor
]->hid
;
127 if (count
> HID_MAX_BUFFER_SIZE
) {
128 hid_warn(dev
, "pid %d passed too large report\n",
129 task_pid_nr(current
));
135 hid_warn(dev
, "pid %d passed too short report\n",
136 task_pid_nr(current
));
141 buf
= memdup_user(buffer
, count
);
147 if ((report_type
== HID_OUTPUT_REPORT
) &&
148 !(dev
->quirks
& HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP
)) {
149 ret
= hid_hw_output_report(dev
, buf
, count
);
151 * compatibility with old implementation of USB-HID and I2C-HID:
152 * if the device does not support receiving output reports,
153 * on an interrupt endpoint, fallback to SET_REPORT HID command.
159 ret
= hid_hw_raw_request(dev
, buf
[0], buf
, count
, report_type
,
168 static ssize_t
hidraw_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
171 mutex_lock(&minors_lock
);
172 ret
= hidraw_send_report(file
, buffer
, count
, HID_OUTPUT_REPORT
);
173 mutex_unlock(&minors_lock
);
179 * This function performs a Get_Report transfer over the control endpoint
180 * per section 7.2.1 of the HID specification, version 1.1. The first byte
181 * of buffer is the report number to request, or 0x0 if the defice does not
182 * use numbered reports. The report_type parameter can be HID_FEATURE_REPORT
183 * or HID_INPUT_REPORT.
185 * This function is to be called with the minors_lock mutex held.
187 static ssize_t
hidraw_get_report(struct file
*file
, char __user
*buffer
, size_t count
, unsigned char report_type
)
189 unsigned int minor
= iminor(file_inode(file
));
190 struct hid_device
*dev
;
193 unsigned char report_number
;
195 dev
= hidraw_table
[minor
]->hid
;
197 if (!dev
->ll_driver
->raw_request
) {
202 if (count
> HID_MAX_BUFFER_SIZE
) {
203 printk(KERN_WARNING
"hidraw: pid %d passed too large report\n",
204 task_pid_nr(current
));
210 printk(KERN_WARNING
"hidraw: pid %d passed too short report\n",
211 task_pid_nr(current
));
216 buf
= kmalloc(count
* sizeof(__u8
), GFP_KERNEL
);
223 * Read the first byte from the user. This is the report number,
224 * which is passed to hid_hw_raw_request().
226 if (copy_from_user(&report_number
, buffer
, 1)) {
231 ret
= hid_hw_raw_request(dev
, report_number
, buf
, count
, report_type
,
237 len
= (ret
< count
) ? ret
: count
;
239 if (copy_to_user(buffer
, buf
, len
)) {
252 static unsigned int hidraw_poll(struct file
*file
, poll_table
*wait
)
254 struct hidraw_list
*list
= file
->private_data
;
256 poll_wait(file
, &list
->hidraw
->wait
, wait
);
257 if (list
->head
!= list
->tail
)
258 return POLLIN
| POLLRDNORM
;
259 if (!list
->hidraw
->exist
)
260 return POLLERR
| POLLHUP
;
264 static int hidraw_open(struct inode
*inode
, struct file
*file
)
266 unsigned int minor
= iminor(inode
);
268 struct hidraw_list
*list
;
272 if (!(list
= kzalloc(sizeof(struct hidraw_list
), GFP_KERNEL
))) {
277 mutex_lock(&minors_lock
);
278 if (!hidraw_table
[minor
] || !hidraw_table
[minor
]->exist
) {
283 dev
= hidraw_table
[minor
];
285 err
= hid_hw_power(dev
->hid
, PM_HINT_FULLON
);
291 err
= hid_hw_open(dev
->hid
);
293 hid_hw_power(dev
->hid
, PM_HINT_NORMAL
);
299 list
->hidraw
= hidraw_table
[minor
];
300 mutex_init(&list
->read_mutex
);
301 spin_lock_irqsave(&hidraw_table
[minor
]->list_lock
, flags
);
302 list_add_tail(&list
->node
, &hidraw_table
[minor
]->list
);
303 spin_unlock_irqrestore(&hidraw_table
[minor
]->list_lock
, flags
);
304 file
->private_data
= list
;
306 mutex_unlock(&minors_lock
);
314 static int hidraw_fasync(int fd
, struct file
*file
, int on
)
316 struct hidraw_list
*list
= file
->private_data
;
318 return fasync_helper(fd
, file
, on
, &list
->fasync
);
321 static void drop_ref(struct hidraw
*hidraw
, int exists_bit
)
326 hid_hw_close(hidraw
->hid
);
327 wake_up_interruptible(&hidraw
->wait
);
329 device_destroy(hidraw_class
,
330 MKDEV(hidraw_major
, hidraw
->minor
));
335 if (!hidraw
->exist
) {
336 hidraw_table
[hidraw
->minor
] = NULL
;
339 /* close device for last reader */
340 hid_hw_close(hidraw
->hid
);
341 hid_hw_power(hidraw
->hid
, PM_HINT_NORMAL
);
346 static int hidraw_release(struct inode
* inode
, struct file
* file
)
348 unsigned int minor
= iminor(inode
);
349 struct hidraw_list
*list
= file
->private_data
;
352 mutex_lock(&minors_lock
);
354 spin_lock_irqsave(&hidraw_table
[minor
]->list_lock
, flags
);
355 list_del(&list
->node
);
356 spin_unlock_irqrestore(&hidraw_table
[minor
]->list_lock
, flags
);
359 drop_ref(hidraw_table
[minor
], 0);
361 mutex_unlock(&minors_lock
);
365 static long hidraw_ioctl(struct file
*file
, unsigned int cmd
,
368 struct inode
*inode
= file_inode(file
);
369 unsigned int minor
= iminor(inode
);
372 void __user
*user_arg
= (void __user
*) arg
;
374 mutex_lock(&minors_lock
);
375 dev
= hidraw_table
[minor
];
382 case HIDIOCGRDESCSIZE
:
383 if (put_user(dev
->hid
->rsize
, (int __user
*)arg
))
391 if (get_user(len
, (int __user
*)arg
))
393 else if (len
> HID_MAX_DESCRIPTOR_SIZE
- 1)
395 else if (copy_to_user(user_arg
+ offsetof(
396 struct hidraw_report_descriptor
,
399 min(dev
->hid
->rsize
, len
)))
405 struct hidraw_devinfo dinfo
;
407 dinfo
.bustype
= dev
->hid
->bus
;
408 dinfo
.vendor
= dev
->hid
->vendor
;
409 dinfo
.product
= dev
->hid
->product
;
410 if (copy_to_user(user_arg
, &dinfo
, sizeof(dinfo
)))
416 struct hid_device
*hid
= dev
->hid
;
417 if (_IOC_TYPE(cmd
) != 'H') {
422 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCSFEATURE(0))) {
423 int len
= _IOC_SIZE(cmd
);
424 ret
= hidraw_send_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
427 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGFEATURE(0))) {
428 int len
= _IOC_SIZE(cmd
);
429 ret
= hidraw_get_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
433 /* Begin Read-only ioctls. */
434 if (_IOC_DIR(cmd
) != _IOC_READ
) {
439 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWNAME(0))) {
440 int len
= strlen(hid
->name
) + 1;
441 if (len
> _IOC_SIZE(cmd
))
442 len
= _IOC_SIZE(cmd
);
443 ret
= copy_to_user(user_arg
, hid
->name
, len
) ?
448 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWPHYS(0))) {
449 int len
= strlen(hid
->phys
) + 1;
450 if (len
> _IOC_SIZE(cmd
))
451 len
= _IOC_SIZE(cmd
);
452 ret
= copy_to_user(user_arg
, hid
->phys
, len
) ?
461 mutex_unlock(&minors_lock
);
465 static const struct file_operations hidraw_ops
= {
466 .owner
= THIS_MODULE
,
468 .write
= hidraw_write
,
471 .release
= hidraw_release
,
472 .unlocked_ioctl
= hidraw_ioctl
,
473 .fasync
= hidraw_fasync
,
475 .compat_ioctl
= hidraw_ioctl
,
477 .llseek
= noop_llseek
,
480 int hidraw_report_event(struct hid_device
*hid
, u8
*data
, int len
)
482 struct hidraw
*dev
= hid
->hidraw
;
483 struct hidraw_list
*list
;
487 spin_lock_irqsave(&dev
->list_lock
, flags
);
488 list_for_each_entry(list
, &dev
->list
, node
) {
489 int new_head
= (list
->head
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
491 if (new_head
== list
->tail
)
494 if (!(list
->buffer
[list
->head
].value
= kmemdup(data
, len
, GFP_ATOMIC
))) {
498 list
->buffer
[list
->head
].len
= len
;
499 list
->head
= new_head
;
500 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
502 spin_unlock_irqrestore(&dev
->list_lock
, flags
);
504 wake_up_interruptible(&dev
->wait
);
507 EXPORT_SYMBOL_GPL(hidraw_report_event
);
509 int hidraw_connect(struct hid_device
*hid
)
514 /* we accept any HID device, all applications */
516 dev
= kzalloc(sizeof(struct hidraw
), GFP_KERNEL
);
522 mutex_lock(&minors_lock
);
524 for (minor
= 0; minor
< HIDRAW_MAX_DEVICES
; minor
++) {
525 if (hidraw_table
[minor
])
527 hidraw_table
[minor
] = dev
;
533 mutex_unlock(&minors_lock
);
538 dev
->dev
= device_create(hidraw_class
, &hid
->dev
, MKDEV(hidraw_major
, minor
),
539 NULL
, "%s%d", "hidraw", minor
);
541 if (IS_ERR(dev
->dev
)) {
542 hidraw_table
[minor
] = NULL
;
543 mutex_unlock(&minors_lock
);
544 result
= PTR_ERR(dev
->dev
);
549 init_waitqueue_head(&dev
->wait
);
550 spin_lock_init(&dev
->list_lock
);
551 INIT_LIST_HEAD(&dev
->list
);
559 mutex_unlock(&minors_lock
);
564 EXPORT_SYMBOL_GPL(hidraw_connect
);
566 void hidraw_disconnect(struct hid_device
*hid
)
568 struct hidraw
*hidraw
= hid
->hidraw
;
570 mutex_lock(&minors_lock
);
574 mutex_unlock(&minors_lock
);
576 EXPORT_SYMBOL_GPL(hidraw_disconnect
);
578 int __init
hidraw_init(void)
583 result
= alloc_chrdev_region(&dev_id
, HIDRAW_FIRST_MINOR
,
584 HIDRAW_MAX_DEVICES
, "hidraw");
586 pr_warn("can't get major number\n");
590 hidraw_major
= MAJOR(dev_id
);
592 hidraw_class
= class_create(THIS_MODULE
, "hidraw");
593 if (IS_ERR(hidraw_class
)) {
594 result
= PTR_ERR(hidraw_class
);
598 cdev_init(&hidraw_cdev
, &hidraw_ops
);
599 result
= cdev_add(&hidraw_cdev
, dev_id
, HIDRAW_MAX_DEVICES
);
603 printk(KERN_INFO
"hidraw: raw HID events driver (C) Jiri Kosina\n");
608 class_destroy(hidraw_class
);
610 unregister_chrdev_region(dev_id
, HIDRAW_MAX_DEVICES
);
614 void hidraw_exit(void)
616 dev_t dev_id
= MKDEV(hidraw_major
, 0);
618 cdev_del(&hidraw_cdev
);
619 class_destroy(hidraw_class
);
620 unregister_chrdev_region(dev_id
, HIDRAW_MAX_DEVICES
);