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