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