1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/kernel.h>
14#include <linux/errno.h>
15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/completion.h>
18#include <linux/sched/mm.h>
19#include <linux/list.h>
20#include <linux/slab.h>
21#include <linux/ioctl.h>
22#include <linux/usb.h>
23#include <linux/usbdevice_fs.h>
24#include <linux/usb/hcd.h>
25#include <linux/usb/otg.h>
26#include <linux/usb/quirks.h>
27#include <linux/workqueue.h>
28#include <linux/mutex.h>
29#include <linux/random.h>
30#include <linux/pm_qos.h>
31#include <linux/kobject.h>
32
33#include <linux/uaccess.h>
34#include <asm/byteorder.h>
35
36#include "hub.h"
37#include "otg_whitelist.h"
38
39#define USB_VENDOR_GENESYS_LOGIC 0x05e3
40#define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND 0x01
41
42#define USB_TP_TRANSMISSION_DELAY 40
43#define USB_TP_TRANSMISSION_DELAY_MAX 65535
44
45
46
47
48static DEFINE_SPINLOCK(device_state_lock);
49
50
51static struct workqueue_struct *hub_wq;
52static void hub_event(struct work_struct *work);
53
54
55DEFINE_MUTEX(usb_port_peer_mutex);
56
57
58static bool blinkenlights;
59module_param(blinkenlights, bool, S_IRUGO);
60MODULE_PARM_DESC(blinkenlights, "true to cycle leds on hubs");
61
62
63
64
65
66
67static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
68module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
69MODULE_PARM_DESC(initial_descriptor_timeout,
70 "initial 64-byte descriptor request timeout in milliseconds "
71 "(default 5000 - 5.0 seconds)");
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87static bool old_scheme_first;
88module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
89MODULE_PARM_DESC(old_scheme_first,
90 "start with the old device initialization scheme");
91
92static bool use_both_schemes = 1;
93module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
94MODULE_PARM_DESC(use_both_schemes,
95 "try the other device initialization scheme if the "
96 "first one fails");
97
98
99
100
101DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
102EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
103
104#define HUB_DEBOUNCE_TIMEOUT 2000
105#define HUB_DEBOUNCE_STEP 25
106#define HUB_DEBOUNCE_STABLE 100
107
108static void hub_release(struct kref *kref);
109static int usb_reset_and_verify_device(struct usb_device *udev);
110static int hub_port_disable(struct usb_hub *hub, int port1, int set_state);
111static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
112 u16 portstatus);
113
114static inline char *portspeed(struct usb_hub *hub, int portstatus)
115{
116 if (hub_is_superspeedplus(hub->hdev))
117 return "10.0 Gb/s";
118 if (hub_is_superspeed(hub->hdev))
119 return "5.0 Gb/s";
120 if (portstatus & USB_PORT_STAT_HIGH_SPEED)
121 return "480 Mb/s";
122 else if (portstatus & USB_PORT_STAT_LOW_SPEED)
123 return "1.5 Mb/s";
124 else
125 return "12 Mb/s";
126}
127
128
129struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
130{
131 if (!hdev || !hdev->actconfig || !hdev->maxchild)
132 return NULL;
133 return usb_get_intfdata(hdev->actconfig->interface[0]);
134}
135
136int usb_device_supports_lpm(struct usb_device *udev)
137{
138
139 if (udev->quirks & USB_QUIRK_NO_LPM)
140 return 0;
141
142
143
144
145 if (udev->speed == USB_SPEED_HIGH || udev->speed == USB_SPEED_FULL) {
146 if (udev->bos->ext_cap &&
147 (USB_LPM_SUPPORT &
148 le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
149 return 1;
150 return 0;
151 }
152
153
154
155
156
157
158 if (!udev->bos->ss_cap) {
159 dev_info(&udev->dev, "No LPM exit latency info found, disabling LPM.\n");
160 return 0;
161 }
162
163 if (udev->bos->ss_cap->bU1devExitLat == 0 &&
164 udev->bos->ss_cap->bU2DevExitLat == 0) {
165 if (udev->parent)
166 dev_info(&udev->dev, "LPM exit latency is zeroed, disabling LPM.\n");
167 else
168 dev_info(&udev->dev, "We don't know the algorithms for LPM for this host, disabling LPM.\n");
169 return 0;
170 }
171
172 if (!udev->parent || udev->parent->lpm_capable)
173 return 1;
174 return 0;
175}
176
177
178
179
180
181static void usb_set_lpm_mel(struct usb_device *udev,
182 struct usb3_lpm_parameters *udev_lpm_params,
183 unsigned int udev_exit_latency,
184 struct usb_hub *hub,
185 struct usb3_lpm_parameters *hub_lpm_params,
186 unsigned int hub_exit_latency)
187{
188 unsigned int total_mel;
189 unsigned int device_mel;
190 unsigned int hub_mel;
191
192
193
194
195
196
197
198
199
200
201 total_mel = hub_lpm_params->mel +
202 (hub->descriptor->u.ss.bHubHdrDecLat * 100);
203
204
205
206
207
208
209
210
211
212 device_mel = udev_exit_latency * 1000;
213 hub_mel = hub_exit_latency * 1000;
214 if (device_mel > hub_mel)
215 total_mel += device_mel;
216 else
217 total_mel += hub_mel;
218
219 udev_lpm_params->mel = total_mel;
220}
221
222
223
224
225
226static void usb_set_lpm_pel(struct usb_device *udev,
227 struct usb3_lpm_parameters *udev_lpm_params,
228 unsigned int udev_exit_latency,
229 struct usb_hub *hub,
230 struct usb3_lpm_parameters *hub_lpm_params,
231 unsigned int hub_exit_latency,
232 unsigned int port_to_port_exit_latency)
233{
234 unsigned int first_link_pel;
235 unsigned int hub_pel;
236
237
238
239
240
241
242 if (udev_exit_latency > hub_exit_latency)
243 first_link_pel = udev_exit_latency * 1000;
244 else
245 first_link_pel = hub_exit_latency * 1000;
246
247
248
249
250
251
252
253 hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel;
254
255
256
257
258
259 if (first_link_pel > hub_pel)
260 udev_lpm_params->pel = first_link_pel;
261 else
262 udev_lpm_params->pel = hub_pel;
263}
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280static void usb_set_lpm_sel(struct usb_device *udev,
281 struct usb3_lpm_parameters *udev_lpm_params)
282{
283 struct usb_device *parent;
284 unsigned int num_hubs;
285 unsigned int total_sel;
286
287
288 total_sel = udev_lpm_params->pel;
289
290 for (parent = udev->parent, num_hubs = 0; parent->parent;
291 parent = parent->parent)
292 num_hubs++;
293
294 if (num_hubs > 0)
295 total_sel += 2100 + 250 * (num_hubs - 1);
296
297
298 total_sel += 250 * num_hubs;
299
300 udev_lpm_params->sel = total_sel;
301}
302
303static void usb_set_lpm_parameters(struct usb_device *udev)
304{
305 struct usb_hub *hub;
306 unsigned int port_to_port_delay;
307 unsigned int udev_u1_del;
308 unsigned int udev_u2_del;
309 unsigned int hub_u1_del;
310 unsigned int hub_u2_del;
311
312 if (!udev->lpm_capable || udev->speed < USB_SPEED_SUPER)
313 return;
314
315 hub = usb_hub_to_struct_hub(udev->parent);
316
317
318
319 if (!hub)
320 return;
321
322 udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
323 udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
324 hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
325 hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
326
327 usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
328 hub, &udev->parent->u1_params, hub_u1_del);
329
330 usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del,
331 hub, &udev->parent->u2_params, hub_u2_del);
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350 port_to_port_delay = 1;
351
352 usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del,
353 hub, &udev->parent->u1_params, hub_u1_del,
354 port_to_port_delay);
355
356 if (hub_u2_del > hub_u1_del)
357 port_to_port_delay = 1 + hub_u2_del - hub_u1_del;
358 else
359 port_to_port_delay = 1 + hub_u1_del;
360
361 usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del,
362 hub, &udev->parent->u2_params, hub_u2_del,
363 port_to_port_delay);
364
365
366 usb_set_lpm_sel(udev, &udev->u1_params);
367 usb_set_lpm_sel(udev, &udev->u2_params);
368}
369
370
371static int get_hub_descriptor(struct usb_device *hdev,
372 struct usb_hub_descriptor *desc)
373{
374 int i, ret, size;
375 unsigned dtype;
376
377 if (hub_is_superspeed(hdev)) {
378 dtype = USB_DT_SS_HUB;
379 size = USB_DT_SS_HUB_SIZE;
380 } else {
381 dtype = USB_DT_HUB;
382 size = sizeof(struct usb_hub_descriptor);
383 }
384
385 for (i = 0; i < 3; i++) {
386 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
387 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
388 dtype << 8, 0, desc, size,
389 USB_CTRL_GET_TIMEOUT);
390 if (hub_is_superspeed(hdev)) {
391 if (ret == size)
392 return ret;
393 } else if (ret >= USB_DT_HUB_NONVAR_SIZE + 2) {
394
395 size = USB_DT_HUB_NONVAR_SIZE + desc->bNbrPorts / 8 + 1;
396 if (ret < size)
397 return -EMSGSIZE;
398 return ret;
399 }
400 }
401 return -EINVAL;
402}
403
404
405
406
407static int clear_hub_feature(struct usb_device *hdev, int feature)
408{
409 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
410 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
411}
412
413
414
415
416int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
417{
418 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
419 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
420 NULL, 0, 1000);
421}
422
423
424
425
426static int set_port_feature(struct usb_device *hdev, int port1, int feature)
427{
428 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
429 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
430 NULL, 0, 1000);
431}
432
433static char *to_led_name(int selector)
434{
435 switch (selector) {
436 case HUB_LED_AMBER:
437 return "amber";
438 case HUB_LED_GREEN:
439 return "green";
440 case HUB_LED_OFF:
441 return "off";
442 case HUB_LED_AUTO:
443 return "auto";
444 default:
445 return "??";
446 }
447}
448
449
450
451
452
453static void set_port_led(struct usb_hub *hub, int port1, int selector)
454{
455 struct usb_port *port_dev = hub->ports[port1 - 1];
456 int status;
457
458 status = set_port_feature(hub->hdev, (selector << 8) | port1,
459 USB_PORT_FEAT_INDICATOR);
460 dev_dbg(&port_dev->dev, "indicator %s status %d\n",
461 to_led_name(selector), status);
462}
463
464#define LED_CYCLE_PERIOD ((2*HZ)/3)
465
466static void led_work(struct work_struct *work)
467{
468 struct usb_hub *hub =
469 container_of(work, struct usb_hub, leds.work);
470 struct usb_device *hdev = hub->hdev;
471 unsigned i;
472 unsigned changed = 0;
473 int cursor = -1;
474
475 if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
476 return;
477
478 for (i = 0; i < hdev->maxchild; i++) {
479 unsigned selector, mode;
480
481
482
483 switch (hub->indicator[i]) {
484
485 case INDICATOR_CYCLE:
486 cursor = i;
487 selector = HUB_LED_AUTO;
488 mode = INDICATOR_AUTO;
489 break;
490
491 case INDICATOR_GREEN_BLINK:
492 selector = HUB_LED_GREEN;
493 mode = INDICATOR_GREEN_BLINK_OFF;
494 break;
495 case INDICATOR_GREEN_BLINK_OFF:
496 selector = HUB_LED_OFF;
497 mode = INDICATOR_GREEN_BLINK;
498 break;
499
500 case INDICATOR_AMBER_BLINK:
501 selector = HUB_LED_AMBER;
502 mode = INDICATOR_AMBER_BLINK_OFF;
503 break;
504 case INDICATOR_AMBER_BLINK_OFF:
505 selector = HUB_LED_OFF;
506 mode = INDICATOR_AMBER_BLINK;
507 break;
508
509 case INDICATOR_ALT_BLINK:
510 selector = HUB_LED_GREEN;
511 mode = INDICATOR_ALT_BLINK_OFF;
512 break;
513 case INDICATOR_ALT_BLINK_OFF:
514 selector = HUB_LED_AMBER;
515 mode = INDICATOR_ALT_BLINK;
516 break;
517 default:
518 continue;
519 }
520 if (selector != HUB_LED_AUTO)
521 changed = 1;
522 set_port_led(hub, i + 1, selector);
523 hub->indicator[i] = mode;
524 }
525 if (!changed && blinkenlights) {
526 cursor++;
527 cursor %= hdev->maxchild;
528 set_port_led(hub, cursor + 1, HUB_LED_GREEN);
529 hub->indicator[cursor] = INDICATOR_CYCLE;
530 changed++;
531 }
532 if (changed)
533 queue_delayed_work(system_power_efficient_wq,
534 &hub->leds, LED_CYCLE_PERIOD);
535}
536
537
538#define USB_STS_TIMEOUT 1000
539#define USB_STS_RETRIES 5
540
541
542
543
544static int get_hub_status(struct usb_device *hdev,
545 struct usb_hub_status *data)
546{
547 int i, status = -ETIMEDOUT;
548
549 for (i = 0; i < USB_STS_RETRIES &&
550 (status == -ETIMEDOUT || status == -EPIPE); i++) {
551 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
552 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
553 data, sizeof(*data), USB_STS_TIMEOUT);
554 }
555 return status;
556}
557
558
559
560
561
562static int get_port_status(struct usb_device *hdev, int port1,
563 void *data, u16 value, u16 length)
564{
565 int i, status = -ETIMEDOUT;
566
567 for (i = 0; i < USB_STS_RETRIES &&
568 (status == -ETIMEDOUT || status == -EPIPE); i++) {
569 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
570 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, value,
571 port1, data, length, USB_STS_TIMEOUT);
572 }
573 return status;
574}
575
576static int hub_ext_port_status(struct usb_hub *hub, int port1, int type,
577 u16 *status, u16 *change, u32 *ext_status)
578{
579 int ret;
580 int len = 4;
581
582 if (type != HUB_PORT_STATUS)
583 len = 8;
584
585 mutex_lock(&hub->status_mutex);
586 ret = get_port_status(hub->hdev, port1, &hub->status->port, type, len);
587 if (ret < len) {
588 if (ret != -ENODEV)
589 dev_err(hub->intfdev,
590 "%s failed (err = %d)\n", __func__, ret);
591 if (ret >= 0)
592 ret = -EIO;
593 } else {
594 *status = le16_to_cpu(hub->status->port.wPortStatus);
595 *change = le16_to_cpu(hub->status->port.wPortChange);
596 if (type != HUB_PORT_STATUS && ext_status)
597 *ext_status = le32_to_cpu(
598 hub->status->port.dwExtPortStatus);
599 ret = 0;
600 }
601 mutex_unlock(&hub->status_mutex);
602 return ret;
603}
604
605static int hub_port_status(struct usb_hub *hub, int port1,
606 u16 *status, u16 *change)
607{
608 return hub_ext_port_status(hub, port1, HUB_PORT_STATUS,
609 status, change, NULL);
610}
611
612static void hub_resubmit_irq_urb(struct usb_hub *hub)
613{
614 unsigned long flags;
615 int status;
616
617 spin_lock_irqsave(&hub->irq_urb_lock, flags);
618
619 if (hub->quiescing) {
620 spin_unlock_irqrestore(&hub->irq_urb_lock, flags);
621 return;
622 }
623
624 status = usb_submit_urb(hub->urb, GFP_ATOMIC);
625 if (status && status != -ENODEV && status != -EPERM &&
626 status != -ESHUTDOWN) {
627 dev_err(hub->intfdev, "resubmit --> %d\n", status);
628 mod_timer(&hub->irq_urb_retry, jiffies + HZ);
629 }
630
631 spin_unlock_irqrestore(&hub->irq_urb_lock, flags);
632}
633
634static void hub_retry_irq_urb(struct timer_list *t)
635{
636 struct usb_hub *hub = from_timer(hub, t, irq_urb_retry);
637
638 hub_resubmit_irq_urb(hub);
639}
640
641
642static void kick_hub_wq(struct usb_hub *hub)
643{
644 struct usb_interface *intf;
645
646 if (hub->disconnected || work_pending(&hub->events))
647 return;
648
649
650
651
652
653
654
655
656
657 intf = to_usb_interface(hub->intfdev);
658 usb_autopm_get_interface_no_resume(intf);
659 kref_get(&hub->kref);
660
661 if (queue_work(hub_wq, &hub->events))
662 return;
663
664
665 usb_autopm_put_interface_async(intf);
666 kref_put(&hub->kref, hub_release);
667}
668
669void usb_kick_hub_wq(struct usb_device *hdev)
670{
671 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
672
673 if (hub)
674 kick_hub_wq(hub);
675}
676
677
678
679
680
681
682
683
684
685void usb_wakeup_notification(struct usb_device *hdev,
686 unsigned int portnum)
687{
688 struct usb_hub *hub;
689 struct usb_port *port_dev;
690
691 if (!hdev)
692 return;
693
694 hub = usb_hub_to_struct_hub(hdev);
695 if (hub) {
696 port_dev = hub->ports[portnum - 1];
697 if (port_dev && port_dev->child)
698 pm_wakeup_event(&port_dev->child->dev, 0);
699
700 set_bit(portnum, hub->wakeup_bits);
701 kick_hub_wq(hub);
702 }
703}
704EXPORT_SYMBOL_GPL(usb_wakeup_notification);
705
706
707static void hub_irq(struct urb *urb)
708{
709 struct usb_hub *hub = urb->context;
710 int status = urb->status;
711 unsigned i;
712 unsigned long bits;
713
714 switch (status) {
715 case -ENOENT:
716 case -ECONNRESET:
717 case -ESHUTDOWN:
718 return;
719
720 default:
721
722 dev_dbg(hub->intfdev, "transfer --> %d\n", status);
723 if ((++hub->nerrors < 10) || hub->error)
724 goto resubmit;
725 hub->error = status;
726
727
728
729 case 0:
730 bits = 0;
731 for (i = 0; i < urb->actual_length; ++i)
732 bits |= ((unsigned long) ((*hub->buffer)[i]))
733 << (i*8);
734 hub->event_bits[0] = bits;
735 break;
736 }
737
738 hub->nerrors = 0;
739
740
741 kick_hub_wq(hub);
742
743resubmit:
744 hub_resubmit_irq_urb(hub);
745}
746
747
748static inline int
749hub_clear_tt_buffer(struct usb_device *hdev, u16 devinfo, u16 tt)
750{
751
752 if (((devinfo >> 11) & USB_ENDPOINT_XFERTYPE_MASK) ==
753 USB_ENDPOINT_XFER_CONTROL) {
754 int status = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
755 HUB_CLEAR_TT_BUFFER, USB_RT_PORT,
756 devinfo ^ 0x8000, tt, NULL, 0, 1000);
757 if (status)
758 return status;
759 }
760 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
761 HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
762 tt, NULL, 0, 1000);
763}
764
765
766
767
768
769
770
771static void hub_tt_work(struct work_struct *work)
772{
773 struct usb_hub *hub =
774 container_of(work, struct usb_hub, tt.clear_work);
775 unsigned long flags;
776
777 spin_lock_irqsave(&hub->tt.lock, flags);
778 while (!list_empty(&hub->tt.clear_list)) {
779 struct list_head *next;
780 struct usb_tt_clear *clear;
781 struct usb_device *hdev = hub->hdev;
782 const struct hc_driver *drv;
783 int status;
784
785 next = hub->tt.clear_list.next;
786 clear = list_entry(next, struct usb_tt_clear, clear_list);
787 list_del(&clear->clear_list);
788
789
790 spin_unlock_irqrestore(&hub->tt.lock, flags);
791 status = hub_clear_tt_buffer(hdev, clear->devinfo, clear->tt);
792 if (status && status != -ENODEV)
793 dev_err(&hdev->dev,
794 "clear tt %d (%04x) error %d\n",
795 clear->tt, clear->devinfo, status);
796
797
798 drv = clear->hcd->driver;
799 if (drv->clear_tt_buffer_complete)
800 (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
801
802 kfree(clear);
803 spin_lock_irqsave(&hub->tt.lock, flags);
804 }
805 spin_unlock_irqrestore(&hub->tt.lock, flags);
806}
807
808
809
810
811
812
813
814
815
816
817
818
819
820int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
821 int port1, bool set)
822{
823 int ret;
824
825 if (set)
826 ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
827 else
828 ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
829
830 if (ret)
831 return ret;
832
833 if (set)
834 set_bit(port1, hub->power_bits);
835 else
836 clear_bit(port1, hub->power_bits);
837 return 0;
838}
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854int usb_hub_clear_tt_buffer(struct urb *urb)
855{
856 struct usb_device *udev = urb->dev;
857 int pipe = urb->pipe;
858 struct usb_tt *tt = udev->tt;
859 unsigned long flags;
860 struct usb_tt_clear *clear;
861
862
863
864
865
866 clear = kmalloc(sizeof *clear, GFP_ATOMIC);
867 if (clear == NULL) {
868 dev_err(&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
869
870 return -ENOMEM;
871 }
872
873
874 clear->tt = tt->multi ? udev->ttport : 1;
875 clear->devinfo = usb_pipeendpoint (pipe);
876 clear->devinfo |= ((u16)udev->devaddr) << 4;
877 clear->devinfo |= usb_pipecontrol(pipe)
878 ? (USB_ENDPOINT_XFER_CONTROL << 11)
879 : (USB_ENDPOINT_XFER_BULK << 11);
880 if (usb_pipein(pipe))
881 clear->devinfo |= 1 << 15;
882
883
884 clear->hcd = bus_to_hcd(udev->bus);
885 clear->ep = urb->ep;
886
887
888 spin_lock_irqsave(&tt->lock, flags);
889 list_add_tail(&clear->clear_list, &tt->clear_list);
890 schedule_work(&tt->clear_work);
891 spin_unlock_irqrestore(&tt->lock, flags);
892 return 0;
893}
894EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
895
896static void hub_power_on(struct usb_hub *hub, bool do_delay)
897{
898 int port1;
899
900
901
902
903
904
905
906 if (hub_is_port_power_switchable(hub))
907 dev_dbg(hub->intfdev, "enabling power on all ports\n");
908 else
909 dev_dbg(hub->intfdev, "trying to enable port power on "
910 "non-switchable hub\n");
911 for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
912 if (test_bit(port1, hub->power_bits))
913 set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
914 else
915 usb_clear_port_feature(hub->hdev, port1,
916 USB_PORT_FEAT_POWER);
917 if (do_delay)
918 msleep(hub_power_on_good_delay(hub));
919}
920
921static int hub_hub_status(struct usb_hub *hub,
922 u16 *status, u16 *change)
923{
924 int ret;
925
926 mutex_lock(&hub->status_mutex);
927 ret = get_hub_status(hub->hdev, &hub->status->hub);
928 if (ret < 0) {
929 if (ret != -ENODEV)
930 dev_err(hub->intfdev,
931 "%s failed (err = %d)\n", __func__, ret);
932 } else {
933 *status = le16_to_cpu(hub->status->hub.wHubStatus);
934 *change = le16_to_cpu(hub->status->hub.wHubChange);
935 ret = 0;
936 }
937 mutex_unlock(&hub->status_mutex);
938 return ret;
939}
940
941static int hub_set_port_link_state(struct usb_hub *hub, int port1,
942 unsigned int link_status)
943{
944 return set_port_feature(hub->hdev,
945 port1 | (link_status << 3),
946 USB_PORT_FEAT_LINK_STATE);
947}
948
949
950
951
952
953
954static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
955{
956 dev_dbg(&hub->ports[port1 - 1]->dev, "logical disconnect\n");
957 hub_port_disable(hub, port1, 1);
958
959
960
961
962
963
964
965
966
967
968 set_bit(port1, hub->change_bits);
969 kick_hub_wq(hub);
970}
971
972
973
974
975
976
977
978
979
980
981
982
983
984int usb_remove_device(struct usb_device *udev)
985{
986 struct usb_hub *hub;
987 struct usb_interface *intf;
988
989 if (!udev->parent)
990 return -EINVAL;
991 hub = usb_hub_to_struct_hub(udev->parent);
992 intf = to_usb_interface(hub->intfdev);
993
994 usb_autopm_get_interface(intf);
995 set_bit(udev->portnum, hub->removed_bits);
996 hub_port_logical_disconnect(hub, udev->portnum);
997 usb_autopm_put_interface(intf);
998 return 0;
999}
1000
1001enum hub_activation_type {
1002 HUB_INIT, HUB_INIT2, HUB_INIT3,
1003 HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
1004};
1005
1006static void hub_init_func2(struct work_struct *ws);
1007static void hub_init_func3(struct work_struct *ws);
1008
1009static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
1010{
1011 struct usb_device *hdev = hub->hdev;
1012 struct usb_hcd *hcd;
1013 int ret;
1014 int port1;
1015 int status;
1016 bool need_debounce_delay = false;
1017 unsigned delay;
1018
1019
1020 if (type == HUB_INIT2 || type == HUB_INIT3) {
1021 device_lock(&hdev->dev);
1022
1023
1024 if (hub->disconnected)
1025 goto disconnected;
1026 if (type == HUB_INIT2)
1027 goto init2;
1028 goto init3;
1029 }
1030 kref_get(&hub->kref);
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042 if (type != HUB_RESUME) {
1043 if (hdev->parent && hub_is_superspeed(hdev)) {
1044 ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
1045 HUB_SET_DEPTH, USB_RT_HUB,
1046 hdev->level - 1, 0, NULL, 0,
1047 USB_CTRL_SET_TIMEOUT);
1048 if (ret < 0)
1049 dev_err(hub->intfdev,
1050 "set hub depth failed\n");
1051 }
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065 if (type == HUB_INIT) {
1066 delay = hub_power_on_good_delay(hub);
1067
1068 hub_power_on(hub, false);
1069 INIT_DELAYED_WORK(&hub->init_work, hub_init_func2);
1070 queue_delayed_work(system_power_efficient_wq,
1071 &hub->init_work,
1072 msecs_to_jiffies(delay));
1073
1074
1075 usb_autopm_get_interface_no_resume(
1076 to_usb_interface(hub->intfdev));
1077 return;
1078 } else if (type == HUB_RESET_RESUME) {
1079
1080
1081
1082
1083 hcd = bus_to_hcd(hdev->bus);
1084 if (hcd->driver->update_hub_device) {
1085 ret = hcd->driver->update_hub_device(hcd, hdev,
1086 &hub->tt, GFP_NOIO);
1087 if (ret < 0) {
1088 dev_err(hub->intfdev,
1089 "Host not accepting hub info update\n");
1090 dev_err(hub->intfdev,
1091 "LS/FS devices and hubs may not work under this hub\n");
1092 }
1093 }
1094 hub_power_on(hub, true);
1095 } else {
1096 hub_power_on(hub, true);
1097 }
1098 }
1099 init2:
1100
1101
1102
1103
1104
1105 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
1106 struct usb_port *port_dev = hub->ports[port1 - 1];
1107 struct usb_device *udev = port_dev->child;
1108 u16 portstatus, portchange;
1109
1110 portstatus = portchange = 0;
1111 status = hub_port_status(hub, port1, &portstatus, &portchange);
1112 if (status)
1113 goto abort;
1114
1115 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1116 dev_dbg(&port_dev->dev, "status %04x change %04x\n",
1117 portstatus, portchange);
1118
1119
1120
1121
1122
1123
1124
1125 if ((portstatus & USB_PORT_STAT_ENABLE) && (
1126 type != HUB_RESUME ||
1127 !(portstatus & USB_PORT_STAT_CONNECTION) ||
1128 !udev ||
1129 udev->state == USB_STATE_NOTATTACHED)) {
1130
1131
1132
1133
1134
1135
1136 portstatus &= ~USB_PORT_STAT_ENABLE;
1137 if (!hub_is_superspeed(hdev))
1138 usb_clear_port_feature(hdev, port1,
1139 USB_PORT_FEAT_ENABLE);
1140 }
1141
1142
1143 if (type == HUB_RESUME &&
1144 hub_port_warm_reset_required(hub, port1, portstatus))
1145 set_bit(port1, hub->event_bits);
1146
1147
1148
1149
1150
1151
1152 if (hub_is_superspeed(hdev) &&
1153 ((portstatus & USB_PORT_STAT_LINK_STATE) ==
1154 USB_SS_PORT_LS_POLLING))
1155 need_debounce_delay = true;
1156
1157
1158 if (portchange & USB_PORT_STAT_C_CONNECTION) {
1159 need_debounce_delay = true;
1160 usb_clear_port_feature(hub->hdev, port1,
1161 USB_PORT_FEAT_C_CONNECTION);
1162 }
1163 if (portchange & USB_PORT_STAT_C_ENABLE) {
1164 need_debounce_delay = true;
1165 usb_clear_port_feature(hub->hdev, port1,
1166 USB_PORT_FEAT_C_ENABLE);
1167 }
1168 if (portchange & USB_PORT_STAT_C_RESET) {
1169 need_debounce_delay = true;
1170 usb_clear_port_feature(hub->hdev, port1,
1171 USB_PORT_FEAT_C_RESET);
1172 }
1173 if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
1174 hub_is_superspeed(hub->hdev)) {
1175 need_debounce_delay = true;
1176 usb_clear_port_feature(hub->hdev, port1,
1177 USB_PORT_FEAT_C_BH_PORT_RESET);
1178 }
1179
1180
1181
1182 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
1183 (portchange & USB_PORT_STAT_C_CONNECTION))
1184 clear_bit(port1, hub->removed_bits);
1185
1186 if (!udev || udev->state == USB_STATE_NOTATTACHED) {
1187
1188
1189
1190
1191
1192
1193 if (udev || (portstatus & USB_PORT_STAT_CONNECTION) ||
1194 (portstatus & USB_PORT_STAT_OVERCURRENT) ||
1195 (portchange & USB_PORT_STAT_C_OVERCURRENT))
1196 set_bit(port1, hub->change_bits);
1197
1198 } else if (portstatus & USB_PORT_STAT_ENABLE) {
1199 bool port_resumed = (portstatus &
1200 USB_PORT_STAT_LINK_STATE) ==
1201 USB_SS_PORT_LS_U0;
1202
1203
1204
1205
1206
1207
1208
1209
1210 if (portchange || (hub_is_superspeed(hub->hdev) &&
1211 port_resumed))
1212 set_bit(port1, hub->change_bits);
1213
1214 } else if (udev->persist_enabled) {
1215#ifdef CONFIG_PM
1216 udev->reset_resume = 1;
1217#endif
1218
1219
1220
1221 if (test_bit(port1, hub->power_bits))
1222 set_bit(port1, hub->change_bits);
1223
1224 } else {
1225
1226 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1227 set_bit(port1, hub->change_bits);
1228 }
1229 }
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239 if (need_debounce_delay) {
1240 delay = HUB_DEBOUNCE_STABLE;
1241
1242
1243 if (type == HUB_INIT2) {
1244 INIT_DELAYED_WORK(&hub->init_work, hub_init_func3);
1245 queue_delayed_work(system_power_efficient_wq,
1246 &hub->init_work,
1247 msecs_to_jiffies(delay));
1248 device_unlock(&hdev->dev);
1249 return;
1250 } else {
1251 msleep(delay);
1252 }
1253 }
1254 init3:
1255 hub->quiescing = 0;
1256
1257 status = usb_submit_urb(hub->urb, GFP_NOIO);
1258 if (status < 0)
1259 dev_err(hub->intfdev, "activate --> %d\n", status);
1260 if (hub->has_indicators && blinkenlights)
1261 queue_delayed_work(system_power_efficient_wq,
1262 &hub->leds, LED_CYCLE_PERIOD);
1263
1264
1265 kick_hub_wq(hub);
1266 abort:
1267 if (type == HUB_INIT2 || type == HUB_INIT3) {
1268
1269 disconnected:
1270 usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
1271 device_unlock(&hdev->dev);
1272 }
1273
1274 kref_put(&hub->kref, hub_release);
1275}
1276
1277
1278static void hub_init_func2(struct work_struct *ws)
1279{
1280 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1281
1282 hub_activate(hub, HUB_INIT2);
1283}
1284
1285static void hub_init_func3(struct work_struct *ws)
1286{
1287 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1288
1289 hub_activate(hub, HUB_INIT3);
1290}
1291
1292enum hub_quiescing_type {
1293 HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
1294};
1295
1296static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
1297{
1298 struct usb_device *hdev = hub->hdev;
1299 unsigned long flags;
1300 int i;
1301
1302
1303 spin_lock_irqsave(&hub->irq_urb_lock, flags);
1304 hub->quiescing = 1;
1305 spin_unlock_irqrestore(&hub->irq_urb_lock, flags);
1306
1307 if (type != HUB_SUSPEND) {
1308
1309 for (i = 0; i < hdev->maxchild; ++i) {
1310 if (hub->ports[i]->child)
1311 usb_disconnect(&hub->ports[i]->child);
1312 }
1313 }
1314
1315
1316 del_timer_sync(&hub->irq_urb_retry);
1317 usb_kill_urb(hub->urb);
1318 if (hub->has_indicators)
1319 cancel_delayed_work_sync(&hub->leds);
1320 if (hub->tt.hub)
1321 flush_work(&hub->tt.clear_work);
1322}
1323
1324static void hub_pm_barrier_for_all_ports(struct usb_hub *hub)
1325{
1326 int i;
1327
1328 for (i = 0; i < hub->hdev->maxchild; ++i)
1329 pm_runtime_barrier(&hub->ports[i]->dev);
1330}
1331
1332
1333static int hub_pre_reset(struct usb_interface *intf)
1334{
1335 struct usb_hub *hub = usb_get_intfdata(intf);
1336
1337 hub_quiesce(hub, HUB_PRE_RESET);
1338 hub->in_reset = 1;
1339 hub_pm_barrier_for_all_ports(hub);
1340 return 0;
1341}
1342
1343
1344static int hub_post_reset(struct usb_interface *intf)
1345{
1346 struct usb_hub *hub = usb_get_intfdata(intf);
1347
1348 hub->in_reset = 0;
1349 hub_pm_barrier_for_all_ports(hub);
1350 hub_activate(hub, HUB_POST_RESET);
1351 return 0;
1352}
1353
1354static int hub_configure(struct usb_hub *hub,
1355 struct usb_endpoint_descriptor *endpoint)
1356{
1357 struct usb_hcd *hcd;
1358 struct usb_device *hdev = hub->hdev;
1359 struct device *hub_dev = hub->intfdev;
1360 u16 hubstatus, hubchange;
1361 u16 wHubCharacteristics;
1362 unsigned int pipe;
1363 int maxp, ret, i;
1364 char *message = "out of memory";
1365 unsigned unit_load;
1366 unsigned full_load;
1367 unsigned maxchild;
1368
1369 hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
1370 if (!hub->buffer) {
1371 ret = -ENOMEM;
1372 goto fail;
1373 }
1374
1375 hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
1376 if (!hub->status) {
1377 ret = -ENOMEM;
1378 goto fail;
1379 }
1380 mutex_init(&hub->status_mutex);
1381
1382 hub->descriptor = kzalloc(sizeof(*hub->descriptor), GFP_KERNEL);
1383 if (!hub->descriptor) {
1384 ret = -ENOMEM;
1385 goto fail;
1386 }
1387
1388
1389
1390
1391
1392 ret = get_hub_descriptor(hdev, hub->descriptor);
1393 if (ret < 0) {
1394 message = "can't read hub descriptor";
1395 goto fail;
1396 }
1397
1398 maxchild = USB_MAXCHILDREN;
1399 if (hub_is_superspeed(hdev))
1400 maxchild = min_t(unsigned, maxchild, USB_SS_MAXPORTS);
1401
1402 if (hub->descriptor->bNbrPorts > maxchild) {
1403 message = "hub has too many ports!";
1404 ret = -ENODEV;
1405 goto fail;
1406 } else if (hub->descriptor->bNbrPorts == 0) {
1407 message = "hub doesn't have any ports!";
1408 ret = -ENODEV;
1409 goto fail;
1410 }
1411
1412
1413
1414
1415
1416 if (hub_is_superspeed(hdev) || hub_is_superspeedplus(hdev)) {
1417 u32 delay = __le16_to_cpu(hub->descriptor->u.ss.wHubDelay);
1418
1419 if (hdev->parent)
1420 delay += hdev->parent->hub_delay;
1421
1422 delay += USB_TP_TRANSMISSION_DELAY;
1423 hdev->hub_delay = min_t(u32, delay, USB_TP_TRANSMISSION_DELAY_MAX);
1424 }
1425
1426 maxchild = hub->descriptor->bNbrPorts;
1427 dev_info(hub_dev, "%d port%s detected\n", maxchild,
1428 (maxchild == 1) ? "" : "s");
1429
1430 hub->ports = kcalloc(maxchild, sizeof(struct usb_port *), GFP_KERNEL);
1431 if (!hub->ports) {
1432 ret = -ENOMEM;
1433 goto fail;
1434 }
1435
1436 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
1437 if (hub_is_superspeed(hdev)) {
1438 unit_load = 150;
1439 full_load = 900;
1440 } else {
1441 unit_load = 100;
1442 full_load = 500;
1443 }
1444
1445
1446 if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
1447 !(hub_is_superspeed(hdev))) {
1448 char portstr[USB_MAXCHILDREN + 1];
1449
1450 for (i = 0; i < maxchild; i++)
1451 portstr[i] = hub->descriptor->u.hs.DeviceRemovable
1452 [((i + 1) / 8)] & (1 << ((i + 1) % 8))
1453 ? 'F' : 'R';
1454 portstr[maxchild] = 0;
1455 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
1456 } else
1457 dev_dbg(hub_dev, "standalone hub\n");
1458
1459 switch (wHubCharacteristics & HUB_CHAR_LPSM) {
1460 case HUB_CHAR_COMMON_LPSM:
1461 dev_dbg(hub_dev, "ganged power switching\n");
1462 break;
1463 case HUB_CHAR_INDV_PORT_LPSM:
1464 dev_dbg(hub_dev, "individual port power switching\n");
1465 break;
1466 case HUB_CHAR_NO_LPSM:
1467 case HUB_CHAR_LPSM:
1468 dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
1469 break;
1470 }
1471
1472 switch (wHubCharacteristics & HUB_CHAR_OCPM) {
1473 case HUB_CHAR_COMMON_OCPM:
1474 dev_dbg(hub_dev, "global over-current protection\n");
1475 break;
1476 case HUB_CHAR_INDV_PORT_OCPM:
1477 dev_dbg(hub_dev, "individual port over-current protection\n");
1478 break;
1479 case HUB_CHAR_NO_OCPM:
1480 case HUB_CHAR_OCPM:
1481 dev_dbg(hub_dev, "no over-current protection\n");
1482 break;
1483 }
1484
1485 spin_lock_init(&hub->tt.lock);
1486 INIT_LIST_HEAD(&hub->tt.clear_list);
1487 INIT_WORK(&hub->tt.clear_work, hub_tt_work);
1488 switch (hdev->descriptor.bDeviceProtocol) {
1489 case USB_HUB_PR_FS:
1490 break;
1491 case USB_HUB_PR_HS_SINGLE_TT:
1492 dev_dbg(hub_dev, "Single TT\n");
1493 hub->tt.hub = hdev;
1494 break;
1495 case USB_HUB_PR_HS_MULTI_TT:
1496 ret = usb_set_interface(hdev, 0, 1);
1497 if (ret == 0) {
1498 dev_dbg(hub_dev, "TT per port\n");
1499 hub->tt.multi = 1;
1500 } else
1501 dev_err(hub_dev, "Using single TT (err %d)\n",
1502 ret);
1503 hub->tt.hub = hdev;
1504 break;
1505 case USB_HUB_PR_SS:
1506
1507 break;
1508 default:
1509 dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
1510 hdev->descriptor.bDeviceProtocol);
1511 break;
1512 }
1513
1514
1515 switch (wHubCharacteristics & HUB_CHAR_TTTT) {
1516 case HUB_TTTT_8_BITS:
1517 if (hdev->descriptor.bDeviceProtocol != 0) {
1518 hub->tt.think_time = 666;
1519 dev_dbg(hub_dev, "TT requires at most %d "
1520 "FS bit times (%d ns)\n",
1521 8, hub->tt.think_time);
1522 }
1523 break;
1524 case HUB_TTTT_16_BITS:
1525 hub->tt.think_time = 666 * 2;
1526 dev_dbg(hub_dev, "TT requires at most %d "
1527 "FS bit times (%d ns)\n",
1528 16, hub->tt.think_time);
1529 break;
1530 case HUB_TTTT_24_BITS:
1531 hub->tt.think_time = 666 * 3;
1532 dev_dbg(hub_dev, "TT requires at most %d "
1533 "FS bit times (%d ns)\n",
1534 24, hub->tt.think_time);
1535 break;
1536 case HUB_TTTT_32_BITS:
1537 hub->tt.think_time = 666 * 4;
1538 dev_dbg(hub_dev, "TT requires at most %d "
1539 "FS bit times (%d ns)\n",
1540 32, hub->tt.think_time);
1541 break;
1542 }
1543
1544
1545 if (wHubCharacteristics & HUB_CHAR_PORTIND) {
1546 hub->has_indicators = 1;
1547 dev_dbg(hub_dev, "Port indicators are supported\n");
1548 }
1549
1550 dev_dbg(hub_dev, "power on to power good time: %dms\n",
1551 hub->descriptor->bPwrOn2PwrGood * 2);
1552
1553
1554
1555
1556 ret = usb_get_std_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
1557 if (ret) {
1558 message = "can't get hub status";
1559 goto fail;
1560 }
1561 hcd = bus_to_hcd(hdev->bus);
1562 if (hdev == hdev->bus->root_hub) {
1563 if (hcd->power_budget > 0)
1564 hdev->bus_mA = hcd->power_budget;
1565 else
1566 hdev->bus_mA = full_load * maxchild;
1567 if (hdev->bus_mA >= full_load)
1568 hub->mA_per_port = full_load;
1569 else {
1570 hub->mA_per_port = hdev->bus_mA;
1571 hub->limited_power = 1;
1572 }
1573 } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
1574 int remaining = hdev->bus_mA -
1575 hub->descriptor->bHubContrCurrent;
1576
1577 dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
1578 hub->descriptor->bHubContrCurrent);
1579 hub->limited_power = 1;
1580
1581 if (remaining < maxchild * unit_load)
1582 dev_warn(hub_dev,
1583 "insufficient power available "
1584 "to use all downstream ports\n");
1585 hub->mA_per_port = unit_load;
1586
1587 } else {
1588
1589
1590 hub->mA_per_port = full_load;
1591 }
1592 if (hub->mA_per_port < full_load)
1593 dev_dbg(hub_dev, "%umA bus power budget for each child\n",
1594 hub->mA_per_port);
1595
1596 ret = hub_hub_status(hub, &hubstatus, &hubchange);
1597 if (ret < 0) {
1598 message = "can't get hub status";
1599 goto fail;
1600 }
1601
1602
1603 if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1604 dev_dbg(hub_dev, "local power source is %s\n",
1605 (hubstatus & HUB_STATUS_LOCAL_POWER)
1606 ? "lost (inactive)" : "good");
1607
1608 if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
1609 dev_dbg(hub_dev, "%sover-current condition exists\n",
1610 (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
1611
1612
1613
1614
1615
1616
1617
1618 pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
1619 maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
1620
1621 if (maxp > sizeof(*hub->buffer))
1622 maxp = sizeof(*hub->buffer);
1623
1624 hub->urb = usb_alloc_urb(0, GFP_KERNEL);
1625 if (!hub->urb) {
1626 ret = -ENOMEM;
1627 goto fail;
1628 }
1629
1630 usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
1631 hub, endpoint->bInterval);
1632
1633
1634 if (hub->has_indicators && blinkenlights)
1635 hub->indicator[0] = INDICATOR_CYCLE;
1636
1637 mutex_lock(&usb_port_peer_mutex);
1638 for (i = 0; i < maxchild; i++) {
1639 ret = usb_hub_create_port_device(hub, i + 1);
1640 if (ret < 0) {
1641 dev_err(hub->intfdev,
1642 "couldn't create port%d device.\n", i + 1);
1643 break;
1644 }
1645 }
1646 hdev->maxchild = i;
1647 for (i = 0; i < hdev->maxchild; i++) {
1648 struct usb_port *port_dev = hub->ports[i];
1649
1650 pm_runtime_put(&port_dev->dev);
1651 }
1652
1653 mutex_unlock(&usb_port_peer_mutex);
1654 if (ret < 0)
1655 goto fail;
1656
1657
1658
1659
1660 if (hcd->driver->update_hub_device) {
1661 ret = hcd->driver->update_hub_device(hcd, hdev,
1662 &hub->tt, GFP_KERNEL);
1663 if (ret < 0) {
1664 message = "can't update HCD hub info";
1665 goto fail;
1666 }
1667 }
1668
1669 usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
1670
1671 hub_activate(hub, HUB_INIT);
1672 return 0;
1673
1674fail:
1675 dev_err(hub_dev, "config failed, %s (err %d)\n",
1676 message, ret);
1677
1678 return ret;
1679}
1680
1681static void hub_release(struct kref *kref)
1682{
1683 struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
1684
1685 usb_put_dev(hub->hdev);
1686 usb_put_intf(to_usb_interface(hub->intfdev));
1687 kfree(hub);
1688}
1689
1690static unsigned highspeed_hubs;
1691
1692static void hub_disconnect(struct usb_interface *intf)
1693{
1694 struct usb_hub *hub = usb_get_intfdata(intf);
1695 struct usb_device *hdev = interface_to_usbdev(intf);
1696 int port1;
1697
1698
1699
1700
1701
1702 hub->disconnected = 1;
1703
1704
1705 hub->error = 0;
1706 hub_quiesce(hub, HUB_DISCONNECT);
1707
1708 mutex_lock(&usb_port_peer_mutex);
1709
1710
1711 spin_lock_irq(&device_state_lock);
1712 port1 = hdev->maxchild;
1713 hdev->maxchild = 0;
1714 usb_set_intfdata(intf, NULL);
1715 spin_unlock_irq(&device_state_lock);
1716
1717 for (; port1 > 0; --port1)
1718 usb_hub_remove_port_device(hub, port1);
1719
1720 mutex_unlock(&usb_port_peer_mutex);
1721
1722 if (hub->hdev->speed == USB_SPEED_HIGH)
1723 highspeed_hubs--;
1724
1725 usb_free_urb(hub->urb);
1726 kfree(hub->ports);
1727 kfree(hub->descriptor);
1728 kfree(hub->status);
1729 kfree(hub->buffer);
1730
1731 pm_suspend_ignore_children(&intf->dev, false);
1732 kref_put(&hub->kref, hub_release);
1733}
1734
1735static bool hub_descriptor_is_sane(struct usb_host_interface *desc)
1736{
1737
1738
1739 if (desc->desc.bInterfaceSubClass != 0 &&
1740 desc->desc.bInterfaceSubClass != 1)
1741 return false;
1742
1743
1744 if (desc->desc.bNumEndpoints != 1)
1745 return false;
1746
1747
1748 if (!usb_endpoint_is_int_in(&desc->endpoint[0].desc))
1749 return false;
1750
1751 return true;
1752}
1753
1754static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
1755{
1756 struct usb_host_interface *desc;
1757 struct usb_device *hdev;
1758 struct usb_hub *hub;
1759
1760 desc = intf->cur_altsetting;
1761 hdev = interface_to_usbdev(intf);
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799#ifdef CONFIG_PM
1800 if (hdev->dev.power.autosuspend_delay >= 0)
1801 pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
1802#endif
1803
1804
1805
1806
1807
1808
1809 if (hdev->parent) {
1810 usb_enable_autosuspend(hdev);
1811 } else {
1812 const struct hc_driver *drv = bus_to_hcd(hdev->bus)->driver;
1813
1814 if (drv->bus_suspend && drv->bus_resume)
1815 usb_enable_autosuspend(hdev);
1816 }
1817
1818 if (hdev->level == MAX_TOPO_LEVEL) {
1819 dev_err(&intf->dev,
1820 "Unsupported bus topology: hub nested too deep\n");
1821 return -E2BIG;
1822 }
1823
1824#ifdef CONFIG_USB_OTG_BLACKLIST_HUB
1825 if (hdev->parent) {
1826 dev_warn(&intf->dev, "ignoring external hub\n");
1827 return -ENODEV;
1828 }
1829#endif
1830
1831 if (!hub_descriptor_is_sane(desc)) {
1832 dev_err(&intf->dev, "bad descriptor, ignoring hub\n");
1833 return -EIO;
1834 }
1835
1836
1837 dev_info(&intf->dev, "USB hub found\n");
1838
1839 hub = kzalloc(sizeof(*hub), GFP_KERNEL);
1840 if (!hub)
1841 return -ENOMEM;
1842
1843 kref_init(&hub->kref);
1844 hub->intfdev = &intf->dev;
1845 hub->hdev = hdev;
1846 INIT_DELAYED_WORK(&hub->leds, led_work);
1847 INIT_DELAYED_WORK(&hub->init_work, NULL);
1848 INIT_WORK(&hub->events, hub_event);
1849 spin_lock_init(&hub->irq_urb_lock);
1850 timer_setup(&hub->irq_urb_retry, hub_retry_irq_urb, 0);
1851 usb_get_intf(intf);
1852 usb_get_dev(hdev);
1853
1854 usb_set_intfdata(intf, hub);
1855 intf->needs_remote_wakeup = 1;
1856 pm_suspend_ignore_children(&intf->dev, true);
1857
1858 if (hdev->speed == USB_SPEED_HIGH)
1859 highspeed_hubs++;
1860
1861 if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
1862 hub->quirk_check_port_auto_suspend = 1;
1863
1864 if (hub_configure(hub, &desc->endpoint[0].desc) >= 0)
1865 return 0;
1866
1867 hub_disconnect(intf);
1868 return -ENODEV;
1869}
1870
1871static int
1872hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
1873{
1874 struct usb_device *hdev = interface_to_usbdev(intf);
1875 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1876
1877
1878 switch (code) {
1879 case USBDEVFS_HUB_PORTINFO: {
1880 struct usbdevfs_hub_portinfo *info = user_data;
1881 int i;
1882
1883 spin_lock_irq(&device_state_lock);
1884 if (hdev->devnum <= 0)
1885 info->nports = 0;
1886 else {
1887 info->nports = hdev->maxchild;
1888 for (i = 0; i < info->nports; i++) {
1889 if (hub->ports[i]->child == NULL)
1890 info->port[i] = 0;
1891 else
1892 info->port[i] =
1893 hub->ports[i]->child->devnum;
1894 }
1895 }
1896 spin_unlock_irq(&device_state_lock);
1897
1898 return info->nports + 1;
1899 }
1900
1901 default:
1902 return -ENOSYS;
1903 }
1904}
1905
1906
1907
1908
1909
1910static int find_port_owner(struct usb_device *hdev, unsigned port1,
1911 struct usb_dev_state ***ppowner)
1912{
1913 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1914
1915 if (hdev->state == USB_STATE_NOTATTACHED)
1916 return -ENODEV;
1917 if (port1 == 0 || port1 > hdev->maxchild)
1918 return -EINVAL;
1919
1920
1921
1922
1923 *ppowner = &(hub->ports[port1 - 1]->port_owner);
1924 return 0;
1925}
1926
1927
1928int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
1929 struct usb_dev_state *owner)
1930{
1931 int rc;
1932 struct usb_dev_state **powner;
1933
1934 rc = find_port_owner(hdev, port1, &powner);
1935 if (rc)
1936 return rc;
1937 if (*powner)
1938 return -EBUSY;
1939 *powner = owner;
1940 return rc;
1941}
1942EXPORT_SYMBOL_GPL(usb_hub_claim_port);
1943
1944int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
1945 struct usb_dev_state *owner)
1946{
1947 int rc;
1948 struct usb_dev_state **powner;
1949
1950 rc = find_port_owner(hdev, port1, &powner);
1951 if (rc)
1952 return rc;
1953 if (*powner != owner)
1954 return -ENOENT;
1955 *powner = NULL;
1956 return rc;
1957}
1958EXPORT_SYMBOL_GPL(usb_hub_release_port);
1959
1960void usb_hub_release_all_ports(struct usb_device *hdev, struct usb_dev_state *owner)
1961{
1962 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1963 int n;
1964
1965 for (n = 0; n < hdev->maxchild; n++) {
1966 if (hub->ports[n]->port_owner == owner)
1967 hub->ports[n]->port_owner = NULL;
1968 }
1969
1970}
1971
1972
1973bool usb_device_is_owned(struct usb_device *udev)
1974{
1975 struct usb_hub *hub;
1976
1977 if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
1978 return false;
1979 hub = usb_hub_to_struct_hub(udev->parent);
1980 return !!hub->ports[udev->portnum - 1]->port_owner;
1981}
1982
1983static void recursively_mark_NOTATTACHED(struct usb_device *udev)
1984{
1985 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
1986 int i;
1987
1988 for (i = 0; i < udev->maxchild; ++i) {
1989 if (hub->ports[i]->child)
1990 recursively_mark_NOTATTACHED(hub->ports[i]->child);
1991 }
1992 if (udev->state == USB_STATE_SUSPENDED)
1993 udev->active_duration -= jiffies;
1994 udev->state = USB_STATE_NOTATTACHED;
1995}
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018void usb_set_device_state(struct usb_device *udev,
2019 enum usb_device_state new_state)
2020{
2021 unsigned long flags;
2022 int wakeup = -1;
2023
2024 spin_lock_irqsave(&device_state_lock, flags);
2025 if (udev->state == USB_STATE_NOTATTACHED)
2026 ;
2027 else if (new_state != USB_STATE_NOTATTACHED) {
2028
2029
2030
2031
2032 if (udev->parent) {
2033 if (udev->state == USB_STATE_SUSPENDED
2034 || new_state == USB_STATE_SUSPENDED)
2035 ;
2036 else if (new_state == USB_STATE_CONFIGURED)
2037 wakeup = (udev->quirks &
2038 USB_QUIRK_IGNORE_REMOTE_WAKEUP) ? 0 :
2039 udev->actconfig->desc.bmAttributes &
2040 USB_CONFIG_ATT_WAKEUP;
2041 else
2042 wakeup = 0;
2043 }
2044 if (udev->state == USB_STATE_SUSPENDED &&
2045 new_state != USB_STATE_SUSPENDED)
2046 udev->active_duration -= jiffies;
2047 else if (new_state == USB_STATE_SUSPENDED &&
2048 udev->state != USB_STATE_SUSPENDED)
2049 udev->active_duration += jiffies;
2050 udev->state = new_state;
2051 } else
2052 recursively_mark_NOTATTACHED(udev);
2053 spin_unlock_irqrestore(&device_state_lock, flags);
2054 if (wakeup >= 0)
2055 device_set_wakeup_capable(&udev->dev, wakeup);
2056}
2057EXPORT_SYMBOL_GPL(usb_set_device_state);
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088static void choose_devnum(struct usb_device *udev)
2089{
2090 int devnum;
2091 struct usb_bus *bus = udev->bus;
2092
2093
2094 mutex_lock(&bus->devnum_next_mutex);
2095 if (udev->wusb) {
2096 devnum = udev->portnum + 1;
2097 BUG_ON(test_bit(devnum, bus->devmap.devicemap));
2098 } else {
2099
2100
2101 devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
2102 bus->devnum_next);
2103 if (devnum >= 128)
2104 devnum = find_next_zero_bit(bus->devmap.devicemap,
2105 128, 1);
2106 bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
2107 }
2108 if (devnum < 128) {
2109 set_bit(devnum, bus->devmap.devicemap);
2110 udev->devnum = devnum;
2111 }
2112 mutex_unlock(&bus->devnum_next_mutex);
2113}
2114
2115static void release_devnum(struct usb_device *udev)
2116{
2117 if (udev->devnum > 0) {
2118 clear_bit(udev->devnum, udev->bus->devmap.devicemap);
2119 udev->devnum = -1;
2120 }
2121}
2122
2123static void update_devnum(struct usb_device *udev, int devnum)
2124{
2125
2126 if (!udev->wusb)
2127 udev->devnum = devnum;
2128 if (!udev->devaddr)
2129 udev->devaddr = (u8)devnum;
2130}
2131
2132static void hub_free_dev(struct usb_device *udev)
2133{
2134 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2135
2136
2137 if (hcd->driver->free_dev && udev->parent)
2138 hcd->driver->free_dev(hcd, udev);
2139}
2140
2141static void hub_disconnect_children(struct usb_device *udev)
2142{
2143 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
2144 int i;
2145
2146
2147 for (i = 0; i < udev->maxchild; i++) {
2148 if (hub->ports[i]->child)
2149 usb_disconnect(&hub->ports[i]->child);
2150 }
2151}
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169void usb_disconnect(struct usb_device **pdev)
2170{
2171 struct usb_port *port_dev = NULL;
2172 struct usb_device *udev = *pdev;
2173 struct usb_hub *hub = NULL;
2174 int port1 = 1;
2175
2176
2177
2178
2179
2180 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2181 dev_info(&udev->dev, "USB disconnect, device number %d\n",
2182 udev->devnum);
2183
2184
2185
2186
2187
2188 pm_runtime_barrier(&udev->dev);
2189
2190 usb_lock_device(udev);
2191
2192 hub_disconnect_children(udev);
2193
2194
2195
2196
2197
2198 dev_dbg(&udev->dev, "unregistering device\n");
2199 usb_disable_device(udev, 0);
2200 usb_hcd_synchronize_unlinks(udev);
2201
2202 if (udev->parent) {
2203 port1 = udev->portnum;
2204 hub = usb_hub_to_struct_hub(udev->parent);
2205 port_dev = hub->ports[port1 - 1];
2206
2207 sysfs_remove_link(&udev->dev.kobj, "port");
2208 sysfs_remove_link(&port_dev->dev.kobj, "device");
2209
2210
2211
2212
2213
2214 if (!test_and_set_bit(port1, hub->child_usage_bits))
2215 pm_runtime_get_sync(&port_dev->dev);
2216 }
2217
2218 usb_remove_ep_devs(&udev->ep0);
2219 usb_unlock_device(udev);
2220
2221
2222
2223
2224
2225 device_del(&udev->dev);
2226
2227
2228
2229
2230 release_devnum(udev);
2231
2232
2233 spin_lock_irq(&device_state_lock);
2234 *pdev = NULL;
2235 spin_unlock_irq(&device_state_lock);
2236
2237 if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits))
2238 pm_runtime_put(&port_dev->dev);
2239
2240 hub_free_dev(udev);
2241
2242 put_device(&udev->dev);
2243}
2244
2245#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
2246static void show_string(struct usb_device *udev, char *id, char *string)
2247{
2248 if (!string)
2249 return;
2250 dev_info(&udev->dev, "%s: %s\n", id, string);
2251}
2252
2253static void announce_device(struct usb_device *udev)
2254{
2255 u16 bcdDevice = le16_to_cpu(udev->descriptor.bcdDevice);
2256
2257 dev_info(&udev->dev,
2258 "New USB device found, idVendor=%04x, idProduct=%04x, bcdDevice=%2x.%02x\n",
2259 le16_to_cpu(udev->descriptor.idVendor),
2260 le16_to_cpu(udev->descriptor.idProduct),
2261 bcdDevice >> 8, bcdDevice & 0xff);
2262 dev_info(&udev->dev,
2263 "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
2264 udev->descriptor.iManufacturer,
2265 udev->descriptor.iProduct,
2266 udev->descriptor.iSerialNumber);
2267 show_string(udev, "Product", udev->product);
2268 show_string(udev, "Manufacturer", udev->manufacturer);
2269 show_string(udev, "SerialNumber", udev->serial);
2270}
2271#else
2272static inline void announce_device(struct usb_device *udev) { }
2273#endif
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284static int usb_enumerate_device_otg(struct usb_device *udev)
2285{
2286 int err = 0;
2287
2288#ifdef CONFIG_USB_OTG
2289
2290
2291
2292
2293
2294 if (!udev->bus->is_b_host
2295 && udev->config
2296 && udev->parent == udev->bus->root_hub) {
2297 struct usb_otg_descriptor *desc = NULL;
2298 struct usb_bus *bus = udev->bus;
2299 unsigned port1 = udev->portnum;
2300
2301
2302 err = __usb_get_extra_descriptor(udev->rawdescriptors[0],
2303 le16_to_cpu(udev->config[0].desc.wTotalLength),
2304 USB_DT_OTG, (void **) &desc, sizeof(*desc));
2305 if (err || !(desc->bmAttributes & USB_OTG_HNP))
2306 return 0;
2307
2308 dev_info(&udev->dev, "Dual-Role OTG device on %sHNP port\n",
2309 (port1 == bus->otg_port) ? "" : "non-");
2310
2311
2312 if (port1 == bus->otg_port) {
2313 bus->b_hnp_enable = 1;
2314 err = usb_control_msg(udev,
2315 usb_sndctrlpipe(udev, 0),
2316 USB_REQ_SET_FEATURE, 0,
2317 USB_DEVICE_B_HNP_ENABLE,
2318 0, NULL, 0,
2319 USB_CTRL_SET_TIMEOUT);
2320 if (err < 0) {
2321
2322
2323
2324
2325 dev_err(&udev->dev, "can't set HNP mode: %d\n",
2326 err);
2327 bus->b_hnp_enable = 0;
2328 }
2329 } else if (desc->bLength == sizeof
2330 (struct usb_otg_descriptor)) {
2331
2332 err = usb_control_msg(udev,
2333 usb_sndctrlpipe(udev, 0),
2334 USB_REQ_SET_FEATURE, 0,
2335 USB_DEVICE_A_ALT_HNP_SUPPORT,
2336 0, NULL, 0,
2337 USB_CTRL_SET_TIMEOUT);
2338 if (err < 0)
2339 dev_err(&udev->dev,
2340 "set a_alt_hnp_support failed: %d\n",
2341 err);
2342 }
2343 }
2344#endif
2345 return err;
2346}
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363static int usb_enumerate_device(struct usb_device *udev)
2364{
2365 int err;
2366 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2367
2368 if (udev->config == NULL) {
2369 err = usb_get_configuration(udev);
2370 if (err < 0) {
2371 if (err != -ENODEV)
2372 dev_err(&udev->dev, "can't read configurations, error %d\n",
2373 err);
2374 return err;
2375 }
2376 }
2377
2378
2379 udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
2380 udev->manufacturer = usb_cache_string(udev,
2381 udev->descriptor.iManufacturer);
2382 udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
2383
2384 err = usb_enumerate_device_otg(udev);
2385 if (err < 0)
2386 return err;
2387
2388 if (IS_ENABLED(CONFIG_USB_OTG_WHITELIST) && hcd->tpl_support &&
2389 !is_targeted(udev)) {
2390
2391
2392
2393 if (IS_ENABLED(CONFIG_USB_OTG) && (udev->bus->b_hnp_enable
2394 || udev->bus->is_b_host)) {
2395 err = usb_port_suspend(udev, PMSG_AUTO_SUSPEND);
2396 if (err < 0)
2397 dev_dbg(&udev->dev, "HNP fail, %d\n", err);
2398 }
2399 return -ENOTSUPP;
2400 }
2401
2402 usb_detect_interface_quirks(udev);
2403
2404 return 0;
2405}
2406
2407static void set_usb_port_removable(struct usb_device *udev)
2408{
2409 struct usb_device *hdev = udev->parent;
2410 struct usb_hub *hub;
2411 u8 port = udev->portnum;
2412 u16 wHubCharacteristics;
2413 bool removable = true;
2414
2415 if (!hdev)
2416 return;
2417
2418 hub = usb_hub_to_struct_hub(udev->parent);
2419
2420
2421
2422
2423
2424 switch (hub->ports[udev->portnum - 1]->connect_type) {
2425 case USB_PORT_CONNECT_TYPE_HOT_PLUG:
2426 udev->removable = USB_DEVICE_REMOVABLE;
2427 return;
2428 case USB_PORT_CONNECT_TYPE_HARD_WIRED:
2429 case USB_PORT_NOT_USED:
2430 udev->removable = USB_DEVICE_FIXED;
2431 return;
2432 default:
2433 break;
2434 }
2435
2436
2437
2438
2439
2440 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
2441
2442 if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
2443 return;
2444
2445 if (hub_is_superspeed(hdev)) {
2446 if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
2447 & (1 << port))
2448 removable = false;
2449 } else {
2450 if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
2451 removable = false;
2452 }
2453
2454 if (removable)
2455 udev->removable = USB_DEVICE_REMOVABLE;
2456 else
2457 udev->removable = USB_DEVICE_FIXED;
2458
2459}
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482int usb_new_device(struct usb_device *udev)
2483{
2484 int err;
2485
2486 if (udev->parent) {
2487
2488
2489
2490
2491 device_init_wakeup(&udev->dev, 0);
2492 }
2493
2494
2495 pm_runtime_set_active(&udev->dev);
2496 pm_runtime_get_noresume(&udev->dev);
2497 pm_runtime_use_autosuspend(&udev->dev);
2498 pm_runtime_enable(&udev->dev);
2499
2500
2501
2502
2503 usb_disable_autosuspend(udev);
2504
2505 err = usb_enumerate_device(udev);
2506 if (err < 0)
2507 goto fail;
2508 dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
2509 udev->devnum, udev->bus->busnum,
2510 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2511
2512 udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
2513 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2514
2515
2516 announce_device(udev);
2517
2518 if (udev->serial)
2519 add_device_randomness(udev->serial, strlen(udev->serial));
2520 if (udev->product)
2521 add_device_randomness(udev->product, strlen(udev->product));
2522 if (udev->manufacturer)
2523 add_device_randomness(udev->manufacturer,
2524 strlen(udev->manufacturer));
2525
2526 device_enable_async_suspend(&udev->dev);
2527
2528
2529 if (udev->parent)
2530 set_usb_port_removable(udev);
2531
2532
2533
2534
2535
2536 err = device_add(&udev->dev);
2537 if (err) {
2538 dev_err(&udev->dev, "can't device_add, error %d\n", err);
2539 goto fail;
2540 }
2541
2542
2543 if (udev->parent) {
2544 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2545 int port1 = udev->portnum;
2546 struct usb_port *port_dev = hub->ports[port1 - 1];
2547
2548 err = sysfs_create_link(&udev->dev.kobj,
2549 &port_dev->dev.kobj, "port");
2550 if (err)
2551 goto fail;
2552
2553 err = sysfs_create_link(&port_dev->dev.kobj,
2554 &udev->dev.kobj, "device");
2555 if (err) {
2556 sysfs_remove_link(&udev->dev.kobj, "port");
2557 goto fail;
2558 }
2559
2560 if (!test_and_set_bit(port1, hub->child_usage_bits))
2561 pm_runtime_get_sync(&port_dev->dev);
2562 }
2563
2564 (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
2565 usb_mark_last_busy(udev);
2566 pm_runtime_put_sync_autosuspend(&udev->dev);
2567 return err;
2568
2569fail:
2570 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2571 pm_runtime_disable(&udev->dev);
2572 pm_runtime_set_suspended(&udev->dev);
2573 return err;
2574}
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589int usb_deauthorize_device(struct usb_device *usb_dev)
2590{
2591 usb_lock_device(usb_dev);
2592 if (usb_dev->authorized == 0)
2593 goto out_unauthorized;
2594
2595 usb_dev->authorized = 0;
2596 usb_set_configuration(usb_dev, -1);
2597
2598out_unauthorized:
2599 usb_unlock_device(usb_dev);
2600 return 0;
2601}
2602
2603
2604int usb_authorize_device(struct usb_device *usb_dev)
2605{
2606 int result = 0, c;
2607
2608 usb_lock_device(usb_dev);
2609 if (usb_dev->authorized == 1)
2610 goto out_authorized;
2611
2612 result = usb_autoresume_device(usb_dev);
2613 if (result < 0) {
2614 dev_err(&usb_dev->dev,
2615 "can't autoresume for authorization: %d\n", result);
2616 goto error_autoresume;
2617 }
2618
2619 if (usb_dev->wusb) {
2620 result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
2621 if (result < 0) {
2622 dev_err(&usb_dev->dev, "can't re-read device descriptor for "
2623 "authorization: %d\n", result);
2624 goto error_device_descriptor;
2625 }
2626 }
2627
2628 usb_dev->authorized = 1;
2629
2630
2631
2632 c = usb_choose_configuration(usb_dev);
2633 if (c >= 0) {
2634 result = usb_set_configuration(usb_dev, c);
2635 if (result) {
2636 dev_err(&usb_dev->dev,
2637 "can't set config #%d, error %d\n", c, result);
2638
2639
2640 }
2641 }
2642 dev_info(&usb_dev->dev, "authorized to connect\n");
2643
2644error_device_descriptor:
2645 usb_autosuspend_device(usb_dev);
2646error_autoresume:
2647out_authorized:
2648 usb_unlock_device(usb_dev);
2649 return result;
2650}
2651
2652
2653
2654
2655
2656
2657
2658static int port_speed_is_ssp(struct usb_device *hdev, int speed_id)
2659{
2660 int ssa_count;
2661 u32 ss_attr;
2662 int i;
2663 struct usb_ssp_cap_descriptor *ssp_cap = hdev->bos->ssp_cap;
2664
2665 if (!ssp_cap)
2666 return 0;
2667
2668 ssa_count = le32_to_cpu(ssp_cap->bmAttributes) &
2669 USB_SSP_SUBLINK_SPEED_ATTRIBS;
2670
2671 for (i = 0; i <= ssa_count; i++) {
2672 ss_attr = le32_to_cpu(ssp_cap->bmSublinkSpeedAttr[i]);
2673 if (speed_id == (ss_attr & USB_SSP_SUBLINK_SPEED_SSID))
2674 return !!(ss_attr & USB_SSP_SUBLINK_SPEED_LP);
2675 }
2676 return 0;
2677}
2678
2679
2680static unsigned hub_is_wusb(struct usb_hub *hub)
2681{
2682 struct usb_hcd *hcd;
2683 if (hub->hdev->parent != NULL)
2684 return 0;
2685 hcd = bus_to_hcd(hub->hdev->bus);
2686 return hcd->wireless;
2687}
2688
2689
2690#define PORT_RESET_TRIES 5
2691#define SET_ADDRESS_TRIES 2
2692#define GET_DESCRIPTOR_TRIES 2
2693#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))
2694#define USE_NEW_SCHEME(i, scheme) ((i) / 2 == (int)scheme)
2695
2696#define HUB_ROOT_RESET_TIME 60
2697#define HUB_SHORT_RESET_TIME 10
2698#define HUB_BH_RESET_TIME 50
2699#define HUB_LONG_RESET_TIME 200
2700#define HUB_RESET_TIMEOUT 800
2701
2702
2703
2704
2705
2706
2707
2708
2709static bool use_new_scheme(struct usb_device *udev, int retry,
2710 struct usb_port *port_dev)
2711{
2712 int old_scheme_first_port =
2713 port_dev->quirks & USB_PORT_QUIRK_OLD_SCHEME;
2714 int quick_enumeration = (udev->speed == USB_SPEED_HIGH);
2715
2716 if (udev->speed >= USB_SPEED_SUPER)
2717 return false;
2718
2719 return USE_NEW_SCHEME(retry, old_scheme_first_port || old_scheme_first
2720 || quick_enumeration);
2721}
2722
2723
2724
2725
2726static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
2727 u16 portstatus)
2728{
2729 u16 link_state;
2730
2731 if (!hub_is_superspeed(hub->hdev))
2732 return false;
2733
2734 if (test_bit(port1, hub->warm_reset_bits))
2735 return true;
2736
2737 link_state = portstatus & USB_PORT_STAT_LINK_STATE;
2738 return link_state == USB_SS_PORT_LS_SS_INACTIVE
2739 || link_state == USB_SS_PORT_LS_COMP_MOD;
2740}
2741
2742static int hub_port_wait_reset(struct usb_hub *hub, int port1,
2743 struct usb_device *udev, unsigned int delay, bool warm)
2744{
2745 int delay_time, ret;
2746 u16 portstatus;
2747 u16 portchange;
2748 u32 ext_portstatus = 0;
2749
2750 for (delay_time = 0;
2751 delay_time < HUB_RESET_TIMEOUT;
2752 delay_time += delay) {
2753
2754 msleep(delay);
2755
2756
2757 if (hub_is_superspeedplus(hub->hdev))
2758 ret = hub_ext_port_status(hub, port1,
2759 HUB_EXT_PORT_STATUS,
2760 &portstatus, &portchange,
2761 &ext_portstatus);
2762 else
2763 ret = hub_port_status(hub, port1, &portstatus,
2764 &portchange);
2765 if (ret < 0)
2766 return ret;
2767
2768
2769
2770
2771
2772
2773
2774
2775 if (!(portstatus & USB_PORT_STAT_RESET) &&
2776 (portstatus & USB_PORT_STAT_CONNECTION))
2777 break;
2778
2779
2780 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
2781 delay = HUB_LONG_RESET_TIME;
2782
2783 dev_dbg(&hub->ports[port1 - 1]->dev,
2784 "not %sreset yet, waiting %dms\n",
2785 warm ? "warm " : "", delay);
2786 }
2787
2788 if ((portstatus & USB_PORT_STAT_RESET))
2789 return -EBUSY;
2790
2791 if (hub_port_warm_reset_required(hub, port1, portstatus))
2792 return -ENOTCONN;
2793
2794
2795 if (!(portstatus & USB_PORT_STAT_CONNECTION))
2796 return -ENOTCONN;
2797
2798
2799
2800
2801
2802 if (!hub_is_superspeed(hub->hdev) &&
2803 (portchange & USB_PORT_STAT_C_CONNECTION)) {
2804 usb_clear_port_feature(hub->hdev, port1,
2805 USB_PORT_FEAT_C_CONNECTION);
2806 return -EAGAIN;
2807 }
2808
2809 if (!(portstatus & USB_PORT_STAT_ENABLE))
2810 return -EBUSY;
2811
2812 if (!udev)
2813 return 0;
2814
2815 if (hub_is_superspeedplus(hub->hdev)) {
2816
2817 udev->rx_lanes = USB_EXT_PORT_RX_LANES(ext_portstatus) + 1;
2818 udev->tx_lanes = USB_EXT_PORT_TX_LANES(ext_portstatus) + 1;
2819 } else {
2820 udev->rx_lanes = 1;
2821 udev->tx_lanes = 1;
2822 }
2823 if (hub_is_wusb(hub))
2824 udev->speed = USB_SPEED_WIRELESS;
2825 else if (hub_is_superspeedplus(hub->hdev) &&
2826 port_speed_is_ssp(hub->hdev, ext_portstatus &
2827 USB_EXT_PORT_STAT_RX_SPEED_ID))
2828 udev->speed = USB_SPEED_SUPER_PLUS;
2829 else if (hub_is_superspeed(hub->hdev))
2830 udev->speed = USB_SPEED_SUPER;
2831 else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
2832 udev->speed = USB_SPEED_HIGH;
2833 else if (portstatus & USB_PORT_STAT_LOW_SPEED)
2834 udev->speed = USB_SPEED_LOW;
2835 else
2836 udev->speed = USB_SPEED_FULL;
2837 return 0;
2838}
2839
2840
2841static int hub_port_reset(struct usb_hub *hub, int port1,
2842 struct usb_device *udev, unsigned int delay, bool warm)
2843{
2844 int i, status;
2845 u16 portchange, portstatus;
2846 struct usb_port *port_dev = hub->ports[port1 - 1];
2847 int reset_recovery_time;
2848
2849 if (!hub_is_superspeed(hub->hdev)) {
2850 if (warm) {
2851 dev_err(hub->intfdev, "only USB3 hub support "
2852 "warm reset\n");
2853 return -EINVAL;
2854 }
2855
2856
2857
2858 down_read(&ehci_cf_port_reset_rwsem);
2859 } else if (!warm) {
2860
2861
2862
2863
2864 if (hub_port_status(hub, port1, &portstatus, &portchange) == 0)
2865 if (hub_port_warm_reset_required(hub, port1,
2866 portstatus))
2867 warm = true;
2868 }
2869 clear_bit(port1, hub->warm_reset_bits);
2870
2871
2872 for (i = 0; i < PORT_RESET_TRIES; i++) {
2873 status = set_port_feature(hub->hdev, port1, (warm ?
2874 USB_PORT_FEAT_BH_PORT_RESET :
2875 USB_PORT_FEAT_RESET));
2876 if (status == -ENODEV) {
2877 ;
2878 } else if (status) {
2879 dev_err(&port_dev->dev,
2880 "cannot %sreset (err = %d)\n",
2881 warm ? "warm " : "", status);
2882 } else {
2883 status = hub_port_wait_reset(hub, port1, udev, delay,
2884 warm);
2885 if (status && status != -ENOTCONN && status != -ENODEV)
2886 dev_dbg(hub->intfdev,
2887 "port_wait_reset: err = %d\n",
2888 status);
2889 }
2890
2891
2892 if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
2893 usb_clear_port_feature(hub->hdev, port1,
2894 USB_PORT_FEAT_C_RESET);
2895
2896 if (!hub_is_superspeed(hub->hdev))
2897 goto done;
2898
2899 usb_clear_port_feature(hub->hdev, port1,
2900 USB_PORT_FEAT_C_BH_PORT_RESET);
2901 usb_clear_port_feature(hub->hdev, port1,
2902 USB_PORT_FEAT_C_PORT_LINK_STATE);
2903
2904 if (udev)
2905 usb_clear_port_feature(hub->hdev, port1,
2906 USB_PORT_FEAT_C_CONNECTION);
2907
2908
2909
2910
2911
2912 if (hub_port_status(hub, port1,
2913 &portstatus, &portchange) < 0)
2914 goto done;
2915
2916 if (!hub_port_warm_reset_required(hub, port1,
2917 portstatus))
2918 goto done;
2919
2920
2921
2922
2923
2924 if (!warm) {
2925 dev_dbg(&port_dev->dev,
2926 "hot reset failed, warm reset\n");
2927 warm = true;
2928 }
2929 }
2930
2931 dev_dbg(&port_dev->dev,
2932 "not enabled, trying %sreset again...\n",
2933 warm ? "warm " : "");
2934 delay = HUB_LONG_RESET_TIME;
2935 }
2936
2937 dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
2938
2939done:
2940 if (status == 0) {
2941 if (port_dev->quirks & USB_PORT_QUIRK_FAST_ENUM)
2942 usleep_range(10000, 12000);
2943 else {
2944
2945 reset_recovery_time = 10 + 40;
2946
2947
2948 if (hub->hdev->quirks & USB_QUIRK_HUB_SLOW_RESET)
2949 reset_recovery_time += 100;
2950
2951 msleep(reset_recovery_time);
2952 }
2953
2954 if (udev) {
2955 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2956
2957 update_devnum(udev, 0);
2958
2959
2960
2961 if (hcd->driver->reset_device)
2962 hcd->driver->reset_device(hcd, udev);
2963
2964 usb_set_device_state(udev, USB_STATE_DEFAULT);
2965 }
2966 } else {
2967 if (udev)
2968 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2969 }
2970
2971 if (!hub_is_superspeed(hub->hdev))
2972 up_read(&ehci_cf_port_reset_rwsem);
2973
2974 return status;
2975}
2976
2977
2978static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
2979{
2980 int ret = 0;
2981
2982 if (hub_is_superspeed(hub->hdev)) {
2983 if (portstatus & USB_SS_PORT_STAT_POWER)
2984 ret = 1;
2985 } else {
2986 if (portstatus & USB_PORT_STAT_POWER)
2987 ret = 1;
2988 }
2989
2990 return ret;
2991}
2992
2993static void usb_lock_port(struct usb_port *port_dev)
2994 __acquires(&port_dev->status_lock)
2995{
2996 mutex_lock(&port_dev->status_lock);
2997 __acquire(&port_dev->status_lock);
2998}
2999
3000static void usb_unlock_port(struct usb_port *port_dev)
3001 __releases(&port_dev->status_lock)
3002{
3003 mutex_unlock(&port_dev->status_lock);
3004 __release(&port_dev->status_lock);
3005}
3006
3007#ifdef CONFIG_PM
3008
3009
3010static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
3011{
3012 int ret = 0;
3013
3014 if (hub_is_superspeed(hub->hdev)) {
3015 if ((portstatus & USB_PORT_STAT_LINK_STATE)
3016 == USB_SS_PORT_LS_U3)
3017 ret = 1;
3018 } else {
3019 if (portstatus & USB_PORT_STAT_SUSPEND)
3020 ret = 1;
3021 }
3022
3023 return ret;
3024}
3025
3026
3027
3028
3029static int check_port_resume_type(struct usb_device *udev,
3030 struct usb_hub *hub, int port1,
3031 int status, u16 portchange, u16 portstatus)
3032{
3033 struct usb_port *port_dev = hub->ports[port1 - 1];
3034 int retries = 3;
3035
3036 retry:
3037
3038 if (status == 0 && udev->reset_resume
3039 && hub_port_warm_reset_required(hub, port1, portstatus)) {
3040 ;
3041 }
3042
3043 else if (status || port_is_suspended(hub, portstatus) ||
3044 !port_is_power_on(hub, portstatus)) {
3045 if (status >= 0)
3046 status = -ENODEV;
3047 } else if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
3048 if (retries--) {
3049 usleep_range(200, 300);
3050 status = hub_port_status(hub, port1, &portstatus,
3051 &portchange);
3052 goto retry;
3053 }
3054 status = -ENODEV;
3055 }
3056
3057
3058
3059
3060 else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
3061 if (udev->persist_enabled)
3062 udev->reset_resume = 1;
3063 else
3064 status = -ENODEV;
3065 }
3066
3067 if (status) {
3068 dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n",
3069 portchange, portstatus, status);
3070 } else if (udev->reset_resume) {
3071
3072
3073 if (portchange & USB_PORT_STAT_C_CONNECTION)
3074 usb_clear_port_feature(hub->hdev, port1,
3075 USB_PORT_FEAT_C_CONNECTION);
3076 if (portchange & USB_PORT_STAT_C_ENABLE)
3077 usb_clear_port_feature(hub->hdev, port1,
3078 USB_PORT_FEAT_C_ENABLE);
3079 }
3080
3081 return status;
3082}
3083
3084int usb_disable_ltm(struct usb_device *udev)
3085{
3086 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3087
3088
3089 if (!usb_device_supports_ltm(hcd->self.root_hub) ||
3090 !usb_device_supports_ltm(udev))
3091 return 0;
3092
3093
3094
3095
3096 if (!udev->actconfig)
3097 return 0;
3098
3099 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3100 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
3101 USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
3102 USB_CTRL_SET_TIMEOUT);
3103}
3104EXPORT_SYMBOL_GPL(usb_disable_ltm);
3105
3106void usb_enable_ltm(struct usb_device *udev)
3107{
3108 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3109
3110
3111 if (!usb_device_supports_ltm(hcd->self.root_hub) ||
3112 !usb_device_supports_ltm(udev))
3113 return;
3114
3115
3116
3117
3118 if (!udev->actconfig)
3119 return;
3120
3121 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3122 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
3123 USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
3124 USB_CTRL_SET_TIMEOUT);
3125}
3126EXPORT_SYMBOL_GPL(usb_enable_ltm);
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138static int usb_enable_remote_wakeup(struct usb_device *udev)
3139{
3140 if (udev->speed < USB_SPEED_SUPER)
3141 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3142 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
3143 USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
3144 USB_CTRL_SET_TIMEOUT);
3145 else
3146 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3147 USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
3148 USB_INTRF_FUNC_SUSPEND,
3149 USB_INTRF_FUNC_SUSPEND_RW |
3150 USB_INTRF_FUNC_SUSPEND_LP,
3151 NULL, 0, USB_CTRL_SET_TIMEOUT);
3152}
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164static int usb_disable_remote_wakeup(struct usb_device *udev)
3165{
3166 if (udev->speed < USB_SPEED_SUPER)
3167 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3168 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
3169 USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
3170 USB_CTRL_SET_TIMEOUT);
3171 else
3172 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3173 USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
3174 USB_INTRF_FUNC_SUSPEND, 0, NULL, 0,
3175 USB_CTRL_SET_TIMEOUT);
3176}
3177
3178
3179unsigned usb_wakeup_enabled_descendants(struct usb_device *udev)
3180{
3181 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
3182
3183 return udev->do_remote_wakeup +
3184 (hub ? hub->wakeup_enabled_descendants : 0);
3185}
3186EXPORT_SYMBOL_GPL(usb_wakeup_enabled_descendants);
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
3237{
3238 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
3239 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
3240 int port1 = udev->portnum;
3241 int status;
3242 bool really_suspend = true;
3243
3244 usb_lock_port(port_dev);
3245
3246
3247
3248
3249
3250
3251
3252 if (udev->do_remote_wakeup) {
3253 status = usb_enable_remote_wakeup(udev);
3254 if (status) {
3255 dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
3256 status);
3257
3258 if (PMSG_IS_AUTO(msg))
3259 goto err_wakeup;
3260 }
3261 }
3262
3263
3264 usb_disable_usb2_hardware_lpm(udev);
3265
3266 if (usb_disable_ltm(udev)) {
3267 dev_err(&udev->dev, "Failed to disable LTM before suspend\n");
3268 status = -ENOMEM;
3269 if (PMSG_IS_AUTO(msg))
3270 goto err_ltm;
3271 }
3272
3273
3274 if (hub_is_superspeed(hub->hdev))
3275 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288 else if (PMSG_IS_AUTO(msg) || usb_wakeup_enabled_descendants(udev) > 0)
3289 status = set_port_feature(hub->hdev, port1,
3290 USB_PORT_FEAT_SUSPEND);
3291 else {
3292 really_suspend = false;
3293 status = 0;
3294 }
3295 if (status) {
3296 dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status);
3297
3298
3299 usb_enable_ltm(udev);
3300 err_ltm:
3301
3302 usb_enable_usb2_hardware_lpm(udev);
3303
3304 if (udev->do_remote_wakeup)
3305 (void) usb_disable_remote_wakeup(udev);
3306 err_wakeup:
3307
3308
3309 if (!PMSG_IS_AUTO(msg))
3310 status = 0;
3311 } else {
3312 dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
3313 (PMSG_IS_AUTO(msg) ? "auto-" : ""),
3314 udev->do_remote_wakeup);
3315 if (really_suspend) {
3316 udev->port_is_suspended = 1;
3317
3318
3319 msleep(10);
3320 }
3321 usb_set_device_state(udev, USB_STATE_SUSPENDED);
3322 }
3323
3324 if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled
3325 && test_and_clear_bit(port1, hub->child_usage_bits))
3326 pm_runtime_put_sync(&port_dev->dev);
3327
3328 usb_mark_last_busy(hub->hdev);
3329
3330 usb_unlock_port(port_dev);
3331 return status;
3332}
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345static int finish_port_resume(struct usb_device *udev)
3346{
3347 int status = 0;
3348 u16 devstatus = 0;
3349
3350
3351 dev_dbg(&udev->dev, "%s\n",
3352 udev->reset_resume ? "finish reset-resume" : "finish resume");
3353
3354
3355
3356
3357
3358
3359 usb_set_device_state(udev, udev->actconfig
3360 ? USB_STATE_CONFIGURED
3361 : USB_STATE_ADDRESS);
3362
3363
3364
3365
3366
3367
3368 if (udev->reset_resume) {
3369
3370
3371
3372
3373
3374
3375 retry_reset_resume:
3376 if (udev->quirks & USB_QUIRK_RESET)
3377 status = -ENODEV;
3378 else
3379 status = usb_reset_and_verify_device(udev);
3380 }
3381
3382
3383
3384
3385
3386 if (status == 0) {
3387 devstatus = 0;
3388 status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
3389
3390
3391 if (status && !udev->reset_resume && udev->persist_enabled) {
3392 dev_dbg(&udev->dev, "retry with reset-resume\n");
3393 udev->reset_resume = 1;
3394 goto retry_reset_resume;
3395 }
3396 }
3397
3398 if (status) {
3399 dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
3400 status);
3401
3402
3403
3404
3405
3406
3407 } else if (udev->actconfig && !udev->reset_resume) {
3408 if (udev->speed < USB_SPEED_SUPER) {
3409 if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
3410 status = usb_disable_remote_wakeup(udev);
3411 } else {
3412 status = usb_get_std_status(udev, USB_RECIP_INTERFACE, 0,
3413 &devstatus);
3414 if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
3415 | USB_INTRF_STAT_FUNC_RW))
3416 status = usb_disable_remote_wakeup(udev);
3417 }
3418
3419 if (status)
3420 dev_dbg(&udev->dev,
3421 "disable remote wakeup, status %d\n",
3422 status);
3423 status = 0;
3424 }
3425 return status;
3426}
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452static int wait_for_connected(struct usb_device *udev,
3453 struct usb_hub *hub, int *port1,
3454 u16 *portchange, u16 *portstatus)
3455{
3456 int status = 0, delay_ms = 0;
3457
3458 while (delay_ms < 2000) {
3459 if (status || *portstatus & USB_PORT_STAT_CONNECTION)
3460 break;
3461 if (!port_is_power_on(hub, *portstatus)) {
3462 status = -ENODEV;
3463 break;
3464 }
3465 msleep(20);
3466 delay_ms += 20;
3467 status = hub_port_status(hub, *port1, portstatus, portchange);
3468 }
3469 dev_dbg(&udev->dev, "Waited %dms for CONNECT\n", delay_ms);
3470 return status;
3471}
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507int usb_port_resume(struct usb_device *udev, pm_message_t msg)
3508{
3509 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
3510 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
3511 int port1 = udev->portnum;
3512 int status;
3513 u16 portchange, portstatus;
3514
3515 if (!test_and_set_bit(port1, hub->child_usage_bits)) {
3516 status = pm_runtime_get_sync(&port_dev->dev);
3517 if (status < 0) {
3518 dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
3519 status);
3520 return status;
3521 }
3522 }
3523
3524 usb_lock_port(port_dev);
3525
3526
3527 status = hub_port_status(hub, port1, &portstatus, &portchange);
3528 if (status == 0 && !port_is_suspended(hub, portstatus)) {
3529 if (portchange & USB_PORT_STAT_C_SUSPEND)
3530 pm_wakeup_event(&udev->dev, 0);
3531 goto SuspendCleared;
3532 }
3533
3534
3535 if (hub_is_superspeed(hub->hdev))
3536 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
3537 else
3538 status = usb_clear_port_feature(hub->hdev,
3539 port1, USB_PORT_FEAT_SUSPEND);
3540 if (status) {
3541 dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
3542 } else {
3543
3544 dev_dbg(&udev->dev, "usb %sresume\n",
3545 (PMSG_IS_AUTO(msg) ? "auto-" : ""));
3546 msleep(USB_RESUME_TIMEOUT);
3547
3548
3549
3550
3551
3552 status = hub_port_status(hub, port1, &portstatus, &portchange);
3553
3554
3555 msleep(10);
3556 }
3557
3558 SuspendCleared:
3559 if (status == 0) {
3560 udev->port_is_suspended = 0;
3561 if (hub_is_superspeed(hub->hdev)) {
3562 if (portchange & USB_PORT_STAT_C_LINK_STATE)
3563 usb_clear_port_feature(hub->hdev, port1,
3564 USB_PORT_FEAT_C_PORT_LINK_STATE);
3565 } else {
3566 if (portchange & USB_PORT_STAT_C_SUSPEND)
3567 usb_clear_port_feature(hub->hdev, port1,
3568 USB_PORT_FEAT_C_SUSPEND);
3569 }
3570 }
3571
3572 if (udev->persist_enabled)
3573 status = wait_for_connected(udev, hub, &port1, &portchange,
3574 &portstatus);
3575
3576 status = check_port_resume_type(udev,
3577 hub, port1, status, portchange, portstatus);
3578 if (status == 0)
3579 status = finish_port_resume(udev);
3580 if (status < 0) {
3581 dev_dbg(&udev->dev, "can't resume, status %d\n", status);
3582 hub_port_logical_disconnect(hub, port1);
3583 } else {
3584
3585 usb_enable_usb2_hardware_lpm(udev);
3586
3587
3588 usb_enable_ltm(udev);
3589 }
3590
3591 usb_unlock_port(port_dev);
3592
3593 return status;
3594}
3595
3596int usb_remote_wakeup(struct usb_device *udev)
3597{
3598 int status = 0;
3599
3600 usb_lock_device(udev);
3601 if (udev->state == USB_STATE_SUSPENDED) {
3602 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
3603 status = usb_autoresume_device(udev);
3604 if (status == 0) {
3605
3606 usb_autosuspend_device(udev);
3607 }
3608 }
3609 usb_unlock_device(udev);
3610 return status;
3611}
3612
3613
3614static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
3615 u16 portstatus, u16 portchange)
3616 __must_hold(&port_dev->status_lock)
3617{
3618 struct usb_port *port_dev = hub->ports[port - 1];
3619 struct usb_device *hdev;
3620 struct usb_device *udev;
3621 int connect_change = 0;
3622 u16 link_state;
3623 int ret;
3624
3625 hdev = hub->hdev;
3626 udev = port_dev->child;
3627 if (!hub_is_superspeed(hdev)) {
3628 if (!(portchange & USB_PORT_STAT_C_SUSPEND))
3629 return 0;
3630 usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
3631 } else {
3632 link_state = portstatus & USB_PORT_STAT_LINK_STATE;
3633 if (!udev || udev->state != USB_STATE_SUSPENDED ||
3634 (link_state != USB_SS_PORT_LS_U0 &&
3635 link_state != USB_SS_PORT_LS_U1 &&
3636 link_state != USB_SS_PORT_LS_U2))
3637 return 0;
3638 }
3639
3640 if (udev) {
3641
3642 msleep(10);
3643
3644 usb_unlock_port(port_dev);
3645 ret = usb_remote_wakeup(udev);
3646 usb_lock_port(port_dev);
3647 if (ret < 0)
3648 connect_change = 1;
3649 } else {
3650 ret = -ENODEV;
3651 hub_port_disable(hub, port, 1);
3652 }
3653 dev_dbg(&port_dev->dev, "resume, status %d\n", ret);
3654 return connect_change;
3655}
3656
3657static int check_ports_changed(struct usb_hub *hub)
3658{
3659 int port1;
3660
3661 for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) {
3662 u16 portstatus, portchange;
3663 int status;
3664
3665 status = hub_port_status(hub, port1, &portstatus, &portchange);
3666 if (!status && portchange)
3667 return 1;
3668 }
3669 return 0;
3670}
3671
3672static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
3673{
3674 struct usb_hub *hub = usb_get_intfdata(intf);
3675 struct usb_device *hdev = hub->hdev;
3676 unsigned port1;
3677
3678
3679
3680
3681
3682 hub->wakeup_enabled_descendants = 0;
3683 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3684 struct usb_port *port_dev = hub->ports[port1 - 1];
3685 struct usb_device *udev = port_dev->child;
3686
3687 if (udev && udev->can_submit) {
3688 dev_warn(&port_dev->dev, "device %s not suspended yet\n",
3689 dev_name(&udev->dev));
3690 if (PMSG_IS_AUTO(msg))
3691 return -EBUSY;
3692 }
3693 if (udev)
3694 hub->wakeup_enabled_descendants +=
3695 usb_wakeup_enabled_descendants(udev);
3696 }
3697
3698 if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) {
3699
3700 if (check_ports_changed(hub)) {
3701 if (PMSG_IS_AUTO(msg))
3702 return -EBUSY;
3703 pm_wakeup_event(&hdev->dev, 2000);
3704 }
3705 }
3706
3707 if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
3708
3709 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3710 set_port_feature(hdev,
3711 port1 |
3712 USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
3713 USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
3714 USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
3715 USB_PORT_FEAT_REMOTE_WAKE_MASK);
3716 }
3717 }
3718
3719 dev_dbg(&intf->dev, "%s\n", __func__);
3720
3721
3722 hub_quiesce(hub, HUB_SUSPEND);
3723 return 0;
3724}
3725
3726
3727static void report_wakeup_requests(struct usb_hub *hub)
3728{
3729 struct usb_device *hdev = hub->hdev;
3730 struct usb_device *udev;
3731 struct usb_hcd *hcd;
3732 unsigned long resuming_ports;
3733 int i;
3734
3735 if (hdev->parent)
3736 return;
3737
3738 hcd = bus_to_hcd(hdev->bus);
3739 if (hcd->driver->get_resuming_ports) {
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749 resuming_ports = hcd->driver->get_resuming_ports(hcd);
3750 for (i = 0; i < hdev->maxchild; ++i) {
3751 if (test_bit(i, &resuming_ports)) {
3752 udev = hub->ports[i]->child;
3753 if (udev)
3754 pm_wakeup_event(&udev->dev, 0);
3755 }
3756 }
3757 }
3758}
3759
3760static int hub_resume(struct usb_interface *intf)
3761{
3762 struct usb_hub *hub = usb_get_intfdata(intf);
3763
3764 dev_dbg(&intf->dev, "%s\n", __func__);
3765 hub_activate(hub, HUB_RESUME);
3766
3767
3768
3769
3770
3771
3772
3773 report_wakeup_requests(hub);
3774 return 0;
3775}
3776
3777static int hub_reset_resume(struct usb_interface *intf)
3778{
3779 struct usb_hub *hub = usb_get_intfdata(intf);
3780
3781 dev_dbg(&intf->dev, "%s\n", __func__);
3782 hub_activate(hub, HUB_RESET_RESUME);
3783 return 0;
3784}
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797void usb_root_hub_lost_power(struct usb_device *rhdev)
3798{
3799 dev_notice(&rhdev->dev, "root hub lost power or was reset\n");
3800 rhdev->reset_resume = 1;
3801}
3802EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
3803
3804static const char * const usb3_lpm_names[] = {
3805 "U0",
3806 "U1",
3807 "U2",
3808 "U3",
3809};
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
3821{
3822 struct usb_set_sel_req *sel_values;
3823 unsigned long long u1_sel;
3824 unsigned long long u1_pel;
3825 unsigned long long u2_sel;
3826 unsigned long long u2_pel;
3827 int ret;
3828
3829 if (udev->state != USB_STATE_CONFIGURED)
3830 return 0;
3831
3832
3833 u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
3834 u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
3835 u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
3836 u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846 if ((state == USB3_LPM_U1 &&
3847 (u1_sel > USB3_LPM_MAX_U1_SEL_PEL ||
3848 u1_pel > USB3_LPM_MAX_U1_SEL_PEL)) ||
3849 (state == USB3_LPM_U2 &&
3850 (u2_sel > USB3_LPM_MAX_U2_SEL_PEL ||
3851 u2_pel > USB3_LPM_MAX_U2_SEL_PEL))) {
3852 dev_dbg(&udev->dev, "Device-initiated %s disabled due to long SEL %llu us or PEL %llu us\n",
3853 usb3_lpm_names[state], u1_sel, u1_pel);
3854 return -EINVAL;
3855 }
3856
3857
3858
3859
3860
3861
3862 if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL)
3863 u1_sel = USB3_LPM_MAX_U1_SEL_PEL;
3864
3865 if (u1_pel > USB3_LPM_MAX_U1_SEL_PEL)
3866 u1_pel = USB3_LPM_MAX_U1_SEL_PEL;
3867
3868 if (u2_sel > USB3_LPM_MAX_U2_SEL_PEL)
3869 u2_sel = USB3_LPM_MAX_U2_SEL_PEL;
3870
3871 if (u2_pel > USB3_LPM_MAX_U2_SEL_PEL)
3872 u2_pel = USB3_LPM_MAX_U2_SEL_PEL;
3873
3874
3875
3876
3877
3878
3879 sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
3880 if (!sel_values)
3881 return -ENOMEM;
3882
3883 sel_values->u1_sel = u1_sel;
3884 sel_values->u1_pel = u1_pel;
3885 sel_values->u2_sel = cpu_to_le16(u2_sel);
3886 sel_values->u2_pel = cpu_to_le16(u2_pel);
3887
3888 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3889 USB_REQ_SET_SEL,
3890 USB_RECIP_DEVICE,
3891 0, 0,
3892 sel_values, sizeof *(sel_values),
3893 USB_CTRL_SET_TIMEOUT);
3894 kfree(sel_values);
3895 return ret;
3896}
3897
3898
3899
3900
3901static int usb_set_device_initiated_lpm(struct usb_device *udev,
3902 enum usb3_link_state state, bool enable)
3903{
3904 int ret;
3905 int feature;
3906
3907 switch (state) {
3908 case USB3_LPM_U1:
3909 feature = USB_DEVICE_U1_ENABLE;
3910 break;
3911 case USB3_LPM_U2:
3912 feature = USB_DEVICE_U2_ENABLE;
3913 break;
3914 default:
3915 dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n",
3916 __func__, enable ? "enable" : "disable");
3917 return -EINVAL;
3918 }
3919
3920 if (udev->state != USB_STATE_CONFIGURED) {
3921 dev_dbg(&udev->dev, "%s: Can't %s %s state "
3922 "for unconfigured device.\n",
3923 __func__, enable ? "enable" : "disable",
3924 usb3_lpm_names[state]);
3925 return 0;
3926 }
3927
3928 if (enable) {
3929
3930
3931
3932
3933 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3934 USB_REQ_SET_FEATURE,
3935 USB_RECIP_DEVICE,
3936 feature,
3937 0, NULL, 0,
3938 USB_CTRL_SET_TIMEOUT);
3939 } else {
3940 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3941 USB_REQ_CLEAR_FEATURE,
3942 USB_RECIP_DEVICE,
3943 feature,
3944 0, NULL, 0,
3945 USB_CTRL_SET_TIMEOUT);
3946 }
3947 if (ret < 0) {
3948 dev_warn(&udev->dev, "%s of device-initiated %s failed.\n",
3949 enable ? "Enable" : "Disable",
3950 usb3_lpm_names[state]);
3951 return -EBUSY;
3952 }
3953 return 0;
3954}
3955
3956static int usb_set_lpm_timeout(struct usb_device *udev,
3957 enum usb3_link_state state, int timeout)
3958{
3959 int ret;
3960 int feature;
3961
3962 switch (state) {
3963 case USB3_LPM_U1:
3964 feature = USB_PORT_FEAT_U1_TIMEOUT;
3965 break;
3966 case USB3_LPM_U2:
3967 feature = USB_PORT_FEAT_U2_TIMEOUT;
3968 break;
3969 default:
3970 dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n",
3971 __func__);
3972 return -EINVAL;
3973 }
3974
3975 if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT &&
3976 timeout != USB3_LPM_DEVICE_INITIATED) {
3977 dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, "
3978 "which is a reserved value.\n",
3979 usb3_lpm_names[state], timeout);
3980 return -EINVAL;
3981 }
3982
3983 ret = set_port_feature(udev->parent,
3984 USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum,
3985 feature);
3986 if (ret < 0) {
3987 dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x,"
3988 "error code %i\n", usb3_lpm_names[state],
3989 timeout, ret);
3990 return -EBUSY;
3991 }
3992 if (state == USB3_LPM_U1)
3993 udev->u1_params.timeout = timeout;
3994 else
3995 udev->u2_params.timeout = timeout;
3996 return 0;
3997}
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
4015 enum usb3_link_state state)
4016{
4017 int timeout, ret;
4018 __u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
4019 __le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;
4020
4021
4022
4023
4024
4025 if ((state == USB3_LPM_U1 && u1_mel == 0) ||
4026 (state == USB3_LPM_U2 && u2_mel == 0))
4027 return;
4028
4029
4030
4031
4032
4033 ret = usb_req_set_sel(udev, state);
4034 if (ret < 0) {
4035 dev_warn(&udev->dev, "Set SEL for device-initiated %s failed.\n",
4036 usb3_lpm_names[state]);
4037 return;
4038 }
4039
4040
4041
4042
4043
4044
4045 timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state);
4046
4047
4048 if (timeout == 0)
4049 return;
4050
4051 if (timeout < 0) {
4052 dev_warn(&udev->dev, "Could not enable %s link state, "
4053 "xHCI error %i.\n", usb3_lpm_names[state],
4054 timeout);
4055 return;
4056 }
4057
4058 if (usb_set_lpm_timeout(udev, state, timeout)) {
4059
4060
4061
4062
4063 hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
4064 return;
4065 }
4066
4067
4068
4069
4070 if (udev->actconfig &&
4071 usb_set_device_initiated_lpm(udev, state, true) == 0) {
4072 if (state == USB3_LPM_U1)
4073 udev->usb3_lpm_u1_enabled = 1;
4074 else if (state == USB3_LPM_U2)
4075 udev->usb3_lpm_u2_enabled = 1;
4076 } else {
4077
4078
4079
4080 usb_set_lpm_timeout(udev, state, 0);
4081 hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
4082 }
4083}
4084
4085
4086
4087
4088
4089
4090
4091
4092
4093
4094
4095
4096
4097
4098
4099
4100static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
4101 enum usb3_link_state state)
4102{
4103 switch (state) {
4104 case USB3_LPM_U1:
4105 case USB3_LPM_U2:
4106 break;
4107 default:
4108 dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n",
4109 __func__);
4110 return -EINVAL;
4111 }
4112
4113 if (usb_set_lpm_timeout(udev, state, 0))
4114 return -EBUSY;
4115
4116 usb_set_device_initiated_lpm(udev, state, false);
4117
4118 if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state))
4119 dev_warn(&udev->dev, "Could not disable xHCI %s timeout, "
4120 "bus schedule bandwidth may be impacted.\n",
4121 usb3_lpm_names[state]);
4122
4123
4124
4125
4126
4127
4128
4129 if (state == USB3_LPM_U1)
4130 udev->usb3_lpm_u1_enabled = 0;
4131 else if (state == USB3_LPM_U2)
4132 udev->usb3_lpm_u2_enabled = 0;
4133
4134 return 0;
4135}
4136
4137
4138
4139
4140
4141
4142
4143
4144int usb_disable_lpm(struct usb_device *udev)
4145{
4146 struct usb_hcd *hcd;
4147
4148 if (!udev || !udev->parent ||
4149 udev->speed < USB_SPEED_SUPER ||
4150 !udev->lpm_capable ||
4151 udev->state < USB_STATE_CONFIGURED)
4152 return 0;
4153
4154 hcd = bus_to_hcd(udev->bus);
4155 if (!hcd || !hcd->driver->disable_usb3_lpm_timeout)
4156 return 0;
4157
4158 udev->lpm_disable_count++;
4159 if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
4160 return 0;
4161
4162
4163 if (usb_disable_link_state(hcd, udev, USB3_LPM_U1))
4164 goto enable_lpm;
4165 if (usb_disable_link_state(hcd, udev, USB3_LPM_U2))
4166 goto enable_lpm;
4167
4168 return 0;
4169
4170enable_lpm:
4171 usb_enable_lpm(udev);
4172 return -EBUSY;
4173}
4174EXPORT_SYMBOL_GPL(usb_disable_lpm);
4175
4176
4177int usb_unlocked_disable_lpm(struct usb_device *udev)
4178{
4179 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4180 int ret;
4181
4182 if (!hcd)
4183 return -EINVAL;
4184
4185 mutex_lock(hcd->bandwidth_mutex);
4186 ret = usb_disable_lpm(udev);
4187 mutex_unlock(hcd->bandwidth_mutex);
4188
4189 return ret;
4190}
4191EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4192
4193
4194
4195
4196
4197
4198
4199
4200
4201void usb_enable_lpm(struct usb_device *udev)
4202{
4203 struct usb_hcd *hcd;
4204 struct usb_hub *hub;
4205 struct usb_port *port_dev;
4206
4207 if (!udev || !udev->parent ||
4208 udev->speed < USB_SPEED_SUPER ||
4209 !udev->lpm_capable ||
4210 udev->state < USB_STATE_CONFIGURED)
4211 return;
4212
4213 udev->lpm_disable_count--;
4214 hcd = bus_to_hcd(udev->bus);
4215
4216
4217
4218 if (!hcd || !hcd->driver->enable_usb3_lpm_timeout ||
4219 !hcd->driver->disable_usb3_lpm_timeout)
4220 return;
4221
4222 if (udev->lpm_disable_count > 0)
4223 return;
4224
4225 hub = usb_hub_to_struct_hub(udev->parent);
4226 if (!hub)
4227 return;
4228
4229 port_dev = hub->ports[udev->portnum - 1];
4230
4231 if (port_dev->usb3_lpm_u1_permit)
4232 usb_enable_link_state(hcd, udev, USB3_LPM_U1);
4233
4234 if (port_dev->usb3_lpm_u2_permit)
4235 usb_enable_link_state(hcd, udev, USB3_LPM_U2);
4236}
4237EXPORT_SYMBOL_GPL(usb_enable_lpm);
4238
4239
4240void usb_unlocked_enable_lpm(struct usb_device *udev)
4241{
4242 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4243
4244 if (!hcd)
4245 return;
4246
4247 mutex_lock(hcd->bandwidth_mutex);
4248 usb_enable_lpm(udev);
4249 mutex_unlock(hcd->bandwidth_mutex);
4250}
4251EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4252
4253
4254static void hub_usb3_port_prepare_disable(struct usb_hub *hub,
4255 struct usb_port *port_dev)
4256{
4257 struct usb_device *udev = port_dev->child;
4258 int ret;
4259
4260 if (udev && udev->port_is_suspended && udev->do_remote_wakeup) {
4261 ret = hub_set_port_link_state(hub, port_dev->portnum,
4262 USB_SS_PORT_LS_U0);
4263 if (!ret) {
4264 msleep(USB_RESUME_TIMEOUT);
4265 ret = usb_disable_remote_wakeup(udev);
4266 }
4267 if (ret)
4268 dev_warn(&udev->dev,
4269 "Port disable: can't disable remote wake\n");
4270 udev->do_remote_wakeup = 0;
4271 }
4272}
4273
4274#else
4275
4276#define hub_suspend NULL
4277#define hub_resume NULL
4278#define hub_reset_resume NULL
4279
4280static inline void hub_usb3_port_prepare_disable(struct usb_hub *hub,
4281 struct usb_port *port_dev) { }
4282
4283int usb_disable_lpm(struct usb_device *udev)
4284{
4285 return 0;
4286}
4287EXPORT_SYMBOL_GPL(usb_disable_lpm);
4288
4289void usb_enable_lpm(struct usb_device *udev) { }
4290EXPORT_SYMBOL_GPL(usb_enable_lpm);
4291
4292int usb_unlocked_disable_lpm(struct usb_device *udev)
4293{
4294 return 0;
4295}
4296EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4297
4298void usb_unlocked_enable_lpm(struct usb_device *udev) { }
4299EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4300
4301int usb_disable_ltm(struct usb_device *udev)
4302{
4303 return 0;
4304}
4305EXPORT_SYMBOL_GPL(usb_disable_ltm);
4306
4307void usb_enable_ltm(struct usb_device *udev) { }
4308EXPORT_SYMBOL_GPL(usb_enable_ltm);
4309
4310static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
4311 u16 portstatus, u16 portchange)
4312{
4313 return 0;
4314}
4315
4316#endif
4317
4318
4319
4320
4321
4322
4323static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
4324{
4325 struct usb_port *port_dev = hub->ports[port1 - 1];
4326 struct usb_device *hdev = hub->hdev;
4327 int ret = 0;
4328
4329 if (!hub->error) {
4330 if (hub_is_superspeed(hub->hdev)) {
4331 hub_usb3_port_prepare_disable(hub, port_dev);
4332 ret = hub_set_port_link_state(hub, port_dev->portnum,
4333 USB_SS_PORT_LS_U3);
4334 } else {
4335 ret = usb_clear_port_feature(hdev, port1,
4336 USB_PORT_FEAT_ENABLE);
4337 }
4338 }
4339 if (port_dev->child && set_state)
4340 usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
4341 if (ret && ret != -ENODEV)
4342 dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
4343 return ret;
4344}
4345
4346
4347
4348
4349
4350
4351
4352
4353int usb_port_disable(struct usb_device *udev)
4354{
4355 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
4356
4357 return hub_port_disable(hub, udev->portnum, 0);
4358}
4359
4360
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
4376{
4377 int ret;
4378 u16 portchange, portstatus;
4379 unsigned connection = 0xffff;
4380 int total_time, stable_time = 0;
4381 struct usb_port *port_dev = hub->ports[port1 - 1];
4382
4383 for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
4384 ret = hub_port_status(hub, port1, &portstatus, &portchange);
4385 if (ret < 0)
4386 return ret;
4387
4388 if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
4389 (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
4390 if (!must_be_connected ||
4391 (connection == USB_PORT_STAT_CONNECTION))
4392 stable_time += HUB_DEBOUNCE_STEP;
4393 if (stable_time >= HUB_DEBOUNCE_STABLE)
4394 break;
4395 } else {
4396 stable_time = 0;
4397 connection = portstatus & USB_PORT_STAT_CONNECTION;
4398 }
4399
4400 if (portchange & USB_PORT_STAT_C_CONNECTION) {
4401 usb_clear_port_feature(hub->hdev, port1,
4402 USB_PORT_FEAT_C_CONNECTION);
4403 }
4404
4405 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
4406 break;
4407 msleep(HUB_DEBOUNCE_STEP);
4408 }
4409
4410 dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n",
4411 total_time, stable_time, portstatus);
4412
4413 if (stable_time < HUB_DEBOUNCE_STABLE)
4414 return -ETIMEDOUT;
4415 return portstatus;
4416}
4417
4418void usb_ep0_reinit(struct usb_device *udev)
4419{
4420 usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
4421 usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
4422 usb_enable_endpoint(udev, &udev->ep0, true);
4423}
4424EXPORT_SYMBOL_GPL(usb_ep0_reinit);
4425
4426#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)
4427#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN)
4428
4429static int hub_set_address(struct usb_device *udev, int devnum)
4430{
4431 int retval;
4432 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4433
4434
4435
4436
4437
4438 if (!hcd->driver->address_device && devnum <= 1)
4439 return -EINVAL;
4440 if (udev->state == USB_STATE_ADDRESS)
4441 return 0;
4442 if (udev->state != USB_STATE_DEFAULT)
4443 return -EINVAL;
4444 if (hcd->driver->address_device)
4445 retval = hcd->driver->address_device(hcd, udev);
4446 else
4447 retval = usb_control_msg(udev, usb_sndaddr0pipe(),
4448 USB_REQ_SET_ADDRESS, 0, devnum, 0,
4449 NULL, 0, USB_CTRL_SET_TIMEOUT);
4450 if (retval == 0) {
4451 update_devnum(udev, devnum);
4452
4453 usb_set_device_state(udev, USB_STATE_ADDRESS);
4454 usb_ep0_reinit(udev);
4455 }
4456 return retval;
4457}
4458
4459
4460
4461
4462
4463
4464
4465
4466
4467
4468static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
4469{
4470 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
4471 int connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
4472
4473 if (!udev->usb2_hw_lpm_capable || !udev->bos)
4474 return;
4475
4476 if (hub)
4477 connect_type = hub->ports[udev->portnum - 1]->connect_type;
4478
4479 if ((udev->bos->ext_cap->bmAttributes & cpu_to_le32(USB_BESL_SUPPORT)) ||
4480 connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
4481 udev->usb2_hw_lpm_allowed = 1;
4482 usb_enable_usb2_hardware_lpm(udev);
4483 }
4484}
4485
4486static int hub_enable_device(struct usb_device *udev)
4487{
4488 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4489
4490 if (!hcd->driver->enable_device)
4491 return 0;
4492 if (udev->state == USB_STATE_ADDRESS)
4493 return 0;
4494 if (udev->state != USB_STATE_DEFAULT)
4495 return -EINVAL;
4496
4497 return hcd->driver->enable_device(hcd, udev);
4498}
4499
4500
4501
4502
4503
4504
4505
4506
4507
4508
4509
4510static int
4511hub_port_init(struct usb_hub *hub, struct usb_device *udev, int port1,
4512 int retry_counter)
4513{
4514 struct usb_device *hdev = hub->hdev;
4515 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
4516 struct usb_port *port_dev = hub->ports[port1 - 1];
4517 int retries, operations, retval, i;
4518 unsigned delay = HUB_SHORT_RESET_TIME;
4519 enum usb_device_speed oldspeed = udev->speed;
4520 const char *speed;
4521 int devnum = udev->devnum;
4522 const char *driver_name;
4523
4524
4525
4526
4527 if (!hdev->parent) {
4528 delay = HUB_ROOT_RESET_TIME;
4529 if (port1 == hdev->bus->otg_port)
4530 hdev->bus->b_hnp_enable = 0;
4531 }
4532
4533
4534
4535 if (oldspeed == USB_SPEED_LOW)
4536 delay = HUB_LONG_RESET_TIME;
4537
4538 mutex_lock(hcd->address0_mutex);
4539
4540
4541
4542 retval = hub_port_reset(hub, port1, udev, delay, false);
4543 if (retval < 0)
4544 goto fail;
4545
4546
4547 retval = -ENODEV;
4548
4549
4550 if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed &&
4551 !(oldspeed == USB_SPEED_SUPER && udev->speed > oldspeed)) {
4552 dev_dbg(&udev->dev, "device reset changed speed!\n");
4553 goto fail;
4554 }
4555 oldspeed = udev->speed;
4556
4557
4558
4559
4560
4561
4562 switch (udev->speed) {
4563 case USB_SPEED_SUPER_PLUS:
4564 case USB_SPEED_SUPER:
4565 case USB_SPEED_WIRELESS:
4566 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
4567 break;
4568 case USB_SPEED_HIGH:
4569 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
4570 break;
4571 case USB_SPEED_FULL:
4572
4573
4574
4575
4576 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
4577 break;
4578 case USB_SPEED_LOW:
4579 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
4580 break;
4581 default:
4582 goto fail;
4583 }
4584
4585 if (udev->speed == USB_SPEED_WIRELESS)
4586 speed = "variable speed Wireless";
4587 else
4588 speed = usb_speed_string(udev->speed);
4589
4590
4591
4592
4593
4594
4595
4596
4597 if (udev->bus->controller->driver)
4598 driver_name = udev->bus->controller->driver->name;
4599 else
4600 driver_name = udev->bus->sysdev->driver->name;
4601
4602 if (udev->speed < USB_SPEED_SUPER)
4603 dev_info(&udev->dev,
4604 "%s %s USB device number %d using %s\n",
4605 (udev->config) ? "reset" : "new", speed,
4606 devnum, driver_name);
4607
4608
4609 if (hdev->tt) {
4610 udev->tt = hdev->tt;
4611 udev->ttport = hdev->ttport;
4612 } else if (udev->speed != USB_SPEED_HIGH
4613 && hdev->speed == USB_SPEED_HIGH) {
4614 if (!hub->tt.hub) {
4615 dev_err(&udev->dev, "parent hub has no TT\n");
4616 retval = -EINVAL;
4617 goto fail;
4618 }
4619 udev->tt = &hub->tt;
4620 udev->ttport = port1;
4621 }
4622
4623
4624
4625
4626
4627
4628
4629
4630
4631
4632
4633
4634
4635 for (retries = 0; retries < GET_DESCRIPTOR_TRIES; (++retries, msleep(100))) {
4636 bool did_new_scheme = false;
4637
4638 if (use_new_scheme(udev, retry_counter, port_dev)) {
4639 struct usb_device_descriptor *buf;
4640 int r = 0;
4641
4642 did_new_scheme = true;
4643 retval = hub_enable_device(udev);
4644 if (retval < 0) {
4645 dev_err(&udev->dev,
4646 "hub failed to enable device, error %d\n",
4647 retval);
4648 goto fail;
4649 }
4650
4651#define GET_DESCRIPTOR_BUFSIZE 64
4652 buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
4653 if (!buf) {
4654 retval = -ENOMEM;
4655 continue;
4656 }
4657
4658
4659
4660
4661
4662 for (operations = 0; operations < 3; ++operations) {
4663 buf->bMaxPacketSize0 = 0;
4664 r = usb_control_msg(udev, usb_rcvaddr0pipe(),
4665 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
4666 USB_DT_DEVICE << 8, 0,
4667 buf, GET_DESCRIPTOR_BUFSIZE,
4668 initial_descriptor_timeout);
4669 switch (buf->bMaxPacketSize0) {
4670 case 8: case 16: case 32: case 64: case 255:
4671 if (buf->bDescriptorType ==
4672 USB_DT_DEVICE) {
4673 r = 0;
4674 break;
4675 }
4676
4677 default:
4678 if (r == 0)
4679 r = -EPROTO;
4680 break;
4681 }
4682
4683
4684
4685
4686
4687
4688 if (r == 0 || (r == -ETIMEDOUT &&
4689 retries == 0 &&
4690 udev->speed > USB_SPEED_FULL))
4691 break;
4692 }
4693 udev->descriptor.bMaxPacketSize0 =
4694 buf->bMaxPacketSize0;
4695 kfree(buf);
4696
4697 retval = hub_port_reset(hub, port1, udev, delay, false);
4698 if (retval < 0)
4699 goto fail;
4700 if (oldspeed != udev->speed) {
4701 dev_dbg(&udev->dev,
4702 "device reset changed speed!\n");
4703 retval = -ENODEV;
4704 goto fail;
4705 }
4706 if (r) {
4707 if (r != -ENODEV)
4708 dev_err(&udev->dev, "device descriptor read/64, error %d\n",
4709 r);
4710 retval = -EMSGSIZE;
4711 continue;
4712 }
4713#undef GET_DESCRIPTOR_BUFSIZE
4714 }
4715
4716
4717
4718
4719
4720
4721 if (udev->wusb == 0) {
4722 for (operations = 0; operations < SET_ADDRESS_TRIES; ++operations) {
4723 retval = hub_set_address(udev, devnum);
4724 if (retval >= 0)
4725 break;
4726 msleep(200);
4727 }
4728 if (retval < 0) {
4729 if (retval != -ENODEV)
4730 dev_err(&udev->dev, "device not accepting address %d, error %d\n",
4731 devnum, retval);
4732 goto fail;
4733 }
4734 if (udev->speed >= USB_SPEED_SUPER) {
4735 devnum = udev->devnum;
4736 dev_info(&udev->dev,
4737 "%s SuperSpeed%s%s USB device number %d using %s\n",
4738 (udev->config) ? "reset" : "new",
4739 (udev->speed == USB_SPEED_SUPER_PLUS) ?
4740 "Plus Gen 2" : " Gen 1",
4741 (udev->rx_lanes == 2 && udev->tx_lanes == 2) ?
4742 "x2" : "",
4743 devnum, driver_name);
4744 }
4745
4746
4747
4748
4749
4750 msleep(10);
4751
4752
4753
4754
4755 if (did_new_scheme)
4756 break;
4757 }
4758
4759 retval = usb_get_device_descriptor(udev, 8);
4760 if (retval < 8) {
4761 if (retval != -ENODEV)
4762 dev_err(&udev->dev,
4763 "device descriptor read/8, error %d\n",
4764 retval);
4765 if (retval >= 0)
4766 retval = -EMSGSIZE;
4767 } else {
4768 u32 delay;
4769
4770 retval = 0;
4771
4772 delay = udev->parent->hub_delay;
4773 udev->hub_delay = min_t(u32, delay,
4774 USB_TP_TRANSMISSION_DELAY_MAX);
4775 retval = usb_set_isoch_delay(udev);
4776 if (retval) {
4777 dev_dbg(&udev->dev,
4778 "Failed set isoch delay, error %d\n",
4779 retval);
4780 retval = 0;
4781 }
4782 break;
4783 }
4784 }
4785 if (retval)
4786 goto fail;
4787
4788
4789
4790
4791
4792
4793
4794 if ((udev->speed >= USB_SPEED_SUPER) &&
4795 (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
4796 dev_err(&udev->dev, "got a wrong device descriptor, "
4797 "warm reset device\n");
4798 hub_port_reset(hub, port1, udev,
4799 HUB_BH_RESET_TIME, true);
4800 retval = -EINVAL;
4801 goto fail;
4802 }
4803
4804 if (udev->descriptor.bMaxPacketSize0 == 0xff ||
4805 udev->speed >= USB_SPEED_SUPER)
4806 i = 512;
4807 else
4808 i = udev->descriptor.bMaxPacketSize0;
4809 if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
4810 if (udev->speed == USB_SPEED_LOW ||
4811 !(i == 8 || i == 16 || i == 32 || i == 64)) {
4812 dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
4813 retval = -EMSGSIZE;
4814 goto fail;
4815 }
4816 if (udev->speed == USB_SPEED_FULL)
4817 dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
4818 else
4819 dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
4820 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
4821 usb_ep0_reinit(udev);
4822 }
4823
4824 retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
4825 if (retval < (signed)sizeof(udev->descriptor)) {
4826 if (retval != -ENODEV)
4827 dev_err(&udev->dev, "device descriptor read/all, error %d\n",
4828 retval);
4829 if (retval >= 0)
4830 retval = -ENOMSG;
4831 goto fail;
4832 }
4833
4834 usb_detect_quirks(udev);
4835
4836 if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
4837 retval = usb_get_bos_descriptor(udev);
4838 if (!retval) {
4839 udev->lpm_capable = usb_device_supports_lpm(udev);
4840 usb_set_lpm_parameters(udev);
4841 }
4842 }
4843
4844 retval = 0;
4845
4846 if (hcd->driver->update_device)
4847 hcd->driver->update_device(hcd, udev);
4848 hub_set_initial_usb2_lpm_policy(udev);
4849fail:
4850 if (retval) {
4851 hub_port_disable(hub, port1, 0);
4852 update_devnum(udev, devnum);
4853 }
4854 mutex_unlock(hcd->address0_mutex);
4855 return retval;
4856}
4857
4858static void
4859check_highspeed(struct usb_hub *hub, struct usb_device *udev, int port1)
4860{
4861 struct usb_qualifier_descriptor *qual;
4862 int status;
4863
4864 if (udev->quirks & USB_QUIRK_DEVICE_QUALIFIER)
4865 return;
4866
4867 qual = kmalloc(sizeof *qual, GFP_KERNEL);
4868 if (qual == NULL)
4869 return;
4870
4871 status = usb_get_descriptor(udev, USB_DT_DEVICE_QUALIFIER, 0,
4872 qual, sizeof *qual);
4873 if (status == sizeof *qual) {
4874 dev_info(&udev->dev, "not running at top speed; "
4875 "connect to a high speed hub\n");
4876
4877 if (hub->has_indicators) {
4878 hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
4879 queue_delayed_work(system_power_efficient_wq,
4880 &hub->leds, 0);
4881 }
4882 }
4883 kfree(qual);
4884}
4885
4886static unsigned
4887hub_power_remaining(struct usb_hub *hub)
4888{
4889 struct usb_device *hdev = hub->hdev;
4890 int remaining;
4891 int port1;
4892
4893 if (!hub->limited_power)
4894 return 0;
4895
4896 remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
4897 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
4898 struct usb_port *port_dev = hub->ports[port1 - 1];
4899 struct usb_device *udev = port_dev->child;
4900 unsigned unit_load;
4901 int delta;
4902
4903 if (!udev)
4904 continue;
4905 if (hub_is_superspeed(udev))
4906 unit_load = 150;
4907 else
4908 unit_load = 100;
4909
4910
4911
4912
4913
4914 if (udev->actconfig)
4915 delta = usb_get_max_power(udev, udev->actconfig);
4916 else if (port1 != udev->bus->otg_port || hdev->parent)
4917 delta = unit_load;
4918 else
4919 delta = 8;
4920 if (delta > hub->mA_per_port)
4921 dev_warn(&port_dev->dev, "%dmA is over %umA budget!\n",
4922 delta, hub->mA_per_port);
4923 remaining -= delta;
4924 }
4925 if (remaining < 0) {
4926 dev_warn(hub->intfdev, "%dmA over power budget!\n",
4927 -remaining);
4928 remaining = 0;
4929 }
4930 return remaining;
4931}
4932
4933static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
4934 u16 portchange)
4935{
4936 int status = -ENODEV;
4937 int i;
4938 unsigned unit_load;
4939 struct usb_device *hdev = hub->hdev;
4940 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
4941 struct usb_port *port_dev = hub->ports[port1 - 1];
4942 struct usb_device *udev = port_dev->child;
4943 static int unreliable_port = -1;
4944
4945
4946 if (udev) {
4947 if (hcd->usb_phy && !hdev->parent)
4948 usb_phy_notify_disconnect(hcd->usb_phy, udev->speed);
4949 usb_disconnect(&port_dev->child);
4950 }
4951
4952
4953
4954
4955 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
4956 (portchange & USB_PORT_STAT_C_CONNECTION))
4957 clear_bit(port1, hub->removed_bits);
4958
4959 if (portchange & (USB_PORT_STAT_C_CONNECTION |
4960 USB_PORT_STAT_C_ENABLE)) {
4961 status = hub_port_debounce_be_stable(hub, port1);
4962 if (status < 0) {
4963 if (status != -ENODEV &&
4964 port1 != unreliable_port &&
4965 printk_ratelimit())
4966 dev_err(&port_dev->dev, "connect-debounce failed\n");
4967 portstatus &= ~USB_PORT_STAT_CONNECTION;
4968 unreliable_port = port1;
4969 } else {
4970 portstatus = status;
4971 }
4972 }
4973
4974
4975
4976
4977 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
4978 test_bit(port1, hub->removed_bits)) {
4979
4980
4981
4982
4983
4984 if (hub_is_port_power_switchable(hub)
4985 && !port_is_power_on(hub, portstatus)
4986 && !port_dev->port_owner)
4987 set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
4988
4989 if (portstatus & USB_PORT_STAT_ENABLE)
4990 goto done;
4991 return;
4992 }
4993 if (hub_is_superspeed(hub->hdev))
4994 unit_load = 150;
4995 else
4996 unit_load = 100;
4997
4998 status = 0;
4999 for (i = 0; i < SET_CONFIG_TRIES; i++) {
5000
5001
5002
5003
5004 udev = usb_alloc_dev(hdev, hdev->bus, port1);
5005 if (!udev) {
5006 dev_err(&port_dev->dev,
5007 "couldn't allocate usb_device\n");
5008 goto done;
5009 }
5010
5011 usb_set_device_state(udev, USB_STATE_POWERED);
5012 udev->bus_mA = hub->mA_per_port;
5013 udev->level = hdev->level + 1;
5014 udev->wusb = hub_is_wusb(hub);
5015
5016
5017 if (hub_is_superspeed(hub->hdev))
5018 udev->speed = USB_SPEED_SUPER;
5019 else
5020 udev->speed = USB_SPEED_UNKNOWN;
5021
5022 choose_devnum(udev);
5023 if (udev->devnum <= 0) {
5024 status = -ENOTCONN;
5025 goto loop;
5026 }
5027
5028
5029 usb_lock_port(port_dev);
5030 status = hub_port_init(hub, udev, port1, i);
5031 usb_unlock_port(port_dev);
5032 if (status < 0)
5033 goto loop;
5034
5035 if (udev->quirks & USB_QUIRK_DELAY_INIT)
5036 msleep(2000);
5037
5038
5039
5040
5041
5042
5043
5044 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
5045 && udev->bus_mA <= unit_load) {
5046 u16 devstat;
5047
5048 status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0,
5049 &devstat);
5050 if (status) {
5051 dev_dbg(&udev->dev, "get status %d ?\n", status);
5052 goto loop_disable;
5053 }
5054 if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
5055 dev_err(&udev->dev,
5056 "can't connect bus-powered hub "
5057 "to this port\n");
5058 if (hub->has_indicators) {
5059 hub->indicator[port1-1] =
5060 INDICATOR_AMBER_BLINK;
5061 queue_delayed_work(
5062 system_power_efficient_wq,
5063 &hub->leds, 0);
5064 }
5065 status = -ENOTCONN;
5066 goto loop_disable;
5067 }
5068 }
5069
5070
5071 if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
5072 && udev->speed == USB_SPEED_FULL
5073 && highspeed_hubs != 0)
5074 check_highspeed(hub, udev, port1);
5075
5076
5077
5078
5079
5080 status = 0;
5081
5082 mutex_lock(&usb_port_peer_mutex);
5083
5084
5085
5086
5087
5088 spin_lock_irq(&device_state_lock);
5089 if (hdev->state == USB_STATE_NOTATTACHED)
5090 status = -ENOTCONN;
5091 else
5092 port_dev->child = udev;
5093 spin_unlock_irq(&device_state_lock);
5094 mutex_unlock(&usb_port_peer_mutex);
5095
5096
5097 if (!status) {
5098 status = usb_new_device(udev);
5099 if (status) {
5100 mutex_lock(&usb_port_peer_mutex);
5101 spin_lock_irq(&device_state_lock);
5102 port_dev->child = NULL;
5103 spin_unlock_irq(&device_state_lock);
5104 mutex_unlock(&usb_port_peer_mutex);
5105 } else {
5106 if (hcd->usb_phy && !hdev->parent)
5107 usb_phy_notify_connect(hcd->usb_phy,
5108 udev->speed);
5109 }
5110 }
5111
5112 if (status)
5113 goto loop_disable;
5114
5115 status = hub_power_remaining(hub);
5116 if (status)
5117 dev_dbg(hub->intfdev, "%dmA power budget left\n", status);
5118
5119 return;
5120
5121loop_disable:
5122 hub_port_disable(hub, port1, 1);
5123loop:
5124 usb_ep0_reinit(udev);
5125 release_devnum(udev);
5126 hub_free_dev(udev);
5127 usb_put_dev(udev);
5128 if ((status == -ENOTCONN) || (status == -ENOTSUPP))
5129 break;
5130
5131
5132 if (i == (SET_CONFIG_TRIES / 2) - 1) {
5133 dev_info(&port_dev->dev, "attempt power cycle\n");
5134 usb_hub_set_port_power(hdev, hub, port1, false);
5135 msleep(2 * hub_power_on_good_delay(hub));
5136 usb_hub_set_port_power(hdev, hub, port1, true);
5137 msleep(hub_power_on_good_delay(hub));
5138 }
5139 }
5140 if (hub->hdev->parent ||
5141 !hcd->driver->port_handed_over ||
5142 !(hcd->driver->port_handed_over)(hcd, port1)) {
5143 if (status != -ENOTCONN && status != -ENODEV)
5144 dev_err(&port_dev->dev,
5145 "unable to enumerate USB device\n");
5146 }
5147
5148done:
5149 hub_port_disable(hub, port1, 1);
5150 if (hcd->driver->relinquish_port && !hub->hdev->parent) {
5151 if (status != -ENOTCONN && status != -ENODEV)
5152 hcd->driver->relinquish_port(hcd, port1);
5153 }
5154}
5155
5156
5157
5158
5159
5160
5161
5162
5163
5164static void hub_port_connect_change(struct usb_hub *hub, int port1,
5165 u16 portstatus, u16 portchange)
5166 __must_hold(&port_dev->status_lock)
5167{
5168 struct usb_port *port_dev = hub->ports[port1 - 1];
5169 struct usb_device *udev = port_dev->child;
5170 int status = -ENODEV;
5171
5172 dev_dbg(&port_dev->dev, "status %04x, change %04x, %s\n", portstatus,
5173 portchange, portspeed(hub, portstatus));
5174
5175 if (hub->has_indicators) {
5176 set_port_led(hub, port1, HUB_LED_AUTO);
5177 hub->indicator[port1-1] = INDICATOR_AUTO;
5178 }
5179
5180#ifdef CONFIG_USB_OTG
5181
5182 if (hub->hdev->bus->is_b_host)
5183 portchange &= ~(USB_PORT_STAT_C_CONNECTION |
5184 USB_PORT_STAT_C_ENABLE);
5185#endif
5186
5187
5188 if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
5189 udev->state != USB_STATE_NOTATTACHED) {
5190 if (portstatus & USB_PORT_STAT_ENABLE) {
5191 status = 0;
5192#ifdef CONFIG_PM
5193 } else if (udev->state == USB_STATE_SUSPENDED &&
5194 udev->persist_enabled) {
5195
5196
5197
5198 usb_unlock_port(port_dev);
5199 status = usb_remote_wakeup(udev);
5200 usb_lock_port(port_dev);
5201#endif
5202 } else {
5203 ;
5204 }
5205 }
5206 clear_bit(port1, hub->change_bits);
5207
5208
5209 if (status == 0)
5210 return;
5211
5212 usb_unlock_port(port_dev);
5213 hub_port_connect(hub, port1, portstatus, portchange);
5214 usb_lock_port(port_dev);
5215}
5216
5217
5218static void port_over_current_notify(struct usb_port *port_dev)
5219{
5220 char *envp[3];
5221 struct device *hub_dev;
5222 char *port_dev_path;
5223
5224 sysfs_notify(&port_dev->dev.kobj, NULL, "over_current_count");
5225
5226 hub_dev = port_dev->dev.parent;
5227
5228 if (!hub_dev)
5229 return;
5230
5231 port_dev_path = kobject_get_path(&port_dev->dev.kobj, GFP_KERNEL);
5232 if (!port_dev_path)
5233 return;
5234
5235 envp[0] = kasprintf(GFP_KERNEL, "OVER_CURRENT_PORT=%s", port_dev_path);
5236 if (!envp[0])
5237 goto exit_path;
5238
5239 envp[1] = kasprintf(GFP_KERNEL, "OVER_CURRENT_COUNT=%u",
5240 port_dev->over_current_count);
5241 if (!envp[1])
5242 goto exit;
5243
5244 envp[2] = NULL;
5245 kobject_uevent_env(&hub_dev->kobj, KOBJ_CHANGE, envp);
5246
5247 kfree(envp[1]);
5248exit:
5249 kfree(envp[0]);
5250exit_path:
5251 kfree(port_dev_path);
5252}
5253
5254static void port_event(struct usb_hub *hub, int port1)
5255 __must_hold(&port_dev->status_lock)
5256{
5257 int connect_change;
5258 struct usb_port *port_dev = hub->ports[port1 - 1];
5259 struct usb_device *udev = port_dev->child;
5260 struct usb_device *hdev = hub->hdev;
5261 u16 portstatus, portchange;
5262
5263 connect_change = test_bit(port1, hub->change_bits);
5264 clear_bit(port1, hub->event_bits);
5265 clear_bit(port1, hub->wakeup_bits);
5266
5267 if (hub_port_status(hub, port1, &portstatus, &portchange) < 0)
5268 return;
5269
5270 if (portchange & USB_PORT_STAT_C_CONNECTION) {
5271 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
5272 connect_change = 1;
5273 }
5274
5275 if (portchange & USB_PORT_STAT_C_ENABLE) {
5276 if (!connect_change)
5277 dev_dbg(&port_dev->dev, "enable change, status %08x\n",
5278 portstatus);
5279 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
5280
5281
5282
5283
5284
5285
5286 if (!(portstatus & USB_PORT_STAT_ENABLE)
5287 && !connect_change && udev) {
5288 dev_err(&port_dev->dev, "disabled by hub (EMI?), re-enabling...\n");
5289 connect_change = 1;
5290 }
5291 }
5292
5293 if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
5294 u16 status = 0, unused;
5295 port_dev->over_current_count++;
5296 port_over_current_notify(port_dev);
5297
5298 dev_dbg(&port_dev->dev, "over-current change #%u\n",
5299 port_dev->over_current_count);
5300 usb_clear_port_feature(hdev, port1,
5301 USB_PORT_FEAT_C_OVER_CURRENT);
5302 msleep(100);
5303 hub_power_on(hub, true);
5304 hub_port_status(hub, port1, &status, &unused);
5305 if (status & USB_PORT_STAT_OVERCURRENT)
5306 dev_err(&port_dev->dev, "over-current condition\n");
5307 }
5308
5309 if (portchange & USB_PORT_STAT_C_RESET) {
5310 dev_dbg(&port_dev->dev, "reset change\n");
5311 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_RESET);
5312 }
5313 if ((portchange & USB_PORT_STAT_C_BH_RESET)
5314 && hub_is_superspeed(hdev)) {
5315 dev_dbg(&port_dev->dev, "warm reset change\n");
5316 usb_clear_port_feature(hdev, port1,
5317 USB_PORT_FEAT_C_BH_PORT_RESET);
5318 }
5319 if (portchange & USB_PORT_STAT_C_LINK_STATE) {
5320 dev_dbg(&port_dev->dev, "link state change\n");
5321 usb_clear_port_feature(hdev, port1,
5322 USB_PORT_FEAT_C_PORT_LINK_STATE);
5323 }
5324 if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
5325 dev_warn(&port_dev->dev, "config error\n");
5326 usb_clear_port_feature(hdev, port1,
5327 USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
5328 }
5329
5330
5331 if (!pm_runtime_active(&port_dev->dev))
5332 return;
5333
5334 if (hub_handle_remote_wakeup(hub, port1, portstatus, portchange))
5335 connect_change = 1;
5336
5337
5338
5339
5340
5341 if (hub_port_warm_reset_required(hub, port1, portstatus)) {
5342 dev_dbg(&port_dev->dev, "do warm reset\n");
5343 if (!udev || !(portstatus & USB_PORT_STAT_CONNECTION)
5344 || udev->state == USB_STATE_NOTATTACHED) {
5345 if (hub_port_reset(hub, port1, NULL,
5346 HUB_BH_RESET_TIME, true) < 0)
5347 hub_port_disable(hub, port1, 1);
5348 } else {
5349 usb_unlock_port(port_dev);
5350 usb_lock_device(udev);
5351 usb_reset_device(udev);
5352 usb_unlock_device(udev);
5353 usb_lock_port(port_dev);
5354 connect_change = 0;
5355 }
5356 }
5357
5358 if (connect_change)
5359 hub_port_connect_change(hub, port1, portstatus, portchange);
5360}
5361
5362static void hub_event(struct work_struct *work)
5363{
5364 struct usb_device *hdev;
5365 struct usb_interface *intf;
5366 struct usb_hub *hub;
5367 struct device *hub_dev;
5368 u16 hubstatus;
5369 u16 hubchange;
5370 int i, ret;
5371
5372 hub = container_of(work, struct usb_hub, events);
5373 hdev = hub->hdev;
5374 hub_dev = hub->intfdev;
5375 intf = to_usb_interface(hub_dev);
5376
5377 dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
5378 hdev->state, hdev->maxchild,
5379
5380 (u16) hub->change_bits[0],
5381 (u16) hub->event_bits[0]);
5382
5383
5384
5385 usb_lock_device(hdev);
5386 if (unlikely(hub->disconnected))
5387 goto out_hdev_lock;
5388
5389
5390 if (hdev->state == USB_STATE_NOTATTACHED) {
5391 hub->error = -ENODEV;
5392 hub_quiesce(hub, HUB_DISCONNECT);
5393 goto out_hdev_lock;
5394 }
5395
5396
5397 ret = usb_autopm_get_interface(intf);
5398 if (ret) {
5399 dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
5400 goto out_hdev_lock;
5401 }
5402
5403
5404 if (hub->quiescing)
5405 goto out_autopm;
5406
5407 if (hub->error) {
5408 dev_dbg(hub_dev, "resetting for error %d\n", hub->error);
5409
5410 ret = usb_reset_device(hdev);
5411 if (ret) {
5412 dev_dbg(hub_dev, "error resetting hub: %d\n", ret);
5413 goto out_autopm;
5414 }
5415
5416 hub->nerrors = 0;
5417 hub->error = 0;
5418 }
5419
5420
5421 for (i = 1; i <= hdev->maxchild; i++) {
5422 struct usb_port *port_dev = hub->ports[i - 1];
5423
5424 if (test_bit(i, hub->event_bits)
5425 || test_bit(i, hub->change_bits)
5426 || test_bit(i, hub->wakeup_bits)) {
5427
5428
5429
5430
5431
5432
5433
5434
5435
5436 pm_runtime_get_noresume(&port_dev->dev);
5437 pm_runtime_barrier(&port_dev->dev);
5438 usb_lock_port(port_dev);
5439 port_event(hub, i);
5440 usb_unlock_port(port_dev);
5441 pm_runtime_put_sync(&port_dev->dev);
5442 }
5443 }
5444
5445
5446 if (test_and_clear_bit(0, hub->event_bits) == 0)
5447 ;
5448 else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
5449 dev_err(hub_dev, "get_hub_status failed\n");
5450 else {
5451 if (hubchange & HUB_CHANGE_LOCAL_POWER) {
5452 dev_dbg(hub_dev, "power change\n");
5453 clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
5454 if (hubstatus & HUB_STATUS_LOCAL_POWER)
5455
5456 hub->limited_power = 1;
5457 else
5458 hub->limited_power = 0;
5459 }
5460 if (hubchange & HUB_CHANGE_OVERCURRENT) {
5461 u16 status = 0;
5462 u16 unused;
5463
5464 dev_dbg(hub_dev, "over-current change\n");
5465 clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
5466 msleep(500);
5467 hub_power_on(hub, true);
5468 hub_hub_status(hub, &status, &unused);
5469 if (status & HUB_STATUS_OVERCURRENT)
5470 dev_err(hub_dev, "over-current condition\n");
5471 }
5472 }
5473
5474out_autopm:
5475
5476 usb_autopm_put_interface_no_suspend(intf);
5477out_hdev_lock:
5478 usb_unlock_device(hdev);
5479
5480
5481 usb_autopm_put_interface(intf);
5482 kref_put(&hub->kref, hub_release);
5483}
5484
5485static const struct usb_device_id hub_id_table[] = {
5486 { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
5487 | USB_DEVICE_ID_MATCH_INT_CLASS,
5488 .idVendor = USB_VENDOR_GENESYS_LOGIC,
5489 .bInterfaceClass = USB_CLASS_HUB,
5490 .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
5491 { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
5492 .bDeviceClass = USB_CLASS_HUB},
5493 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
5494 .bInterfaceClass = USB_CLASS_HUB},
5495 { }
5496};
5497
5498MODULE_DEVICE_TABLE(usb, hub_id_table);
5499
5500static struct usb_driver hub_driver = {
5501 .name = "hub",
5502 .probe = hub_probe,
5503 .disconnect = hub_disconnect,
5504 .suspend = hub_suspend,
5505 .resume = hub_resume,
5506 .reset_resume = hub_reset_resume,
5507 .pre_reset = hub_pre_reset,
5508 .post_reset = hub_post_reset,
5509 .unlocked_ioctl = hub_ioctl,
5510 .id_table = hub_id_table,
5511 .supports_autosuspend = 1,
5512};
5513
5514int usb_hub_init(void)
5515{
5516 if (usb_register(&hub_driver) < 0) {
5517 printk(KERN_ERR "%s: can't register hub driver\n",
5518 usbcore_name);
5519 return -1;
5520 }
5521
5522
5523
5524
5525
5526
5527
5528 hub_wq = alloc_workqueue("usb_hub_wq", WQ_FREEZABLE, 0);
5529 if (hub_wq)
5530 return 0;
5531
5532
5533 usb_deregister(&hub_driver);
5534 pr_err("%s: can't allocate workqueue for usb hub\n", usbcore_name);
5535
5536 return -1;
5537}
5538
5539void usb_hub_cleanup(void)
5540{
5541 destroy_workqueue(hub_wq);
5542
5543
5544
5545
5546
5547
5548
5549
5550 usb_deregister(&hub_driver);
5551}
5552
5553static int descriptors_changed(struct usb_device *udev,
5554 struct usb_device_descriptor *old_device_descriptor,
5555 struct usb_host_bos *old_bos)
5556{
5557 int changed = 0;
5558 unsigned index;
5559 unsigned serial_len = 0;
5560 unsigned len;
5561 unsigned old_length;
5562 int length;
5563 char *buf;
5564
5565 if (memcmp(&udev->descriptor, old_device_descriptor,
5566 sizeof(*old_device_descriptor)) != 0)
5567 return 1;
5568
5569 if ((old_bos && !udev->bos) || (!old_bos && udev->bos))
5570 return 1;
5571 if (udev->bos) {
5572 len = le16_to_cpu(udev->bos->desc->wTotalLength);
5573 if (len != le16_to_cpu(old_bos->desc->wTotalLength))
5574 return 1;
5575 if (memcmp(udev->bos->desc, old_bos->desc, len))
5576 return 1;
5577 }
5578
5579
5580
5581
5582
5583
5584
5585 if (udev->serial)
5586 serial_len = strlen(udev->serial) + 1;
5587
5588 len = serial_len;
5589 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
5590 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
5591 len = max(len, old_length);
5592 }
5593
5594 buf = kmalloc(len, GFP_NOIO);
5595 if (!buf)
5596
5597 return 1;
5598
5599 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
5600 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
5601 length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
5602 old_length);
5603 if (length != old_length) {
5604 dev_dbg(&udev->dev, "config index %d, error %d\n",
5605 index, length);
5606 changed = 1;
5607 break;
5608 }
5609 if (memcmp(buf, udev->rawdescriptors[index], old_length)
5610 != 0) {
5611 dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
5612 index,
5613 ((struct usb_config_descriptor *) buf)->
5614 bConfigurationValue);
5615 changed = 1;
5616 break;
5617 }
5618 }
5619
5620 if (!changed && serial_len) {
5621 length = usb_string(udev, udev->descriptor.iSerialNumber,
5622 buf, serial_len);
5623 if (length + 1 != serial_len) {
5624 dev_dbg(&udev->dev, "serial string error %d\n",
5625 length);
5626 changed = 1;
5627 } else if (memcmp(buf, udev->serial, length) != 0) {
5628 dev_dbg(&udev->dev, "serial string changed\n");
5629 changed = 1;
5630 }
5631 }
5632
5633 kfree(buf);
5634 return changed;
5635}
5636
5637
5638
5639
5640
5641
5642
5643
5644
5645
5646
5647
5648
5649
5650
5651
5652
5653
5654
5655
5656
5657
5658
5659
5660
5661
5662
5663
5664
5665
5666
5667
5668
5669
5670
5671static int usb_reset_and_verify_device(struct usb_device *udev)
5672{
5673 struct usb_device *parent_hdev = udev->parent;
5674 struct usb_hub *parent_hub;
5675 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
5676 struct usb_device_descriptor descriptor = udev->descriptor;
5677 struct usb_host_bos *bos;
5678 int i, j, ret = 0;
5679 int port1 = udev->portnum;
5680
5681 if (udev->state == USB_STATE_NOTATTACHED ||
5682 udev->state == USB_STATE_SUSPENDED) {
5683 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5684 udev->state);
5685 return -EINVAL;
5686 }
5687
5688 if (!parent_hdev)
5689 return -EISDIR;
5690
5691 parent_hub = usb_hub_to_struct_hub(parent_hdev);
5692
5693
5694
5695
5696 usb_disable_usb2_hardware_lpm(udev);
5697
5698
5699
5700
5701
5702 ret = usb_unlocked_disable_lpm(udev);
5703 if (ret) {
5704 dev_err(&udev->dev, "%s Failed to disable LPM\n", __func__);
5705 goto re_enumerate_no_bos;
5706 }
5707
5708 bos = udev->bos;
5709 udev->bos = NULL;
5710
5711 for (i = 0; i < SET_CONFIG_TRIES; ++i) {
5712
5713
5714
5715 usb_ep0_reinit(udev);
5716 ret = hub_port_init(parent_hub, udev, port1, i);
5717 if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
5718 break;
5719 }
5720
5721 if (ret < 0)
5722 goto re_enumerate;
5723
5724
5725 if (descriptors_changed(udev, &descriptor, bos)) {
5726 dev_info(&udev->dev, "device firmware changed\n");
5727 udev->descriptor = descriptor;
5728 goto re_enumerate;
5729 }
5730
5731
5732 if (!udev->actconfig)
5733 goto done;
5734
5735 mutex_lock(hcd->bandwidth_mutex);
5736 ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
5737 if (ret < 0) {
5738 dev_warn(&udev->dev,
5739 "Busted HC? Not enough HCD resources for "
5740 "old configuration.\n");
5741 mutex_unlock(hcd->bandwidth_mutex);
5742 goto re_enumerate;
5743 }
5744 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
5745 USB_REQ_SET_CONFIGURATION, 0,
5746 udev->actconfig->desc.bConfigurationValue, 0,
5747 NULL, 0, USB_CTRL_SET_TIMEOUT);
5748 if (ret < 0) {
5749 dev_err(&udev->dev,
5750 "can't restore configuration #%d (error=%d)\n",
5751 udev->actconfig->desc.bConfigurationValue, ret);
5752 mutex_unlock(hcd->bandwidth_mutex);
5753 goto re_enumerate;
5754 }
5755 mutex_unlock(hcd->bandwidth_mutex);
5756 usb_set_device_state(udev, USB_STATE_CONFIGURED);
5757
5758
5759
5760
5761
5762
5763
5764 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
5765 struct usb_host_config *config = udev->actconfig;
5766 struct usb_interface *intf = config->interface[i];
5767 struct usb_interface_descriptor *desc;
5768
5769 desc = &intf->cur_altsetting->desc;
5770 if (desc->bAlternateSetting == 0) {
5771 usb_disable_interface(udev, intf, true);
5772 usb_enable_interface(udev, intf, true);
5773 ret = 0;
5774 } else {
5775
5776
5777
5778
5779 intf->resetting_device = 1;
5780 ret = usb_set_interface(udev, desc->bInterfaceNumber,
5781 desc->bAlternateSetting);
5782 intf->resetting_device = 0;
5783 }
5784 if (ret < 0) {
5785 dev_err(&udev->dev, "failed to restore interface %d "
5786 "altsetting %d (error=%d)\n",
5787 desc->bInterfaceNumber,
5788 desc->bAlternateSetting,
5789 ret);
5790 goto re_enumerate;
5791 }
5792
5793 for (j = 0; j < intf->cur_altsetting->desc.bNumEndpoints; j++)
5794 intf->cur_altsetting->endpoint[j].streams = 0;
5795 }
5796
5797done:
5798
5799 usb_enable_usb2_hardware_lpm(udev);
5800 usb_unlocked_enable_lpm(udev);
5801 usb_enable_ltm(udev);
5802 usb_release_bos_descriptor(udev);
5803 udev->bos = bos;
5804 return 0;
5805
5806re_enumerate:
5807 usb_release_bos_descriptor(udev);
5808 udev->bos = bos;
5809re_enumerate_no_bos:
5810
5811 hub_port_logical_disconnect(parent_hub, port1);
5812 return -ENODEV;
5813}
5814
5815
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825
5826
5827
5828
5829
5830
5831
5832
5833
5834
5835
5836int usb_reset_device(struct usb_device *udev)
5837{
5838 int ret;
5839 int i;
5840 unsigned int noio_flag;
5841 struct usb_port *port_dev;
5842 struct usb_host_config *config = udev->actconfig;
5843 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
5844
5845 if (udev->state == USB_STATE_NOTATTACHED ||
5846 udev->state == USB_STATE_SUSPENDED) {
5847 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5848 udev->state);
5849 return -EINVAL;
5850 }
5851
5852 if (!udev->parent) {
5853
5854 dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
5855 return -EISDIR;
5856 }
5857
5858 port_dev = hub->ports[udev->portnum - 1];
5859
5860
5861
5862
5863
5864
5865
5866
5867
5868
5869 noio_flag = memalloc_noio_save();
5870
5871
5872 usb_autoresume_device(udev);
5873
5874 if (config) {
5875 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
5876 struct usb_interface *cintf = config->interface[i];
5877 struct usb_driver *drv;
5878 int unbind = 0;
5879
5880 if (cintf->dev.driver) {
5881 drv = to_usb_driver(cintf->dev.driver);
5882 if (drv->pre_reset && drv->post_reset)
5883 unbind = (drv->pre_reset)(cintf);
5884 else if (cintf->condition ==
5885 USB_INTERFACE_BOUND)
5886 unbind = 1;
5887 if (unbind)
5888 usb_forced_unbind_intf(cintf);
5889 }
5890 }
5891 }
5892
5893 usb_lock_port(port_dev);
5894 ret = usb_reset_and_verify_device(udev);
5895 usb_unlock_port(port_dev);
5896
5897 if (config) {
5898 for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
5899 struct usb_interface *cintf = config->interface[i];
5900 struct usb_driver *drv;
5901 int rebind = cintf->needs_binding;
5902
5903 if (!rebind && cintf->dev.driver) {
5904 drv = to_usb_driver(cintf->dev.driver);
5905 if (drv->post_reset)
5906 rebind = (drv->post_reset)(cintf);
5907 else if (cintf->condition ==
5908 USB_INTERFACE_BOUND)
5909 rebind = 1;
5910 if (rebind)
5911 cintf->needs_binding = 1;
5912 }
5913 }
5914
5915
5916 if (ret == 0)
5917 usb_unbind_and_rebind_marked_interfaces(udev);
5918 }
5919
5920 usb_autosuspend_device(udev);
5921 memalloc_noio_restore(noio_flag);
5922 return ret;
5923}
5924EXPORT_SYMBOL_GPL(usb_reset_device);
5925
5926
5927
5928
5929
5930
5931
5932
5933
5934
5935
5936
5937
5938
5939
5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955void usb_queue_reset_device(struct usb_interface *iface)
5956{
5957 if (schedule_work(&iface->reset_ws))
5958 usb_get_intf(iface);
5959}
5960EXPORT_SYMBOL_GPL(usb_queue_reset_device);
5961
5962
5963
5964
5965
5966
5967
5968
5969
5970
5971
5972
5973
5974
5975struct usb_device *usb_hub_find_child(struct usb_device *hdev,
5976 int port1)
5977{
5978 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
5979
5980 if (port1 < 1 || port1 > hdev->maxchild)
5981 return NULL;
5982 return hub->ports[port1 - 1]->child;
5983}
5984EXPORT_SYMBOL_GPL(usb_hub_find_child);
5985
5986void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
5987 struct usb_hub_descriptor *desc)
5988{
5989 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
5990 enum usb_port_connect_type connect_type;
5991 int i;
5992
5993 if (!hub)
5994 return;
5995
5996 if (!hub_is_superspeed(hdev)) {
5997 for (i = 1; i <= hdev->maxchild; i++) {
5998 struct usb_port *port_dev = hub->ports[i - 1];
5999
6000 connect_type = port_dev->connect_type;
6001 if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
6002 u8 mask = 1 << (i%8);
6003
6004 if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
6005 dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
6006 desc->u.hs.DeviceRemovable[i/8] |= mask;
6007 }
6008 }
6009 }
6010 } else {
6011 u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);
6012
6013 for (i = 1; i <= hdev->maxchild; i++) {
6014 struct usb_port *port_dev = hub->ports[i - 1];
6015
6016 connect_type = port_dev->connect_type;
6017 if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
6018 u16 mask = 1 << i;
6019
6020 if (!(port_removable & mask)) {
6021 dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
6022 port_removable |= mask;
6023 }
6024 }
6025 }
6026
6027 desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
6028 }
6029}
6030
6031#ifdef CONFIG_ACPI
6032
6033
6034
6035
6036
6037
6038
6039
6040acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
6041 int port1)
6042{
6043 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
6044
6045 if (!hub)
6046 return NULL;
6047
6048 return ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
6049}
6050#endif
6051