2
* Copyright (c) 2001 Paul Stewart
3
* Copyright (c) 2001 Vojtech Pavlik
5
* HID char devices, giving access to raw HID device events.
10
* This program is free software; you can redistribute it and/or modify
11
* it under the terms of the GNU General Public License as published by
12
* the Free Software Foundation; either version 2 of the License, or
13
* (at your option) any later version.
15
* This program is distributed in the hope that it will be useful,
16
* but WITHOUT ANY WARRANTY; without even the implied warranty of
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18
* GNU General Public License for more details.
20
* You should have received a copy of the GNU General Public License
21
* along with this program; if not, write to the Free Software
22
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24
* Should you need to contact me, the author, you can do so either by
25
* e-mail - mail your message to Paul Stewart <stewart@wetlogic.net>
28
#include <linux/poll.h>
29
#include <linux/slab.h>
30
#include <linux/module.h>
31
#include <linux/init.h>
32
#include <linux/input.h>
33
#include <linux/usb.h>
34
#include <linux/hid.h>
35
#include <linux/hiddev.h>
36
#include <linux/compat.h>
39
#ifdef CONFIG_USB_DYNAMIC_MINORS
40
#define HIDDEV_MINOR_BASE 0
41
#define HIDDEV_MINORS 256
43
#define HIDDEV_MINOR_BASE 96
44
#define HIDDEV_MINORS 16
46
#define HIDDEV_BUFFER_SIZE 2048
51
struct mutex existancelock;
52
wait_queue_head_t wait;
53
struct hid_device *hid;
54
struct list_head list;
59
struct hiddev_usage_ref buffer[HIDDEV_BUFFER_SIZE];
63
struct fasync_struct *fasync;
64
struct hiddev *hiddev;
65
struct list_head node;
66
struct mutex thread_lock;
70
* Find a report, given the report's type and ID. The ID can be specified
71
* indirectly by REPORT_ID_FIRST (which returns the first report of the given
72
* type) or by (REPORT_ID_NEXT | old_id), which returns the next report of the
73
* given type which follows old_id.
75
static struct hid_report *
76
hiddev_lookup_report(struct hid_device *hid, struct hiddev_report_info *rinfo)
78
unsigned int flags = rinfo->report_id & ~HID_REPORT_ID_MASK;
79
unsigned int rid = rinfo->report_id & HID_REPORT_ID_MASK;
80
struct hid_report_enum *report_enum;
81
struct hid_report *report;
82
struct list_head *list;
84
if (rinfo->report_type < HID_REPORT_TYPE_MIN ||
85
rinfo->report_type > HID_REPORT_TYPE_MAX)
88
report_enum = hid->report_enum +
89
(rinfo->report_type - HID_REPORT_TYPE_MIN);
92
case 0: /* Nothing to do -- report_id is already set correctly */
95
case HID_REPORT_ID_FIRST:
96
if (list_empty(&report_enum->report_list))
99
list = report_enum->report_list.next;
100
report = list_entry(list, struct hid_report, list);
101
rinfo->report_id = report->id;
104
case HID_REPORT_ID_NEXT:
105
report = report_enum->report_id_hash[rid];
109
list = report->list.next;
110
if (list == &report_enum->report_list)
113
report = list_entry(list, struct hid_report, list);
114
rinfo->report_id = report->id;
121
return report_enum->report_id_hash[rinfo->report_id];
125
* Perform an exhaustive search of the report table for a usage, given its
128
static struct hid_field *
129
hiddev_lookup_usage(struct hid_device *hid, struct hiddev_usage_ref *uref)
132
struct hid_report *report;
133
struct hid_report_enum *report_enum;
134
struct hid_field *field;
136
if (uref->report_type < HID_REPORT_TYPE_MIN ||
137
uref->report_type > HID_REPORT_TYPE_MAX)
140
report_enum = hid->report_enum +
141
(uref->report_type - HID_REPORT_TYPE_MIN);
143
list_for_each_entry(report, &report_enum->report_list, list) {
144
for (i = 0; i < report->maxfield; i++) {
145
field = report->field[i];
146
for (j = 0; j < field->maxusage; j++) {
147
if (field->usage[j].hid == uref->usage_code) {
148
uref->report_id = report->id;
149
uref->field_index = i;
150
uref->usage_index = j;
160
static void hiddev_send_event(struct hid_device *hid,
161
struct hiddev_usage_ref *uref)
163
struct hiddev *hiddev = hid->hiddev;
164
struct hiddev_list *list;
167
spin_lock_irqsave(&hiddev->list_lock, flags);
168
list_for_each_entry(list, &hiddev->list, node) {
169
if (uref->field_index != HID_FIELD_INDEX_NONE ||
170
(list->flags & HIDDEV_FLAG_REPORT) != 0) {
171
list->buffer[list->head] = *uref;
172
list->head = (list->head + 1) &
173
(HIDDEV_BUFFER_SIZE - 1);
174
kill_fasync(&list->fasync, SIGIO, POLL_IN);
177
spin_unlock_irqrestore(&hiddev->list_lock, flags);
179
wake_up_interruptible(&hiddev->wait);
183
* This is where hid.c calls into hiddev to pass an event that occurred over
186
void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
187
struct hid_usage *usage, __s32 value)
189
unsigned type = field->report_type;
190
struct hiddev_usage_ref uref;
193
(type == HID_INPUT_REPORT) ? HID_REPORT_TYPE_INPUT :
194
((type == HID_OUTPUT_REPORT) ? HID_REPORT_TYPE_OUTPUT :
195
((type == HID_FEATURE_REPORT) ? HID_REPORT_TYPE_FEATURE : 0));
196
uref.report_id = field->report->id;
197
uref.field_index = field->index;
198
uref.usage_index = (usage - field->usage);
199
uref.usage_code = usage->hid;
202
hiddev_send_event(hid, &uref);
204
EXPORT_SYMBOL_GPL(hiddev_hid_event);
206
void hiddev_report_event(struct hid_device *hid, struct hid_report *report)
208
unsigned type = report->type;
209
struct hiddev_usage_ref uref;
211
memset(&uref, 0, sizeof(uref));
213
(type == HID_INPUT_REPORT) ? HID_REPORT_TYPE_INPUT :
214
((type == HID_OUTPUT_REPORT) ? HID_REPORT_TYPE_OUTPUT :
215
((type == HID_FEATURE_REPORT) ? HID_REPORT_TYPE_FEATURE : 0));
216
uref.report_id = report->id;
217
uref.field_index = HID_FIELD_INDEX_NONE;
219
hiddev_send_event(hid, &uref);
225
static int hiddev_fasync(int fd, struct file *file, int on)
227
struct hiddev_list *list = file->private_data;
229
return fasync_helper(fd, file, on, &list->fasync);
236
static int hiddev_release(struct inode * inode, struct file * file)
238
struct hiddev_list *list = file->private_data;
241
spin_lock_irqsave(&list->hiddev->list_lock, flags);
242
list_del(&list->node);
243
spin_unlock_irqrestore(&list->hiddev->list_lock, flags);
245
mutex_lock(&list->hiddev->existancelock);
246
if (!--list->hiddev->open) {
247
if (list->hiddev->exist) {
248
usbhid_close(list->hiddev->hid);
249
usbhid_put_power(list->hiddev->hid);
251
mutex_unlock(&list->hiddev->existancelock);
258
mutex_unlock(&list->hiddev->existancelock);
267
static int hiddev_open(struct inode *inode, struct file *file)
269
struct hiddev_list *list;
270
struct usb_interface *intf;
271
struct hid_device *hid;
272
struct hiddev *hiddev;
275
intf = usbhid_find_interface(iminor(inode));
278
hid = usb_get_intfdata(intf);
279
hiddev = hid->hiddev;
281
if (!(list = kzalloc(sizeof(struct hiddev_list), GFP_KERNEL)))
283
mutex_init(&list->thread_lock);
284
list->hiddev = hiddev;
285
file->private_data = list;
288
* no need for locking because the USB major number
289
* is shared which usbcore guards against disconnect
291
if (list->hiddev->exist) {
292
if (!list->hiddev->open++) {
293
res = usbhid_open(hiddev->hid);
304
spin_lock_irq(&list->hiddev->list_lock);
305
list_add_tail(&list->node, &hiddev->list);
306
spin_unlock_irq(&list->hiddev->list_lock);
308
mutex_lock(&hiddev->existancelock);
309
if (!list->hiddev->open++)
310
if (list->hiddev->exist) {
311
struct hid_device *hid = hiddev->hid;
312
res = usbhid_get_power(hid);
319
mutex_unlock(&hiddev->existancelock);
322
mutex_unlock(&hiddev->existancelock);
324
file->private_data = NULL;
332
static ssize_t hiddev_write(struct file * file, const char __user * buffer, size_t count, loff_t *ppos)
340
static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t count, loff_t *ppos)
343
struct hiddev_list *list = file->private_data;
347
event_size = ((list->flags & HIDDEV_FLAG_UREF) != 0) ?
348
sizeof(struct hiddev_usage_ref) : sizeof(struct hiddev_event);
350
if (count < event_size)
353
/* lock against other threads */
354
retval = mutex_lock_interruptible(&list->thread_lock);
358
while (retval == 0) {
359
if (list->head == list->tail) {
360
prepare_to_wait(&list->hiddev->wait, &wait, TASK_INTERRUPTIBLE);
362
while (list->head == list->tail) {
363
if (file->f_flags & O_NONBLOCK) {
367
if (signal_pending(current)) {
368
retval = -ERESTARTSYS;
371
if (!list->hiddev->exist) {
376
/* let O_NONBLOCK tasks run */
377
mutex_unlock(&list->thread_lock);
379
if (mutex_lock_interruptible(&list->thread_lock)) {
380
finish_wait(&list->hiddev->wait, &wait);
383
set_current_state(TASK_INTERRUPTIBLE);
385
finish_wait(&list->hiddev->wait, &wait);
390
mutex_unlock(&list->thread_lock);
395
while (list->head != list->tail &&
396
retval + event_size <= count) {
397
if ((list->flags & HIDDEV_FLAG_UREF) == 0) {
398
if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE) {
399
struct hiddev_event event;
401
event.hid = list->buffer[list->tail].usage_code;
402
event.value = list->buffer[list->tail].value;
403
if (copy_to_user(buffer + retval, &event, sizeof(struct hiddev_event))) {
404
mutex_unlock(&list->thread_lock);
407
retval += sizeof(struct hiddev_event);
410
if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE ||
411
(list->flags & HIDDEV_FLAG_REPORT) != 0) {
413
if (copy_to_user(buffer + retval, list->buffer + list->tail, sizeof(struct hiddev_usage_ref))) {
414
mutex_unlock(&list->thread_lock);
417
retval += sizeof(struct hiddev_usage_ref);
420
list->tail = (list->tail + 1) & (HIDDEV_BUFFER_SIZE - 1);
424
mutex_unlock(&list->thread_lock);
431
* No kernel lock - fine
433
static unsigned int hiddev_poll(struct file *file, poll_table *wait)
435
struct hiddev_list *list = file->private_data;
437
poll_wait(file, &list->hiddev->wait, wait);
438
if (list->head != list->tail)
439
return POLLIN | POLLRDNORM;
440
if (!list->hiddev->exist)
441
return POLLERR | POLLHUP;
448
static noinline int hiddev_ioctl_usage(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg)
450
struct hid_device *hid = hiddev->hid;
451
struct hiddev_report_info rinfo;
452
struct hiddev_usage_ref_multi *uref_multi = NULL;
453
struct hiddev_usage_ref *uref;
454
struct hid_report *report;
455
struct hid_field *field;
458
uref_multi = kmalloc(sizeof(struct hiddev_usage_ref_multi), GFP_KERNEL);
461
uref = &uref_multi->uref;
462
if (cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) {
463
if (copy_from_user(uref_multi, user_arg,
464
sizeof(*uref_multi)))
467
if (copy_from_user(uref, user_arg, sizeof(*uref)))
473
rinfo.report_type = uref->report_type;
474
rinfo.report_id = uref->report_id;
475
if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
478
if (uref->field_index >= report->maxfield)
481
field = report->field[uref->field_index];
482
if (uref->usage_index >= field->maxusage)
485
uref->usage_code = field->usage[uref->usage_index].hid;
487
if (copy_to_user(user_arg, uref, sizeof(*uref)))
493
if (cmd != HIDIOCGUSAGE &&
494
cmd != HIDIOCGUSAGES &&
495
uref->report_type == HID_REPORT_TYPE_INPUT)
498
if (uref->report_id == HID_REPORT_ID_UNKNOWN) {
499
field = hiddev_lookup_usage(hid, uref);
503
rinfo.report_type = uref->report_type;
504
rinfo.report_id = uref->report_id;
505
if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
508
if (uref->field_index >= report->maxfield)
511
field = report->field[uref->field_index];
513
if (cmd == HIDIOCGCOLLECTIONINDEX) {
514
if (uref->usage_index >= field->maxusage)
516
} else if (uref->usage_index >= field->report_count)
519
else if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) &&
520
(uref_multi->num_values > HID_MAX_MULTI_USAGES ||
521
uref->usage_index + uref_multi->num_values > field->report_count))
527
uref->value = field->value[uref->usage_index];
528
if (copy_to_user(user_arg, uref, sizeof(*uref)))
533
field->value[uref->usage_index] = uref->value;
536
case HIDIOCGCOLLECTIONINDEX:
537
i = field->usage[uref->usage_index].collection_index;
541
for (i = 0; i < uref_multi->num_values; i++)
542
uref_multi->values[i] =
543
field->value[uref->usage_index + i];
544
if (copy_to_user(user_arg, uref_multi,
545
sizeof(*uref_multi)))
549
for (i = 0; i < uref_multi->num_values; i++)
550
field->value[uref->usage_index + i] =
551
uref_multi->values[i];
567
static noinline int hiddev_ioctl_string(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg)
569
struct hid_device *hid = hiddev->hid;
570
struct usb_device *dev = hid_to_usb_dev(hid);
574
if (get_user(idx, (int __user *)user_arg))
577
if ((buf = kmalloc(HID_STRING_SIZE, GFP_KERNEL)) == NULL)
580
if ((len = usb_string(dev, idx, buf, HID_STRING_SIZE-1)) < 0) {
585
if (copy_to_user(user_arg+sizeof(int), buf, len+1)) {
595
static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
597
struct hiddev_list *list = file->private_data;
598
struct hiddev *hiddev = list->hiddev;
599
struct hid_device *hid;
600
struct hiddev_collection_info cinfo;
601
struct hiddev_report_info rinfo;
602
struct hiddev_field_info finfo;
603
struct hiddev_devinfo dinfo;
604
struct hid_report *report;
605
struct hid_field *field;
606
void __user *user_arg = (void __user *)arg;
609
/* Called without BKL by compat methods so no BKL taken */
611
mutex_lock(&hiddev->existancelock);
612
if (!hiddev->exist) {
622
r = put_user(HID_VERSION, (int __user *)arg) ?
626
case HIDIOCAPPLICATION:
627
if (arg < 0 || arg >= hid->maxapplication)
630
for (i = 0; i < hid->maxcollection; i++)
631
if (hid->collection[i].type ==
632
HID_COLLECTION_APPLICATION && arg-- == 0)
635
if (i < hid->maxcollection)
636
r = hid->collection[i].usage;
641
struct usb_device *dev = hid_to_usb_dev(hid);
642
struct usbhid_device *usbhid = hid->driver_data;
644
memset(&dinfo, 0, sizeof(dinfo));
646
dinfo.bustype = BUS_USB;
647
dinfo.busnum = dev->bus->busnum;
648
dinfo.devnum = dev->devnum;
649
dinfo.ifnum = usbhid->ifnum;
650
dinfo.vendor = le16_to_cpu(dev->descriptor.idVendor);
651
dinfo.product = le16_to_cpu(dev->descriptor.idProduct);
652
dinfo.version = le16_to_cpu(dev->descriptor.bcdDevice);
653
dinfo.num_applications = hid->maxapplication;
655
r = copy_to_user(user_arg, &dinfo, sizeof(dinfo)) ?
661
r = put_user(list->flags, (int __user *)arg) ?
669
if (get_user(newflags, (int __user *)arg)) {
674
if ((newflags & ~HIDDEV_FLAGS) != 0 ||
675
((newflags & HIDDEV_FLAG_REPORT) != 0 &&
676
(newflags & HIDDEV_FLAG_UREF) == 0))
679
list->flags = newflags;
686
r = hiddev_ioctl_string(hiddev, cmd, user_arg);
689
case HIDIOCINITREPORT:
690
usbhid_init_reports(hid);
695
if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) {
700
if (rinfo.report_type == HID_REPORT_TYPE_OUTPUT)
703
report = hiddev_lookup_report(hid, &rinfo);
707
usbhid_submit_report(hid, report, USB_DIR_IN);
714
if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) {
719
if (rinfo.report_type == HID_REPORT_TYPE_INPUT)
722
report = hiddev_lookup_report(hid, &rinfo);
726
usbhid_submit_report(hid, report, USB_DIR_OUT);
732
case HIDIOCGREPORTINFO:
733
if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) {
738
report = hiddev_lookup_report(hid, &rinfo);
742
rinfo.num_fields = report->maxfield;
744
r = copy_to_user(user_arg, &rinfo, sizeof(rinfo)) ?
748
case HIDIOCGFIELDINFO:
749
if (copy_from_user(&finfo, user_arg, sizeof(finfo))) {
754
rinfo.report_type = finfo.report_type;
755
rinfo.report_id = finfo.report_id;
757
report = hiddev_lookup_report(hid, &rinfo);
761
if (finfo.field_index >= report->maxfield)
764
field = report->field[finfo.field_index];
765
memset(&finfo, 0, sizeof(finfo));
766
finfo.report_type = rinfo.report_type;
767
finfo.report_id = rinfo.report_id;
768
finfo.field_index = field->report_count - 1;
769
finfo.maxusage = field->maxusage;
770
finfo.flags = field->flags;
771
finfo.physical = field->physical;
772
finfo.logical = field->logical;
773
finfo.application = field->application;
774
finfo.logical_minimum = field->logical_minimum;
775
finfo.logical_maximum = field->logical_maximum;
776
finfo.physical_minimum = field->physical_minimum;
777
finfo.physical_maximum = field->physical_maximum;
778
finfo.unit_exponent = field->unit_exponent;
779
finfo.unit = field->unit;
781
r = copy_to_user(user_arg, &finfo, sizeof(finfo)) ?
791
case HIDIOCGCOLLECTIONINDEX:
792
r = hiddev_ioctl_usage(hiddev, cmd, user_arg);
795
case HIDIOCGCOLLECTIONINFO:
796
if (copy_from_user(&cinfo, user_arg, sizeof(cinfo))) {
801
if (cinfo.index >= hid->maxcollection)
804
cinfo.type = hid->collection[cinfo.index].type;
805
cinfo.usage = hid->collection[cinfo.index].usage;
806
cinfo.level = hid->collection[cinfo.index].level;
808
r = copy_to_user(user_arg, &cinfo, sizeof(cinfo)) ?
813
if (_IOC_TYPE(cmd) != 'H' || _IOC_DIR(cmd) != _IOC_READ)
816
if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGNAME(0))) {
817
int len = strlen(hid->name) + 1;
818
if (len > _IOC_SIZE(cmd))
819
len = _IOC_SIZE(cmd);
820
r = copy_to_user(user_arg, hid->name, len) ?
825
if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGPHYS(0))) {
826
int len = strlen(hid->phys) + 1;
827
if (len > _IOC_SIZE(cmd))
828
len = _IOC_SIZE(cmd);
829
r = copy_to_user(user_arg, hid->phys, len) ?
836
mutex_unlock(&hiddev->existancelock);
841
static long hiddev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
843
return hiddev_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
847
static const struct file_operations hiddev_fops = {
848
.owner = THIS_MODULE,
850
.write = hiddev_write,
853
.release = hiddev_release,
854
.unlocked_ioctl = hiddev_ioctl,
855
.fasync = hiddev_fasync,
857
.compat_ioctl = hiddev_compat_ioctl,
859
.llseek = noop_llseek,
862
static char *hiddev_devnode(struct device *dev, mode_t *mode)
864
return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
867
static struct usb_class_driver hiddev_class = {
869
.devnode = hiddev_devnode,
870
.fops = &hiddev_fops,
871
.minor_base = HIDDEV_MINOR_BASE,
875
* This is where hid.c calls us to connect a hid device to the hiddev driver
877
int hiddev_connect(struct hid_device *hid, unsigned int force)
879
struct hiddev *hiddev;
880
struct usbhid_device *usbhid = hid->driver_data;
885
for (i = 0; i < hid->maxcollection; i++)
886
if (hid->collection[i].type ==
887
HID_COLLECTION_APPLICATION &&
888
!IS_INPUT_APPLICATION(hid->collection[i].usage))
891
if (i == hid->maxcollection)
895
if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL)))
898
init_waitqueue_head(&hiddev->wait);
899
INIT_LIST_HEAD(&hiddev->list);
900
spin_lock_init(&hiddev->list_lock);
901
mutex_init(&hiddev->existancelock);
902
hid->hiddev = hiddev;
905
retval = usb_register_dev(usbhid->intf, &hiddev_class);
907
hid_err(hid, "Not able to get a minor for this device\n");
916
* This is where hid.c calls us to disconnect a hiddev device from the
917
* corresponding hid device (usually because the usb device has disconnected)
919
static struct usb_class_driver hiddev_class;
920
void hiddev_disconnect(struct hid_device *hid)
922
struct hiddev *hiddev = hid->hiddev;
923
struct usbhid_device *usbhid = hid->driver_data;
925
mutex_lock(&hiddev->existancelock);
928
usb_deregister_dev(usbhid->intf, &hiddev_class);
931
mutex_unlock(&hiddev->existancelock);
932
usbhid_close(hiddev->hid);
933
wake_up_interruptible(&hiddev->wait);
935
mutex_unlock(&hiddev->existancelock);