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
->buffer
[list
->tail
].value
= NULL
;
100 list
->tail
= (list
->tail
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
103 mutex_unlock(&list
->read_mutex
);
107 /* The first byte is expected to be a report number.
108 * This function is to be called with the minors_lock mutex held */
109 static ssize_t
hidraw_send_report(struct file
*file
, const char __user
*buffer
, size_t count
, unsigned char report_type
)
111 unsigned int minor
= iminor(file
->f_path
.dentry
->d_inode
);
112 struct hid_device
*dev
;
116 if (!hidraw_table
[minor
]) {
121 dev
= hidraw_table
[minor
]->hid
;
123 if (!dev
->hid_output_raw_report
) {
128 if (count
> HID_MAX_BUFFER_SIZE
) {
129 hid_warn(dev
, "pid %d passed too large report\n",
130 task_pid_nr(current
));
136 hid_warn(dev
, "pid %d passed too short report\n",
137 task_pid_nr(current
));
142 buf
= kmalloc(count
* sizeof(__u8
), GFP_KERNEL
);
148 if (copy_from_user(buf
, buffer
, count
)) {
153 ret
= dev
->hid_output_raw_report(dev
, buf
, count
, report_type
);
160 /* the first byte is expected to be a report number */
161 static ssize_t
hidraw_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
164 mutex_lock(&minors_lock
);
165 ret
= hidraw_send_report(file
, buffer
, count
, HID_OUTPUT_REPORT
);
166 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. This function is to be called with the minors_lock
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
->f_path
.dentry
->d_inode
);
180 struct hid_device
*dev
;
183 unsigned char report_number
;
185 dev
= hidraw_table
[minor
]->hid
;
187 if (!dev
->hid_get_raw_report
) {
192 if (count
> HID_MAX_BUFFER_SIZE
) {
193 printk(KERN_WARNING
"hidraw: pid %d passed too large report\n",
194 task_pid_nr(current
));
200 printk(KERN_WARNING
"hidraw: pid %d passed too short report\n",
201 task_pid_nr(current
));
206 buf
= kmalloc(count
* sizeof(__u8
), GFP_KERNEL
);
212 /* Read the first byte from the user. This is the report number,
213 * which is passed to dev->hid_get_raw_report(). */
214 if (copy_from_user(&report_number
, buffer
, 1)) {
219 ret
= dev
->hid_get_raw_report(dev
, report_number
, buf
, count
, report_type
);
224 len
= (ret
< count
) ? ret
: count
;
226 if (copy_to_user(buffer
, buf
, len
)) {
239 static unsigned int hidraw_poll(struct file
*file
, poll_table
*wait
)
241 struct hidraw_list
*list
= file
->private_data
;
243 poll_wait(file
, &list
->hidraw
->wait
, wait
);
244 if (list
->head
!= list
->tail
)
245 return POLLIN
| POLLRDNORM
;
246 if (!list
->hidraw
->exist
)
247 return POLLERR
| POLLHUP
;
251 static int hidraw_open(struct inode
*inode
, struct file
*file
)
253 unsigned int minor
= iminor(inode
);
255 struct hidraw_list
*list
;
258 if (!(list
= kzalloc(sizeof(struct hidraw_list
), GFP_KERNEL
))) {
263 mutex_lock(&minors_lock
);
264 if (!hidraw_table
[minor
]) {
269 list
->hidraw
= hidraw_table
[minor
];
270 mutex_init(&list
->read_mutex
);
271 list_add_tail(&list
->node
, &hidraw_table
[minor
]->list
);
272 file
->private_data
= list
;
274 dev
= hidraw_table
[minor
];
276 err
= hid_hw_power(dev
->hid
, PM_HINT_FULLON
);
282 err
= hid_hw_open(dev
->hid
);
284 hid_hw_power(dev
->hid
, PM_HINT_NORMAL
);
290 mutex_unlock(&minors_lock
);
298 static int hidraw_release(struct inode
* inode
, struct file
* file
)
300 unsigned int minor
= iminor(inode
);
302 struct hidraw_list
*list
= file
->private_data
;
306 mutex_lock(&minors_lock
);
307 if (!hidraw_table
[minor
]) {
312 list_del(&list
->node
);
313 dev
= hidraw_table
[minor
];
315 if (list
->hidraw
->exist
) {
316 hid_hw_power(dev
->hid
, PM_HINT_NORMAL
);
317 hid_hw_close(dev
->hid
);
323 for (i
= 0; i
< HIDRAW_BUFFER_SIZE
; ++i
)
324 kfree(list
->buffer
[i
].value
);
328 mutex_unlock(&minors_lock
);
333 static long hidraw_ioctl(struct file
*file
, unsigned int cmd
,
336 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
337 unsigned int minor
= iminor(inode
);
340 void __user
*user_arg
= (void __user
*) arg
;
342 mutex_lock(&minors_lock
);
343 dev
= hidraw_table
[minor
];
350 case HIDIOCGRDESCSIZE
:
351 if (put_user(dev
->hid
->rsize
, (int __user
*)arg
))
359 if (get_user(len
, (int __user
*)arg
))
361 else if (len
> HID_MAX_DESCRIPTOR_SIZE
- 1)
363 else if (copy_to_user(user_arg
+ offsetof(
364 struct hidraw_report_descriptor
,
367 min(dev
->hid
->rsize
, len
)))
373 struct hidraw_devinfo dinfo
;
375 dinfo
.bustype
= dev
->hid
->bus
;
376 dinfo
.vendor
= dev
->hid
->vendor
;
377 dinfo
.product
= dev
->hid
->product
;
378 if (copy_to_user(user_arg
, &dinfo
, sizeof(dinfo
)))
384 struct hid_device
*hid
= dev
->hid
;
385 if (_IOC_TYPE(cmd
) != 'H') {
390 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCSFEATURE(0))) {
391 int len
= _IOC_SIZE(cmd
);
392 ret
= hidraw_send_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
395 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGFEATURE(0))) {
396 int len
= _IOC_SIZE(cmd
);
397 ret
= hidraw_get_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
401 /* Begin Read-only ioctls. */
402 if (_IOC_DIR(cmd
) != _IOC_READ
) {
407 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWNAME(0))) {
408 int len
= strlen(hid
->name
) + 1;
409 if (len
> _IOC_SIZE(cmd
))
410 len
= _IOC_SIZE(cmd
);
411 ret
= copy_to_user(user_arg
, hid
->name
, len
) ?
416 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWPHYS(0))) {
417 int len
= strlen(hid
->phys
) + 1;
418 if (len
> _IOC_SIZE(cmd
))
419 len
= _IOC_SIZE(cmd
);
420 ret
= copy_to_user(user_arg
, hid
->phys
, len
) ?
429 mutex_unlock(&minors_lock
);
433 static const struct file_operations hidraw_ops
= {
434 .owner
= THIS_MODULE
,
436 .write
= hidraw_write
,
439 .release
= hidraw_release
,
440 .unlocked_ioctl
= hidraw_ioctl
,
442 .compat_ioctl
= hidraw_ioctl
,
444 .llseek
= noop_llseek
,
447 int hidraw_report_event(struct hid_device
*hid
, u8
*data
, int len
)
449 struct hidraw
*dev
= hid
->hidraw
;
450 struct hidraw_list
*list
;
453 list_for_each_entry(list
, &dev
->list
, node
) {
454 int new_head
= (list
->head
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
456 if (new_head
== list
->tail
)
459 if (!(list
->buffer
[list
->head
].value
= kmemdup(data
, len
, GFP_ATOMIC
))) {
463 list
->buffer
[list
->head
].len
= len
;
464 list
->head
= new_head
;
465 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
468 wake_up_interruptible(&dev
->wait
);
471 EXPORT_SYMBOL_GPL(hidraw_report_event
);
473 int hidraw_connect(struct hid_device
*hid
)
478 /* we accept any HID device, no matter the applications */
480 dev
= kzalloc(sizeof(struct hidraw
), GFP_KERNEL
);
486 mutex_lock(&minors_lock
);
488 for (minor
= 0; minor
< HIDRAW_MAX_DEVICES
; minor
++) {
489 if (hidraw_table
[minor
])
491 hidraw_table
[minor
] = dev
;
497 mutex_unlock(&minors_lock
);
502 dev
->dev
= device_create(hidraw_class
, &hid
->dev
, MKDEV(hidraw_major
, minor
),
503 NULL
, "%s%d", "hidraw", minor
);
505 if (IS_ERR(dev
->dev
)) {
506 hidraw_table
[minor
] = NULL
;
507 mutex_unlock(&minors_lock
);
508 result
= PTR_ERR(dev
->dev
);
513 mutex_unlock(&minors_lock
);
514 init_waitqueue_head(&dev
->wait
);
515 INIT_LIST_HEAD(&dev
->list
);
527 EXPORT_SYMBOL_GPL(hidraw_connect
);
529 void hidraw_disconnect(struct hid_device
*hid
)
531 struct hidraw
*hidraw
= hid
->hidraw
;
533 mutex_lock(&minors_lock
);
536 device_destroy(hidraw_class
, MKDEV(hidraw_major
, hidraw
->minor
));
538 hidraw_table
[hidraw
->minor
] = NULL
;
542 wake_up_interruptible(&hidraw
->wait
);
546 mutex_unlock(&minors_lock
);
548 EXPORT_SYMBOL_GPL(hidraw_disconnect
);
550 int __init
hidraw_init(void)
555 result
= alloc_chrdev_region(&dev_id
, HIDRAW_FIRST_MINOR
,
556 HIDRAW_MAX_DEVICES
, "hidraw");
558 hidraw_major
= MAJOR(dev_id
);
561 pr_warn("can't get major number\n");
566 hidraw_class
= class_create(THIS_MODULE
, "hidraw");
567 if (IS_ERR(hidraw_class
)) {
568 result
= PTR_ERR(hidraw_class
);
569 unregister_chrdev(hidraw_major
, "hidraw");
573 cdev_init(&hidraw_cdev
, &hidraw_ops
);
574 cdev_add(&hidraw_cdev
, dev_id
, HIDRAW_MAX_DEVICES
);
579 void hidraw_exit(void)
581 dev_t dev_id
= MKDEV(hidraw_major
, 0);
583 cdev_del(&hidraw_cdev
);
584 class_destroy(hidraw_class
);
585 unregister_chrdev_region(dev_id
, HIDRAW_MAX_DEVICES
);