1 // SPDX-License-Identifier: GPL-2.0-only
3 * HID raw devices, giving access to raw HID events.
5 * In comparison to hiddev, this device does not process the
6 * hid events at all (no parsing, no lookups). This lets applications
7 * to work on raw hid events as they want to, and avoids a need to
8 * use a transport-specific userspace libhid/libusb libraries.
10 * Copyright (c) 2007-2014 Jiri Kosina
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 #include <linux/module.h>
18 #include <linux/errno.h>
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/cdev.h>
22 #include <linux/poll.h>
23 #include <linux/device.h>
24 #include <linux/major.h>
25 #include <linux/slab.h>
26 #include <linux/hid.h>
27 #include <linux/mutex.h>
28 #include <linux/sched/signal.h>
29 #include <linux/string.h>
31 #include <linux/hidraw.h>
33 static int hidraw_major
;
34 static struct cdev hidraw_cdev
;
35 static struct class *hidraw_class
;
36 static struct hidraw
*hidraw_table
[HIDRAW_MAX_DEVICES
];
37 static DEFINE_MUTEX(minors_lock
);
39 static ssize_t
hidraw_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
41 struct hidraw_list
*list
= file
->private_data
;
43 DECLARE_WAITQUEUE(wait
, current
);
45 mutex_lock(&list
->read_mutex
);
48 if (list
->head
== list
->tail
) {
49 add_wait_queue(&list
->hidraw
->wait
, &wait
);
50 set_current_state(TASK_INTERRUPTIBLE
);
52 while (list
->head
== list
->tail
) {
53 if (signal_pending(current
)) {
57 if (!list
->hidraw
->exist
) {
61 if (file
->f_flags
& O_NONBLOCK
) {
66 /* allow O_NONBLOCK to work well from other threads */
67 mutex_unlock(&list
->read_mutex
);
69 mutex_lock(&list
->read_mutex
);
70 set_current_state(TASK_INTERRUPTIBLE
);
73 set_current_state(TASK_RUNNING
);
74 remove_wait_queue(&list
->hidraw
->wait
, &wait
);
80 len
= list
->buffer
[list
->tail
].len
> count
?
81 count
: list
->buffer
[list
->tail
].len
;
83 if (list
->buffer
[list
->tail
].value
) {
84 if (copy_to_user(buffer
, list
->buffer
[list
->tail
].value
, len
)) {
91 kfree(list
->buffer
[list
->tail
].value
);
92 list
->buffer
[list
->tail
].value
= NULL
;
93 list
->tail
= (list
->tail
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
96 mutex_unlock(&list
->read_mutex
);
101 * The first byte of the report buffer is expected to be a report number.
103 static ssize_t
hidraw_send_report(struct file
*file
, const char __user
*buffer
, size_t count
, unsigned char report_type
)
105 unsigned int minor
= iminor(file_inode(file
));
106 struct hid_device
*dev
;
110 lockdep_assert_held(&minors_lock
);
112 if (!hidraw_table
[minor
] || !hidraw_table
[minor
]->exist
) {
117 dev
= hidraw_table
[minor
]->hid
;
119 if (count
> HID_MAX_BUFFER_SIZE
) {
120 hid_warn(dev
, "pid %d passed too large report\n",
121 task_pid_nr(current
));
127 hid_warn(dev
, "pid %d passed too short report\n",
128 task_pid_nr(current
));
133 buf
= memdup_user(buffer
, count
);
139 if ((report_type
== HID_OUTPUT_REPORT
) &&
140 !(dev
->quirks
& HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP
)) {
141 ret
= hid_hw_output_report(dev
, buf
, count
);
143 * compatibility with old implementation of USB-HID and I2C-HID:
144 * if the device does not support receiving output reports,
145 * on an interrupt endpoint, fallback to SET_REPORT HID command.
151 ret
= hid_hw_raw_request(dev
, buf
[0], buf
, count
, report_type
,
160 static ssize_t
hidraw_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
163 mutex_lock(&minors_lock
);
164 ret
= hidraw_send_report(file
, buffer
, count
, HID_OUTPUT_REPORT
);
165 mutex_unlock(&minors_lock
);
171 * This function performs a Get_Report transfer over the control endpoint
172 * per section 7.2.1 of the HID specification, version 1.1. The first byte
173 * of buffer is the report number to request, or 0x0 if the defice does not
174 * use numbered reports. The report_type parameter can be HID_FEATURE_REPORT
175 * or HID_INPUT_REPORT.
177 static ssize_t
hidraw_get_report(struct file
*file
, char __user
*buffer
, size_t count
, unsigned char report_type
)
179 unsigned int minor
= iminor(file_inode(file
));
180 struct hid_device
*dev
;
183 unsigned char report_number
;
185 lockdep_assert_held(&minors_lock
);
187 if (!hidraw_table
[minor
] || !hidraw_table
[minor
]->exist
) {
192 dev
= hidraw_table
[minor
]->hid
;
194 if (!dev
->ll_driver
->raw_request
) {
199 if (count
> HID_MAX_BUFFER_SIZE
) {
200 printk(KERN_WARNING
"hidraw: pid %d passed too large report\n",
201 task_pid_nr(current
));
207 printk(KERN_WARNING
"hidraw: pid %d passed too short report\n",
208 task_pid_nr(current
));
213 buf
= kmalloc(count
, GFP_KERNEL
);
220 * Read the first byte from the user. This is the report number,
221 * which is passed to hid_hw_raw_request().
223 if (copy_from_user(&report_number
, buffer
, 1)) {
228 ret
= hid_hw_raw_request(dev
, report_number
, buf
, count
, report_type
,
234 len
= (ret
< count
) ? ret
: count
;
236 if (copy_to_user(buffer
, buf
, len
)) {
249 static __poll_t
hidraw_poll(struct file
*file
, poll_table
*wait
)
251 struct hidraw_list
*list
= file
->private_data
;
253 poll_wait(file
, &list
->hidraw
->wait
, wait
);
254 if (list
->head
!= list
->tail
)
255 return EPOLLIN
| EPOLLRDNORM
;
256 if (!list
->hidraw
->exist
)
257 return EPOLLERR
| EPOLLHUP
;
261 static int hidraw_open(struct inode
*inode
, struct file
*file
)
263 unsigned int minor
= iminor(inode
);
265 struct hidraw_list
*list
;
269 if (!(list
= kzalloc(sizeof(struct hidraw_list
), GFP_KERNEL
))) {
274 mutex_lock(&minors_lock
);
275 if (!hidraw_table
[minor
] || !hidraw_table
[minor
]->exist
) {
280 dev
= hidraw_table
[minor
];
282 err
= hid_hw_power(dev
->hid
, PM_HINT_FULLON
);
288 err
= hid_hw_open(dev
->hid
);
290 hid_hw_power(dev
->hid
, PM_HINT_NORMAL
);
296 list
->hidraw
= hidraw_table
[minor
];
297 mutex_init(&list
->read_mutex
);
298 spin_lock_irqsave(&hidraw_table
[minor
]->list_lock
, flags
);
299 list_add_tail(&list
->node
, &hidraw_table
[minor
]->list
);
300 spin_unlock_irqrestore(&hidraw_table
[minor
]->list_lock
, flags
);
301 file
->private_data
= list
;
303 mutex_unlock(&minors_lock
);
311 static int hidraw_fasync(int fd
, struct file
*file
, int on
)
313 struct hidraw_list
*list
= file
->private_data
;
315 return fasync_helper(fd
, file
, on
, &list
->fasync
);
318 static void drop_ref(struct hidraw
*hidraw
, int exists_bit
)
323 hid_hw_close(hidraw
->hid
);
324 wake_up_interruptible(&hidraw
->wait
);
326 device_destroy(hidraw_class
,
327 MKDEV(hidraw_major
, hidraw
->minor
));
332 if (!hidraw
->exist
) {
333 hidraw_table
[hidraw
->minor
] = NULL
;
336 /* close device for last reader */
337 hid_hw_close(hidraw
->hid
);
338 hid_hw_power(hidraw
->hid
, PM_HINT_NORMAL
);
343 static int hidraw_release(struct inode
* inode
, struct file
* file
)
345 unsigned int minor
= iminor(inode
);
346 struct hidraw_list
*list
= file
->private_data
;
349 mutex_lock(&minors_lock
);
351 spin_lock_irqsave(&hidraw_table
[minor
]->list_lock
, flags
);
352 list_del(&list
->node
);
353 spin_unlock_irqrestore(&hidraw_table
[minor
]->list_lock
, flags
);
356 drop_ref(hidraw_table
[minor
], 0);
358 mutex_unlock(&minors_lock
);
362 static long hidraw_ioctl(struct file
*file
, unsigned int cmd
,
365 struct inode
*inode
= file_inode(file
);
366 unsigned int minor
= iminor(inode
);
369 void __user
*user_arg
= (void __user
*) arg
;
371 mutex_lock(&minors_lock
);
372 dev
= hidraw_table
[minor
];
379 case HIDIOCGRDESCSIZE
:
380 if (put_user(dev
->hid
->rsize
, (int __user
*)arg
))
388 if (get_user(len
, (int __user
*)arg
))
390 else if (len
> HID_MAX_DESCRIPTOR_SIZE
- 1)
392 else if (copy_to_user(user_arg
+ offsetof(
393 struct hidraw_report_descriptor
,
396 min(dev
->hid
->rsize
, len
)))
402 struct hidraw_devinfo dinfo
;
404 dinfo
.bustype
= dev
->hid
->bus
;
405 dinfo
.vendor
= dev
->hid
->vendor
;
406 dinfo
.product
= dev
->hid
->product
;
407 if (copy_to_user(user_arg
, &dinfo
, sizeof(dinfo
)))
413 struct hid_device
*hid
= dev
->hid
;
414 if (_IOC_TYPE(cmd
) != 'H') {
419 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCSFEATURE(0))) {
420 int len
= _IOC_SIZE(cmd
);
421 ret
= hidraw_send_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
424 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGFEATURE(0))) {
425 int len
= _IOC_SIZE(cmd
);
426 ret
= hidraw_get_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
430 /* Begin Read-only ioctls. */
431 if (_IOC_DIR(cmd
) != _IOC_READ
) {
436 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWNAME(0))) {
437 int len
= strlen(hid
->name
) + 1;
438 if (len
> _IOC_SIZE(cmd
))
439 len
= _IOC_SIZE(cmd
);
440 ret
= copy_to_user(user_arg
, hid
->name
, len
) ?
445 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWPHYS(0))) {
446 int len
= strlen(hid
->phys
) + 1;
447 if (len
> _IOC_SIZE(cmd
))
448 len
= _IOC_SIZE(cmd
);
449 ret
= copy_to_user(user_arg
, hid
->phys
, len
) ?
458 mutex_unlock(&minors_lock
);
462 static const struct file_operations hidraw_ops
= {
463 .owner
= THIS_MODULE
,
465 .write
= hidraw_write
,
468 .release
= hidraw_release
,
469 .unlocked_ioctl
= hidraw_ioctl
,
470 .fasync
= hidraw_fasync
,
472 .compat_ioctl
= hidraw_ioctl
,
474 .llseek
= noop_llseek
,
477 int hidraw_report_event(struct hid_device
*hid
, u8
*data
, int len
)
479 struct hidraw
*dev
= hid
->hidraw
;
480 struct hidraw_list
*list
;
484 spin_lock_irqsave(&dev
->list_lock
, flags
);
485 list_for_each_entry(list
, &dev
->list
, node
) {
486 int new_head
= (list
->head
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
488 if (new_head
== list
->tail
)
491 if (!(list
->buffer
[list
->head
].value
= kmemdup(data
, len
, GFP_ATOMIC
))) {
495 list
->buffer
[list
->head
].len
= len
;
496 list
->head
= new_head
;
497 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
499 spin_unlock_irqrestore(&dev
->list_lock
, flags
);
501 wake_up_interruptible(&dev
->wait
);
504 EXPORT_SYMBOL_GPL(hidraw_report_event
);
506 int hidraw_connect(struct hid_device
*hid
)
511 /* we accept any HID device, all applications */
513 dev
= kzalloc(sizeof(struct hidraw
), GFP_KERNEL
);
519 mutex_lock(&minors_lock
);
521 for (minor
= 0; minor
< HIDRAW_MAX_DEVICES
; minor
++) {
522 if (hidraw_table
[minor
])
524 hidraw_table
[minor
] = dev
;
530 mutex_unlock(&minors_lock
);
535 dev
->dev
= device_create(hidraw_class
, &hid
->dev
, MKDEV(hidraw_major
, minor
),
536 NULL
, "%s%d", "hidraw", minor
);
538 if (IS_ERR(dev
->dev
)) {
539 hidraw_table
[minor
] = NULL
;
540 mutex_unlock(&minors_lock
);
541 result
= PTR_ERR(dev
->dev
);
546 init_waitqueue_head(&dev
->wait
);
547 spin_lock_init(&dev
->list_lock
);
548 INIT_LIST_HEAD(&dev
->list
);
556 mutex_unlock(&minors_lock
);
561 EXPORT_SYMBOL_GPL(hidraw_connect
);
563 void hidraw_disconnect(struct hid_device
*hid
)
565 struct hidraw
*hidraw
= hid
->hidraw
;
567 mutex_lock(&minors_lock
);
571 mutex_unlock(&minors_lock
);
573 EXPORT_SYMBOL_GPL(hidraw_disconnect
);
575 int __init
hidraw_init(void)
580 result
= alloc_chrdev_region(&dev_id
, HIDRAW_FIRST_MINOR
,
581 HIDRAW_MAX_DEVICES
, "hidraw");
583 pr_warn("can't get major number\n");
587 hidraw_major
= MAJOR(dev_id
);
589 hidraw_class
= class_create(THIS_MODULE
, "hidraw");
590 if (IS_ERR(hidraw_class
)) {
591 result
= PTR_ERR(hidraw_class
);
595 cdev_init(&hidraw_cdev
, &hidraw_ops
);
596 result
= cdev_add(&hidraw_cdev
, dev_id
, HIDRAW_MAX_DEVICES
);
600 printk(KERN_INFO
"hidraw: raw HID events driver (C) Jiri Kosina\n");
605 class_destroy(hidraw_class
);
607 unregister_chrdev_region(dev_id
, HIDRAW_MAX_DEVICES
);
611 void hidraw_exit(void)
613 dev_t dev_id
= MKDEV(hidraw_major
, 0);
615 cdev_del(&hidraw_cdev
);
616 class_destroy(hidraw_class
);
617 unregister_chrdev_region(dev_id
, HIDRAW_MAX_DEVICES
);