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
);
45 static void drop_ref(struct hidraw
*hid
, int exists_bit
);
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 (file
->f_flags
& O_NONBLOCK
) {
65 if (signal_pending(current
)) {
69 if (!list
->hidraw
->exist
) {
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
);
108 /* The first byte is expected to be a report number.
109 * This function is to be called with the minors_lock mutex held */
110 static ssize_t
hidraw_send_report(struct file
*file
, const char __user
*buffer
, size_t count
, unsigned char report_type
)
112 unsigned int minor
= iminor(file
->f_path
.dentry
->d_inode
);
113 struct hid_device
*dev
;
117 if (!hidraw_table
[minor
] || !hidraw_table
[minor
]->exist
) {
122 dev
= hidraw_table
[minor
]->hid
;
124 if (!dev
->hid_output_raw_report
) {
129 if (count
> HID_MAX_BUFFER_SIZE
) {
130 hid_warn(dev
, "pid %d passed too large report\n",
131 task_pid_nr(current
));
137 hid_warn(dev
, "pid %d passed too short report\n",
138 task_pid_nr(current
));
143 buf
= kmalloc(count
* sizeof(__u8
), GFP_KERNEL
);
149 if (copy_from_user(buf
, buffer
, count
)) {
154 ret
= dev
->hid_output_raw_report(dev
, buf
, count
, report_type
);
161 /* the first byte is expected to be a report number */
162 static ssize_t
hidraw_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
165 mutex_lock(&minors_lock
);
166 ret
= hidraw_send_report(file
, buffer
, count
, HID_OUTPUT_REPORT
);
167 mutex_unlock(&minors_lock
);
172 /* This function performs a Get_Report transfer over the control endpoint
173 * per section 7.2.1 of the HID specification, version 1.1. The first byte
174 * of buffer is the report number to request, or 0x0 if the defice does not
175 * use numbered reports. The report_type parameter can be HID_FEATURE_REPORT
176 * or HID_INPUT_REPORT. This function is to be called with the minors_lock
178 static ssize_t
hidraw_get_report(struct file
*file
, char __user
*buffer
, size_t count
, unsigned char report_type
)
180 unsigned int minor
= iminor(file
->f_path
.dentry
->d_inode
);
181 struct hid_device
*dev
;
184 unsigned char report_number
;
186 dev
= hidraw_table
[minor
]->hid
;
188 if (!dev
->hid_get_raw_report
) {
193 if (count
> HID_MAX_BUFFER_SIZE
) {
194 printk(KERN_WARNING
"hidraw: pid %d passed too large report\n",
195 task_pid_nr(current
));
201 printk(KERN_WARNING
"hidraw: pid %d passed too short report\n",
202 task_pid_nr(current
));
207 buf
= kmalloc(count
* sizeof(__u8
), GFP_KERNEL
);
213 /* Read the first byte from the user. This is the report number,
214 * which is passed to dev->hid_get_raw_report(). */
215 if (copy_from_user(&report_number
, buffer
, 1)) {
220 ret
= dev
->hid_get_raw_report(dev
, report_number
, buf
, count
, report_type
);
225 len
= (ret
< count
) ? ret
: count
;
227 if (copy_to_user(buffer
, buf
, len
)) {
240 static unsigned int hidraw_poll(struct file
*file
, poll_table
*wait
)
242 struct hidraw_list
*list
= file
->private_data
;
244 poll_wait(file
, &list
->hidraw
->wait
, wait
);
245 if (list
->head
!= list
->tail
)
246 return POLLIN
| POLLRDNORM
;
247 if (!list
->hidraw
->exist
)
248 return POLLERR
| POLLHUP
;
252 static int hidraw_open(struct inode
*inode
, struct file
*file
)
254 unsigned int minor
= iminor(inode
);
256 struct hidraw_list
*list
;
259 if (!(list
= kzalloc(sizeof(struct hidraw_list
), GFP_KERNEL
))) {
264 mutex_lock(&minors_lock
);
265 if (!hidraw_table
[minor
] || !hidraw_table
[minor
]->exist
) {
270 list
->hidraw
= hidraw_table
[minor
];
271 mutex_init(&list
->read_mutex
);
272 list_add_tail(&list
->node
, &hidraw_table
[minor
]->list
);
273 file
->private_data
= list
;
275 dev
= hidraw_table
[minor
];
277 err
= hid_hw_power(dev
->hid
, PM_HINT_FULLON
);
283 err
= hid_hw_open(dev
->hid
);
285 hid_hw_power(dev
->hid
, PM_HINT_NORMAL
);
291 mutex_unlock(&minors_lock
);
299 static int hidraw_release(struct inode
* inode
, struct file
* file
)
301 unsigned int minor
= iminor(inode
);
302 struct hidraw_list
*list
= file
->private_data
;
304 drop_ref(hidraw_table
[minor
], 0);
305 list_del(&list
->node
);
310 static long hidraw_ioctl(struct file
*file
, unsigned int cmd
,
313 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
314 unsigned int minor
= iminor(inode
);
317 void __user
*user_arg
= (void __user
*) arg
;
319 mutex_lock(&minors_lock
);
320 dev
= hidraw_table
[minor
];
327 case HIDIOCGRDESCSIZE
:
328 if (put_user(dev
->hid
->rsize
, (int __user
*)arg
))
336 if (get_user(len
, (int __user
*)arg
))
338 else if (len
> HID_MAX_DESCRIPTOR_SIZE
- 1)
340 else if (copy_to_user(user_arg
+ offsetof(
341 struct hidraw_report_descriptor
,
344 min(dev
->hid
->rsize
, len
)))
350 struct hidraw_devinfo dinfo
;
352 dinfo
.bustype
= dev
->hid
->bus
;
353 dinfo
.vendor
= dev
->hid
->vendor
;
354 dinfo
.product
= dev
->hid
->product
;
355 if (copy_to_user(user_arg
, &dinfo
, sizeof(dinfo
)))
361 struct hid_device
*hid
= dev
->hid
;
362 if (_IOC_TYPE(cmd
) != 'H') {
367 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCSFEATURE(0))) {
368 int len
= _IOC_SIZE(cmd
);
369 ret
= hidraw_send_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
372 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGFEATURE(0))) {
373 int len
= _IOC_SIZE(cmd
);
374 ret
= hidraw_get_report(file
, user_arg
, len
, HID_FEATURE_REPORT
);
378 /* Begin Read-only ioctls. */
379 if (_IOC_DIR(cmd
) != _IOC_READ
) {
384 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWNAME(0))) {
385 int len
= strlen(hid
->name
) + 1;
386 if (len
> _IOC_SIZE(cmd
))
387 len
= _IOC_SIZE(cmd
);
388 ret
= copy_to_user(user_arg
, hid
->name
, len
) ?
393 if (_IOC_NR(cmd
) == _IOC_NR(HIDIOCGRAWPHYS(0))) {
394 int len
= strlen(hid
->phys
) + 1;
395 if (len
> _IOC_SIZE(cmd
))
396 len
= _IOC_SIZE(cmd
);
397 ret
= copy_to_user(user_arg
, hid
->phys
, len
) ?
406 mutex_unlock(&minors_lock
);
410 static const struct file_operations hidraw_ops
= {
411 .owner
= THIS_MODULE
,
413 .write
= hidraw_write
,
416 .release
= hidraw_release
,
417 .unlocked_ioctl
= hidraw_ioctl
,
419 .compat_ioctl
= hidraw_ioctl
,
421 .llseek
= noop_llseek
,
424 int hidraw_report_event(struct hid_device
*hid
, u8
*data
, int len
)
426 struct hidraw
*dev
= hid
->hidraw
;
427 struct hidraw_list
*list
;
430 list_for_each_entry(list
, &dev
->list
, node
) {
431 int new_head
= (list
->head
+ 1) & (HIDRAW_BUFFER_SIZE
- 1);
433 if (new_head
== list
->tail
)
436 if (!(list
->buffer
[list
->head
].value
= kmemdup(data
, len
, GFP_ATOMIC
))) {
440 list
->buffer
[list
->head
].len
= len
;
441 list
->head
= new_head
;
442 kill_fasync(&list
->fasync
, SIGIO
, POLL_IN
);
445 wake_up_interruptible(&dev
->wait
);
448 EXPORT_SYMBOL_GPL(hidraw_report_event
);
450 int hidraw_connect(struct hid_device
*hid
)
455 /* we accept any HID device, no matter the applications */
457 dev
= kzalloc(sizeof(struct hidraw
), GFP_KERNEL
);
463 mutex_lock(&minors_lock
);
465 for (minor
= 0; minor
< HIDRAW_MAX_DEVICES
; minor
++) {
466 if (hidraw_table
[minor
])
468 hidraw_table
[minor
] = dev
;
474 mutex_unlock(&minors_lock
);
479 dev
->dev
= device_create(hidraw_class
, &hid
->dev
, MKDEV(hidraw_major
, minor
),
480 NULL
, "%s%d", "hidraw", minor
);
482 if (IS_ERR(dev
->dev
)) {
483 hidraw_table
[minor
] = NULL
;
484 mutex_unlock(&minors_lock
);
485 result
= PTR_ERR(dev
->dev
);
490 mutex_unlock(&minors_lock
);
491 init_waitqueue_head(&dev
->wait
);
492 INIT_LIST_HEAD(&dev
->list
);
504 EXPORT_SYMBOL_GPL(hidraw_connect
);
506 void hidraw_disconnect(struct hid_device
*hid
)
508 struct hidraw
*hidraw
= hid
->hidraw
;
511 EXPORT_SYMBOL_GPL(hidraw_disconnect
);
513 int __init
hidraw_init(void)
518 result
= alloc_chrdev_region(&dev_id
, HIDRAW_FIRST_MINOR
,
519 HIDRAW_MAX_DEVICES
, "hidraw");
521 hidraw_major
= MAJOR(dev_id
);
524 pr_warn("can't get major number\n");
528 hidraw_class
= class_create(THIS_MODULE
, "hidraw");
529 if (IS_ERR(hidraw_class
)) {
530 result
= PTR_ERR(hidraw_class
);
534 cdev_init(&hidraw_cdev
, &hidraw_ops
);
535 result
= cdev_add(&hidraw_cdev
, dev_id
, HIDRAW_MAX_DEVICES
);
543 class_destroy(hidraw_class
);
545 unregister_chrdev_region(dev_id
, HIDRAW_MAX_DEVICES
);
549 void hidraw_exit(void)
551 dev_t dev_id
= MKDEV(hidraw_major
, 0);
553 cdev_del(&hidraw_cdev
);
554 class_destroy(hidraw_class
);
555 unregister_chrdev_region(dev_id
, HIDRAW_MAX_DEVICES
);
559 static void drop_ref(struct hidraw
*hidraw
, int exists_bit
)
561 mutex_lock(&minors_lock
);
563 hid_hw_close(hidraw
->hid
);
566 wake_up_interruptible(&hidraw
->wait
);
571 if (!hidraw
->open
&& !hidraw
->exist
) {
572 device_destroy(hidraw_class
, MKDEV(hidraw_major
, hidraw
->minor
));
573 hidraw_table
[hidraw
->minor
] = NULL
;
576 mutex_unlock(&minors_lock
);