1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * USB HID support for Linux
4 *
5 * Copyright (c) 1999 Andreas Gal
6 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
7 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
8 * Copyright (c) 2007-2008 Oliver Neukum
9 * Copyright (c) 2006-2010 Jiri Kosina
10 */
11
12/*
13 */
14
15#include <linux/module.h>
16#include <linux/slab.h>
17#include <linux/init.h>
18#include <linux/kernel.h>
19#include <linux/list.h>
20#include <linux/mm.h>
21#include <linux/mutex.h>
22#include <linux/property.h>
23#include <linux/spinlock.h>
24#include <linux/unaligned.h>
25#include <asm/byteorder.h>
26#include <linux/input.h>
27#include <linux/wait.h>
28#include <linux/workqueue.h>
29#include <linux/string.h>
30
31#include <linux/usb.h>
32
33#include <linux/hid.h>
34#include <linux/hiddev.h>
35#include <linux/hid-debug.h>
36#include <linux/hidraw.h>
37#include "usbhid.h"
38#include "hid-pidff.h"
39
40/*
41 * Version Information
42 */
43
44#define DRIVER_DESC "USB HID core driver"
45
46/*
47 * Module parameters.
48 */
49
50static unsigned int hid_mousepoll_interval;
51module_param_named(mousepoll, hid_mousepoll_interval, uint, 0644);
52MODULE_PARM_DESC(mousepoll, "Polling interval of mice");
53
54static unsigned int hid_jspoll_interval;
55module_param_named(jspoll, hid_jspoll_interval, uint, 0644);
56MODULE_PARM_DESC(jspoll, "Polling interval of joysticks");
57
58static unsigned int hid_kbpoll_interval;
59module_param_named(kbpoll, hid_kbpoll_interval, uint, 0644);
60MODULE_PARM_DESC(kbpoll, "Polling interval of keyboards");
61
62static unsigned int ignoreled;
63module_param_named(ignoreled, ignoreled, uint, 0644);
64MODULE_PARM_DESC(ignoreled, "Autosuspend with active leds");
65
66/* Quirks specified at module load time */
67static char *quirks_param[MAX_USBHID_BOOT_QUIRKS];
68module_param_array_named(quirks, quirks_param, charp, NULL, 0444);
69MODULE_PARM_DESC(quirks, "Add/modify USB HID quirks by specifying "
70 " quirks=vendorID:productID:quirks"
71 " where vendorID, productID, and quirks are all in"
72 " 0x-prefixed hex");
73/*
74 * Input submission and I/O error handler.
75 */
76static void hid_io_error(struct hid_device *hid);
77static int hid_submit_out(struct hid_device *hid);
78static int hid_submit_ctrl(struct hid_device *hid);
79static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid);
80
81/* Start up the input URB */
82static int hid_start_in(struct hid_device *hid)
83{
84 unsigned long flags;
85 int rc = 0;
86 struct usbhid_device *usbhid = hid->driver_data;
87
88 spin_lock_irqsave(&usbhid->lock, flags);
89 if (test_bit(HID_IN_POLLING, &usbhid->iofl) &&
90 !test_bit(HID_DISCONNECTED, &usbhid->iofl) &&
91 !test_bit(HID_SUSPENDED, &usbhid->iofl) &&
92 !test_and_set_bit(HID_IN_RUNNING, addr: &usbhid->iofl)) {
93 rc = usb_submit_urb(urb: usbhid->urbin, GFP_ATOMIC);
94 if (rc != 0) {
95 clear_bit(HID_IN_RUNNING, addr: &usbhid->iofl);
96 if (rc == -ENOSPC)
97 set_bit(HID_NO_BANDWIDTH, addr: &usbhid->iofl);
98 } else {
99 clear_bit(HID_NO_BANDWIDTH, addr: &usbhid->iofl);
100 }
101 }
102 spin_unlock_irqrestore(lock: &usbhid->lock, flags);
103 return rc;
104}
105
106/* I/O retry timer routine */
107static void hid_retry_timeout(struct timer_list *t)
108{
109 struct usbhid_device *usbhid = timer_container_of(usbhid, t, io_retry);
110 struct hid_device *hid = usbhid->hid;
111
112 dev_dbg(&usbhid->intf->dev, "retrying intr urb\n");
113 if (hid_start_in(hid))
114 hid_io_error(hid);
115}
116
117/* Workqueue routine to reset the device or clear a halt */
118static void hid_reset(struct work_struct *work)
119{
120 struct usbhid_device *usbhid =
121 container_of(work, struct usbhid_device, reset_work);
122 struct hid_device *hid = usbhid->hid;
123 int rc;
124
125 if (test_bit(HID_CLEAR_HALT, &usbhid->iofl)) {
126 dev_dbg(&usbhid->intf->dev, "clear halt\n");
127 rc = usb_clear_halt(hid_to_usb_dev(hid), pipe: usbhid->urbin->pipe);
128 clear_bit(HID_CLEAR_HALT, addr: &usbhid->iofl);
129 if (rc == 0) {
130 hid_start_in(hid);
131 } else {
132 dev_dbg(&usbhid->intf->dev,
133 "clear-halt failed: %d\n", rc);
134 set_bit(HID_RESET_PENDING, addr: &usbhid->iofl);
135 }
136 }
137
138 if (test_bit(HID_RESET_PENDING, &usbhid->iofl)) {
139 dev_dbg(&usbhid->intf->dev, "resetting device\n");
140 usb_queue_reset_device(dev: usbhid->intf);
141 }
142}
143
144/* Main I/O error handler */
145static void hid_io_error(struct hid_device *hid)
146{
147 unsigned long flags;
148 struct usbhid_device *usbhid = hid->driver_data;
149
150 spin_lock_irqsave(&usbhid->lock, flags);
151
152 /* Stop when disconnected */
153 if (test_bit(HID_DISCONNECTED, &usbhid->iofl))
154 goto done;
155
156 /* If it has been a while since the last error, we'll assume
157 * this a brand new error and reset the retry timeout. */
158 if (time_after(jiffies, usbhid->stop_retry + HZ/2))
159 usbhid->retry_delay = 0;
160
161 /* When an error occurs, retry at increasing intervals */
162 if (usbhid->retry_delay == 0) {
163 usbhid->retry_delay = 13; /* Then 26, 52, 104, 104, ... */
164 usbhid->stop_retry = jiffies + msecs_to_jiffies(m: 1000);
165 } else if (usbhid->retry_delay < 100)
166 usbhid->retry_delay *= 2;
167
168 if (time_after(jiffies, usbhid->stop_retry)) {
169
170 /* Retries failed, so do a port reset unless we lack bandwidth*/
171 if (!test_bit(HID_NO_BANDWIDTH, &usbhid->iofl)
172 && !test_and_set_bit(HID_RESET_PENDING, addr: &usbhid->iofl)) {
173
174 schedule_work(work: &usbhid->reset_work);
175 goto done;
176 }
177 }
178
179 mod_timer(timer: &usbhid->io_retry,
180 expires: jiffies + msecs_to_jiffies(m: usbhid->retry_delay));
181done:
182 spin_unlock_irqrestore(lock: &usbhid->lock, flags);
183}
184
185static void usbhid_mark_busy(struct usbhid_device *usbhid)
186{
187 struct usb_interface *intf = usbhid->intf;
188
189 usb_mark_last_busy(interface_to_usbdev(intf));
190}
191
192static int usbhid_restart_out_queue(struct usbhid_device *usbhid)
193{
194 struct hid_device *hid = usb_get_intfdata(intf: usbhid->intf);
195 int kicked;
196 int r;
197
198 if (!hid || test_bit(HID_RESET_PENDING, &usbhid->iofl) ||
199 test_bit(HID_SUSPENDED, &usbhid->iofl))
200 return 0;
201
202 if ((kicked = (usbhid->outhead != usbhid->outtail))) {
203 hid_dbg(hid, "Kicking head %d tail %d", usbhid->outhead, usbhid->outtail);
204
205 /* Try to wake up from autosuspend... */
206 r = usb_autopm_get_interface_async(intf: usbhid->intf);
207 if (r < 0)
208 return r;
209
210 /*
211 * If still suspended, don't submit. Submission will
212 * occur if/when resume drains the queue.
213 */
214 if (test_bit(HID_SUSPENDED, &usbhid->iofl)) {
215 usb_autopm_put_interface_no_suspend(intf: usbhid->intf);
216 return r;
217 }
218
219 /* Asynchronously flush queue. */
220 set_bit(HID_OUT_RUNNING, addr: &usbhid->iofl);
221 if (hid_submit_out(hid)) {
222 clear_bit(HID_OUT_RUNNING, addr: &usbhid->iofl);
223 usb_autopm_put_interface_async(intf: usbhid->intf);
224 }
225 wake_up(&usbhid->wait);
226 }
227 return kicked;
228}
229
230static int usbhid_restart_ctrl_queue(struct usbhid_device *usbhid)
231{
232 struct hid_device *hid = usb_get_intfdata(intf: usbhid->intf);
233 int kicked;
234 int r;
235
236 WARN_ON(hid == NULL);
237 if (!hid || test_bit(HID_RESET_PENDING, &usbhid->iofl) ||
238 test_bit(HID_SUSPENDED, &usbhid->iofl))
239 return 0;
240
241 if ((kicked = (usbhid->ctrlhead != usbhid->ctrltail))) {
242 hid_dbg(hid, "Kicking head %d tail %d", usbhid->ctrlhead, usbhid->ctrltail);
243
244 /* Try to wake up from autosuspend... */
245 r = usb_autopm_get_interface_async(intf: usbhid->intf);
246 if (r < 0)
247 return r;
248
249 /*
250 * If still suspended, don't submit. Submission will
251 * occur if/when resume drains the queue.
252 */
253 if (test_bit(HID_SUSPENDED, &usbhid->iofl)) {
254 usb_autopm_put_interface_no_suspend(intf: usbhid->intf);
255 return r;
256 }
257
258 /* Asynchronously flush queue. */
259 set_bit(HID_CTRL_RUNNING, addr: &usbhid->iofl);
260 if (hid_submit_ctrl(hid)) {
261 clear_bit(HID_CTRL_RUNNING, addr: &usbhid->iofl);
262 usb_autopm_put_interface_async(intf: usbhid->intf);
263 }
264 wake_up(&usbhid->wait);
265 }
266 return kicked;
267}
268
269/*
270 * Input interrupt completion handler.
271 */
272
273static void hid_irq_in(struct urb *urb)
274{
275 struct hid_device *hid = urb->context;
276 struct usbhid_device *usbhid = hid->driver_data;
277 int status;
278
279 switch (urb->status) {
280 case 0: /* success */
281 usbhid->retry_delay = 0;
282 if (!test_bit(HID_OPENED, &usbhid->iofl))
283 break;
284 usbhid_mark_busy(usbhid);
285 if (!test_bit(HID_RESUME_RUNNING, &usbhid->iofl)) {
286 hid_input_report(hid: urb->context, type: HID_INPUT_REPORT,
287 data: urb->transfer_buffer,
288 size: urb->actual_length, interrupt: 1);
289 /*
290 * autosuspend refused while keys are pressed
291 * because most keyboards don't wake up when
292 * a key is released
293 */
294 if (hid_check_keys_pressed(hid))
295 set_bit(HID_KEYS_PRESSED, addr: &usbhid->iofl);
296 else
297 clear_bit(HID_KEYS_PRESSED, addr: &usbhid->iofl);
298 }
299 break;
300 case -EPIPE: /* stall */
301 usbhid_mark_busy(usbhid);
302 clear_bit(HID_IN_RUNNING, addr: &usbhid->iofl);
303 set_bit(HID_CLEAR_HALT, addr: &usbhid->iofl);
304 schedule_work(work: &usbhid->reset_work);
305 return;
306 case -ECONNRESET: /* unlink */
307 case -ENOENT:
308 case -ESHUTDOWN: /* unplug */
309 clear_bit(HID_IN_RUNNING, addr: &usbhid->iofl);
310 return;
311 case -EILSEQ: /* protocol error or unplug */
312 case -EPROTO: /* protocol error or unplug */
313 case -ETIME: /* protocol error or unplug */
314 case -ETIMEDOUT: /* Should never happen, but... */
315 usbhid_mark_busy(usbhid);
316 clear_bit(HID_IN_RUNNING, addr: &usbhid->iofl);
317 hid_io_error(hid);
318 return;
319 default: /* error */
320 hid_warn(urb->dev, "input irq status %d received\n",
321 urb->status);
322 }
323
324 status = usb_submit_urb(urb, GFP_ATOMIC);
325 if (status) {
326 clear_bit(HID_IN_RUNNING, addr: &usbhid->iofl);
327 if (status != -EPERM) {
328 hid_err(hid, "can't resubmit intr, %s-%s/input%d, status %d\n",
329 hid_to_usb_dev(hid)->bus->bus_name,
330 hid_to_usb_dev(hid)->devpath,
331 usbhid->ifnum, status);
332 hid_io_error(hid);
333 }
334 }
335}
336
337static int hid_submit_out(struct hid_device *hid)
338{
339 struct hid_report *report;
340 char *raw_report;
341 struct usbhid_device *usbhid = hid->driver_data;
342 int r;
343
344 report = usbhid->out[usbhid->outtail].report;
345 raw_report = usbhid->out[usbhid->outtail].raw_report;
346
347 usbhid->urbout->transfer_buffer_length = hid_report_len(report);
348 usbhid->urbout->dev = hid_to_usb_dev(hid);
349 if (raw_report) {
350 memcpy(to: usbhid->outbuf, from: raw_report,
351 len: usbhid->urbout->transfer_buffer_length);
352 kfree(objp: raw_report);
353 usbhid->out[usbhid->outtail].raw_report = NULL;
354 }
355
356 dbg_hid("submitting out urb\n");
357
358 r = usb_submit_urb(urb: usbhid->urbout, GFP_ATOMIC);
359 if (r < 0) {
360 hid_err(hid, "usb_submit_urb(out) failed: %d\n", r);
361 return r;
362 }
363 usbhid->last_out = jiffies;
364 return 0;
365}
366
367static int hid_submit_ctrl(struct hid_device *hid)
368{
369 struct hid_report *report;
370 unsigned char dir;
371 char *raw_report;
372 int len, r;
373 struct usbhid_device *usbhid = hid->driver_data;
374
375 report = usbhid->ctrl[usbhid->ctrltail].report;
376 raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report;
377 dir = usbhid->ctrl[usbhid->ctrltail].dir;
378
379 len = hid_report_len(report);
380 if (dir == USB_DIR_OUT) {
381 usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
382 if (raw_report) {
383 memcpy(to: usbhid->ctrlbuf, from: raw_report, len);
384 kfree(objp: raw_report);
385 usbhid->ctrl[usbhid->ctrltail].raw_report = NULL;
386 }
387 } else {
388 int maxpacket;
389
390 usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0);
391 maxpacket = usb_maxpacket(hid_to_usb_dev(hid),
392 pipe: usbhid->urbctrl->pipe);
393 len += (len == 0); /* Don't allow 0-length reports */
394 len = round_up(len, maxpacket);
395 if (len > usbhid->bufsize)
396 len = usbhid->bufsize;
397 }
398 usbhid->urbctrl->transfer_buffer_length = len;
399 usbhid->urbctrl->dev = hid_to_usb_dev(hid);
400
401 usbhid->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | dir;
402 usbhid->cr->bRequest = (dir == USB_DIR_OUT) ? HID_REQ_SET_REPORT :
403 HID_REQ_GET_REPORT;
404 usbhid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) |
405 report->id);
406 usbhid->cr->wIndex = cpu_to_le16(usbhid->ifnum);
407 usbhid->cr->wLength = cpu_to_le16(len);
408
409 dbg_hid("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u\n",
410 usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" :
411 "Get_Report",
412 usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength);
413
414 r = usb_submit_urb(urb: usbhid->urbctrl, GFP_ATOMIC);
415 if (r < 0) {
416 hid_err(hid, "usb_submit_urb(ctrl) failed: %d\n", r);
417 return r;
418 }
419 usbhid->last_ctrl = jiffies;
420 return 0;
421}
422
423/*
424 * Output interrupt completion handler.
425 */
426
427static void hid_irq_out(struct urb *urb)
428{
429 struct hid_device *hid = urb->context;
430 struct usbhid_device *usbhid = hid->driver_data;
431 unsigned long flags;
432 int unplug = 0;
433
434 switch (urb->status) {
435 case 0: /* success */
436 break;
437 case -ESHUTDOWN: /* unplug */
438 unplug = 1;
439 break;
440 case -EILSEQ: /* protocol error or unplug */
441 case -EPROTO: /* protocol error or unplug */
442 case -ECONNRESET: /* unlink */
443 case -ENOENT:
444 break;
445 default: /* error */
446 hid_warn(urb->dev, "output irq status %d received\n",
447 urb->status);
448 }
449
450 spin_lock_irqsave(&usbhid->lock, flags);
451
452 if (unplug) {
453 usbhid->outtail = usbhid->outhead;
454 } else {
455 usbhid->outtail = (usbhid->outtail + 1) & (HID_OUTPUT_FIFO_SIZE - 1);
456
457 if (usbhid->outhead != usbhid->outtail &&
458 hid_submit_out(hid) == 0) {
459 /* Successfully submitted next urb in queue */
460 spin_unlock_irqrestore(lock: &usbhid->lock, flags);
461 return;
462 }
463 }
464
465 clear_bit(HID_OUT_RUNNING, addr: &usbhid->iofl);
466 spin_unlock_irqrestore(lock: &usbhid->lock, flags);
467 usb_autopm_put_interface_async(intf: usbhid->intf);
468 wake_up(&usbhid->wait);
469}
470
471/*
472 * Control pipe completion handler.
473 */
474
475static void hid_ctrl(struct urb *urb)
476{
477 struct hid_device *hid = urb->context;
478 struct usbhid_device *usbhid = hid->driver_data;
479 unsigned long flags;
480 int unplug = 0, status = urb->status;
481
482 switch (status) {
483 case 0: /* success */
484 if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)
485 hid_input_report(hid: urb->context,
486 type: usbhid->ctrl[usbhid->ctrltail].report->type,
487 data: urb->transfer_buffer, size: urb->actual_length, interrupt: 0);
488 break;
489 case -ESHUTDOWN: /* unplug */
490 unplug = 1;
491 break;
492 case -EILSEQ: /* protocol error or unplug */
493 case -EPROTO: /* protocol error or unplug */
494 case -ECONNRESET: /* unlink */
495 case -ENOENT:
496 case -EPIPE: /* report not available */
497 break;
498 default: /* error */
499 hid_warn(urb->dev, "ctrl urb status %d received\n", status);
500 }
501
502 spin_lock_irqsave(&usbhid->lock, flags);
503
504 if (unplug) {
505 usbhid->ctrltail = usbhid->ctrlhead;
506 } else if (usbhid->ctrlhead != usbhid->ctrltail) {
507 usbhid->ctrltail = (usbhid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1);
508
509 if (usbhid->ctrlhead != usbhid->ctrltail &&
510 hid_submit_ctrl(hid) == 0) {
511 /* Successfully submitted next urb in queue */
512 spin_unlock_irqrestore(lock: &usbhid->lock, flags);
513 return;
514 }
515 }
516
517 clear_bit(HID_CTRL_RUNNING, addr: &usbhid->iofl);
518 spin_unlock_irqrestore(lock: &usbhid->lock, flags);
519 usb_autopm_put_interface_async(intf: usbhid->intf);
520 wake_up(&usbhid->wait);
521}
522
523static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *report,
524 unsigned char dir)
525{
526 int head;
527 struct usbhid_device *usbhid = hid->driver_data;
528
529 if (((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN) ||
530 test_bit(HID_DISCONNECTED, &usbhid->iofl))
531 return;
532
533 if (usbhid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) {
534 if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) {
535 hid_warn(hid, "output queue full\n");
536 return;
537 }
538
539 usbhid->out[usbhid->outhead].raw_report = hid_alloc_report_buf(report, GFP_ATOMIC);
540 if (!usbhid->out[usbhid->outhead].raw_report) {
541 hid_warn(hid, "output queueing failed\n");
542 return;
543 }
544 hid_output_report(report, data: usbhid->out[usbhid->outhead].raw_report);
545 usbhid->out[usbhid->outhead].report = report;
546 usbhid->outhead = head;
547
548 /* If the queue isn't running, restart it */
549 if (!test_bit(HID_OUT_RUNNING, &usbhid->iofl)) {
550 usbhid_restart_out_queue(usbhid);
551
552 /* Otherwise see if an earlier request has timed out */
553 } else if (time_after(jiffies, usbhid->last_out + HZ * 5)) {
554
555 /* Prevent autosuspend following the unlink */
556 usb_autopm_get_interface_no_resume(intf: usbhid->intf);
557
558 /*
559 * Prevent resubmission in case the URB completes
560 * before we can unlink it. We don't want to cancel
561 * the wrong transfer!
562 */
563 usb_block_urb(urb: usbhid->urbout);
564
565 /* Drop lock to avoid deadlock if the callback runs */
566 spin_unlock(lock: &usbhid->lock);
567
568 usb_unlink_urb(urb: usbhid->urbout);
569 spin_lock(lock: &usbhid->lock);
570 usb_unblock_urb(urb: usbhid->urbout);
571
572 /* Unlink might have stopped the queue */
573 if (!test_bit(HID_OUT_RUNNING, &usbhid->iofl))
574 usbhid_restart_out_queue(usbhid);
575
576 /* Now we can allow autosuspend again */
577 usb_autopm_put_interface_async(intf: usbhid->intf);
578 }
579 return;
580 }
581
582 if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) {
583 hid_warn(hid, "control queue full\n");
584 return;
585 }
586
587 if (dir == USB_DIR_OUT) {
588 usbhid->ctrl[usbhid->ctrlhead].raw_report = hid_alloc_report_buf(report, GFP_ATOMIC);
589 if (!usbhid->ctrl[usbhid->ctrlhead].raw_report) {
590 hid_warn(hid, "control queueing failed\n");
591 return;
592 }
593 hid_output_report(report, data: usbhid->ctrl[usbhid->ctrlhead].raw_report);
594 }
595 usbhid->ctrl[usbhid->ctrlhead].report = report;
596 usbhid->ctrl[usbhid->ctrlhead].dir = dir;
597 usbhid->ctrlhead = head;
598
599 /* If the queue isn't running, restart it */
600 if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) {
601 usbhid_restart_ctrl_queue(usbhid);
602
603 /* Otherwise see if an earlier request has timed out */
604 } else if (time_after(jiffies, usbhid->last_ctrl + HZ * 5)) {
605
606 /* Prevent autosuspend following the unlink */
607 usb_autopm_get_interface_no_resume(intf: usbhid->intf);
608
609 /*
610 * Prevent resubmission in case the URB completes
611 * before we can unlink it. We don't want to cancel
612 * the wrong transfer!
613 */
614 usb_block_urb(urb: usbhid->urbctrl);
615
616 /* Drop lock to avoid deadlock if the callback runs */
617 spin_unlock(lock: &usbhid->lock);
618
619 usb_unlink_urb(urb: usbhid->urbctrl);
620 spin_lock(lock: &usbhid->lock);
621 usb_unblock_urb(urb: usbhid->urbctrl);
622
623 /* Unlink might have stopped the queue */
624 if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl))
625 usbhid_restart_ctrl_queue(usbhid);
626
627 /* Now we can allow autosuspend again */
628 usb_autopm_put_interface_async(intf: usbhid->intf);
629 }
630}
631
632static void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
633{
634 struct usbhid_device *usbhid = hid->driver_data;
635 unsigned long flags;
636
637 spin_lock_irqsave(&usbhid->lock, flags);
638 __usbhid_submit_report(hid, report, dir);
639 spin_unlock_irqrestore(lock: &usbhid->lock, flags);
640}
641
642static int usbhid_wait_io(struct hid_device *hid)
643{
644 struct usbhid_device *usbhid = hid->driver_data;
645
646 if (!wait_event_timeout(usbhid->wait,
647 (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) &&
648 !test_bit(HID_OUT_RUNNING, &usbhid->iofl)),
649 10*HZ)) {
650 dbg_hid("timeout waiting for ctrl or out queue to clear\n");
651 return -1;
652 }
653
654 return 0;
655}
656
657static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle)
658{
659 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
660 request: HID_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, value: (idle << 8) | report,
661 index: ifnum, NULL, size: 0, USB_CTRL_SET_TIMEOUT);
662}
663
664static int hid_get_class_descriptor(struct usb_device *dev, int ifnum,
665 unsigned char type, void *buf, int size)
666{
667 int result, retries = 4;
668
669 memset(s: buf, c: 0, n: size);
670
671 do {
672 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
673 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
674 value: (type << 8), index: ifnum, data: buf, size, USB_CTRL_GET_TIMEOUT);
675 retries--;
676 } while (result < size && retries);
677 return result;
678}
679
680static int usbhid_open(struct hid_device *hid)
681{
682 struct usbhid_device *usbhid = hid->driver_data;
683 int res;
684
685 mutex_lock(lock: &usbhid->mutex);
686
687 set_bit(HID_OPENED, addr: &usbhid->iofl);
688
689 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
690 res = 0;
691 goto Done;
692 }
693
694 res = usb_autopm_get_interface(intf: usbhid->intf);
695 /* the device must be awake to reliably request remote wakeup */
696 if (res < 0) {
697 clear_bit(HID_OPENED, addr: &usbhid->iofl);
698 res = -EIO;
699 goto Done;
700 }
701
702 usbhid->intf->needs_remote_wakeup = 1;
703
704 set_bit(HID_RESUME_RUNNING, addr: &usbhid->iofl);
705 set_bit(HID_IN_POLLING, addr: &usbhid->iofl);
706
707 res = hid_start_in(hid);
708 if (res) {
709 if (res != -ENOSPC) {
710 hid_io_error(hid);
711 res = 0;
712 } else {
713 /* no use opening if resources are insufficient */
714 res = -EBUSY;
715 clear_bit(HID_OPENED, addr: &usbhid->iofl);
716 clear_bit(HID_IN_POLLING, addr: &usbhid->iofl);
717 usbhid->intf->needs_remote_wakeup = 0;
718 }
719 }
720
721 usb_autopm_put_interface(intf: usbhid->intf);
722
723 /*
724 * In case events are generated while nobody was listening,
725 * some are released when the device is re-opened.
726 * Wait 50 msec for the queue to empty before allowing events
727 * to go through hid.
728 */
729 if (res == 0)
730 msleep(msecs: 50);
731
732 clear_bit(HID_RESUME_RUNNING, addr: &usbhid->iofl);
733
734 Done:
735 mutex_unlock(lock: &usbhid->mutex);
736 return res;
737}
738
739static void usbhid_close(struct hid_device *hid)
740{
741 struct usbhid_device *usbhid = hid->driver_data;
742
743 mutex_lock(lock: &usbhid->mutex);
744
745 /*
746 * Make sure we don't restart data acquisition due to
747 * a resumption we no longer care about by avoiding racing
748 * with hid_start_in().
749 */
750 spin_lock_irq(lock: &usbhid->lock);
751 clear_bit(HID_OPENED, addr: &usbhid->iofl);
752 if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL))
753 clear_bit(HID_IN_POLLING, addr: &usbhid->iofl);
754 spin_unlock_irq(lock: &usbhid->lock);
755
756 if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL)) {
757 hid_cancel_delayed_stuff(usbhid);
758 usb_kill_urb(urb: usbhid->urbin);
759 usbhid->intf->needs_remote_wakeup = 0;
760 }
761
762 mutex_unlock(lock: &usbhid->mutex);
763}
764
765/*
766 * Initialize all reports
767 */
768
769void usbhid_init_reports(struct hid_device *hid)
770{
771 struct hid_report *report;
772 struct usbhid_device *usbhid = hid->driver_data;
773 struct hid_report_enum *report_enum;
774 int err, ret;
775
776 report_enum = &hid->report_enum[HID_INPUT_REPORT];
777 list_for_each_entry(report, &report_enum->report_list, list)
778 usbhid_submit_report(hid, report, USB_DIR_IN);
779
780 report_enum = &hid->report_enum[HID_FEATURE_REPORT];
781 list_for_each_entry(report, &report_enum->report_list, list)
782 usbhid_submit_report(hid, report, USB_DIR_IN);
783
784 err = 0;
785 ret = usbhid_wait_io(hid);
786 while (ret) {
787 err |= ret;
788 if (test_bit(HID_CTRL_RUNNING, &usbhid->iofl))
789 usb_kill_urb(urb: usbhid->urbctrl);
790 if (test_bit(HID_OUT_RUNNING, &usbhid->iofl))
791 usb_kill_urb(urb: usbhid->urbout);
792 ret = usbhid_wait_io(hid);
793 }
794
795 if (err)
796 hid_warn(hid, "timeout initializing reports\n");
797}
798
799/*
800 * Reset LEDs which BIOS might have left on. For now, just NumLock (0x01).
801 */
802static int hid_find_field_early(struct hid_device *hid, unsigned int page,
803 unsigned int hid_code, struct hid_field **pfield)
804{
805 struct hid_report *report;
806 struct hid_field *field;
807 struct hid_usage *usage;
808 int i, j;
809
810 list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
811 for (i = 0; i < report->maxfield; i++) {
812 field = report->field[i];
813 for (j = 0; j < field->maxusage; j++) {
814 usage = &field->usage[j];
815 if ((usage->hid & HID_USAGE_PAGE) == page &&
816 (usage->hid & 0xFFFF) == hid_code) {
817 *pfield = field;
818 return j;
819 }
820 }
821 }
822 }
823 return -1;
824}
825
826static void usbhid_set_leds(struct hid_device *hid)
827{
828 struct hid_field *field;
829 int offset;
830
831 if ((offset = hid_find_field_early(hid, HID_UP_LED, hid_code: 0x01, pfield: &field)) != -1) {
832 hid_set_field(field, offset, 0);
833 usbhid_submit_report(hid, report: field->report, USB_DIR_OUT);
834 }
835}
836
837/*
838 * Traverse the supplied list of reports and find the longest
839 */
840static void hid_find_max_report(struct hid_device *hid, unsigned int type,
841 unsigned int *max)
842{
843 struct hid_report *report;
844 unsigned int size;
845
846 list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
847 size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered;
848 if (*max < size)
849 *max = size;
850 }
851}
852
853static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
854{
855 struct usbhid_device *usbhid = hid->driver_data;
856
857 usbhid->inbuf = usb_alloc_coherent(dev, size: usbhid->bufsize, GFP_KERNEL,
858 dma: &usbhid->inbuf_dma);
859 usbhid->outbuf = usb_alloc_coherent(dev, size: usbhid->bufsize, GFP_KERNEL,
860 dma: &usbhid->outbuf_dma);
861 usbhid->cr = kmalloc(sizeof(*usbhid->cr), GFP_KERNEL);
862 usbhid->ctrlbuf = usb_alloc_coherent(dev, size: usbhid->bufsize, GFP_KERNEL,
863 dma: &usbhid->ctrlbuf_dma);
864 if (!usbhid->inbuf || !usbhid->outbuf || !usbhid->cr ||
865 !usbhid->ctrlbuf)
866 return -1;
867
868 return 0;
869}
870
871static int usbhid_get_raw_report(struct hid_device *hid,
872 unsigned char report_number, __u8 *buf, size_t count,
873 unsigned char report_type)
874{
875 struct usbhid_device *usbhid = hid->driver_data;
876 struct usb_device *dev = hid_to_usb_dev(hid);
877 struct usb_interface *intf = usbhid->intf;
878 struct usb_host_interface *interface = intf->cur_altsetting;
879 int skipped_report_id = 0;
880 int ret;
881
882 /* Byte 0 is the report number. Report data starts at byte 1.*/
883 buf[0] = report_number;
884 if (report_number == 0x0) {
885 /* Offset the return buffer by 1, so that the report ID
886 will remain in byte 0. */
887 buf++;
888 count--;
889 skipped_report_id = 1;
890 }
891 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
892 request: HID_REQ_GET_REPORT,
893 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
894 value: ((report_type + 1) << 8) | report_number,
895 index: interface->desc.bInterfaceNumber, data: buf, size: count,
896 USB_CTRL_SET_TIMEOUT);
897
898 /* count also the report id */
899 if (ret > 0 && skipped_report_id)
900 ret++;
901
902 return ret;
903}
904
905static int usbhid_set_raw_report(struct hid_device *hid, unsigned int reportnum,
906 __u8 *buf, size_t count, unsigned char rtype)
907{
908 struct usbhid_device *usbhid = hid->driver_data;
909 struct usb_device *dev = hid_to_usb_dev(hid);
910 struct usb_interface *intf = usbhid->intf;
911 struct usb_host_interface *interface = intf->cur_altsetting;
912 int ret, skipped_report_id = 0;
913
914 /* Byte 0 is the report number. Report data starts at byte 1.*/
915 if ((rtype == HID_OUTPUT_REPORT) &&
916 (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORT_ID))
917 buf[0] = 0;
918 else
919 buf[0] = reportnum;
920
921 if (buf[0] == 0x0) {
922 /* Don't send the Report ID */
923 buf++;
924 count--;
925 skipped_report_id = 1;
926 }
927
928 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
929 request: HID_REQ_SET_REPORT,
930 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
931 value: ((rtype + 1) << 8) | reportnum,
932 index: interface->desc.bInterfaceNumber, data: buf, size: count,
933 USB_CTRL_SET_TIMEOUT);
934 /* count also the report id, if this was a numbered report. */
935 if (ret > 0 && skipped_report_id)
936 ret++;
937
938 return ret;
939}
940
941static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count)
942{
943 struct usbhid_device *usbhid = hid->driver_data;
944 struct usb_device *dev = hid_to_usb_dev(hid);
945 int actual_length, skipped_report_id = 0, ret;
946
947 if (!usbhid->urbout)
948 return -ENOSYS;
949
950 if (buf[0] == 0x0) {
951 /* Don't send the Report ID */
952 buf++;
953 count--;
954 skipped_report_id = 1;
955 }
956
957 ret = usb_interrupt_msg(usb_dev: dev, pipe: usbhid->urbout->pipe,
958 data: buf, len: count, actual_length: &actual_length,
959 USB_CTRL_SET_TIMEOUT);
960 /* return the number of bytes transferred */
961 if (ret == 0) {
962 ret = actual_length;
963 /* count also the report id */
964 if (skipped_report_id)
965 ret++;
966 }
967
968 return ret;
969}
970
971static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
972{
973 struct usbhid_device *usbhid = hid->driver_data;
974
975 usb_free_coherent(dev, size: usbhid->bufsize, addr: usbhid->inbuf, dma: usbhid->inbuf_dma);
976 usb_free_coherent(dev, size: usbhid->bufsize, addr: usbhid->outbuf, dma: usbhid->outbuf_dma);
977 kfree(objp: usbhid->cr);
978 usb_free_coherent(dev, size: usbhid->bufsize, addr: usbhid->ctrlbuf, dma: usbhid->ctrlbuf_dma);
979}
980
981static int usbhid_parse(struct hid_device *hid)
982{
983 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
984 struct usb_host_interface *interface = intf->cur_altsetting;
985 struct usb_device *dev = interface_to_usbdev (intf);
986 struct hid_descriptor *hdesc;
987 struct hid_class_descriptor *hcdesc;
988 u32 quirks = 0;
989 unsigned int rsize = 0;
990 char *rdesc;
991 int ret;
992
993 quirks = hid_lookup_quirk(hdev: hid);
994
995 if (quirks & HID_QUIRK_IGNORE)
996 return -ENODEV;
997
998 /* Many keyboards and mice don't like to be polled for reports,
999 * so we will always set the HID_QUIRK_NOGET flag for them. */
1000 if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) {
1001 if (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD ||
1002 interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)
1003 quirks |= HID_QUIRK_NOGET;
1004 }
1005
1006 if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
1007 (!interface->desc.bNumEndpoints ||
1008 usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
1009 dbg_hid("class descriptor not present\n");
1010 return -ENODEV;
1011 }
1012
1013 if (!hdesc->bNumDescriptors ||
1014 hdesc->bLength != sizeof(*hdesc) +
1015 (hdesc->bNumDescriptors - 1) * sizeof(*hcdesc)) {
1016 dbg_hid("hid descriptor invalid, bLen=%hhu bNum=%hhu\n",
1017 hdesc->bLength, hdesc->bNumDescriptors);
1018 return -EINVAL;
1019 }
1020
1021 hid->version = le16_to_cpu(hdesc->bcdHID);
1022 hid->country = hdesc->bCountryCode;
1023
1024 if (hdesc->rpt_desc.bDescriptorType == HID_DT_REPORT)
1025 rsize = le16_to_cpu(hdesc->rpt_desc.wDescriptorLength);
1026
1027 if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
1028 dbg_hid("weird size of report descriptor (%u)\n", rsize);
1029 return -EINVAL;
1030 }
1031
1032 rdesc = kmalloc(rsize, GFP_KERNEL);
1033 if (!rdesc)
1034 return -ENOMEM;
1035
1036 hid_set_idle(dev, ifnum: interface->desc.bInterfaceNumber, report: 0, idle: 0);
1037
1038 ret = hid_get_class_descriptor(dev, ifnum: interface->desc.bInterfaceNumber,
1039 HID_DT_REPORT, buf: rdesc, size: rsize);
1040 if (ret < 0) {
1041 dbg_hid("reading report descriptor failed\n");
1042 kfree(objp: rdesc);
1043 goto err;
1044 }
1045
1046 ret = hid_parse_report(hid, start: rdesc, size: rsize);
1047 kfree(objp: rdesc);
1048 if (ret) {
1049 dbg_hid("parsing report descriptor failed\n");
1050 goto err;
1051 }
1052
1053 if (hdesc->bNumDescriptors > 1)
1054 hid_warn(intf,
1055 "%u unsupported optional hid class descriptors\n",
1056 (int)(hdesc->bNumDescriptors - 1));
1057
1058 hid->quirks |= quirks;
1059
1060 return 0;
1061err:
1062 return ret;
1063}
1064
1065static int usbhid_start(struct hid_device *hid)
1066{
1067 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
1068 struct usb_host_interface *interface = intf->cur_altsetting;
1069 struct usb_device *dev = interface_to_usbdev(intf);
1070 struct usbhid_device *usbhid = hid->driver_data;
1071 unsigned int n, insize = 0;
1072 int ret;
1073
1074 mutex_lock(lock: &usbhid->mutex);
1075
1076 clear_bit(HID_DISCONNECTED, addr: &usbhid->iofl);
1077
1078 usbhid->bufsize = HID_MIN_BUFFER_SIZE;
1079 hid_find_max_report(hid, type: HID_INPUT_REPORT, max: &usbhid->bufsize);
1080 hid_find_max_report(hid, type: HID_OUTPUT_REPORT, max: &usbhid->bufsize);
1081 hid_find_max_report(hid, type: HID_FEATURE_REPORT, max: &usbhid->bufsize);
1082
1083 if (usbhid->bufsize > HID_MAX_BUFFER_SIZE)
1084 usbhid->bufsize = HID_MAX_BUFFER_SIZE;
1085
1086 hid_find_max_report(hid, type: HID_INPUT_REPORT, max: &insize);
1087
1088 if (insize > HID_MAX_BUFFER_SIZE)
1089 insize = HID_MAX_BUFFER_SIZE;
1090
1091 if (hid_alloc_buffers(dev, hid)) {
1092 ret = -ENOMEM;
1093 goto fail;
1094 }
1095
1096 for (n = 0; n < interface->desc.bNumEndpoints; n++) {
1097 struct usb_endpoint_descriptor *endpoint;
1098 int pipe;
1099 int interval;
1100
1101 endpoint = &interface->endpoint[n].desc;
1102 if (!usb_endpoint_xfer_int(epd: endpoint))
1103 continue;
1104
1105 interval = endpoint->bInterval;
1106
1107 /* Some vendors give fullspeed interval on highspeed devices */
1108 if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL &&
1109 dev->speed == USB_SPEED_HIGH) {
1110 interval = fls(x: endpoint->bInterval*8);
1111 pr_info("%s: Fixing fullspeed to highspeed interval: %d -> %d\n",
1112 hid->name, endpoint->bInterval, interval);
1113 }
1114
1115 /* Change the polling interval of mice, joysticks
1116 * and keyboards.
1117 */
1118 switch (hid->collection->usage) {
1119 case HID_GD_MOUSE:
1120 if (hid_mousepoll_interval > 0)
1121 interval = hid_mousepoll_interval;
1122 break;
1123 case HID_GD_JOYSTICK:
1124 if (hid_jspoll_interval > 0)
1125 interval = hid_jspoll_interval;
1126 break;
1127 case HID_GD_KEYBOARD:
1128 if (hid_kbpoll_interval > 0)
1129 interval = hid_kbpoll_interval;
1130 break;
1131 }
1132
1133 ret = -ENOMEM;
1134 if (usb_endpoint_dir_in(epd: endpoint)) {
1135 if (usbhid->urbin)
1136 continue;
1137 if (!(usbhid->urbin = usb_alloc_urb(iso_packets: 0, GFP_KERNEL)))
1138 goto fail;
1139 pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
1140 usb_fill_int_urb(urb: usbhid->urbin, dev, pipe, transfer_buffer: usbhid->inbuf, buffer_length: insize,
1141 complete_fn: hid_irq_in, context: hid, interval);
1142 usbhid->urbin->transfer_dma = usbhid->inbuf_dma;
1143 usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1144 } else {
1145 if (usbhid->urbout)
1146 continue;
1147 if (!(usbhid->urbout = usb_alloc_urb(iso_packets: 0, GFP_KERNEL)))
1148 goto fail;
1149 pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);
1150 usb_fill_int_urb(urb: usbhid->urbout, dev, pipe, transfer_buffer: usbhid->outbuf, buffer_length: 0,
1151 complete_fn: hid_irq_out, context: hid, interval);
1152 usbhid->urbout->transfer_dma = usbhid->outbuf_dma;
1153 usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1154 }
1155 }
1156
1157 usbhid->urbctrl = usb_alloc_urb(iso_packets: 0, GFP_KERNEL);
1158 if (!usbhid->urbctrl) {
1159 ret = -ENOMEM;
1160 goto fail;
1161 }
1162
1163 usb_fill_control_urb(urb: usbhid->urbctrl, dev, pipe: 0, setup_packet: (void *) usbhid->cr,
1164 transfer_buffer: usbhid->ctrlbuf, buffer_length: 1, complete_fn: hid_ctrl, context: hid);
1165 usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
1166 usbhid->urbctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1167
1168 set_bit(HID_STARTED, addr: &usbhid->iofl);
1169
1170 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
1171 ret = usb_autopm_get_interface(intf: usbhid->intf);
1172 if (ret)
1173 goto fail;
1174 set_bit(HID_IN_POLLING, addr: &usbhid->iofl);
1175 usbhid->intf->needs_remote_wakeup = 1;
1176 ret = hid_start_in(hid);
1177 if (ret) {
1178 dev_err(&hid->dev,
1179 "failed to start in urb: %d\n", ret);
1180 }
1181 usb_autopm_put_interface(intf: usbhid->intf);
1182 }
1183
1184 /* Some keyboards don't work until their LEDs have been set.
1185 * Since BIOSes do set the LEDs, it must be safe for any device
1186 * that supports the keyboard boot protocol.
1187 * In addition, enable remote wakeup by default for all keyboard
1188 * devices supporting the boot protocol.
1189 */
1190 if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT &&
1191 interface->desc.bInterfaceProtocol ==
1192 USB_INTERFACE_PROTOCOL_KEYBOARD) {
1193 usbhid_set_leds(hid);
1194 device_set_wakeup_enable(dev: &dev->dev, enable: 1);
1195 }
1196
1197 mutex_unlock(lock: &usbhid->mutex);
1198 return 0;
1199
1200fail:
1201 usb_free_urb(urb: usbhid->urbin);
1202 usb_free_urb(urb: usbhid->urbout);
1203 usb_free_urb(urb: usbhid->urbctrl);
1204 usbhid->urbin = NULL;
1205 usbhid->urbout = NULL;
1206 usbhid->urbctrl = NULL;
1207 hid_free_buffers(dev, hid);
1208 mutex_unlock(lock: &usbhid->mutex);
1209 return ret;
1210}
1211
1212static void usbhid_stop(struct hid_device *hid)
1213{
1214 struct usbhid_device *usbhid = hid->driver_data;
1215
1216 if (WARN_ON(!usbhid))
1217 return;
1218
1219 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
1220 clear_bit(HID_IN_POLLING, addr: &usbhid->iofl);
1221 usbhid->intf->needs_remote_wakeup = 0;
1222 }
1223
1224 mutex_lock(lock: &usbhid->mutex);
1225
1226 clear_bit(HID_STARTED, addr: &usbhid->iofl);
1227
1228 spin_lock_irq(lock: &usbhid->lock); /* Sync with error and led handlers */
1229 set_bit(HID_DISCONNECTED, addr: &usbhid->iofl);
1230 while (usbhid->ctrltail != usbhid->ctrlhead) {
1231 if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_OUT) {
1232 kfree(objp: usbhid->ctrl[usbhid->ctrltail].raw_report);
1233 usbhid->ctrl[usbhid->ctrltail].raw_report = NULL;
1234 }
1235
1236 usbhid->ctrltail = (usbhid->ctrltail + 1) &
1237 (HID_CONTROL_FIFO_SIZE - 1);
1238 }
1239 spin_unlock_irq(lock: &usbhid->lock);
1240
1241 usb_kill_urb(urb: usbhid->urbin);
1242 usb_kill_urb(urb: usbhid->urbout);
1243 usb_kill_urb(urb: usbhid->urbctrl);
1244
1245 hid_cancel_delayed_stuff(usbhid);
1246
1247 hid->claimed = 0;
1248
1249 usb_free_urb(urb: usbhid->urbin);
1250 usb_free_urb(urb: usbhid->urbctrl);
1251 usb_free_urb(urb: usbhid->urbout);
1252 usbhid->urbin = NULL; /* don't mess up next start */
1253 usbhid->urbctrl = NULL;
1254 usbhid->urbout = NULL;
1255
1256 hid_free_buffers(hid_to_usb_dev(hid), hid);
1257
1258 mutex_unlock(lock: &usbhid->mutex);
1259}
1260
1261static int usbhid_power(struct hid_device *hid, int lvl)
1262{
1263 struct usbhid_device *usbhid = hid->driver_data;
1264 int r = 0;
1265
1266 switch (lvl) {
1267 case PM_HINT_FULLON:
1268 r = usb_autopm_get_interface(intf: usbhid->intf);
1269 break;
1270
1271 case PM_HINT_NORMAL:
1272 usb_autopm_put_interface(intf: usbhid->intf);
1273 break;
1274 }
1275
1276 return r;
1277}
1278
1279static void usbhid_request(struct hid_device *hid, struct hid_report *rep, int reqtype)
1280{
1281 switch (reqtype) {
1282 case HID_REQ_GET_REPORT:
1283 usbhid_submit_report(hid, report: rep, USB_DIR_IN);
1284 break;
1285 case HID_REQ_SET_REPORT:
1286 usbhid_submit_report(hid, report: rep, USB_DIR_OUT);
1287 break;
1288 }
1289}
1290
1291static int usbhid_raw_request(struct hid_device *hid, unsigned char reportnum,
1292 __u8 *buf, size_t len, unsigned char rtype,
1293 int reqtype)
1294{
1295 switch (reqtype) {
1296 case HID_REQ_GET_REPORT:
1297 return usbhid_get_raw_report(hid, report_number: reportnum, buf, count: len, report_type: rtype);
1298 case HID_REQ_SET_REPORT:
1299 return usbhid_set_raw_report(hid, reportnum, buf, count: len, rtype);
1300 default:
1301 return -EIO;
1302 }
1303}
1304
1305static int usbhid_idle(struct hid_device *hid, int report, int idle,
1306 int reqtype)
1307{
1308 struct usb_device *dev = hid_to_usb_dev(hid);
1309 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
1310 struct usb_host_interface *interface = intf->cur_altsetting;
1311 int ifnum = interface->desc.bInterfaceNumber;
1312
1313 if (reqtype != HID_REQ_SET_IDLE)
1314 return -EINVAL;
1315
1316 return hid_set_idle(dev, ifnum, report, idle);
1317}
1318
1319static bool usbhid_may_wakeup(struct hid_device *hid)
1320{
1321 struct usb_device *dev = hid_to_usb_dev(hid);
1322
1323 return device_may_wakeup(dev: &dev->dev);
1324}
1325
1326static const struct hid_ll_driver usb_hid_driver = {
1327 .parse = usbhid_parse,
1328 .start = usbhid_start,
1329 .stop = usbhid_stop,
1330 .open = usbhid_open,
1331 .close = usbhid_close,
1332 .power = usbhid_power,
1333 .request = usbhid_request,
1334 .wait = usbhid_wait_io,
1335 .raw_request = usbhid_raw_request,
1336 .output_report = usbhid_output_report,
1337 .idle = usbhid_idle,
1338 .may_wakeup = usbhid_may_wakeup,
1339};
1340
1341bool hid_is_usb(const struct hid_device *hdev)
1342{
1343 return hdev->ll_driver == &usb_hid_driver;
1344}
1345EXPORT_SYMBOL_GPL(hid_is_usb);
1346
1347static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *id)
1348{
1349 struct usb_host_interface *interface = intf->cur_altsetting;
1350 struct usb_device *dev = interface_to_usbdev(intf);
1351 struct usbhid_device *usbhid;
1352 struct hid_device *hid;
1353 unsigned int n, has_in = 0;
1354 size_t len;
1355 int ret;
1356
1357 dbg_hid("HID probe called for ifnum %d\n",
1358 intf->altsetting->desc.bInterfaceNumber);
1359
1360 for (n = 0; n < interface->desc.bNumEndpoints; n++)
1361 if (usb_endpoint_is_int_in(epd: &interface->endpoint[n].desc))
1362 has_in++;
1363 if (!has_in) {
1364 hid_err(intf, "couldn't find an input interrupt endpoint\n");
1365 return -ENODEV;
1366 }
1367
1368 hid = hid_allocate_device();
1369 if (IS_ERR(ptr: hid))
1370 return PTR_ERR(ptr: hid);
1371
1372 usb_set_intfdata(intf, data: hid);
1373 hid->ll_driver = &usb_hid_driver;
1374 hid->ff_init = hid_pidff_init;
1375#ifdef CONFIG_USB_HIDDEV
1376 hid->hiddev_connect = hiddev_connect;
1377 hid->hiddev_disconnect = hiddev_disconnect;
1378 hid->hiddev_hid_event = hiddev_hid_event;
1379 hid->hiddev_report_event = hiddev_report_event;
1380#endif
1381 hid->dev.parent = &intf->dev;
1382 device_set_node(dev: &hid->dev, dev_fwnode(&intf->dev));
1383 hid->bus = BUS_USB;
1384 hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
1385 hid->product = le16_to_cpu(dev->descriptor.idProduct);
1386 hid->version = le16_to_cpu(dev->descriptor.bcdDevice);
1387 hid->name[0] = 0;
1388 if (intf->cur_altsetting->desc.bInterfaceProtocol ==
1389 USB_INTERFACE_PROTOCOL_MOUSE)
1390 hid->type = HID_TYPE_USBMOUSE;
1391 else if (intf->cur_altsetting->desc.bInterfaceProtocol == 0)
1392 hid->type = HID_TYPE_USBNONE;
1393
1394 if (dev->manufacturer)
1395 strscpy(hid->name, dev->manufacturer, sizeof(hid->name));
1396
1397 if (dev->product) {
1398 if (dev->manufacturer)
1399 strlcat(hid->name, " ", sizeof(hid->name));
1400 strlcat(hid->name, dev->product, sizeof(hid->name));
1401 }
1402
1403 if (!strlen(hid->name))
1404 snprintf(buf: hid->name, size: sizeof(hid->name), fmt: "HID %04x:%04x",
1405 le16_to_cpu(dev->descriptor.idVendor),
1406 le16_to_cpu(dev->descriptor.idProduct));
1407
1408 usb_make_path(dev, buf: hid->phys, size: sizeof(hid->phys));
1409 strlcat(hid->phys, "/input", sizeof(hid->phys));
1410 len = strlen(hid->phys);
1411 if (len < sizeof(hid->phys) - 1)
1412 snprintf(buf: hid->phys + len, size: sizeof(hid->phys) - len,
1413 fmt: "%d", intf->altsetting[0].desc.bInterfaceNumber);
1414
1415 if (usb_string(dev, index: dev->descriptor.iSerialNumber, buf: hid->uniq, size: 64) <= 0)
1416 hid->uniq[0] = 0;
1417
1418 usbhid = kzalloc(sizeof(*usbhid), GFP_KERNEL);
1419 if (usbhid == NULL) {
1420 ret = -ENOMEM;
1421 goto err;
1422 }
1423
1424 hid->driver_data = usbhid;
1425 usbhid->hid = hid;
1426 usbhid->intf = intf;
1427 usbhid->ifnum = interface->desc.bInterfaceNumber;
1428
1429 init_waitqueue_head(&usbhid->wait);
1430 INIT_WORK(&usbhid->reset_work, hid_reset);
1431 timer_setup(&usbhid->io_retry, hid_retry_timeout, 0);
1432 spin_lock_init(&usbhid->lock);
1433 mutex_init(&usbhid->mutex);
1434
1435 ret = hid_add_device(hid);
1436 if (ret) {
1437 if (ret != -ENODEV)
1438 hid_err(intf, "can't add hid device: %d\n", ret);
1439 goto err_free;
1440 }
1441
1442 return 0;
1443err_free:
1444 kfree(objp: usbhid);
1445err:
1446 hid_destroy_device(hid);
1447 return ret;
1448}
1449
1450static void usbhid_disconnect(struct usb_interface *intf)
1451{
1452 struct hid_device *hid = usb_get_intfdata(intf);
1453 struct usbhid_device *usbhid;
1454
1455 if (WARN_ON(!hid))
1456 return;
1457
1458 usbhid = hid->driver_data;
1459 spin_lock_irq(lock: &usbhid->lock); /* Sync with error and led handlers */
1460 set_bit(HID_DISCONNECTED, addr: &usbhid->iofl);
1461 spin_unlock_irq(lock: &usbhid->lock);
1462 hid_destroy_device(hid);
1463 kfree(objp: usbhid);
1464}
1465
1466static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid)
1467{
1468 timer_delete_sync(timer: &usbhid->io_retry);
1469 cancel_work_sync(work: &usbhid->reset_work);
1470}
1471
1472static void hid_cease_io(struct usbhid_device *usbhid)
1473{
1474 timer_delete_sync(timer: &usbhid->io_retry);
1475 usb_kill_urb(urb: usbhid->urbin);
1476 usb_kill_urb(urb: usbhid->urbctrl);
1477 usb_kill_urb(urb: usbhid->urbout);
1478}
1479
1480static void hid_restart_io(struct hid_device *hid)
1481{
1482 struct usbhid_device *usbhid = hid->driver_data;
1483 int clear_halt = test_bit(HID_CLEAR_HALT, &usbhid->iofl);
1484 int reset_pending = test_bit(HID_RESET_PENDING, &usbhid->iofl);
1485
1486 spin_lock_irq(lock: &usbhid->lock);
1487 clear_bit(HID_SUSPENDED, addr: &usbhid->iofl);
1488 usbhid_mark_busy(usbhid);
1489
1490 if (clear_halt || reset_pending)
1491 schedule_work(work: &usbhid->reset_work);
1492 usbhid->retry_delay = 0;
1493 spin_unlock_irq(lock: &usbhid->lock);
1494
1495 if (reset_pending || !test_bit(HID_STARTED, &usbhid->iofl))
1496 return;
1497
1498 if (!clear_halt) {
1499 if (hid_start_in(hid) < 0)
1500 hid_io_error(hid);
1501 }
1502
1503 spin_lock_irq(lock: &usbhid->lock);
1504 if (usbhid->urbout && !test_bit(HID_OUT_RUNNING, &usbhid->iofl))
1505 usbhid_restart_out_queue(usbhid);
1506 if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl))
1507 usbhid_restart_ctrl_queue(usbhid);
1508 spin_unlock_irq(lock: &usbhid->lock);
1509}
1510
1511/* Treat USB reset pretty much the same as suspend/resume */
1512static int hid_pre_reset(struct usb_interface *intf)
1513{
1514 struct hid_device *hid = usb_get_intfdata(intf);
1515 struct usbhid_device *usbhid = hid->driver_data;
1516
1517 spin_lock_irq(lock: &usbhid->lock);
1518 set_bit(HID_RESET_PENDING, addr: &usbhid->iofl);
1519 spin_unlock_irq(lock: &usbhid->lock);
1520 hid_cease_io(usbhid);
1521
1522 return 0;
1523}
1524
1525/* Same routine used for post_reset and reset_resume */
1526static int hid_post_reset(struct usb_interface *intf)
1527{
1528 struct usb_device *dev = interface_to_usbdev (intf);
1529 struct hid_device *hid = usb_get_intfdata(intf);
1530 struct usbhid_device *usbhid = hid->driver_data;
1531 struct usb_host_interface *interface = intf->cur_altsetting;
1532 int status;
1533 char *rdesc;
1534
1535 /* Fetch and examine the HID report descriptor. If this
1536 * has changed, then rebind. Since usbcore's check of the
1537 * configuration descriptors passed, we already know that
1538 * the size of the HID report descriptor has not changed.
1539 */
1540 rdesc = kmalloc(hid->dev_rsize, GFP_KERNEL);
1541 if (!rdesc)
1542 return -ENOMEM;
1543
1544 status = hid_get_class_descriptor(dev,
1545 ifnum: interface->desc.bInterfaceNumber,
1546 HID_DT_REPORT, buf: rdesc, size: hid->dev_rsize);
1547 if (status < 0) {
1548 dbg_hid("reading report descriptor failed (post_reset)\n");
1549 kfree(objp: rdesc);
1550 return status;
1551 }
1552 status = memcmp(rdesc, hid->dev_rdesc, hid->dev_rsize);
1553 kfree(objp: rdesc);
1554 if (status != 0) {
1555 dbg_hid("report descriptor changed\n");
1556 return -EPERM;
1557 }
1558
1559 /* No need to do another reset or clear a halted endpoint */
1560 spin_lock_irq(lock: &usbhid->lock);
1561 clear_bit(HID_RESET_PENDING, addr: &usbhid->iofl);
1562 clear_bit(HID_CLEAR_HALT, addr: &usbhid->iofl);
1563 spin_unlock_irq(lock: &usbhid->lock);
1564 hid_set_idle(dev, ifnum: intf->cur_altsetting->desc.bInterfaceNumber, report: 0, idle: 0);
1565
1566 hid_restart_io(hid);
1567
1568 return 0;
1569}
1570
1571static int hid_resume_common(struct hid_device *hid, bool driver_suspended)
1572{
1573 int status = 0;
1574
1575 hid_restart_io(hid);
1576 if (driver_suspended)
1577 status = hid_driver_resume(hdev: hid);
1578 return status;
1579}
1580
1581static int hid_suspend(struct usb_interface *intf, pm_message_t message)
1582{
1583 struct hid_device *hid = usb_get_intfdata(intf);
1584 struct usbhid_device *usbhid = hid->driver_data;
1585 int status = 0;
1586 bool driver_suspended = false;
1587 unsigned int ledcount;
1588
1589 if (PMSG_IS_AUTO(message)) {
1590 ledcount = hidinput_count_leds(hid);
1591 spin_lock_irq(lock: &usbhid->lock); /* Sync with error handler */
1592 if (!test_bit(HID_RESET_PENDING, &usbhid->iofl)
1593 && !test_bit(HID_CLEAR_HALT, &usbhid->iofl)
1594 && !test_bit(HID_OUT_RUNNING, &usbhid->iofl)
1595 && !test_bit(HID_CTRL_RUNNING, &usbhid->iofl)
1596 && !test_bit(HID_KEYS_PRESSED, &usbhid->iofl)
1597 && (!ledcount || ignoreled))
1598 {
1599 set_bit(HID_SUSPENDED, addr: &usbhid->iofl);
1600 spin_unlock_irq(lock: &usbhid->lock);
1601 status = hid_driver_suspend(hdev: hid, state: message);
1602 if (status < 0)
1603 goto failed;
1604 driver_suspended = true;
1605 } else {
1606 usbhid_mark_busy(usbhid);
1607 spin_unlock_irq(lock: &usbhid->lock);
1608 return -EBUSY;
1609 }
1610
1611 } else {
1612 /* TODO: resume() might need to handle suspend failure */
1613 status = hid_driver_suspend(hdev: hid, state: message);
1614 driver_suspended = true;
1615 spin_lock_irq(lock: &usbhid->lock);
1616 set_bit(HID_SUSPENDED, addr: &usbhid->iofl);
1617 spin_unlock_irq(lock: &usbhid->lock);
1618 if (usbhid_wait_io(hid) < 0)
1619 status = -EIO;
1620 }
1621
1622 hid_cancel_delayed_stuff(usbhid);
1623 hid_cease_io(usbhid);
1624
1625 if (PMSG_IS_AUTO(message) && test_bit(HID_KEYS_PRESSED, &usbhid->iofl)) {
1626 /* lost race against keypresses */
1627 status = -EBUSY;
1628 goto failed;
1629 }
1630 dev_dbg(&intf->dev, "suspend\n");
1631 return status;
1632
1633 failed:
1634 hid_resume_common(hid, driver_suspended);
1635 return status;
1636}
1637
1638static int hid_resume(struct usb_interface *intf)
1639{
1640 struct hid_device *hid = usb_get_intfdata (intf);
1641 int status;
1642
1643 status = hid_resume_common(hid, driver_suspended: true);
1644 dev_dbg(&intf->dev, "resume status %d\n", status);
1645 return 0;
1646}
1647
1648static int hid_reset_resume(struct usb_interface *intf)
1649{
1650 struct hid_device *hid = usb_get_intfdata(intf);
1651 int status;
1652
1653 status = hid_post_reset(intf);
1654 if (status >= 0) {
1655 int ret = hid_driver_reset_resume(hdev: hid);
1656 if (ret < 0)
1657 status = ret;
1658 }
1659 return status;
1660}
1661
1662static const struct usb_device_id hid_usb_ids[] = {
1663 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
1664 .bInterfaceClass = USB_INTERFACE_CLASS_HID },
1665 { } /* Terminating entry */
1666};
1667
1668MODULE_DEVICE_TABLE (usb, hid_usb_ids);
1669
1670static struct usb_driver hid_driver = {
1671 .name = "usbhid",
1672 .probe = usbhid_probe,
1673 .disconnect = usbhid_disconnect,
1674 .suspend = pm_ptr(hid_suspend),
1675 .resume = pm_ptr(hid_resume),
1676 .reset_resume = pm_ptr(hid_reset_resume),
1677 .pre_reset = hid_pre_reset,
1678 .post_reset = hid_post_reset,
1679 .id_table = hid_usb_ids,
1680 .supports_autosuspend = 1,
1681};
1682
1683struct usb_interface *usbhid_find_interface(int minor)
1684{
1685 return usb_find_interface(drv: &hid_driver, minor);
1686}
1687
1688static int __init hid_init(void)
1689{
1690 int retval;
1691
1692 retval = hid_quirks_init(quirks_param, BUS_USB, MAX_USBHID_BOOT_QUIRKS);
1693 if (retval)
1694 goto usbhid_quirks_init_fail;
1695 retval = usb_register(&hid_driver);
1696 if (retval)
1697 goto usb_register_fail;
1698 pr_info(KBUILD_MODNAME ": " DRIVER_DESC "\n");
1699
1700 return 0;
1701usb_register_fail:
1702 hid_quirks_exit(BUS_USB);
1703usbhid_quirks_init_fail:
1704 return retval;
1705}
1706
1707static void __exit hid_exit(void)
1708{
1709 usb_deregister(&hid_driver);
1710 hid_quirks_exit(BUS_USB);
1711}
1712
1713module_init(hid_init);
1714module_exit(hid_exit);
1715
1716MODULE_AUTHOR("Andreas Gal");
1717MODULE_AUTHOR("Vojtech Pavlik");
1718MODULE_AUTHOR("Jiri Kosina");
1719MODULE_DESCRIPTION(DRIVER_DESC);
1720MODULE_LICENSE("GPL");
1721