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