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#define PORT_RESET_TRIES 5
2709#define SET_ADDRESS_TRIES 2
2710#define GET_DESCRIPTOR_TRIES 2
2711#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))
2712#define USE_NEW_SCHEME(i, scheme) ((i) / 2 == (int)(scheme))
2713
2714#define HUB_ROOT_RESET_TIME 60
2715#define HUB_SHORT_RESET_TIME 10
2716#define HUB_BH_RESET_TIME 50
2717#define HUB_LONG_RESET_TIME 200
2718#define HUB_RESET_TIMEOUT 800
2719
2720
2721
2722
2723
2724
2725
2726
2727static bool use_new_scheme(struct usb_device *udev, int retry,
2728 struct usb_port *port_dev)
2729{
2730 int old_scheme_first_port =
2731 port_dev->quirks & USB_PORT_QUIRK_OLD_SCHEME;
2732
2733 if (udev->speed >= USB_SPEED_SUPER)
2734 return false;
2735
2736 return USE_NEW_SCHEME(retry, old_scheme_first_port || old_scheme_first);
2737}
2738
2739
2740
2741
2742static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
2743 u16 portstatus)
2744{
2745 u16 link_state;
2746
2747 if (!hub_is_superspeed(hub->hdev))
2748 return false;
2749
2750 if (test_bit(port1, hub->warm_reset_bits))
2751 return true;
2752
2753 link_state = portstatus & USB_PORT_STAT_LINK_STATE;
2754 return link_state == USB_SS_PORT_LS_SS_INACTIVE
2755 || link_state == USB_SS_PORT_LS_COMP_MOD;
2756}
2757
2758static int hub_port_wait_reset(struct usb_hub *hub, int port1,
2759 struct usb_device *udev, unsigned int delay, bool warm)
2760{
2761 int delay_time, ret;
2762 u16 portstatus;
2763 u16 portchange;
2764 u32 ext_portstatus = 0;
2765
2766 for (delay_time = 0;
2767 delay_time < HUB_RESET_TIMEOUT;
2768 delay_time += delay) {
2769
2770 msleep(delay);
2771
2772
2773 if (hub_is_superspeedplus(hub->hdev))
2774 ret = hub_ext_port_status(hub, port1,
2775 HUB_EXT_PORT_STATUS,
2776 &portstatus, &portchange,
2777 &ext_portstatus);
2778 else
2779 ret = hub_port_status(hub, port1, &portstatus,
2780 &portchange);
2781 if (ret < 0)
2782 return ret;
2783
2784
2785
2786
2787
2788
2789
2790
2791 if (!(portstatus & USB_PORT_STAT_RESET) &&
2792 (portstatus & USB_PORT_STAT_CONNECTION))
2793 break;
2794
2795
2796 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
2797 delay = HUB_LONG_RESET_TIME;
2798
2799 dev_dbg(&hub->ports[port1 - 1]->dev,
2800 "not %sreset yet, waiting %dms\n",
2801 warm ? "warm " : "", delay);
2802 }
2803
2804 if ((portstatus & USB_PORT_STAT_RESET))
2805 return -EBUSY;
2806
2807 if (hub_port_warm_reset_required(hub, port1, portstatus))
2808 return -ENOTCONN;
2809
2810
2811 if (!(portstatus & USB_PORT_STAT_CONNECTION))
2812 return -ENOTCONN;
2813
2814
2815
2816
2817
2818 if (!hub_is_superspeed(hub->hdev) &&
2819 (portchange & USB_PORT_STAT_C_CONNECTION)) {
2820 usb_clear_port_feature(hub->hdev, port1,
2821 USB_PORT_FEAT_C_CONNECTION);
2822 return -EAGAIN;
2823 }
2824
2825 if (!(portstatus & USB_PORT_STAT_ENABLE))
2826 return -EBUSY;
2827
2828 if (!udev)
2829 return 0;
2830
2831 if (hub_is_superspeedplus(hub->hdev)) {
2832
2833 udev->rx_lanes = USB_EXT_PORT_RX_LANES(ext_portstatus) + 1;
2834 udev->tx_lanes = USB_EXT_PORT_TX_LANES(ext_portstatus) + 1;
2835 } else {
2836 udev->rx_lanes = 1;
2837 udev->tx_lanes = 1;
2838 }
2839 if (hub_is_wusb(hub))
2840 udev->speed = USB_SPEED_WIRELESS;
2841 else if (hub_is_superspeedplus(hub->hdev) &&
2842 port_speed_is_ssp(hub->hdev, ext_portstatus &
2843 USB_EXT_PORT_STAT_RX_SPEED_ID))
2844 udev->speed = USB_SPEED_SUPER_PLUS;
2845 else if (hub_is_superspeed(hub->hdev))
2846 udev->speed = USB_SPEED_SUPER;
2847 else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
2848 udev->speed = USB_SPEED_HIGH;
2849 else if (portstatus & USB_PORT_STAT_LOW_SPEED)
2850 udev->speed = USB_SPEED_LOW;
2851 else
2852 udev->speed = USB_SPEED_FULL;
2853 return 0;
2854}
2855
2856
2857static int hub_port_reset(struct usb_hub *hub, int port1,
2858 struct usb_device *udev, unsigned int delay, bool warm)
2859{
2860 int i, status;
2861 u16 portchange, portstatus;
2862 struct usb_port *port_dev = hub->ports[port1 - 1];
2863 int reset_recovery_time;
2864
2865 if (!hub_is_superspeed(hub->hdev)) {
2866 if (warm) {
2867 dev_err(hub->intfdev, "only USB3 hub support "
2868 "warm reset\n");
2869 return -EINVAL;
2870 }
2871
2872
2873
2874 down_read(&ehci_cf_port_reset_rwsem);
2875 } else if (!warm) {
2876
2877
2878
2879
2880 if (hub_port_status(hub, port1, &portstatus, &portchange) == 0)
2881 if (hub_port_warm_reset_required(hub, port1,
2882 portstatus))
2883 warm = true;
2884 }
2885 clear_bit(port1, hub->warm_reset_bits);
2886
2887
2888 for (i = 0; i < PORT_RESET_TRIES; i++) {
2889 status = set_port_feature(hub->hdev, port1, (warm ?
2890 USB_PORT_FEAT_BH_PORT_RESET :
2891 USB_PORT_FEAT_RESET));
2892 if (status == -ENODEV) {
2893 ;
2894 } else if (status) {
2895 dev_err(&port_dev->dev,
2896 "cannot %sreset (err = %d)\n",
2897 warm ? "warm " : "", status);
2898 } else {
2899 status = hub_port_wait_reset(hub, port1, udev, delay,
2900 warm);
2901 if (status && status != -ENOTCONN && status != -ENODEV)
2902 dev_dbg(hub->intfdev,
2903 "port_wait_reset: err = %d\n",
2904 status);
2905 }
2906
2907
2908 if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
2909 usb_clear_port_feature(hub->hdev, port1,
2910 USB_PORT_FEAT_C_RESET);
2911
2912 if (!hub_is_superspeed(hub->hdev))
2913 goto done;
2914
2915 usb_clear_port_feature(hub->hdev, port1,
2916 USB_PORT_FEAT_C_BH_PORT_RESET);
2917 usb_clear_port_feature(hub->hdev, port1,
2918 USB_PORT_FEAT_C_PORT_LINK_STATE);
2919
2920 if (udev)
2921 usb_clear_port_feature(hub->hdev, port1,
2922 USB_PORT_FEAT_C_CONNECTION);
2923
2924
2925
2926
2927
2928 if (hub_port_status(hub, port1,
2929 &portstatus, &portchange) < 0)
2930 goto done;
2931
2932 if (!hub_port_warm_reset_required(hub, port1,
2933 portstatus))
2934 goto done;
2935
2936
2937
2938
2939
2940 if (!warm) {
2941 dev_dbg(&port_dev->dev,
2942 "hot reset failed, warm reset\n");
2943 warm = true;
2944 }
2945 }
2946
2947 dev_dbg(&port_dev->dev,
2948 "not enabled, trying %sreset again...\n",
2949 warm ? "warm " : "");
2950 delay = HUB_LONG_RESET_TIME;
2951 }
2952
2953 dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
2954
2955done:
2956 if (status == 0) {
2957 if (port_dev->quirks & USB_PORT_QUIRK_FAST_ENUM)
2958 usleep_range(10000, 12000);
2959 else {
2960
2961 reset_recovery_time = 10 + 40;
2962
2963
2964 if (hub->hdev->quirks & USB_QUIRK_HUB_SLOW_RESET)
2965 reset_recovery_time += 100;
2966
2967 msleep(reset_recovery_time);
2968 }
2969
2970 if (udev) {
2971 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2972
2973 update_devnum(udev, 0);
2974
2975
2976
2977 if (hcd->driver->reset_device)
2978 hcd->driver->reset_device(hcd, udev);
2979
2980 usb_set_device_state(udev, USB_STATE_DEFAULT);
2981 }
2982 } else {
2983 if (udev)
2984 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2985 }
2986
2987 if (!hub_is_superspeed(hub->hdev))
2988 up_read(&ehci_cf_port_reset_rwsem);
2989
2990 return status;
2991}
2992
2993
2994static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
2995{
2996 int ret = 0;
2997
2998 if (hub_is_superspeed(hub->hdev)) {
2999 if (portstatus & USB_SS_PORT_STAT_POWER)
3000 ret = 1;
3001 } else {
3002 if (portstatus & USB_PORT_STAT_POWER)
3003 ret = 1;
3004 }
3005
3006 return ret;
3007}
3008
3009static void usb_lock_port(struct usb_port *port_dev)
3010 __acquires(&port_dev->status_lock)
3011{
3012 mutex_lock(&port_dev->status_lock);
3013 __acquire(&port_dev->status_lock);
3014}
3015
3016static void usb_unlock_port(struct usb_port *port_dev)
3017 __releases(&port_dev->status_lock)
3018{
3019 mutex_unlock(&port_dev->status_lock);
3020 __release(&port_dev->status_lock);
3021}
3022
3023#ifdef CONFIG_PM
3024
3025
3026static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
3027{
3028 int ret = 0;
3029
3030 if (hub_is_superspeed(hub->hdev)) {
3031 if ((portstatus & USB_PORT_STAT_LINK_STATE)
3032 == USB_SS_PORT_LS_U3)
3033 ret = 1;
3034 } else {
3035 if (portstatus & USB_PORT_STAT_SUSPEND)
3036 ret = 1;
3037 }
3038
3039 return ret;
3040}
3041
3042
3043
3044
3045static int check_port_resume_type(struct usb_device *udev,
3046 struct usb_hub *hub, int port1,
3047 int status, u16 portchange, u16 portstatus)
3048{
3049 struct usb_port *port_dev = hub->ports[port1 - 1];
3050 int retries = 3;
3051
3052 retry:
3053
3054 if (status == 0 && udev->reset_resume
3055 && hub_port_warm_reset_required(hub, port1, portstatus)) {
3056 ;
3057 }
3058
3059 else if (status || port_is_suspended(hub, portstatus) ||
3060 !port_is_power_on(hub, portstatus)) {
3061 if (status >= 0)
3062 status = -ENODEV;
3063 } else if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
3064 if (retries--) {
3065 usleep_range(200, 300);
3066 status = hub_port_status(hub, port1, &portstatus,
3067 &portchange);
3068 goto retry;
3069 }
3070 status = -ENODEV;
3071 }
3072
3073
3074
3075
3076 else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
3077 if (udev->persist_enabled)
3078 udev->reset_resume = 1;
3079 else
3080 status = -ENODEV;
3081 }
3082
3083 if (status) {
3084 dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n",
3085 portchange, portstatus, status);
3086 } else if (udev->reset_resume) {
3087
3088
3089 if (portchange & USB_PORT_STAT_C_CONNECTION)
3090 usb_clear_port_feature(hub->hdev, port1,
3091 USB_PORT_FEAT_C_CONNECTION);
3092 if (portchange & USB_PORT_STAT_C_ENABLE)
3093 usb_clear_port_feature(hub->hdev, port1,
3094 USB_PORT_FEAT_C_ENABLE);
3095
3096
3097
3098
3099
3100
3101
3102
3103 clear_bit(port1, hub->change_bits);
3104 }
3105
3106 return status;
3107}
3108
3109int usb_disable_ltm(struct usb_device *udev)
3110{
3111 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3112
3113
3114 if (!usb_device_supports_ltm(hcd->self.root_hub) ||
3115 !usb_device_supports_ltm(udev))
3116 return 0;
3117
3118
3119
3120
3121 if (!udev->actconfig)
3122 return 0;
3123
3124 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3125 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
3126 USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
3127 USB_CTRL_SET_TIMEOUT);
3128}
3129EXPORT_SYMBOL_GPL(usb_disable_ltm);
3130
3131void usb_enable_ltm(struct usb_device *udev)
3132{
3133 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3134
3135
3136 if (!usb_device_supports_ltm(hcd->self.root_hub) ||
3137 !usb_device_supports_ltm(udev))
3138 return;
3139
3140
3141
3142
3143 if (!udev->actconfig)
3144 return;
3145
3146 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3147 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
3148 USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
3149 USB_CTRL_SET_TIMEOUT);
3150}
3151EXPORT_SYMBOL_GPL(usb_enable_ltm);
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163static int usb_enable_remote_wakeup(struct usb_device *udev)
3164{
3165 if (udev->speed < USB_SPEED_SUPER)
3166 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3167 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
3168 USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
3169 USB_CTRL_SET_TIMEOUT);
3170 else
3171 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3172 USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
3173 USB_INTRF_FUNC_SUSPEND,
3174 USB_INTRF_FUNC_SUSPEND_RW |
3175 USB_INTRF_FUNC_SUSPEND_LP,
3176 NULL, 0, USB_CTRL_SET_TIMEOUT);
3177}
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189static int usb_disable_remote_wakeup(struct usb_device *udev)
3190{
3191 if (udev->speed < USB_SPEED_SUPER)
3192 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3193 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
3194 USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
3195 USB_CTRL_SET_TIMEOUT);
3196 else
3197 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3198 USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
3199 USB_INTRF_FUNC_SUSPEND, 0, NULL, 0,
3200 USB_CTRL_SET_TIMEOUT);
3201}
3202
3203
3204unsigned usb_wakeup_enabled_descendants(struct usb_device *udev)
3205{
3206 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
3207
3208 return udev->do_remote_wakeup +
3209 (hub ? hub->wakeup_enabled_descendants : 0);
3210}
3211EXPORT_SYMBOL_GPL(usb_wakeup_enabled_descendants);
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
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
3261int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
3262{
3263 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
3264 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
3265 int port1 = udev->portnum;
3266 int status;
3267 bool really_suspend = true;
3268
3269 usb_lock_port(port_dev);
3270
3271
3272
3273
3274
3275
3276
3277 if (udev->do_remote_wakeup) {
3278 status = usb_enable_remote_wakeup(udev);
3279 if (status) {
3280 dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
3281 status);
3282
3283 if (PMSG_IS_AUTO(msg))
3284 goto err_wakeup;
3285 }
3286 }
3287
3288
3289 usb_disable_usb2_hardware_lpm(udev);
3290
3291 if (usb_disable_ltm(udev)) {
3292 dev_err(&udev->dev, "Failed to disable LTM before suspend\n");
3293 status = -ENOMEM;
3294 if (PMSG_IS_AUTO(msg))
3295 goto err_ltm;
3296 }
3297
3298
3299 if (hub_is_superspeed(hub->hdev))
3300 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313 else if (PMSG_IS_AUTO(msg) || usb_wakeup_enabled_descendants(udev) > 0)
3314 status = set_port_feature(hub->hdev, port1,
3315 USB_PORT_FEAT_SUSPEND);
3316 else {
3317 really_suspend = false;
3318 status = 0;
3319 }
3320 if (status) {
3321 dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status);
3322
3323
3324 usb_enable_ltm(udev);
3325 err_ltm:
3326
3327 usb_enable_usb2_hardware_lpm(udev);
3328
3329 if (udev->do_remote_wakeup)
3330 (void) usb_disable_remote_wakeup(udev);
3331 err_wakeup:
3332
3333
3334 if (!PMSG_IS_AUTO(msg))
3335 status = 0;
3336 } else {
3337 dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
3338 (PMSG_IS_AUTO(msg) ? "auto-" : ""),
3339 udev->do_remote_wakeup);
3340 if (really_suspend) {
3341 udev->port_is_suspended = 1;
3342
3343
3344 msleep(10);
3345 }
3346 usb_set_device_state(udev, USB_STATE_SUSPENDED);
3347 }
3348
3349 if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled
3350 && test_and_clear_bit(port1, hub->child_usage_bits))
3351 pm_runtime_put_sync(&port_dev->dev);
3352
3353 usb_mark_last_busy(hub->hdev);
3354
3355 usb_unlock_port(port_dev);
3356 return status;
3357}
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370static int finish_port_resume(struct usb_device *udev)
3371{
3372 int status = 0;
3373 u16 devstatus = 0;
3374
3375
3376 dev_dbg(&udev->dev, "%s\n",
3377 udev->reset_resume ? "finish reset-resume" : "finish resume");
3378
3379
3380
3381
3382
3383
3384 usb_set_device_state(udev, udev->actconfig
3385 ? USB_STATE_CONFIGURED
3386 : USB_STATE_ADDRESS);
3387
3388
3389
3390
3391
3392
3393 if (udev->reset_resume) {
3394
3395
3396
3397
3398
3399
3400 retry_reset_resume:
3401 if (udev->quirks & USB_QUIRK_RESET)
3402 status = -ENODEV;
3403 else
3404 status = usb_reset_and_verify_device(udev);
3405 }
3406
3407
3408
3409
3410
3411 if (status == 0) {
3412 devstatus = 0;
3413 status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
3414
3415
3416 if (status && !udev->reset_resume && udev->persist_enabled) {
3417 dev_dbg(&udev->dev, "retry with reset-resume\n");
3418 udev->reset_resume = 1;
3419 goto retry_reset_resume;
3420 }
3421 }
3422
3423 if (status) {
3424 dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
3425 status);
3426
3427
3428
3429
3430
3431
3432 } else if (udev->actconfig && !udev->reset_resume) {
3433 if (udev->speed < USB_SPEED_SUPER) {
3434 if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
3435 status = usb_disable_remote_wakeup(udev);
3436 } else {
3437 status = usb_get_std_status(udev, USB_RECIP_INTERFACE, 0,
3438 &devstatus);
3439 if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
3440 | USB_INTRF_STAT_FUNC_RW))
3441 status = usb_disable_remote_wakeup(udev);
3442 }
3443
3444 if (status)
3445 dev_dbg(&udev->dev,
3446 "disable remote wakeup, status %d\n",
3447 status);
3448 status = 0;
3449 }
3450 return status;
3451}
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477static int wait_for_connected(struct usb_device *udev,
3478 struct usb_hub *hub, int *port1,
3479 u16 *portchange, u16 *portstatus)
3480{
3481 int status = 0, delay_ms = 0;
3482
3483 while (delay_ms < 2000) {
3484 if (status || *portstatus & USB_PORT_STAT_CONNECTION)
3485 break;
3486 if (!port_is_power_on(hub, *portstatus)) {
3487 status = -ENODEV;
3488 break;
3489 }
3490 msleep(20);
3491 delay_ms += 20;
3492 status = hub_port_status(hub, *port1, portstatus, portchange);
3493 }
3494 dev_dbg(&udev->dev, "Waited %dms for CONNECT\n", delay_ms);
3495 return status;
3496}
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532int usb_port_resume(struct usb_device *udev, pm_message_t msg)
3533{
3534 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
3535 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
3536 int port1 = udev->portnum;
3537 int status;
3538 u16 portchange, portstatus;
3539
3540 if (!test_and_set_bit(port1, hub->child_usage_bits)) {
3541 status = pm_runtime_get_sync(&port_dev->dev);
3542 if (status < 0) {
3543 dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
3544 status);
3545 return status;
3546 }
3547 }
3548
3549 usb_lock_port(port_dev);
3550
3551
3552 status = hub_port_status(hub, port1, &portstatus, &portchange);
3553 if (status == 0 && !port_is_suspended(hub, portstatus)) {
3554 if (portchange & USB_PORT_STAT_C_SUSPEND)
3555 pm_wakeup_event(&udev->dev, 0);
3556 goto SuspendCleared;
3557 }
3558
3559
3560 if (hub_is_superspeed(hub->hdev))
3561 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
3562 else
3563 status = usb_clear_port_feature(hub->hdev,
3564 port1, USB_PORT_FEAT_SUSPEND);
3565 if (status) {
3566 dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
3567 } else {
3568
3569 dev_dbg(&udev->dev, "usb %sresume\n",
3570 (PMSG_IS_AUTO(msg) ? "auto-" : ""));
3571 msleep(USB_RESUME_TIMEOUT);
3572
3573
3574
3575
3576
3577 status = hub_port_status(hub, port1, &portstatus, &portchange);
3578
3579
3580 msleep(10);
3581 }
3582
3583 SuspendCleared:
3584 if (status == 0) {
3585 udev->port_is_suspended = 0;
3586 if (hub_is_superspeed(hub->hdev)) {
3587 if (portchange & USB_PORT_STAT_C_LINK_STATE)
3588 usb_clear_port_feature(hub->hdev, port1,
3589 USB_PORT_FEAT_C_PORT_LINK_STATE);
3590 } else {
3591 if (portchange & USB_PORT_STAT_C_SUSPEND)
3592 usb_clear_port_feature(hub->hdev, port1,
3593 USB_PORT_FEAT_C_SUSPEND);
3594 }
3595 }
3596
3597 if (udev->persist_enabled)
3598 status = wait_for_connected(udev, hub, &port1, &portchange,
3599 &portstatus);
3600
3601 status = check_port_resume_type(udev,
3602 hub, port1, status, portchange, portstatus);
3603 if (status == 0)
3604 status = finish_port_resume(udev);
3605 if (status < 0) {
3606 dev_dbg(&udev->dev, "can't resume, status %d\n", status);
3607 hub_port_logical_disconnect(hub, port1);
3608 } else {
3609
3610 usb_enable_usb2_hardware_lpm(udev);
3611
3612
3613 usb_enable_ltm(udev);
3614 }
3615
3616 usb_unlock_port(port_dev);
3617
3618 return status;
3619}
3620
3621int usb_remote_wakeup(struct usb_device *udev)
3622{
3623 int status = 0;
3624
3625 usb_lock_device(udev);
3626 if (udev->state == USB_STATE_SUSPENDED) {
3627 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
3628 status = usb_autoresume_device(udev);
3629 if (status == 0) {
3630
3631 usb_autosuspend_device(udev);
3632 }
3633 }
3634 usb_unlock_device(udev);
3635 return status;
3636}
3637
3638
3639static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
3640 u16 portstatus, u16 portchange)
3641 __must_hold(&port_dev->status_lock)
3642{
3643 struct usb_port *port_dev = hub->ports[port - 1];
3644 struct usb_device *hdev;
3645 struct usb_device *udev;
3646 int connect_change = 0;
3647 u16 link_state;
3648 int ret;
3649
3650 hdev = hub->hdev;
3651 udev = port_dev->child;
3652 if (!hub_is_superspeed(hdev)) {
3653 if (!(portchange & USB_PORT_STAT_C_SUSPEND))
3654 return 0;
3655 usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
3656 } else {
3657 link_state = portstatus & USB_PORT_STAT_LINK_STATE;
3658 if (!udev || udev->state != USB_STATE_SUSPENDED ||
3659 (link_state != USB_SS_PORT_LS_U0 &&
3660 link_state != USB_SS_PORT_LS_U1 &&
3661 link_state != USB_SS_PORT_LS_U2))
3662 return 0;
3663 }
3664
3665 if (udev) {
3666
3667 msleep(10);
3668
3669 usb_unlock_port(port_dev);
3670 ret = usb_remote_wakeup(udev);
3671 usb_lock_port(port_dev);
3672 if (ret < 0)
3673 connect_change = 1;
3674 } else {
3675 ret = -ENODEV;
3676 hub_port_disable(hub, port, 1);
3677 }
3678 dev_dbg(&port_dev->dev, "resume, status %d\n", ret);
3679 return connect_change;
3680}
3681
3682static int check_ports_changed(struct usb_hub *hub)
3683{
3684 int port1;
3685
3686 for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) {
3687 u16 portstatus, portchange;
3688 int status;
3689
3690 status = hub_port_status(hub, port1, &portstatus, &portchange);
3691 if (!status && portchange)
3692 return 1;
3693 }
3694 return 0;
3695}
3696
3697static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
3698{
3699 struct usb_hub *hub = usb_get_intfdata(intf);
3700 struct usb_device *hdev = hub->hdev;
3701 unsigned port1;
3702
3703
3704
3705
3706
3707 hub->wakeup_enabled_descendants = 0;
3708 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3709 struct usb_port *port_dev = hub->ports[port1 - 1];
3710 struct usb_device *udev = port_dev->child;
3711
3712 if (udev && udev->can_submit) {
3713 dev_warn(&port_dev->dev, "device %s not suspended yet\n",
3714 dev_name(&udev->dev));
3715 if (PMSG_IS_AUTO(msg))
3716 return -EBUSY;
3717 }
3718 if (udev)
3719 hub->wakeup_enabled_descendants +=
3720 usb_wakeup_enabled_descendants(udev);
3721 }
3722
3723 if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) {
3724
3725 if (check_ports_changed(hub)) {
3726 if (PMSG_IS_AUTO(msg))
3727 return -EBUSY;
3728 pm_wakeup_event(&hdev->dev, 2000);
3729 }
3730 }
3731
3732 if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
3733
3734 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3735 set_port_feature(hdev,
3736 port1 |
3737 USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
3738 USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
3739 USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
3740 USB_PORT_FEAT_REMOTE_WAKE_MASK);
3741 }
3742 }
3743
3744 dev_dbg(&intf->dev, "%s\n", __func__);
3745
3746
3747 hub_quiesce(hub, HUB_SUSPEND);
3748 return 0;
3749}
3750
3751
3752static void report_wakeup_requests(struct usb_hub *hub)
3753{
3754 struct usb_device *hdev = hub->hdev;
3755 struct usb_device *udev;
3756 struct usb_hcd *hcd;
3757 unsigned long resuming_ports;
3758 int i;
3759
3760 if (hdev->parent)
3761 return;
3762
3763 hcd = bus_to_hcd(hdev->bus);
3764 if (hcd->driver->get_resuming_ports) {
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774 resuming_ports = hcd->driver->get_resuming_ports(hcd);
3775 for (i = 0; i < hdev->maxchild; ++i) {
3776 if (test_bit(i, &resuming_ports)) {
3777 udev = hub->ports[i]->child;
3778 if (udev)
3779 pm_wakeup_event(&udev->dev, 0);
3780 }
3781 }
3782 }
3783}
3784
3785static int hub_resume(struct usb_interface *intf)
3786{
3787 struct usb_hub *hub = usb_get_intfdata(intf);
3788
3789 dev_dbg(&intf->dev, "%s\n", __func__);
3790 hub_activate(hub, HUB_RESUME);
3791
3792
3793
3794
3795
3796
3797
3798 report_wakeup_requests(hub);
3799 return 0;
3800}
3801
3802static int hub_reset_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_RESET_RESUME);
3808 return 0;
3809}
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822void usb_root_hub_lost_power(struct usb_device *rhdev)
3823{
3824 dev_notice(&rhdev->dev, "root hub lost power or was reset\n");
3825 rhdev->reset_resume = 1;
3826}
3827EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
3828
3829static const char * const usb3_lpm_names[] = {
3830 "U0",
3831 "U1",
3832 "U2",
3833 "U3",
3834};
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
3846{
3847 struct usb_set_sel_req *sel_values;
3848 unsigned long long u1_sel;
3849 unsigned long long u1_pel;
3850 unsigned long long u2_sel;
3851 unsigned long long u2_pel;
3852 int ret;
3853
3854 if (udev->state != USB_STATE_CONFIGURED)
3855 return 0;
3856
3857
3858 u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
3859 u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
3860 u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
3861 u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871 if ((state == USB3_LPM_U1 &&
3872 (u1_sel > USB3_LPM_MAX_U1_SEL_PEL ||
3873 u1_pel > USB3_LPM_MAX_U1_SEL_PEL)) ||
3874 (state == USB3_LPM_U2 &&
3875 (u2_sel > USB3_LPM_MAX_U2_SEL_PEL ||
3876 u2_pel > USB3_LPM_MAX_U2_SEL_PEL))) {
3877 dev_dbg(&udev->dev, "Device-initiated %s disabled due to long SEL %llu us or PEL %llu us\n",
3878 usb3_lpm_names[state], u1_sel, u1_pel);
3879 return -EINVAL;
3880 }
3881
3882
3883
3884
3885
3886
3887 if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL)
3888 u1_sel = USB3_LPM_MAX_U1_SEL_PEL;
3889
3890 if (u1_pel > USB3_LPM_MAX_U1_SEL_PEL)
3891 u1_pel = USB3_LPM_MAX_U1_SEL_PEL;
3892
3893 if (u2_sel > USB3_LPM_MAX_U2_SEL_PEL)
3894 u2_sel = USB3_LPM_MAX_U2_SEL_PEL;
3895
3896 if (u2_pel > USB3_LPM_MAX_U2_SEL_PEL)
3897 u2_pel = USB3_LPM_MAX_U2_SEL_PEL;
3898
3899
3900
3901
3902
3903
3904 sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
3905 if (!sel_values)
3906 return -ENOMEM;
3907
3908 sel_values->u1_sel = u1_sel;
3909 sel_values->u1_pel = u1_pel;
3910 sel_values->u2_sel = cpu_to_le16(u2_sel);
3911 sel_values->u2_pel = cpu_to_le16(u2_pel);
3912
3913 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3914 USB_REQ_SET_SEL,
3915 USB_RECIP_DEVICE,
3916 0, 0,
3917 sel_values, sizeof *(sel_values),
3918 USB_CTRL_SET_TIMEOUT);
3919 kfree(sel_values);
3920 return ret;
3921}
3922
3923
3924
3925
3926static int usb_set_device_initiated_lpm(struct usb_device *udev,
3927 enum usb3_link_state state, bool enable)
3928{
3929 int ret;
3930 int feature;
3931
3932 switch (state) {
3933 case USB3_LPM_U1:
3934 feature = USB_DEVICE_U1_ENABLE;
3935 break;
3936 case USB3_LPM_U2:
3937 feature = USB_DEVICE_U2_ENABLE;
3938 break;
3939 default:
3940 dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n",
3941 __func__, enable ? "enable" : "disable");
3942 return -EINVAL;
3943 }
3944
3945 if (udev->state != USB_STATE_CONFIGURED) {
3946 dev_dbg(&udev->dev, "%s: Can't %s %s state "
3947 "for unconfigured device.\n",
3948 __func__, enable ? "enable" : "disable",
3949 usb3_lpm_names[state]);
3950 return 0;
3951 }
3952
3953 if (enable) {
3954
3955
3956
3957
3958 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3959 USB_REQ_SET_FEATURE,
3960 USB_RECIP_DEVICE,
3961 feature,
3962 0, NULL, 0,
3963 USB_CTRL_SET_TIMEOUT);
3964 } else {
3965 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3966 USB_REQ_CLEAR_FEATURE,
3967 USB_RECIP_DEVICE,
3968 feature,
3969 0, NULL, 0,
3970 USB_CTRL_SET_TIMEOUT);
3971 }
3972 if (ret < 0) {
3973 dev_warn(&udev->dev, "%s of device-initiated %s failed.\n",
3974 enable ? "Enable" : "Disable",
3975 usb3_lpm_names[state]);
3976 return -EBUSY;
3977 }
3978 return 0;
3979}
3980
3981static int usb_set_lpm_timeout(struct usb_device *udev,
3982 enum usb3_link_state state, int timeout)
3983{
3984 int ret;
3985 int feature;
3986
3987 switch (state) {
3988 case USB3_LPM_U1:
3989 feature = USB_PORT_FEAT_U1_TIMEOUT;
3990 break;
3991 case USB3_LPM_U2:
3992 feature = USB_PORT_FEAT_U2_TIMEOUT;
3993 break;
3994 default:
3995 dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n",
3996 __func__);
3997 return -EINVAL;
3998 }
3999
4000 if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT &&
4001 timeout != USB3_LPM_DEVICE_INITIATED) {
4002 dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, "
4003 "which is a reserved value.\n",
4004 usb3_lpm_names[state], timeout);
4005 return -EINVAL;
4006 }
4007
4008 ret = set_port_feature(udev->parent,
4009 USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum,
4010 feature);
4011 if (ret < 0) {
4012 dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x,"
4013 "error code %i\n", usb3_lpm_names[state],
4014 timeout, ret);
4015 return -EBUSY;
4016 }
4017 if (state == USB3_LPM_U1)
4018 udev->u1_params.timeout = timeout;
4019 else
4020 udev->u2_params.timeout = timeout;
4021 return 0;
4022}
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
4040 enum usb3_link_state state)
4041{
4042 int timeout, ret;
4043 __u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
4044 __le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;
4045
4046
4047
4048
4049
4050 if ((state == USB3_LPM_U1 && u1_mel == 0) ||
4051 (state == USB3_LPM_U2 && u2_mel == 0))
4052 return;
4053
4054
4055
4056
4057
4058 ret = usb_req_set_sel(udev, state);
4059 if (ret < 0) {
4060 dev_warn(&udev->dev, "Set SEL for device-initiated %s failed.\n",
4061 usb3_lpm_names[state]);
4062 return;
4063 }
4064
4065
4066
4067
4068
4069
4070 timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state);
4071
4072
4073 if (timeout == 0)
4074 return;
4075
4076 if (timeout < 0) {
4077 dev_warn(&udev->dev, "Could not enable %s link state, "
4078 "xHCI error %i.\n", usb3_lpm_names[state],
4079 timeout);
4080 return;
4081 }
4082
4083 if (usb_set_lpm_timeout(udev, state, timeout)) {
4084
4085
4086
4087
4088 hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
4089 return;
4090 }
4091
4092
4093
4094
4095 if (udev->actconfig &&
4096 usb_set_device_initiated_lpm(udev, state, true) == 0) {
4097 if (state == USB3_LPM_U1)
4098 udev->usb3_lpm_u1_enabled = 1;
4099 else if (state == USB3_LPM_U2)
4100 udev->usb3_lpm_u2_enabled = 1;
4101 } else {
4102
4103
4104
4105 usb_set_lpm_timeout(udev, state, 0);
4106 hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
4107 }
4108}
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118
4119
4120
4121
4122
4123
4124
4125static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
4126 enum usb3_link_state state)
4127{
4128 switch (state) {
4129 case USB3_LPM_U1:
4130 case USB3_LPM_U2:
4131 break;
4132 default:
4133 dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n",
4134 __func__);
4135 return -EINVAL;
4136 }
4137
4138 if (usb_set_lpm_timeout(udev, state, 0))
4139 return -EBUSY;
4140
4141 usb_set_device_initiated_lpm(udev, state, false);
4142
4143 if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state))
4144 dev_warn(&udev->dev, "Could not disable xHCI %s timeout, "
4145 "bus schedule bandwidth may be impacted.\n",
4146 usb3_lpm_names[state]);
4147
4148
4149
4150
4151
4152
4153
4154 if (state == USB3_LPM_U1)
4155 udev->usb3_lpm_u1_enabled = 0;
4156 else if (state == USB3_LPM_U2)
4157 udev->usb3_lpm_u2_enabled = 0;
4158
4159 return 0;
4160}
4161
4162
4163
4164
4165
4166
4167
4168
4169int usb_disable_lpm(struct usb_device *udev)
4170{
4171 struct usb_hcd *hcd;
4172
4173 if (!udev || !udev->parent ||
4174 udev->speed < USB_SPEED_SUPER ||
4175 !udev->lpm_capable ||
4176 udev->state < USB_STATE_CONFIGURED)
4177 return 0;
4178
4179 hcd = bus_to_hcd(udev->bus);
4180 if (!hcd || !hcd->driver->disable_usb3_lpm_timeout)
4181 return 0;
4182
4183 udev->lpm_disable_count++;
4184 if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
4185 return 0;
4186
4187
4188 if (usb_disable_link_state(hcd, udev, USB3_LPM_U1))
4189 goto enable_lpm;
4190 if (usb_disable_link_state(hcd, udev, USB3_LPM_U2))
4191 goto enable_lpm;
4192
4193 return 0;
4194
4195enable_lpm:
4196 usb_enable_lpm(udev);
4197 return -EBUSY;
4198}
4199EXPORT_SYMBOL_GPL(usb_disable_lpm);
4200
4201
4202int usb_unlocked_disable_lpm(struct usb_device *udev)
4203{
4204 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4205 int ret;
4206
4207 if (!hcd)
4208 return -EINVAL;
4209
4210 mutex_lock(hcd->bandwidth_mutex);
4211 ret = usb_disable_lpm(udev);
4212 mutex_unlock(hcd->bandwidth_mutex);
4213
4214 return ret;
4215}
4216EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226void usb_enable_lpm(struct usb_device *udev)
4227{
4228 struct usb_hcd *hcd;
4229 struct usb_hub *hub;
4230 struct usb_port *port_dev;
4231
4232 if (!udev || !udev->parent ||
4233 udev->speed < USB_SPEED_SUPER ||
4234 !udev->lpm_capable ||
4235 udev->state < USB_STATE_CONFIGURED)
4236 return;
4237
4238 udev->lpm_disable_count--;
4239 hcd = bus_to_hcd(udev->bus);
4240
4241
4242
4243 if (!hcd || !hcd->driver->enable_usb3_lpm_timeout ||
4244 !hcd->driver->disable_usb3_lpm_timeout)
4245 return;
4246
4247 if (udev->lpm_disable_count > 0)
4248 return;
4249
4250 hub = usb_hub_to_struct_hub(udev->parent);
4251 if (!hub)
4252 return;
4253
4254 port_dev = hub->ports[udev->portnum - 1];
4255
4256 if (port_dev->usb3_lpm_u1_permit)
4257 usb_enable_link_state(hcd, udev, USB3_LPM_U1);
4258
4259 if (port_dev->usb3_lpm_u2_permit)
4260 usb_enable_link_state(hcd, udev, USB3_LPM_U2);
4261}
4262EXPORT_SYMBOL_GPL(usb_enable_lpm);
4263
4264
4265void usb_unlocked_enable_lpm(struct usb_device *udev)
4266{
4267 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4268
4269 if (!hcd)
4270 return;
4271
4272 mutex_lock(hcd->bandwidth_mutex);
4273 usb_enable_lpm(udev);
4274 mutex_unlock(hcd->bandwidth_mutex);
4275}
4276EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4277
4278
4279static void hub_usb3_port_prepare_disable(struct usb_hub *hub,
4280 struct usb_port *port_dev)
4281{
4282 struct usb_device *udev = port_dev->child;
4283 int ret;
4284
4285 if (udev && udev->port_is_suspended && udev->do_remote_wakeup) {
4286 ret = hub_set_port_link_state(hub, port_dev->portnum,
4287 USB_SS_PORT_LS_U0);
4288 if (!ret) {
4289 msleep(USB_RESUME_TIMEOUT);
4290 ret = usb_disable_remote_wakeup(udev);
4291 }
4292 if (ret)
4293 dev_warn(&udev->dev,
4294 "Port disable: can't disable remote wake\n");
4295 udev->do_remote_wakeup = 0;
4296 }
4297}
4298
4299#else
4300
4301#define hub_suspend NULL
4302#define hub_resume NULL
4303#define hub_reset_resume NULL
4304
4305static inline void hub_usb3_port_prepare_disable(struct usb_hub *hub,
4306 struct usb_port *port_dev) { }
4307
4308int usb_disable_lpm(struct usb_device *udev)
4309{
4310 return 0;
4311}
4312EXPORT_SYMBOL_GPL(usb_disable_lpm);
4313
4314void usb_enable_lpm(struct usb_device *udev) { }
4315EXPORT_SYMBOL_GPL(usb_enable_lpm);
4316
4317int usb_unlocked_disable_lpm(struct usb_device *udev)
4318{
4319 return 0;
4320}
4321EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4322
4323void usb_unlocked_enable_lpm(struct usb_device *udev) { }
4324EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4325
4326int usb_disable_ltm(struct usb_device *udev)
4327{
4328 return 0;
4329}
4330EXPORT_SYMBOL_GPL(usb_disable_ltm);
4331
4332void usb_enable_ltm(struct usb_device *udev) { }
4333EXPORT_SYMBOL_GPL(usb_enable_ltm);
4334
4335static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
4336 u16 portstatus, u16 portchange)
4337{
4338 return 0;
4339}
4340
4341#endif
4342
4343
4344
4345
4346
4347
4348static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
4349{
4350 struct usb_port *port_dev = hub->ports[port1 - 1];
4351 struct usb_device *hdev = hub->hdev;
4352 int ret = 0;
4353
4354 if (!hub->error) {
4355 if (hub_is_superspeed(hub->hdev)) {
4356 hub_usb3_port_prepare_disable(hub, port_dev);
4357 ret = hub_set_port_link_state(hub, port_dev->portnum,
4358 USB_SS_PORT_LS_U3);
4359 } else {
4360 ret = usb_clear_port_feature(hdev, port1,
4361 USB_PORT_FEAT_ENABLE);
4362 }
4363 }
4364 if (port_dev->child && set_state)
4365 usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
4366 if (ret && ret != -ENODEV)
4367 dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
4368 return ret;
4369}
4370
4371
4372
4373
4374
4375
4376
4377
4378int usb_port_disable(struct usb_device *udev)
4379{
4380 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
4381
4382 return hub_port_disable(hub, udev->portnum, 0);
4383}
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
4401{
4402 int ret;
4403 u16 portchange, portstatus;
4404 unsigned connection = 0xffff;
4405 int total_time, stable_time = 0;
4406 struct usb_port *port_dev = hub->ports[port1 - 1];
4407
4408 for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
4409 ret = hub_port_status(hub, port1, &portstatus, &portchange);
4410 if (ret < 0)
4411 return ret;
4412
4413 if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
4414 (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
4415 if (!must_be_connected ||
4416 (connection == USB_PORT_STAT_CONNECTION))
4417 stable_time += HUB_DEBOUNCE_STEP;
4418 if (stable_time >= HUB_DEBOUNCE_STABLE)
4419 break;
4420 } else {
4421 stable_time = 0;
4422 connection = portstatus & USB_PORT_STAT_CONNECTION;
4423 }
4424
4425 if (portchange & USB_PORT_STAT_C_CONNECTION) {
4426 usb_clear_port_feature(hub->hdev, port1,
4427 USB_PORT_FEAT_C_CONNECTION);
4428 }
4429
4430 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
4431 break;
4432 msleep(HUB_DEBOUNCE_STEP);
4433 }
4434
4435 dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n",
4436 total_time, stable_time, portstatus);
4437
4438 if (stable_time < HUB_DEBOUNCE_STABLE)
4439 return -ETIMEDOUT;
4440 return portstatus;
4441}
4442
4443void usb_ep0_reinit(struct usb_device *udev)
4444{
4445 usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
4446 usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
4447 usb_enable_endpoint(udev, &udev->ep0, true);
4448}
4449EXPORT_SYMBOL_GPL(usb_ep0_reinit);
4450
4451#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)
4452#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN)
4453
4454static int hub_set_address(struct usb_device *udev, int devnum)
4455{
4456 int retval;
4457 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4458
4459
4460
4461
4462
4463 if (!hcd->driver->address_device && devnum <= 1)
4464 return -EINVAL;
4465 if (udev->state == USB_STATE_ADDRESS)
4466 return 0;
4467 if (udev->state != USB_STATE_DEFAULT)
4468 return -EINVAL;
4469 if (hcd->driver->address_device)
4470 retval = hcd->driver->address_device(hcd, udev);
4471 else
4472 retval = usb_control_msg(udev, usb_sndaddr0pipe(),
4473 USB_REQ_SET_ADDRESS, 0, devnum, 0,
4474 NULL, 0, USB_CTRL_SET_TIMEOUT);
4475 if (retval == 0) {
4476 update_devnum(udev, devnum);
4477
4478 usb_set_device_state(udev, USB_STATE_ADDRESS);
4479 usb_ep0_reinit(udev);
4480 }
4481 return retval;
4482}
4483
4484
4485
4486
4487
4488
4489
4490
4491
4492
4493static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
4494{
4495 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
4496 int connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
4497
4498 if (!udev->usb2_hw_lpm_capable || !udev->bos)
4499 return;
4500
4501 if (hub)
4502 connect_type = hub->ports[udev->portnum - 1]->connect_type;
4503
4504 if ((udev->bos->ext_cap->bmAttributes & cpu_to_le32(USB_BESL_SUPPORT)) ||
4505 connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
4506 udev->usb2_hw_lpm_allowed = 1;
4507 usb_enable_usb2_hardware_lpm(udev);
4508 }
4509}
4510
4511static int hub_enable_device(struct usb_device *udev)
4512{
4513 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4514
4515 if (!hcd->driver->enable_device)
4516 return 0;
4517 if (udev->state == USB_STATE_ADDRESS)
4518 return 0;
4519 if (udev->state != USB_STATE_DEFAULT)
4520 return -EINVAL;
4521
4522 return hcd->driver->enable_device(hcd, udev);
4523}
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535static int
4536hub_port_init(struct usb_hub *hub, struct usb_device *udev, int port1,
4537 int retry_counter)
4538{
4539 struct usb_device *hdev = hub->hdev;
4540 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
4541 struct usb_port *port_dev = hub->ports[port1 - 1];
4542 int retries, operations, retval, i;
4543 unsigned delay = HUB_SHORT_RESET_TIME;
4544 enum usb_device_speed oldspeed = udev->speed;
4545 const char *speed;
4546 int devnum = udev->devnum;
4547 const char *driver_name;
4548
4549
4550
4551
4552 if (!hdev->parent) {
4553 delay = HUB_ROOT_RESET_TIME;
4554 if (port1 == hdev->bus->otg_port)
4555 hdev->bus->b_hnp_enable = 0;
4556 }
4557
4558
4559
4560 if (oldspeed == USB_SPEED_LOW)
4561 delay = HUB_LONG_RESET_TIME;
4562
4563 mutex_lock(hcd->address0_mutex);
4564
4565
4566
4567 retval = hub_port_reset(hub, port1, udev, delay, false);
4568 if (retval < 0)
4569 goto fail;
4570
4571
4572 retval = -ENODEV;
4573
4574
4575 if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed &&
4576 !(oldspeed == USB_SPEED_SUPER && udev->speed > oldspeed)) {
4577 dev_dbg(&udev->dev, "device reset changed speed!\n");
4578 goto fail;
4579 }
4580 oldspeed = udev->speed;
4581
4582
4583
4584
4585
4586
4587 switch (udev->speed) {
4588 case USB_SPEED_SUPER_PLUS:
4589 case USB_SPEED_SUPER:
4590 case USB_SPEED_WIRELESS:
4591 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
4592 break;
4593 case USB_SPEED_HIGH:
4594 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
4595 break;
4596 case USB_SPEED_FULL:
4597
4598
4599
4600
4601 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
4602 break;
4603 case USB_SPEED_LOW:
4604 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
4605 break;
4606 default:
4607 goto fail;
4608 }
4609
4610 if (udev->speed == USB_SPEED_WIRELESS)
4611 speed = "variable speed Wireless";
4612 else
4613 speed = usb_speed_string(udev->speed);
4614
4615
4616
4617
4618
4619
4620
4621
4622 if (udev->bus->controller->driver)
4623 driver_name = udev->bus->controller->driver->name;
4624 else
4625 driver_name = udev->bus->sysdev->driver->name;
4626
4627 if (udev->speed < USB_SPEED_SUPER)
4628 dev_info(&udev->dev,
4629 "%s %s USB device number %d using %s\n",
4630 (udev->config) ? "reset" : "new", speed,
4631 devnum, driver_name);
4632
4633
4634 if (hdev->tt) {
4635 udev->tt = hdev->tt;
4636 udev->ttport = hdev->ttport;
4637 } else if (udev->speed != USB_SPEED_HIGH
4638 && hdev->speed == USB_SPEED_HIGH) {
4639 if (!hub->tt.hub) {
4640 dev_err(&udev->dev, "parent hub has no TT\n");
4641 retval = -EINVAL;
4642 goto fail;
4643 }
4644 udev->tt = &hub->tt;
4645 udev->ttport = port1;
4646 }
4647
4648
4649
4650
4651
4652
4653
4654
4655
4656
4657
4658
4659
4660 for (retries = 0; retries < GET_DESCRIPTOR_TRIES; (++retries, msleep(100))) {
4661 bool did_new_scheme = false;
4662
4663 if (use_new_scheme(udev, retry_counter, port_dev)) {
4664 struct usb_device_descriptor *buf;
4665 int r = 0;
4666
4667 did_new_scheme = true;
4668 retval = hub_enable_device(udev);
4669 if (retval < 0) {
4670 dev_err(&udev->dev,
4671 "hub failed to enable device, error %d\n",
4672 retval);
4673 goto fail;
4674 }
4675
4676#define GET_DESCRIPTOR_BUFSIZE 64
4677 buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
4678 if (!buf) {
4679 retval = -ENOMEM;
4680 continue;
4681 }
4682
4683
4684
4685
4686
4687 for (operations = 0; operations < 3; ++operations) {
4688 buf->bMaxPacketSize0 = 0;
4689 r = usb_control_msg(udev, usb_rcvaddr0pipe(),
4690 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
4691 USB_DT_DEVICE << 8, 0,
4692 buf, GET_DESCRIPTOR_BUFSIZE,
4693 initial_descriptor_timeout);
4694 switch (buf->bMaxPacketSize0) {
4695 case 8: case 16: case 32: case 64: case 255:
4696 if (buf->bDescriptorType ==
4697 USB_DT_DEVICE) {
4698 r = 0;
4699 break;
4700 }
4701 fallthrough;
4702 default:
4703 if (r == 0)
4704 r = -EPROTO;
4705 break;
4706 }
4707
4708
4709
4710
4711
4712
4713 if (r == 0 || (r == -ETIMEDOUT &&
4714 retries == 0 &&
4715 udev->speed > USB_SPEED_FULL))
4716 break;
4717 }
4718 udev->descriptor.bMaxPacketSize0 =
4719 buf->bMaxPacketSize0;
4720 kfree(buf);
4721
4722 retval = hub_port_reset(hub, port1, udev, delay, false);
4723 if (retval < 0)
4724 goto fail;
4725 if (oldspeed != udev->speed) {
4726 dev_dbg(&udev->dev,
4727 "device reset changed speed!\n");
4728 retval = -ENODEV;
4729 goto fail;
4730 }
4731 if (r) {
4732 if (r != -ENODEV)
4733 dev_err(&udev->dev, "device descriptor read/64, error %d\n",
4734 r);
4735 retval = -EMSGSIZE;
4736 continue;
4737 }
4738#undef GET_DESCRIPTOR_BUFSIZE
4739 }
4740
4741
4742
4743
4744
4745
4746 if (udev->wusb == 0) {
4747 for (operations = 0; operations < SET_ADDRESS_TRIES; ++operations) {
4748 retval = hub_set_address(udev, devnum);
4749 if (retval >= 0)
4750 break;
4751 msleep(200);
4752 }
4753 if (retval < 0) {
4754 if (retval != -ENODEV)
4755 dev_err(&udev->dev, "device not accepting address %d, error %d\n",
4756 devnum, retval);
4757 goto fail;
4758 }
4759 if (udev->speed >= USB_SPEED_SUPER) {
4760 devnum = udev->devnum;
4761 dev_info(&udev->dev,
4762 "%s SuperSpeed%s%s USB device number %d using %s\n",
4763 (udev->config) ? "reset" : "new",
4764 (udev->speed == USB_SPEED_SUPER_PLUS) ?
4765 "Plus Gen 2" : " Gen 1",
4766 (udev->rx_lanes == 2 && udev->tx_lanes == 2) ?
4767 "x2" : "",
4768 devnum, driver_name);
4769 }
4770
4771
4772
4773
4774
4775 msleep(10);
4776
4777
4778
4779
4780 if (did_new_scheme)
4781 break;
4782 }
4783
4784 retval = usb_get_device_descriptor(udev, 8);
4785 if (retval < 8) {
4786 if (retval != -ENODEV)
4787 dev_err(&udev->dev,
4788 "device descriptor read/8, error %d\n",
4789 retval);
4790 if (retval >= 0)
4791 retval = -EMSGSIZE;
4792 } else {
4793 u32 delay;
4794
4795 retval = 0;
4796
4797 delay = udev->parent->hub_delay;
4798 udev->hub_delay = min_t(u32, delay,
4799 USB_TP_TRANSMISSION_DELAY_MAX);
4800 retval = usb_set_isoch_delay(udev);
4801 if (retval) {
4802 dev_dbg(&udev->dev,
4803 "Failed set isoch delay, error %d\n",
4804 retval);
4805 retval = 0;
4806 }
4807 break;
4808 }
4809 }
4810 if (retval)
4811 goto fail;
4812
4813
4814
4815
4816
4817
4818
4819 if ((udev->speed >= USB_SPEED_SUPER) &&
4820 (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
4821 dev_err(&udev->dev, "got a wrong device descriptor, "
4822 "warm reset device\n");
4823 hub_port_reset(hub, port1, udev,
4824 HUB_BH_RESET_TIME, true);
4825 retval = -EINVAL;
4826 goto fail;
4827 }
4828
4829 if (udev->descriptor.bMaxPacketSize0 == 0xff ||
4830 udev->speed >= USB_SPEED_SUPER)
4831 i = 512;
4832 else
4833 i = udev->descriptor.bMaxPacketSize0;
4834 if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
4835 if (udev->speed == USB_SPEED_LOW ||
4836 !(i == 8 || i == 16 || i == 32 || i == 64)) {
4837 dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
4838 retval = -EMSGSIZE;
4839 goto fail;
4840 }
4841 if (udev->speed == USB_SPEED_FULL)
4842 dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
4843 else
4844 dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
4845 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
4846 usb_ep0_reinit(udev);
4847 }
4848
4849 retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
4850 if (retval < (signed)sizeof(udev->descriptor)) {
4851 if (retval != -ENODEV)
4852 dev_err(&udev->dev, "device descriptor read/all, error %d\n",
4853 retval);
4854 if (retval >= 0)
4855 retval = -ENOMSG;
4856 goto fail;
4857 }
4858
4859 usb_detect_quirks(udev);
4860
4861 if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
4862 retval = usb_get_bos_descriptor(udev);
4863 if (!retval) {
4864 udev->lpm_capable = usb_device_supports_lpm(udev);
4865 usb_set_lpm_parameters(udev);
4866 }
4867 }
4868
4869 retval = 0;
4870
4871 if (hcd->driver->update_device)
4872 hcd->driver->update_device(hcd, udev);
4873 hub_set_initial_usb2_lpm_policy(udev);
4874fail:
4875 if (retval) {
4876 hub_port_disable(hub, port1, 0);
4877 update_devnum(udev, devnum);
4878 }
4879 mutex_unlock(hcd->address0_mutex);
4880 return retval;
4881}
4882
4883static void
4884check_highspeed(struct usb_hub *hub, struct usb_device *udev, int port1)
4885{
4886 struct usb_qualifier_descriptor *qual;
4887 int status;
4888
4889 if (udev->quirks & USB_QUIRK_DEVICE_QUALIFIER)
4890 return;
4891
4892 qual = kmalloc(sizeof *qual, GFP_KERNEL);
4893 if (qual == NULL)
4894 return;
4895
4896 status = usb_get_descriptor(udev, USB_DT_DEVICE_QUALIFIER, 0,
4897 qual, sizeof *qual);
4898 if (status == sizeof *qual) {
4899 dev_info(&udev->dev, "not running at top speed; "
4900 "connect to a high speed hub\n");
4901
4902 if (hub->has_indicators) {
4903 hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
4904 queue_delayed_work(system_power_efficient_wq,
4905 &hub->leds, 0);
4906 }
4907 }
4908 kfree(qual);
4909}
4910
4911static unsigned
4912hub_power_remaining(struct usb_hub *hub)
4913{
4914 struct usb_device *hdev = hub->hdev;
4915 int remaining;
4916 int port1;
4917
4918 if (!hub->limited_power)
4919 return 0;
4920
4921 remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
4922 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
4923 struct usb_port *port_dev = hub->ports[port1 - 1];
4924 struct usb_device *udev = port_dev->child;
4925 unsigned unit_load;
4926 int delta;
4927
4928 if (!udev)
4929 continue;
4930 if (hub_is_superspeed(udev))
4931 unit_load = 150;
4932 else
4933 unit_load = 100;
4934
4935
4936
4937
4938
4939 if (udev->actconfig)
4940 delta = usb_get_max_power(udev, udev->actconfig);
4941 else if (port1 != udev->bus->otg_port || hdev->parent)
4942 delta = unit_load;
4943 else
4944 delta = 8;
4945 if (delta > hub->mA_per_port)
4946 dev_warn(&port_dev->dev, "%dmA is over %umA budget!\n",
4947 delta, hub->mA_per_port);
4948 remaining -= delta;
4949 }
4950 if (remaining < 0) {
4951 dev_warn(hub->intfdev, "%dmA over power budget!\n",
4952 -remaining);
4953 remaining = 0;
4954 }
4955 return remaining;
4956}
4957
4958
4959static int descriptors_changed(struct usb_device *udev,
4960 struct usb_device_descriptor *old_device_descriptor,
4961 struct usb_host_bos *old_bos)
4962{
4963 int changed = 0;
4964 unsigned index;
4965 unsigned serial_len = 0;
4966 unsigned len;
4967 unsigned old_length;
4968 int length;
4969 char *buf;
4970
4971 if (memcmp(&udev->descriptor, old_device_descriptor,
4972 sizeof(*old_device_descriptor)) != 0)
4973 return 1;
4974
4975 if ((old_bos && !udev->bos) || (!old_bos && udev->bos))
4976 return 1;
4977 if (udev->bos) {
4978 len = le16_to_cpu(udev->bos->desc->wTotalLength);
4979 if (len != le16_to_cpu(old_bos->desc->wTotalLength))
4980 return 1;
4981 if (memcmp(udev->bos->desc, old_bos->desc, len))
4982 return 1;
4983 }
4984
4985
4986
4987
4988
4989
4990
4991 if (udev->serial)
4992 serial_len = strlen(udev->serial) + 1;
4993
4994 len = serial_len;
4995 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
4996 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
4997 len = max(len, old_length);
4998 }
4999
5000 buf = kmalloc(len, GFP_NOIO);
5001 if (!buf)
5002
5003 return 1;
5004
5005 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
5006 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
5007 length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
5008 old_length);
5009 if (length != old_length) {
5010 dev_dbg(&udev->dev, "config index %d, error %d\n",
5011 index, length);
5012 changed = 1;
5013 break;
5014 }
5015 if (memcmp(buf, udev->rawdescriptors[index], old_length)
5016 != 0) {
5017 dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
5018 index,
5019 ((struct usb_config_descriptor *) buf)->
5020 bConfigurationValue);
5021 changed = 1;
5022 break;
5023 }
5024 }
5025
5026 if (!changed && serial_len) {
5027 length = usb_string(udev, udev->descriptor.iSerialNumber,
5028 buf, serial_len);
5029 if (length + 1 != serial_len) {
5030 dev_dbg(&udev->dev, "serial string error %d\n",
5031 length);
5032 changed = 1;
5033 } else if (memcmp(buf, udev->serial, length) != 0) {
5034 dev_dbg(&udev->dev, "serial string changed\n");
5035 changed = 1;
5036 }
5037 }
5038
5039 kfree(buf);
5040 return changed;
5041}
5042
5043static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
5044 u16 portchange)
5045{
5046 int status = -ENODEV;
5047 int i;
5048 unsigned unit_load;
5049 struct usb_device *hdev = hub->hdev;
5050 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
5051 struct usb_port *port_dev = hub->ports[port1 - 1];
5052 struct usb_device *udev = port_dev->child;
5053 static int unreliable_port = -1;
5054
5055
5056 if (udev) {
5057 if (hcd->usb_phy && !hdev->parent)
5058 usb_phy_notify_disconnect(hcd->usb_phy, udev->speed);
5059 usb_disconnect(&port_dev->child);
5060 }
5061
5062
5063
5064
5065 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
5066 (portchange & USB_PORT_STAT_C_CONNECTION))
5067 clear_bit(port1, hub->removed_bits);
5068
5069 if (portchange & (USB_PORT_STAT_C_CONNECTION |
5070 USB_PORT_STAT_C_ENABLE)) {
5071 status = hub_port_debounce_be_stable(hub, port1);
5072 if (status < 0) {
5073 if (status != -ENODEV &&
5074 port1 != unreliable_port &&
5075 printk_ratelimit())
5076 dev_err(&port_dev->dev, "connect-debounce failed\n");
5077 portstatus &= ~USB_PORT_STAT_CONNECTION;
5078 unreliable_port = port1;
5079 } else {
5080 portstatus = status;
5081 }
5082 }
5083
5084
5085
5086
5087 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
5088 test_bit(port1, hub->removed_bits)) {
5089
5090
5091
5092
5093
5094 if (hub_is_port_power_switchable(hub)
5095 && !port_is_power_on(hub, portstatus)
5096 && !port_dev->port_owner)
5097 set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
5098
5099 if (portstatus & USB_PORT_STAT_ENABLE)
5100 goto done;
5101 return;
5102 }
5103 if (hub_is_superspeed(hub->hdev))
5104 unit_load = 150;
5105 else
5106 unit_load = 100;
5107
5108 status = 0;
5109 for (i = 0; i < SET_CONFIG_TRIES; i++) {
5110
5111
5112
5113
5114 udev = usb_alloc_dev(hdev, hdev->bus, port1);
5115 if (!udev) {
5116 dev_err(&port_dev->dev,
5117 "couldn't allocate usb_device\n");
5118 goto done;
5119 }
5120
5121 usb_set_device_state(udev, USB_STATE_POWERED);
5122 udev->bus_mA = hub->mA_per_port;
5123 udev->level = hdev->level + 1;
5124 udev->wusb = hub_is_wusb(hub);
5125
5126
5127 if (hub_is_superspeed(hub->hdev))
5128 udev->speed = USB_SPEED_SUPER;
5129 else
5130 udev->speed = USB_SPEED_UNKNOWN;
5131
5132 choose_devnum(udev);
5133 if (udev->devnum <= 0) {
5134 status = -ENOTCONN;
5135 goto loop;
5136 }
5137
5138
5139 usb_lock_port(port_dev);
5140 status = hub_port_init(hub, udev, port1, i);
5141 usb_unlock_port(port_dev);
5142 if (status < 0)
5143 goto loop;
5144
5145 if (udev->quirks & USB_QUIRK_DELAY_INIT)
5146 msleep(2000);
5147
5148
5149
5150
5151
5152
5153
5154 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
5155 && udev->bus_mA <= unit_load) {
5156 u16 devstat;
5157
5158 status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0,
5159 &devstat);
5160 if (status) {
5161 dev_dbg(&udev->dev, "get status %d ?\n", status);
5162 goto loop_disable;
5163 }
5164 if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
5165 dev_err(&udev->dev,
5166 "can't connect bus-powered hub "
5167 "to this port\n");
5168 if (hub->has_indicators) {
5169 hub->indicator[port1-1] =
5170 INDICATOR_AMBER_BLINK;
5171 queue_delayed_work(
5172 system_power_efficient_wq,
5173 &hub->leds, 0);
5174 }
5175 status = -ENOTCONN;
5176 goto loop_disable;
5177 }
5178 }
5179
5180
5181 if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
5182 && udev->speed == USB_SPEED_FULL
5183 && highspeed_hubs != 0)
5184 check_highspeed(hub, udev, port1);
5185
5186
5187
5188
5189
5190 status = 0;
5191
5192 mutex_lock(&usb_port_peer_mutex);
5193
5194
5195
5196
5197
5198 spin_lock_irq(&device_state_lock);
5199 if (hdev->state == USB_STATE_NOTATTACHED)
5200 status = -ENOTCONN;
5201 else
5202 port_dev->child = udev;
5203 spin_unlock_irq(&device_state_lock);
5204 mutex_unlock(&usb_port_peer_mutex);
5205
5206
5207 if (!status) {
5208 status = usb_new_device(udev);
5209 if (status) {
5210 mutex_lock(&usb_port_peer_mutex);
5211 spin_lock_irq(&device_state_lock);
5212 port_dev->child = NULL;
5213 spin_unlock_irq(&device_state_lock);
5214 mutex_unlock(&usb_port_peer_mutex);
5215 } else {
5216 if (hcd->usb_phy && !hdev->parent)
5217 usb_phy_notify_connect(hcd->usb_phy,
5218 udev->speed);
5219 }
5220 }
5221
5222 if (status)
5223 goto loop_disable;
5224
5225 status = hub_power_remaining(hub);
5226 if (status)
5227 dev_dbg(hub->intfdev, "%dmA power budget left\n", status);
5228
5229 return;
5230
5231loop_disable:
5232 hub_port_disable(hub, port1, 1);
5233loop:
5234 usb_ep0_reinit(udev);
5235 release_devnum(udev);
5236 hub_free_dev(udev);
5237 usb_put_dev(udev);
5238 if ((status == -ENOTCONN) || (status == -ENOTSUPP))
5239 break;
5240
5241
5242 if (i == (SET_CONFIG_TRIES / 2) - 1) {
5243 dev_info(&port_dev->dev, "attempt power cycle\n");
5244 usb_hub_set_port_power(hdev, hub, port1, false);
5245 msleep(2 * hub_power_on_good_delay(hub));
5246 usb_hub_set_port_power(hdev, hub, port1, true);
5247 msleep(hub_power_on_good_delay(hub));
5248 }
5249 }
5250 if (hub->hdev->parent ||
5251 !hcd->driver->port_handed_over ||
5252 !(hcd->driver->port_handed_over)(hcd, port1)) {
5253 if (status != -ENOTCONN && status != -ENODEV)
5254 dev_err(&port_dev->dev,
5255 "unable to enumerate USB device\n");
5256 }
5257
5258done:
5259 hub_port_disable(hub, port1, 1);
5260 if (hcd->driver->relinquish_port && !hub->hdev->parent) {
5261 if (status != -ENOTCONN && status != -ENODEV)
5262 hcd->driver->relinquish_port(hcd, port1);
5263 }
5264}
5265
5266
5267
5268
5269
5270
5271
5272
5273
5274static void hub_port_connect_change(struct usb_hub *hub, int port1,
5275 u16 portstatus, u16 portchange)
5276 __must_hold(&port_dev->status_lock)
5277{
5278 struct usb_port *port_dev = hub->ports[port1 - 1];
5279 struct usb_device *udev = port_dev->child;
5280 struct usb_device_descriptor descriptor;
5281 int status = -ENODEV;
5282 int retval;
5283
5284 dev_dbg(&port_dev->dev, "status %04x, change %04x, %s\n", portstatus,
5285 portchange, portspeed(hub, portstatus));
5286
5287 if (hub->has_indicators) {
5288 set_port_led(hub, port1, HUB_LED_AUTO);
5289 hub->indicator[port1-1] = INDICATOR_AUTO;
5290 }
5291
5292#ifdef CONFIG_USB_OTG
5293
5294 if (hub->hdev->bus->is_b_host)
5295 portchange &= ~(USB_PORT_STAT_C_CONNECTION |
5296 USB_PORT_STAT_C_ENABLE);
5297#endif
5298
5299
5300 if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
5301 udev->state != USB_STATE_NOTATTACHED) {
5302 if (portstatus & USB_PORT_STAT_ENABLE) {
5303
5304
5305
5306
5307
5308
5309 descriptor = udev->descriptor;
5310 retval = usb_get_device_descriptor(udev,
5311 sizeof(udev->descriptor));
5312 if (retval < 0) {
5313 dev_dbg(&udev->dev,
5314 "can't read device descriptor %d\n",
5315 retval);
5316 } else {
5317 if (descriptors_changed(udev, &descriptor,
5318 udev->bos)) {
5319 dev_dbg(&udev->dev,
5320 "device descriptor has changed\n");
5321
5322 udev->descriptor = descriptor;
5323 } else {
5324 status = 0;
5325 }
5326 }
5327#ifdef CONFIG_PM
5328 } else if (udev->state == USB_STATE_SUSPENDED &&
5329 udev->persist_enabled) {
5330
5331
5332
5333 usb_unlock_port(port_dev);
5334 status = usb_remote_wakeup(udev);
5335 usb_lock_port(port_dev);
5336#endif
5337 } else {
5338 ;
5339 }
5340 }
5341 clear_bit(port1, hub->change_bits);
5342
5343
5344 if (status == 0)
5345 return;
5346
5347 usb_unlock_port(port_dev);
5348 hub_port_connect(hub, port1, portstatus, portchange);
5349 usb_lock_port(port_dev);
5350}
5351
5352
5353static void port_over_current_notify(struct usb_port *port_dev)
5354{
5355 char *envp[3];
5356 struct device *hub_dev;
5357 char *port_dev_path;
5358
5359 sysfs_notify(&port_dev->dev.kobj, NULL, "over_current_count");
5360
5361 hub_dev = port_dev->dev.parent;
5362
5363 if (!hub_dev)
5364 return;
5365
5366 port_dev_path = kobject_get_path(&port_dev->dev.kobj, GFP_KERNEL);
5367 if (!port_dev_path)
5368 return;
5369
5370 envp[0] = kasprintf(GFP_KERNEL, "OVER_CURRENT_PORT=%s", port_dev_path);
5371 if (!envp[0])
5372 goto exit_path;
5373
5374 envp[1] = kasprintf(GFP_KERNEL, "OVER_CURRENT_COUNT=%u",
5375 port_dev->over_current_count);
5376 if (!envp[1])
5377 goto exit;
5378
5379 envp[2] = NULL;
5380 kobject_uevent_env(&hub_dev->kobj, KOBJ_CHANGE, envp);
5381
5382 kfree(envp[1]);
5383exit:
5384 kfree(envp[0]);
5385exit_path:
5386 kfree(port_dev_path);
5387}
5388
5389static void port_event(struct usb_hub *hub, int port1)
5390 __must_hold(&port_dev->status_lock)
5391{
5392 int connect_change;
5393 struct usb_port *port_dev = hub->ports[port1 - 1];
5394 struct usb_device *udev = port_dev->child;
5395 struct usb_device *hdev = hub->hdev;
5396 u16 portstatus, portchange;
5397
5398 connect_change = test_bit(port1, hub->change_bits);
5399 clear_bit(port1, hub->event_bits);
5400 clear_bit(port1, hub->wakeup_bits);
5401
5402 if (hub_port_status(hub, port1, &portstatus, &portchange) < 0)
5403 return;
5404
5405 if (portchange & USB_PORT_STAT_C_CONNECTION) {
5406 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
5407 connect_change = 1;
5408 }
5409
5410 if (portchange & USB_PORT_STAT_C_ENABLE) {
5411 if (!connect_change)
5412 dev_dbg(&port_dev->dev, "enable change, status %08x\n",
5413 portstatus);
5414 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
5415
5416
5417
5418
5419
5420
5421 if (!(portstatus & USB_PORT_STAT_ENABLE)
5422 && !connect_change && udev) {
5423 dev_err(&port_dev->dev, "disabled by hub (EMI?), re-enabling...\n");
5424 connect_change = 1;
5425 }
5426 }
5427
5428 if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
5429 u16 status = 0, unused;
5430 port_dev->over_current_count++;
5431 port_over_current_notify(port_dev);
5432
5433 dev_dbg(&port_dev->dev, "over-current change #%u\n",
5434 port_dev->over_current_count);
5435 usb_clear_port_feature(hdev, port1,
5436 USB_PORT_FEAT_C_OVER_CURRENT);
5437 msleep(100);
5438 hub_power_on(hub, true);
5439 hub_port_status(hub, port1, &status, &unused);
5440 if (status & USB_PORT_STAT_OVERCURRENT)
5441 dev_err(&port_dev->dev, "over-current condition\n");
5442 }
5443
5444 if (portchange & USB_PORT_STAT_C_RESET) {
5445 dev_dbg(&port_dev->dev, "reset change\n");
5446 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_RESET);
5447 }
5448 if ((portchange & USB_PORT_STAT_C_BH_RESET)
5449 && hub_is_superspeed(hdev)) {
5450 dev_dbg(&port_dev->dev, "warm reset change\n");
5451 usb_clear_port_feature(hdev, port1,
5452 USB_PORT_FEAT_C_BH_PORT_RESET);
5453 }
5454 if (portchange & USB_PORT_STAT_C_LINK_STATE) {
5455 dev_dbg(&port_dev->dev, "link state change\n");
5456 usb_clear_port_feature(hdev, port1,
5457 USB_PORT_FEAT_C_PORT_LINK_STATE);
5458 }
5459 if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
5460 dev_warn(&port_dev->dev, "config error\n");
5461 usb_clear_port_feature(hdev, port1,
5462 USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
5463 }
5464
5465
5466 if (!pm_runtime_active(&port_dev->dev))
5467 return;
5468
5469 if (hub_handle_remote_wakeup(hub, port1, portstatus, portchange))
5470 connect_change = 1;
5471
5472
5473
5474
5475
5476 if (hub_port_warm_reset_required(hub, port1, portstatus)) {
5477 dev_dbg(&port_dev->dev, "do warm reset\n");
5478 if (!udev || !(portstatus & USB_PORT_STAT_CONNECTION)
5479 || udev->state == USB_STATE_NOTATTACHED) {
5480 if (hub_port_reset(hub, port1, NULL,
5481 HUB_BH_RESET_TIME, true) < 0)
5482 hub_port_disable(hub, port1, 1);
5483 } else {
5484 usb_unlock_port(port_dev);
5485 usb_lock_device(udev);
5486 usb_reset_device(udev);
5487 usb_unlock_device(udev);
5488 usb_lock_port(port_dev);
5489 connect_change = 0;
5490 }
5491 }
5492
5493 if (connect_change)
5494 hub_port_connect_change(hub, port1, portstatus, portchange);
5495}
5496
5497static void hub_event(struct work_struct *work)
5498{
5499 struct usb_device *hdev;
5500 struct usb_interface *intf;
5501 struct usb_hub *hub;
5502 struct device *hub_dev;
5503 u16 hubstatus;
5504 u16 hubchange;
5505 int i, ret;
5506
5507 hub = container_of(work, struct usb_hub, events);
5508 hdev = hub->hdev;
5509 hub_dev = hub->intfdev;
5510 intf = to_usb_interface(hub_dev);
5511
5512 kcov_remote_start_usb((u64)hdev->bus->busnum);
5513
5514 dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
5515 hdev->state, hdev->maxchild,
5516
5517 (u16) hub->change_bits[0],
5518 (u16) hub->event_bits[0]);
5519
5520
5521
5522 usb_lock_device(hdev);
5523 if (unlikely(hub->disconnected))
5524 goto out_hdev_lock;
5525
5526
5527 if (hdev->state == USB_STATE_NOTATTACHED) {
5528 hub->error = -ENODEV;
5529 hub_quiesce(hub, HUB_DISCONNECT);
5530 goto out_hdev_lock;
5531 }
5532
5533
5534 ret = usb_autopm_get_interface(intf);
5535 if (ret) {
5536 dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
5537 goto out_hdev_lock;
5538 }
5539
5540
5541 if (hub->quiescing)
5542 goto out_autopm;
5543
5544 if (hub->error) {
5545 dev_dbg(hub_dev, "resetting for error %d\n", hub->error);
5546
5547 ret = usb_reset_device(hdev);
5548 if (ret) {
5549 dev_dbg(hub_dev, "error resetting hub: %d\n", ret);
5550 goto out_autopm;
5551 }
5552
5553 hub->nerrors = 0;
5554 hub->error = 0;
5555 }
5556
5557
5558 for (i = 1; i <= hdev->maxchild; i++) {
5559 struct usb_port *port_dev = hub->ports[i - 1];
5560
5561 if (test_bit(i, hub->event_bits)
5562 || test_bit(i, hub->change_bits)
5563 || test_bit(i, hub->wakeup_bits)) {
5564
5565
5566
5567
5568
5569
5570
5571
5572
5573 pm_runtime_get_noresume(&port_dev->dev);
5574 pm_runtime_barrier(&port_dev->dev);
5575 usb_lock_port(port_dev);
5576 port_event(hub, i);
5577 usb_unlock_port(port_dev);
5578 pm_runtime_put_sync(&port_dev->dev);
5579 }
5580 }
5581
5582
5583 if (test_and_clear_bit(0, hub->event_bits) == 0)
5584 ;
5585 else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
5586 dev_err(hub_dev, "get_hub_status failed\n");
5587 else {
5588 if (hubchange & HUB_CHANGE_LOCAL_POWER) {
5589 dev_dbg(hub_dev, "power change\n");
5590 clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
5591 if (hubstatus & HUB_STATUS_LOCAL_POWER)
5592
5593 hub->limited_power = 1;
5594 else
5595 hub->limited_power = 0;
5596 }
5597 if (hubchange & HUB_CHANGE_OVERCURRENT) {
5598 u16 status = 0;
5599 u16 unused;
5600
5601 dev_dbg(hub_dev, "over-current change\n");
5602 clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
5603 msleep(500);
5604 hub_power_on(hub, true);
5605 hub_hub_status(hub, &status, &unused);
5606 if (status & HUB_STATUS_OVERCURRENT)
5607 dev_err(hub_dev, "over-current condition\n");
5608 }
5609 }
5610
5611out_autopm:
5612
5613 usb_autopm_put_interface_no_suspend(intf);
5614out_hdev_lock:
5615 usb_unlock_device(hdev);
5616
5617
5618 usb_autopm_put_interface(intf);
5619 kref_put(&hub->kref, hub_release);
5620
5621 kcov_remote_stop();
5622}
5623
5624static const struct usb_device_id hub_id_table[] = {
5625 { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
5626 | USB_DEVICE_ID_MATCH_PRODUCT
5627 | USB_DEVICE_ID_MATCH_INT_CLASS,
5628 .idVendor = USB_VENDOR_SMSC,
5629 .idProduct = USB_PRODUCT_USB5534B,
5630 .bInterfaceClass = USB_CLASS_HUB,
5631 .driver_info = HUB_QUIRK_DISABLE_AUTOSUSPEND},
5632 { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
5633 | USB_DEVICE_ID_MATCH_INT_CLASS,
5634 .idVendor = USB_VENDOR_GENESYS_LOGIC,
5635 .bInterfaceClass = USB_CLASS_HUB,
5636 .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
5637 { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
5638 .bDeviceClass = USB_CLASS_HUB},
5639 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
5640 .bInterfaceClass = USB_CLASS_HUB},
5641 { }
5642};
5643
5644MODULE_DEVICE_TABLE(usb, hub_id_table);
5645
5646static struct usb_driver hub_driver = {
5647 .name = "hub",
5648 .probe = hub_probe,
5649 .disconnect = hub_disconnect,
5650 .suspend = hub_suspend,
5651 .resume = hub_resume,
5652 .reset_resume = hub_reset_resume,
5653 .pre_reset = hub_pre_reset,
5654 .post_reset = hub_post_reset,
5655 .unlocked_ioctl = hub_ioctl,
5656 .id_table = hub_id_table,
5657 .supports_autosuspend = 1,
5658};
5659
5660int usb_hub_init(void)
5661{
5662 if (usb_register(&hub_driver) < 0) {
5663 printk(KERN_ERR "%s: can't register hub driver\n",
5664 usbcore_name);
5665 return -1;
5666 }
5667
5668
5669
5670
5671
5672
5673
5674 hub_wq = alloc_workqueue("usb_hub_wq", WQ_FREEZABLE, 0);
5675 if (hub_wq)
5676 return 0;
5677
5678
5679 usb_deregister(&hub_driver);
5680 pr_err("%s: can't allocate workqueue for usb hub\n", usbcore_name);
5681
5682 return -1;
5683}
5684
5685void usb_hub_cleanup(void)
5686{
5687 destroy_workqueue(hub_wq);
5688
5689
5690
5691
5692
5693
5694
5695
5696 usb_deregister(&hub_driver);
5697}
5698
5699
5700
5701
5702
5703
5704
5705
5706
5707
5708
5709
5710
5711
5712
5713
5714
5715
5716
5717
5718
5719
5720
5721
5722
5723
5724
5725
5726
5727
5728
5729
5730
5731
5732
5733static int usb_reset_and_verify_device(struct usb_device *udev)
5734{
5735 struct usb_device *parent_hdev = udev->parent;
5736 struct usb_hub *parent_hub;
5737 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
5738 struct usb_device_descriptor descriptor = udev->descriptor;
5739 struct usb_host_bos *bos;
5740 int i, j, ret = 0;
5741 int port1 = udev->portnum;
5742
5743 if (udev->state == USB_STATE_NOTATTACHED ||
5744 udev->state == USB_STATE_SUSPENDED) {
5745 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5746 udev->state);
5747 return -EINVAL;
5748 }
5749
5750 if (!parent_hdev)
5751 return -EISDIR;
5752
5753 parent_hub = usb_hub_to_struct_hub(parent_hdev);
5754
5755
5756
5757
5758 usb_disable_usb2_hardware_lpm(udev);
5759
5760
5761
5762
5763
5764 ret = usb_unlocked_disable_lpm(udev);
5765 if (ret) {
5766 dev_err(&udev->dev, "%s Failed to disable LPM\n", __func__);
5767 goto re_enumerate_no_bos;
5768 }
5769
5770 bos = udev->bos;
5771 udev->bos = NULL;
5772
5773 for (i = 0; i < SET_CONFIG_TRIES; ++i) {
5774
5775
5776
5777 usb_ep0_reinit(udev);
5778 ret = hub_port_init(parent_hub, udev, port1, i);
5779 if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
5780 break;
5781 }
5782
5783 if (ret < 0)
5784 goto re_enumerate;
5785
5786
5787 if (descriptors_changed(udev, &descriptor, bos)) {
5788 dev_info(&udev->dev, "device firmware changed\n");
5789 udev->descriptor = descriptor;
5790 goto re_enumerate;
5791 }
5792
5793
5794 if (!udev->actconfig)
5795 goto done;
5796
5797 mutex_lock(hcd->bandwidth_mutex);
5798 ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
5799 if (ret < 0) {
5800 dev_warn(&udev->dev,
5801 "Busted HC? Not enough HCD resources for "
5802 "old configuration.\n");
5803 mutex_unlock(hcd->bandwidth_mutex);
5804 goto re_enumerate;
5805 }
5806 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
5807 USB_REQ_SET_CONFIGURATION, 0,
5808 udev->actconfig->desc.bConfigurationValue, 0,
5809 NULL, 0, USB_CTRL_SET_TIMEOUT);
5810 if (ret < 0) {
5811 dev_err(&udev->dev,
5812 "can't restore configuration #%d (error=%d)\n",
5813 udev->actconfig->desc.bConfigurationValue, ret);
5814 mutex_unlock(hcd->bandwidth_mutex);
5815 goto re_enumerate;
5816 }
5817 mutex_unlock(hcd->bandwidth_mutex);
5818 usb_set_device_state(udev, USB_STATE_CONFIGURED);
5819
5820
5821
5822
5823
5824
5825
5826 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
5827 struct usb_host_config *config = udev->actconfig;
5828 struct usb_interface *intf = config->interface[i];
5829 struct usb_interface_descriptor *desc;
5830
5831 desc = &intf->cur_altsetting->desc;
5832 if (desc->bAlternateSetting == 0) {
5833 usb_disable_interface(udev, intf, true);
5834 usb_enable_interface(udev, intf, true);
5835 ret = 0;
5836 } else {
5837
5838
5839
5840
5841 intf->resetting_device = 1;
5842 ret = usb_set_interface(udev, desc->bInterfaceNumber,
5843 desc->bAlternateSetting);
5844 intf->resetting_device = 0;
5845 }
5846 if (ret < 0) {
5847 dev_err(&udev->dev, "failed to restore interface %d "
5848 "altsetting %d (error=%d)\n",
5849 desc->bInterfaceNumber,
5850 desc->bAlternateSetting,
5851 ret);
5852 goto re_enumerate;
5853 }
5854
5855 for (j = 0; j < intf->cur_altsetting->desc.bNumEndpoints; j++)
5856 intf->cur_altsetting->endpoint[j].streams = 0;
5857 }
5858
5859done:
5860
5861 usb_enable_usb2_hardware_lpm(udev);
5862 usb_unlocked_enable_lpm(udev);
5863 usb_enable_ltm(udev);
5864 usb_release_bos_descriptor(udev);
5865 udev->bos = bos;
5866 return 0;
5867
5868re_enumerate:
5869 usb_release_bos_descriptor(udev);
5870 udev->bos = bos;
5871re_enumerate_no_bos:
5872
5873 hub_port_logical_disconnect(parent_hub, port1);
5874 return -ENODEV;
5875}
5876
5877
5878
5879
5880
5881
5882
5883
5884
5885
5886
5887
5888
5889
5890
5891
5892
5893
5894
5895
5896
5897
5898int usb_reset_device(struct usb_device *udev)
5899{
5900 int ret;
5901 int i;
5902 unsigned int noio_flag;
5903 struct usb_port *port_dev;
5904 struct usb_host_config *config = udev->actconfig;
5905 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
5906
5907 if (udev->state == USB_STATE_NOTATTACHED) {
5908 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5909 udev->state);
5910 return -EINVAL;
5911 }
5912
5913 if (!udev->parent) {
5914
5915 dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
5916 return -EISDIR;
5917 }
5918
5919 port_dev = hub->ports[udev->portnum - 1];
5920
5921
5922
5923
5924
5925
5926
5927
5928
5929
5930 noio_flag = memalloc_noio_save();
5931
5932
5933 usb_autoresume_device(udev);
5934
5935 if (config) {
5936 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
5937 struct usb_interface *cintf = config->interface[i];
5938 struct usb_driver *drv;
5939 int unbind = 0;
5940
5941 if (cintf->dev.driver) {
5942 drv = to_usb_driver(cintf->dev.driver);
5943 if (drv->pre_reset && drv->post_reset)
5944 unbind = (drv->pre_reset)(cintf);
5945 else if (cintf->condition ==
5946 USB_INTERFACE_BOUND)
5947 unbind = 1;
5948 if (unbind)
5949 usb_forced_unbind_intf(cintf);
5950 }
5951 }
5952 }
5953
5954 usb_lock_port(port_dev);
5955 ret = usb_reset_and_verify_device(udev);
5956 usb_unlock_port(port_dev);
5957
5958 if (config) {
5959 for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
5960 struct usb_interface *cintf = config->interface[i];
5961 struct usb_driver *drv;
5962 int rebind = cintf->needs_binding;
5963
5964 if (!rebind && cintf->dev.driver) {
5965 drv = to_usb_driver(cintf->dev.driver);
5966 if (drv->post_reset)
5967 rebind = (drv->post_reset)(cintf);
5968 else if (cintf->condition ==
5969 USB_INTERFACE_BOUND)
5970 rebind = 1;
5971 if (rebind)
5972 cintf->needs_binding = 1;
5973 }
5974 }
5975
5976
5977 if (ret == 0)
5978 usb_unbind_and_rebind_marked_interfaces(udev);
5979 }
5980
5981 usb_autosuspend_device(udev);
5982 memalloc_noio_restore(noio_flag);
5983 return ret;
5984}
5985EXPORT_SYMBOL_GPL(usb_reset_device);
5986
5987
5988
5989
5990
5991
5992
5993
5994
5995
5996
5997
5998
5999
6000
6001
6002
6003
6004
6005
6006
6007
6008
6009
6010
6011
6012
6013
6014
6015
6016void usb_queue_reset_device(struct usb_interface *iface)
6017{
6018 if (schedule_work(&iface->reset_ws))
6019 usb_get_intf(iface);
6020}
6021EXPORT_SYMBOL_GPL(usb_queue_reset_device);
6022
6023
6024
6025
6026
6027
6028
6029
6030
6031
6032
6033
6034
6035
6036struct usb_device *usb_hub_find_child(struct usb_device *hdev,
6037 int port1)
6038{
6039 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
6040
6041 if (port1 < 1 || port1 > hdev->maxchild)
6042 return NULL;
6043 return hub->ports[port1 - 1]->child;
6044}
6045EXPORT_SYMBOL_GPL(usb_hub_find_child);
6046
6047void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
6048 struct usb_hub_descriptor *desc)
6049{
6050 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
6051 enum usb_port_connect_type connect_type;
6052 int i;
6053
6054 if (!hub)
6055 return;
6056
6057 if (!hub_is_superspeed(hdev)) {
6058 for (i = 1; i <= hdev->maxchild; i++) {
6059 struct usb_port *port_dev = hub->ports[i - 1];
6060
6061 connect_type = port_dev->connect_type;
6062 if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
6063 u8 mask = 1 << (i%8);
6064
6065 if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
6066 dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
6067 desc->u.hs.DeviceRemovable[i/8] |= mask;
6068 }
6069 }
6070 }
6071 } else {
6072 u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);
6073
6074 for (i = 1; i <= hdev->maxchild; i++) {
6075 struct usb_port *port_dev = hub->ports[i - 1];
6076
6077 connect_type = port_dev->connect_type;
6078 if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
6079 u16 mask = 1 << i;
6080
6081 if (!(port_removable & mask)) {
6082 dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
6083 port_removable |= mask;
6084 }
6085 }
6086 }
6087
6088 desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
6089 }
6090}
6091
6092#ifdef CONFIG_ACPI
6093
6094
6095
6096
6097
6098
6099
6100
6101acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
6102 int port1)
6103{
6104 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
6105
6106 if (!hub)
6107 return NULL;
6108
6109 return ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
6110}
6111#endif
6112