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