usb: hub_handle_remote_wakeup() only exists for CONFIG_PM=y
[karo-tx-linux.git] / drivers / usb / core / hub.c
1 /*
2  * USB hub driver.
3  *
4  * (C) Copyright 1999 Linus Torvalds
5  * (C) Copyright 1999 Johannes Erdfelt
6  * (C) Copyright 1999 Gregory P. Smith
7  * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
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 #define USB_VENDOR_GENESYS_LOGIC                0x05e3
37 #define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND        0x01
38
39 /* Protect struct usb_device->state and ->children members
40  * Note: Both are also protected by ->dev.sem, except that ->state can
41  * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
42 static DEFINE_SPINLOCK(device_state_lock);
43
44 /* khubd's worklist and its lock */
45 static DEFINE_SPINLOCK(hub_event_lock);
46 static LIST_HEAD(hub_event_list);       /* List of hubs needing servicing */
47
48 /* Wakes up khubd */
49 static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
50
51 static struct task_struct *khubd_task;
52
53 /* synchronize hub-port add/remove and peering operations */
54 DEFINE_MUTEX(usb_port_peer_mutex);
55
56 /* cycle leds on hubs that aren't blinking for attention */
57 static bool blinkenlights = 0;
58 module_param (blinkenlights, bool, S_IRUGO);
59 MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");
60
61 /*
62  * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about
63  * 10 seconds to send reply for the initial 64-byte descriptor request.
64  */
65 /* define initial 64-byte descriptor request timeout in milliseconds */
66 static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
67 module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
68 MODULE_PARM_DESC(initial_descriptor_timeout,
69                 "initial 64-byte descriptor request timeout in milliseconds "
70                 "(default 5000 - 5.0 seconds)");
71
72 /*
73  * As of 2.6.10 we introduce a new USB device initialization scheme which
74  * closely resembles the way Windows works.  Hopefully it will be compatible
75  * with a wider range of devices than the old scheme.  However some previously
76  * working devices may start giving rise to "device not accepting address"
77  * errors; if that happens the user can try the old scheme by adjusting the
78  * following module parameters.
79  *
80  * For maximum flexibility there are two boolean parameters to control the
81  * hub driver's behavior.  On the first initialization attempt, if the
82  * "old_scheme_first" parameter is set then the old scheme will be used,
83  * otherwise the new scheme is used.  If that fails and "use_both_schemes"
84  * is set, then the driver will make another attempt, using the other scheme.
85  */
86 static bool old_scheme_first = 0;
87 module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
88 MODULE_PARM_DESC(old_scheme_first,
89                  "start with the old device initialization scheme");
90
91 static bool use_both_schemes = 1;
92 module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
93 MODULE_PARM_DESC(use_both_schemes,
94                 "try the other device initialization scheme if the "
95                 "first one fails");
96
97 /* Mutual exclusion for EHCI CF initialization.  This interferes with
98  * port reset on some companion controllers.
99  */
100 DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
101 EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
102
103 #define HUB_DEBOUNCE_TIMEOUT    2000
104 #define HUB_DEBOUNCE_STEP         25
105 #define HUB_DEBOUNCE_STABLE      100
106
107 static int usb_reset_and_verify_device(struct usb_device *udev);
108
109 static inline char *portspeed(struct usb_hub *hub, int portstatus)
110 {
111         if (hub_is_superspeed(hub->hdev))
112                 return "5.0 Gb/s";
113         if (portstatus & USB_PORT_STAT_HIGH_SPEED)
114                 return "480 Mb/s";
115         else if (portstatus & USB_PORT_STAT_LOW_SPEED)
116                 return "1.5 Mb/s";
117         else
118                 return "12 Mb/s";
119 }
120
121 /* Note that hdev or one of its children must be locked! */
122 struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
123 {
124         if (!hdev || !hdev->actconfig || !hdev->maxchild)
125                 return NULL;
126         return usb_get_intfdata(hdev->actconfig->interface[0]);
127 }
128
129 static int usb_device_supports_lpm(struct usb_device *udev)
130 {
131         /* USB 2.1 (and greater) devices indicate LPM support through
132          * their USB 2.0 Extended Capabilities BOS descriptor.
133          */
134         if (udev->speed == USB_SPEED_HIGH) {
135                 if (udev->bos->ext_cap &&
136                         (USB_LPM_SUPPORT &
137                          le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
138                         return 1;
139                 return 0;
140         }
141
142         /*
143          * According to the USB 3.0 spec, all USB 3.0 devices must support LPM.
144          * However, there are some that don't, and they set the U1/U2 exit
145          * latencies to zero.
146          */
147         if (!udev->bos->ss_cap) {
148                 dev_info(&udev->dev, "No LPM exit latency info found, disabling LPM.\n");
149                 return 0;
150         }
151
152         if (udev->bos->ss_cap->bU1devExitLat == 0 &&
153                         udev->bos->ss_cap->bU2DevExitLat == 0) {
154                 if (udev->parent)
155                         dev_info(&udev->dev, "LPM exit latency is zeroed, disabling LPM.\n");
156                 else
157                         dev_info(&udev->dev, "We don't know the algorithms for LPM for this host, disabling LPM.\n");
158                 return 0;
159         }
160
161         if (!udev->parent || udev->parent->lpm_capable)
162                 return 1;
163         return 0;
164 }
165
166 /*
167  * Set the Maximum Exit Latency (MEL) for the host to initiate a transition from
168  * either U1 or U2.
169  */
170 static void usb_set_lpm_mel(struct usb_device *udev,
171                 struct usb3_lpm_parameters *udev_lpm_params,
172                 unsigned int udev_exit_latency,
173                 struct usb_hub *hub,
174                 struct usb3_lpm_parameters *hub_lpm_params,
175                 unsigned int hub_exit_latency)
176 {
177         unsigned int total_mel;
178         unsigned int device_mel;
179         unsigned int hub_mel;
180
181         /*
182          * Calculate the time it takes to transition all links from the roothub
183          * to the parent hub into U0.  The parent hub must then decode the
184          * packet (hub header decode latency) to figure out which port it was
185          * bound for.
186          *
187          * The Hub Header decode latency is expressed in 0.1us intervals (0x1
188          * means 0.1us).  Multiply that by 100 to get nanoseconds.
189          */
190         total_mel = hub_lpm_params->mel +
191                 (hub->descriptor->u.ss.bHubHdrDecLat * 100);
192
193         /*
194          * How long will it take to transition the downstream hub's port into
195          * U0?  The greater of either the hub exit latency or the device exit
196          * latency.
197          *
198          * The BOS U1/U2 exit latencies are expressed in 1us intervals.
199          * Multiply that by 1000 to get nanoseconds.
200          */
201         device_mel = udev_exit_latency * 1000;
202         hub_mel = hub_exit_latency * 1000;
203         if (device_mel > hub_mel)
204                 total_mel += device_mel;
205         else
206                 total_mel += hub_mel;
207
208         udev_lpm_params->mel = total_mel;
209 }
210
211 /*
212  * Set the maximum Device to Host Exit Latency (PEL) for the device to initiate
213  * a transition from either U1 or U2.
214  */
215 static void usb_set_lpm_pel(struct usb_device *udev,
216                 struct usb3_lpm_parameters *udev_lpm_params,
217                 unsigned int udev_exit_latency,
218                 struct usb_hub *hub,
219                 struct usb3_lpm_parameters *hub_lpm_params,
220                 unsigned int hub_exit_latency,
221                 unsigned int port_to_port_exit_latency)
222 {
223         unsigned int first_link_pel;
224         unsigned int hub_pel;
225
226         /*
227          * First, the device sends an LFPS to transition the link between the
228          * device and the parent hub into U0.  The exit latency is the bigger of
229          * the device exit latency or the hub exit latency.
230          */
231         if (udev_exit_latency > hub_exit_latency)
232                 first_link_pel = udev_exit_latency * 1000;
233         else
234                 first_link_pel = hub_exit_latency * 1000;
235
236         /*
237          * When the hub starts to receive the LFPS, there is a slight delay for
238          * it to figure out that one of the ports is sending an LFPS.  Then it
239          * will forward the LFPS to its upstream link.  The exit latency is the
240          * delay, plus the PEL that we calculated for this hub.
241          */
242         hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel;
243
244         /*
245          * According to figure C-7 in the USB 3.0 spec, the PEL for this device
246          * is the greater of the two exit latencies.
247          */
248         if (first_link_pel > hub_pel)
249                 udev_lpm_params->pel = first_link_pel;
250         else
251                 udev_lpm_params->pel = hub_pel;
252 }
253
254 /*
255  * Set the System Exit Latency (SEL) to indicate the total worst-case time from
256  * when a device initiates a transition to U0, until when it will receive the
257  * first packet from the host controller.
258  *
259  * Section C.1.5.1 describes the four components to this:
260  *  - t1: device PEL
261  *  - t2: time for the ERDY to make it from the device to the host.
262  *  - t3: a host-specific delay to process the ERDY.
263  *  - t4: time for the packet to make it from the host to the device.
264  *
265  * t3 is specific to both the xHCI host and the platform the host is integrated
266  * into.  The Intel HW folks have said it's negligible, FIXME if a different
267  * vendor says otherwise.
268  */
269 static void usb_set_lpm_sel(struct usb_device *udev,
270                 struct usb3_lpm_parameters *udev_lpm_params)
271 {
272         struct usb_device *parent;
273         unsigned int num_hubs;
274         unsigned int total_sel;
275
276         /* t1 = device PEL */
277         total_sel = udev_lpm_params->pel;
278         /* How many external hubs are in between the device & the root port. */
279         for (parent = udev->parent, num_hubs = 0; parent->parent;
280                         parent = parent->parent)
281                 num_hubs++;
282         /* t2 = 2.1us + 250ns * (num_hubs - 1) */
283         if (num_hubs > 0)
284                 total_sel += 2100 + 250 * (num_hubs - 1);
285
286         /* t4 = 250ns * num_hubs */
287         total_sel += 250 * num_hubs;
288
289         udev_lpm_params->sel = total_sel;
290 }
291
292 static void usb_set_lpm_parameters(struct usb_device *udev)
293 {
294         struct usb_hub *hub;
295         unsigned int port_to_port_delay;
296         unsigned int udev_u1_del;
297         unsigned int udev_u2_del;
298         unsigned int hub_u1_del;
299         unsigned int hub_u2_del;
300
301         if (!udev->lpm_capable || udev->speed != USB_SPEED_SUPER)
302                 return;
303
304         hub = usb_hub_to_struct_hub(udev->parent);
305         /* It doesn't take time to transition the roothub into U0, since it
306          * doesn't have an upstream link.
307          */
308         if (!hub)
309                 return;
310
311         udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
312         udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
313         hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
314         hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
315
316         usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
317                         hub, &udev->parent->u1_params, hub_u1_del);
318
319         usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del,
320                         hub, &udev->parent->u2_params, hub_u2_del);
321
322         /*
323          * Appendix C, section C.2.2.2, says that there is a slight delay from
324          * when the parent hub notices the downstream port is trying to
325          * transition to U0 to when the hub initiates a U0 transition on its
326          * upstream port.  The section says the delays are tPort2PortU1EL and
327          * tPort2PortU2EL, but it doesn't define what they are.
328          *
329          * The hub chapter, sections 10.4.2.4 and 10.4.2.5 seem to be talking
330          * about the same delays.  Use the maximum delay calculations from those
331          * sections.  For U1, it's tHubPort2PortExitLat, which is 1us max.  For
332          * U2, it's tHubPort2PortExitLat + U2DevExitLat - U1DevExitLat.  I
333          * assume the device exit latencies they are talking about are the hub
334          * exit latencies.
335          *
336          * What do we do if the U2 exit latency is less than the U1 exit
337          * latency?  It's possible, although not likely...
338          */
339         port_to_port_delay = 1;
340
341         usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del,
342                         hub, &udev->parent->u1_params, hub_u1_del,
343                         port_to_port_delay);
344
345         if (hub_u2_del > hub_u1_del)
346                 port_to_port_delay = 1 + hub_u2_del - hub_u1_del;
347         else
348                 port_to_port_delay = 1 + hub_u1_del;
349
350         usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del,
351                         hub, &udev->parent->u2_params, hub_u2_del,
352                         port_to_port_delay);
353
354         /* Now that we've got PEL, calculate SEL. */
355         usb_set_lpm_sel(udev, &udev->u1_params);
356         usb_set_lpm_sel(udev, &udev->u2_params);
357 }
358
359 /* USB 2.0 spec Section 11.24.4.5 */
360 static int get_hub_descriptor(struct usb_device *hdev, void *data)
361 {
362         int i, ret, size;
363         unsigned dtype;
364
365         if (hub_is_superspeed(hdev)) {
366                 dtype = USB_DT_SS_HUB;
367                 size = USB_DT_SS_HUB_SIZE;
368         } else {
369                 dtype = USB_DT_HUB;
370                 size = sizeof(struct usb_hub_descriptor);
371         }
372
373         for (i = 0; i < 3; i++) {
374                 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
375                         USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
376                         dtype << 8, 0, data, size,
377                         USB_CTRL_GET_TIMEOUT);
378                 if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
379                         return ret;
380         }
381         return -EINVAL;
382 }
383
384 /*
385  * USB 2.0 spec Section 11.24.2.1
386  */
387 static int clear_hub_feature(struct usb_device *hdev, int feature)
388 {
389         return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
390                 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
391 }
392
393 /*
394  * USB 2.0 spec Section 11.24.2.2
395  */
396 int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
397 {
398         return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
399                 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
400                 NULL, 0, 1000);
401 }
402
403 /*
404  * USB 2.0 spec Section 11.24.2.13
405  */
406 static int set_port_feature(struct usb_device *hdev, int port1, int feature)
407 {
408         return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
409                 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
410                 NULL, 0, 1000);
411 }
412
413 static char *to_led_name(int selector)
414 {
415         switch (selector) {
416         case HUB_LED_AMBER:
417                 return "amber";
418         case HUB_LED_GREEN:
419                 return "green";
420         case HUB_LED_OFF:
421                 return "off";
422         case HUB_LED_AUTO:
423                 return "auto";
424         default:
425                 return "??";
426         }
427 }
428
429 /*
430  * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
431  * for info about using port indicators
432  */
433 static void set_port_led(struct usb_hub *hub, int port1, int selector)
434 {
435         struct usb_port *port_dev = hub->ports[port1 - 1];
436         int status;
437
438         status = set_port_feature(hub->hdev, (selector << 8) | port1,
439                         USB_PORT_FEAT_INDICATOR);
440         dev_dbg(&port_dev->dev, "indicator %s status %d\n",
441                 to_led_name(selector), status);
442 }
443
444 #define LED_CYCLE_PERIOD        ((2*HZ)/3)
445
446 static void led_work (struct work_struct *work)
447 {
448         struct usb_hub          *hub =
449                 container_of(work, struct usb_hub, leds.work);
450         struct usb_device       *hdev = hub->hdev;
451         unsigned                i;
452         unsigned                changed = 0;
453         int                     cursor = -1;
454
455         if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
456                 return;
457
458         for (i = 0; i < hdev->maxchild; i++) {
459                 unsigned        selector, mode;
460
461                 /* 30%-50% duty cycle */
462
463                 switch (hub->indicator[i]) {
464                 /* cycle marker */
465                 case INDICATOR_CYCLE:
466                         cursor = i;
467                         selector = HUB_LED_AUTO;
468                         mode = INDICATOR_AUTO;
469                         break;
470                 /* blinking green = sw attention */
471                 case INDICATOR_GREEN_BLINK:
472                         selector = HUB_LED_GREEN;
473                         mode = INDICATOR_GREEN_BLINK_OFF;
474                         break;
475                 case INDICATOR_GREEN_BLINK_OFF:
476                         selector = HUB_LED_OFF;
477                         mode = INDICATOR_GREEN_BLINK;
478                         break;
479                 /* blinking amber = hw attention */
480                 case INDICATOR_AMBER_BLINK:
481                         selector = HUB_LED_AMBER;
482                         mode = INDICATOR_AMBER_BLINK_OFF;
483                         break;
484                 case INDICATOR_AMBER_BLINK_OFF:
485                         selector = HUB_LED_OFF;
486                         mode = INDICATOR_AMBER_BLINK;
487                         break;
488                 /* blink green/amber = reserved */
489                 case INDICATOR_ALT_BLINK:
490                         selector = HUB_LED_GREEN;
491                         mode = INDICATOR_ALT_BLINK_OFF;
492                         break;
493                 case INDICATOR_ALT_BLINK_OFF:
494                         selector = HUB_LED_AMBER;
495                         mode = INDICATOR_ALT_BLINK;
496                         break;
497                 default:
498                         continue;
499                 }
500                 if (selector != HUB_LED_AUTO)
501                         changed = 1;
502                 set_port_led(hub, i + 1, selector);
503                 hub->indicator[i] = mode;
504         }
505         if (!changed && blinkenlights) {
506                 cursor++;
507                 cursor %= hdev->maxchild;
508                 set_port_led(hub, cursor + 1, HUB_LED_GREEN);
509                 hub->indicator[cursor] = INDICATOR_CYCLE;
510                 changed++;
511         }
512         if (changed)
513                 queue_delayed_work(system_power_efficient_wq,
514                                 &hub->leds, LED_CYCLE_PERIOD);
515 }
516
517 /* use a short timeout for hub/port status fetches */
518 #define USB_STS_TIMEOUT         1000
519 #define USB_STS_RETRIES         5
520
521 /*
522  * USB 2.0 spec Section 11.24.2.6
523  */
524 static int get_hub_status(struct usb_device *hdev,
525                 struct usb_hub_status *data)
526 {
527         int i, status = -ETIMEDOUT;
528
529         for (i = 0; i < USB_STS_RETRIES &&
530                         (status == -ETIMEDOUT || status == -EPIPE); i++) {
531                 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
532                         USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
533                         data, sizeof(*data), USB_STS_TIMEOUT);
534         }
535         return status;
536 }
537
538 /*
539  * USB 2.0 spec Section 11.24.2.7
540  */
541 static int get_port_status(struct usb_device *hdev, int port1,
542                 struct usb_port_status *data)
543 {
544         int i, status = -ETIMEDOUT;
545
546         for (i = 0; i < USB_STS_RETRIES &&
547                         (status == -ETIMEDOUT || status == -EPIPE); i++) {
548                 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
549                         USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
550                         data, sizeof(*data), USB_STS_TIMEOUT);
551         }
552         return status;
553 }
554
555 static int hub_port_status(struct usb_hub *hub, int port1,
556                 u16 *status, u16 *change)
557 {
558         int ret;
559
560         mutex_lock(&hub->status_mutex);
561         ret = get_port_status(hub->hdev, port1, &hub->status->port);
562         if (ret < 4) {
563                 if (ret != -ENODEV)
564                         dev_err(hub->intfdev,
565                                 "%s failed (err = %d)\n", __func__, ret);
566                 if (ret >= 0)
567                         ret = -EIO;
568         } else {
569                 *status = le16_to_cpu(hub->status->port.wPortStatus);
570                 *change = le16_to_cpu(hub->status->port.wPortChange);
571
572                 ret = 0;
573         }
574         mutex_unlock(&hub->status_mutex);
575         return ret;
576 }
577
578 static void kick_khubd(struct usb_hub *hub)
579 {
580         unsigned long   flags;
581
582         spin_lock_irqsave(&hub_event_lock, flags);
583         if (!hub->disconnected && list_empty(&hub->event_list)) {
584                 list_add_tail(&hub->event_list, &hub_event_list);
585
586                 /* Suppress autosuspend until khubd runs */
587                 usb_autopm_get_interface_no_resume(
588                                 to_usb_interface(hub->intfdev));
589                 wake_up(&khubd_wait);
590         }
591         spin_unlock_irqrestore(&hub_event_lock, flags);
592 }
593
594 void usb_kick_khubd(struct usb_device *hdev)
595 {
596         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
597
598         if (hub)
599                 kick_khubd(hub);
600 }
601
602 /*
603  * Let the USB core know that a USB 3.0 device has sent a Function Wake Device
604  * Notification, which indicates it had initiated remote wakeup.
605  *
606  * USB 3.0 hubs do not report the port link state change from U3 to U0 when the
607  * device initiates resume, so the USB core will not receive notice of the
608  * resume through the normal hub interrupt URB.
609  */
610 void usb_wakeup_notification(struct usb_device *hdev,
611                 unsigned int portnum)
612 {
613         struct usb_hub *hub;
614
615         if (!hdev)
616                 return;
617
618         hub = usb_hub_to_struct_hub(hdev);
619         if (hub) {
620                 set_bit(portnum, hub->wakeup_bits);
621                 kick_khubd(hub);
622         }
623 }
624 EXPORT_SYMBOL_GPL(usb_wakeup_notification);
625
626 /* completion function, fires on port status changes and various faults */
627 static void hub_irq(struct urb *urb)
628 {
629         struct usb_hub *hub = urb->context;
630         int status = urb->status;
631         unsigned i;
632         unsigned long bits;
633
634         switch (status) {
635         case -ENOENT:           /* synchronous unlink */
636         case -ECONNRESET:       /* async unlink */
637         case -ESHUTDOWN:        /* hardware going away */
638                 return;
639
640         default:                /* presumably an error */
641                 /* Cause a hub reset after 10 consecutive errors */
642                 dev_dbg (hub->intfdev, "transfer --> %d\n", status);
643                 if ((++hub->nerrors < 10) || hub->error)
644                         goto resubmit;
645                 hub->error = status;
646                 /* FALL THROUGH */
647
648         /* let khubd handle things */
649         case 0:                 /* we got data:  port status changed */
650                 bits = 0;
651                 for (i = 0; i < urb->actual_length; ++i)
652                         bits |= ((unsigned long) ((*hub->buffer)[i]))
653                                         << (i*8);
654                 hub->event_bits[0] = bits;
655                 break;
656         }
657
658         hub->nerrors = 0;
659
660         /* Something happened, let khubd figure it out */
661         kick_khubd(hub);
662
663 resubmit:
664         if (hub->quiescing)
665                 return;
666
667         if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
668                         && status != -ENODEV && status != -EPERM)
669                 dev_err (hub->intfdev, "resubmit --> %d\n", status);
670 }
671
672 /* USB 2.0 spec Section 11.24.2.3 */
673 static inline int
674 hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
675 {
676         /* Need to clear both directions for control ep */
677         if (((devinfo >> 11) & USB_ENDPOINT_XFERTYPE_MASK) ==
678                         USB_ENDPOINT_XFER_CONTROL) {
679                 int status = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
680                                 HUB_CLEAR_TT_BUFFER, USB_RT_PORT,
681                                 devinfo ^ 0x8000, tt, NULL, 0, 1000);
682                 if (status)
683                         return status;
684         }
685         return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
686                                HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
687                                tt, NULL, 0, 1000);
688 }
689
690 /*
691  * enumeration blocks khubd for a long time. we use keventd instead, since
692  * long blocking there is the exception, not the rule.  accordingly, HCDs
693  * talking to TTs must queue control transfers (not just bulk and iso), so
694  * both can talk to the same hub concurrently.
695  */
696 static void hub_tt_work(struct work_struct *work)
697 {
698         struct usb_hub          *hub =
699                 container_of(work, struct usb_hub, tt.clear_work);
700         unsigned long           flags;
701
702         spin_lock_irqsave (&hub->tt.lock, flags);
703         while (!list_empty(&hub->tt.clear_list)) {
704                 struct list_head        *next;
705                 struct usb_tt_clear     *clear;
706                 struct usb_device       *hdev = hub->hdev;
707                 const struct hc_driver  *drv;
708                 int                     status;
709
710                 next = hub->tt.clear_list.next;
711                 clear = list_entry (next, struct usb_tt_clear, clear_list);
712                 list_del (&clear->clear_list);
713
714                 /* drop lock so HCD can concurrently report other TT errors */
715                 spin_unlock_irqrestore (&hub->tt.lock, flags);
716                 status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
717                 if (status && status != -ENODEV)
718                         dev_err (&hdev->dev,
719                                 "clear tt %d (%04x) error %d\n",
720                                 clear->tt, clear->devinfo, status);
721
722                 /* Tell the HCD, even if the operation failed */
723                 drv = clear->hcd->driver;
724                 if (drv->clear_tt_buffer_complete)
725                         (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
726
727                 kfree(clear);
728                 spin_lock_irqsave(&hub->tt.lock, flags);
729         }
730         spin_unlock_irqrestore (&hub->tt.lock, flags);
731 }
732
733 /**
734  * usb_hub_set_port_power - control hub port's power state
735  * @hdev: USB device belonging to the usb hub
736  * @hub: target hub
737  * @port1: port index
738  * @set: expected status
739  *
740  * call this function to control port's power via setting or
741  * clearing the port's PORT_POWER feature.
742  *
743  * Return: 0 if successful. A negative error code otherwise.
744  */
745 int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
746                            int port1, bool set)
747 {
748         int ret;
749
750         if (set)
751                 ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
752         else
753                 ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
754
755         if (ret)
756                 return ret;
757
758         if (set)
759                 set_bit(port1, hub->power_bits);
760         else
761                 clear_bit(port1, hub->power_bits);
762         return 0;
763 }
764
765 /**
766  * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
767  * @urb: an URB associated with the failed or incomplete split transaction
768  *
769  * High speed HCDs use this to tell the hub driver that some split control or
770  * bulk transaction failed in a way that requires clearing internal state of
771  * a transaction translator.  This is normally detected (and reported) from
772  * interrupt context.
773  *
774  * It may not be possible for that hub to handle additional full (or low)
775  * speed transactions until that state is fully cleared out.
776  *
777  * Return: 0 if successful. A negative error code otherwise.
778  */
779 int usb_hub_clear_tt_buffer(struct urb *urb)
780 {
781         struct usb_device       *udev = urb->dev;
782         int                     pipe = urb->pipe;
783         struct usb_tt           *tt = udev->tt;
784         unsigned long           flags;
785         struct usb_tt_clear     *clear;
786
787         /* we've got to cope with an arbitrary number of pending TT clears,
788          * since each TT has "at least two" buffers that can need it (and
789          * there can be many TTs per hub).  even if they're uncommon.
790          */
791         if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) {
792                 dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
793                 /* FIXME recover somehow ... RESET_TT? */
794                 return -ENOMEM;
795         }
796
797         /* info that CLEAR_TT_BUFFER needs */
798         clear->tt = tt->multi ? udev->ttport : 1;
799         clear->devinfo = usb_pipeendpoint (pipe);
800         clear->devinfo |= udev->devnum << 4;
801         clear->devinfo |= usb_pipecontrol (pipe)
802                         ? (USB_ENDPOINT_XFER_CONTROL << 11)
803                         : (USB_ENDPOINT_XFER_BULK << 11);
804         if (usb_pipein (pipe))
805                 clear->devinfo |= 1 << 15;
806
807         /* info for completion callback */
808         clear->hcd = bus_to_hcd(udev->bus);
809         clear->ep = urb->ep;
810
811         /* tell keventd to clear state for this TT */
812         spin_lock_irqsave (&tt->lock, flags);
813         list_add_tail (&clear->clear_list, &tt->clear_list);
814         schedule_work(&tt->clear_work);
815         spin_unlock_irqrestore (&tt->lock, flags);
816         return 0;
817 }
818 EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
819
820 static void hub_power_on(struct usb_hub *hub, bool do_delay)
821 {
822         int port1;
823
824         /* Enable power on each port.  Some hubs have reserved values
825          * of LPSM (> 2) in their descriptors, even though they are
826          * USB 2.0 hubs.  Some hubs do not implement port-power switching
827          * but only emulate it.  In all cases, the ports won't work
828          * unless we send these messages to the hub.
829          */
830         if (hub_is_port_power_switchable(hub))
831                 dev_dbg(hub->intfdev, "enabling power on all ports\n");
832         else
833                 dev_dbg(hub->intfdev, "trying to enable port power on "
834                                 "non-switchable hub\n");
835         for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
836                 if (test_bit(port1, hub->power_bits))
837                         set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
838                 else
839                         usb_clear_port_feature(hub->hdev, port1,
840                                                 USB_PORT_FEAT_POWER);
841         if (do_delay)
842                 msleep(hub_power_on_good_delay(hub));
843 }
844
845 static int hub_hub_status(struct usb_hub *hub,
846                 u16 *status, u16 *change)
847 {
848         int ret;
849
850         mutex_lock(&hub->status_mutex);
851         ret = get_hub_status(hub->hdev, &hub->status->hub);
852         if (ret < 0) {
853                 if (ret != -ENODEV)
854                         dev_err(hub->intfdev,
855                                 "%s failed (err = %d)\n", __func__, ret);
856         } else {
857                 *status = le16_to_cpu(hub->status->hub.wHubStatus);
858                 *change = le16_to_cpu(hub->status->hub.wHubChange);
859                 ret = 0;
860         }
861         mutex_unlock(&hub->status_mutex);
862         return ret;
863 }
864
865 static int hub_set_port_link_state(struct usb_hub *hub, int port1,
866                         unsigned int link_status)
867 {
868         return set_port_feature(hub->hdev,
869                         port1 | (link_status << 3),
870                         USB_PORT_FEAT_LINK_STATE);
871 }
872
873 /*
874  * If USB 3.0 ports are placed into the Disabled state, they will no longer
875  * detect any device connects or disconnects.  This is generally not what the
876  * USB core wants, since it expects a disabled port to produce a port status
877  * change event when a new device connects.
878  *
879  * Instead, set the link state to Disabled, wait for the link to settle into
880  * that state, clear any change bits, and then put the port into the RxDetect
881  * state.
882  */
883 static int hub_usb3_port_disable(struct usb_hub *hub, int port1)
884 {
885         int ret;
886         int total_time;
887         u16 portchange, portstatus;
888
889         if (!hub_is_superspeed(hub->hdev))
890                 return -EINVAL;
891
892         ret = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_SS_DISABLED);
893         if (ret)
894                 return ret;
895
896         /* Wait for the link to enter the disabled state. */
897         for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
898                 ret = hub_port_status(hub, port1, &portstatus, &portchange);
899                 if (ret < 0)
900                         return ret;
901
902                 if ((portstatus & USB_PORT_STAT_LINK_STATE) ==
903                                 USB_SS_PORT_LS_SS_DISABLED)
904                         break;
905                 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
906                         break;
907                 msleep(HUB_DEBOUNCE_STEP);
908         }
909         if (total_time >= HUB_DEBOUNCE_TIMEOUT)
910                 dev_warn(&hub->ports[port1 - 1]->dev,
911                                 "Could not disable after %d ms\n", total_time);
912
913         return hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_RX_DETECT);
914 }
915
916 static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
917 {
918         struct usb_port *port_dev = hub->ports[port1 - 1];
919         struct usb_device *hdev = hub->hdev;
920         int ret = 0;
921
922         if (port_dev->child && set_state)
923                 usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
924         if (!hub->error) {
925                 if (hub_is_superspeed(hub->hdev))
926                         ret = hub_usb3_port_disable(hub, port1);
927                 else
928                         ret = usb_clear_port_feature(hdev, port1,
929                                         USB_PORT_FEAT_ENABLE);
930         }
931         if (ret && ret != -ENODEV)
932                 dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
933         return ret;
934 }
935
936 /*
937  * Disable a port and mark a logical connect-change event, so that some
938  * time later khubd will disconnect() any existing usb_device on the port
939  * and will re-enumerate if there actually is a device attached.
940  */
941 static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
942 {
943         dev_dbg(&hub->ports[port1 - 1]->dev, "logical disconnect\n");
944         hub_port_disable(hub, port1, 1);
945
946         /* FIXME let caller ask to power down the port:
947          *  - some devices won't enumerate without a VBUS power cycle
948          *  - SRP saves power that way
949          *  - ... new call, TBD ...
950          * That's easy if this hub can switch power per-port, and
951          * khubd reactivates the port later (timer, SRP, etc).
952          * Powerdown must be optional, because of reset/DFU.
953          */
954
955         set_bit(port1, hub->change_bits);
956         kick_khubd(hub);
957 }
958
959 /**
960  * usb_remove_device - disable a device's port on its parent hub
961  * @udev: device to be disabled and removed
962  * Context: @udev locked, must be able to sleep.
963  *
964  * After @udev's port has been disabled, khubd is notified and it will
965  * see that the device has been disconnected.  When the device is
966  * physically unplugged and something is plugged in, the events will
967  * be received and processed normally.
968  *
969  * Return: 0 if successful. A negative error code otherwise.
970  */
971 int usb_remove_device(struct usb_device *udev)
972 {
973         struct usb_hub *hub;
974         struct usb_interface *intf;
975
976         if (!udev->parent)      /* Can't remove a root hub */
977                 return -EINVAL;
978         hub = usb_hub_to_struct_hub(udev->parent);
979         intf = to_usb_interface(hub->intfdev);
980
981         usb_autopm_get_interface(intf);
982         set_bit(udev->portnum, hub->removed_bits);
983         hub_port_logical_disconnect(hub, udev->portnum);
984         usb_autopm_put_interface(intf);
985         return 0;
986 }
987
988 enum hub_activation_type {
989         HUB_INIT, HUB_INIT2, HUB_INIT3,         /* INITs must come first */
990         HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
991 };
992
993 static void hub_init_func2(struct work_struct *ws);
994 static void hub_init_func3(struct work_struct *ws);
995
996 static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
997 {
998         struct usb_device *hdev = hub->hdev;
999         struct usb_hcd *hcd;
1000         int ret;
1001         int port1;
1002         int status;
1003         bool need_debounce_delay = false;
1004         unsigned delay;
1005
1006         /* Continue a partial initialization */
1007         if (type == HUB_INIT2)
1008                 goto init2;
1009         if (type == HUB_INIT3)
1010                 goto init3;
1011
1012         /* The superspeed hub except for root hub has to use Hub Depth
1013          * value as an offset into the route string to locate the bits
1014          * it uses to determine the downstream port number. So hub driver
1015          * should send a set hub depth request to superspeed hub after
1016          * the superspeed hub is set configuration in initialization or
1017          * reset procedure.
1018          *
1019          * After a resume, port power should still be on.
1020          * For any other type of activation, turn it on.
1021          */
1022         if (type != HUB_RESUME) {
1023                 if (hdev->parent && hub_is_superspeed(hdev)) {
1024                         ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
1025                                         HUB_SET_DEPTH, USB_RT_HUB,
1026                                         hdev->level - 1, 0, NULL, 0,
1027                                         USB_CTRL_SET_TIMEOUT);
1028                         if (ret < 0)
1029                                 dev_err(hub->intfdev,
1030                                                 "set hub depth failed\n");
1031                 }
1032
1033                 /* Speed up system boot by using a delayed_work for the
1034                  * hub's initial power-up delays.  This is pretty awkward
1035                  * and the implementation looks like a home-brewed sort of
1036                  * setjmp/longjmp, but it saves at least 100 ms for each
1037                  * root hub (assuming usbcore is compiled into the kernel
1038                  * rather than as a module).  It adds up.
1039                  *
1040                  * This can't be done for HUB_RESUME or HUB_RESET_RESUME
1041                  * because for those activation types the ports have to be
1042                  * operational when we return.  In theory this could be done
1043                  * for HUB_POST_RESET, but it's easier not to.
1044                  */
1045                 if (type == HUB_INIT) {
1046                         unsigned delay = hub_power_on_good_delay(hub);
1047
1048                         hub_power_on(hub, false);
1049                         INIT_DELAYED_WORK(&hub->init_work, hub_init_func2);
1050                         queue_delayed_work(system_power_efficient_wq,
1051                                         &hub->init_work,
1052                                         msecs_to_jiffies(delay));
1053
1054                         /* Suppress autosuspend until init is done */
1055                         usb_autopm_get_interface_no_resume(
1056                                         to_usb_interface(hub->intfdev));
1057                         return;         /* Continues at init2: below */
1058                 } else if (type == HUB_RESET_RESUME) {
1059                         /* The internal host controller state for the hub device
1060                          * may be gone after a host power loss on system resume.
1061                          * Update the device's info so the HW knows it's a hub.
1062                          */
1063                         hcd = bus_to_hcd(hdev->bus);
1064                         if (hcd->driver->update_hub_device) {
1065                                 ret = hcd->driver->update_hub_device(hcd, hdev,
1066                                                 &hub->tt, GFP_NOIO);
1067                                 if (ret < 0) {
1068                                         dev_err(hub->intfdev, "Host not "
1069                                                         "accepting hub info "
1070                                                         "update.\n");
1071                                         dev_err(hub->intfdev, "LS/FS devices "
1072                                                         "and hubs may not work "
1073                                                         "under this hub\n.");
1074                                 }
1075                         }
1076                         hub_power_on(hub, true);
1077                 } else {
1078                         hub_power_on(hub, true);
1079                 }
1080         }
1081  init2:
1082
1083         /*
1084          * Check each port and set hub->change_bits to let khubd know
1085          * which ports need attention.
1086          */
1087         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
1088                 struct usb_port *port_dev = hub->ports[port1 - 1];
1089                 struct usb_device *udev = port_dev->child;
1090                 u16 portstatus, portchange;
1091
1092                 portstatus = portchange = 0;
1093                 status = hub_port_status(hub, port1, &portstatus, &portchange);
1094                 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1095                         dev_dbg(&port_dev->dev, "status %04x change %04x\n",
1096                                         portstatus, portchange);
1097
1098                 /*
1099                  * After anything other than HUB_RESUME (i.e., initialization
1100                  * or any sort of reset), every port should be disabled.
1101                  * Unconnected ports should likewise be disabled (paranoia),
1102                  * and so should ports for which we have no usb_device.
1103                  */
1104                 if ((portstatus & USB_PORT_STAT_ENABLE) && (
1105                                 type != HUB_RESUME ||
1106                                 !(portstatus & USB_PORT_STAT_CONNECTION) ||
1107                                 !udev ||
1108                                 udev->state == USB_STATE_NOTATTACHED)) {
1109                         /*
1110                          * USB3 protocol ports will automatically transition
1111                          * to Enabled state when detect an USB3.0 device attach.
1112                          * Do not disable USB3 protocol ports, just pretend
1113                          * power was lost
1114                          */
1115                         portstatus &= ~USB_PORT_STAT_ENABLE;
1116                         if (!hub_is_superspeed(hdev))
1117                                 usb_clear_port_feature(hdev, port1,
1118                                                    USB_PORT_FEAT_ENABLE);
1119                 }
1120
1121                 /* Clear status-change flags; we'll debounce later */
1122                 if (portchange & USB_PORT_STAT_C_CONNECTION) {
1123                         need_debounce_delay = true;
1124                         usb_clear_port_feature(hub->hdev, port1,
1125                                         USB_PORT_FEAT_C_CONNECTION);
1126                 }
1127                 if (portchange & USB_PORT_STAT_C_ENABLE) {
1128                         need_debounce_delay = true;
1129                         usb_clear_port_feature(hub->hdev, port1,
1130                                         USB_PORT_FEAT_C_ENABLE);
1131                 }
1132                 if (portchange & USB_PORT_STAT_C_RESET) {
1133                         need_debounce_delay = true;
1134                         usb_clear_port_feature(hub->hdev, port1,
1135                                         USB_PORT_FEAT_C_RESET);
1136                 }
1137                 if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
1138                                 hub_is_superspeed(hub->hdev)) {
1139                         need_debounce_delay = true;
1140                         usb_clear_port_feature(hub->hdev, port1,
1141                                         USB_PORT_FEAT_C_BH_PORT_RESET);
1142                 }
1143                 /* We can forget about a "removed" device when there's a
1144                  * physical disconnect or the connect status changes.
1145                  */
1146                 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
1147                                 (portchange & USB_PORT_STAT_C_CONNECTION))
1148                         clear_bit(port1, hub->removed_bits);
1149
1150                 if (!udev || udev->state == USB_STATE_NOTATTACHED) {
1151                         /* Tell khubd to disconnect the device or
1152                          * check for a new connection
1153                          */
1154                         if (udev || (portstatus & USB_PORT_STAT_CONNECTION) ||
1155                             (portstatus & USB_PORT_STAT_OVERCURRENT))
1156                                 set_bit(port1, hub->change_bits);
1157
1158                 } else if (portstatus & USB_PORT_STAT_ENABLE) {
1159                         bool port_resumed = (portstatus &
1160                                         USB_PORT_STAT_LINK_STATE) ==
1161                                 USB_SS_PORT_LS_U0;
1162                         /* The power session apparently survived the resume.
1163                          * If there was an overcurrent or suspend change
1164                          * (i.e., remote wakeup request), have khubd
1165                          * take care of it.  Look at the port link state
1166                          * for USB 3.0 hubs, since they don't have a suspend
1167                          * change bit, and they don't set the port link change
1168                          * bit on device-initiated resume.
1169                          */
1170                         if (portchange || (hub_is_superspeed(hub->hdev) &&
1171                                                 port_resumed))
1172                                 set_bit(port1, hub->change_bits);
1173
1174                 } else if (udev->persist_enabled) {
1175 #ifdef CONFIG_PM
1176                         udev->reset_resume = 1;
1177 #endif
1178                         /* Don't set the change_bits when the device
1179                          * was powered off.
1180                          */
1181                         if (test_bit(port1, hub->power_bits))
1182                                 set_bit(port1, hub->change_bits);
1183
1184                 } else {
1185                         /* The power session is gone; tell khubd */
1186                         usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1187                         set_bit(port1, hub->change_bits);
1188                 }
1189         }
1190
1191         /* If no port-status-change flags were set, we don't need any
1192          * debouncing.  If flags were set we can try to debounce the
1193          * ports all at once right now, instead of letting khubd do them
1194          * one at a time later on.
1195          *
1196          * If any port-status changes do occur during this delay, khubd
1197          * will see them later and handle them normally.
1198          */
1199         if (need_debounce_delay) {
1200                 delay = HUB_DEBOUNCE_STABLE;
1201
1202                 /* Don't do a long sleep inside a workqueue routine */
1203                 if (type == HUB_INIT2) {
1204                         INIT_DELAYED_WORK(&hub->init_work, hub_init_func3);
1205                         queue_delayed_work(system_power_efficient_wq,
1206                                         &hub->init_work,
1207                                         msecs_to_jiffies(delay));
1208                         return;         /* Continues at init3: below */
1209                 } else {
1210                         msleep(delay);
1211                 }
1212         }
1213  init3:
1214         hub->quiescing = 0;
1215
1216         status = usb_submit_urb(hub->urb, GFP_NOIO);
1217         if (status < 0)
1218                 dev_err(hub->intfdev, "activate --> %d\n", status);
1219         if (hub->has_indicators && blinkenlights)
1220                 queue_delayed_work(system_power_efficient_wq,
1221                                 &hub->leds, LED_CYCLE_PERIOD);
1222
1223         /* Scan all ports that need attention */
1224         kick_khubd(hub);
1225
1226         /* Allow autosuspend if it was suppressed */
1227         if (type <= HUB_INIT3)
1228                 usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
1229 }
1230
1231 /* Implement the continuations for the delays above */
1232 static void hub_init_func2(struct work_struct *ws)
1233 {
1234         struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1235
1236         hub_activate(hub, HUB_INIT2);
1237 }
1238
1239 static void hub_init_func3(struct work_struct *ws)
1240 {
1241         struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1242
1243         hub_activate(hub, HUB_INIT3);
1244 }
1245
1246 enum hub_quiescing_type {
1247         HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
1248 };
1249
1250 static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
1251 {
1252         struct usb_device *hdev = hub->hdev;
1253         int i;
1254
1255         cancel_delayed_work_sync(&hub->init_work);
1256
1257         /* khubd and related activity won't re-trigger */
1258         hub->quiescing = 1;
1259
1260         if (type != HUB_SUSPEND) {
1261                 /* Disconnect all the children */
1262                 for (i = 0; i < hdev->maxchild; ++i) {
1263                         if (hub->ports[i]->child)
1264                                 usb_disconnect(&hub->ports[i]->child);
1265                 }
1266         }
1267
1268         /* Stop khubd and related activity */
1269         usb_kill_urb(hub->urb);
1270         if (hub->has_indicators)
1271                 cancel_delayed_work_sync(&hub->leds);
1272         if (hub->tt.hub)
1273                 flush_work(&hub->tt.clear_work);
1274 }
1275
1276 static void hub_pm_barrier_for_all_ports(struct usb_hub *hub)
1277 {
1278         int i;
1279
1280         for (i = 0; i < hub->hdev->maxchild; ++i)
1281                 pm_runtime_barrier(&hub->ports[i]->dev);
1282 }
1283
1284 /* caller has locked the hub device */
1285 static int hub_pre_reset(struct usb_interface *intf)
1286 {
1287         struct usb_hub *hub = usb_get_intfdata(intf);
1288
1289         hub_quiesce(hub, HUB_PRE_RESET);
1290         hub->in_reset = 1;
1291         hub_pm_barrier_for_all_ports(hub);
1292         return 0;
1293 }
1294
1295 /* caller has locked the hub device */
1296 static int hub_post_reset(struct usb_interface *intf)
1297 {
1298         struct usb_hub *hub = usb_get_intfdata(intf);
1299
1300         hub->in_reset = 0;
1301         hub_pm_barrier_for_all_ports(hub);
1302         hub_activate(hub, HUB_POST_RESET);
1303         return 0;
1304 }
1305
1306 static int hub_configure(struct usb_hub *hub,
1307         struct usb_endpoint_descriptor *endpoint)
1308 {
1309         struct usb_hcd *hcd;
1310         struct usb_device *hdev = hub->hdev;
1311         struct device *hub_dev = hub->intfdev;
1312         u16 hubstatus, hubchange;
1313         u16 wHubCharacteristics;
1314         unsigned int pipe;
1315         int maxp, ret, i;
1316         char *message = "out of memory";
1317         unsigned unit_load;
1318         unsigned full_load;
1319         unsigned maxchild;
1320
1321         hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
1322         if (!hub->buffer) {
1323                 ret = -ENOMEM;
1324                 goto fail;
1325         }
1326
1327         hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
1328         if (!hub->status) {
1329                 ret = -ENOMEM;
1330                 goto fail;
1331         }
1332         mutex_init(&hub->status_mutex);
1333
1334         hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
1335         if (!hub->descriptor) {
1336                 ret = -ENOMEM;
1337                 goto fail;
1338         }
1339
1340         /* Request the entire hub descriptor.
1341          * hub->descriptor can handle USB_MAXCHILDREN ports,
1342          * but the hub can/will return fewer bytes here.
1343          */
1344         ret = get_hub_descriptor(hdev, hub->descriptor);
1345         if (ret < 0) {
1346                 message = "can't read hub descriptor";
1347                 goto fail;
1348         } else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
1349                 message = "hub has too many ports!";
1350                 ret = -ENODEV;
1351                 goto fail;
1352         } else if (hub->descriptor->bNbrPorts == 0) {
1353                 message = "hub doesn't have any ports!";
1354                 ret = -ENODEV;
1355                 goto fail;
1356         }
1357
1358         maxchild = hub->descriptor->bNbrPorts;
1359         dev_info(hub_dev, "%d port%s detected\n", maxchild,
1360                         (maxchild == 1) ? "" : "s");
1361
1362         hub->ports = kzalloc(maxchild * sizeof(struct usb_port *), GFP_KERNEL);
1363         if (!hub->ports) {
1364                 ret = -ENOMEM;
1365                 goto fail;
1366         }
1367
1368         wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
1369         if (hub_is_superspeed(hdev)) {
1370                 unit_load = 150;
1371                 full_load = 900;
1372         } else {
1373                 unit_load = 100;
1374                 full_load = 500;
1375         }
1376
1377         /* FIXME for USB 3.0, skip for now */
1378         if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
1379                         !(hub_is_superspeed(hdev))) {
1380                 int     i;
1381                 char    portstr[USB_MAXCHILDREN + 1];
1382
1383                 for (i = 0; i < maxchild; i++)
1384                         portstr[i] = hub->descriptor->u.hs.DeviceRemovable
1385                                     [((i + 1) / 8)] & (1 << ((i + 1) % 8))
1386                                 ? 'F' : 'R';
1387                 portstr[maxchild] = 0;
1388                 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
1389         } else
1390                 dev_dbg(hub_dev, "standalone hub\n");
1391
1392         switch (wHubCharacteristics & HUB_CHAR_LPSM) {
1393         case HUB_CHAR_COMMON_LPSM:
1394                 dev_dbg(hub_dev, "ganged power switching\n");
1395                 break;
1396         case HUB_CHAR_INDV_PORT_LPSM:
1397                 dev_dbg(hub_dev, "individual port power switching\n");
1398                 break;
1399         case HUB_CHAR_NO_LPSM:
1400         case HUB_CHAR_LPSM:
1401                 dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
1402                 break;
1403         }
1404
1405         switch (wHubCharacteristics & HUB_CHAR_OCPM) {
1406         case HUB_CHAR_COMMON_OCPM:
1407                 dev_dbg(hub_dev, "global over-current protection\n");
1408                 break;
1409         case HUB_CHAR_INDV_PORT_OCPM:
1410                 dev_dbg(hub_dev, "individual port over-current protection\n");
1411                 break;
1412         case HUB_CHAR_NO_OCPM:
1413         case HUB_CHAR_OCPM:
1414                 dev_dbg(hub_dev, "no over-current protection\n");
1415                 break;
1416         }
1417
1418         spin_lock_init (&hub->tt.lock);
1419         INIT_LIST_HEAD (&hub->tt.clear_list);
1420         INIT_WORK(&hub->tt.clear_work, hub_tt_work);
1421         switch (hdev->descriptor.bDeviceProtocol) {
1422         case USB_HUB_PR_FS:
1423                 break;
1424         case USB_HUB_PR_HS_SINGLE_TT:
1425                 dev_dbg(hub_dev, "Single TT\n");
1426                 hub->tt.hub = hdev;
1427                 break;
1428         case USB_HUB_PR_HS_MULTI_TT:
1429                 ret = usb_set_interface(hdev, 0, 1);
1430                 if (ret == 0) {
1431                         dev_dbg(hub_dev, "TT per port\n");
1432                         hub->tt.multi = 1;
1433                 } else
1434                         dev_err(hub_dev, "Using single TT (err %d)\n",
1435                                 ret);
1436                 hub->tt.hub = hdev;
1437                 break;
1438         case USB_HUB_PR_SS:
1439                 /* USB 3.0 hubs don't have a TT */
1440                 break;
1441         default:
1442                 dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
1443                         hdev->descriptor.bDeviceProtocol);
1444                 break;
1445         }
1446
1447         /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
1448         switch (wHubCharacteristics & HUB_CHAR_TTTT) {
1449         case HUB_TTTT_8_BITS:
1450                 if (hdev->descriptor.bDeviceProtocol != 0) {
1451                         hub->tt.think_time = 666;
1452                         dev_dbg(hub_dev, "TT requires at most %d "
1453                                         "FS bit times (%d ns)\n",
1454                                 8, hub->tt.think_time);
1455                 }
1456                 break;
1457         case HUB_TTTT_16_BITS:
1458                 hub->tt.think_time = 666 * 2;
1459                 dev_dbg(hub_dev, "TT requires at most %d "
1460                                 "FS bit times (%d ns)\n",
1461                         16, hub->tt.think_time);
1462                 break;
1463         case HUB_TTTT_24_BITS:
1464                 hub->tt.think_time = 666 * 3;
1465                 dev_dbg(hub_dev, "TT requires at most %d "
1466                                 "FS bit times (%d ns)\n",
1467                         24, hub->tt.think_time);
1468                 break;
1469         case HUB_TTTT_32_BITS:
1470                 hub->tt.think_time = 666 * 4;
1471                 dev_dbg(hub_dev, "TT requires at most %d "
1472                                 "FS bit times (%d ns)\n",
1473                         32, hub->tt.think_time);
1474                 break;
1475         }
1476
1477         /* probe() zeroes hub->indicator[] */
1478         if (wHubCharacteristics & HUB_CHAR_PORTIND) {
1479                 hub->has_indicators = 1;
1480                 dev_dbg(hub_dev, "Port indicators are supported\n");
1481         }
1482
1483         dev_dbg(hub_dev, "power on to power good time: %dms\n",
1484                 hub->descriptor->bPwrOn2PwrGood * 2);
1485
1486         /* power budgeting mostly matters with bus-powered hubs,
1487          * and battery-powered root hubs (may provide just 8 mA).
1488          */
1489         ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
1490         if (ret) {
1491                 message = "can't get hub status";
1492                 goto fail;
1493         }
1494         hcd = bus_to_hcd(hdev->bus);
1495         if (hdev == hdev->bus->root_hub) {
1496                 if (hcd->power_budget > 0)
1497                         hdev->bus_mA = hcd->power_budget;
1498                 else
1499                         hdev->bus_mA = full_load * maxchild;
1500                 if (hdev->bus_mA >= full_load)
1501                         hub->mA_per_port = full_load;
1502                 else {
1503                         hub->mA_per_port = hdev->bus_mA;
1504                         hub->limited_power = 1;
1505                 }
1506         } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
1507                 int remaining = hdev->bus_mA -
1508                         hub->descriptor->bHubContrCurrent;
1509
1510                 dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
1511                         hub->descriptor->bHubContrCurrent);
1512                 hub->limited_power = 1;
1513
1514                 if (remaining < maxchild * unit_load)
1515                         dev_warn(hub_dev,
1516                                         "insufficient power available "
1517                                         "to use all downstream ports\n");
1518                 hub->mA_per_port = unit_load;   /* 7.2.1 */
1519
1520         } else {        /* Self-powered external hub */
1521                 /* FIXME: What about battery-powered external hubs that
1522                  * provide less current per port? */
1523                 hub->mA_per_port = full_load;
1524         }
1525         if (hub->mA_per_port < full_load)
1526                 dev_dbg(hub_dev, "%umA bus power budget for each child\n",
1527                                 hub->mA_per_port);
1528
1529         /* Update the HCD's internal representation of this hub before khubd
1530          * starts getting port status changes for devices under the hub.
1531          */
1532         if (hcd->driver->update_hub_device) {
1533                 ret = hcd->driver->update_hub_device(hcd, hdev,
1534                                 &hub->tt, GFP_KERNEL);
1535                 if (ret < 0) {
1536                         message = "can't update HCD hub info";
1537                         goto fail;
1538                 }
1539         }
1540
1541         ret = hub_hub_status(hub, &hubstatus, &hubchange);
1542         if (ret < 0) {
1543                 message = "can't get hub status";
1544                 goto fail;
1545         }
1546
1547         /* local power status reports aren't always correct */
1548         if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1549                 dev_dbg(hub_dev, "local power source is %s\n",
1550                         (hubstatus & HUB_STATUS_LOCAL_POWER)
1551                         ? "lost (inactive)" : "good");
1552
1553         if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
1554                 dev_dbg(hub_dev, "%sover-current condition exists\n",
1555                         (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
1556
1557         /* set up the interrupt endpoint
1558          * We use the EP's maxpacket size instead of (PORTS+1+7)/8
1559          * bytes as USB2.0[11.12.3] says because some hubs are known
1560          * to send more data (and thus cause overflow). For root hubs,
1561          * maxpktsize is defined in hcd.c's fake endpoint descriptors
1562          * to be big enough for at least USB_MAXCHILDREN ports. */
1563         pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
1564         maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
1565
1566         if (maxp > sizeof(*hub->buffer))
1567                 maxp = sizeof(*hub->buffer);
1568
1569         hub->urb = usb_alloc_urb(0, GFP_KERNEL);
1570         if (!hub->urb) {
1571                 ret = -ENOMEM;
1572                 goto fail;
1573         }
1574
1575         usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
1576                 hub, endpoint->bInterval);
1577
1578         /* maybe cycle the hub leds */
1579         if (hub->has_indicators && blinkenlights)
1580                 hub->indicator[0] = INDICATOR_CYCLE;
1581
1582         mutex_lock(&usb_port_peer_mutex);
1583         for (i = 0; i < maxchild; i++) {
1584                 ret = usb_hub_create_port_device(hub, i + 1);
1585                 if (ret < 0) {
1586                         dev_err(hub->intfdev,
1587                                 "couldn't create port%d device.\n", i + 1);
1588                         break;
1589                 }
1590         }
1591         hdev->maxchild = i;
1592         mutex_unlock(&usb_port_peer_mutex);
1593         if (ret < 0)
1594                 goto fail;
1595
1596         usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
1597
1598         hub_activate(hub, HUB_INIT);
1599         return 0;
1600
1601 fail:
1602         dev_err (hub_dev, "config failed, %s (err %d)\n",
1603                         message, ret);
1604         /* hub_disconnect() frees urb and descriptor */
1605         return ret;
1606 }
1607
1608 static void hub_release(struct kref *kref)
1609 {
1610         struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
1611
1612         usb_put_intf(to_usb_interface(hub->intfdev));
1613         kfree(hub);
1614 }
1615
1616 static unsigned highspeed_hubs;
1617
1618 static void hub_disconnect(struct usb_interface *intf)
1619 {
1620         struct usb_hub *hub = usb_get_intfdata(intf);
1621         struct usb_device *hdev = interface_to_usbdev(intf);
1622         int port1;
1623
1624         /* Take the hub off the event list and don't let it be added again */
1625         spin_lock_irq(&hub_event_lock);
1626         if (!list_empty(&hub->event_list)) {
1627                 list_del_init(&hub->event_list);
1628                 usb_autopm_put_interface_no_suspend(intf);
1629         }
1630         hub->disconnected = 1;
1631         spin_unlock_irq(&hub_event_lock);
1632
1633         /* Disconnect all children and quiesce the hub */
1634         hub->error = 0;
1635         hub_quiesce(hub, HUB_DISCONNECT);
1636
1637         mutex_lock(&usb_port_peer_mutex);
1638
1639         /* Avoid races with recursively_mark_NOTATTACHED() */
1640         spin_lock_irq(&device_state_lock);
1641         port1 = hdev->maxchild;
1642         hdev->maxchild = 0;
1643         usb_set_intfdata(intf, NULL);
1644         spin_unlock_irq(&device_state_lock);
1645
1646         for (; port1 > 0; --port1)
1647                 usb_hub_remove_port_device(hub, port1);
1648
1649         mutex_unlock(&usb_port_peer_mutex);
1650
1651         if (hub->hdev->speed == USB_SPEED_HIGH)
1652                 highspeed_hubs--;
1653
1654         usb_free_urb(hub->urb);
1655         kfree(hub->ports);
1656         kfree(hub->descriptor);
1657         kfree(hub->status);
1658         kfree(hub->buffer);
1659
1660         pm_suspend_ignore_children(&intf->dev, false);
1661         kref_put(&hub->kref, hub_release);
1662 }
1663
1664 static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
1665 {
1666         struct usb_host_interface *desc;
1667         struct usb_endpoint_descriptor *endpoint;
1668         struct usb_device *hdev;
1669         struct usb_hub *hub;
1670
1671         desc = intf->cur_altsetting;
1672         hdev = interface_to_usbdev(intf);
1673
1674         /*
1675          * Set default autosuspend delay as 0 to speedup bus suspend,
1676          * based on the below considerations:
1677          *
1678          * - Unlike other drivers, the hub driver does not rely on the
1679          *   autosuspend delay to provide enough time to handle a wakeup
1680          *   event, and the submitted status URB is just to check future
1681          *   change on hub downstream ports, so it is safe to do it.
1682          *
1683          * - The patch might cause one or more auto supend/resume for
1684          *   below very rare devices when they are plugged into hub
1685          *   first time:
1686          *
1687          *      devices having trouble initializing, and disconnect
1688          *      themselves from the bus and then reconnect a second
1689          *      or so later
1690          *
1691          *      devices just for downloading firmware, and disconnects
1692          *      themselves after completing it
1693          *
1694          *   For these quite rare devices, their drivers may change the
1695          *   autosuspend delay of their parent hub in the probe() to one
1696          *   appropriate value to avoid the subtle problem if someone
1697          *   does care it.
1698          *
1699          * - The patch may cause one or more auto suspend/resume on
1700          *   hub during running 'lsusb', but it is probably too
1701          *   infrequent to worry about.
1702          *
1703          * - Change autosuspend delay of hub can avoid unnecessary auto
1704          *   suspend timer for hub, also may decrease power consumption
1705          *   of USB bus.
1706          */
1707         pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
1708
1709         /* Hubs have proper suspend/resume support. */
1710         usb_enable_autosuspend(hdev);
1711
1712         if (hdev->level == MAX_TOPO_LEVEL) {
1713                 dev_err(&intf->dev,
1714                         "Unsupported bus topology: hub nested too deep\n");
1715                 return -E2BIG;
1716         }
1717
1718 #ifdef  CONFIG_USB_OTG_BLACKLIST_HUB
1719         if (hdev->parent) {
1720                 dev_warn(&intf->dev, "ignoring external hub\n");
1721                 return -ENODEV;
1722         }
1723 #endif
1724
1725         /* Some hubs have a subclass of 1, which AFAICT according to the */
1726         /*  specs is not defined, but it works */
1727         if ((desc->desc.bInterfaceSubClass != 0) &&
1728             (desc->desc.bInterfaceSubClass != 1)) {
1729 descriptor_error:
1730                 dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
1731                 return -EIO;
1732         }
1733
1734         /* Multiple endpoints? What kind of mutant ninja-hub is this? */
1735         if (desc->desc.bNumEndpoints != 1)
1736                 goto descriptor_error;
1737
1738         endpoint = &desc->endpoint[0].desc;
1739
1740         /* If it's not an interrupt in endpoint, we'd better punt! */
1741         if (!usb_endpoint_is_int_in(endpoint))
1742                 goto descriptor_error;
1743
1744         /* We found a hub */
1745         dev_info (&intf->dev, "USB hub found\n");
1746
1747         hub = kzalloc(sizeof(*hub), GFP_KERNEL);
1748         if (!hub) {
1749                 dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
1750                 return -ENOMEM;
1751         }
1752
1753         kref_init(&hub->kref);
1754         INIT_LIST_HEAD(&hub->event_list);
1755         hub->intfdev = &intf->dev;
1756         hub->hdev = hdev;
1757         INIT_DELAYED_WORK(&hub->leds, led_work);
1758         INIT_DELAYED_WORK(&hub->init_work, NULL);
1759         usb_get_intf(intf);
1760
1761         usb_set_intfdata (intf, hub);
1762         intf->needs_remote_wakeup = 1;
1763         pm_suspend_ignore_children(&intf->dev, true);
1764
1765         if (hdev->speed == USB_SPEED_HIGH)
1766                 highspeed_hubs++;
1767
1768         if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
1769                 hub->quirk_check_port_auto_suspend = 1;
1770
1771         if (hub_configure(hub, endpoint) >= 0)
1772                 return 0;
1773
1774         hub_disconnect (intf);
1775         return -ENODEV;
1776 }
1777
1778 static int
1779 hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
1780 {
1781         struct usb_device *hdev = interface_to_usbdev (intf);
1782         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1783
1784         /* assert ifno == 0 (part of hub spec) */
1785         switch (code) {
1786         case USBDEVFS_HUB_PORTINFO: {
1787                 struct usbdevfs_hub_portinfo *info = user_data;
1788                 int i;
1789
1790                 spin_lock_irq(&device_state_lock);
1791                 if (hdev->devnum <= 0)
1792                         info->nports = 0;
1793                 else {
1794                         info->nports = hdev->maxchild;
1795                         for (i = 0; i < info->nports; i++) {
1796                                 if (hub->ports[i]->child == NULL)
1797                                         info->port[i] = 0;
1798                                 else
1799                                         info->port[i] =
1800                                                 hub->ports[i]->child->devnum;
1801                         }
1802                 }
1803                 spin_unlock_irq(&device_state_lock);
1804
1805                 return info->nports + 1;
1806                 }
1807
1808         default:
1809                 return -ENOSYS;
1810         }
1811 }
1812
1813 /*
1814  * Allow user programs to claim ports on a hub.  When a device is attached
1815  * to one of these "claimed" ports, the program will "own" the device.
1816  */
1817 static int find_port_owner(struct usb_device *hdev, unsigned port1,
1818                 struct usb_dev_state ***ppowner)
1819 {
1820         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1821
1822         if (hdev->state == USB_STATE_NOTATTACHED)
1823                 return -ENODEV;
1824         if (port1 == 0 || port1 > hdev->maxchild)
1825                 return -EINVAL;
1826
1827         /* Devices not managed by the hub driver
1828          * will always have maxchild equal to 0.
1829          */
1830         *ppowner = &(hub->ports[port1 - 1]->port_owner);
1831         return 0;
1832 }
1833
1834 /* In the following three functions, the caller must hold hdev's lock */
1835 int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
1836                        struct usb_dev_state *owner)
1837 {
1838         int rc;
1839         struct usb_dev_state **powner;
1840
1841         rc = find_port_owner(hdev, port1, &powner);
1842         if (rc)
1843                 return rc;
1844         if (*powner)
1845                 return -EBUSY;
1846         *powner = owner;
1847         return rc;
1848 }
1849 EXPORT_SYMBOL_GPL(usb_hub_claim_port);
1850
1851 int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
1852                          struct usb_dev_state *owner)
1853 {
1854         int rc;
1855         struct usb_dev_state **powner;
1856
1857         rc = find_port_owner(hdev, port1, &powner);
1858         if (rc)
1859                 return rc;
1860         if (*powner != owner)
1861                 return -ENOENT;
1862         *powner = NULL;
1863         return rc;
1864 }
1865 EXPORT_SYMBOL_GPL(usb_hub_release_port);
1866
1867 void usb_hub_release_all_ports(struct usb_device *hdev, struct usb_dev_state *owner)
1868 {
1869         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1870         int n;
1871
1872         for (n = 0; n < hdev->maxchild; n++) {
1873                 if (hub->ports[n]->port_owner == owner)
1874                         hub->ports[n]->port_owner = NULL;
1875         }
1876
1877 }
1878
1879 /* The caller must hold udev's lock */
1880 bool usb_device_is_owned(struct usb_device *udev)
1881 {
1882         struct usb_hub *hub;
1883
1884         if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
1885                 return false;
1886         hub = usb_hub_to_struct_hub(udev->parent);
1887         return !!hub->ports[udev->portnum - 1]->port_owner;
1888 }
1889
1890 static void recursively_mark_NOTATTACHED(struct usb_device *udev)
1891 {
1892         struct usb_hub *hub = usb_hub_to_struct_hub(udev);
1893         int i;
1894
1895         for (i = 0; i < udev->maxchild; ++i) {
1896                 if (hub->ports[i]->child)
1897                         recursively_mark_NOTATTACHED(hub->ports[i]->child);
1898         }
1899         if (udev->state == USB_STATE_SUSPENDED)
1900                 udev->active_duration -= jiffies;
1901         udev->state = USB_STATE_NOTATTACHED;
1902 }
1903
1904 /**
1905  * usb_set_device_state - change a device's current state (usbcore, hcds)
1906  * @udev: pointer to device whose state should be changed
1907  * @new_state: new state value to be stored
1908  *
1909  * udev->state is _not_ fully protected by the device lock.  Although
1910  * most transitions are made only while holding the lock, the state can
1911  * can change to USB_STATE_NOTATTACHED at almost any time.  This
1912  * is so that devices can be marked as disconnected as soon as possible,
1913  * without having to wait for any semaphores to be released.  As a result,
1914  * all changes to any device's state must be protected by the
1915  * device_state_lock spinlock.
1916  *
1917  * Once a device has been added to the device tree, all changes to its state
1918  * should be made using this routine.  The state should _not_ be set directly.
1919  *
1920  * If udev->state is already USB_STATE_NOTATTACHED then no change is made.
1921  * Otherwise udev->state is set to new_state, and if new_state is
1922  * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
1923  * to USB_STATE_NOTATTACHED.
1924  */
1925 void usb_set_device_state(struct usb_device *udev,
1926                 enum usb_device_state new_state)
1927 {
1928         unsigned long flags;
1929         int wakeup = -1;
1930
1931         spin_lock_irqsave(&device_state_lock, flags);
1932         if (udev->state == USB_STATE_NOTATTACHED)
1933                 ;       /* do nothing */
1934         else if (new_state != USB_STATE_NOTATTACHED) {
1935
1936                 /* root hub wakeup capabilities are managed out-of-band
1937                  * and may involve silicon errata ... ignore them here.
1938                  */
1939                 if (udev->parent) {
1940                         if (udev->state == USB_STATE_SUSPENDED
1941                                         || new_state == USB_STATE_SUSPENDED)
1942                                 ;       /* No change to wakeup settings */
1943                         else if (new_state == USB_STATE_CONFIGURED)
1944                                 wakeup = udev->actconfig->desc.bmAttributes
1945                                          & USB_CONFIG_ATT_WAKEUP;
1946                         else
1947                                 wakeup = 0;
1948                 }
1949                 if (udev->state == USB_STATE_SUSPENDED &&
1950                         new_state != USB_STATE_SUSPENDED)
1951                         udev->active_duration -= jiffies;
1952                 else if (new_state == USB_STATE_SUSPENDED &&
1953                                 udev->state != USB_STATE_SUSPENDED)
1954                         udev->active_duration += jiffies;
1955                 udev->state = new_state;
1956         } else
1957                 recursively_mark_NOTATTACHED(udev);
1958         spin_unlock_irqrestore(&device_state_lock, flags);
1959         if (wakeup >= 0)
1960                 device_set_wakeup_capable(&udev->dev, wakeup);
1961 }
1962 EXPORT_SYMBOL_GPL(usb_set_device_state);
1963
1964 /*
1965  * Choose a device number.
1966  *
1967  * Device numbers are used as filenames in usbfs.  On USB-1.1 and
1968  * USB-2.0 buses they are also used as device addresses, however on
1969  * USB-3.0 buses the address is assigned by the controller hardware
1970  * and it usually is not the same as the device number.
1971  *
1972  * WUSB devices are simple: they have no hubs behind, so the mapping
1973  * device <-> virtual port number becomes 1:1. Why? to simplify the
1974  * life of the device connection logic in
1975  * drivers/usb/wusbcore/devconnect.c. When we do the initial secret
1976  * handshake we need to assign a temporary address in the unauthorized
1977  * space. For simplicity we use the first virtual port number found to
1978  * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
1979  * and that becomes it's address [X < 128] or its unauthorized address
1980  * [X | 0x80].
1981  *
1982  * We add 1 as an offset to the one-based USB-stack port number
1983  * (zero-based wusb virtual port index) for two reasons: (a) dev addr
1984  * 0 is reserved by USB for default address; (b) Linux's USB stack
1985  * uses always #1 for the root hub of the controller. So USB stack's
1986  * port #1, which is wusb virtual-port #0 has address #2.
1987  *
1988  * Devices connected under xHCI are not as simple.  The host controller
1989  * supports virtualization, so the hardware assigns device addresses and
1990  * the HCD must setup data structures before issuing a set address
1991  * command to the hardware.
1992  */
1993 static void choose_devnum(struct usb_device *udev)
1994 {
1995         int             devnum;
1996         struct usb_bus  *bus = udev->bus;
1997
1998         /* If khubd ever becomes multithreaded, this will need a lock */
1999         if (udev->wusb) {
2000                 devnum = udev->portnum + 1;
2001                 BUG_ON(test_bit(devnum, bus->devmap.devicemap));
2002         } else {
2003                 /* Try to allocate the next devnum beginning at
2004                  * bus->devnum_next. */
2005                 devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
2006                                             bus->devnum_next);
2007                 if (devnum >= 128)
2008                         devnum = find_next_zero_bit(bus->devmap.devicemap,
2009                                                     128, 1);
2010                 bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
2011         }
2012         if (devnum < 128) {
2013                 set_bit(devnum, bus->devmap.devicemap);
2014                 udev->devnum = devnum;
2015         }
2016 }
2017
2018 static void release_devnum(struct usb_device *udev)
2019 {
2020         if (udev->devnum > 0) {
2021                 clear_bit(udev->devnum, udev->bus->devmap.devicemap);
2022                 udev->devnum = -1;
2023         }
2024 }
2025
2026 static void update_devnum(struct usb_device *udev, int devnum)
2027 {
2028         /* The address for a WUSB device is managed by wusbcore. */
2029         if (!udev->wusb)
2030                 udev->devnum = devnum;
2031 }
2032
2033 static void hub_free_dev(struct usb_device *udev)
2034 {
2035         struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2036
2037         /* Root hubs aren't real devices, so don't free HCD resources */
2038         if (hcd->driver->free_dev && udev->parent)
2039                 hcd->driver->free_dev(hcd, udev);
2040 }
2041
2042 static void hub_disconnect_children(struct usb_device *udev)
2043 {
2044         struct usb_hub *hub = usb_hub_to_struct_hub(udev);
2045         int i;
2046
2047         /* Free up all the children before we remove this device */
2048         for (i = 0; i < udev->maxchild; i++) {
2049                 if (hub->ports[i]->child)
2050                         usb_disconnect(&hub->ports[i]->child);
2051         }
2052 }
2053
2054 /**
2055  * usb_disconnect - disconnect a device (usbcore-internal)
2056  * @pdev: pointer to device being disconnected
2057  * Context: !in_interrupt ()
2058  *
2059  * Something got disconnected. Get rid of it and all of its children.
2060  *
2061  * If *pdev is a normal device then the parent hub must already be locked.
2062  * If *pdev is a root hub then the caller must hold the usb_bus_list_lock,
2063  * which protects the set of root hubs as well as the list of buses.
2064  *
2065  * Only hub drivers (including virtual root hub drivers for host
2066  * controllers) should ever call this.
2067  *
2068  * This call is synchronous, and may not be used in an interrupt context.
2069  */
2070 void usb_disconnect(struct usb_device **pdev)
2071 {
2072         struct usb_port *port_dev = NULL;
2073         struct usb_device *udev = *pdev;
2074         struct usb_hub *hub;
2075         int port1;
2076
2077         /* mark the device as inactive, so any further urb submissions for
2078          * this device (and any of its children) will fail immediately.
2079          * this quiesces everything except pending urbs.
2080          */
2081         usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2082         dev_info(&udev->dev, "USB disconnect, device number %d\n",
2083                         udev->devnum);
2084
2085         usb_lock_device(udev);
2086
2087         hub_disconnect_children(udev);
2088
2089         /* deallocate hcd/hardware state ... nuking all pending urbs and
2090          * cleaning up all state associated with the current configuration
2091          * so that the hardware is now fully quiesced.
2092          */
2093         dev_dbg (&udev->dev, "unregistering device\n");
2094         usb_disable_device(udev, 0);
2095         usb_hcd_synchronize_unlinks(udev);
2096
2097         if (udev->parent) {
2098                 port1 = udev->portnum;
2099                 hub = usb_hub_to_struct_hub(udev->parent);
2100                 port_dev = hub->ports[port1 - 1];
2101
2102                 sysfs_remove_link(&udev->dev.kobj, "port");
2103                 sysfs_remove_link(&port_dev->dev.kobj, "device");
2104
2105                 /*
2106                  * As usb_port_runtime_resume() de-references udev, make
2107                  * sure no resumes occur during removal
2108                  */
2109                 if (!test_and_set_bit(port1, hub->child_usage_bits))
2110                         pm_runtime_get_sync(&port_dev->dev);
2111         }
2112
2113         usb_remove_ep_devs(&udev->ep0);
2114         usb_unlock_device(udev);
2115
2116         /* Unregister the device.  The device driver is responsible
2117          * for de-configuring the device and invoking the remove-device
2118          * notifier chain (used by usbfs and possibly others).
2119          */
2120         device_del(&udev->dev);
2121
2122         /* Free the device number and delete the parent's children[]
2123          * (or root_hub) pointer.
2124          */
2125         release_devnum(udev);
2126
2127         /* Avoid races with recursively_mark_NOTATTACHED() */
2128         spin_lock_irq(&device_state_lock);
2129         *pdev = NULL;
2130         spin_unlock_irq(&device_state_lock);
2131
2132         if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits))
2133                 pm_runtime_put(&port_dev->dev);
2134
2135         hub_free_dev(udev);
2136
2137         put_device(&udev->dev);
2138 }
2139
2140 #ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
2141 static void show_string(struct usb_device *udev, char *id, char *string)
2142 {
2143         if (!string)
2144                 return;
2145         dev_info(&udev->dev, "%s: %s\n", id, string);
2146 }
2147
2148 static void announce_device(struct usb_device *udev)
2149 {
2150         dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
2151                 le16_to_cpu(udev->descriptor.idVendor),
2152                 le16_to_cpu(udev->descriptor.idProduct));
2153         dev_info(&udev->dev,
2154                 "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
2155                 udev->descriptor.iManufacturer,
2156                 udev->descriptor.iProduct,
2157                 udev->descriptor.iSerialNumber);
2158         show_string(udev, "Product", udev->product);
2159         show_string(udev, "Manufacturer", udev->manufacturer);
2160         show_string(udev, "SerialNumber", udev->serial);
2161 }
2162 #else
2163 static inline void announce_device(struct usb_device *udev) { }
2164 #endif
2165
2166 #ifdef  CONFIG_USB_OTG
2167 #include "otg_whitelist.h"
2168 #endif
2169
2170 /**
2171  * usb_enumerate_device_otg - FIXME (usbcore-internal)
2172  * @udev: newly addressed device (in ADDRESS state)
2173  *
2174  * Finish enumeration for On-The-Go devices
2175  *
2176  * Return: 0 if successful. A negative error code otherwise.
2177  */
2178 static int usb_enumerate_device_otg(struct usb_device *udev)
2179 {
2180         int err = 0;
2181
2182 #ifdef  CONFIG_USB_OTG
2183         /*
2184          * OTG-aware devices on OTG-capable root hubs may be able to use SRP,
2185          * to wake us after we've powered off VBUS; and HNP, switching roles
2186          * "host" to "peripheral".  The OTG descriptor helps figure this out.
2187          */
2188         if (!udev->bus->is_b_host
2189                         && udev->config
2190                         && udev->parent == udev->bus->root_hub) {
2191                 struct usb_otg_descriptor       *desc = NULL;
2192                 struct usb_bus                  *bus = udev->bus;
2193
2194                 /* descriptor may appear anywhere in config */
2195                 if (__usb_get_extra_descriptor (udev->rawdescriptors[0],
2196                                         le16_to_cpu(udev->config[0].desc.wTotalLength),
2197                                         USB_DT_OTG, (void **) &desc) == 0) {
2198                         if (desc->bmAttributes & USB_OTG_HNP) {
2199                                 unsigned                port1 = udev->portnum;
2200
2201                                 dev_info(&udev->dev,
2202                                         "Dual-Role OTG device on %sHNP port\n",
2203                                         (port1 == bus->otg_port)
2204                                                 ? "" : "non-");
2205
2206                                 /* enable HNP before suspend, it's simpler */
2207                                 if (port1 == bus->otg_port)
2208                                         bus->b_hnp_enable = 1;
2209                                 err = usb_control_msg(udev,
2210                                         usb_sndctrlpipe(udev, 0),
2211                                         USB_REQ_SET_FEATURE, 0,
2212                                         bus->b_hnp_enable
2213                                                 ? USB_DEVICE_B_HNP_ENABLE
2214                                                 : USB_DEVICE_A_ALT_HNP_SUPPORT,
2215                                         0, NULL, 0, USB_CTRL_SET_TIMEOUT);
2216                                 if (err < 0) {
2217                                         /* OTG MESSAGE: report errors here,
2218                                          * customize to match your product.
2219                                          */
2220                                         dev_info(&udev->dev,
2221                                                 "can't set HNP mode: %d\n",
2222                                                 err);
2223                                         bus->b_hnp_enable = 0;
2224                                 }
2225                         }
2226                 }
2227         }
2228
2229         if (!is_targeted(udev)) {
2230
2231                 /* Maybe it can talk to us, though we can't talk to it.
2232                  * (Includes HNP test device.)
2233                  */
2234                 if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
2235                         err = usb_port_suspend(udev, PMSG_SUSPEND);
2236                         if (err < 0)
2237                                 dev_dbg(&udev->dev, "HNP fail, %d\n", err);
2238                 }
2239                 err = -ENOTSUPP;
2240                 goto fail;
2241         }
2242 fail:
2243 #endif
2244         return err;
2245 }
2246
2247
2248 /**
2249  * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
2250  * @udev: newly addressed device (in ADDRESS state)
2251  *
2252  * This is only called by usb_new_device() and usb_authorize_device()
2253  * and FIXME -- all comments that apply to them apply here wrt to
2254  * environment.
2255  *
2256  * If the device is WUSB and not authorized, we don't attempt to read
2257  * the string descriptors, as they will be errored out by the device
2258  * until it has been authorized.
2259  *
2260  * Return: 0 if successful. A negative error code otherwise.
2261  */
2262 static int usb_enumerate_device(struct usb_device *udev)
2263 {
2264         int err;
2265
2266         if (udev->config == NULL) {
2267                 err = usb_get_configuration(udev);
2268                 if (err < 0) {
2269                         if (err != -ENODEV)
2270                                 dev_err(&udev->dev, "can't read configurations, error %d\n",
2271                                                 err);
2272                         return err;
2273                 }
2274         }
2275
2276         /* read the standard strings and cache them if present */
2277         udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
2278         udev->manufacturer = usb_cache_string(udev,
2279                                               udev->descriptor.iManufacturer);
2280         udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
2281
2282         err = usb_enumerate_device_otg(udev);
2283         if (err < 0)
2284                 return err;
2285
2286         usb_detect_interface_quirks(udev);
2287
2288         return 0;
2289 }
2290
2291 static void set_usb_port_removable(struct usb_device *udev)
2292 {
2293         struct usb_device *hdev = udev->parent;
2294         struct usb_hub *hub;
2295         u8 port = udev->portnum;
2296         u16 wHubCharacteristics;
2297         bool removable = true;
2298
2299         if (!hdev)
2300                 return;
2301
2302         hub = usb_hub_to_struct_hub(udev->parent);
2303
2304         wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
2305
2306         if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
2307                 return;
2308
2309         if (hub_is_superspeed(hdev)) {
2310                 if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
2311                                 & (1 << port))
2312                         removable = false;
2313         } else {
2314                 if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
2315                         removable = false;
2316         }
2317
2318         if (removable)
2319                 udev->removable = USB_DEVICE_REMOVABLE;
2320         else
2321                 udev->removable = USB_DEVICE_FIXED;
2322
2323         /*
2324          * Platform firmware may have populated an alternative value for
2325          * removable.  If the parent port has a known connect_type use
2326          * that instead.
2327          */
2328         switch (hub->ports[udev->portnum - 1]->connect_type) {
2329         case USB_PORT_CONNECT_TYPE_HOT_PLUG:
2330                 udev->removable = USB_DEVICE_REMOVABLE;
2331                 break;
2332         case USB_PORT_CONNECT_TYPE_HARD_WIRED:
2333                 udev->removable = USB_DEVICE_FIXED;
2334                 break;
2335         default: /* use what was set above */
2336                 break;
2337         }
2338 }
2339
2340 /**
2341  * usb_new_device - perform initial device setup (usbcore-internal)
2342  * @udev: newly addressed device (in ADDRESS state)
2343  *
2344  * This is called with devices which have been detected but not fully
2345  * enumerated.  The device descriptor is available, but not descriptors
2346  * for any device configuration.  The caller must have locked either
2347  * the parent hub (if udev is a normal device) or else the
2348  * usb_bus_list_lock (if udev is a root hub).  The parent's pointer to
2349  * udev has already been installed, but udev is not yet visible through
2350  * sysfs or other filesystem code.
2351  *
2352  * This call is synchronous, and may not be used in an interrupt context.
2353  *
2354  * Only the hub driver or root-hub registrar should ever call this.
2355  *
2356  * Return: Whether the device is configured properly or not. Zero if the
2357  * interface was registered with the driver core; else a negative errno
2358  * value.
2359  *
2360  */
2361 int usb_new_device(struct usb_device *udev)
2362 {
2363         int err;
2364
2365         if (udev->parent) {
2366                 /* Initialize non-root-hub device wakeup to disabled;
2367                  * device (un)configuration controls wakeup capable
2368                  * sysfs power/wakeup controls wakeup enabled/disabled
2369                  */
2370                 device_init_wakeup(&udev->dev, 0);
2371         }
2372
2373         /* Tell the runtime-PM framework the device is active */
2374         pm_runtime_set_active(&udev->dev);
2375         pm_runtime_get_noresume(&udev->dev);
2376         pm_runtime_use_autosuspend(&udev->dev);
2377         pm_runtime_enable(&udev->dev);
2378
2379         /* By default, forbid autosuspend for all devices.  It will be
2380          * allowed for hubs during binding.
2381          */
2382         usb_disable_autosuspend(udev);
2383
2384         err = usb_enumerate_device(udev);       /* Read descriptors */
2385         if (err < 0)
2386                 goto fail;
2387         dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
2388                         udev->devnum, udev->bus->busnum,
2389                         (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2390         /* export the usbdev device-node for libusb */
2391         udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
2392                         (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2393
2394         /* Tell the world! */
2395         announce_device(udev);
2396
2397         if (udev->serial)
2398                 add_device_randomness(udev->serial, strlen(udev->serial));
2399         if (udev->product)
2400                 add_device_randomness(udev->product, strlen(udev->product));
2401         if (udev->manufacturer)
2402                 add_device_randomness(udev->manufacturer,
2403                                       strlen(udev->manufacturer));
2404
2405         device_enable_async_suspend(&udev->dev);
2406
2407         /* check whether the hub or firmware marks this port as non-removable */
2408         if (udev->parent)
2409                 set_usb_port_removable(udev);
2410
2411         /* Register the device.  The device driver is responsible
2412          * for configuring the device and invoking the add-device
2413          * notifier chain (used by usbfs and possibly others).
2414          */
2415         err = device_add(&udev->dev);
2416         if (err) {
2417                 dev_err(&udev->dev, "can't device_add, error %d\n", err);
2418                 goto fail;
2419         }
2420
2421         /* Create link files between child device and usb port device. */
2422         if (udev->parent) {
2423                 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2424                 int port1 = udev->portnum;
2425                 struct usb_port *port_dev = hub->ports[port1 - 1];
2426
2427                 err = sysfs_create_link(&udev->dev.kobj,
2428                                 &port_dev->dev.kobj, "port");
2429                 if (err)
2430                         goto fail;
2431
2432                 err = sysfs_create_link(&port_dev->dev.kobj,
2433                                 &udev->dev.kobj, "device");
2434                 if (err) {
2435                         sysfs_remove_link(&udev->dev.kobj, "port");
2436                         goto fail;
2437                 }
2438
2439                 if (!test_and_set_bit(port1, hub->child_usage_bits))
2440                         pm_runtime_get_sync(&port_dev->dev);
2441         }
2442
2443         (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
2444         usb_mark_last_busy(udev);
2445         pm_runtime_put_sync_autosuspend(&udev->dev);
2446         return err;
2447
2448 fail:
2449         usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2450         pm_runtime_disable(&udev->dev);
2451         pm_runtime_set_suspended(&udev->dev);
2452         return err;
2453 }
2454
2455
2456 /**
2457  * usb_deauthorize_device - deauthorize a device (usbcore-internal)
2458  * @usb_dev: USB device
2459  *
2460  * Move the USB device to a very basic state where interfaces are disabled
2461  * and the device is in fact unconfigured and unusable.
2462  *
2463  * We share a lock (that we have) with device_del(), so we need to
2464  * defer its call.
2465  *
2466  * Return: 0.
2467  */
2468 int usb_deauthorize_device(struct usb_device *usb_dev)
2469 {
2470         usb_lock_device(usb_dev);
2471         if (usb_dev->authorized == 0)
2472                 goto out_unauthorized;
2473
2474         usb_dev->authorized = 0;
2475         usb_set_configuration(usb_dev, -1);
2476
2477 out_unauthorized:
2478         usb_unlock_device(usb_dev);
2479         return 0;
2480 }
2481
2482
2483 int usb_authorize_device(struct usb_device *usb_dev)
2484 {
2485         int result = 0, c;
2486
2487         usb_lock_device(usb_dev);
2488         if (usb_dev->authorized == 1)
2489                 goto out_authorized;
2490
2491         result = usb_autoresume_device(usb_dev);
2492         if (result < 0) {
2493                 dev_err(&usb_dev->dev,
2494                         "can't autoresume for authorization: %d\n", result);
2495                 goto error_autoresume;
2496         }
2497         result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
2498         if (result < 0) {
2499                 dev_err(&usb_dev->dev, "can't re-read device descriptor for "
2500                         "authorization: %d\n", result);
2501                 goto error_device_descriptor;
2502         }
2503
2504         usb_dev->authorized = 1;
2505         /* Choose and set the configuration.  This registers the interfaces
2506          * with the driver core and lets interface drivers bind to them.
2507          */
2508         c = usb_choose_configuration(usb_dev);
2509         if (c >= 0) {
2510                 result = usb_set_configuration(usb_dev, c);
2511                 if (result) {
2512                         dev_err(&usb_dev->dev,
2513                                 "can't set config #%d, error %d\n", c, result);
2514                         /* This need not be fatal.  The user can try to
2515                          * set other configurations. */
2516                 }
2517         }
2518         dev_info(&usb_dev->dev, "authorized to connect\n");
2519
2520 error_device_descriptor:
2521         usb_autosuspend_device(usb_dev);
2522 error_autoresume:
2523 out_authorized:
2524         usb_unlock_device(usb_dev);     /* complements locktree */
2525         return result;
2526 }
2527
2528
2529 /* Returns 1 if @hub is a WUSB root hub, 0 otherwise */
2530 static unsigned hub_is_wusb(struct usb_hub *hub)
2531 {
2532         struct usb_hcd *hcd;
2533         if (hub->hdev->parent != NULL)  /* not a root hub? */
2534                 return 0;
2535         hcd = container_of(hub->hdev->bus, struct usb_hcd, self);
2536         return hcd->wireless;
2537 }
2538
2539
2540 #define PORT_RESET_TRIES        5
2541 #define SET_ADDRESS_TRIES       2
2542 #define GET_DESCRIPTOR_TRIES    2
2543 #define SET_CONFIG_TRIES        (2 * (use_both_schemes + 1))
2544 #define USE_NEW_SCHEME(i)       ((i) / 2 == (int)old_scheme_first)
2545
2546 #define HUB_ROOT_RESET_TIME     50      /* times are in msec */
2547 #define HUB_SHORT_RESET_TIME    10
2548 #define HUB_BH_RESET_TIME       50
2549 #define HUB_LONG_RESET_TIME     200
2550 #define HUB_RESET_TIMEOUT       800
2551
2552 /*
2553  * "New scheme" enumeration causes an extra state transition to be
2554  * exposed to an xhci host and causes USB3 devices to receive control
2555  * commands in the default state.  This has been seen to cause
2556  * enumeration failures, so disable this enumeration scheme for USB3
2557  * devices.
2558  */
2559 static bool use_new_scheme(struct usb_device *udev, int retry)
2560 {
2561         if (udev->speed == USB_SPEED_SUPER)
2562                 return false;
2563
2564         return USE_NEW_SCHEME(retry);
2565 }
2566
2567 static int hub_port_reset(struct usb_hub *hub, int port1,
2568                         struct usb_device *udev, unsigned int delay, bool warm);
2569
2570 /* Is a USB 3.0 port in the Inactive or Compliance Mode state?
2571  * Port worm reset is required to recover
2572  */
2573 static bool hub_port_warm_reset_required(struct usb_hub *hub, u16 portstatus)
2574 {
2575         return hub_is_superspeed(hub->hdev) &&
2576                 (((portstatus & USB_PORT_STAT_LINK_STATE) ==
2577                   USB_SS_PORT_LS_SS_INACTIVE) ||
2578                  ((portstatus & USB_PORT_STAT_LINK_STATE) ==
2579                   USB_SS_PORT_LS_COMP_MOD)) ;
2580 }
2581
2582 static int hub_port_wait_reset(struct usb_hub *hub, int port1,
2583                         struct usb_device *udev, unsigned int delay, bool warm)
2584 {
2585         int delay_time, ret;
2586         u16 portstatus;
2587         u16 portchange;
2588
2589         for (delay_time = 0;
2590                         delay_time < HUB_RESET_TIMEOUT;
2591                         delay_time += delay) {
2592                 /* wait to give the device a chance to reset */
2593                 msleep(delay);
2594
2595                 /* read and decode port status */
2596                 ret = hub_port_status(hub, port1, &portstatus, &portchange);
2597                 if (ret < 0)
2598                         return ret;
2599
2600                 /* The port state is unknown until the reset completes. */
2601                 if (!(portstatus & USB_PORT_STAT_RESET))
2602                         break;
2603
2604                 /* switch to the long delay after two short delay failures */
2605                 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
2606                         delay = HUB_LONG_RESET_TIME;
2607
2608                 dev_dbg(&hub->ports[port1 - 1]->dev,
2609                                 "not %sreset yet, waiting %dms\n",
2610                                 warm ? "warm " : "", delay);
2611         }
2612
2613         if ((portstatus & USB_PORT_STAT_RESET))
2614                 return -EBUSY;
2615
2616         if (hub_port_warm_reset_required(hub, portstatus))
2617                 return -ENOTCONN;
2618
2619         /* Device went away? */
2620         if (!(portstatus & USB_PORT_STAT_CONNECTION))
2621                 return -ENOTCONN;
2622
2623         /* bomb out completely if the connection bounced.  A USB 3.0
2624          * connection may bounce if multiple warm resets were issued,
2625          * but the device may have successfully re-connected. Ignore it.
2626          */
2627         if (!hub_is_superspeed(hub->hdev) &&
2628                         (portchange & USB_PORT_STAT_C_CONNECTION))
2629                 return -ENOTCONN;
2630
2631         if (!(portstatus & USB_PORT_STAT_ENABLE))
2632                 return -EBUSY;
2633
2634         if (!udev)
2635                 return 0;
2636
2637         if (hub_is_wusb(hub))
2638                 udev->speed = USB_SPEED_WIRELESS;
2639         else if (hub_is_superspeed(hub->hdev))
2640                 udev->speed = USB_SPEED_SUPER;
2641         else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
2642                 udev->speed = USB_SPEED_HIGH;
2643         else if (portstatus & USB_PORT_STAT_LOW_SPEED)
2644                 udev->speed = USB_SPEED_LOW;
2645         else
2646                 udev->speed = USB_SPEED_FULL;
2647         return 0;
2648 }
2649
2650 static void hub_port_finish_reset(struct usb_hub *hub, int port1,
2651                         struct usb_device *udev, int *status)
2652 {
2653         switch (*status) {
2654         case 0:
2655                 /* TRSTRCY = 10 ms; plus some extra */
2656                 msleep(10 + 40);
2657                 if (udev) {
2658                         struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2659
2660                         update_devnum(udev, 0);
2661                         /* The xHC may think the device is already reset,
2662                          * so ignore the status.
2663                          */
2664                         if (hcd->driver->reset_device)
2665                                 hcd->driver->reset_device(hcd, udev);
2666                 }
2667                 /* FALL THROUGH */
2668         case -ENOTCONN:
2669         case -ENODEV:
2670                 usb_clear_port_feature(hub->hdev,
2671                                 port1, USB_PORT_FEAT_C_RESET);
2672                 if (hub_is_superspeed(hub->hdev)) {
2673                         usb_clear_port_feature(hub->hdev, port1,
2674                                         USB_PORT_FEAT_C_BH_PORT_RESET);
2675                         usb_clear_port_feature(hub->hdev, port1,
2676                                         USB_PORT_FEAT_C_PORT_LINK_STATE);
2677                         usb_clear_port_feature(hub->hdev, port1,
2678                                         USB_PORT_FEAT_C_CONNECTION);
2679                 }
2680                 if (udev)
2681                         usb_set_device_state(udev, *status
2682                                         ? USB_STATE_NOTATTACHED
2683                                         : USB_STATE_DEFAULT);
2684                 break;
2685         }
2686 }
2687
2688 /* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
2689 static int hub_port_reset(struct usb_hub *hub, int port1,
2690                         struct usb_device *udev, unsigned int delay, bool warm)
2691 {
2692         int i, status;
2693         u16 portchange, portstatus;
2694         struct usb_port *port_dev = hub->ports[port1 - 1];
2695
2696         if (!hub_is_superspeed(hub->hdev)) {
2697                 if (warm) {
2698                         dev_err(hub->intfdev, "only USB3 hub support "
2699                                                 "warm reset\n");
2700                         return -EINVAL;
2701                 }
2702                 /* Block EHCI CF initialization during the port reset.
2703                  * Some companion controllers don't like it when they mix.
2704                  */
2705                 down_read(&ehci_cf_port_reset_rwsem);
2706         } else if (!warm) {
2707                 /*
2708                  * If the caller hasn't explicitly requested a warm reset,
2709                  * double check and see if one is needed.
2710                  */
2711                 status = hub_port_status(hub, port1,
2712                                         &portstatus, &portchange);
2713                 if (status < 0)
2714                         goto done;
2715
2716                 if (hub_port_warm_reset_required(hub, portstatus))
2717                         warm = true;
2718         }
2719
2720         /* Reset the port */
2721         for (i = 0; i < PORT_RESET_TRIES; i++) {
2722                 status = set_port_feature(hub->hdev, port1, (warm ?
2723                                         USB_PORT_FEAT_BH_PORT_RESET :
2724                                         USB_PORT_FEAT_RESET));
2725                 if (status == -ENODEV) {
2726                         ;       /* The hub is gone */
2727                 } else if (status) {
2728                         dev_err(&port_dev->dev,
2729                                         "cannot %sreset (err = %d)\n",
2730                                         warm ? "warm " : "", status);
2731                 } else {
2732                         status = hub_port_wait_reset(hub, port1, udev, delay,
2733                                                                 warm);
2734                         if (status && status != -ENOTCONN && status != -ENODEV)
2735                                 dev_dbg(hub->intfdev,
2736                                                 "port_wait_reset: err = %d\n",
2737                                                 status);
2738                 }
2739
2740                 /* Check for disconnect or reset */
2741                 if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
2742                         hub_port_finish_reset(hub, port1, udev, &status);
2743
2744                         if (!hub_is_superspeed(hub->hdev))
2745                                 goto done;
2746
2747                         /*
2748                          * If a USB 3.0 device migrates from reset to an error
2749                          * state, re-issue the warm reset.
2750                          */
2751                         if (hub_port_status(hub, port1,
2752                                         &portstatus, &portchange) < 0)
2753                                 goto done;
2754
2755                         if (!hub_port_warm_reset_required(hub, portstatus))
2756                                 goto done;
2757
2758                         /*
2759                          * If the port is in SS.Inactive or Compliance Mode, the
2760                          * hot or warm reset failed.  Try another warm reset.
2761                          */
2762                         if (!warm) {
2763                                 dev_dbg(&port_dev->dev,
2764                                                 "hot reset failed, warm reset\n");
2765                                 warm = true;
2766                         }
2767                 }
2768
2769                 dev_dbg(&port_dev->dev,
2770                                 "not enabled, trying %sreset again...\n",
2771                                 warm ? "warm " : "");
2772                 delay = HUB_LONG_RESET_TIME;
2773         }
2774
2775         dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
2776
2777 done:
2778         if (!hub_is_superspeed(hub->hdev))
2779                 up_read(&ehci_cf_port_reset_rwsem);
2780
2781         return status;
2782 }
2783
2784 /* Check if a port is power on */
2785 static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
2786 {
2787         int ret = 0;
2788
2789         if (hub_is_superspeed(hub->hdev)) {
2790                 if (portstatus & USB_SS_PORT_STAT_POWER)
2791                         ret = 1;
2792         } else {
2793                 if (portstatus & USB_PORT_STAT_POWER)
2794                         ret = 1;
2795         }
2796
2797         return ret;
2798 }
2799
2800 static void usb_lock_port(struct usb_port *port_dev)
2801                 __acquires(&port_dev->status_lock)
2802 {
2803         mutex_lock(&port_dev->status_lock);
2804         __acquire(&port_dev->status_lock);
2805 }
2806
2807 static void usb_unlock_port(struct usb_port *port_dev)
2808                 __releases(&port_dev->status_lock)
2809 {
2810         mutex_unlock(&port_dev->status_lock);
2811         __release(&port_dev->status_lock);
2812 }
2813
2814 #ifdef  CONFIG_PM
2815
2816 /* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
2817 static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
2818 {
2819         int ret = 0;
2820
2821         if (hub_is_superspeed(hub->hdev)) {
2822                 if ((portstatus & USB_PORT_STAT_LINK_STATE)
2823                                 == USB_SS_PORT_LS_U3)
2824                         ret = 1;
2825         } else {
2826                 if (portstatus & USB_PORT_STAT_SUSPEND)
2827                         ret = 1;
2828         }
2829
2830         return ret;
2831 }
2832
2833 /* Determine whether the device on a port is ready for a normal resume,
2834  * is ready for a reset-resume, or should be disconnected.
2835  */
2836 static int check_port_resume_type(struct usb_device *udev,
2837                 struct usb_hub *hub, int port1,
2838                 int status, unsigned portchange, unsigned portstatus)
2839 {
2840         struct usb_port *port_dev = hub->ports[port1 - 1];
2841
2842         /* Is the device still present? */
2843         if (status || port_is_suspended(hub, portstatus) ||
2844                         !port_is_power_on(hub, portstatus) ||
2845                         !(portstatus & USB_PORT_STAT_CONNECTION)) {
2846                 if (status >= 0)
2847                         status = -ENODEV;
2848         }
2849
2850         /* Can't do a normal resume if the port isn't enabled,
2851          * so try a reset-resume instead.
2852          */
2853         else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
2854                 if (udev->persist_enabled)
2855                         udev->reset_resume = 1;
2856                 else
2857                         status = -ENODEV;
2858         }
2859
2860         if (status) {
2861                 dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n",
2862                                 portchange, portstatus, status);
2863         } else if (udev->reset_resume) {
2864
2865                 /* Late port handoff can set status-change bits */
2866                 if (portchange & USB_PORT_STAT_C_CONNECTION)
2867                         usb_clear_port_feature(hub->hdev, port1,
2868                                         USB_PORT_FEAT_C_CONNECTION);
2869                 if (portchange & USB_PORT_STAT_C_ENABLE)
2870                         usb_clear_port_feature(hub->hdev, port1,
2871                                         USB_PORT_FEAT_C_ENABLE);
2872         }
2873
2874         return status;
2875 }
2876
2877 int usb_disable_ltm(struct usb_device *udev)
2878 {
2879         struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2880
2881         /* Check if the roothub and device supports LTM. */
2882         if (!usb_device_supports_ltm(hcd->self.root_hub) ||
2883                         !usb_device_supports_ltm(udev))
2884                 return 0;
2885
2886         /* Clear Feature LTM Enable can only be sent if the device is
2887          * configured.
2888          */
2889         if (!udev->actconfig)
2890                 return 0;
2891
2892         return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2893                         USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
2894                         USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
2895                         USB_CTRL_SET_TIMEOUT);
2896 }
2897 EXPORT_SYMBOL_GPL(usb_disable_ltm);
2898
2899 void usb_enable_ltm(struct usb_device *udev)
2900 {
2901         struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2902
2903         /* Check if the roothub and device supports LTM. */
2904         if (!usb_device_supports_ltm(hcd->self.root_hub) ||
2905                         !usb_device_supports_ltm(udev))
2906                 return;
2907
2908         /* Set Feature LTM Enable can only be sent if the device is
2909          * configured.
2910          */
2911         if (!udev->actconfig)
2912                 return;
2913
2914         usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2915                         USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
2916                         USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
2917                         USB_CTRL_SET_TIMEOUT);
2918 }
2919 EXPORT_SYMBOL_GPL(usb_enable_ltm);
2920
2921 /*
2922  * usb_enable_remote_wakeup - enable remote wakeup for a device
2923  * @udev: target device
2924  *
2925  * For USB-2 devices: Set the device's remote wakeup feature.
2926  *
2927  * For USB-3 devices: Assume there's only one function on the device and
2928  * enable remote wake for the first interface.  FIXME if the interface
2929  * association descriptor shows there's more than one function.
2930  */
2931 static int usb_enable_remote_wakeup(struct usb_device *udev)
2932 {
2933         if (udev->speed < USB_SPEED_SUPER)
2934                 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2935                                 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
2936                                 USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
2937                                 USB_CTRL_SET_TIMEOUT);
2938         else
2939                 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2940                                 USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
2941                                 USB_INTRF_FUNC_SUSPEND,
2942                                 USB_INTRF_FUNC_SUSPEND_RW |
2943                                         USB_INTRF_FUNC_SUSPEND_LP,
2944                                 NULL, 0, USB_CTRL_SET_TIMEOUT);
2945 }
2946
2947 /*
2948  * usb_disable_remote_wakeup - disable remote wakeup for a device
2949  * @udev: target device
2950  *
2951  * For USB-2 devices: Clear the device's remote wakeup feature.
2952  *
2953  * For USB-3 devices: Assume there's only one function on the device and
2954  * disable remote wake for the first interface.  FIXME if the interface
2955  * association descriptor shows there's more than one function.
2956  */
2957 static int usb_disable_remote_wakeup(struct usb_device *udev)
2958 {
2959         if (udev->speed < USB_SPEED_SUPER)
2960                 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2961                                 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
2962                                 USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
2963                                 USB_CTRL_SET_TIMEOUT);
2964         else
2965                 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2966                                 USB_REQ_CLEAR_FEATURE, USB_RECIP_INTERFACE,
2967                                 USB_INTRF_FUNC_SUSPEND, 0, NULL, 0,
2968                                 USB_CTRL_SET_TIMEOUT);
2969 }
2970
2971 /* Count of wakeup-enabled devices at or below udev */
2972 static unsigned wakeup_enabled_descendants(struct usb_device *udev)
2973 {
2974         struct usb_hub *hub = usb_hub_to_struct_hub(udev);
2975
2976         return udev->do_remote_wakeup +
2977                         (hub ? hub->wakeup_enabled_descendants : 0);
2978 }
2979
2980 /*
2981  * usb_port_suspend - suspend a usb device's upstream port
2982  * @udev: device that's no longer in active use, not a root hub
2983  * Context: must be able to sleep; device not locked; pm locks held
2984  *
2985  * Suspends a USB device that isn't in active use, conserving power.
2986  * Devices may wake out of a suspend, if anything important happens,
2987  * using the remote wakeup mechanism.  They may also be taken out of
2988  * suspend by the host, using usb_port_resume().  It's also routine
2989  * to disconnect devices while they are suspended.
2990  *
2991  * This only affects the USB hardware for a device; its interfaces
2992  * (and, for hubs, child devices) must already have been suspended.
2993  *
2994  * Selective port suspend reduces power; most suspended devices draw
2995  * less than 500 uA.  It's also used in OTG, along with remote wakeup.
2996  * All devices below the suspended port are also suspended.
2997  *
2998  * Devices leave suspend state when the host wakes them up.  Some devices
2999  * also support "remote wakeup", where the device can activate the USB
3000  * tree above them to deliver data, such as a keypress or packet.  In
3001  * some cases, this wakes the USB host.
3002  *
3003  * Suspending OTG devices may trigger HNP, if that's been enabled
3004  * between a pair of dual-role devices.  That will change roles, such
3005  * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
3006  *
3007  * Devices on USB hub ports have only one "suspend" state, corresponding
3008  * to ACPI D2, "may cause the device to lose some context".
3009  * State transitions include:
3010  *
3011  *   - suspend, resume ... when the VBUS power link stays live
3012  *   - suspend, disconnect ... VBUS lost
3013  *
3014  * Once VBUS drop breaks the circuit, the port it's using has to go through
3015  * normal re-enumeration procedures, starting with enabling VBUS power.
3016  * Other than re-initializing the hub (plug/unplug, except for root hubs),
3017  * Linux (2.6) currently has NO mechanisms to initiate that:  no khubd
3018  * timer, no SRP, no requests through sysfs.
3019  *
3020  * If Runtime PM isn't enabled or used, non-SuperSpeed devices may not get
3021  * suspended until their bus goes into global suspend (i.e., the root
3022  * hub is suspended).  Nevertheless, we change @udev->state to
3023  * USB_STATE_SUSPENDED as this is the device's "logical" state.  The actual
3024  * upstream port setting is stored in @udev->port_is_suspended.
3025  *
3026  * Returns 0 on success, else negative errno.
3027  */
3028 int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
3029 {
3030         struct usb_hub  *hub = usb_hub_to_struct_hub(udev->parent);
3031         struct usb_port *port_dev = hub->ports[udev->portnum - 1];
3032         int             port1 = udev->portnum;
3033         int             status;
3034         bool            really_suspend = true;
3035
3036         usb_lock_port(port_dev);
3037
3038         /* enable remote wakeup when appropriate; this lets the device
3039          * wake up the upstream hub (including maybe the root hub).
3040          *
3041          * NOTE:  OTG devices may issue remote wakeup (or SRP) even when
3042          * we don't explicitly enable it here.
3043          */
3044         if (udev->do_remote_wakeup) {
3045                 status = usb_enable_remote_wakeup(udev);
3046                 if (status) {
3047                         dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
3048                                         status);
3049                         /* bail if autosuspend is requested */
3050                         if (PMSG_IS_AUTO(msg))
3051                                 goto err_wakeup;
3052                 }
3053         }
3054
3055         /* disable USB2 hardware LPM */
3056         if (udev->usb2_hw_lpm_enabled == 1)
3057                 usb_set_usb2_hardware_lpm(udev, 0);
3058
3059         if (usb_disable_ltm(udev)) {
3060                 dev_err(&udev->dev, "Failed to disable LTM before suspend\n.");
3061                 status = -ENOMEM;
3062                 if (PMSG_IS_AUTO(msg))
3063                         goto err_ltm;
3064         }
3065         if (usb_unlocked_disable_lpm(udev)) {
3066                 dev_err(&udev->dev, "Failed to disable LPM before suspend\n.");
3067                 status = -ENOMEM;
3068                 if (PMSG_IS_AUTO(msg))
3069                         goto err_lpm3;
3070         }
3071
3072         /* see 7.1.7.6 */
3073         if (hub_is_superspeed(hub->hdev))
3074                 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
3075
3076         /*
3077          * For system suspend, we do not need to enable the suspend feature
3078          * on individual USB-2 ports.  The devices will automatically go
3079          * into suspend a few ms after the root hub stops sending packets.
3080          * The USB 2.0 spec calls this "global suspend".
3081          *
3082          * However, many USB hubs have a bug: They don't relay wakeup requests
3083          * from a downstream port if the port's suspend feature isn't on.
3084          * Therefore we will turn on the suspend feature if udev or any of its
3085          * descendants is enabled for remote wakeup.
3086          */
3087         else if (PMSG_IS_AUTO(msg) || wakeup_enabled_descendants(udev) > 0)
3088                 status = set_port_feature(hub->hdev, port1,
3089                                 USB_PORT_FEAT_SUSPEND);
3090         else {
3091                 really_suspend = false;
3092                 status = 0;
3093         }
3094         if (status) {
3095                 dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status);
3096
3097                 /* Try to enable USB3 LPM and LTM again */
3098                 usb_unlocked_enable_lpm(udev);
3099  err_lpm3:
3100                 usb_enable_ltm(udev);
3101  err_ltm:
3102                 /* Try to enable USB2 hardware LPM again */
3103                 if (udev->usb2_hw_lpm_capable == 1)
3104                         usb_set_usb2_hardware_lpm(udev, 1);
3105
3106                 if (udev->do_remote_wakeup)
3107                         (void) usb_disable_remote_wakeup(udev);
3108  err_wakeup:
3109
3110                 /* System sleep transitions should never fail */
3111                 if (!PMSG_IS_AUTO(msg))
3112                         status = 0;
3113         } else {
3114                 dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
3115                                 (PMSG_IS_AUTO(msg) ? "auto-" : ""),
3116                                 udev->do_remote_wakeup);
3117                 if (really_suspend) {
3118                         udev->port_is_suspended = 1;
3119
3120                         /* device has up to 10 msec to fully suspend */
3121                         msleep(10);
3122                 }
3123                 usb_set_device_state(udev, USB_STATE_SUSPENDED);
3124         }
3125
3126         if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled
3127                         && test_and_clear_bit(port1, hub->child_usage_bits))
3128                 pm_runtime_put_sync(&port_dev->dev);
3129
3130         usb_mark_last_busy(hub->hdev);
3131
3132         usb_unlock_port(port_dev);
3133         return status;
3134 }
3135
3136 /*
3137  * If the USB "suspend" state is in use (rather than "global suspend"),
3138  * many devices will be individually taken out of suspend state using
3139  * special "resume" signaling.  This routine kicks in shortly after
3140  * hardware resume signaling is finished, either because of selective
3141  * resume (by host) or remote wakeup (by device) ... now see what changed
3142  * in the tree that's rooted at this device.
3143  *
3144  * If @udev->reset_resume is set then the device is reset before the
3145  * status check is done.
3146  */
3147 static int finish_port_resume(struct usb_device *udev)
3148 {
3149         int     status = 0;
3150         u16     devstatus = 0;
3151
3152         /* caller owns the udev device lock */
3153         dev_dbg(&udev->dev, "%s\n",
3154                 udev->reset_resume ? "finish reset-resume" : "finish resume");
3155
3156         /* usb ch9 identifies four variants of SUSPENDED, based on what
3157          * state the device resumes to.  Linux currently won't see the
3158          * first two on the host side; they'd be inside hub_port_init()
3159          * during many timeouts, but khubd can't suspend until later.
3160          */
3161         usb_set_device_state(udev, udev->actconfig
3162                         ? USB_STATE_CONFIGURED
3163                         : USB_STATE_ADDRESS);
3164
3165         /* 10.5.4.5 says not to reset a suspended port if the attached
3166          * device is enabled for remote wakeup.  Hence the reset
3167          * operation is carried out here, after the port has been
3168          * resumed.
3169          */
3170         if (udev->reset_resume) {
3171                 /*
3172                  * If the device morphs or switches modes when it is reset,
3173                  * we don't want to perform a reset-resume.  We'll fail the
3174                  * resume, which will cause a logical disconnect, and then
3175                  * the device will be rediscovered.
3176                  */
3177  retry_reset_resume:
3178                 if (udev->quirks & USB_QUIRK_RESET)
3179                         status = -ENODEV;
3180                 else
3181                         status = usb_reset_and_verify_device(udev);
3182         }
3183
3184         /* 10.5.4.5 says be sure devices in the tree are still there.
3185          * For now let's assume the device didn't go crazy on resume,
3186          * and device drivers will know about any resume quirks.
3187          */
3188         if (status == 0) {
3189                 devstatus = 0;
3190                 status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
3191
3192                 /* If a normal resume failed, try doing a reset-resume */
3193                 if (status && !udev->reset_resume && udev->persist_enabled) {
3194                         dev_dbg(&udev->dev, "retry with reset-resume\n");
3195                         udev->reset_resume = 1;
3196                         goto retry_reset_resume;
3197                 }
3198         }
3199
3200         if (status) {
3201                 dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
3202                                 status);
3203         /*
3204          * There are a few quirky devices which violate the standard
3205          * by claiming to have remote wakeup enabled after a reset,
3206          * which crash if the feature is cleared, hence check for
3207          * udev->reset_resume
3208          */
3209         } else if (udev->actconfig && !udev->reset_resume) {
3210                 if (udev->speed < USB_SPEED_SUPER) {
3211                         if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
3212                                 status = usb_disable_remote_wakeup(udev);
3213                 } else {
3214                         status = usb_get_status(udev, USB_RECIP_INTERFACE, 0,
3215                                         &devstatus);
3216                         if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
3217                                         | USB_INTRF_STAT_FUNC_RW))
3218                                 status = usb_disable_remote_wakeup(udev);
3219                 }
3220
3221                 if (status)
3222                         dev_dbg(&udev->dev,
3223                                 "disable remote wakeup, status %d\n",
3224                                 status);
3225                 status = 0;
3226         }
3227         return status;
3228 }
3229
3230 /*
3231  * usb_port_resume - re-activate a suspended usb device's upstream port
3232  * @udev: device to re-activate, not a root hub
3233  * Context: must be able to sleep; device not locked; pm locks held
3234  *
3235  * This will re-activate the suspended device, increasing power usage
3236  * while letting drivers communicate again with its endpoints.
3237  * USB resume explicitly guarantees that the power session between
3238  * the host and the device is the same as it was when the device
3239  * suspended.
3240  *
3241  * If @udev->reset_resume is set then this routine won't check that the
3242  * port is still enabled.  Furthermore, finish_port_resume() above will
3243  * reset @udev.  The end result is that a broken power session can be
3244  * recovered and @udev will appear to persist across a loss of VBUS power.
3245  *
3246  * For example, if a host controller doesn't maintain VBUS suspend current
3247  * during a system sleep or is reset when the system wakes up, all the USB
3248  * power sessions below it will be broken.  This is especially troublesome
3249  * for mass-storage devices containing mounted filesystems, since the
3250  * device will appear to have disconnected and all the memory mappings
3251  * to it will be lost.  Using the USB_PERSIST facility, the device can be
3252  * made to appear as if it had not disconnected.
3253  *
3254  * This facility can be dangerous.  Although usb_reset_and_verify_device() makes
3255  * every effort to insure that the same device is present after the
3256  * reset as before, it cannot provide a 100% guarantee.  Furthermore it's
3257  * quite possible for a device to remain unaltered but its media to be
3258  * changed.  If the user replaces a flash memory card while the system is
3259  * asleep, he will have only himself to blame when the filesystem on the
3260  * new card is corrupted and the system crashes.
3261  *
3262  * Returns 0 on success, else negative errno.
3263  */
3264 int usb_port_resume(struct usb_device *udev, pm_message_t msg)
3265 {
3266         struct usb_hub  *hub = usb_hub_to_struct_hub(udev->parent);
3267         struct usb_port *port_dev = hub->ports[udev->portnum  - 1];
3268         int             port1 = udev->portnum;
3269         int             status;
3270         u16             portchange, portstatus;
3271
3272         if (!test_and_set_bit(port1, hub->child_usage_bits)) {
3273                 status = pm_runtime_get_sync(&port_dev->dev);
3274                 if (status < 0) {
3275                         dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
3276                                         status);
3277                         return status;
3278     &nb