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 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.h>
38 #include <linux/hidraw.h>
40 static int hidraw_major
;
41 static struct cdev hidraw_cdev
;
42 static struct class *hidraw_class
;
43 static struct hidraw
*hidraw_table
[HIDRAW_MAX_DEVICES
];
44 static DEFINE_MUTEX(minors_lock
);
46 static ssize_t
hidraw_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
48 struct hidraw_list
*list
= file
->private_data
;
50 DECLARE_WAITQUEUE(wait
, current
);
52 mutex_lock(&list
->read_mutex
);
55 if (list
->head
== list
->tail
) {
56 add_wait_queue(&list
->hidraw
->wait
, &wait
);
57 set_current_state(TASK_INTERRUPTIBLE
);
59 while (list
->head
== list
->tail
) {
60 if (file
->f_flags
& O_NONBLOCK
) {
64 if (signal_pending(current
)) {
68 if (!list
->hidraw
->exist
) {
73 /* allow O_NONBLOCK to work well from other threads */
74 mutex_unlock(&list
->read_mutex
);
76 mutex_lock(&list
->read_mutex
);
77 set_current_state(TASK_INTERRUPTIBLE
);
80 set_current_state(TASK_RUNNING
);
81 remove_wait_queue(&list
->hidraw
->wait
, &wait
);
87 len
= list
->buffer
[list
->tail
].len
> count
?
88 count
: list
->buffer
[list
->tail
].len
;
90 if (list
->buffer
[list
->tail
].value
) {
91 if (copy_to_user(buffer
, list
->buffer
[list
->tail
].value
, len
)) {
98 kfree(list
->buffer
[list
->tail
].value
);
99 list
->tail
= (list
->tail
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
102 mutex_unlock(&list
->read_mutex
);
106 /* The first byte is expected to be a report number.
107 * This function is to be called with the minors_lock mutex held */
108 static ssize_t
hidraw_send_report(struct file
*file
, const char __user
*buffer
, size_t count
, unsigned char report_type
)
110 unsigned int minor
= iminor(file
->f_path
.dentry
->d_inode
);
111 struct hid_device
*dev
;
115 if (!hidraw_table
[minor
]) {
120 dev
= hidraw_table
[minor
]->hid
;
122 if (!dev
->hid_output_raw_report
) {
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
= kmalloc(count
* sizeof(__u8
), GFP_KERNEL
);
147 if (copy_from_user(buf
, buffer
, count
)) {
152 ret
= dev
->hid_output_raw_report(dev
, buf
, count
, report_type
);
159 /* the first byte is expected to be a report number */
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
);
170 /* This function performs a Get_Report transfer over the control endpoint
171 * per section 7.2.1 of the HID specification, version 1.1. The first byte
172 * of buffer is the report number to request, or 0x0 if the defice does not
173 * use numbered reports. The report_type parameter can be HID_FEATURE_REPORT
174 * or HID_INPUT_REPORT. This function is to be called with the minors_lock
176 static ssize_t
hidraw_get_report(struct file
*file
, char __user
*buffer
, size_t count
, unsigned char report_type
)
178 unsigned int minor
= iminor(file
->f_path
.dentry
->d_inode
);
179 struct hid_device
*dev
;
182 unsigned char report_number
;
184 dev
= hidraw_table
[minor
]->hid
;
186 if (!dev
->hid_get_raw_report
) {
191 if (count
> HID_MAX_BUFFER_SIZE
) {
192 printk(KERN_WARNING
"hidraw: pid %d passed too large report\n",
193 task_pid_nr(current
));
199 printk(KERN_WARNING
"hidraw: pid %d passed too short report\n",
200 task_pid_nr(current
));
205 buf
= kmalloc(count
* sizeof(__u8
), GFP_KERNEL
);
211 /* Read the first byte from the user. This is the report number,
212 * which is passed to dev->hid_get_raw_report(). */
213 if (copy_from_user(&report_number
, buffer
, 1)) {
218 ret
= dev
->hid_get_raw_report(dev
, report_number
, buf
, count
, report_type
);
223 len
= (ret
< count
) ? ret
: count
;
225 if (copy_to_user(buffer
, buf
, len
)) {
238 static unsigned int hidraw_poll(struct file
*file
, poll_table
*wait
)
240 struct hidraw_list
*list
= file
->private_data
;
242 poll_wait(file
, &list
->hidraw
->wait
, wait
);
243 if (list
->head
!= list
->tail
)
244 return POLLIN
| POLLRDNORM
;
245 if (!list
->hidraw
->exist
)
246 return POLLERR
| POLLHUP
;
250 static int hidraw_open(struct inode
*inode
, struct file
*file
)
252 unsigned int minor
= iminor(inode
);
254 struct hidraw_list
*list
;
257 if (!(list
= kzalloc(sizeof(struct hidraw_list
), GFP_KERNEL
))) {
262 mutex_lock(&minors_lock
);
263 if (!hidraw_table
[minor
]) {
268 list
->hidraw
= hidraw_table
[minor
];
269 mutex_init(&list
->read_mutex
);
270 list_add_tail(&list
->node
, &hidraw_table
[minor
]->list
);
271 file
->private_data
= list
;
273 dev
= hidraw_table
[minor
];
275 err
= hid_hw_power(dev
->hid
, PM_HINT_FULLON
);
281 err
= hid_hw_open(dev
->hid
);
283 hid_hw_power(dev
->hid
, PM_HINT_NORMAL
);
289 mutex_unlock(&minors_lock
);
297 static int hidraw_release(struct inode
* inode
, struct file
* file
)
299 unsigned int minor
= iminor(inode
);
301 struct hidraw_list
*list
= file
->private_data
;
304 mutex_lock(&minors_lock
);
305 if (!hidraw_table
[minor
]) {
310 list_del(&list
->node
);
311 dev
= hidraw_table
[minor
];
313 if (list
->hidraw
->exist
) {
314 hid_hw_power(dev
->hid
, PM_HINT_NORMAL
);
315 hid_hw_close(dev
->hid
);
323 mutex_unlock(&minors_lock
);
328 static long hidraw_ioctl(struct file
*file
, unsigned int cmd
,
331 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
332 unsigned int minor
= iminor(inode
);
335 void __user
*user_arg
= (void __user
*) arg
;
337 mutex_lock(&minors_lock
);
338 dev
= hidraw_table
[minor
];
345 case HIDIOCGRDESCSIZE
:
346 if (put_user(dev
->hid
->rsize
, (int __user
*)arg
))
354 if (get_user(len
, (int __user
*)arg
))
356 else if (len
> HID_MAX_DESCRIPTOR_SIZE
- 1)
358 else if (copy_to_user(user_arg
+ offsetof(
359 struct hidraw_report_descriptor
,
362 min(dev
->hid
->rsize
, len
)))
368 struct hidraw_devinfo dinfo
;
370 dinfo
.bustype
= dev
->hid
->bus
;
371 dinfo
.vendor
= dev
->hid
->vendor
;
372 dinfo
.product
= dev
->hid
->product
;
373 if (copy_to_user(user_arg
, &dinfo
, sizeof(dinfo
)))
379 struct hid_device
*hid
= dev
->hid
;
380 if (_IOC_TYPE(cmd
) != 'H') {
385 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCSFEATURE(0))) {
386 int len
= _IOC_SIZE(cmd
);
387 ret
= hidraw_send_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
390 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGFEATURE(0))) {
391 int len
= _IOC_SIZE(cmd
);
392 ret
= hidraw_get_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
396 /* Begin Read-only ioctls. */
397 if (_IOC_DIR(cmd
) != _IOC_READ
) {
402 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWNAME(0))) {
403 int len
= strlen(hid
->name
) + 1;
404 if (len
> _IOC_SIZE(cmd
))
405 len
= _IOC_SIZE(cmd
);
406 ret
= copy_to_user(user_arg
, hid
->name
, len
) ?
411 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWPHYS(0))) {
412 int len
= strlen(hid
->phys
) + 1;
413 if (len
> _IOC_SIZE(cmd
))
414 len
= _IOC_SIZE(cmd
);
415 ret
= copy_to_user(user_arg
, hid
->phys
, len
) ?
424 mutex_unlock(&minors_lock
);
428 static const struct file_operations hidraw_ops
= {
429 .owner
= THIS_MODULE
,
431 .write
= hidraw_write
,
434 .release
= hidraw_release
,
435 .unlocked_ioctl
= hidraw_ioctl
,
437 .compat_ioctl
= hidraw_ioctl
,
439 .llseek
= noop_llseek
,
442 int hidraw_report_event(struct hid_device
*hid
, u8
*data
, int len
)
444 struct hidraw
*dev
= hid
->hidraw
;
445 struct hidraw_list
*list
;
448 list_for_each_entry(list
, &dev
->list
, node
) {
449 if (!(list
->buffer
[list
->head
].value
= kmemdup(data
, len
, GFP_ATOMIC
))) {
453 list
->buffer
[list
->head
].len
= len
;
454 list
->head
= (list
->head
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
455 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
458 wake_up_interruptible(&dev
->wait
);
461 EXPORT_SYMBOL_GPL(hidraw_report_event
);
463 int hidraw_connect(struct hid_device
*hid
)
468 /* we accept any HID device, no matter the applications */
470 dev
= kzalloc(sizeof(struct hidraw
), GFP_KERNEL
);
476 mutex_lock(&minors_lock
);
478 for (minor
= 0; minor
< HIDRAW_MAX_DEVICES
; minor
++) {
479 if (hidraw_table
[minor
])
481 hidraw_table
[minor
] = dev
;
487 mutex_unlock(&minors_lock
);
492 dev
->dev
= device_create(hidraw_class
, &hid
->dev
, MKDEV(hidraw_major
, minor
),
493 NULL
, "%s%d", "hidraw", minor
);
495 if (IS_ERR(dev
->dev
)) {
496 hidraw_table
[minor
] = NULL
;
497 mutex_unlock(&minors_lock
);
498 result
= PTR_ERR(dev
->dev
);
503 mutex_unlock(&minors_lock
);
504 init_waitqueue_head(&dev
->wait
);
505 INIT_LIST_HEAD(&dev
->list
);
517 EXPORT_SYMBOL_GPL(hidraw_connect
);
519 void hidraw_disconnect(struct hid_device
*hid
)
521 struct hidraw
*hidraw
= hid
->hidraw
;
523 mutex_lock(&minors_lock
);
526 device_destroy(hidraw_class
, MKDEV(hidraw_major
, hidraw
->minor
));
528 hidraw_table
[hidraw
->minor
] = NULL
;
532 wake_up_interruptible(&hidraw
->wait
);
536 mutex_unlock(&minors_lock
);
538 EXPORT_SYMBOL_GPL(hidraw_disconnect
);
540 int __init
hidraw_init(void)
545 result
= alloc_chrdev_region(&dev_id
, HIDRAW_FIRST_MINOR
,
546 HIDRAW_MAX_DEVICES
, "hidraw");
548 hidraw_major
= MAJOR(dev_id
);
551 pr_warn("can't get major number\n");
556 hidraw_class
= class_create(THIS_MODULE
, "hidraw");
557 if (IS_ERR(hidraw_class
)) {
558 result
= PTR_ERR(hidraw_class
);
559 unregister_chrdev(hidraw_major
, "hidraw");
563 cdev_init(&hidraw_cdev
, &hidraw_ops
);
564 cdev_add(&hidraw_cdev
, dev_id
, HIDRAW_MAX_DEVICES
);
569 void hidraw_exit(void)
571 dev_t dev_id
= MKDEV(hidraw_major
, 0);
573 cdev_del(&hidraw_cdev
);
574 class_destroy(hidraw_class
);
575 unregister_chrdev_region(dev_id
, HIDRAW_MAX_DEVICES
);