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