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