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