blob: 891ff531cf347726d87d909b475f2d15c98ff575 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (c) 2001 Paul Stewart
3 * Copyright (c) 2001 Vojtech Pavlik
4 *
5 * HID char devices, giving access to raw HID device events.
6 *
7 */
8
9/*
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.
14 *
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.
19 *
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
23 *
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>
26 */
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/poll.h>
29#include <linux/slab.h>
30#include <linux/module.h>
31#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/input.h>
33#include <linux/usb.h>
Jiri Kosinadde58452006-12-08 18:40:44 +010034#include <linux/hid.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/hiddev.h>
Philip Langdalebb6c8d82007-10-14 12:03:58 +020036#include <linux/compat.h>
Jiri Kosinadde58452006-12-08 18:40:44 +010037#include "usbhid.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#ifdef CONFIG_USB_DYNAMIC_MINORS
40#define HIDDEV_MINOR_BASE 0
41#define HIDDEV_MINORS 256
42#else
43#define HIDDEV_MINOR_BASE 96
44#define HIDDEV_MINORS 16
45#endif
Jiri Kosinaaffbb8c2009-08-20 12:04:14 +020046#define HIDDEV_BUFFER_SIZE 2048
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
48struct hiddev {
49 int exist;
50 int open;
Oliver Neukum07903402008-12-16 10:55:15 +010051 struct mutex existancelock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 wait_queue_head_t wait;
53 struct hid_device *hid;
Dmitry Torokhov826d5982006-07-19 01:09:10 -040054 struct list_head list;
Jiri Kosinacdcb44e2007-05-10 08:45:56 +020055 spinlock_t list_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056};
57
58struct hiddev_list {
59 struct hiddev_usage_ref buffer[HIDDEV_BUFFER_SIZE];
60 int head;
61 int tail;
62 unsigned flags;
63 struct fasync_struct *fasync;
64 struct hiddev *hiddev;
Dmitry Torokhov826d5982006-07-19 01:09:10 -040065 struct list_head node;
Oliver Neukum07903402008-12-16 10:55:15 +010066 struct mutex thread_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067};
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069/*
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.
74 */
75static struct hid_report *
76hiddev_lookup_report(struct hid_device *hid, struct hiddev_report_info *rinfo)
77{
Dmitry Torokhov826d5982006-07-19 01:09:10 -040078 unsigned int flags = rinfo->report_id & ~HID_REPORT_ID_MASK;
79 unsigned int rid = rinfo->report_id & HID_REPORT_ID_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 struct hid_report_enum *report_enum;
Dmitry Torokhov826d5982006-07-19 01:09:10 -040081 struct hid_report *report;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 struct list_head *list;
83
84 if (rinfo->report_type < HID_REPORT_TYPE_MIN ||
Dmitry Torokhov826d5982006-07-19 01:09:10 -040085 rinfo->report_type > HID_REPORT_TYPE_MAX)
86 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88 report_enum = hid->report_enum +
89 (rinfo->report_type - HID_REPORT_TYPE_MIN);
90
91 switch (flags) {
92 case 0: /* Nothing to do -- report_id is already set correctly */
93 break;
94
95 case HID_REPORT_ID_FIRST:
Dmitry Torokhov826d5982006-07-19 01:09:10 -040096 if (list_empty(&report_enum->report_list))
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 return NULL;
Dmitry Torokhov826d5982006-07-19 01:09:10 -040098
99 list = report_enum->report_list.next;
100 report = list_entry(list, struct hid_report, list);
101 rinfo->report_id = report->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 break;
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 case HID_REPORT_ID_NEXT:
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400105 report = report_enum->report_id_hash[rid];
106 if (!report)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 return NULL;
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400108
109 list = report->list.next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 if (list == &report_enum->report_list)
111 return NULL;
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400112
113 report = list_entry(list, struct hid_report, list);
114 rinfo->report_id = report->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 break;
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500116
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 default:
118 return NULL;
119 }
120
121 return report_enum->report_id_hash[rinfo->report_id];
122}
123
124/*
125 * Perform an exhaustive search of the report table for a usage, given its
126 * type and usage id.
127 */
128static struct hid_field *
129hiddev_lookup_usage(struct hid_device *hid, struct hiddev_usage_ref *uref)
130{
131 int i, j;
132 struct hid_report *report;
133 struct hid_report_enum *report_enum;
134 struct hid_field *field;
135
136 if (uref->report_type < HID_REPORT_TYPE_MIN ||
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400137 uref->report_type > HID_REPORT_TYPE_MAX)
138 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
140 report_enum = hid->report_enum +
141 (uref->report_type - HID_REPORT_TYPE_MIN);
142
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400143 list_for_each_entry(report, &report_enum->report_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 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;
151 return field;
152 }
153 }
154 }
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400155 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 return NULL;
158}
159
160static void hiddev_send_event(struct hid_device *hid,
161 struct hiddev_usage_ref *uref)
162{
163 struct hiddev *hiddev = hid->hiddev;
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400164 struct hiddev_list *list;
Jiri Kosinacdcb44e2007-05-10 08:45:56 +0200165 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Jiri Kosinacdcb44e2007-05-10 08:45:56 +0200167 spin_lock_irqsave(&hiddev->list_lock, flags);
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400168 list_for_each_entry(list, &hiddev->list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 if (uref->field_index != HID_FIELD_INDEX_NONE ||
170 (list->flags & HIDDEV_FLAG_REPORT) != 0) {
171 list->buffer[list->head] = *uref;
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500172 list->head = (list->head + 1) &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 (HIDDEV_BUFFER_SIZE - 1);
174 kill_fasync(&list->fasync, SIGIO, POLL_IN);
175 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 }
Jiri Kosinacdcb44e2007-05-10 08:45:56 +0200177 spin_unlock_irqrestore(&hiddev->list_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179 wake_up_interruptible(&hiddev->wait);
180}
181
182/*
183 * This is where hid.c calls into hiddev to pass an event that occurred over
184 * the interrupt pipe
185 */
186void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
David Howells7d12e782006-10-05 14:55:46 +0100187 struct hid_usage *usage, __s32 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
189 unsigned type = field->report_type;
190 struct hiddev_usage_ref uref;
191
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500192 uref.report_type =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 (type == HID_INPUT_REPORT) ? HID_REPORT_TYPE_INPUT :
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500194 ((type == HID_OUTPUT_REPORT) ? HID_REPORT_TYPE_OUTPUT :
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400195 ((type == HID_FEATURE_REPORT) ? HID_REPORT_TYPE_FEATURE : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 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;
200 uref.value = value;
201
202 hiddev_send_event(hid, &uref);
203}
Jiri Kosina229695e2006-12-08 18:40:53 +0100204EXPORT_SYMBOL_GPL(hiddev_hid_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206void hiddev_report_event(struct hid_device *hid, struct hid_report *report)
207{
208 unsigned type = report->type;
209 struct hiddev_usage_ref uref;
210
211 memset(&uref, 0, sizeof(uref));
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500212 uref.report_type =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 (type == HID_INPUT_REPORT) ? HID_REPORT_TYPE_INPUT :
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500214 ((type == HID_OUTPUT_REPORT) ? HID_REPORT_TYPE_OUTPUT :
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400215 ((type == HID_FEATURE_REPORT) ? HID_REPORT_TYPE_FEATURE : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 uref.report_id = report->id;
217 uref.field_index = HID_FIELD_INDEX_NONE;
218
219 hiddev_send_event(hid, &uref);
220}
Jiri Kosinaaa8de2f2006-12-08 18:41:17 +0100221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222/*
223 * fasync file op
224 */
225static int hiddev_fasync(int fd, struct file *file, int on)
226{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 struct hiddev_list *list = file->private_data;
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400228
Jonathan Corbet60aa4922009-02-01 14:52:56 -0700229 return fasync_helper(fd, file, on, &list->fasync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230}
231
232
233/*
234 * release file op
235 */
236static int hiddev_release(struct inode * inode, struct file * file)
237{
238 struct hiddev_list *list = file->private_data;
Jiri Kosinacdcb44e2007-05-10 08:45:56 +0200239 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Jiri Kosinacdcb44e2007-05-10 08:45:56 +0200241 spin_lock_irqsave(&list->hiddev->list_lock, flags);
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400242 list_del(&list->node);
Jiri Kosinacdcb44e2007-05-10 08:45:56 +0200243 spin_unlock_irqrestore(&list->hiddev->list_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 if (!--list->hiddev->open) {
Oliver Neukum0361a282008-12-17 15:38:03 +0100246 if (list->hiddev->exist) {
Jiri Kosina4916b3a2006-12-08 18:41:03 +0100247 usbhid_close(list->hiddev->hid);
Oliver Neukum0361a282008-12-17 15:38:03 +0100248 usbhid_put_power(list->hiddev->hid);
249 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 kfree(list->hiddev);
Oliver Neukum0361a282008-12-17 15:38:03 +0100251 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253
254 kfree(list);
255
256 return 0;
257}
258
259/*
260 * open file op
261 */
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400262static int hiddev_open(struct inode *inode, struct file *file)
263{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 struct hiddev_list *list;
Arnd Bergmannbd25f4d2010-07-11 15:34:05 +0200265 struct usb_interface *intf;
Jiri Kosina9c9e54a2010-08-13 12:19:45 +0200266 struct hid_device *hid;
Arnd Bergmannbd25f4d2010-07-11 15:34:05 +0200267 struct hiddev *hiddev;
268 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Guillaume Chazarain8fe294c2010-09-12 21:32:35 +0200270 intf = usbhid_find_interface(iminor(inode));
Arnd Bergmannbd25f4d2010-07-11 15:34:05 +0200271 if (!intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 return -ENODEV;
Jiri Kosina9c9e54a2010-08-13 12:19:45 +0200273 hid = usb_get_intfdata(intf);
274 hiddev = hid->hiddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Oliver Neukumbbdb7da2006-01-06 20:54:29 +0100276 if (!(list = kzalloc(sizeof(struct hiddev_list), GFP_KERNEL)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 return -ENOMEM;
Oliver Neukum07903402008-12-16 10:55:15 +0100278 mutex_init(&list->thread_lock);
Arnd Bergmannbd25f4d2010-07-11 15:34:05 +0200279 list->hiddev = hiddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 file->private_data = list;
281
Oliver Neukum07903402008-12-16 10:55:15 +0100282 /*
283 * no need for locking because the USB major number
284 * is shared which usbcore guards against disconnect
285 */
286 if (list->hiddev->exist) {
287 if (!list->hiddev->open++) {
Arnd Bergmannbd25f4d2010-07-11 15:34:05 +0200288 res = usbhid_open(hiddev->hid);
Oliver Neukum07903402008-12-16 10:55:15 +0100289 if (res < 0) {
290 res = -EIO;
291 goto bail;
292 }
293 }
294 } else {
295 res = -ENODEV;
296 goto bail;
297 }
298
299 spin_lock_irq(&list->hiddev->list_lock);
Arnd Bergmannbd25f4d2010-07-11 15:34:05 +0200300 list_add_tail(&list->node, &hiddev->list);
Oliver Neukum07903402008-12-16 10:55:15 +0100301 spin_unlock_irq(&list->hiddev->list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Oliver Neukum0361a282008-12-17 15:38:03 +0100303 if (!list->hiddev->open++)
304 if (list->hiddev->exist) {
Arnd Bergmannbd25f4d2010-07-11 15:34:05 +0200305 struct hid_device *hid = hiddev->hid;
Oliver Neukum0361a282008-12-17 15:38:03 +0100306 res = usbhid_get_power(hid);
307 if (res < 0) {
308 res = -EIO;
309 goto bail;
310 }
311 usbhid_open(hid);
312 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 return 0;
Oliver Neukum07903402008-12-16 10:55:15 +0100314bail:
315 file->private_data = NULL;
Johannes Weiner48e7a3c2009-03-10 22:43:56 +0100316 kfree(list);
Oliver Neukum07903402008-12-16 10:55:15 +0100317 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
320/*
321 * "write" file op
322 */
323static ssize_t hiddev_write(struct file * file, const char __user * buffer, size_t count, loff_t *ppos)
324{
325 return -EINVAL;
326}
327
328/*
329 * "read" file op
330 */
331static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t count, loff_t *ppos)
332{
Johannes Weiner96fe2ab2009-03-10 22:44:01 +0100333 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 struct hiddev_list *list = file->private_data;
335 int event_size;
Oliver Neukum07903402008-12-16 10:55:15 +0100336 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
338 event_size = ((list->flags & HIDDEV_FLAG_UREF) != 0) ?
339 sizeof(struct hiddev_usage_ref) : sizeof(struct hiddev_event);
340
341 if (count < event_size)
342 return 0;
343
Oliver Neukum07903402008-12-16 10:55:15 +0100344 /* lock against other threads */
345 retval = mutex_lock_interruptible(&list->thread_lock);
346 if (retval)
347 return -ERESTARTSYS;
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 while (retval == 0) {
350 if (list->head == list->tail) {
Oliver Neukum07903402008-12-16 10:55:15 +0100351 prepare_to_wait(&list->hiddev->wait, &wait, TASK_INTERRUPTIBLE);
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 while (list->head == list->tail) {
354 if (file->f_flags & O_NONBLOCK) {
355 retval = -EAGAIN;
356 break;
357 }
358 if (signal_pending(current)) {
359 retval = -ERESTARTSYS;
360 break;
361 }
362 if (!list->hiddev->exist) {
363 retval = -EIO;
364 break;
365 }
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500366
Oliver Neukum07903402008-12-16 10:55:15 +0100367 /* let O_NONBLOCK tasks run */
368 mutex_unlock(&list->thread_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 schedule();
Peter Waechtler06268b22011-04-28 20:53:58 +0200370 if (mutex_lock_interruptible(&list->thread_lock)) {
371 finish_wait(&list->hiddev->wait, &wait);
Oliver Neukum07903402008-12-16 10:55:15 +0100372 return -EINTR;
Peter Waechtler06268b22011-04-28 20:53:58 +0200373 }
Micon, David48d70552006-05-20 14:59:59 -0700374 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 }
Oliver Neukum07903402008-12-16 10:55:15 +0100376 finish_wait(&list->hiddev->wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 }
379
Oliver Neukum07903402008-12-16 10:55:15 +0100380 if (retval) {
381 mutex_unlock(&list->thread_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 return retval;
Oliver Neukum07903402008-12-16 10:55:15 +0100383 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500386 while (list->head != list->tail &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 retval + event_size <= count) {
388 if ((list->flags & HIDDEV_FLAG_UREF) == 0) {
Oliver Neukum07903402008-12-16 10:55:15 +0100389 if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 struct hiddev_event event;
Oliver Neukum07903402008-12-16 10:55:15 +0100391
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 event.hid = list->buffer[list->tail].usage_code;
393 event.value = list->buffer[list->tail].value;
Oliver Neukum07903402008-12-16 10:55:15 +0100394 if (copy_to_user(buffer + retval, &event, sizeof(struct hiddev_event))) {
395 mutex_unlock(&list->thread_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 return -EFAULT;
Oliver Neukum07903402008-12-16 10:55:15 +0100397 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 retval += sizeof(struct hiddev_event);
399 }
400 } else {
401 if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE ||
402 (list->flags & HIDDEV_FLAG_REPORT) != 0) {
Oliver Neukum07903402008-12-16 10:55:15 +0100403
404 if (copy_to_user(buffer + retval, list->buffer + list->tail, sizeof(struct hiddev_usage_ref))) {
405 mutex_unlock(&list->thread_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return -EFAULT;
Oliver Neukum07903402008-12-16 10:55:15 +0100407 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 retval += sizeof(struct hiddev_usage_ref);
409 }
410 }
411 list->tail = (list->tail + 1) & (HIDDEV_BUFFER_SIZE - 1);
412 }
413
414 }
Oliver Neukum07903402008-12-16 10:55:15 +0100415 mutex_unlock(&list->thread_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417 return retval;
418}
419
420/*
421 * "poll" file op
422 * No kernel lock - fine
423 */
424static unsigned int hiddev_poll(struct file *file, poll_table *wait)
425{
426 struct hiddev_list *list = file->private_data;
Dmitry Torokhov826d5982006-07-19 01:09:10 -0400427
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 poll_wait(file, &list->hiddev->wait, wait);
429 if (list->head != list->tail)
430 return POLLIN | POLLRDNORM;
431 if (!list->hiddev->exist)
432 return POLLERR | POLLHUP;
433 return 0;
434}
435
436/*
437 * "ioctl" file op
438 */
Jean Delvarecf2a2992008-03-03 11:48:43 +0100439static noinline int hiddev_ioctl_usage(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg)
440{
441 struct hid_device *hid = hiddev->hid;
442 struct hiddev_report_info rinfo;
443 struct hiddev_usage_ref_multi *uref_multi = NULL;
444 struct hiddev_usage_ref *uref;
445 struct hid_report *report;
446 struct hid_field *field;
447 int i;
448
449 uref_multi = kmalloc(sizeof(struct hiddev_usage_ref_multi), GFP_KERNEL);
450 if (!uref_multi)
451 return -ENOMEM;
452 uref = &uref_multi->uref;
453 if (cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) {
454 if (copy_from_user(uref_multi, user_arg,
455 sizeof(*uref_multi)))
456 goto fault;
457 } else {
458 if (copy_from_user(uref, user_arg, sizeof(*uref)))
459 goto fault;
460 }
461
462 switch (cmd) {
463 case HIDIOCGUCODE:
464 rinfo.report_type = uref->report_type;
465 rinfo.report_id = uref->report_id;
466 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
467 goto inval;
468
469 if (uref->field_index >= report->maxfield)
470 goto inval;
471
472 field = report->field[uref->field_index];
473 if (uref->usage_index >= field->maxusage)
474 goto inval;
475
476 uref->usage_code = field->usage[uref->usage_index].hid;
477
478 if (copy_to_user(user_arg, uref, sizeof(*uref)))
479 goto fault;
480
Jiri Slabyeb991082008-10-23 01:47:34 +0200481 goto goodreturn;
Jean Delvarecf2a2992008-03-03 11:48:43 +0100482
483 default:
484 if (cmd != HIDIOCGUSAGE &&
485 cmd != HIDIOCGUSAGES &&
486 uref->report_type == HID_REPORT_TYPE_INPUT)
487 goto inval;
488
489 if (uref->report_id == HID_REPORT_ID_UNKNOWN) {
490 field = hiddev_lookup_usage(hid, uref);
491 if (field == NULL)
492 goto inval;
493 } else {
494 rinfo.report_type = uref->report_type;
495 rinfo.report_id = uref->report_id;
496 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
497 goto inval;
498
499 if (uref->field_index >= report->maxfield)
500 goto inval;
501
502 field = report->field[uref->field_index];
503
504 if (cmd == HIDIOCGCOLLECTIONINDEX) {
505 if (uref->usage_index >= field->maxusage)
506 goto inval;
507 } else if (uref->usage_index >= field->report_count)
508 goto inval;
509
510 else if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) &&
511 (uref_multi->num_values > HID_MAX_MULTI_USAGES ||
512 uref->usage_index + uref_multi->num_values > field->report_count))
513 goto inval;
514 }
515
516 switch (cmd) {
517 case HIDIOCGUSAGE:
518 uref->value = field->value[uref->usage_index];
519 if (copy_to_user(user_arg, uref, sizeof(*uref)))
520 goto fault;
521 goto goodreturn;
522
523 case HIDIOCSUSAGE:
524 field->value[uref->usage_index] = uref->value;
525 goto goodreturn;
526
527 case HIDIOCGCOLLECTIONINDEX:
Jiri Slaby48594842009-06-19 23:24:11 +0200528 i = field->usage[uref->usage_index].collection_index;
Jean Delvarecf2a2992008-03-03 11:48:43 +0100529 kfree(uref_multi);
Jiri Slaby48594842009-06-19 23:24:11 +0200530 return i;
Jean Delvarecf2a2992008-03-03 11:48:43 +0100531 case HIDIOCGUSAGES:
532 for (i = 0; i < uref_multi->num_values; i++)
533 uref_multi->values[i] =
534 field->value[uref->usage_index + i];
535 if (copy_to_user(user_arg, uref_multi,
536 sizeof(*uref_multi)))
537 goto fault;
538 goto goodreturn;
539 case HIDIOCSUSAGES:
540 for (i = 0; i < uref_multi->num_values; i++)
541 field->value[uref->usage_index + i] =
542 uref_multi->values[i];
543 goto goodreturn;
544 }
545
546goodreturn:
547 kfree(uref_multi);
548 return 0;
549fault:
550 kfree(uref_multi);
551 return -EFAULT;
552inval:
553 kfree(uref_multi);
554 return -EINVAL;
555 }
556}
557
558static noinline int hiddev_ioctl_string(struct hiddev *hiddev, unsigned int cmd, void __user *user_arg)
559{
560 struct hid_device *hid = hiddev->hid;
561 struct usb_device *dev = hid_to_usb_dev(hid);
562 int idx, len;
563 char *buf;
564
565 if (get_user(idx, (int __user *)user_arg))
566 return -EFAULT;
567
568 if ((buf = kmalloc(HID_STRING_SIZE, GFP_KERNEL)) == NULL)
569 return -ENOMEM;
570
571 if ((len = usb_string(dev, idx, buf, HID_STRING_SIZE-1)) < 0) {
572 kfree(buf);
573 return -EINVAL;
574 }
575
576 if (copy_to_user(user_arg+sizeof(int), buf, len+1)) {
577 kfree(buf);
578 return -EFAULT;
579 }
580
581 kfree(buf);
582
583 return len;
584}
585
Alan Cox7961df12008-05-26 11:25:20 +0200586static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
588 struct hiddev_list *list = file->private_data;
589 struct hiddev *hiddev = list->hiddev;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300590 struct hid_device *hid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 struct hiddev_collection_info cinfo;
592 struct hiddev_report_info rinfo;
593 struct hiddev_field_info finfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 struct hiddev_devinfo dinfo;
595 struct hid_report *report;
596 struct hid_field *field;
597 void __user *user_arg = (void __user *)arg;
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300598 int i, r = -EINVAL;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300599
Alan Cox7961df12008-05-26 11:25:20 +0200600 /* Called without BKL by compat methods so no BKL taken */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300602 mutex_lock(&hiddev->existancelock);
603 if (!hiddev->exist) {
604 r = -ENODEV;
605 goto ret_unlock;
606 }
607
608 hid = hiddev->hid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
610 switch (cmd) {
611
612 case HIDIOCGVERSION:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300613 r = put_user(HID_VERSION, (int __user *)arg) ?
614 -EFAULT : 0;
615 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 case HIDIOCAPPLICATION:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300618 if (arg < 0 || arg >= hid->maxapplication)
619 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621 for (i = 0; i < hid->maxcollection; i++)
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500622 if (hid->collection[i].type ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 HID_COLLECTION_APPLICATION && arg-- == 0)
624 break;
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500625
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300626 if (i < hid->maxcollection)
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300627 r = hid->collection[i].usage;
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300628 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630 case HIDIOCGDEVINFO:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300631 {
632 struct usb_device *dev = hid_to_usb_dev(hid);
633 struct usbhid_device *usbhid = hid->driver_data;
634
635 dinfo.bustype = BUS_USB;
636 dinfo.busnum = dev->bus->busnum;
637 dinfo.devnum = dev->devnum;
638 dinfo.ifnum = usbhid->ifnum;
639 dinfo.vendor = le16_to_cpu(dev->descriptor.idVendor);
640 dinfo.product = le16_to_cpu(dev->descriptor.idProduct);
641 dinfo.version = le16_to_cpu(dev->descriptor.bcdDevice);
642 dinfo.num_applications = hid->maxapplication;
643
644 r = copy_to_user(user_arg, &dinfo, sizeof(dinfo)) ?
645 -EFAULT : 0;
646 break;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300647 }
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 case HIDIOCGFLAG:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300650 r = put_user(list->flags, (int __user *)arg) ?
651 -EFAULT : 0;
652 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 case HIDIOCSFLAG:
655 {
656 int newflags;
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300657
658 if (get_user(newflags, (int __user *)arg)) {
659 r = -EFAULT;
660 break;
661 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663 if ((newflags & ~HIDDEV_FLAGS) != 0 ||
664 ((newflags & HIDDEV_FLAG_REPORT) != 0 &&
665 (newflags & HIDDEV_FLAG_UREF) == 0))
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300666 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
668 list->flags = newflags;
669
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300670 r = 0;
671 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 }
673
674 case HIDIOCGSTRING:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300675 r = hiddev_ioctl_string(hiddev, cmd, user_arg);
676 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 case HIDIOCINITREPORT:
Jiri Kosina4916b3a2006-12-08 18:41:03 +0100679 usbhid_init_reports(hid);
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300680 r = 0;
681 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
683 case HIDIOCGREPORT:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300684 if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) {
685 r = -EFAULT;
686 break;
687 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
689 if (rinfo.report_type == HID_REPORT_TYPE_OUTPUT)
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300690 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300692 report = hiddev_lookup_report(hid, &rinfo);
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300693 if (report == NULL)
694 break;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300695
696 usbhid_submit_report(hid, report, USB_DIR_IN);
697 usbhid_wait_io(hid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300699 r = 0;
700 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 case HIDIOCSREPORT:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300703 if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) {
704 r = -EFAULT;
705 break;
706 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
708 if (rinfo.report_type == HID_REPORT_TYPE_INPUT)
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300709 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300711 report = hiddev_lookup_report(hid, &rinfo);
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300712 if (report == NULL)
713 break;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300714
715 usbhid_submit_report(hid, report, USB_DIR_OUT);
716 usbhid_wait_io(hid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300718 r = 0;
719 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
721 case HIDIOCGREPORTINFO:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300722 if (copy_from_user(&rinfo, user_arg, sizeof(rinfo))) {
723 r = -EFAULT;
724 break;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300725 }
726
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300727 report = hiddev_lookup_report(hid, &rinfo);
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300728 if (report == NULL)
729 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
731 rinfo.num_fields = report->maxfield;
732
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300733 r = copy_to_user(user_arg, &rinfo, sizeof(rinfo)) ?
734 -EFAULT : 0;
735 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
737 case HIDIOCGFIELDINFO:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300738 if (copy_from_user(&finfo, user_arg, sizeof(finfo))) {
739 r = -EFAULT;
740 break;
741 }
742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 rinfo.report_type = finfo.report_type;
744 rinfo.report_id = finfo.report_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300746 report = hiddev_lookup_report(hid, &rinfo);
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300747 if (report == NULL)
748 break;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300749
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300750 if (finfo.field_index >= report->maxfield)
751 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
753 field = report->field[finfo.field_index];
754 memset(&finfo, 0, sizeof(finfo));
755 finfo.report_type = rinfo.report_type;
756 finfo.report_id = rinfo.report_id;
757 finfo.field_index = field->report_count - 1;
758 finfo.maxusage = field->maxusage;
759 finfo.flags = field->flags;
760 finfo.physical = field->physical;
761 finfo.logical = field->logical;
762 finfo.application = field->application;
763 finfo.logical_minimum = field->logical_minimum;
764 finfo.logical_maximum = field->logical_maximum;
765 finfo.physical_minimum = field->physical_minimum;
766 finfo.physical_maximum = field->physical_maximum;
767 finfo.unit_exponent = field->unit_exponent;
768 finfo.unit = field->unit;
769
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300770 r = copy_to_user(user_arg, &finfo, sizeof(finfo)) ?
771 -EFAULT : 0;
772 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
774 case HIDIOCGUCODE:
Jean Delvarecf2a2992008-03-03 11:48:43 +0100775 /* fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 case HIDIOCGUSAGE:
777 case HIDIOCSUSAGE:
778 case HIDIOCGUSAGES:
779 case HIDIOCSUSAGES:
780 case HIDIOCGCOLLECTIONINDEX:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300781 r = hiddev_ioctl_usage(hiddev, cmd, user_arg);
782 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
784 case HIDIOCGCOLLECTIONINFO:
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300785 if (copy_from_user(&cinfo, user_arg, sizeof(cinfo))) {
786 r = -EFAULT;
787 break;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300788 }
789
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300790 if (cinfo.index >= hid->maxcollection)
791 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 cinfo.type = hid->collection[cinfo.index].type;
794 cinfo.usage = hid->collection[cinfo.index].usage;
795 cinfo.level = hid->collection[cinfo.index].level;
796
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300797 r = copy_to_user(user_arg, &cinfo, sizeof(cinfo)) ?
798 -EFAULT : 0;
799 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
801 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 if (_IOC_TYPE(cmd) != 'H' || _IOC_DIR(cmd) != _IOC_READ)
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300803 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
805 if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGNAME(0))) {
806 int len;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300807
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300808 if (!hid->name) {
809 r = 0;
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300810 break;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300811 }
812
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 len = strlen(hid->name) + 1;
814 if (len > _IOC_SIZE(cmd))
815 len = _IOC_SIZE(cmd);
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300816 r = copy_to_user(user_arg, hid->name, len) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 -EFAULT : len;
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300818 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 }
820
821 if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGPHYS(0))) {
822 int len;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300823
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300824 if (!hid->phys) {
825 r = 0;
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300826 break;
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300827 }
828
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 len = strlen(hid->phys) + 1;
830 if (len > _IOC_SIZE(cmd))
831 len = _IOC_SIZE(cmd);
Valentine Barshak1a8e8fa2010-12-06 17:51:41 +0300832 r = copy_to_user(user_arg, hid->phys, len) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 -EFAULT : len;
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300834 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 }
836 }
Valentine Barshak33d6eb52010-12-06 18:16:11 +0300837
838ret_unlock:
839 mutex_unlock(&hiddev->existancelock);
840 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
842
Philip Langdalebb6c8d82007-10-14 12:03:58 +0200843#ifdef CONFIG_COMPAT
844static long hiddev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
845{
Jiri Kosina88af45b2008-05-27 11:36:40 +0200846 return hiddev_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
Philip Langdalebb6c8d82007-10-14 12:03:58 +0200847}
848#endif
849
Luiz Fernando N. Capitulino066202d2006-08-05 20:37:11 -0300850static const struct file_operations hiddev_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 .owner = THIS_MODULE,
852 .read = hiddev_read,
853 .write = hiddev_write,
854 .poll = hiddev_poll,
855 .open = hiddev_open,
856 .release = hiddev_release,
Alan Cox7961df12008-05-26 11:25:20 +0200857 .unlocked_ioctl = hiddev_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 .fasync = hiddev_fasync,
Philip Langdalebb6c8d82007-10-14 12:03:58 +0200859#ifdef CONFIG_COMPAT
860 .compat_ioctl = hiddev_compat_ioctl,
861#endif
Arnd Bergmann6038f372010-08-15 18:52:59 +0200862 .llseek = noop_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863};
864
Kay Sieverse454cea2009-09-18 23:01:12 +0200865static char *hiddev_devnode(struct device *dev, mode_t *mode)
Kay Sieversf7a386c2009-04-30 15:23:42 +0200866{
867 return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
868}
869
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870static struct usb_class_driver hiddev_class = {
Greg Kroah-Hartmand6e5bcf2005-06-20 21:15:16 -0700871 .name = "hiddev%d",
Kay Sieverse454cea2009-09-18 23:01:12 +0200872 .devnode = hiddev_devnode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 .fops = &hiddev_fops,
Dmitry Torokhov05f091ab2005-05-29 02:29:01 -0500874 .minor_base = HIDDEV_MINOR_BASE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875};
876
877/*
878 * This is where hid.c calls us to connect a hid device to the hiddev driver
879 */
Jiri Slaby93c10132008-06-27 00:04:24 +0200880int hiddev_connect(struct hid_device *hid, unsigned int force)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881{
882 struct hiddev *hiddev;
Jiri Kosina4916b3a2006-12-08 18:41:03 +0100883 struct usbhid_device *usbhid = hid->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 int retval;
885
Jiri Slaby93c10132008-06-27 00:04:24 +0200886 if (!force) {
887 unsigned int i;
888 for (i = 0; i < hid->maxcollection; i++)
889 if (hid->collection[i].type ==
890 HID_COLLECTION_APPLICATION &&
891 !IS_INPUT_APPLICATION(hid->collection[i].usage))
892 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
Jiri Slaby93c10132008-06-27 00:04:24 +0200894 if (i == hid->maxcollection)
895 return -1;
896 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
Oliver Neukumbbdb7da2006-01-06 20:54:29 +0100898 if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900
Oliver Neukum07903402008-12-16 10:55:15 +0100901 init_waitqueue_head(&hiddev->wait);
902 INIT_LIST_HEAD(&hiddev->list);
903 spin_lock_init(&hiddev->list_lock);
904 mutex_init(&hiddev->existancelock);
Jiri Kosina76052742009-01-07 13:25:36 +0100905 hid->hiddev = hiddev;
Oliver Neukum07903402008-12-16 10:55:15 +0100906 hiddev->hid = hid;
907 hiddev->exist = 1;
Jiri Kosina4916b3a2006-12-08 18:41:03 +0100908 retval = usb_register_dev(usbhid->intf, &hiddev_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 if (retval) {
Joe Perches4291ee32010-12-09 19:29:03 -0800910 hid_err(hid, "Not able to get a minor for this device\n");
Jiri Kosina76052742009-01-07 13:25:36 +0100911 hid->hiddev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 kfree(hiddev);
913 return -1;
914 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 return 0;
916}
917
918/*
919 * This is where hid.c calls us to disconnect a hiddev device from the
920 * corresponding hid device (usually because the usb device has disconnected)
921 */
922static struct usb_class_driver hiddev_class;
923void hiddev_disconnect(struct hid_device *hid)
924{
925 struct hiddev *hiddev = hid->hiddev;
Jiri Kosina4916b3a2006-12-08 18:41:03 +0100926 struct usbhid_device *usbhid = hid->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
Oliver Neukum07903402008-12-16 10:55:15 +0100928 mutex_lock(&hiddev->existancelock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 hiddev->exist = 0;
Oliver Neukum07903402008-12-16 10:55:15 +0100930 mutex_unlock(&hiddev->existancelock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
Jiri Kosina4916b3a2006-12-08 18:41:03 +0100932 usb_deregister_dev(usbhid->intf, &hiddev_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
934 if (hiddev->open) {
Jiri Kosina4916b3a2006-12-08 18:41:03 +0100935 usbhid_close(hiddev->hid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 wake_up_interruptible(&hiddev->wait);
937 } else {
938 kfree(hiddev);
939 }
940}