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