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