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