blob: 5480352f984dc2df418902a430979c828cb5df52 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/ioctl.h>
20#include <linux/usb.h>
21#include <linux/usbdevice_fs.h>
Eric Lescouet27729aa2010-04-24 23:21:52 +020022#include <linux/usb/hcd.h>
Richard Zhao925aa462012-07-11 11:09:28 +080023#include <linux/usb/otg.h>
Phil Dibowitz93362a82010-07-22 00:05:01 +020024#include <linux/usb/quirks.h>
akpm@osdl.org9c8d6172005-06-20 14:29:58 -070025#include <linux/kthread.h>
Arjan van de Ven4186ecf2006-01-11 15:55:29 +010026#include <linux/mutex.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080027#include <linux/freezer.h>
Theodore Ts'ob04b3152012-07-04 11:22:20 -040028#include <linux/random.h>
Lan Tianyuad493e52013-01-23 04:26:30 +080029#include <linux/pm_qos.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <asm/uaccess.h>
32#include <asm/byteorder.h>
33
Lan Tianyu6e30d7c2013-01-11 20:10:38 +080034#include "hub.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -080036/* if we are in debug mode, always announce new devices */
37#ifdef DEBUG
38#ifndef CONFIG_USB_ANNOUNCE_NEW_DEVICES
39#define CONFIG_USB_ANNOUNCE_NEW_DEVICES
40#endif
41#endif
42
Ming Leie6f30de2012-10-24 11:59:24 +080043#define USB_VENDOR_GENESYS_LOGIC 0x05e3
44#define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND 0x01
45
John Youndbe79bb2001-09-17 00:00:00 -070046static inline int hub_is_superspeed(struct usb_device *hdev)
47{
Aman Deep7bf01182011-12-08 12:05:22 +053048 return (hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS);
John Youndbe79bb2001-09-17 00:00:00 -070049}
Alan Stern1bb5f662006-11-06 11:56:13 -050050
Greg Kroah-Hartmanfa286182012-05-14 09:20:37 -070051/* Protect struct usb_device->state and ->children members
Alan Stern9ad3d6c2005-11-17 17:10:32 -050052 * Note: Both are also protected by ->dev.sem, except that ->state can
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
54static DEFINE_SPINLOCK(device_state_lock);
55
56/* khubd's worklist and its lock */
57static DEFINE_SPINLOCK(hub_event_lock);
58static LIST_HEAD(hub_event_list); /* List of hubs needing servicing */
59
60/* Wakes up khubd */
61static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
62
akpm@osdl.org9c8d6172005-06-20 14:29:58 -070063static struct task_struct *khubd_task;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65/* cycle leds on hubs that aren't blinking for attention */
Rusty Russell90ab5ee2012-01-13 09:32:20 +103066static bool blinkenlights = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067module_param (blinkenlights, bool, S_IRUGO);
68MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");
69
70/*
Jaroslav Kyselafd7c5192008-10-10 16:24:45 +020071 * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about
72 * 10 seconds to send reply for the initial 64-byte descriptor request.
73 */
74/* define initial 64-byte descriptor request timeout in milliseconds */
75static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
76module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
Wu Fengguangb9cef6c2008-12-15 15:32:01 +080077MODULE_PARM_DESC(initial_descriptor_timeout,
78 "initial 64-byte descriptor request timeout in milliseconds "
79 "(default 5000 - 5.0 seconds)");
Jaroslav Kyselafd7c5192008-10-10 16:24:45 +020080
81/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 * As of 2.6.10 we introduce a new USB device initialization scheme which
83 * closely resembles the way Windows works. Hopefully it will be compatible
84 * with a wider range of devices than the old scheme. However some previously
85 * working devices may start giving rise to "device not accepting address"
86 * errors; if that happens the user can try the old scheme by adjusting the
87 * following module parameters.
88 *
89 * For maximum flexibility there are two boolean parameters to control the
90 * hub driver's behavior. On the first initialization attempt, if the
91 * "old_scheme_first" parameter is set then the old scheme will be used,
92 * otherwise the new scheme is used. If that fails and "use_both_schemes"
93 * is set, then the driver will make another attempt, using the other scheme.
94 */
Rusty Russell90ab5ee2012-01-13 09:32:20 +103095static bool old_scheme_first = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
97MODULE_PARM_DESC(old_scheme_first,
98 "start with the old device initialization scheme");
99
Rusty Russell90ab5ee2012-01-13 09:32:20 +1030100static bool use_both_schemes = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
102MODULE_PARM_DESC(use_both_schemes,
103 "try the other device initialization scheme if the "
104 "first one fails");
105
Alan Stern32fe0192007-10-10 16:27:07 -0400106/* Mutual exclusion for EHCI CF initialization. This interferes with
107 * port reset on some companion controllers.
108 */
109DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
110EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
111
Lan Tianyuad493e52013-01-23 04:26:30 +0800112#define HUB_DEBOUNCE_TIMEOUT 2000
Alan Stern948fea32008-04-28 11:07:07 -0400113#define HUB_DEBOUNCE_STEP 25
114#define HUB_DEBOUNCE_STABLE 100
115
Ming Lei742120c2008-06-18 22:00:29 +0800116static int usb_reset_and_verify_device(struct usb_device *udev);
117
Sarah Sharp131dec32010-12-06 21:00:19 -0800118static inline char *portspeed(struct usb_hub *hub, int portstatus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
Sarah Sharp131dec32010-12-06 21:00:19 -0800120 if (hub_is_superspeed(hub->hdev))
121 return "5.0 Gb/s";
Alan Stern288ead42010-03-04 11:32:30 -0500122 if (portstatus & USB_PORT_STAT_HIGH_SPEED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 return "480 Mb/s";
Alan Stern288ead42010-03-04 11:32:30 -0500124 else if (portstatus & USB_PORT_STAT_LOW_SPEED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 return "1.5 Mb/s";
126 else
127 return "12 Mb/s";
128}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
130/* Note that hdev or one of its children must be locked! */
Lan Tianyuad493e52013-01-23 04:26:30 +0800131struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
Lan Tianyuff823c792012-09-05 13:44:32 +0800133 if (!hdev || !hdev->actconfig || !hdev->maxchild)
Alan Stern251180842009-07-22 14:41:18 -0400134 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 return usb_get_intfdata(hdev->actconfig->interface[0]);
136}
137
Sarah Sharpd9b20992012-02-20 08:31:26 -0800138static int usb_device_supports_lpm(struct usb_device *udev)
139{
140 /* USB 2.1 (and greater) devices indicate LPM support through
141 * their USB 2.0 Extended Capabilities BOS descriptor.
142 */
143 if (udev->speed == USB_SPEED_HIGH) {
144 if (udev->bos->ext_cap &&
145 (USB_LPM_SUPPORT &
146 le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
147 return 1;
148 return 0;
149 }
Sarah Sharp51e0a012012-02-20 12:02:19 -0800150
151 /* All USB 3.0 must support LPM, but we need their max exit latency
152 * information from the SuperSpeed Extended Capabilities BOS descriptor.
153 */
154 if (!udev->bos->ss_cap) {
155 dev_warn(&udev->dev, "No LPM exit latency info found. "
156 "Power management will be impacted.\n");
157 return 0;
158 }
159 if (udev->parent->lpm_capable)
160 return 1;
161
162 dev_warn(&udev->dev, "Parent hub missing LPM exit latency info. "
163 "Power management will be impacted.\n");
Sarah Sharpd9b20992012-02-20 08:31:26 -0800164 return 0;
165}
166
Sarah Sharp51e0a012012-02-20 12:02:19 -0800167/*
168 * Set the Maximum Exit Latency (MEL) for the host to initiate a transition from
169 * either U1 or U2.
170 */
171static void usb_set_lpm_mel(struct usb_device *udev,
172 struct usb3_lpm_parameters *udev_lpm_params,
173 unsigned int udev_exit_latency,
174 struct usb_hub *hub,
175 struct usb3_lpm_parameters *hub_lpm_params,
176 unsigned int hub_exit_latency)
177{
178 unsigned int total_mel;
179 unsigned int device_mel;
180 unsigned int hub_mel;
181
182 /*
183 * Calculate the time it takes to transition all links from the roothub
184 * to the parent hub into U0. The parent hub must then decode the
185 * packet (hub header decode latency) to figure out which port it was
186 * bound for.
187 *
188 * The Hub Header decode latency is expressed in 0.1us intervals (0x1
189 * means 0.1us). Multiply that by 100 to get nanoseconds.
190 */
191 total_mel = hub_lpm_params->mel +
192 (hub->descriptor->u.ss.bHubHdrDecLat * 100);
193
194 /*
195 * How long will it take to transition the downstream hub's port into
196 * U0? The greater of either the hub exit latency or the device exit
197 * latency.
198 *
199 * The BOS U1/U2 exit latencies are expressed in 1us intervals.
200 * Multiply that by 1000 to get nanoseconds.
201 */
202 device_mel = udev_exit_latency * 1000;
203 hub_mel = hub_exit_latency * 1000;
204 if (device_mel > hub_mel)
205 total_mel += device_mel;
206 else
207 total_mel += hub_mel;
208
209 udev_lpm_params->mel = total_mel;
210}
211
212/*
213 * Set the maximum Device to Host Exit Latency (PEL) for the device to initiate
214 * a transition from either U1 or U2.
215 */
216static void usb_set_lpm_pel(struct usb_device *udev,
217 struct usb3_lpm_parameters *udev_lpm_params,
218 unsigned int udev_exit_latency,
219 struct usb_hub *hub,
220 struct usb3_lpm_parameters *hub_lpm_params,
221 unsigned int hub_exit_latency,
222 unsigned int port_to_port_exit_latency)
223{
224 unsigned int first_link_pel;
225 unsigned int hub_pel;
226
227 /*
228 * First, the device sends an LFPS to transition the link between the
229 * device and the parent hub into U0. The exit latency is the bigger of
230 * the device exit latency or the hub exit latency.
231 */
232 if (udev_exit_latency > hub_exit_latency)
233 first_link_pel = udev_exit_latency * 1000;
234 else
235 first_link_pel = hub_exit_latency * 1000;
236
237 /*
238 * When the hub starts to receive the LFPS, there is a slight delay for
239 * it to figure out that one of the ports is sending an LFPS. Then it
240 * will forward the LFPS to its upstream link. The exit latency is the
241 * delay, plus the PEL that we calculated for this hub.
242 */
243 hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel;
244
245 /*
246 * According to figure C-7 in the USB 3.0 spec, the PEL for this device
247 * is the greater of the two exit latencies.
248 */
249 if (first_link_pel > hub_pel)
250 udev_lpm_params->pel = first_link_pel;
251 else
252 udev_lpm_params->pel = hub_pel;
253}
254
255/*
256 * Set the System Exit Latency (SEL) to indicate the total worst-case time from
257 * when a device initiates a transition to U0, until when it will receive the
258 * first packet from the host controller.
259 *
260 * Section C.1.5.1 describes the four components to this:
261 * - t1: device PEL
262 * - t2: time for the ERDY to make it from the device to the host.
263 * - t3: a host-specific delay to process the ERDY.
264 * - t4: time for the packet to make it from the host to the device.
265 *
266 * t3 is specific to both the xHCI host and the platform the host is integrated
267 * into. The Intel HW folks have said it's negligible, FIXME if a different
268 * vendor says otherwise.
269 */
270static void usb_set_lpm_sel(struct usb_device *udev,
271 struct usb3_lpm_parameters *udev_lpm_params)
272{
273 struct usb_device *parent;
274 unsigned int num_hubs;
275 unsigned int total_sel;
276
277 /* t1 = device PEL */
278 total_sel = udev_lpm_params->pel;
279 /* How many external hubs are in between the device & the root port. */
280 for (parent = udev->parent, num_hubs = 0; parent->parent;
281 parent = parent->parent)
282 num_hubs++;
283 /* t2 = 2.1us + 250ns * (num_hubs - 1) */
284 if (num_hubs > 0)
285 total_sel += 2100 + 250 * (num_hubs - 1);
286
287 /* t4 = 250ns * num_hubs */
288 total_sel += 250 * num_hubs;
289
290 udev_lpm_params->sel = total_sel;
291}
292
293static void usb_set_lpm_parameters(struct usb_device *udev)
294{
295 struct usb_hub *hub;
296 unsigned int port_to_port_delay;
297 unsigned int udev_u1_del;
298 unsigned int udev_u2_del;
299 unsigned int hub_u1_del;
300 unsigned int hub_u2_del;
301
302 if (!udev->lpm_capable || udev->speed != USB_SPEED_SUPER)
303 return;
304
Lan Tianyuad493e52013-01-23 04:26:30 +0800305 hub = usb_hub_to_struct_hub(udev->parent);
Sarah Sharp51e0a012012-02-20 12:02:19 -0800306 /* It doesn't take time to transition the roothub into U0, since it
307 * doesn't have an upstream link.
308 */
309 if (!hub)
310 return;
311
312 udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
313 udev_u2_del = udev->bos->ss_cap->bU2DevExitLat;
314 hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
315 hub_u2_del = udev->parent->bos->ss_cap->bU2DevExitLat;
316
317 usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
318 hub, &udev->parent->u1_params, hub_u1_del);
319
320 usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del,
321 hub, &udev->parent->u2_params, hub_u2_del);
322
323 /*
324 * Appendix C, section C.2.2.2, says that there is a slight delay from
325 * when the parent hub notices the downstream port is trying to
326 * transition to U0 to when the hub initiates a U0 transition on its
327 * upstream port. The section says the delays are tPort2PortU1EL and
328 * tPort2PortU2EL, but it doesn't define what they are.
329 *
330 * The hub chapter, sections 10.4.2.4 and 10.4.2.5 seem to be talking
331 * about the same delays. Use the maximum delay calculations from those
332 * sections. For U1, it's tHubPort2PortExitLat, which is 1us max. For
333 * U2, it's tHubPort2PortExitLat + U2DevExitLat - U1DevExitLat. I
334 * assume the device exit latencies they are talking about are the hub
335 * exit latencies.
336 *
337 * What do we do if the U2 exit latency is less than the U1 exit
338 * latency? It's possible, although not likely...
339 */
340 port_to_port_delay = 1;
341
342 usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del,
343 hub, &udev->parent->u1_params, hub_u1_del,
344 port_to_port_delay);
345
346 if (hub_u2_del > hub_u1_del)
347 port_to_port_delay = 1 + hub_u2_del - hub_u1_del;
348 else
349 port_to_port_delay = 1 + hub_u1_del;
350
351 usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del,
352 hub, &udev->parent->u2_params, hub_u2_del,
353 port_to_port_delay);
354
355 /* Now that we've got PEL, calculate SEL. */
356 usb_set_lpm_sel(udev, &udev->u1_params);
357 usb_set_lpm_sel(udev, &udev->u2_params);
358}
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360/* USB 2.0 spec Section 11.24.4.5 */
John Youndbe79bb2001-09-17 00:00:00 -0700361static int get_hub_descriptor(struct usb_device *hdev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
John Youndbe79bb2001-09-17 00:00:00 -0700363 int i, ret, size;
364 unsigned dtype;
365
366 if (hub_is_superspeed(hdev)) {
367 dtype = USB_DT_SS_HUB;
368 size = USB_DT_SS_HUB_SIZE;
369 } else {
370 dtype = USB_DT_HUB;
371 size = sizeof(struct usb_hub_descriptor);
372 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
374 for (i = 0; i < 3; i++) {
375 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
376 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
John Youndbe79bb2001-09-17 00:00:00 -0700377 dtype << 8, 0, data, size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 USB_CTRL_GET_TIMEOUT);
379 if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
380 return ret;
381 }
382 return -EINVAL;
383}
384
385/*
386 * USB 2.0 spec Section 11.24.2.1
387 */
388static int clear_hub_feature(struct usb_device *hdev, int feature)
389{
390 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
391 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
392}
393
394/*
395 * USB 2.0 spec Section 11.24.2.2
396 */
Lan Tianyuad493e52013-01-23 04:26:30 +0800397int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398{
399 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
400 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
401 NULL, 0, 1000);
402}
403
404/*
405 * USB 2.0 spec Section 11.24.2.13
406 */
407static int set_port_feature(struct usb_device *hdev, int port1, int feature)
408{
409 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
410 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
411 NULL, 0, 1000);
412}
413
414/*
415 * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
416 * for info about using port indicators
417 */
418static void set_port_led(
419 struct usb_hub *hub,
420 int port1,
421 int selector
422)
423{
424 int status = set_port_feature(hub->hdev, (selector << 8) | port1,
425 USB_PORT_FEAT_INDICATOR);
426 if (status < 0)
427 dev_dbg (hub->intfdev,
428 "port %d indicator %s status %d\n",
429 port1,
430 ({ char *s; switch (selector) {
431 case HUB_LED_AMBER: s = "amber"; break;
432 case HUB_LED_GREEN: s = "green"; break;
433 case HUB_LED_OFF: s = "off"; break;
434 case HUB_LED_AUTO: s = "auto"; break;
435 default: s = "??"; break;
436 }; s; }),
437 status);
438}
439
440#define LED_CYCLE_PERIOD ((2*HZ)/3)
441
David Howellsc4028952006-11-22 14:57:56 +0000442static void led_work (struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
David Howellsc4028952006-11-22 14:57:56 +0000444 struct usb_hub *hub =
445 container_of(work, struct usb_hub, leds.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 struct usb_device *hdev = hub->hdev;
447 unsigned i;
448 unsigned changed = 0;
449 int cursor = -1;
450
451 if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
452 return;
453
454 for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
455 unsigned selector, mode;
456
457 /* 30%-50% duty cycle */
458
459 switch (hub->indicator[i]) {
460 /* cycle marker */
461 case INDICATOR_CYCLE:
462 cursor = i;
463 selector = HUB_LED_AUTO;
464 mode = INDICATOR_AUTO;
465 break;
466 /* blinking green = sw attention */
467 case INDICATOR_GREEN_BLINK:
468 selector = HUB_LED_GREEN;
469 mode = INDICATOR_GREEN_BLINK_OFF;
470 break;
471 case INDICATOR_GREEN_BLINK_OFF:
472 selector = HUB_LED_OFF;
473 mode = INDICATOR_GREEN_BLINK;
474 break;
475 /* blinking amber = hw attention */
476 case INDICATOR_AMBER_BLINK:
477 selector = HUB_LED_AMBER;
478 mode = INDICATOR_AMBER_BLINK_OFF;
479 break;
480 case INDICATOR_AMBER_BLINK_OFF:
481 selector = HUB_LED_OFF;
482 mode = INDICATOR_AMBER_BLINK;
483 break;
484 /* blink green/amber = reserved */
485 case INDICATOR_ALT_BLINK:
486 selector = HUB_LED_GREEN;
487 mode = INDICATOR_ALT_BLINK_OFF;
488 break;
489 case INDICATOR_ALT_BLINK_OFF:
490 selector = HUB_LED_AMBER;
491 mode = INDICATOR_ALT_BLINK;
492 break;
493 default:
494 continue;
495 }
496 if (selector != HUB_LED_AUTO)
497 changed = 1;
498 set_port_led(hub, i + 1, selector);
499 hub->indicator[i] = mode;
500 }
501 if (!changed && blinkenlights) {
502 cursor++;
503 cursor %= hub->descriptor->bNbrPorts;
504 set_port_led(hub, cursor + 1, HUB_LED_GREEN);
505 hub->indicator[cursor] = INDICATOR_CYCLE;
506 changed++;
507 }
508 if (changed)
509 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
510}
511
512/* use a short timeout for hub/port status fetches */
513#define USB_STS_TIMEOUT 1000
514#define USB_STS_RETRIES 5
515
516/*
517 * USB 2.0 spec Section 11.24.2.6
518 */
519static int get_hub_status(struct usb_device *hdev,
520 struct usb_hub_status *data)
521{
522 int i, status = -ETIMEDOUT;
523
Libor Pechacek3824c1d2011-05-20 14:53:25 +0200524 for (i = 0; i < USB_STS_RETRIES &&
525 (status == -ETIMEDOUT || status == -EPIPE); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
527 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
528 data, sizeof(*data), USB_STS_TIMEOUT);
529 }
530 return status;
531}
532
533/*
534 * USB 2.0 spec Section 11.24.2.7
535 */
536static int get_port_status(struct usb_device *hdev, int port1,
537 struct usb_port_status *data)
538{
539 int i, status = -ETIMEDOUT;
540
Libor Pechacek3824c1d2011-05-20 14:53:25 +0200541 for (i = 0; i < USB_STS_RETRIES &&
542 (status == -ETIMEDOUT || status == -EPIPE); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
544 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
545 data, sizeof(*data), USB_STS_TIMEOUT);
546 }
547 return status;
548}
549
Alan Stern3eb14912008-03-03 15:15:43 -0500550static int hub_port_status(struct usb_hub *hub, int port1,
551 u16 *status, u16 *change)
552{
553 int ret;
554
555 mutex_lock(&hub->status_mutex);
556 ret = get_port_status(hub->hdev, port1, &hub->status->port);
557 if (ret < 4) {
558 dev_err(hub->intfdev,
559 "%s failed (err = %d)\n", __func__, ret);
560 if (ret >= 0)
561 ret = -EIO;
562 } else {
563 *status = le16_to_cpu(hub->status->port.wPortStatus);
564 *change = le16_to_cpu(hub->status->port.wPortChange);
John Youndbe79bb2001-09-17 00:00:00 -0700565
Alan Stern3eb14912008-03-03 15:15:43 -0500566 ret = 0;
567 }
568 mutex_unlock(&hub->status_mutex);
569 return ret;
570}
571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572static void kick_khubd(struct usb_hub *hub)
573{
574 unsigned long flags;
575
576 spin_lock_irqsave(&hub_event_lock, flags);
Roel Kluin2e2c5ee2007-10-26 23:54:35 +0200577 if (!hub->disconnected && list_empty(&hub->event_list)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 list_add_tail(&hub->event_list, &hub_event_list);
Alan Stern8e4ceb32009-12-07 13:01:37 -0500579
580 /* Suppress autosuspend until khubd runs */
581 usb_autopm_get_interface_no_resume(
582 to_usb_interface(hub->intfdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 wake_up(&khubd_wait);
584 }
585 spin_unlock_irqrestore(&hub_event_lock, flags);
586}
587
588void usb_kick_khubd(struct usb_device *hdev)
589{
Lan Tianyuad493e52013-01-23 04:26:30 +0800590 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Alan Stern251180842009-07-22 14:41:18 -0400591
592 if (hub)
593 kick_khubd(hub);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594}
595
Sarah Sharp4ee823b2011-11-14 18:00:01 -0800596/*
597 * Let the USB core know that a USB 3.0 device has sent a Function Wake Device
598 * Notification, which indicates it had initiated remote wakeup.
599 *
600 * USB 3.0 hubs do not report the port link state change from U3 to U0 when the
601 * device initiates resume, so the USB core will not receive notice of the
602 * resume through the normal hub interrupt URB.
603 */
604void usb_wakeup_notification(struct usb_device *hdev,
605 unsigned int portnum)
606{
607 struct usb_hub *hub;
608
609 if (!hdev)
610 return;
611
Lan Tianyuad493e52013-01-23 04:26:30 +0800612 hub = usb_hub_to_struct_hub(hdev);
Sarah Sharp4ee823b2011-11-14 18:00:01 -0800613 if (hub) {
614 set_bit(portnum, hub->wakeup_bits);
615 kick_khubd(hub);
616 }
617}
618EXPORT_SYMBOL_GPL(usb_wakeup_notification);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
620/* completion function, fires on port status changes and various faults */
David Howells7d12e782006-10-05 14:55:46 +0100621static void hub_irq(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622{
Tobias Klauserec17cf12006-09-13 21:38:41 +0200623 struct usb_hub *hub = urb->context;
Alan Sterne0152682007-08-24 15:42:52 -0400624 int status = urb->status;
Roel Kluin71d27182009-03-13 12:19:18 +0100625 unsigned i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 unsigned long bits;
627
Alan Sterne0152682007-08-24 15:42:52 -0400628 switch (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 case -ENOENT: /* synchronous unlink */
630 case -ECONNRESET: /* async unlink */
631 case -ESHUTDOWN: /* hardware going away */
632 return;
633
634 default: /* presumably an error */
635 /* Cause a hub reset after 10 consecutive errors */
Alan Sterne0152682007-08-24 15:42:52 -0400636 dev_dbg (hub->intfdev, "transfer --> %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 if ((++hub->nerrors < 10) || hub->error)
638 goto resubmit;
Alan Sterne0152682007-08-24 15:42:52 -0400639 hub->error = status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 /* FALL THROUGH */
Tobias Klauserec17cf12006-09-13 21:38:41 +0200641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 /* let khubd handle things */
643 case 0: /* we got data: port status changed */
644 bits = 0;
645 for (i = 0; i < urb->actual_length; ++i)
646 bits |= ((unsigned long) ((*hub->buffer)[i]))
647 << (i*8);
648 hub->event_bits[0] = bits;
649 break;
650 }
651
652 hub->nerrors = 0;
653
654 /* Something happened, let khubd figure it out */
655 kick_khubd(hub);
656
657resubmit:
658 if (hub->quiescing)
659 return;
660
661 if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
662 && status != -ENODEV && status != -EPERM)
663 dev_err (hub->intfdev, "resubmit --> %d\n", status);
664}
665
666/* USB 2.0 spec Section 11.24.2.3 */
667static inline int
668hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
669{
Alan Sternc2f65952009-11-18 11:37:15 -0500670 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
672 tt, NULL, 0, 1000);
673}
674
675/*
676 * enumeration blocks khubd for a long time. we use keventd instead, since
677 * long blocking there is the exception, not the rule. accordingly, HCDs
678 * talking to TTs must queue control transfers (not just bulk and iso), so
679 * both can talk to the same hub concurrently.
680 */
Alan Sterncb88a1b2009-06-29 10:43:32 -0400681static void hub_tt_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682{
David Howellsc4028952006-11-22 14:57:56 +0000683 struct usb_hub *hub =
Alan Sterncb88a1b2009-06-29 10:43:32 -0400684 container_of(work, struct usb_hub, tt.clear_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 unsigned long flags;
686
687 spin_lock_irqsave (&hub->tt.lock, flags);
Octavian Purdila3b6054d2012-10-01 22:21:12 +0300688 while (!list_empty(&hub->tt.clear_list)) {
H Hartley Sweetend0f830d2009-04-22 16:03:05 -0400689 struct list_head *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 struct usb_tt_clear *clear;
691 struct usb_device *hdev = hub->hdev;
Alan Sterncb88a1b2009-06-29 10:43:32 -0400692 const struct hc_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 int status;
694
H Hartley Sweetend0f830d2009-04-22 16:03:05 -0400695 next = hub->tt.clear_list.next;
696 clear = list_entry (next, struct usb_tt_clear, clear_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 list_del (&clear->clear_list);
698
699 /* drop lock so HCD can concurrently report other TT errors */
700 spin_unlock_irqrestore (&hub->tt.lock, flags);
701 status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 if (status)
703 dev_err (&hdev->dev,
704 "clear tt %d (%04x) error %d\n",
705 clear->tt, clear->devinfo, status);
Alan Sterncb88a1b2009-06-29 10:43:32 -0400706
707 /* Tell the HCD, even if the operation failed */
708 drv = clear->hcd->driver;
709 if (drv->clear_tt_buffer_complete)
710 (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
711
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -0700712 kfree(clear);
Alan Sterncb88a1b2009-06-29 10:43:32 -0400713 spin_lock_irqsave(&hub->tt.lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 }
715 spin_unlock_irqrestore (&hub->tt.lock, flags);
716}
717
718/**
Lan Tianyu971fcd42013-01-23 04:26:29 +0800719 * usb_hub_set_port_power - control hub port's power state
720 * @hdev: target hub
721 * @port1: port index
722 * @set: expected status
723 *
724 * call this function to control port's power via setting or
725 * clearing the port's PORT_POWER feature.
726 */
727int usb_hub_set_port_power(struct usb_device *hdev, int port1,
728 bool set)
729{
730 int ret;
Lan Tianyuad493e52013-01-23 04:26:30 +0800731 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
732 struct usb_port *port_dev = hub->ports[port1 - 1];
Lan Tianyu971fcd42013-01-23 04:26:29 +0800733
734 if (set)
735 ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
736 else
Lan Tianyuad493e52013-01-23 04:26:30 +0800737 ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
738
739 if (!ret)
740 port_dev->power_is_on = set;
Lan Tianyu971fcd42013-01-23 04:26:29 +0800741 return ret;
742}
743
744/**
Alan Sterncb88a1b2009-06-29 10:43:32 -0400745 * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
746 * @urb: an URB associated with the failed or incomplete split transaction
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 *
748 * High speed HCDs use this to tell the hub driver that some split control or
749 * bulk transaction failed in a way that requires clearing internal state of
750 * a transaction translator. This is normally detected (and reported) from
751 * interrupt context.
752 *
753 * It may not be possible for that hub to handle additional full (or low)
754 * speed transactions until that state is fully cleared out.
755 */
Alan Sterncb88a1b2009-06-29 10:43:32 -0400756int usb_hub_clear_tt_buffer(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757{
Alan Sterncb88a1b2009-06-29 10:43:32 -0400758 struct usb_device *udev = urb->dev;
759 int pipe = urb->pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 struct usb_tt *tt = udev->tt;
761 unsigned long flags;
762 struct usb_tt_clear *clear;
763
764 /* we've got to cope with an arbitrary number of pending TT clears,
765 * since each TT has "at least two" buffers that can need it (and
766 * there can be many TTs per hub). even if they're uncommon.
767 */
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800768 if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
770 /* FIXME recover somehow ... RESET_TT? */
Alan Sterncb88a1b2009-06-29 10:43:32 -0400771 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 }
773
774 /* info that CLEAR_TT_BUFFER needs */
775 clear->tt = tt->multi ? udev->ttport : 1;
776 clear->devinfo = usb_pipeendpoint (pipe);
777 clear->devinfo |= udev->devnum << 4;
778 clear->devinfo |= usb_pipecontrol (pipe)
779 ? (USB_ENDPOINT_XFER_CONTROL << 11)
780 : (USB_ENDPOINT_XFER_BULK << 11);
781 if (usb_pipein (pipe))
782 clear->devinfo |= 1 << 15;
Alan Sterncb88a1b2009-06-29 10:43:32 -0400783
784 /* info for completion callback */
785 clear->hcd = bus_to_hcd(udev->bus);
786 clear->ep = urb->ep;
787
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 /* tell keventd to clear state for this TT */
789 spin_lock_irqsave (&tt->lock, flags);
790 list_add_tail (&clear->clear_list, &tt->clear_list);
Alan Sterncb88a1b2009-06-29 10:43:32 -0400791 schedule_work(&tt->clear_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 spin_unlock_irqrestore (&tt->lock, flags);
Alan Sterncb88a1b2009-06-29 10:43:32 -0400793 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794}
Alan Sterncb88a1b2009-06-29 10:43:32 -0400795EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Alan Stern8520f382008-09-22 14:44:26 -0400797/* If do_delay is false, return the number of milliseconds the caller
798 * needs to delay.
799 */
800static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801{
802 int port1;
David Brownellb7896962005-08-31 10:41:44 -0700803 unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
Alan Stern8520f382008-09-22 14:44:26 -0400804 unsigned delay;
Alan Stern4489a572006-04-27 15:54:22 -0400805 u16 wHubCharacteristics =
806 le16_to_cpu(hub->descriptor->wHubCharacteristics);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
Alan Stern4489a572006-04-27 15:54:22 -0400808 /* Enable power on each port. Some hubs have reserved values
809 * of LPSM (> 2) in their descriptors, even though they are
810 * USB 2.0 hubs. Some hubs do not implement port-power switching
811 * but only emulate it. In all cases, the ports won't work
812 * unless we send these messages to the hub.
813 */
814 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 dev_dbg(hub->intfdev, "enabling power on all ports\n");
Alan Stern4489a572006-04-27 15:54:22 -0400816 else
817 dev_dbg(hub->intfdev, "trying to enable port power on "
818 "non-switchable hub\n");
819 for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
Lan Tianyuad493e52013-01-23 04:26:30 +0800820 if (hub->ports[port1 - 1]->power_is_on)
821 set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
822 else
823 usb_clear_port_feature(hub->hdev, port1,
824 USB_PORT_FEAT_POWER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
David Brownellb7896962005-08-31 10:41:44 -0700826 /* Wait at least 100 msec for power to become stable */
Alan Stern8520f382008-09-22 14:44:26 -0400827 delay = max(pgood_delay, (unsigned) 100);
828 if (do_delay)
829 msleep(delay);
830 return delay;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831}
832
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833static int hub_hub_status(struct usb_hub *hub,
834 u16 *status, u16 *change)
835{
836 int ret;
837
Alan Sterndb90e7a2007-02-05 09:56:15 -0500838 mutex_lock(&hub->status_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 ret = get_hub_status(hub->hdev, &hub->status->hub);
840 if (ret < 0)
841 dev_err (hub->intfdev,
Harvey Harrison441b62c2008-03-03 16:08:34 -0800842 "%s failed (err = %d)\n", __func__, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 else {
844 *status = le16_to_cpu(hub->status->hub.wHubStatus);
845 *change = le16_to_cpu(hub->status->hub.wHubChange);
846 ret = 0;
847 }
Alan Sterndb90e7a2007-02-05 09:56:15 -0500848 mutex_unlock(&hub->status_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 return ret;
850}
851
Sarah Sharp41e7e052012-11-14 16:42:32 -0800852static int hub_set_port_link_state(struct usb_hub *hub, int port1,
853 unsigned int link_status)
854{
855 return set_port_feature(hub->hdev,
856 port1 | (link_status << 3),
857 USB_PORT_FEAT_LINK_STATE);
858}
859
860/*
861 * If USB 3.0 ports are placed into the Disabled state, they will no longer
862 * detect any device connects or disconnects. This is generally not what the
863 * USB core wants, since it expects a disabled port to produce a port status
864 * change event when a new device connects.
865 *
866 * Instead, set the link state to Disabled, wait for the link to settle into
867 * that state, clear any change bits, and then put the port into the RxDetect
868 * state.
869 */
870static int hub_usb3_port_disable(struct usb_hub *hub, int port1)
871{
872 int ret;
873 int total_time;
874 u16 portchange, portstatus;
875
876 if (!hub_is_superspeed(hub->hdev))
877 return -EINVAL;
878
879 ret = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_SS_DISABLED);
880 if (ret) {
881 dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
882 port1, ret);
883 return ret;
884 }
885
886 /* Wait for the link to enter the disabled state. */
887 for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
888 ret = hub_port_status(hub, port1, &portstatus, &portchange);
889 if (ret < 0)
890 return ret;
891
892 if ((portstatus & USB_PORT_STAT_LINK_STATE) ==
893 USB_SS_PORT_LS_SS_DISABLED)
894 break;
895 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
896 break;
897 msleep(HUB_DEBOUNCE_STEP);
898 }
899 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
900 dev_warn(hub->intfdev, "Could not disable port %d after %d ms\n",
901 port1, total_time);
902
903 return hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_RX_DETECT);
904}
905
Alan Stern8b28c752005-08-10 17:04:13 -0400906static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
907{
908 struct usb_device *hdev = hub->hdev;
Alan Stern0458d5b2007-05-04 11:52:20 -0400909 int ret = 0;
Alan Stern8b28c752005-08-10 17:04:13 -0400910
Lan Tianyuff823c792012-09-05 13:44:32 +0800911 if (hub->ports[port1 - 1]->child && set_state)
912 usb_set_device_state(hub->ports[port1 - 1]->child,
Alan Stern8b28c752005-08-10 17:04:13 -0400913 USB_STATE_NOTATTACHED);
Sarah Sharp41e7e052012-11-14 16:42:32 -0800914 if (!hub->error) {
915 if (hub_is_superspeed(hub->hdev))
916 ret = hub_usb3_port_disable(hub, port1);
917 else
Lan Tianyuad493e52013-01-23 04:26:30 +0800918 ret = usb_clear_port_feature(hdev, port1,
Sarah Sharp41e7e052012-11-14 16:42:32 -0800919 USB_PORT_FEAT_ENABLE);
920 }
Alan Stern8b28c752005-08-10 17:04:13 -0400921 if (ret)
922 dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
Alan Stern0458d5b2007-05-04 11:52:20 -0400923 port1, ret);
Alan Stern8b28c752005-08-10 17:04:13 -0400924 return ret;
925}
926
Alan Stern0458d5b2007-05-04 11:52:20 -0400927/*
Justin P. Mattock6d42fcd2011-02-26 20:33:56 -0800928 * Disable a port and mark a logical connect-change event, so that some
Alan Stern0458d5b2007-05-04 11:52:20 -0400929 * time later khubd will disconnect() any existing usb_device on the port
930 * and will re-enumerate if there actually is a device attached.
931 */
932static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
933{
934 dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
935 hub_port_disable(hub, port1, 1);
936
937 /* FIXME let caller ask to power down the port:
938 * - some devices won't enumerate without a VBUS power cycle
939 * - SRP saves power that way
940 * - ... new call, TBD ...
941 * That's easy if this hub can switch power per-port, and
942 * khubd reactivates the port later (timer, SRP, etc).
943 * Powerdown must be optional, because of reset/DFU.
944 */
945
946 set_bit(port1, hub->change_bits);
947 kick_khubd(hub);
948}
949
Alan Stern253e0572009-10-27 15:20:13 -0400950/**
951 * usb_remove_device - disable a device's port on its parent hub
952 * @udev: device to be disabled and removed
953 * Context: @udev locked, must be able to sleep.
954 *
955 * After @udev's port has been disabled, khubd is notified and it will
956 * see that the device has been disconnected. When the device is
957 * physically unplugged and something is plugged in, the events will
958 * be received and processed normally.
959 */
960int usb_remove_device(struct usb_device *udev)
961{
962 struct usb_hub *hub;
963 struct usb_interface *intf;
964
965 if (!udev->parent) /* Can't remove a root hub */
966 return -EINVAL;
Lan Tianyuad493e52013-01-23 04:26:30 +0800967 hub = usb_hub_to_struct_hub(udev->parent);
Alan Stern253e0572009-10-27 15:20:13 -0400968 intf = to_usb_interface(hub->intfdev);
969
970 usb_autopm_get_interface(intf);
971 set_bit(udev->portnum, hub->removed_bits);
972 hub_port_logical_disconnect(hub, udev->portnum);
973 usb_autopm_put_interface(intf);
974 return 0;
975}
976
Alan Stern6ee0b272008-04-28 11:06:42 -0400977enum hub_activation_type {
Alan Stern8e4ceb32009-12-07 13:01:37 -0500978 HUB_INIT, HUB_INIT2, HUB_INIT3, /* INITs must come first */
Alan Stern8520f382008-09-22 14:44:26 -0400979 HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
Alan Stern6ee0b272008-04-28 11:06:42 -0400980};
Alan Stern5e6effa2008-03-03 15:15:51 -0500981
Alan Stern8520f382008-09-22 14:44:26 -0400982static void hub_init_func2(struct work_struct *ws);
983static void hub_init_func3(struct work_struct *ws);
984
Alan Sternf2835212008-04-28 11:07:17 -0400985static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
Alan Stern5e6effa2008-03-03 15:15:51 -0500986{
987 struct usb_device *hdev = hub->hdev;
Sarah Sharp653a39d2010-12-23 11:12:42 -0800988 struct usb_hcd *hcd;
989 int ret;
Alan Stern5e6effa2008-03-03 15:15:51 -0500990 int port1;
Alan Sternf2835212008-04-28 11:07:17 -0400991 int status;
Alan Stern948fea32008-04-28 11:07:07 -0400992 bool need_debounce_delay = false;
Alan Stern8520f382008-09-22 14:44:26 -0400993 unsigned delay;
994
995 /* Continue a partial initialization */
996 if (type == HUB_INIT2)
997 goto init2;
998 if (type == HUB_INIT3)
999 goto init3;
Alan Stern5e6effa2008-03-03 15:15:51 -05001000
Elric Fua45aa3b2012-02-18 13:32:27 +08001001 /* The superspeed hub except for root hub has to use Hub Depth
1002 * value as an offset into the route string to locate the bits
1003 * it uses to determine the downstream port number. So hub driver
1004 * should send a set hub depth request to superspeed hub after
1005 * the superspeed hub is set configuration in initialization or
1006 * reset procedure.
1007 *
1008 * After a resume, port power should still be on.
Alan Sternf2835212008-04-28 11:07:17 -04001009 * For any other type of activation, turn it on.
1010 */
Alan Stern8520f382008-09-22 14:44:26 -04001011 if (type != HUB_RESUME) {
Elric Fua45aa3b2012-02-18 13:32:27 +08001012 if (hdev->parent && hub_is_superspeed(hdev)) {
1013 ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
1014 HUB_SET_DEPTH, USB_RT_HUB,
1015 hdev->level - 1, 0, NULL, 0,
1016 USB_CTRL_SET_TIMEOUT);
1017 if (ret < 0)
1018 dev_err(hub->intfdev,
1019 "set hub depth failed\n");
1020 }
Alan Stern8520f382008-09-22 14:44:26 -04001021
1022 /* Speed up system boot by using a delayed_work for the
1023 * hub's initial power-up delays. This is pretty awkward
1024 * and the implementation looks like a home-brewed sort of
1025 * setjmp/longjmp, but it saves at least 100 ms for each
1026 * root hub (assuming usbcore is compiled into the kernel
1027 * rather than as a module). It adds up.
1028 *
1029 * This can't be done for HUB_RESUME or HUB_RESET_RESUME
1030 * because for those activation types the ports have to be
1031 * operational when we return. In theory this could be done
1032 * for HUB_POST_RESET, but it's easier not to.
1033 */
1034 if (type == HUB_INIT) {
1035 delay = hub_power_on(hub, false);
1036 PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func2);
1037 schedule_delayed_work(&hub->init_work,
1038 msecs_to_jiffies(delay));
Alan Stern61fbeba2008-10-27 12:07:44 -04001039
1040 /* Suppress autosuspend until init is done */
Alan Stern8e4ceb32009-12-07 13:01:37 -05001041 usb_autopm_get_interface_no_resume(
1042 to_usb_interface(hub->intfdev));
Alan Stern8520f382008-09-22 14:44:26 -04001043 return; /* Continues at init2: below */
Sarah Sharp653a39d2010-12-23 11:12:42 -08001044 } else if (type == HUB_RESET_RESUME) {
1045 /* The internal host controller state for the hub device
1046 * may be gone after a host power loss on system resume.
1047 * Update the device's info so the HW knows it's a hub.
1048 */
1049 hcd = bus_to_hcd(hdev->bus);
1050 if (hcd->driver->update_hub_device) {
1051 ret = hcd->driver->update_hub_device(hcd, hdev,
1052 &hub->tt, GFP_NOIO);
1053 if (ret < 0) {
1054 dev_err(hub->intfdev, "Host not "
1055 "accepting hub info "
1056 "update.\n");
1057 dev_err(hub->intfdev, "LS/FS devices "
1058 "and hubs may not work "
1059 "under this hub\n.");
1060 }
1061 }
1062 hub_power_on(hub, true);
Alan Stern8520f382008-09-22 14:44:26 -04001063 } else {
1064 hub_power_on(hub, true);
1065 }
1066 }
1067 init2:
Alan Sternf2835212008-04-28 11:07:17 -04001068
Alan Stern6ee0b272008-04-28 11:06:42 -04001069 /* Check each port and set hub->change_bits to let khubd know
1070 * which ports need attention.
Alan Stern5e6effa2008-03-03 15:15:51 -05001071 */
1072 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
Lan Tianyuff823c792012-09-05 13:44:32 +08001073 struct usb_device *udev = hub->ports[port1 - 1]->child;
Alan Stern5e6effa2008-03-03 15:15:51 -05001074 u16 portstatus, portchange;
1075
Alan Stern6ee0b272008-04-28 11:06:42 -04001076 portstatus = portchange = 0;
1077 status = hub_port_status(hub, port1, &portstatus, &portchange);
1078 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1079 dev_dbg(hub->intfdev,
1080 "port %d: status %04x change %04x\n",
1081 port1, portstatus, portchange);
Alan Stern5e6effa2008-03-03 15:15:51 -05001082
Alan Stern6ee0b272008-04-28 11:06:42 -04001083 /* After anything other than HUB_RESUME (i.e., initialization
1084 * or any sort of reset), every port should be disabled.
1085 * Unconnected ports should likewise be disabled (paranoia),
1086 * and so should ports for which we have no usb_device.
Alan Stern5e6effa2008-03-03 15:15:51 -05001087 */
Alan Stern6ee0b272008-04-28 11:06:42 -04001088 if ((portstatus & USB_PORT_STAT_ENABLE) && (
1089 type != HUB_RESUME ||
1090 !(portstatus & USB_PORT_STAT_CONNECTION) ||
1091 !udev ||
1092 udev->state == USB_STATE_NOTATTACHED)) {
Andiry Xu9f0a6cd2010-05-07 18:09:27 +08001093 /*
1094 * USB3 protocol ports will automatically transition
1095 * to Enabled state when detect an USB3.0 device attach.
1096 * Do not disable USB3 protocol ports.
Andiry Xu9f0a6cd2010-05-07 18:09:27 +08001097 */
Sarah Sharp131dec32010-12-06 21:00:19 -08001098 if (!hub_is_superspeed(hdev)) {
Lan Tianyuad493e52013-01-23 04:26:30 +08001099 usb_clear_port_feature(hdev, port1,
Andiry Xu9f0a6cd2010-05-07 18:09:27 +08001100 USB_PORT_FEAT_ENABLE);
1101 portstatus &= ~USB_PORT_STAT_ENABLE;
Sarah Sharp85f0ff42010-10-14 07:22:54 -07001102 } else {
1103 /* Pretend that power was lost for USB3 devs */
1104 portstatus &= ~USB_PORT_STAT_ENABLE;
Andiry Xu9f0a6cd2010-05-07 18:09:27 +08001105 }
Alan Stern6ee0b272008-04-28 11:06:42 -04001106 }
1107
Alan Stern948fea32008-04-28 11:07:07 -04001108 /* Clear status-change flags; we'll debounce later */
1109 if (portchange & USB_PORT_STAT_C_CONNECTION) {
1110 need_debounce_delay = true;
Lan Tianyuad493e52013-01-23 04:26:30 +08001111 usb_clear_port_feature(hub->hdev, port1,
Alan Stern948fea32008-04-28 11:07:07 -04001112 USB_PORT_FEAT_C_CONNECTION);
1113 }
1114 if (portchange & USB_PORT_STAT_C_ENABLE) {
1115 need_debounce_delay = true;
Lan Tianyuad493e52013-01-23 04:26:30 +08001116 usb_clear_port_feature(hub->hdev, port1,
Alan Stern948fea32008-04-28 11:07:07 -04001117 USB_PORT_FEAT_C_ENABLE);
1118 }
Don Zickus79c3dd82011-11-03 09:07:18 -04001119 if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
1120 hub_is_superspeed(hub->hdev)) {
1121 need_debounce_delay = true;
Lan Tianyuad493e52013-01-23 04:26:30 +08001122 usb_clear_port_feature(hub->hdev, port1,
Don Zickus79c3dd82011-11-03 09:07:18 -04001123 USB_PORT_FEAT_C_BH_PORT_RESET);
1124 }
Alan Stern253e0572009-10-27 15:20:13 -04001125 /* We can forget about a "removed" device when there's a
1126 * physical disconnect or the connect status changes.
1127 */
1128 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
1129 (portchange & USB_PORT_STAT_C_CONNECTION))
1130 clear_bit(port1, hub->removed_bits);
1131
Alan Stern6ee0b272008-04-28 11:06:42 -04001132 if (!udev || udev->state == USB_STATE_NOTATTACHED) {
1133 /* Tell khubd to disconnect the device or
1134 * check for a new connection
1135 */
1136 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1137 set_bit(port1, hub->change_bits);
1138
1139 } else if (portstatus & USB_PORT_STAT_ENABLE) {
Sarah Sharp72937e12012-01-24 11:46:50 -08001140 bool port_resumed = (portstatus &
1141 USB_PORT_STAT_LINK_STATE) ==
1142 USB_SS_PORT_LS_U0;
Alan Stern6ee0b272008-04-28 11:06:42 -04001143 /* The power session apparently survived the resume.
1144 * If there was an overcurrent or suspend change
1145 * (i.e., remote wakeup request), have khubd
Sarah Sharp72937e12012-01-24 11:46:50 -08001146 * take care of it. Look at the port link state
1147 * for USB 3.0 hubs, since they don't have a suspend
1148 * change bit, and they don't set the port link change
1149 * bit on device-initiated resume.
Alan Stern6ee0b272008-04-28 11:06:42 -04001150 */
Sarah Sharp72937e12012-01-24 11:46:50 -08001151 if (portchange || (hub_is_superspeed(hub->hdev) &&
1152 port_resumed))
Alan Stern6ee0b272008-04-28 11:06:42 -04001153 set_bit(port1, hub->change_bits);
1154
1155 } else if (udev->persist_enabled) {
Lan Tianyuad493e52013-01-23 04:26:30 +08001156 struct usb_port *port_dev = hub->ports[port1 - 1];
1157
Alan Stern6ee0b272008-04-28 11:06:42 -04001158#ifdef CONFIG_PM
Alan Stern5e6effa2008-03-03 15:15:51 -05001159 udev->reset_resume = 1;
Alan Stern6ee0b272008-04-28 11:06:42 -04001160#endif
Lan Tianyuad493e52013-01-23 04:26:30 +08001161 /* Don't set the change_bits when the device
1162 * was powered off.
1163 */
1164 if (port_dev->power_is_on)
1165 set_bit(port1, hub->change_bits);
Alan Stern8808f002008-04-28 11:06:55 -04001166
Alan Stern6ee0b272008-04-28 11:06:42 -04001167 } else {
1168 /* The power session is gone; tell khubd */
1169 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1170 set_bit(port1, hub->change_bits);
Alan Stern5e6effa2008-03-03 15:15:51 -05001171 }
Alan Stern5e6effa2008-03-03 15:15:51 -05001172 }
1173
Alan Stern948fea32008-04-28 11:07:07 -04001174 /* If no port-status-change flags were set, we don't need any
1175 * debouncing. If flags were set we can try to debounce the
1176 * ports all at once right now, instead of letting khubd do them
1177 * one at a time later on.
1178 *
1179 * If any port-status changes do occur during this delay, khubd
1180 * will see them later and handle them normally.
1181 */
Alan Stern8520f382008-09-22 14:44:26 -04001182 if (need_debounce_delay) {
1183 delay = HUB_DEBOUNCE_STABLE;
Alan Sternf2835212008-04-28 11:07:17 -04001184
Alan Stern8520f382008-09-22 14:44:26 -04001185 /* Don't do a long sleep inside a workqueue routine */
1186 if (type == HUB_INIT2) {
1187 PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func3);
1188 schedule_delayed_work(&hub->init_work,
1189 msecs_to_jiffies(delay));
1190 return; /* Continues at init3: below */
1191 } else {
1192 msleep(delay);
1193 }
1194 }
1195 init3:
Alan Sternf2835212008-04-28 11:07:17 -04001196 hub->quiescing = 0;
1197
1198 status = usb_submit_urb(hub->urb, GFP_NOIO);
1199 if (status < 0)
1200 dev_err(hub->intfdev, "activate --> %d\n", status);
1201 if (hub->has_indicators && blinkenlights)
1202 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
1203
1204 /* Scan all ports that need attention */
1205 kick_khubd(hub);
Alan Stern8e4ceb32009-12-07 13:01:37 -05001206
1207 /* Allow autosuspend if it was suppressed */
1208 if (type <= HUB_INIT3)
1209 usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
Alan Stern5e6effa2008-03-03 15:15:51 -05001210}
1211
Alan Stern8520f382008-09-22 14:44:26 -04001212/* Implement the continuations for the delays above */
1213static void hub_init_func2(struct work_struct *ws)
1214{
1215 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1216
1217 hub_activate(hub, HUB_INIT2);
1218}
1219
1220static void hub_init_func3(struct work_struct *ws)
1221{
1222 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1223
1224 hub_activate(hub, HUB_INIT3);
1225}
1226
Alan Stern43303542008-04-28 11:07:31 -04001227enum hub_quiescing_type {
1228 HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
1229};
1230
1231static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
1232{
1233 struct usb_device *hdev = hub->hdev;
1234 int i;
1235
Alan Stern8520f382008-09-22 14:44:26 -04001236 cancel_delayed_work_sync(&hub->init_work);
1237
Alan Stern43303542008-04-28 11:07:31 -04001238 /* khubd and related activity won't re-trigger */
1239 hub->quiescing = 1;
1240
1241 if (type != HUB_SUSPEND) {
1242 /* Disconnect all the children */
1243 for (i = 0; i < hdev->maxchild; ++i) {
Lan Tianyuff823c792012-09-05 13:44:32 +08001244 if (hub->ports[i]->child)
1245 usb_disconnect(&hub->ports[i]->child);
Alan Stern43303542008-04-28 11:07:31 -04001246 }
1247 }
1248
1249 /* Stop khubd and related activity */
1250 usb_kill_urb(hub->urb);
1251 if (hub->has_indicators)
1252 cancel_delayed_work_sync(&hub->leds);
1253 if (hub->tt.hub)
Octavian Purdila036546b2012-10-23 11:33:12 +03001254 flush_work(&hub->tt.clear_work);
Alan Stern43303542008-04-28 11:07:31 -04001255}
1256
Alan Stern3eb14912008-03-03 15:15:43 -05001257/* caller has locked the hub device */
1258static int hub_pre_reset(struct usb_interface *intf)
1259{
1260 struct usb_hub *hub = usb_get_intfdata(intf);
1261
Alan Stern43303542008-04-28 11:07:31 -04001262 hub_quiesce(hub, HUB_PRE_RESET);
Alan Sternf07600c2007-05-30 15:38:16 -04001263 return 0;
Alan Stern7d069b72005-11-18 12:06:34 -05001264}
1265
1266/* caller has locked the hub device */
Alan Sternf07600c2007-05-30 15:38:16 -04001267static int hub_post_reset(struct usb_interface *intf)
Alan Stern7d069b72005-11-18 12:06:34 -05001268{
Alan Stern7de18d82006-06-01 13:37:24 -04001269 struct usb_hub *hub = usb_get_intfdata(intf);
1270
Alan Sternf2835212008-04-28 11:07:17 -04001271 hub_activate(hub, HUB_POST_RESET);
Alan Sternf07600c2007-05-30 15:38:16 -04001272 return 0;
Alan Stern7d069b72005-11-18 12:06:34 -05001273}
1274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275static int hub_configure(struct usb_hub *hub,
1276 struct usb_endpoint_descriptor *endpoint)
1277{
Sarah Sharpb356b7c2009-09-04 10:53:24 -07001278 struct usb_hcd *hcd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 struct usb_device *hdev = hub->hdev;
1280 struct device *hub_dev = hub->intfdev;
1281 u16 hubstatus, hubchange;
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001282 u16 wHubCharacteristics;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 unsigned int pipe;
Lan Tianyufa2a9562012-09-05 13:44:31 +08001284 int maxp, ret, i;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001285 char *message = "out of memory";
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001286 unsigned unit_load;
1287 unsigned full_load;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Alan Sternd697cdd2009-10-27 15:18:46 -04001289 hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 if (!hub->buffer) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 ret = -ENOMEM;
1292 goto fail;
1293 }
1294
1295 hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
1296 if (!hub->status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 ret = -ENOMEM;
1298 goto fail;
1299 }
Alan Sterndb90e7a2007-02-05 09:56:15 -05001300 mutex_init(&hub->status_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301
1302 hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
1303 if (!hub->descriptor) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 ret = -ENOMEM;
1305 goto fail;
1306 }
1307
1308 /* Request the entire hub descriptor.
1309 * hub->descriptor can handle USB_MAXCHILDREN ports,
1310 * but the hub can/will return fewer bytes here.
1311 */
John Youndbe79bb2001-09-17 00:00:00 -07001312 ret = get_hub_descriptor(hdev, hub->descriptor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 if (ret < 0) {
1314 message = "can't read hub descriptor";
1315 goto fail;
1316 } else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
1317 message = "hub has too many ports!";
1318 ret = -ENODEV;
1319 goto fail;
1320 }
1321
1322 hdev->maxchild = hub->descriptor->bNbrPorts;
1323 dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
1324 (hdev->maxchild == 1) ? "" : "s");
1325
Lan Tianyufa2a9562012-09-05 13:44:31 +08001326 hub->ports = kzalloc(hdev->maxchild * sizeof(struct usb_port *),
1327 GFP_KERNEL);
Lan Tianyuff823c792012-09-05 13:44:32 +08001328 if (!hub->ports) {
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001329 ret = -ENOMEM;
1330 goto fail;
1331 }
1332
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001333 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001334 if (hub_is_superspeed(hdev)) {
1335 unit_load = 150;
1336 full_load = 900;
1337 } else {
1338 unit_load = 100;
1339 full_load = 500;
1340 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
John Youndbe79bb2001-09-17 00:00:00 -07001342 /* FIXME for USB 3.0, skip for now */
1343 if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
1344 !(hub_is_superspeed(hdev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 int i;
1346 char portstr [USB_MAXCHILDREN + 1];
1347
1348 for (i = 0; i < hdev->maxchild; i++)
John Youndbe79bb2001-09-17 00:00:00 -07001349 portstr[i] = hub->descriptor->u.hs.DeviceRemovable
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 [((i + 1) / 8)] & (1 << ((i + 1) % 8))
1351 ? 'F' : 'R';
1352 portstr[hdev->maxchild] = 0;
1353 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
1354 } else
1355 dev_dbg(hub_dev, "standalone hub\n");
1356
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001357 switch (wHubCharacteristics & HUB_CHAR_LPSM) {
Aman Deep7bf01182011-12-08 12:05:22 +05301358 case HUB_CHAR_COMMON_LPSM:
1359 dev_dbg(hub_dev, "ganged power switching\n");
1360 break;
1361 case HUB_CHAR_INDV_PORT_LPSM:
1362 dev_dbg(hub_dev, "individual port power switching\n");
1363 break;
1364 case HUB_CHAR_NO_LPSM:
1365 case HUB_CHAR_LPSM:
1366 dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
1367 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 }
1369
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001370 switch (wHubCharacteristics & HUB_CHAR_OCPM) {
Aman Deep7bf01182011-12-08 12:05:22 +05301371 case HUB_CHAR_COMMON_OCPM:
1372 dev_dbg(hub_dev, "global over-current protection\n");
1373 break;
1374 case HUB_CHAR_INDV_PORT_OCPM:
1375 dev_dbg(hub_dev, "individual port over-current protection\n");
1376 break;
1377 case HUB_CHAR_NO_OCPM:
1378 case HUB_CHAR_OCPM:
1379 dev_dbg(hub_dev, "no over-current protection\n");
1380 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 }
1382
1383 spin_lock_init (&hub->tt.lock);
1384 INIT_LIST_HEAD (&hub->tt.clear_list);
Alan Sterncb88a1b2009-06-29 10:43:32 -04001385 INIT_WORK(&hub->tt.clear_work, hub_tt_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 switch (hdev->descriptor.bDeviceProtocol) {
Aman Deep7bf01182011-12-08 12:05:22 +05301387 case USB_HUB_PR_FS:
1388 break;
1389 case USB_HUB_PR_HS_SINGLE_TT:
1390 dev_dbg(hub_dev, "Single TT\n");
1391 hub->tt.hub = hdev;
1392 break;
1393 case USB_HUB_PR_HS_MULTI_TT:
1394 ret = usb_set_interface(hdev, 0, 1);
1395 if (ret == 0) {
1396 dev_dbg(hub_dev, "TT per port\n");
1397 hub->tt.multi = 1;
1398 } else
1399 dev_err(hub_dev, "Using single TT (err %d)\n",
1400 ret);
1401 hub->tt.hub = hdev;
1402 break;
1403 case USB_HUB_PR_SS:
1404 /* USB 3.0 hubs don't have a TT */
1405 break;
1406 default:
1407 dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
1408 hdev->descriptor.bDeviceProtocol);
1409 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 }
1411
david-b@pacbell.nete09711a2005-08-13 18:41:04 -07001412 /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001413 switch (wHubCharacteristics & HUB_CHAR_TTTT) {
david-b@pacbell.nete09711a2005-08-13 18:41:04 -07001414 case HUB_TTTT_8_BITS:
1415 if (hdev->descriptor.bDeviceProtocol != 0) {
1416 hub->tt.think_time = 666;
1417 dev_dbg(hub_dev, "TT requires at most %d "
1418 "FS bit times (%d ns)\n",
1419 8, hub->tt.think_time);
1420 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 break;
david-b@pacbell.nete09711a2005-08-13 18:41:04 -07001422 case HUB_TTTT_16_BITS:
1423 hub->tt.think_time = 666 * 2;
1424 dev_dbg(hub_dev, "TT requires at most %d "
1425 "FS bit times (%d ns)\n",
1426 16, hub->tt.think_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 break;
david-b@pacbell.nete09711a2005-08-13 18:41:04 -07001428 case HUB_TTTT_24_BITS:
1429 hub->tt.think_time = 666 * 3;
1430 dev_dbg(hub_dev, "TT requires at most %d "
1431 "FS bit times (%d ns)\n",
1432 24, hub->tt.think_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 break;
david-b@pacbell.nete09711a2005-08-13 18:41:04 -07001434 case HUB_TTTT_32_BITS:
1435 hub->tt.think_time = 666 * 4;
1436 dev_dbg(hub_dev, "TT requires at most %d "
1437 "FS bit times (%d ns)\n",
1438 32, hub->tt.think_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 break;
1440 }
1441
1442 /* probe() zeroes hub->indicator[] */
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001443 if (wHubCharacteristics & HUB_CHAR_PORTIND) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 hub->has_indicators = 1;
1445 dev_dbg(hub_dev, "Port indicators are supported\n");
1446 }
1447
1448 dev_dbg(hub_dev, "power on to power good time: %dms\n",
1449 hub->descriptor->bPwrOn2PwrGood * 2);
1450
1451 /* power budgeting mostly matters with bus-powered hubs,
1452 * and battery-powered root hubs (may provide just 8 mA).
1453 */
1454 ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
Alan Stern55c52712005-11-23 12:03:12 -05001455 if (ret < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 message = "can't get hub status";
1457 goto fail;
1458 }
Alan Stern7d35b922005-04-25 11:18:32 -04001459 le16_to_cpus(&hubstatus);
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001460 hcd = bus_to_hcd(hdev->bus);
Alan Stern7d35b922005-04-25 11:18:32 -04001461 if (hdev == hdev->bus->root_hub) {
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001462 if (hcd->power_budget > 0)
1463 hdev->bus_mA = hcd->power_budget;
1464 else
1465 hdev->bus_mA = full_load * hdev->maxchild;
1466 if (hdev->bus_mA >= full_load)
1467 hub->mA_per_port = full_load;
Alan Stern55c52712005-11-23 12:03:12 -05001468 else {
1469 hub->mA_per_port = hdev->bus_mA;
1470 hub->limited_power = 1;
1471 }
Alan Stern7d35b922005-04-25 11:18:32 -04001472 } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001473 int remaining = hdev->bus_mA -
1474 hub->descriptor->bHubContrCurrent;
1475
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
1477 hub->descriptor->bHubContrCurrent);
Alan Stern55c52712005-11-23 12:03:12 -05001478 hub->limited_power = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001480 if (remaining < hdev->maxchild * unit_load)
1481 dev_warn(hub_dev,
Alan Stern55c52712005-11-23 12:03:12 -05001482 "insufficient power available "
1483 "to use all downstream ports\n");
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001484 hub->mA_per_port = unit_load; /* 7.2.1 */
1485
Alan Stern55c52712005-11-23 12:03:12 -05001486 } else { /* Self-powered external hub */
1487 /* FIXME: What about battery-powered external hubs that
1488 * provide less current per port? */
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001489 hub->mA_per_port = full_load;
Alan Stern55c52712005-11-23 12:03:12 -05001490 }
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001491 if (hub->mA_per_port < full_load)
Alan Stern55c52712005-11-23 12:03:12 -05001492 dev_dbg(hub_dev, "%umA bus power budget for each child\n",
1493 hub->mA_per_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
Sarah Sharpb356b7c2009-09-04 10:53:24 -07001495 /* Update the HCD's internal representation of this hub before khubd
1496 * starts getting port status changes for devices under the hub.
1497 */
Sarah Sharpb356b7c2009-09-04 10:53:24 -07001498 if (hcd->driver->update_hub_device) {
1499 ret = hcd->driver->update_hub_device(hcd, hdev,
1500 &hub->tt, GFP_KERNEL);
1501 if (ret < 0) {
1502 message = "can't update HCD hub info";
1503 goto fail;
1504 }
1505 }
1506
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 ret = hub_hub_status(hub, &hubstatus, &hubchange);
1508 if (ret < 0) {
1509 message = "can't get hub status";
1510 goto fail;
1511 }
1512
1513 /* local power status reports aren't always correct */
1514 if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1515 dev_dbg(hub_dev, "local power source is %s\n",
1516 (hubstatus & HUB_STATUS_LOCAL_POWER)
1517 ? "lost (inactive)" : "good");
1518
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001519 if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 dev_dbg(hub_dev, "%sover-current condition exists\n",
1521 (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
1522
inaky@linux.intel.com88fafff2006-10-11 20:05:59 -07001523 /* set up the interrupt endpoint
1524 * We use the EP's maxpacket size instead of (PORTS+1+7)/8
1525 * bytes as USB2.0[11.12.3] says because some hubs are known
1526 * to send more data (and thus cause overflow). For root hubs,
1527 * maxpktsize is defined in hcd.c's fake endpoint descriptors
1528 * to be big enough for at least USB_MAXCHILDREN ports. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
1530 maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
1531
1532 if (maxp > sizeof(*hub->buffer))
1533 maxp = sizeof(*hub->buffer);
1534
1535 hub->urb = usb_alloc_urb(0, GFP_KERNEL);
1536 if (!hub->urb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 ret = -ENOMEM;
1538 goto fail;
1539 }
1540
1541 usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
1542 hub, endpoint->bInterval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543
1544 /* maybe cycle the hub leds */
1545 if (hub->has_indicators && blinkenlights)
1546 hub->indicator [0] = INDICATOR_CYCLE;
1547
Lan Tianyufa2a9562012-09-05 13:44:31 +08001548 for (i = 0; i < hdev->maxchild; i++)
1549 if (usb_hub_create_port_device(hub, i + 1) < 0)
1550 dev_err(hub->intfdev,
1551 "couldn't create port%d device.\n", i + 1);
1552
Lan Tianyud2123fd2013-01-21 22:18:00 +08001553 usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
1554
Alan Sternf2835212008-04-28 11:07:17 -04001555 hub_activate(hub, HUB_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 return 0;
1557
1558fail:
1559 dev_err (hub_dev, "config failed, %s (err %d)\n",
1560 message, ret);
1561 /* hub_disconnect() frees urb and descriptor */
1562 return ret;
1563}
1564
Alan Sterne8054852007-05-04 11:55:11 -04001565static void hub_release(struct kref *kref)
1566{
1567 struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
1568
1569 usb_put_intf(to_usb_interface(hub->intfdev));
1570 kfree(hub);
1571}
1572
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573static unsigned highspeed_hubs;
1574
1575static void hub_disconnect(struct usb_interface *intf)
1576{
Huajun Li88162302012-03-12 21:00:19 +08001577 struct usb_hub *hub = usb_get_intfdata(intf);
Greg Kroah-Hartmanfa286182012-05-14 09:20:37 -07001578 struct usb_device *hdev = interface_to_usbdev(intf);
Lan Tianyufa2a9562012-09-05 13:44:31 +08001579 int i;
1580
Alan Sterne8054852007-05-04 11:55:11 -04001581 /* Take the hub off the event list and don't let it be added again */
1582 spin_lock_irq(&hub_event_lock);
Alan Stern8e4ceb32009-12-07 13:01:37 -05001583 if (!list_empty(&hub->event_list)) {
1584 list_del_init(&hub->event_list);
1585 usb_autopm_put_interface_no_suspend(intf);
1586 }
Alan Sterne8054852007-05-04 11:55:11 -04001587 hub->disconnected = 1;
1588 spin_unlock_irq(&hub_event_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
Alan Stern7de18d82006-06-01 13:37:24 -04001590 /* Disconnect all children and quiesce the hub */
1591 hub->error = 0;
Alan Stern43303542008-04-28 11:07:31 -04001592 hub_quiesce(hub, HUB_DISCONNECT);
Alan Stern7de18d82006-06-01 13:37:24 -04001593
Alan Stern8b28c752005-08-10 17:04:13 -04001594 usb_set_intfdata (intf, NULL);
Alexander Shishkin1f2235b2012-09-12 14:48:31 +03001595
1596 for (i = 0; i < hdev->maxchild; i++)
1597 usb_hub_remove_port_device(hub, i + 1);
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001598 hub->hdev->maxchild = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
Alan Sterne8054852007-05-04 11:55:11 -04001600 if (hub->hdev->speed == USB_SPEED_HIGH)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 highspeed_hubs--;
1602
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 usb_free_urb(hub->urb);
Lan Tianyufa2a9562012-09-05 13:44:31 +08001604 kfree(hub->ports);
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -07001605 kfree(hub->descriptor);
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -07001606 kfree(hub->status);
Alan Sternd697cdd2009-10-27 15:18:46 -04001607 kfree(hub->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
Lan Tianyu971fcd42013-01-23 04:26:29 +08001609 pm_suspend_ignore_children(&intf->dev, false);
Alan Sterne8054852007-05-04 11:55:11 -04001610 kref_put(&hub->kref, hub_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611}
1612
1613static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
1614{
1615 struct usb_host_interface *desc;
1616 struct usb_endpoint_descriptor *endpoint;
1617 struct usb_device *hdev;
1618 struct usb_hub *hub;
1619
1620 desc = intf->cur_altsetting;
1621 hdev = interface_to_usbdev(intf);
1622
Ming Lei596d7892012-10-24 11:59:25 +08001623 /*
1624 * Set default autosuspend delay as 0 to speedup bus suspend,
1625 * based on the below considerations:
1626 *
1627 * - Unlike other drivers, the hub driver does not rely on the
1628 * autosuspend delay to provide enough time to handle a wakeup
1629 * event, and the submitted status URB is just to check future
1630 * change on hub downstream ports, so it is safe to do it.
1631 *
1632 * - The patch might cause one or more auto supend/resume for
1633 * below very rare devices when they are plugged into hub
1634 * first time:
1635 *
1636 * devices having trouble initializing, and disconnect
1637 * themselves from the bus and then reconnect a second
1638 * or so later
1639 *
1640 * devices just for downloading firmware, and disconnects
1641 * themselves after completing it
1642 *
1643 * For these quite rare devices, their drivers may change the
1644 * autosuspend delay of their parent hub in the probe() to one
1645 * appropriate value to avoid the subtle problem if someone
1646 * does care it.
1647 *
1648 * - The patch may cause one or more auto suspend/resume on
1649 * hub during running 'lsusb', but it is probably too
1650 * infrequent to worry about.
1651 *
1652 * - Change autosuspend delay of hub can avoid unnecessary auto
1653 * suspend timer for hub, also may decrease power consumption
1654 * of USB bus.
1655 */
1656 pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
1657
Sarah Sharp2839f5b2012-01-06 16:27:25 -08001658 /* Hubs have proper suspend/resume support. */
1659 usb_enable_autosuspend(hdev);
Alan Stern088f7fe2010-01-08 12:56:54 -05001660
Felipe Balbi38f3ad52008-06-12 10:49:47 +03001661 if (hdev->level == MAX_TOPO_LEVEL) {
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08001662 dev_err(&intf->dev,
1663 "Unsupported bus topology: hub nested too deep\n");
Felipe Balbi38f3ad52008-06-12 10:49:47 +03001664 return -E2BIG;
1665 }
1666
David Brownell89ccbdc2006-04-02 10:18:09 -08001667#ifdef CONFIG_USB_OTG_BLACKLIST_HUB
1668 if (hdev->parent) {
1669 dev_warn(&intf->dev, "ignoring external hub\n");
1670 return -ENODEV;
1671 }
1672#endif
1673
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 /* Some hubs have a subclass of 1, which AFAICT according to the */
1675 /* specs is not defined, but it works */
1676 if ((desc->desc.bInterfaceSubClass != 0) &&
1677 (desc->desc.bInterfaceSubClass != 1)) {
1678descriptor_error:
1679 dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
1680 return -EIO;
1681 }
1682
1683 /* Multiple endpoints? What kind of mutant ninja-hub is this? */
1684 if (desc->desc.bNumEndpoints != 1)
1685 goto descriptor_error;
1686
1687 endpoint = &desc->endpoint[0].desc;
1688
Luiz Fernando N. Capitulinofbf81c22006-09-27 11:58:53 -07001689 /* If it's not an interrupt in endpoint, we'd better punt! */
1690 if (!usb_endpoint_is_int_in(endpoint))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 goto descriptor_error;
1692
1693 /* We found a hub */
1694 dev_info (&intf->dev, "USB hub found\n");
1695
Alan Stern0a1ef3b2005-10-24 15:38:24 -04001696 hub = kzalloc(sizeof(*hub), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 if (!hub) {
1698 dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
1699 return -ENOMEM;
1700 }
1701
Alan Sterne8054852007-05-04 11:55:11 -04001702 kref_init(&hub->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 INIT_LIST_HEAD(&hub->event_list);
1704 hub->intfdev = &intf->dev;
1705 hub->hdev = hdev;
David Howellsc4028952006-11-22 14:57:56 +00001706 INIT_DELAYED_WORK(&hub->leds, led_work);
Alan Stern8520f382008-09-22 14:44:26 -04001707 INIT_DELAYED_WORK(&hub->init_work, NULL);
Alan Sterne8054852007-05-04 11:55:11 -04001708 usb_get_intf(intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709
1710 usb_set_intfdata (intf, hub);
Alan Stern40f122f2006-11-09 14:44:33 -05001711 intf->needs_remote_wakeup = 1;
Lan Tianyu971fcd42013-01-23 04:26:29 +08001712 pm_suspend_ignore_children(&intf->dev, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713
1714 if (hdev->speed == USB_SPEED_HIGH)
1715 highspeed_hubs++;
1716
Ming Leie6f30de2012-10-24 11:59:24 +08001717 if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
1718 hub->quirk_check_port_auto_suspend = 1;
1719
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 if (hub_configure(hub, endpoint) >= 0)
1721 return 0;
1722
1723 hub_disconnect (intf);
1724 return -ENODEV;
1725}
1726
1727static int
1728hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
1729{
1730 struct usb_device *hdev = interface_to_usbdev (intf);
Lan Tianyuad493e52013-01-23 04:26:30 +08001731 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732
1733 /* assert ifno == 0 (part of hub spec) */
1734 switch (code) {
1735 case USBDEVFS_HUB_PORTINFO: {
1736 struct usbdevfs_hub_portinfo *info = user_data;
1737 int i;
1738
1739 spin_lock_irq(&device_state_lock);
1740 if (hdev->devnum <= 0)
1741 info->nports = 0;
1742 else {
1743 info->nports = hdev->maxchild;
1744 for (i = 0; i < info->nports; i++) {
Lan Tianyuff823c792012-09-05 13:44:32 +08001745 if (hub->ports[i]->child == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 info->port[i] = 0;
1747 else
1748 info->port[i] =
Lan Tianyuff823c792012-09-05 13:44:32 +08001749 hub->ports[i]->child->devnum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 }
1751 }
1752 spin_unlock_irq(&device_state_lock);
1753
1754 return info->nports + 1;
1755 }
1756
1757 default:
1758 return -ENOSYS;
1759 }
1760}
1761
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001762/*
1763 * Allow user programs to claim ports on a hub. When a device is attached
1764 * to one of these "claimed" ports, the program will "own" the device.
1765 */
1766static int find_port_owner(struct usb_device *hdev, unsigned port1,
Lan Tianyu336c5c32012-07-06 14:13:52 +08001767 struct dev_state ***ppowner)
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001768{
1769 if (hdev->state == USB_STATE_NOTATTACHED)
1770 return -ENODEV;
1771 if (port1 == 0 || port1 > hdev->maxchild)
1772 return -EINVAL;
1773
1774 /* This assumes that devices not managed by the hub driver
1775 * will always have maxchild equal to 0.
1776 */
Lan Tianyuad493e52013-01-23 04:26:30 +08001777 *ppowner = &(usb_hub_to_struct_hub(hdev)->ports[port1 - 1]->port_owner);
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001778 return 0;
1779}
1780
1781/* In the following three functions, the caller must hold hdev's lock */
Lan Tianyu336c5c32012-07-06 14:13:52 +08001782int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
1783 struct dev_state *owner)
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001784{
1785 int rc;
Lan Tianyu336c5c32012-07-06 14:13:52 +08001786 struct dev_state **powner;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001787
1788 rc = find_port_owner(hdev, port1, &powner);
1789 if (rc)
1790 return rc;
1791 if (*powner)
1792 return -EBUSY;
1793 *powner = owner;
1794 return rc;
1795}
1796
Lan Tianyu336c5c32012-07-06 14:13:52 +08001797int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
1798 struct dev_state *owner)
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001799{
1800 int rc;
Lan Tianyu336c5c32012-07-06 14:13:52 +08001801 struct dev_state **powner;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001802
1803 rc = find_port_owner(hdev, port1, &powner);
1804 if (rc)
1805 return rc;
1806 if (*powner != owner)
1807 return -ENOENT;
1808 *powner = NULL;
1809 return rc;
1810}
1811
Lan Tianyu336c5c32012-07-06 14:13:52 +08001812void usb_hub_release_all_ports(struct usb_device *hdev, struct dev_state *owner)
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001813{
Lan Tianyuad493e52013-01-23 04:26:30 +08001814 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001815 int n;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001816
Lan Tianyufa2a9562012-09-05 13:44:31 +08001817 for (n = 0; n < hdev->maxchild; n++) {
1818 if (hub->ports[n]->port_owner == owner)
1819 hub->ports[n]->port_owner = NULL;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001820 }
Lan Tianyufa2a9562012-09-05 13:44:31 +08001821
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001822}
1823
1824/* The caller must hold udev's lock */
1825bool usb_device_is_owned(struct usb_device *udev)
1826{
1827 struct usb_hub *hub;
1828
1829 if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
1830 return false;
Lan Tianyuad493e52013-01-23 04:26:30 +08001831 hub = usb_hub_to_struct_hub(udev->parent);
Lan Tianyufa2a9562012-09-05 13:44:31 +08001832 return !!hub->ports[udev->portnum - 1]->port_owner;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001833}
1834
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835static void recursively_mark_NOTATTACHED(struct usb_device *udev)
1836{
Lan Tianyuad493e52013-01-23 04:26:30 +08001837 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 int i;
1839
1840 for (i = 0; i < udev->maxchild; ++i) {
Lan Tianyuff823c792012-09-05 13:44:32 +08001841 if (hub->ports[i]->child)
1842 recursively_mark_NOTATTACHED(hub->ports[i]->child);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 }
Alan Stern9bbdf1e2010-01-08 12:57:28 -05001844 if (udev->state == USB_STATE_SUSPENDED)
Sarah Sharp15123002007-12-21 16:54:15 -08001845 udev->active_duration -= jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 udev->state = USB_STATE_NOTATTACHED;
1847}
1848
1849/**
1850 * usb_set_device_state - change a device's current state (usbcore, hcds)
1851 * @udev: pointer to device whose state should be changed
1852 * @new_state: new state value to be stored
1853 *
1854 * udev->state is _not_ fully protected by the device lock. Although
1855 * most transitions are made only while holding the lock, the state can
1856 * can change to USB_STATE_NOTATTACHED at almost any time. This
1857 * is so that devices can be marked as disconnected as soon as possible,
1858 * without having to wait for any semaphores to be released. As a result,
1859 * all changes to any device's state must be protected by the
1860 * device_state_lock spinlock.
1861 *
1862 * Once a device has been added to the device tree, all changes to its state
1863 * should be made using this routine. The state should _not_ be set directly.
1864 *
1865 * If udev->state is already USB_STATE_NOTATTACHED then no change is made.
1866 * Otherwise udev->state is set to new_state, and if new_state is
1867 * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
1868 * to USB_STATE_NOTATTACHED.
1869 */
1870void usb_set_device_state(struct usb_device *udev,
1871 enum usb_device_state new_state)
1872{
1873 unsigned long flags;
Rafael J. Wysocki4681b172011-02-08 23:25:48 +01001874 int wakeup = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875
1876 spin_lock_irqsave(&device_state_lock, flags);
1877 if (udev->state == USB_STATE_NOTATTACHED)
1878 ; /* do nothing */
David Brownellb94dc6b2005-09-12 19:39:39 -07001879 else if (new_state != USB_STATE_NOTATTACHED) {
David Brownellfb669cc2006-01-24 08:40:27 -08001880
1881 /* root hub wakeup capabilities are managed out-of-band
1882 * and may involve silicon errata ... ignore them here.
1883 */
1884 if (udev->parent) {
Alan Stern645daaa2006-08-30 15:47:02 -04001885 if (udev->state == USB_STATE_SUSPENDED
1886 || new_state == USB_STATE_SUSPENDED)
1887 ; /* No change to wakeup settings */
1888 else if (new_state == USB_STATE_CONFIGURED)
Rafael J. Wysocki4681b172011-02-08 23:25:48 +01001889 wakeup = udev->actconfig->desc.bmAttributes
1890 & USB_CONFIG_ATT_WAKEUP;
Alan Stern645daaa2006-08-30 15:47:02 -04001891 else
Rafael J. Wysocki4681b172011-02-08 23:25:48 +01001892 wakeup = 0;
David Brownellfb669cc2006-01-24 08:40:27 -08001893 }
Sarah Sharp15123002007-12-21 16:54:15 -08001894 if (udev->state == USB_STATE_SUSPENDED &&
1895 new_state != USB_STATE_SUSPENDED)
1896 udev->active_duration -= jiffies;
1897 else if (new_state == USB_STATE_SUSPENDED &&
1898 udev->state != USB_STATE_SUSPENDED)
1899 udev->active_duration += jiffies;
Alan Stern645daaa2006-08-30 15:47:02 -04001900 udev->state = new_state;
David Brownellb94dc6b2005-09-12 19:39:39 -07001901 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 recursively_mark_NOTATTACHED(udev);
1903 spin_unlock_irqrestore(&device_state_lock, flags);
Rafael J. Wysocki4681b172011-02-08 23:25:48 +01001904 if (wakeup >= 0)
1905 device_set_wakeup_capable(&udev->dev, wakeup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906}
David Vrabel6da9c992009-02-18 14:43:47 +00001907EXPORT_SYMBOL_GPL(usb_set_device_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001909/*
Alan Stern3b29b682011-02-22 09:53:41 -05001910 * Choose a device number.
1911 *
1912 * Device numbers are used as filenames in usbfs. On USB-1.1 and
1913 * USB-2.0 buses they are also used as device addresses, however on
1914 * USB-3.0 buses the address is assigned by the controller hardware
1915 * and it usually is not the same as the device number.
1916 *
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001917 * WUSB devices are simple: they have no hubs behind, so the mapping
1918 * device <-> virtual port number becomes 1:1. Why? to simplify the
1919 * life of the device connection logic in
1920 * drivers/usb/wusbcore/devconnect.c. When we do the initial secret
1921 * handshake we need to assign a temporary address in the unauthorized
1922 * space. For simplicity we use the first virtual port number found to
1923 * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
1924 * and that becomes it's address [X < 128] or its unauthorized address
1925 * [X | 0x80].
1926 *
1927 * We add 1 as an offset to the one-based USB-stack port number
1928 * (zero-based wusb virtual port index) for two reasons: (a) dev addr
1929 * 0 is reserved by USB for default address; (b) Linux's USB stack
1930 * uses always #1 for the root hub of the controller. So USB stack's
1931 * port #1, which is wusb virtual-port #0 has address #2.
Sarah Sharpc6515272009-04-27 19:57:26 -07001932 *
1933 * Devices connected under xHCI are not as simple. The host controller
1934 * supports virtualization, so the hardware assigns device addresses and
1935 * the HCD must setup data structures before issuing a set address
1936 * command to the hardware.
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001937 */
Alan Stern3b29b682011-02-22 09:53:41 -05001938static void choose_devnum(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939{
1940 int devnum;
1941 struct usb_bus *bus = udev->bus;
1942
1943 /* If khubd ever becomes multithreaded, this will need a lock */
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001944 if (udev->wusb) {
1945 devnum = udev->portnum + 1;
1946 BUG_ON(test_bit(devnum, bus->devmap.devicemap));
1947 } else {
1948 /* Try to allocate the next devnum beginning at
1949 * bus->devnum_next. */
1950 devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
1951 bus->devnum_next);
1952 if (devnum >= 128)
1953 devnum = find_next_zero_bit(bus->devmap.devicemap,
1954 128, 1);
1955 bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);
1956 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 if (devnum < 128) {
1958 set_bit(devnum, bus->devmap.devicemap);
1959 udev->devnum = devnum;
1960 }
1961}
1962
Alan Stern3b29b682011-02-22 09:53:41 -05001963static void release_devnum(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964{
1965 if (udev->devnum > 0) {
1966 clear_bit(udev->devnum, udev->bus->devmap.devicemap);
1967 udev->devnum = -1;
1968 }
1969}
1970
Alan Stern3b29b682011-02-22 09:53:41 -05001971static void update_devnum(struct usb_device *udev, int devnum)
David Vrabel4953d142008-04-08 13:24:46 -07001972{
1973 /* The address for a WUSB device is managed by wusbcore. */
1974 if (!udev->wusb)
1975 udev->devnum = devnum;
1976}
1977
Herbert Xuf7410ce2010-01-10 20:15:03 +11001978static void hub_free_dev(struct usb_device *udev)
1979{
1980 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1981
1982 /* Root hubs aren't real devices, so don't free HCD resources */
1983 if (hcd->driver->free_dev && udev->parent)
1984 hcd->driver->free_dev(hcd, udev);
1985}
1986
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987/**
1988 * usb_disconnect - disconnect a device (usbcore-internal)
1989 * @pdev: pointer to device being disconnected
1990 * Context: !in_interrupt ()
1991 *
1992 * Something got disconnected. Get rid of it and all of its children.
1993 *
1994 * If *pdev is a normal device then the parent hub must already be locked.
1995 * If *pdev is a root hub then this routine will acquire the
1996 * usb_bus_list_lock on behalf of the caller.
1997 *
1998 * Only hub drivers (including virtual root hub drivers for host
1999 * controllers) should ever call this.
2000 *
2001 * This call is synchronous, and may not be used in an interrupt context.
2002 */
2003void usb_disconnect(struct usb_device **pdev)
2004{
2005 struct usb_device *udev = *pdev;
Lan Tianyuad493e52013-01-23 04:26:30 +08002006 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 int i;
2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 /* mark the device as inactive, so any further urb submissions for
2010 * this device (and any of its children) will fail immediately.
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002011 * this quiesces everything except pending urbs.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 */
2013 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
Alan Stern3b29b682011-02-22 09:53:41 -05002014 dev_info(&udev->dev, "USB disconnect, device number %d\n",
2015 udev->devnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016
Alan Stern9ad3d6c2005-11-17 17:10:32 -05002017 usb_lock_device(udev);
2018
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 /* Free up all the children before we remove this device */
Huajun Li88162302012-03-12 21:00:19 +08002020 for (i = 0; i < udev->maxchild; i++) {
Lan Tianyuff823c792012-09-05 13:44:32 +08002021 if (hub->ports[i]->child)
2022 usb_disconnect(&hub->ports[i]->child);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 }
2024
2025 /* deallocate hcd/hardware state ... nuking all pending urbs and
2026 * cleaning up all state associated with the current configuration
2027 * so that the hardware is now fully quiesced.
2028 */
Alan Stern782da722006-07-01 22:09:35 -04002029 dev_dbg (&udev->dev, "unregistering device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 usb_disable_device(udev, 0);
Alan Sterncde217a2008-10-21 15:28:46 -04002031 usb_hcd_synchronize_unlinks(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032
Lan Tianyufde26382013-01-20 01:53:33 +08002033 if (udev->parent) {
Lan Tianyuad493e52013-01-23 04:26:30 +08002034 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2035 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
Lan Tianyufde26382013-01-20 01:53:33 +08002036
2037 sysfs_remove_link(&udev->dev.kobj, "port");
2038 sysfs_remove_link(&port_dev->dev.kobj, "device");
Lan Tianyu971fcd42013-01-23 04:26:29 +08002039
Lan Tianyuad493e52013-01-23 04:26:30 +08002040 if (!port_dev->did_runtime_put)
2041 pm_runtime_put(&port_dev->dev);
2042 else
2043 port_dev->did_runtime_put = false;
Lan Tianyufde26382013-01-20 01:53:33 +08002044 }
2045
Alan Stern3b23dd62008-12-05 14:10:34 -05002046 usb_remove_ep_devs(&udev->ep0);
Alan Stern782da722006-07-01 22:09:35 -04002047 usb_unlock_device(udev);
Greg Kroah-Hartman3099e752005-06-20 21:15:16 -07002048
Alan Stern782da722006-07-01 22:09:35 -04002049 /* Unregister the device. The device driver is responsible
Alan Stern3b23dd62008-12-05 14:10:34 -05002050 * for de-configuring the device and invoking the remove-device
2051 * notifier chain (used by usbfs and possibly others).
Alan Stern782da722006-07-01 22:09:35 -04002052 */
2053 device_del(&udev->dev);
2054
2055 /* Free the device number and delete the parent's children[]
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 * (or root_hub) pointer.
2057 */
Alan Stern3b29b682011-02-22 09:53:41 -05002058 release_devnum(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059
2060 /* Avoid races with recursively_mark_NOTATTACHED() */
2061 spin_lock_irq(&device_state_lock);
2062 *pdev = NULL;
2063 spin_unlock_irq(&device_state_lock);
2064
Herbert Xuf7410ce2010-01-10 20:15:03 +11002065 hub_free_dev(udev);
2066
Alan Stern782da722006-07-01 22:09:35 -04002067 put_device(&udev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068}
2069
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -08002070#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071static void show_string(struct usb_device *udev, char *id, char *string)
2072{
2073 if (!string)
2074 return;
Joe Perchesf2ec5222012-10-28 01:05:51 -07002075 dev_info(&udev->dev, "%s: %s\n", id, string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076}
2077
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -08002078static void announce_device(struct usb_device *udev)
2079{
2080 dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
2081 le16_to_cpu(udev->descriptor.idVendor),
2082 le16_to_cpu(udev->descriptor.idProduct));
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08002083 dev_info(&udev->dev,
2084 "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -08002085 udev->descriptor.iManufacturer,
2086 udev->descriptor.iProduct,
2087 udev->descriptor.iSerialNumber);
2088 show_string(udev, "Product", udev->product);
2089 show_string(udev, "Manufacturer", udev->manufacturer);
2090 show_string(udev, "SerialNumber", udev->serial);
2091}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092#else
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -08002093static inline void announce_device(struct usb_device *udev) { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094#endif
2095
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096#ifdef CONFIG_USB_OTG
2097#include "otg_whitelist.h"
2098#endif
2099
Oliver Neukum3ede7602007-01-11 14:35:50 +01002100/**
Alan Stern8d8558d2009-12-08 15:50:41 -05002101 * usb_enumerate_device_otg - FIXME (usbcore-internal)
Oliver Neukum3ede7602007-01-11 14:35:50 +01002102 * @udev: newly addressed device (in ADDRESS state)
2103 *
Alan Stern8d8558d2009-12-08 15:50:41 -05002104 * Finish enumeration for On-The-Go devices
Oliver Neukum3ede7602007-01-11 14:35:50 +01002105 */
Alan Stern8d8558d2009-12-08 15:50:41 -05002106static int usb_enumerate_device_otg(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107{
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002108 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
2110#ifdef CONFIG_USB_OTG
2111 /*
2112 * OTG-aware devices on OTG-capable root hubs may be able to use SRP,
2113 * to wake us after we've powered off VBUS; and HNP, switching roles
2114 * "host" to "peripheral". The OTG descriptor helps figure this out.
2115 */
2116 if (!udev->bus->is_b_host
2117 && udev->config
2118 && udev->parent == udev->bus->root_hub) {
Felipe Balbi2eb50522009-12-04 15:47:43 +02002119 struct usb_otg_descriptor *desc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 struct usb_bus *bus = udev->bus;
2121
2122 /* descriptor may appear anywhere in config */
2123 if (__usb_get_extra_descriptor (udev->rawdescriptors[0],
2124 le16_to_cpu(udev->config[0].desc.wTotalLength),
2125 USB_DT_OTG, (void **) &desc) == 0) {
2126 if (desc->bmAttributes & USB_OTG_HNP) {
Alan Stern12c3da32005-11-23 12:09:52 -05002127 unsigned port1 = udev->portnum;
David Brownellfc849b82006-09-18 16:53:26 -07002128
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 dev_info(&udev->dev,
2130 "Dual-Role OTG device on %sHNP port\n",
2131 (port1 == bus->otg_port)
2132 ? "" : "non-");
2133
2134 /* enable HNP before suspend, it's simpler */
2135 if (port1 == bus->otg_port)
2136 bus->b_hnp_enable = 1;
2137 err = usb_control_msg(udev,
2138 usb_sndctrlpipe(udev, 0),
2139 USB_REQ_SET_FEATURE, 0,
2140 bus->b_hnp_enable
2141 ? USB_DEVICE_B_HNP_ENABLE
2142 : USB_DEVICE_A_ALT_HNP_SUPPORT,
2143 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
2144 if (err < 0) {
2145 /* OTG MESSAGE: report errors here,
2146 * customize to match your product.
2147 */
2148 dev_info(&udev->dev,
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08002149 "can't set HNP mode: %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 err);
2151 bus->b_hnp_enable = 0;
2152 }
2153 }
2154 }
2155 }
2156
2157 if (!is_targeted(udev)) {
2158
2159 /* Maybe it can talk to us, though we can't talk to it.
2160 * (Includes HNP test device.)
2161 */
2162 if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
David Brownell634a84f2009-01-15 13:51:28 -08002163 err = usb_port_suspend(udev, PMSG_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 if (err < 0)
2165 dev_dbg(&udev->dev, "HNP fail, %d\n", err);
2166 }
Vikram Panditaffcdc182007-05-25 21:31:07 -07002167 err = -ENOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 goto fail;
2169 }
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002170fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171#endif
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002172 return err;
2173}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002175
2176/**
Alan Stern8d8558d2009-12-08 15:50:41 -05002177 * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002178 * @udev: newly addressed device (in ADDRESS state)
2179 *
2180 * This is only called by usb_new_device() and usb_authorize_device()
2181 * and FIXME -- all comments that apply to them apply here wrt to
2182 * environment.
2183 *
2184 * If the device is WUSB and not authorized, we don't attempt to read
2185 * the string descriptors, as they will be errored out by the device
2186 * until it has been authorized.
2187 */
Alan Stern8d8558d2009-12-08 15:50:41 -05002188static int usb_enumerate_device(struct usb_device *udev)
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002189{
2190 int err;
2191
2192 if (udev->config == NULL) {
2193 err = usb_get_configuration(udev);
2194 if (err < 0) {
2195 dev_err(&udev->dev, "can't read configurations, error %d\n",
2196 err);
Laurent Pinchart80da2e02012-07-19 12:39:13 +02002197 return err;
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002198 }
2199 }
2200 if (udev->wusb == 1 && udev->authorized == 0) {
2201 udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
2202 udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
2203 udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
2204 }
2205 else {
2206 /* read the standard strings and cache them if present */
2207 udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
2208 udev->manufacturer = usb_cache_string(udev,
2209 udev->descriptor.iManufacturer);
2210 udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
2211 }
Alan Stern8d8558d2009-12-08 15:50:41 -05002212 err = usb_enumerate_device_otg(udev);
Laurent Pinchart80da2e02012-07-19 12:39:13 +02002213 if (err < 0)
2214 return err;
2215
2216 usb_detect_interface_quirks(udev);
2217
2218 return 0;
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002219}
2220
Matthew Garrettd35e70d2012-02-03 17:11:55 -05002221static void set_usb_port_removable(struct usb_device *udev)
2222{
2223 struct usb_device *hdev = udev->parent;
2224 struct usb_hub *hub;
2225 u8 port = udev->portnum;
2226 u16 wHubCharacteristics;
2227 bool removable = true;
2228
2229 if (!hdev)
2230 return;
2231
Lan Tianyuad493e52013-01-23 04:26:30 +08002232 hub = usb_hub_to_struct_hub(udev->parent);
Matthew Garrettd35e70d2012-02-03 17:11:55 -05002233
2234 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
2235
2236 if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
2237 return;
2238
2239 if (hub_is_superspeed(hdev)) {
Lan Tianyuca3c1532012-09-11 04:22:36 +08002240 if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
2241 & (1 << port))
Matthew Garrettd35e70d2012-02-03 17:11:55 -05002242 removable = false;
2243 } else {
2244 if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
2245 removable = false;
2246 }
2247
2248 if (removable)
2249 udev->removable = USB_DEVICE_REMOVABLE;
2250 else
2251 udev->removable = USB_DEVICE_FIXED;
2252}
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002253
2254/**
2255 * usb_new_device - perform initial device setup (usbcore-internal)
2256 * @udev: newly addressed device (in ADDRESS state)
2257 *
Alan Stern8d8558d2009-12-08 15:50:41 -05002258 * This is called with devices which have been detected but not fully
2259 * enumerated. The device descriptor is available, but not descriptors
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002260 * for any device configuration. The caller must have locked either
2261 * the parent hub (if udev is a normal device) or else the
2262 * usb_bus_list_lock (if udev is a root hub). The parent's pointer to
2263 * udev has already been installed, but udev is not yet visible through
2264 * sysfs or other filesystem code.
2265 *
2266 * It will return if the device is configured properly or not. Zero if
2267 * the interface was registered with the driver core; else a negative
2268 * errno value.
2269 *
2270 * This call is synchronous, and may not be used in an interrupt context.
2271 *
2272 * Only the hub driver or root-hub registrar should ever call this.
2273 */
2274int usb_new_device(struct usb_device *udev)
2275{
2276 int err;
2277
Dan Streetman16985402010-01-06 09:56:53 -05002278 if (udev->parent) {
Dan Streetman16985402010-01-06 09:56:53 -05002279 /* Initialize non-root-hub device wakeup to disabled;
2280 * device (un)configuration controls wakeup capable
2281 * sysfs power/wakeup controls wakeup enabled/disabled
2282 */
2283 device_init_wakeup(&udev->dev, 0);
Dan Streetman16985402010-01-06 09:56:53 -05002284 }
2285
Alan Stern9bbdf1e2010-01-08 12:57:28 -05002286 /* Tell the runtime-PM framework the device is active */
2287 pm_runtime_set_active(&udev->dev);
Alan Sternc08512c2010-11-15 15:57:58 -05002288 pm_runtime_get_noresume(&udev->dev);
Alan Sternfcc4a012010-11-15 15:57:51 -05002289 pm_runtime_use_autosuspend(&udev->dev);
Alan Stern9bbdf1e2010-01-08 12:57:28 -05002290 pm_runtime_enable(&udev->dev);
2291
Alan Sternc08512c2010-11-15 15:57:58 -05002292 /* By default, forbid autosuspend for all devices. It will be
2293 * allowed for hubs during binding.
2294 */
2295 usb_disable_autosuspend(udev);
2296
Alan Stern8d8558d2009-12-08 15:50:41 -05002297 err = usb_enumerate_device(udev); /* Read descriptors */
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002298 if (err < 0)
2299 goto fail;
Sarah Sharpc6515272009-04-27 19:57:26 -07002300 dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
2301 udev->devnum, udev->bus->busnum,
2302 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
Kay Sievers9f8b17e2007-03-13 15:59:31 +01002303 /* export the usbdev device-node for libusb */
2304 udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
2305 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2306
Alan Stern6cd13202008-11-13 15:08:30 -05002307 /* Tell the world! */
2308 announce_device(udev);
Alan Stern195af2c2007-07-16 15:28:19 -04002309
Theodore Ts'ob04b3152012-07-04 11:22:20 -04002310 if (udev->serial)
2311 add_device_randomness(udev->serial, strlen(udev->serial));
2312 if (udev->product)
2313 add_device_randomness(udev->product, strlen(udev->product));
2314 if (udev->manufacturer)
2315 add_device_randomness(udev->manufacturer,
2316 strlen(udev->manufacturer));
2317
Rafael J. Wysocki927bc912010-02-08 19:18:16 +01002318 device_enable_async_suspend(&udev->dev);
Matthew Garrettd35e70d2012-02-03 17:11:55 -05002319
2320 /*
2321 * check whether the hub marks this port as non-removable. Do it
2322 * now so that platform-specific data can override it in
2323 * device_add()
2324 */
2325 if (udev->parent)
2326 set_usb_port_removable(udev);
2327
Alan Stern782da722006-07-01 22:09:35 -04002328 /* Register the device. The device driver is responsible
Alan Stern3b23dd62008-12-05 14:10:34 -05002329 * for configuring the device and invoking the add-device
2330 * notifier chain (used by usbfs and possibly others).
Alan Stern782da722006-07-01 22:09:35 -04002331 */
Kay Sievers9f8b17e2007-03-13 15:59:31 +01002332 err = device_add(&udev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 if (err) {
2334 dev_err(&udev->dev, "can't device_add, error %d\n", err);
2335 goto fail;
2336 }
Alan Stern9ad3d6c2005-11-17 17:10:32 -05002337
Lan Tianyufde26382013-01-20 01:53:33 +08002338 /* Create link files between child device and usb port device. */
2339 if (udev->parent) {
Lan Tianyuad493e52013-01-23 04:26:30 +08002340 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2341 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
Lan Tianyufde26382013-01-20 01:53:33 +08002342
2343 err = sysfs_create_link(&udev->dev.kobj,
2344 &port_dev->dev.kobj, "port");
2345 if (err)
2346 goto fail;
2347
2348 err = sysfs_create_link(&port_dev->dev.kobj,
2349 &udev->dev.kobj, "device");
2350 if (err) {
2351 sysfs_remove_link(&udev->dev.kobj, "port");
2352 goto fail;
2353 }
Lan Tianyu971fcd42013-01-23 04:26:29 +08002354
2355 pm_runtime_get_sync(&port_dev->dev);
Lan Tianyufde26382013-01-20 01:53:33 +08002356 }
2357
Alan Stern3b23dd62008-12-05 14:10:34 -05002358 (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
Alan Sternc08512c2010-11-15 15:57:58 -05002359 usb_mark_last_busy(udev);
2360 pm_runtime_put_sync_autosuspend(&udev->dev);
Greg Kroah-Hartmanc0664752006-08-11 01:55:12 -07002361 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362
2363fail:
2364 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
Alan Stern9bbdf1e2010-01-08 12:57:28 -05002365 pm_runtime_disable(&udev->dev);
2366 pm_runtime_set_suspended(&udev->dev);
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002367 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368}
2369
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002370
2371/**
Randy Dunlapfd39c862007-10-15 17:30:02 -07002372 * usb_deauthorize_device - deauthorize a device (usbcore-internal)
2373 * @usb_dev: USB device
2374 *
2375 * Move the USB device to a very basic state where interfaces are disabled
2376 * and the device is in fact unconfigured and unusable.
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002377 *
2378 * We share a lock (that we have) with device_del(), so we need to
2379 * defer its call.
2380 */
2381int usb_deauthorize_device(struct usb_device *usb_dev)
2382{
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002383 usb_lock_device(usb_dev);
2384 if (usb_dev->authorized == 0)
2385 goto out_unauthorized;
Alan Sternda307122009-12-08 15:54:44 -05002386
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002387 usb_dev->authorized = 0;
2388 usb_set_configuration(usb_dev, -1);
Alan Sternda307122009-12-08 15:54:44 -05002389
2390 kfree(usb_dev->product);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002391 usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
Alan Sternda307122009-12-08 15:54:44 -05002392 kfree(usb_dev->manufacturer);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002393 usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
Alan Sternda307122009-12-08 15:54:44 -05002394 kfree(usb_dev->serial);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002395 usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
Alan Sternda307122009-12-08 15:54:44 -05002396
2397 usb_destroy_configuration(usb_dev);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002398 usb_dev->descriptor.bNumConfigurations = 0;
Alan Sternda307122009-12-08 15:54:44 -05002399
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002400out_unauthorized:
2401 usb_unlock_device(usb_dev);
2402 return 0;
2403}
2404
2405
2406int usb_authorize_device(struct usb_device *usb_dev)
2407{
2408 int result = 0, c;
Alan Sternda307122009-12-08 15:54:44 -05002409
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002410 usb_lock_device(usb_dev);
2411 if (usb_dev->authorized == 1)
2412 goto out_authorized;
Alan Sternda307122009-12-08 15:54:44 -05002413
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002414 result = usb_autoresume_device(usb_dev);
2415 if (result < 0) {
2416 dev_err(&usb_dev->dev,
2417 "can't autoresume for authorization: %d\n", result);
2418 goto error_autoresume;
2419 }
2420 result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
2421 if (result < 0) {
2422 dev_err(&usb_dev->dev, "can't re-read device descriptor for "
2423 "authorization: %d\n", result);
2424 goto error_device_descriptor;
2425 }
Alan Sternda307122009-12-08 15:54:44 -05002426
2427 kfree(usb_dev->product);
2428 usb_dev->product = NULL;
2429 kfree(usb_dev->manufacturer);
2430 usb_dev->manufacturer = NULL;
2431 kfree(usb_dev->serial);
2432 usb_dev->serial = NULL;
2433
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002434 usb_dev->authorized = 1;
Alan Stern8d8558d2009-12-08 15:50:41 -05002435 result = usb_enumerate_device(usb_dev);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002436 if (result < 0)
Alan Stern8d8558d2009-12-08 15:50:41 -05002437 goto error_enumerate;
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002438 /* Choose and set the configuration. This registers the interfaces
2439 * with the driver core and lets interface drivers bind to them.
2440 */
Greg Kroah-Hartmanb5ea0602007-08-02 22:44:27 -06002441 c = usb_choose_configuration(usb_dev);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002442 if (c >= 0) {
2443 result = usb_set_configuration(usb_dev, c);
2444 if (result) {
2445 dev_err(&usb_dev->dev,
2446 "can't set config #%d, error %d\n", c, result);
2447 /* This need not be fatal. The user can try to
2448 * set other configurations. */
2449 }
2450 }
2451 dev_info(&usb_dev->dev, "authorized to connect\n");
Alan Sternda307122009-12-08 15:54:44 -05002452
Alan Stern8d8558d2009-12-08 15:50:41 -05002453error_enumerate:
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002454error_device_descriptor:
Alan Sternda307122009-12-08 15:54:44 -05002455 usb_autosuspend_device(usb_dev);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002456error_autoresume:
2457out_authorized:
2458 usb_unlock_device(usb_dev); // complements locktree
2459 return result;
2460}
2461
2462
Inaky Perez-Gonzalez0165de02006-08-25 19:35:29 -07002463/* Returns 1 if @hub is a WUSB root hub, 0 otherwise */
2464static unsigned hub_is_wusb(struct usb_hub *hub)
2465{
2466 struct usb_hcd *hcd;
2467 if (hub->hdev->parent != NULL) /* not a root hub? */
2468 return 0;
2469 hcd = container_of(hub->hdev->bus, struct usb_hcd, self);
2470 return hcd->wireless;
2471}
2472
2473
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474#define PORT_RESET_TRIES 5
2475#define SET_ADDRESS_TRIES 2
2476#define GET_DESCRIPTOR_TRIES 2
2477#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))
Rusty Russell90ab5ee2012-01-13 09:32:20 +10302478#define USE_NEW_SCHEME(i) ((i) / 2 == (int)old_scheme_first)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479
2480#define HUB_ROOT_RESET_TIME 50 /* times are in msec */
2481#define HUB_SHORT_RESET_TIME 10
Andiry Xu75d7cf72011-09-13 16:41:11 -07002482#define HUB_BH_RESET_TIME 50
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483#define HUB_LONG_RESET_TIME 200
Sarah Sharp77c7f072012-11-14 17:16:52 -08002484#define HUB_RESET_TIMEOUT 800
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485
Sarah Sharp10d674a2011-09-14 14:24:52 -07002486static int hub_port_reset(struct usb_hub *hub, int port1,
2487 struct usb_device *udev, unsigned int delay, bool warm);
2488
Stanislaw Ledwon8bea2bd2012-06-18 15:20:00 +02002489/* Is a USB 3.0 port in the Inactive or Complinance Mode state?
2490 * Port worm reset is required to recover
2491 */
2492static bool hub_port_warm_reset_required(struct usb_hub *hub, u16 portstatus)
Sarah Sharp10d674a2011-09-14 14:24:52 -07002493{
2494 return hub_is_superspeed(hub->hdev) &&
Stanislaw Ledwon8bea2bd2012-06-18 15:20:00 +02002495 (((portstatus & USB_PORT_STAT_LINK_STATE) ==
2496 USB_SS_PORT_LS_SS_INACTIVE) ||
2497 ((portstatus & USB_PORT_STAT_LINK_STATE) ==
2498 USB_SS_PORT_LS_COMP_MOD)) ;
Sarah Sharp10d674a2011-09-14 14:24:52 -07002499}
2500
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501static int hub_port_wait_reset(struct usb_hub *hub, int port1,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002502 struct usb_device *udev, unsigned int delay, bool warm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503{
2504 int delay_time, ret;
2505 u16 portstatus;
2506 u16 portchange;
2507
2508 for (delay_time = 0;
2509 delay_time < HUB_RESET_TIMEOUT;
2510 delay_time += delay) {
2511 /* wait to give the device a chance to reset */
2512 msleep(delay);
2513
2514 /* read and decode port status */
2515 ret = hub_port_status(hub, port1, &portstatus, &portchange);
2516 if (ret < 0)
2517 return ret;
2518
Sarah Sharp4f434472012-11-15 14:58:04 -08002519 /* The port state is unknown until the reset completes. */
Sarah Sharp470f0be2012-12-11 10:14:03 -08002520 if (!(portstatus & USB_PORT_STAT_RESET))
2521 break;
Sarah Sharp4f434472012-11-15 14:58:04 -08002522
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523 /* switch to the long delay after two short delay failures */
2524 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
2525 delay = HUB_LONG_RESET_TIME;
2526
2527 dev_dbg (hub->intfdev,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002528 "port %d not %sreset yet, waiting %dms\n",
2529 port1, warm ? "warm " : "", delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530 }
2531
Sarah Sharp470f0be2012-12-11 10:14:03 -08002532 if ((portstatus & USB_PORT_STAT_RESET))
2533 return -EBUSY;
2534
2535 if (hub_port_warm_reset_required(hub, portstatus))
2536 return -ENOTCONN;
2537
2538 /* Device went away? */
2539 if (!(portstatus & USB_PORT_STAT_CONNECTION))
2540 return -ENOTCONN;
2541
2542 /* bomb out completely if the connection bounced. A USB 3.0
2543 * connection may bounce if multiple warm resets were issued,
2544 * but the device may have successfully re-connected. Ignore it.
2545 */
2546 if (!hub_is_superspeed(hub->hdev) &&
2547 (portchange & USB_PORT_STAT_C_CONNECTION))
2548 return -ENOTCONN;
2549
2550 if (!(portstatus & USB_PORT_STAT_ENABLE))
2551 return -EBUSY;
2552
2553 if (!udev)
2554 return 0;
2555
2556 if (hub_is_wusb(hub))
2557 udev->speed = USB_SPEED_WIRELESS;
2558 else if (hub_is_superspeed(hub->hdev))
2559 udev->speed = USB_SPEED_SUPER;
2560 else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
2561 udev->speed = USB_SPEED_HIGH;
2562 else if (portstatus & USB_PORT_STAT_LOW_SPEED)
2563 udev->speed = USB_SPEED_LOW;
2564 else
2565 udev->speed = USB_SPEED_FULL;
2566 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567}
2568
Andiry Xu75d7cf72011-09-13 16:41:11 -07002569static void hub_port_finish_reset(struct usb_hub *hub, int port1,
Sarah Sharpa24a6072012-11-01 11:20:44 -07002570 struct usb_device *udev, int *status)
Andiry Xu75d7cf72011-09-13 16:41:11 -07002571{
2572 switch (*status) {
2573 case 0:
Sarah Sharpa24a6072012-11-01 11:20:44 -07002574 /* TRSTRCY = 10 ms; plus some extra */
2575 msleep(10 + 40);
2576 if (udev) {
2577 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2578
2579 update_devnum(udev, 0);
2580 /* The xHC may think the device is already reset,
2581 * so ignore the status.
2582 */
2583 if (hcd->driver->reset_device)
2584 hcd->driver->reset_device(hcd, udev);
Andiry Xu75d7cf72011-09-13 16:41:11 -07002585 }
2586 /* FALL THROUGH */
2587 case -ENOTCONN:
2588 case -ENODEV:
Lan Tianyuad493e52013-01-23 04:26:30 +08002589 usb_clear_port_feature(hub->hdev,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002590 port1, USB_PORT_FEAT_C_RESET);
Sarah Sharp1c7439c62012-11-14 15:58:52 -08002591 if (hub_is_superspeed(hub->hdev)) {
Lan Tianyuad493e52013-01-23 04:26:30 +08002592 usb_clear_port_feature(hub->hdev, port1,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002593 USB_PORT_FEAT_C_BH_PORT_RESET);
Lan Tianyuad493e52013-01-23 04:26:30 +08002594 usb_clear_port_feature(hub->hdev, port1,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002595 USB_PORT_FEAT_C_PORT_LINK_STATE);
Lan Tianyuad493e52013-01-23 04:26:30 +08002596 usb_clear_port_feature(hub->hdev, port1,
Sarah Sharpa24a6072012-11-01 11:20:44 -07002597 USB_PORT_FEAT_C_CONNECTION);
Sarah Sharp1c7439c62012-11-14 15:58:52 -08002598 }
Sarah Sharpa24a6072012-11-01 11:20:44 -07002599 if (udev)
Andiry Xu75d7cf72011-09-13 16:41:11 -07002600 usb_set_device_state(udev, *status
2601 ? USB_STATE_NOTATTACHED
2602 : USB_STATE_DEFAULT);
Andiry Xu75d7cf72011-09-13 16:41:11 -07002603 break;
2604 }
2605}
2606
2607/* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608static int hub_port_reset(struct usb_hub *hub, int port1,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002609 struct usb_device *udev, unsigned int delay, bool warm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610{
2611 int i, status;
Sarah Sharpa24a6072012-11-01 11:20:44 -07002612 u16 portchange, portstatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613
Sarah Sharp0fe51aa2012-11-01 11:20:44 -07002614 if (!hub_is_superspeed(hub->hdev)) {
2615 if (warm) {
Andiry Xu75d7cf72011-09-13 16:41:11 -07002616 dev_err(hub->intfdev, "only USB3 hub support "
2617 "warm reset\n");
2618 return -EINVAL;
2619 }
Sarah Sharp0fe51aa2012-11-01 11:20:44 -07002620 /* Block EHCI CF initialization during the port reset.
2621 * Some companion controllers don't like it when they mix.
2622 */
2623 down_read(&ehci_cf_port_reset_rwsem);
Sarah Sharpd3b9d7a2012-11-01 11:20:44 -07002624 } else if (!warm) {
2625 /*
2626 * If the caller hasn't explicitly requested a warm reset,
2627 * double check and see if one is needed.
2628 */
2629 status = hub_port_status(hub, port1,
2630 &portstatus, &portchange);
2631 if (status < 0)
2632 goto done;
2633
2634 if (hub_port_warm_reset_required(hub, portstatus))
2635 warm = true;
Andiry Xu75d7cf72011-09-13 16:41:11 -07002636 }
Alan Stern32fe0192007-10-10 16:27:07 -04002637
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 /* Reset the port */
2639 for (i = 0; i < PORT_RESET_TRIES; i++) {
Andiry Xu75d7cf72011-09-13 16:41:11 -07002640 status = set_port_feature(hub->hdev, port1, (warm ?
2641 USB_PORT_FEAT_BH_PORT_RESET :
2642 USB_PORT_FEAT_RESET));
2643 if (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 dev_err(hub->intfdev,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002645 "cannot %sreset port %d (err = %d)\n",
2646 warm ? "warm " : "", port1, status);
2647 } else {
2648 status = hub_port_wait_reset(hub, port1, udev, delay,
2649 warm);
David Brownelldd165252005-08-31 10:45:25 -07002650 if (status && status != -ENOTCONN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651 dev_dbg(hub->intfdev,
2652 "port_wait_reset: err = %d\n",
2653 status);
2654 }
2655
Sarah Sharpa24a6072012-11-01 11:20:44 -07002656 /* Check for disconnect or reset */
Andiry Xu75d7cf72011-09-13 16:41:11 -07002657 if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
Sarah Sharpa24a6072012-11-01 11:20:44 -07002658 hub_port_finish_reset(hub, port1, udev, &status);
2659
2660 if (!hub_is_superspeed(hub->hdev))
2661 goto done;
2662
2663 /*
2664 * If a USB 3.0 device migrates from reset to an error
2665 * state, re-issue the warm reset.
2666 */
2667 if (hub_port_status(hub, port1,
2668 &portstatus, &portchange) < 0)
2669 goto done;
2670
2671 if (!hub_port_warm_reset_required(hub, portstatus))
2672 goto done;
2673
2674 /*
2675 * If the port is in SS.Inactive or Compliance Mode, the
2676 * hot or warm reset failed. Try another warm reset.
2677 */
2678 if (!warm) {
2679 dev_dbg(hub->intfdev, "hot reset failed, warm reset port %d\n",
2680 port1);
2681 warm = true;
2682 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683 }
2684
2685 dev_dbg (hub->intfdev,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002686 "port %d not enabled, trying %sreset again...\n",
2687 port1, warm ? "warm " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002688 delay = HUB_LONG_RESET_TIME;
2689 }
2690
2691 dev_err (hub->intfdev,
2692 "Cannot enable port %i. Maybe the USB cable is bad?\n",
2693 port1);
2694
Andiry Xu75d7cf72011-09-13 16:41:11 -07002695done:
Sarah Sharp0fe51aa2012-11-01 11:20:44 -07002696 if (!hub_is_superspeed(hub->hdev))
Andiry Xu75d7cf72011-09-13 16:41:11 -07002697 up_read(&ehci_cf_port_reset_rwsem);
2698
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699 return status;
2700}
2701
Andiry Xu0ed9a572011-04-27 18:07:43 +08002702/* Check if a port is power on */
2703static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
2704{
2705 int ret = 0;
2706
2707 if (hub_is_superspeed(hub->hdev)) {
2708 if (portstatus & USB_SS_PORT_STAT_POWER)
2709 ret = 1;
2710 } else {
2711 if (portstatus & USB_PORT_STAT_POWER)
2712 ret = 1;
2713 }
2714
2715 return ret;
2716}
2717
Alan Sternd388dab2006-07-01 22:14:24 -04002718#ifdef CONFIG_PM
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719
Andiry Xu0ed9a572011-04-27 18:07:43 +08002720/* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
2721static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
2722{
2723 int ret = 0;
2724
2725 if (hub_is_superspeed(hub->hdev)) {
2726 if ((portstatus & USB_PORT_STAT_LINK_STATE)
2727 == USB_SS_PORT_LS_U3)
2728 ret = 1;
2729 } else {
2730 if (portstatus & USB_PORT_STAT_SUSPEND)
2731 ret = 1;
2732 }
2733
2734 return ret;
2735}
Alan Sternb01b03f2008-04-28 11:06:11 -04002736
2737/* Determine whether the device on a port is ready for a normal resume,
2738 * is ready for a reset-resume, or should be disconnected.
2739 */
2740static int check_port_resume_type(struct usb_device *udev,
2741 struct usb_hub *hub, int port1,
2742 int status, unsigned portchange, unsigned portstatus)
2743{
2744 /* Is the device still present? */
Andiry Xu0ed9a572011-04-27 18:07:43 +08002745 if (status || port_is_suspended(hub, portstatus) ||
2746 !port_is_power_on(hub, portstatus) ||
2747 !(portstatus & USB_PORT_STAT_CONNECTION)) {
Alan Sternb01b03f2008-04-28 11:06:11 -04002748 if (status >= 0)
2749 status = -ENODEV;
2750 }
2751
Alan Stern86c57ed2008-06-30 11:14:43 -04002752 /* Can't do a normal resume if the port isn't enabled,
2753 * so try a reset-resume instead.
2754 */
2755 else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
2756 if (udev->persist_enabled)
2757 udev->reset_resume = 1;
2758 else
2759 status = -ENODEV;
2760 }
Alan Sternb01b03f2008-04-28 11:06:11 -04002761
2762 if (status) {
2763 dev_dbg(hub->intfdev,
2764 "port %d status %04x.%04x after resume, %d\n",
2765 port1, portchange, portstatus, status);
2766 } else if (udev->reset_resume) {
2767
2768 /* Late port handoff can set status-change bits */
2769 if (portchange & USB_PORT_STAT_C_CONNECTION)
Lan Tianyuad493e52013-01-23 04:26:30 +08002770 usb_clear_port_feature(hub->hdev, port1,
Alan Sternb01b03f2008-04-28 11:06:11 -04002771 USB_PORT_FEAT_C_CONNECTION);
2772 if (portchange & USB_PORT_STAT_C_ENABLE)
Lan Tianyuad493e52013-01-23 04:26:30 +08002773 usb_clear_port_feature(hub->hdev, port1,
Alan Sternb01b03f2008-04-28 11:06:11 -04002774 USB_PORT_FEAT_C_ENABLE);
2775 }
2776
2777 return status;
2778}
2779
Sarah Sharpf74631e2012-06-25 12:08:08 -07002780int usb_disable_ltm(struct usb_device *udev)
2781{
2782 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2783
2784 /* Check if the roothub and device supports LTM. */
2785 if (!usb_device_supports_ltm(hcd->self.root_hub) ||
2786 !usb_device_supports_ltm(udev))
2787 return 0;
2788
2789 /* Clear Feature LTM Enable can only be sent if the device is
2790 * configured.
2791 */
2792 if (!udev->actconfig)
2793 return 0;
2794
2795 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2796 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
2797 USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
2798 USB_CTRL_SET_TIMEOUT);
2799}
2800EXPORT_SYMBOL_GPL(usb_disable_ltm);
2801
2802void usb_enable_ltm(struct usb_device *udev)
2803{
2804 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2805
2806 /* Check if the roothub and device supports LTM. */
2807 if (!usb_device_supports_ltm(hcd->self.root_hub) ||
2808 !usb_device_supports_ltm(udev))
2809 return;
2810
2811 /* Set Feature LTM Enable can only be sent if the device is
2812 * configured.
2813 */
2814 if (!udev->actconfig)
2815 return;
2816
2817 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2818 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
2819 USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
2820 USB_CTRL_SET_TIMEOUT);
2821}
2822EXPORT_SYMBOL_GPL(usb_enable_ltm);
2823
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824#ifdef CONFIG_USB_SUSPEND
Lan Tianyu54a3ac02013-01-24 10:31:28 +08002825/*
2826 * usb_disable_function_remotewakeup - disable usb3.0
2827 * device's function remote wakeup
2828 * @udev: target device
2829 *
2830 * Assume there's only one function on the USB 3.0
2831 * device and disable remote wake for the first
2832 * interface. FIXME if the interface association
2833 * descriptor shows there's more than one function.
2834 */
2835static int usb_disable_function_remotewakeup(struct usb_device *udev)
2836{
2837 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2838 USB_REQ_CLEAR_FEATURE, USB_RECIP_INTERFACE,
2839 USB_INTRF_FUNC_SUSPEND, 0, NULL, 0,
2840 USB_CTRL_SET_TIMEOUT);
2841}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842
2843/*
Alan Stern140d8f62006-07-01 22:07:21 -04002844 * usb_port_suspend - suspend a usb device's upstream port
Alan Stern624d6c02007-05-30 15:35:16 -04002845 * @udev: device that's no longer in active use, not a root hub
David Brownell5edbfb72005-09-22 22:45:26 -07002846 * Context: must be able to sleep; device not locked; pm locks held
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 *
2848 * Suspends a USB device that isn't in active use, conserving power.
2849 * Devices may wake out of a suspend, if anything important happens,
2850 * using the remote wakeup mechanism. They may also be taken out of
Alan Stern140d8f62006-07-01 22:07:21 -04002851 * suspend by the host, using usb_port_resume(). It's also routine
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 * to disconnect devices while they are suspended.
2853 *
David Brownell390a8c32005-09-13 19:57:27 -07002854 * This only affects the USB hardware for a device; its interfaces
2855 * (and, for hubs, child devices) must already have been suspended.
2856 *
Alan Stern624d6c02007-05-30 15:35:16 -04002857 * Selective port suspend reduces power; most suspended devices draw
2858 * less than 500 uA. It's also used in OTG, along with remote wakeup.
2859 * All devices below the suspended port are also suspended.
2860 *
2861 * Devices leave suspend state when the host wakes them up. Some devices
2862 * also support "remote wakeup", where the device can activate the USB
2863 * tree above them to deliver data, such as a keypress or packet. In
2864 * some cases, this wakes the USB host.
2865 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 * Suspending OTG devices may trigger HNP, if that's been enabled
2867 * between a pair of dual-role devices. That will change roles, such
2868 * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
2869 *
Alan Stern4956ecc2007-05-30 16:51:28 -04002870 * Devices on USB hub ports have only one "suspend" state, corresponding
2871 * to ACPI D2, "may cause the device to lose some context".
2872 * State transitions include:
2873 *
2874 * - suspend, resume ... when the VBUS power link stays live
2875 * - suspend, disconnect ... VBUS lost
2876 *
2877 * Once VBUS drop breaks the circuit, the port it's using has to go through
2878 * normal re-enumeration procedures, starting with enabling VBUS power.
2879 * Other than re-initializing the hub (plug/unplug, except for root hubs),
2880 * Linux (2.6) currently has NO mechanisms to initiate that: no khubd
2881 * timer, no SRP, no requests through sysfs.
2882 *
2883 * If CONFIG_USB_SUSPEND isn't enabled, devices only really suspend when
2884 * the root hub for their bus goes into global suspend ... so we don't
2885 * (falsely) update the device power state to say it suspended.
2886 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 * Returns 0 on success, else negative errno.
2888 */
Alan Stern65bfd292008-11-25 16:39:18 -05002889int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890{
Lan Tianyuad493e52013-01-23 04:26:30 +08002891 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2892 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
2893 enum pm_qos_flags_status pm_qos_stat;
Alan Stern624d6c02007-05-30 15:35:16 -04002894 int port1 = udev->portnum;
2895 int status;
Alan Stern4956ecc2007-05-30 16:51:28 -04002896
Alan Stern624d6c02007-05-30 15:35:16 -04002897 /* enable remote wakeup when appropriate; this lets the device
2898 * wake up the upstream hub (including maybe the root hub).
2899 *
2900 * NOTE: OTG devices may issue remote wakeup (or SRP) even when
2901 * we don't explicitly enable it here.
2902 */
2903 if (udev->do_remote_wakeup) {
Sarah Sharp623bef92011-11-11 14:57:33 -08002904 if (!hub_is_superspeed(hub->hdev)) {
2905 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2906 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
2907 USB_DEVICE_REMOTE_WAKEUP, 0,
2908 NULL, 0,
2909 USB_CTRL_SET_TIMEOUT);
2910 } else {
2911 /* Assume there's only one function on the USB 3.0
2912 * device and enable remote wake for the first
2913 * interface. FIXME if the interface association
2914 * descriptor shows there's more than one function.
2915 */
2916 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2917 USB_REQ_SET_FEATURE,
2918 USB_RECIP_INTERFACE,
2919 USB_INTRF_FUNC_SUSPEND,
Sarah Sharp3b9b6ac2012-01-06 15:48:30 -08002920 USB_INTRF_FUNC_SUSPEND_RW |
2921 USB_INTRF_FUNC_SUSPEND_LP,
Sarah Sharp623bef92011-11-11 14:57:33 -08002922 NULL, 0,
2923 USB_CTRL_SET_TIMEOUT);
2924 }
Oliver Neukum0c487202009-10-19 13:19:41 +02002925 if (status) {
Alan Stern624d6c02007-05-30 15:35:16 -04002926 dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
2927 status);
Oliver Neukum0c487202009-10-19 13:19:41 +02002928 /* bail if autosuspend is requested */
Alan Stern5b1b0b82011-08-19 23:49:48 +02002929 if (PMSG_IS_AUTO(msg))
Oliver Neukum0c487202009-10-19 13:19:41 +02002930 return status;
2931 }
Alan Stern624d6c02007-05-30 15:35:16 -04002932 }
2933
Andiry Xu65580b432011-09-23 14:19:52 -07002934 /* disable USB2 hardware LPM */
2935 if (udev->usb2_hw_lpm_enabled == 1)
2936 usb_set_usb2_hardware_lpm(udev, 0);
2937
Sarah Sharpf74631e2012-06-25 12:08:08 -07002938 if (usb_disable_ltm(udev)) {
2939 dev_err(&udev->dev, "%s Failed to disable LTM before suspend\n.",
2940 __func__);
2941 return -ENOMEM;
2942 }
Sarah Sharp83060952012-05-02 14:25:52 -07002943 if (usb_unlocked_disable_lpm(udev)) {
2944 dev_err(&udev->dev, "%s Failed to disable LPM before suspend\n.",
2945 __func__);
2946 return -ENOMEM;
2947 }
2948
Alan Stern624d6c02007-05-30 15:35:16 -04002949 /* see 7.1.7.6 */
Andiry Xua7114232011-04-27 18:07:50 +08002950 if (hub_is_superspeed(hub->hdev))
Sarah Sharpc2f60db2012-12-10 15:43:08 -08002951 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
Andiry Xua8f08d82011-03-31 14:56:50 +08002952 else
2953 status = set_port_feature(hub->hdev, port1,
2954 USB_PORT_FEAT_SUSPEND);
Alan Stern624d6c02007-05-30 15:35:16 -04002955 if (status) {
2956 dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
2957 port1, status);
2958 /* paranoia: "should not happen" */
Lan Tianyu54a3ac02013-01-24 10:31:28 +08002959 if (udev->do_remote_wakeup) {
2960 if (!hub_is_superspeed(hub->hdev)) {
2961 (void) usb_control_msg(udev,
2962 usb_sndctrlpipe(udev, 0),
2963 USB_REQ_CLEAR_FEATURE,
2964 USB_RECIP_DEVICE,
2965 USB_DEVICE_REMOTE_WAKEUP, 0,
2966 NULL, 0,
2967 USB_CTRL_SET_TIMEOUT);
2968 } else
2969 (void) usb_disable_function_remotewakeup(udev);
2970
2971 }
Alan Sterncbb33002011-06-15 16:29:16 -04002972
Andiry Xuc3e751e2012-05-05 00:50:10 +08002973 /* Try to enable USB2 hardware LPM again */
2974 if (udev->usb2_hw_lpm_capable == 1)
2975 usb_set_usb2_hardware_lpm(udev, 1);
2976
Sarah Sharpf74631e2012-06-25 12:08:08 -07002977 /* Try to enable USB3 LTM and LPM again */
2978 usb_enable_ltm(udev);
Sarah Sharp83060952012-05-02 14:25:52 -07002979 usb_unlocked_enable_lpm(udev);
2980
Alan Sterncbb33002011-06-15 16:29:16 -04002981 /* System sleep transitions should never fail */
Alan Stern5b1b0b82011-08-19 23:49:48 +02002982 if (!PMSG_IS_AUTO(msg))
Alan Sterncbb33002011-06-15 16:29:16 -04002983 status = 0;
Alan Stern624d6c02007-05-30 15:35:16 -04002984 } else {
2985 /* device has up to 10 msec to fully suspend */
Alan Stern30b1a7a2011-09-27 21:54:22 +02002986 dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
2987 (PMSG_IS_AUTO(msg) ? "auto-" : ""),
2988 udev->do_remote_wakeup);
Alan Stern624d6c02007-05-30 15:35:16 -04002989 usb_set_device_state(udev, USB_STATE_SUSPENDED);
Alan Sternbfd1e912012-10-19 11:03:39 -04002990 udev->port_is_suspended = 1;
Alan Stern624d6c02007-05-30 15:35:16 -04002991 msleep(10);
2992 }
Lan Tianyuad493e52013-01-23 04:26:30 +08002993
2994 /*
2995 * Check whether current status meets the requirement of
2996 * usb port power off mechanism
2997 */
2998 pm_qos_stat = dev_pm_qos_flags(&port_dev->dev,
2999 PM_QOS_FLAG_NO_POWER_OFF);
3000 if (!udev->do_remote_wakeup
3001 && pm_qos_stat != PM_QOS_FLAGS_ALL
3002 && udev->persist_enabled
3003 && !status) {
3004 pm_runtime_put_sync(&port_dev->dev);
3005 port_dev->did_runtime_put = true;
3006 }
3007
Alan Sternc08512c2010-11-15 15:57:58 -05003008 usb_mark_last_busy(hub->hdev);
Alan Stern4956ecc2007-05-30 16:51:28 -04003009 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010}
David Brownellf3f32532005-09-22 22:37:29 -07003011
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012/*
David Brownell390a8c32005-09-13 19:57:27 -07003013 * If the USB "suspend" state is in use (rather than "global suspend"),
3014 * many devices will be individually taken out of suspend state using
Alan Stern54515fe2007-05-30 15:38:58 -04003015 * special "resume" signaling. This routine kicks in shortly after
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 * hardware resume signaling is finished, either because of selective
3017 * resume (by host) or remote wakeup (by device) ... now see what changed
3018 * in the tree that's rooted at this device.
Alan Stern54515fe2007-05-30 15:38:58 -04003019 *
3020 * If @udev->reset_resume is set then the device is reset before the
3021 * status check is done.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022 */
Alan Stern140d8f62006-07-01 22:07:21 -04003023static int finish_port_resume(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024{
Alan Stern54515fe2007-05-30 15:38:58 -04003025 int status = 0;
Oliver Neukum07e72b92012-11-29 15:05:57 +01003026 u16 devstatus = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027
3028 /* caller owns the udev device lock */
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08003029 dev_dbg(&udev->dev, "%s\n",
3030 udev->reset_resume ? "finish reset-resume" : "finish resume");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031
3032 /* usb ch9 identifies four variants of SUSPENDED, based on what
3033 * state the device resumes to. Linux currently won't see the
3034 * first two on the host side; they'd be inside hub_port_init()
3035 * during many timeouts, but khubd can't suspend until later.
3036 */
3037 usb_set_device_state(udev, udev->actconfig
3038 ? USB_STATE_CONFIGURED
3039 : USB_STATE_ADDRESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040
Alan Stern54515fe2007-05-30 15:38:58 -04003041 /* 10.5.4.5 says not to reset a suspended port if the attached
3042 * device is enabled for remote wakeup. Hence the reset
3043 * operation is carried out here, after the port has been
3044 * resumed.
3045 */
3046 if (udev->reset_resume)
Alan Stern86c57ed2008-06-30 11:14:43 -04003047 retry_reset_resume:
Ming Lei742120c2008-06-18 22:00:29 +08003048 status = usb_reset_and_verify_device(udev);
Alan Stern54515fe2007-05-30 15:38:58 -04003049
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050 /* 10.5.4.5 says be sure devices in the tree are still there.
3051 * For now let's assume the device didn't go crazy on resume,
3052 * and device drivers will know about any resume quirks.
3053 */
Alan Stern54515fe2007-05-30 15:38:58 -04003054 if (status == 0) {
Alan Stern46dede42007-08-14 10:56:10 -04003055 devstatus = 0;
Alan Stern54515fe2007-05-30 15:38:58 -04003056 status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
3057 if (status >= 0)
Alan Stern46dede42007-08-14 10:56:10 -04003058 status = (status > 0 ? 0 : -ENODEV);
Alan Stern86c57ed2008-06-30 11:14:43 -04003059
3060 /* If a normal resume failed, try doing a reset-resume */
3061 if (status && !udev->reset_resume && udev->persist_enabled) {
3062 dev_dbg(&udev->dev, "retry with reset-resume\n");
3063 udev->reset_resume = 1;
3064 goto retry_reset_resume;
3065 }
Alan Stern54515fe2007-05-30 15:38:58 -04003066 }
Alan Sternb40b7a92006-06-19 15:12:38 -04003067
Alan Stern624d6c02007-05-30 15:35:16 -04003068 if (status) {
3069 dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
3070 status);
Oliver Neukum07e72b92012-11-29 15:05:57 +01003071 /*
3072 * There are a few quirky devices which violate the standard
3073 * by claiming to have remote wakeup enabled after a reset,
3074 * which crash if the feature is cleared, hence check for
3075 * udev->reset_resume
3076 */
3077 } else if (udev->actconfig && !udev->reset_resume) {
Lan Tianyu54a3ac02013-01-24 10:31:28 +08003078 if (!hub_is_superspeed(udev->parent)) {
3079 le16_to_cpus(&devstatus);
3080 if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
3081 status = usb_control_msg(udev,
3082 usb_sndctrlpipe(udev, 0),
3083 USB_REQ_CLEAR_FEATURE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084 USB_RECIP_DEVICE,
Lan Tianyu54a3ac02013-01-24 10:31:28 +08003085 USB_DEVICE_REMOTE_WAKEUP, 0,
3086 NULL, 0,
3087 USB_CTRL_SET_TIMEOUT);
3088 } else {
3089 status = usb_get_status(udev, USB_RECIP_INTERFACE, 0,
3090 &devstatus);
3091 le16_to_cpus(&devstatus);
3092 if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
3093 | USB_INTRF_STAT_FUNC_RW))
3094 status =
3095 usb_disable_function_remotewakeup(udev);
Alan Stern4bf0ba82005-11-21 11:58:07 -05003096 }
Lan Tianyu54a3ac02013-01-24 10:31:28 +08003097
3098 if (status)
3099 dev_dbg(&udev->dev,
3100 "disable remote wakeup, status %d\n",
3101 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 }
3104 return status;
3105}
3106
Alan Stern624d6c02007-05-30 15:35:16 -04003107/*
3108 * usb_port_resume - re-activate a suspended usb device's upstream port
3109 * @udev: device to re-activate, not a root hub
3110 * Context: must be able to sleep; device not locked; pm locks held
3111 *
3112 * This will re-activate the suspended device, increasing power usage
3113 * while letting drivers communicate again with its endpoints.
3114 * USB resume explicitly guarantees that the power session between
3115 * the host and the device is the same as it was when the device
3116 * suspended.
3117 *
Alan Sternfeccc302008-03-03 15:15:59 -05003118 * If @udev->reset_resume is set then this routine won't check that the
3119 * port is still enabled. Furthermore, finish_port_resume() above will
Alan Stern54515fe2007-05-30 15:38:58 -04003120 * reset @udev. The end result is that a broken power session can be
3121 * recovered and @udev will appear to persist across a loss of VBUS power.
3122 *
3123 * For example, if a host controller doesn't maintain VBUS suspend current
3124 * during a system sleep or is reset when the system wakes up, all the USB
3125 * power sessions below it will be broken. This is especially troublesome
3126 * for mass-storage devices containing mounted filesystems, since the
3127 * device will appear to have disconnected and all the memory mappings
3128 * to it will be lost. Using the USB_PERSIST facility, the device can be
3129 * made to appear as if it had not disconnected.
3130 *
Ming Lei742120c2008-06-18 22:00:29 +08003131 * This facility can be dangerous. Although usb_reset_and_verify_device() makes
Alan Sternfeccc302008-03-03 15:15:59 -05003132 * every effort to insure that the same device is present after the
Alan Stern54515fe2007-05-30 15:38:58 -04003133 * reset as before, it cannot provide a 100% guarantee. Furthermore it's
3134 * quite possible for a device to remain unaltered but its media to be
3135 * changed. If the user replaces a flash memory card while the system is
3136 * asleep, he will have only himself to blame when the filesystem on the
3137 * new card is corrupted and the system crashes.
3138 *
Alan Stern624d6c02007-05-30 15:35:16 -04003139 * Returns 0 on success, else negative errno.
3140 */
Alan Stern65bfd292008-11-25 16:39:18 -05003141int usb_port_resume(struct usb_device *udev, pm_message_t msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142{
Lan Tianyuad493e52013-01-23 04:26:30 +08003143 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
3144 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
Alan Stern624d6c02007-05-30 15:35:16 -04003145 int port1 = udev->portnum;
3146 int status;
3147 u16 portchange, portstatus;
Alan Sternd25450c2006-11-20 11:14:30 -05003148
Lan Tianyuad493e52013-01-23 04:26:30 +08003149 if (port_dev->did_runtime_put) {
3150 status = pm_runtime_get_sync(&port_dev->dev);
3151 port_dev->did_runtime_put = false;
3152 if (status < 0) {
3153 dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
3154 status);
3155 return status;
3156 }
3157 }
3158
Alan Sternd25450c2006-11-20 11:14:30 -05003159 /* Skip the initial Clear-Suspend step for a remote wakeup */
3160 status = hub_port_status(hub, port1, &portstatus, &portchange);
Andiry Xu0ed9a572011-04-27 18:07:43 +08003161 if (status == 0 && !port_is_suspended(hub, portstatus))
Alan Sternd25450c2006-11-20 11:14:30 -05003162 goto SuspendCleared;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163
3164 // dev_dbg(hub->intfdev, "resume port %d\n", port1);
3165
Alan Sternd5cbad42006-08-11 16:52:39 -04003166 set_bit(port1, hub->busy_bits);
3167
Linus Torvalds1da177e2005-04-16 15:20:36 -07003168 /* see 7.1.7.7; affects power usage, but not budgeting */
Andiry Xua7114232011-04-27 18:07:50 +08003169 if (hub_is_superspeed(hub->hdev))
Sarah Sharpc2f60db2012-12-10 15:43:08 -08003170 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
Andiry Xua7114232011-04-27 18:07:50 +08003171 else
Lan Tianyuad493e52013-01-23 04:26:30 +08003172 status = usb_clear_port_feature(hub->hdev,
Andiry Xua7114232011-04-27 18:07:50 +08003173 port1, USB_PORT_FEAT_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174 if (status) {
Alan Stern624d6c02007-05-30 15:35:16 -04003175 dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
3176 port1, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 /* drive resume for at least 20 msec */
Alan Stern686314c2007-05-30 15:34:36 -04003179 dev_dbg(&udev->dev, "usb %sresume\n",
Alan Stern5b1b0b82011-08-19 23:49:48 +02003180 (PMSG_IS_AUTO(msg) ? "auto-" : ""));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181 msleep(25);
3182
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183 /* Virtual root hubs can trigger on GET_PORT_STATUS to
3184 * stop resume signaling. Then finish the resume
3185 * sequence.
3186 */
Alan Sternd25450c2006-11-20 11:14:30 -05003187 status = hub_port_status(hub, port1, &portstatus, &portchange);
Alan Stern54515fe2007-05-30 15:38:58 -04003188
Alan Sternb01b03f2008-04-28 11:06:11 -04003189 /* TRSMRCY = 10 msec */
3190 msleep(10);
3191 }
Alan Stern54515fe2007-05-30 15:38:58 -04003192
Alan Sternb01b03f2008-04-28 11:06:11 -04003193 SuspendCleared:
3194 if (status == 0) {
Alan Sternbfd1e912012-10-19 11:03:39 -04003195 udev->port_is_suspended = 0;
Andiry Xua7114232011-04-27 18:07:50 +08003196 if (hub_is_superspeed(hub->hdev)) {
3197 if (portchange & USB_PORT_STAT_C_LINK_STATE)
Lan Tianyuad493e52013-01-23 04:26:30 +08003198 usb_clear_port_feature(hub->hdev, port1,
Andiry Xua7114232011-04-27 18:07:50 +08003199 USB_PORT_FEAT_C_PORT_LINK_STATE);
3200 } else {
3201 if (portchange & USB_PORT_STAT_C_SUSPEND)
Lan Tianyuad493e52013-01-23 04:26:30 +08003202 usb_clear_port_feature(hub->hdev, port1,
Andiry Xua7114232011-04-27 18:07:50 +08003203 USB_PORT_FEAT_C_SUSPEND);
3204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206
Alan Sternd5cbad42006-08-11 16:52:39 -04003207 clear_bit(port1, hub->busy_bits);
Alan Sternd5cbad42006-08-11 16:52:39 -04003208
Alan Sternb01b03f2008-04-28 11:06:11 -04003209 status = check_port_resume_type(udev,
3210 hub, port1, status, portchange, portstatus);
Alan Stern54515fe2007-05-30 15:38:58 -04003211 if (status == 0)
3212 status = finish_port_resume(udev);
3213 if (status < 0) {
3214 dev_dbg(&udev->dev, "can't resume, status %d\n", status);
3215 hub_port_logical_disconnect(hub, port1);
Andiry Xu65580b432011-09-23 14:19:52 -07003216 } else {
3217 /* Try to enable USB2 hardware LPM */
3218 if (udev->usb2_hw_lpm_capable == 1)
3219 usb_set_usb2_hardware_lpm(udev, 1);
Sarah Sharp83060952012-05-02 14:25:52 -07003220
Sarah Sharpf74631e2012-06-25 12:08:08 -07003221 /* Try to enable USB3 LTM and LPM */
3222 usb_enable_ltm(udev);
Sarah Sharp83060952012-05-02 14:25:52 -07003223 usb_unlocked_enable_lpm(udev);
Alan Stern54515fe2007-05-30 15:38:58 -04003224 }
Andiry Xu65580b432011-09-23 14:19:52 -07003225
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226 return status;
3227}
3228
Alan Stern8808f002008-04-28 11:06:55 -04003229/* caller has locked udev */
Alan Stern0534d462010-01-08 12:56:30 -05003230int usb_remote_wakeup(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231{
3232 int status = 0;
3233
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234 if (udev->state == USB_STATE_SUSPENDED) {
Alan Stern645daaa2006-08-30 15:47:02 -04003235 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
Alan Stern9bbdf1e2010-01-08 12:57:28 -05003236 status = usb_autoresume_device(udev);
3237 if (status == 0) {
3238 /* Let the drivers do their thing, then... */
3239 usb_autosuspend_device(udev);
3240 }
Alan Sternd25450c2006-11-20 11:14:30 -05003241 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242 return status;
3243}
3244
Alan Sternd388dab2006-07-01 22:14:24 -04003245#else /* CONFIG_USB_SUSPEND */
3246
3247/* When CONFIG_USB_SUSPEND isn't set, we never suspend or resume any ports. */
3248
Alan Stern65bfd292008-11-25 16:39:18 -05003249int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
Alan Sternd388dab2006-07-01 22:14:24 -04003250{
3251 return 0;
3252}
3253
Alan Sternb01b03f2008-04-28 11:06:11 -04003254/* However we may need to do a reset-resume */
3255
Alan Stern65bfd292008-11-25 16:39:18 -05003256int usb_port_resume(struct usb_device *udev, pm_message_t msg)
Alan Sternd388dab2006-07-01 22:14:24 -04003257{
Lan Tianyuad493e52013-01-23 04:26:30 +08003258 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
Alan Sternb01b03f2008-04-28 11:06:11 -04003259 int port1 = udev->portnum;
3260 int status;
3261 u16 portchange, portstatus;
Alan Stern54515fe2007-05-30 15:38:58 -04003262
Alan Sternb01b03f2008-04-28 11:06:11 -04003263 status = hub_port_status(hub, port1, &portstatus, &portchange);
3264 status = check_port_resume_type(udev,
3265 hub, port1, status, portchange, portstatus);
3266
3267 if (status) {
3268 dev_dbg(&udev->dev, "can't resume, status %d\n", status);
3269 hub_port_logical_disconnect(hub, port1);
3270 } else if (udev->reset_resume) {
Alan Stern54515fe2007-05-30 15:38:58 -04003271 dev_dbg(&udev->dev, "reset-resume\n");
Ming Lei742120c2008-06-18 22:00:29 +08003272 status = usb_reset_and_verify_device(udev);
Alan Stern54515fe2007-05-30 15:38:58 -04003273 }
3274 return status;
Alan Sternd388dab2006-07-01 22:14:24 -04003275}
3276
Alan Sternd388dab2006-07-01 22:14:24 -04003277#endif
3278
Ming Leie6f30de2012-10-24 11:59:24 +08003279static int check_ports_changed(struct usb_hub *hub)
3280{
3281 int port1;
3282
3283 for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) {
3284 u16 portstatus, portchange;
3285 int status;
3286
3287 status = hub_port_status(hub, port1, &portstatus, &portchange);
3288 if (!status && portchange)
3289 return 1;
3290 }
3291 return 0;
3292}
3293
David Brownelldb690872005-09-13 19:56:33 -07003294static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295{
3296 struct usb_hub *hub = usb_get_intfdata (intf);
3297 struct usb_device *hdev = hub->hdev;
3298 unsigned port1;
Sarah Sharp4296c70a2012-01-06 10:34:31 -08003299 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003300
Alan Sterncbb33002011-06-15 16:29:16 -04003301 /* Warn if children aren't already suspended */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3303 struct usb_device *udev;
3304
Lan Tianyuff823c792012-09-05 13:44:32 +08003305 udev = hub->ports[port1 - 1]->child;
Alan Stern6840d252007-09-10 11:34:26 -04003306 if (udev && udev->can_submit) {
Alan Sterncbb33002011-06-15 16:29:16 -04003307 dev_warn(&intf->dev, "port %d nyet suspended\n", port1);
Alan Stern5b1b0b82011-08-19 23:49:48 +02003308 if (PMSG_IS_AUTO(msg))
Alan Sterncbb33002011-06-15 16:29:16 -04003309 return -EBUSY;
David Brownellc9f89fa2005-09-13 19:57:04 -07003310 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003311 }
Ming Leie6f30de2012-10-24 11:59:24 +08003312
3313 if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) {
3314 /* check if there are changes pending on hub ports */
3315 if (check_ports_changed(hub)) {
3316 if (PMSG_IS_AUTO(msg))
3317 return -EBUSY;
3318 pm_wakeup_event(&hdev->dev, 2000);
3319 }
3320 }
3321
Sarah Sharp4296c70a2012-01-06 10:34:31 -08003322 if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
3323 /* Enable hub to send remote wakeup for all ports. */
3324 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3325 status = set_port_feature(hdev,
3326 port1 |
3327 USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
3328 USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
3329 USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
3330 USB_PORT_FEAT_REMOTE_WAKE_MASK);
3331 }
3332 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333
Harvey Harrison441b62c2008-03-03 16:08:34 -08003334 dev_dbg(&intf->dev, "%s\n", __func__);
Alan Stern40f122f2006-11-09 14:44:33 -05003335
David Brownellc9f89fa2005-09-13 19:57:04 -07003336 /* stop khubd and related activity */
Alan Stern43303542008-04-28 11:07:31 -04003337 hub_quiesce(hub, HUB_SUSPEND);
Alan Sternb6f64362007-05-04 11:51:54 -04003338 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003339}
3340
3341static int hub_resume(struct usb_interface *intf)
3342{
Alan Stern5e6effa2008-03-03 15:15:51 -05003343 struct usb_hub *hub = usb_get_intfdata(intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003344
Alan Stern5e6effa2008-03-03 15:15:51 -05003345 dev_dbg(&intf->dev, "%s\n", __func__);
Alan Sternf2835212008-04-28 11:07:17 -04003346 hub_activate(hub, HUB_RESUME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003347 return 0;
3348}
3349
Alan Sternb41a60e2007-05-30 15:39:33 -04003350static int hub_reset_resume(struct usb_interface *intf)
Alan Sternf07600c2007-05-30 15:38:16 -04003351{
Alan Sternb41a60e2007-05-30 15:39:33 -04003352 struct usb_hub *hub = usb_get_intfdata(intf);
Alan Sternf07600c2007-05-30 15:38:16 -04003353
Alan Stern5e6effa2008-03-03 15:15:51 -05003354 dev_dbg(&intf->dev, "%s\n", __func__);
Alan Sternf2835212008-04-28 11:07:17 -04003355 hub_activate(hub, HUB_RESET_RESUME);
Alan Sternf07600c2007-05-30 15:38:16 -04003356 return 0;
3357}
3358
Alan Stern54515fe2007-05-30 15:38:58 -04003359/**
3360 * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
3361 * @rhdev: struct usb_device for the root hub
3362 *
3363 * The USB host controller driver calls this function when its root hub
3364 * is resumed and Vbus power has been interrupted or the controller
Alan Sternfeccc302008-03-03 15:15:59 -05003365 * has been reset. The routine marks @rhdev as having lost power.
3366 * When the hub driver is resumed it will take notice and carry out
3367 * power-session recovery for all the "USB-PERSIST"-enabled child devices;
3368 * the others will be disconnected.
Alan Stern54515fe2007-05-30 15:38:58 -04003369 */
3370void usb_root_hub_lost_power(struct usb_device *rhdev)
3371{
3372 dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
3373 rhdev->reset_resume = 1;
3374}
3375EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
3376
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003377static const char * const usb3_lpm_names[] = {
3378 "U0",
3379 "U1",
3380 "U2",
3381 "U3",
3382};
3383
3384/*
3385 * Send a Set SEL control transfer to the device, prior to enabling
3386 * device-initiated U1 or U2. This lets the device know the exit latencies from
3387 * the time the device initiates a U1 or U2 exit, to the time it will receive a
3388 * packet from the host.
3389 *
3390 * This function will fail if the SEL or PEL values for udev are greater than
3391 * the maximum allowed values for the link state to be enabled.
3392 */
3393static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
3394{
3395 struct usb_set_sel_req *sel_values;
3396 unsigned long long u1_sel;
3397 unsigned long long u1_pel;
3398 unsigned long long u2_sel;
3399 unsigned long long u2_pel;
3400 int ret;
3401
3402 /* Convert SEL and PEL stored in ns to us */
3403 u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
3404 u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
3405 u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
3406 u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);
3407
3408 /*
3409 * Make sure that the calculated SEL and PEL values for the link
3410 * state we're enabling aren't bigger than the max SEL/PEL
3411 * value that will fit in the SET SEL control transfer.
3412 * Otherwise the device would get an incorrect idea of the exit
3413 * latency for the link state, and could start a device-initiated
3414 * U1/U2 when the exit latencies are too high.
3415 */
3416 if ((state == USB3_LPM_U1 &&
3417 (u1_sel > USB3_LPM_MAX_U1_SEL_PEL ||
3418 u1_pel > USB3_LPM_MAX_U1_SEL_PEL)) ||
3419 (state == USB3_LPM_U2 &&
3420 (u2_sel > USB3_LPM_MAX_U2_SEL_PEL ||
3421 u2_pel > USB3_LPM_MAX_U2_SEL_PEL))) {
Sarah Sharp1510a1a2012-10-05 10:30:35 -07003422 dev_dbg(&udev->dev, "Device-initiated %s disabled due to long SEL %llu us or PEL %llu us\n",
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003423 usb3_lpm_names[state], u1_sel, u1_pel);
3424 return -EINVAL;
3425 }
3426
3427 /*
3428 * If we're enabling device-initiated LPM for one link state,
3429 * but the other link state has a too high SEL or PEL value,
3430 * just set those values to the max in the Set SEL request.
3431 */
3432 if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL)
3433 u1_sel = USB3_LPM_MAX_U1_SEL_PEL;
3434
3435 if (u1_pel > USB3_LPM_MAX_U1_SEL_PEL)
3436 u1_pel = USB3_LPM_MAX_U1_SEL_PEL;
3437
3438 if (u2_sel > USB3_LPM_MAX_U2_SEL_PEL)
3439 u2_sel = USB3_LPM_MAX_U2_SEL_PEL;
3440
3441 if (u2_pel > USB3_LPM_MAX_U2_SEL_PEL)
3442 u2_pel = USB3_LPM_MAX_U2_SEL_PEL;
3443
3444 /*
3445 * usb_enable_lpm() can be called as part of a failed device reset,
3446 * which may be initiated by an error path of a mass storage driver.
3447 * Therefore, use GFP_NOIO.
3448 */
3449 sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
3450 if (!sel_values)
3451 return -ENOMEM;
3452
3453 sel_values->u1_sel = u1_sel;
3454 sel_values->u1_pel = u1_pel;
3455 sel_values->u2_sel = cpu_to_le16(u2_sel);
3456 sel_values->u2_pel = cpu_to_le16(u2_pel);
3457
3458 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3459 USB_REQ_SET_SEL,
3460 USB_RECIP_DEVICE,
3461 0, 0,
3462 sel_values, sizeof *(sel_values),
3463 USB_CTRL_SET_TIMEOUT);
3464 kfree(sel_values);
3465 return ret;
3466}
3467
3468/*
3469 * Enable or disable device-initiated U1 or U2 transitions.
3470 */
3471static int usb_set_device_initiated_lpm(struct usb_device *udev,
3472 enum usb3_link_state state, bool enable)
3473{
3474 int ret;
3475 int feature;
3476
3477 switch (state) {
3478 case USB3_LPM_U1:
3479 feature = USB_DEVICE_U1_ENABLE;
3480 break;
3481 case USB3_LPM_U2:
3482 feature = USB_DEVICE_U2_ENABLE;
3483 break;
3484 default:
3485 dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n",
3486 __func__, enable ? "enable" : "disable");
3487 return -EINVAL;
3488 }
3489
3490 if (udev->state != USB_STATE_CONFIGURED) {
3491 dev_dbg(&udev->dev, "%s: Can't %s %s state "
3492 "for unconfigured device.\n",
3493 __func__, enable ? "enable" : "disable",
3494 usb3_lpm_names[state]);
3495 return 0;
3496 }
3497
3498 if (enable) {
3499 /*
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003500 * Now send the control transfer to enable device-initiated LPM
3501 * for either U1 or U2.
3502 */
3503 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3504 USB_REQ_SET_FEATURE,
3505 USB_RECIP_DEVICE,
3506 feature,
3507 0, NULL, 0,
3508 USB_CTRL_SET_TIMEOUT);
3509 } else {
3510 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3511 USB_REQ_CLEAR_FEATURE,
3512 USB_RECIP_DEVICE,
3513 feature,
3514 0, NULL, 0,
3515 USB_CTRL_SET_TIMEOUT);
3516 }
3517 if (ret < 0) {
3518 dev_warn(&udev->dev, "%s of device-initiated %s failed.\n",
3519 enable ? "Enable" : "Disable",
3520 usb3_lpm_names[state]);
3521 return -EBUSY;
3522 }
3523 return 0;
3524}
3525
3526static int usb_set_lpm_timeout(struct usb_device *udev,
3527 enum usb3_link_state state, int timeout)
3528{
3529 int ret;
3530 int feature;
3531
3532 switch (state) {
3533 case USB3_LPM_U1:
3534 feature = USB_PORT_FEAT_U1_TIMEOUT;
3535 break;
3536 case USB3_LPM_U2:
3537 feature = USB_PORT_FEAT_U2_TIMEOUT;
3538 break;
3539 default:
3540 dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n",
3541 __func__);
3542 return -EINVAL;
3543 }
3544
3545 if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT &&
3546 timeout != USB3_LPM_DEVICE_INITIATED) {
3547 dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, "
3548 "which is a reserved value.\n",
3549 usb3_lpm_names[state], timeout);
3550 return -EINVAL;
3551 }
3552
3553 ret = set_port_feature(udev->parent,
3554 USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum,
3555 feature);
3556 if (ret < 0) {
3557 dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x,"
3558 "error code %i\n", usb3_lpm_names[state],
3559 timeout, ret);
3560 return -EBUSY;
3561 }
3562 if (state == USB3_LPM_U1)
3563 udev->u1_params.timeout = timeout;
3564 else
3565 udev->u2_params.timeout = timeout;
3566 return 0;
3567}
3568
3569/*
3570 * Enable the hub-initiated U1/U2 idle timeouts, and enable device-initiated
3571 * U1/U2 entry.
3572 *
3573 * We will attempt to enable U1 or U2, but there are no guarantees that the
3574 * control transfers to set the hub timeout or enable device-initiated U1/U2
3575 * will be successful.
3576 *
3577 * If we cannot set the parent hub U1/U2 timeout, we attempt to let the xHCI
3578 * driver know about it. If that call fails, it should be harmless, and just
3579 * take up more slightly more bus bandwidth for unnecessary U1/U2 exit latency.
3580 */
3581static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
3582 enum usb3_link_state state)
3583{
Sarah Sharp65a95b72012-10-05 10:32:07 -07003584 int timeout, ret;
Sarah Sharpae8963a2012-10-03 11:18:05 -07003585 __u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
3586 __le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;
3587
3588 /* If the device says it doesn't have *any* exit latency to come out of
3589 * U1 or U2, it's probably lying. Assume it doesn't implement that link
3590 * state.
3591 */
3592 if ((state == USB3_LPM_U1 && u1_mel == 0) ||
3593 (state == USB3_LPM_U2 && u2_mel == 0))
3594 return;
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003595
Sarah Sharp65a95b72012-10-05 10:32:07 -07003596 /*
3597 * First, let the device know about the exit latencies
3598 * associated with the link state we're about to enable.
3599 */
3600 ret = usb_req_set_sel(udev, state);
3601 if (ret < 0) {
3602 dev_warn(&udev->dev, "Set SEL for device-initiated %s failed.\n",
3603 usb3_lpm_names[state]);
3604 return;
3605 }
3606
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003607 /* We allow the host controller to set the U1/U2 timeout internally
3608 * first, so that it can change its schedule to account for the
3609 * additional latency to send data to a device in a lower power
3610 * link state.
3611 */
3612 timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state);
3613
3614 /* xHCI host controller doesn't want to enable this LPM state. */
3615 if (timeout == 0)
3616 return;
3617
3618 if (timeout < 0) {
3619 dev_warn(&udev->dev, "Could not enable %s link state, "
3620 "xHCI error %i.\n", usb3_lpm_names[state],
3621 timeout);
3622 return;
3623 }
3624
3625 if (usb_set_lpm_timeout(udev, state, timeout))
3626 /* If we can't set the parent hub U1/U2 timeout,
3627 * device-initiated LPM won't be allowed either, so let the xHCI
3628 * host know that this link state won't be enabled.
3629 */
3630 hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
3631
3632 /* Only a configured device will accept the Set Feature U1/U2_ENABLE */
3633 else if (udev->actconfig)
3634 usb_set_device_initiated_lpm(udev, state, true);
3635
3636}
3637
3638/*
3639 * Disable the hub-initiated U1/U2 idle timeouts, and disable device-initiated
3640 * U1/U2 entry.
3641 *
3642 * If this function returns -EBUSY, the parent hub will still allow U1/U2 entry.
3643 * If zero is returned, the parent will not allow the link to go into U1/U2.
3644 *
3645 * If zero is returned, device-initiated U1/U2 entry may still be enabled, but
3646 * it won't have an effect on the bus link state because the parent hub will
3647 * still disallow device-initiated U1/U2 entry.
3648 *
3649 * If zero is returned, the xHCI host controller may still think U1/U2 entry is
3650 * possible. The result will be slightly more bus bandwidth will be taken up
3651 * (to account for U1/U2 exit latency), but it should be harmless.
3652 */
3653static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
3654 enum usb3_link_state state)
3655{
3656 int feature;
3657
3658 switch (state) {
3659 case USB3_LPM_U1:
3660 feature = USB_PORT_FEAT_U1_TIMEOUT;
3661 break;
3662 case USB3_LPM_U2:
3663 feature = USB_PORT_FEAT_U2_TIMEOUT;
3664 break;
3665 default:
3666 dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n",
3667 __func__);
3668 return -EINVAL;
3669 }
3670
3671 if (usb_set_lpm_timeout(udev, state, 0))
3672 return -EBUSY;
3673
3674 usb_set_device_initiated_lpm(udev, state, false);
3675
3676 if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state))
3677 dev_warn(&udev->dev, "Could not disable xHCI %s timeout, "
3678 "bus schedule bandwidth may be impacted.\n",
3679 usb3_lpm_names[state]);
3680 return 0;
3681}
3682
3683/*
3684 * Disable hub-initiated and device-initiated U1 and U2 entry.
3685 * Caller must own the bandwidth_mutex.
3686 *
3687 * This will call usb_enable_lpm() on failure, which will decrement
3688 * lpm_disable_count, and will re-enable LPM if lpm_disable_count reaches zero.
3689 */
3690int usb_disable_lpm(struct usb_device *udev)
3691{
3692 struct usb_hcd *hcd;
3693
3694 if (!udev || !udev->parent ||
3695 udev->speed != USB_SPEED_SUPER ||
3696 !udev->lpm_capable)
3697 return 0;
3698
3699 hcd = bus_to_hcd(udev->bus);
3700 if (!hcd || !hcd->driver->disable_usb3_lpm_timeout)
3701 return 0;
3702
3703 udev->lpm_disable_count++;
Dan Carpenter55558c32012-05-22 20:54:34 +03003704 if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003705 return 0;
3706
3707 /* If LPM is enabled, attempt to disable it. */
3708 if (usb_disable_link_state(hcd, udev, USB3_LPM_U1))
3709 goto enable_lpm;
3710 if (usb_disable_link_state(hcd, udev, USB3_LPM_U2))
3711 goto enable_lpm;
3712
3713 return 0;
3714
3715enable_lpm:
3716 usb_enable_lpm(udev);
3717 return -EBUSY;
3718}
3719EXPORT_SYMBOL_GPL(usb_disable_lpm);
3720
3721/* Grab the bandwidth_mutex before calling usb_disable_lpm() */
3722int usb_unlocked_disable_lpm(struct usb_device *udev)
3723{
3724 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3725 int ret;
3726
3727 if (!hcd)
3728 return -EINVAL;
3729
3730 mutex_lock(hcd->bandwidth_mutex);
3731 ret = usb_disable_lpm(udev);
3732 mutex_unlock(hcd->bandwidth_mutex);
3733
3734 return ret;
3735}
3736EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
3737
3738/*
3739 * Attempt to enable device-initiated and hub-initiated U1 and U2 entry. The
3740 * xHCI host policy may prevent U1 or U2 from being enabled.
3741 *
3742 * Other callers may have disabled link PM, so U1 and U2 entry will be disabled
3743 * until the lpm_disable_count drops to zero. Caller must own the
3744 * bandwidth_mutex.
3745 */
3746void usb_enable_lpm(struct usb_device *udev)
3747{
3748 struct usb_hcd *hcd;
3749
3750 if (!udev || !udev->parent ||
3751 udev->speed != USB_SPEED_SUPER ||
3752 !udev->lpm_capable)
3753 return;
3754
3755 udev->lpm_disable_count--;
3756 hcd = bus_to_hcd(udev->bus);
3757 /* Double check that we can both enable and disable LPM.
3758 * Device must be configured to accept set feature U1/U2 timeout.
3759 */
3760 if (!hcd || !hcd->driver->enable_usb3_lpm_timeout ||
3761 !hcd->driver->disable_usb3_lpm_timeout)
3762 return;
3763
3764 if (udev->lpm_disable_count > 0)
3765 return;
3766
3767 usb_enable_link_state(hcd, udev, USB3_LPM_U1);
3768 usb_enable_link_state(hcd, udev, USB3_LPM_U2);
3769}
3770EXPORT_SYMBOL_GPL(usb_enable_lpm);
3771
3772/* Grab the bandwidth_mutex before calling usb_enable_lpm() */
3773void usb_unlocked_enable_lpm(struct usb_device *udev)
3774{
3775 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3776
3777 if (!hcd)
3778 return;
3779
3780 mutex_lock(hcd->bandwidth_mutex);
3781 usb_enable_lpm(udev);
3782 mutex_unlock(hcd->bandwidth_mutex);
3783}
3784EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
3785
3786
Alan Sternd388dab2006-07-01 22:14:24 -04003787#else /* CONFIG_PM */
3788
Alan Sternf07600c2007-05-30 15:38:16 -04003789#define hub_suspend NULL
3790#define hub_resume NULL
3791#define hub_reset_resume NULL
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003792
3793int usb_disable_lpm(struct usb_device *udev)
3794{
3795 return 0;
3796}
Sarah Sharpe9261fb2012-05-21 08:29:01 -07003797EXPORT_SYMBOL_GPL(usb_disable_lpm);
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003798
3799void usb_enable_lpm(struct usb_device *udev) { }
Sarah Sharpe9261fb2012-05-21 08:29:01 -07003800EXPORT_SYMBOL_GPL(usb_enable_lpm);
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003801
3802int usb_unlocked_disable_lpm(struct usb_device *udev)
3803{
3804 return 0;
3805}
Sarah Sharpe9261fb2012-05-21 08:29:01 -07003806EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003807
3808void usb_unlocked_enable_lpm(struct usb_device *udev) { }
Sarah Sharpe9261fb2012-05-21 08:29:01 -07003809EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
Sarah Sharpf74631e2012-06-25 12:08:08 -07003810
3811int usb_disable_ltm(struct usb_device *udev)
3812{
3813 return 0;
3814}
3815EXPORT_SYMBOL_GPL(usb_disable_ltm);
3816
3817void usb_enable_ltm(struct usb_device *udev) { }
3818EXPORT_SYMBOL_GPL(usb_enable_ltm);
Alan Sternd388dab2006-07-01 22:14:24 -04003819#endif
3820
Linus Torvalds1da177e2005-04-16 15:20:36 -07003821
3822/* USB 2.0 spec, 7.1.7.3 / fig 7-29:
3823 *
3824 * Between connect detection and reset signaling there must be a delay
3825 * of 100ms at least for debounce and power-settling. The corresponding
3826 * timer shall restart whenever the downstream port detects a disconnect.
3827 *
3828 * Apparently there are some bluetooth and irda-dongles and a number of
3829 * low-speed devices for which this debounce period may last over a second.
3830 * Not covered by the spec - but easy to deal with.
3831 *
3832 * This implementation uses a 1500ms total debounce timeout; if the
3833 * connection isn't stable by then it returns -ETIMEDOUT. It checks
3834 * every 25ms for transient disconnects. When the port status has been
3835 * unchanged for 100ms it returns the port status.
3836 */
Lan Tianyuad493e52013-01-23 04:26:30 +08003837int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838{
3839 int ret;
3840 int total_time, stable_time = 0;
3841 u16 portchange, portstatus;
3842 unsigned connection = 0xffff;
3843
3844 for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
3845 ret = hub_port_status(hub, port1, &portstatus, &portchange);
3846 if (ret < 0)
3847 return ret;
3848
3849 if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
3850 (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
Lan Tianyuad493e52013-01-23 04:26:30 +08003851 if (!must_be_connected ||
3852 (connection == USB_PORT_STAT_CONNECTION))
3853 stable_time += HUB_DEBOUNCE_STEP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003854 if (stable_time >= HUB_DEBOUNCE_STABLE)
3855 break;
3856 } else {
3857 stable_time = 0;
3858 connection = portstatus & USB_PORT_STAT_CONNECTION;
3859 }
3860
3861 if (portchange & USB_PORT_STAT_C_CONNECTION) {
Lan Tianyuad493e52013-01-23 04:26:30 +08003862 usb_clear_port_feature(hub->hdev, port1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003863 USB_PORT_FEAT_C_CONNECTION);
3864 }
3865
3866 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
3867 break;
3868 msleep(HUB_DEBOUNCE_STEP);
3869 }
3870
3871 dev_dbg (hub->intfdev,
3872 "debounce: port %d: total %dms stable %dms status 0x%x\n",
3873 port1, total_time, stable_time, portstatus);
3874
3875 if (stable_time < HUB_DEBOUNCE_STABLE)
3876 return -ETIMEDOUT;
3877 return portstatus;
3878}
3879
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07003880void usb_ep0_reinit(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003881{
Alan Sternddeac4e2009-01-15 17:03:33 -05003882 usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
3883 usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
Alan Stern2caf7fc2008-12-31 11:31:33 -05003884 usb_enable_endpoint(udev, &udev->ep0, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003885}
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07003886EXPORT_SYMBOL_GPL(usb_ep0_reinit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003887
3888#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)
3889#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN)
3890
Alan Stern4326ed02007-07-30 17:08:43 -04003891static int hub_set_address(struct usb_device *udev, int devnum)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003892{
3893 int retval;
Sarah Sharpc6515272009-04-27 19:57:26 -07003894 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003895
Sarah Sharpc6515272009-04-27 19:57:26 -07003896 /*
3897 * The host controller will choose the device address,
3898 * instead of the core having chosen it earlier
3899 */
3900 if (!hcd->driver->address_device && devnum <= 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003901 return -EINVAL;
3902 if (udev->state == USB_STATE_ADDRESS)
3903 return 0;
3904 if (udev->state != USB_STATE_DEFAULT)
3905 return -EINVAL;
Andiry Xuc8d4af82010-10-14 07:22:51 -07003906 if (hcd->driver->address_device)
Sarah Sharpc6515272009-04-27 19:57:26 -07003907 retval = hcd->driver->address_device(hcd, udev);
Andiry Xuc8d4af82010-10-14 07:22:51 -07003908 else
Sarah Sharpc6515272009-04-27 19:57:26 -07003909 retval = usb_control_msg(udev, usb_sndaddr0pipe(),
3910 USB_REQ_SET_ADDRESS, 0, devnum, 0,
3911 NULL, 0, USB_CTRL_SET_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003912 if (retval == 0) {
Alan Stern3b29b682011-02-22 09:53:41 -05003913 update_devnum(udev, devnum);
David Vrabel4953d142008-04-08 13:24:46 -07003914 /* Device now using proper address. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003915 usb_set_device_state(udev, USB_STATE_ADDRESS);
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07003916 usb_ep0_reinit(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003917 }
3918 return retval;
3919}
3920
3921/* Reset device, (re)assign address, get device descriptor.
3922 * Device connection must be stable, no more debouncing needed.
3923 * Returns device in USB_STATE_ADDRESS, except on error.
3924 *
3925 * If this is called for an already-existing device (as part of
Ming Lei742120c2008-06-18 22:00:29 +08003926 * usb_reset_and_verify_device), the caller must own the device lock. For a
Linus Torvalds1da177e2005-04-16 15:20:36 -07003927 * newly detected device that is not accessible through any global
3928 * pointers, it's not necessary to lock the device.
3929 */
3930static int
3931hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
3932 int retry_counter)
3933{
Arjan van de Ven4186ecf2006-01-11 15:55:29 +01003934 static DEFINE_MUTEX(usb_address0_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003935
3936 struct usb_device *hdev = hub->hdev;
Sarah Sharpe7b77172009-04-27 19:54:26 -07003937 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003938 int i, j, retval;
3939 unsigned delay = HUB_SHORT_RESET_TIME;
3940 enum usb_device_speed oldspeed = udev->speed;
Michal Nazarewicze538dfd2011-08-30 17:11:19 +02003941 const char *speed;
Alan Stern4326ed02007-07-30 17:08:43 -04003942 int devnum = udev->devnum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003943
3944 /* root hub ports have a slightly longer reset period
3945 * (from USB 2.0 spec, section 7.1.7.5)
3946 */
3947 if (!hdev->parent) {
3948 delay = HUB_ROOT_RESET_TIME;
3949 if (port1 == hdev->bus->otg_port)
3950 hdev->bus->b_hnp_enable = 0;
3951 }
3952
3953 /* Some low speed devices have problems with the quick delay, so */
3954 /* be a bit pessimistic with those devices. RHbug #23670 */
3955 if (oldspeed == USB_SPEED_LOW)
3956 delay = HUB_LONG_RESET_TIME;
3957
Arjan van de Ven4186ecf2006-01-11 15:55:29 +01003958 mutex_lock(&usb_address0_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003959
Luben Tuikov07194ab2011-02-11 11:33:10 -08003960 /* Reset the device; full speed may morph to high speed */
3961 /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
Andiry Xu75d7cf72011-09-13 16:41:11 -07003962 retval = hub_port_reset(hub, port1, udev, delay, false);
Luben Tuikov07194ab2011-02-11 11:33:10 -08003963 if (retval < 0) /* error or disconnect */
3964 goto fail;
3965 /* success, speed is known */
3966
Linus Torvalds1da177e2005-04-16 15:20:36 -07003967 retval = -ENODEV;
3968
3969 if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {
3970 dev_dbg(&udev->dev, "device reset changed speed!\n");
3971 goto fail;
3972 }
3973 oldspeed = udev->speed;
Alan Stern4326ed02007-07-30 17:08:43 -04003974
Linus Torvalds1da177e2005-04-16 15:20:36 -07003975 /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
3976 * it's fixed size except for full speed devices.
Inaky Perez-Gonzalez5bb6e0a2006-08-25 19:35:30 -07003977 * For Wireless USB devices, ep0 max packet is always 512 (tho
3978 * reported as 0xff in the device descriptor). WUSB1.0[4.8.1].
Linus Torvalds1da177e2005-04-16 15:20:36 -07003979 */
3980 switch (udev->speed) {
Sarah Sharp6b403b02009-04-27 19:54:10 -07003981 case USB_SPEED_SUPER:
Greg Kroah-Hartman551cdbb2010-01-14 11:08:04 -08003982 case USB_SPEED_WIRELESS: /* fixed at 512 */
Harvey Harrison551509d2009-02-11 14:11:36 -08003983 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
Inaky Perez-Gonzalez5bb6e0a2006-08-25 19:35:30 -07003984 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003985 case USB_SPEED_HIGH: /* fixed at 64 */
Harvey Harrison551509d2009-02-11 14:11:36 -08003986 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003987 break;
3988 case USB_SPEED_FULL: /* 8, 16, 32, or 64 */
3989 /* to determine the ep0 maxpacket size, try to read
3990 * the device descriptor to get bMaxPacketSize0 and
3991 * then correct our initial guess.
3992 */
Harvey Harrison551509d2009-02-11 14:11:36 -08003993 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003994 break;
3995 case USB_SPEED_LOW: /* fixed at 8 */
Harvey Harrison551509d2009-02-11 14:11:36 -08003996 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003997 break;
3998 default:
3999 goto fail;
4000 }
Michal Nazarewicze538dfd2011-08-30 17:11:19 +02004001
4002 if (udev->speed == USB_SPEED_WIRELESS)
4003 speed = "variable speed Wireless";
4004 else
4005 speed = usb_speed_string(udev->speed);
4006
Sarah Sharpc6515272009-04-27 19:57:26 -07004007 if (udev->speed != USB_SPEED_SUPER)
4008 dev_info(&udev->dev,
Michal Nazarewicze538dfd2011-08-30 17:11:19 +02004009 "%s %s USB device number %d using %s\n",
4010 (udev->config) ? "reset" : "new", speed,
Alan Stern3b29b682011-02-22 09:53:41 -05004011 devnum, udev->bus->controller->driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004012
4013 /* Set up TT records, if needed */
4014 if (hdev->tt) {
4015 udev->tt = hdev->tt;
4016 udev->ttport = hdev->ttport;
4017 } else if (udev->speed != USB_SPEED_HIGH
4018 && hdev->speed == USB_SPEED_HIGH) {
Alan Sternd199c962011-01-31 10:56:37 -05004019 if (!hub->tt.hub) {
4020 dev_err(&udev->dev, "parent hub has no TT\n");
4021 retval = -EINVAL;
4022 goto fail;
4023 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004024 udev->tt = &hub->tt;
4025 udev->ttport = port1;
4026 }
4027
4028 /* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
4029 * Because device hardware and firmware is sometimes buggy in
4030 * this area, and this is how Linux has done it for ages.
4031 * Change it cautiously.
4032 *
4033 * NOTE: If USE_NEW_SCHEME() is true we will start by issuing
4034 * a 64-byte GET_DESCRIPTOR request. This is what Windows does,
4035 * so it may help with some non-standards-compliant devices.
4036 * Otherwise we start with SET_ADDRESS and then try to read the
4037 * first 8 bytes of the device descriptor to get the ep0 maxpacket
4038 * value.
4039 */
4040 for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
Sarah Sharpc6515272009-04-27 19:57:26 -07004041 if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004042 struct usb_device_descriptor *buf;
4043 int r = 0;
4044
4045#define GET_DESCRIPTOR_BUFSIZE 64
4046 buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
4047 if (!buf) {
4048 retval = -ENOMEM;
4049 continue;
4050 }
4051
Alan Sternb89ee192007-05-11 10:19:04 -04004052 /* Retry on all errors; some devices are flakey.
4053 * 255 is for WUSB devices, we actually need to use
4054 * 512 (WUSB1.0[4.8.1]).
Linus Torvalds1da177e2005-04-16 15:20:36 -07004055 */
4056 for (j = 0; j < 3; ++j) {
4057 buf->bMaxPacketSize0 = 0;
4058 r = usb_control_msg(udev, usb_rcvaddr0pipe(),
4059 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
4060 USB_DT_DEVICE << 8, 0,
4061 buf, GET_DESCRIPTOR_BUFSIZE,
Jaroslav Kyselafd7c5192008-10-10 16:24:45 +02004062 initial_descriptor_timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004063 switch (buf->bMaxPacketSize0) {
Inaky Perez-Gonzalez5bb6e0a2006-08-25 19:35:30 -07004064 case 8: case 16: case 32: case 64: case 255:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004065 if (buf->bDescriptorType ==
4066 USB_DT_DEVICE) {
4067 r = 0;
4068 break;
4069 }
4070 /* FALL THROUGH */
4071 default:
4072 if (r == 0)
4073 r = -EPROTO;
4074 break;
4075 }
4076 if (r == 0)
4077 break;
4078 }
4079 udev->descriptor.bMaxPacketSize0 =
4080 buf->bMaxPacketSize0;
4081 kfree(buf);
4082
Andiry Xu75d7cf72011-09-13 16:41:11 -07004083 retval = hub_port_reset(hub, port1, udev, delay, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004084 if (retval < 0) /* error or disconnect */
4085 goto fail;
4086 if (oldspeed != udev->speed) {
4087 dev_dbg(&udev->dev,
4088 "device reset changed speed!\n");
4089 retval = -ENODEV;
4090 goto fail;
4091 }
4092 if (r) {
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08004093 dev_err(&udev->dev,
4094 "device descriptor read/64, error %d\n",
4095 r);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004096 retval = -EMSGSIZE;
4097 continue;
4098 }
4099#undef GET_DESCRIPTOR_BUFSIZE
4100 }
4101
Inaky Perez-Gonzalez6c529cd2008-04-08 13:24:46 -07004102 /*
4103 * If device is WUSB, we already assigned an
4104 * unauthorized address in the Connect Ack sequence;
4105 * authorization will assign the final address.
4106 */
Sarah Sharpc6515272009-04-27 19:57:26 -07004107 if (udev->wusb == 0) {
Inaky Perez-Gonzalez6c529cd2008-04-08 13:24:46 -07004108 for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
4109 retval = hub_set_address(udev, devnum);
4110 if (retval >= 0)
4111 break;
4112 msleep(200);
4113 }
4114 if (retval < 0) {
4115 dev_err(&udev->dev,
4116 "device not accepting address %d, error %d\n",
4117 devnum, retval);
4118 goto fail;
4119 }
Sarah Sharpc6515272009-04-27 19:57:26 -07004120 if (udev->speed == USB_SPEED_SUPER) {
4121 devnum = udev->devnum;
4122 dev_info(&udev->dev,
Alan Stern3b29b682011-02-22 09:53:41 -05004123 "%s SuperSpeed USB device number %d using %s\n",
Sarah Sharpc6515272009-04-27 19:57:26 -07004124 (udev->config) ? "reset" : "new",
Alan Stern3b29b682011-02-22 09:53:41 -05004125 devnum, udev->bus->controller->driver->name);
Sarah Sharpc6515272009-04-27 19:57:26 -07004126 }
Inaky Perez-Gonzalez6c529cd2008-04-08 13:24:46 -07004127
4128 /* cope with hardware quirkiness:
4129 * - let SET_ADDRESS settle, some device hardware wants it
4130 * - read ep0 maxpacket even for high and low speed,
4131 */
4132 msleep(10);
Sarah Sharpc6515272009-04-27 19:57:26 -07004133 if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004134 break;
Inaky Perez-Gonzalez6c529cd2008-04-08 13:24:46 -07004135 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004136
4137 retval = usb_get_device_descriptor(udev, 8);
4138 if (retval < 8) {
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08004139 dev_err(&udev->dev,
4140 "device descriptor read/8, error %d\n",
4141 retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004142 if (retval >= 0)
4143 retval = -EMSGSIZE;
4144 } else {
4145 retval = 0;
4146 break;
4147 }
4148 }
4149 if (retval)
4150 goto fail;
4151
Peter Chenb76baa82012-11-09 09:44:43 +08004152 if (hcd->phy && !hdev->parent)
Peter Chenac965112012-11-09 09:44:44 +08004153 usb_phy_notify_connect(hcd->phy, udev->speed);
Peter Chenb76baa82012-11-09 09:44:43 +08004154
Elric Fud8aec3d2012-03-26 21:16:02 +08004155 /*
4156 * Some superspeed devices have finished the link training process
4157 * and attached to a superspeed hub port, but the device descriptor
4158 * got from those devices show they aren't superspeed devices. Warm
4159 * reset the port attached by the devices can fix them.
4160 */
4161 if ((udev->speed == USB_SPEED_SUPER) &&
4162 (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
4163 dev_err(&udev->dev, "got a wrong device descriptor, "
4164 "warm reset device\n");
4165 hub_port_reset(hub, port1, udev,
4166 HUB_BH_RESET_TIME, true);
4167 retval = -EINVAL;
4168 goto fail;
4169 }
4170
Sarah Sharp6b403b02009-04-27 19:54:10 -07004171 if (udev->descriptor.bMaxPacketSize0 == 0xff ||
4172 udev->speed == USB_SPEED_SUPER)
4173 i = 512;
4174 else
4175 i = udev->descriptor.bMaxPacketSize0;
Kuninori Morimoto29cc8892011-08-23 03:12:03 -07004176 if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
Alan Stern56626a72010-10-14 15:25:21 -04004177 if (udev->speed == USB_SPEED_LOW ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07004178 !(i == 8 || i == 16 || i == 32 || i == 64)) {
Alan Stern56626a72010-10-14 15:25:21 -04004179 dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004180 retval = -EMSGSIZE;
4181 goto fail;
4182 }
Alan Stern56626a72010-10-14 15:25:21 -04004183 if (udev->speed == USB_SPEED_FULL)
4184 dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
4185 else
4186 dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004187 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07004188 usb_ep0_reinit(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004189 }
4190
4191 retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
4192 if (retval < (signed)sizeof(udev->descriptor)) {
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08004193 dev_err(&udev->dev, "device descriptor read/all, error %d\n",
4194 retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004195 if (retval >= 0)
4196 retval = -ENOMSG;
4197 goto fail;
4198 }
4199
Andiry Xu1ff4df52011-09-23 14:19:48 -07004200 if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
4201 retval = usb_get_bos_descriptor(udev);
Sarah Sharp51e0a012012-02-20 12:02:19 -08004202 if (!retval) {
Sarah Sharpd9b20992012-02-20 08:31:26 -08004203 udev->lpm_capable = usb_device_supports_lpm(udev);
Sarah Sharp51e0a012012-02-20 12:02:19 -08004204 usb_set_lpm_parameters(udev);
4205 }
Andiry Xu1ff4df52011-09-23 14:19:48 -07004206 }
Andiry Xu3148bf02011-09-23 14:19:47 -07004207
Linus Torvalds1da177e2005-04-16 15:20:36 -07004208 retval = 0;
Alek Du48f24972010-06-04 15:47:55 +08004209 /* notify HCD that we have a device connected and addressed */
4210 if (hcd->driver->update_device)
4211 hcd->driver->update_device(hcd, udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004212fail:
Alan Stern4326ed02007-07-30 17:08:43 -04004213 if (retval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004214 hub_port_disable(hub, port1, 0);
Alan Stern3b29b682011-02-22 09:53:41 -05004215 update_devnum(udev, devnum); /* for disconnect processing */
Alan Stern4326ed02007-07-30 17:08:43 -04004216 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +01004217 mutex_unlock(&usb_address0_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004218 return retval;
4219}
4220
4221static void
4222check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
4223{
4224 struct usb_qualifier_descriptor *qual;
4225 int status;
4226
Christoph Lametere94b1762006-12-06 20:33:17 -08004227 qual = kmalloc (sizeof *qual, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004228 if (qual == NULL)
4229 return;
4230
4231 status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0,
4232 qual, sizeof *qual);
4233 if (status == sizeof *qual) {
4234 dev_info(&udev->dev, "not running at top speed; "
4235 "connect to a high speed hub\n");
4236 /* hub LEDs are probably harder to miss than syslog */
4237 if (hub->has_indicators) {
4238 hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
David Howellsc4028952006-11-22 14:57:56 +00004239 schedule_delayed_work (&hub->leds, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004240 }
4241 }
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -07004242 kfree(qual);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004243}
4244
4245static unsigned
4246hub_power_remaining (struct usb_hub *hub)
4247{
4248 struct usb_device *hdev = hub->hdev;
4249 int remaining;
Alan Stern55c52712005-11-23 12:03:12 -05004250 int port1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004251
Alan Stern55c52712005-11-23 12:03:12 -05004252 if (!hub->limited_power)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004253 return 0;
4254
Alan Stern55c52712005-11-23 12:03:12 -05004255 remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
4256 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
Lan Tianyuff823c792012-09-05 13:44:32 +08004257 struct usb_device *udev = hub->ports[port1 - 1]->child;
Alan Stern55c52712005-11-23 12:03:12 -05004258 int delta;
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004259 unsigned unit_load;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004260
4261 if (!udev)
4262 continue;
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004263 if (hub_is_superspeed(udev))
4264 unit_load = 150;
4265 else
4266 unit_load = 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004267
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004268 /*
4269 * Unconfigured devices may not use more than one unit load,
4270 * or 8mA for OTG ports
4271 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004272 if (udev->actconfig)
Sebastian Andrzej Siewior8d8479d2012-12-18 15:25:46 +01004273 delta = usb_get_max_power(udev, udev->actconfig);
Alan Stern55c52712005-11-23 12:03:12 -05004274 else if (port1 != udev->bus->otg_port || hdev->parent)
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004275 delta = unit_load;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004276 else
Alan Stern55c52712005-11-23 12:03:12 -05004277 delta = 8;
4278 if (delta > hub->mA_per_port)
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08004279 dev_warn(&udev->dev,
4280 "%dmA is over %umA budget for port %d!\n",
4281 delta, hub->mA_per_port, port1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004282 remaining -= delta;
4283 }
4284 if (remaining < 0) {
Alan Stern55c52712005-11-23 12:03:12 -05004285 dev_warn(hub->intfdev, "%dmA over power budget!\n",
4286 - remaining);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004287 remaining = 0;
4288 }
4289 return remaining;
4290}
4291
4292/* Handle physical or logical connection change events.
4293 * This routine is called when:
4294 * a port connection-change occurs;
4295 * a port enable-change occurs (often caused by EMI);
Ming Lei742120c2008-06-18 22:00:29 +08004296 * usb_reset_and_verify_device() encounters changed descriptors (as from
Linus Torvalds1da177e2005-04-16 15:20:36 -07004297 * a firmware download)
4298 * caller already locked the hub
4299 */
4300static void hub_port_connect_change(struct usb_hub *hub, int port1,
4301 u16 portstatus, u16 portchange)
4302{
4303 struct usb_device *hdev = hub->hdev;
4304 struct device *hub_dev = hub->intfdev;
Balaji Rao90da0962007-11-22 01:58:14 +05304305 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
Alan Stern24618b02008-04-28 11:06:28 -04004306 unsigned wHubCharacteristics =
4307 le16_to_cpu(hub->descriptor->wHubCharacteristics);
Alan Stern8808f002008-04-28 11:06:55 -04004308 struct usb_device *udev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004309 int status, i;
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004310 unsigned unit_load;
Alan Stern24618b02008-04-28 11:06:28 -04004311
Linus Torvalds1da177e2005-04-16 15:20:36 -07004312 dev_dbg (hub_dev,
4313 "port %d, status %04x, change %04x, %s\n",
Sarah Sharp131dec32010-12-06 21:00:19 -08004314 port1, portstatus, portchange, portspeed(hub, portstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004315
4316 if (hub->has_indicators) {
4317 set_port_led(hub, port1, HUB_LED_AUTO);
4318 hub->indicator[port1-1] = INDICATOR_AUTO;
4319 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004320
4321#ifdef CONFIG_USB_OTG
4322 /* during HNP, don't repeat the debounce */
4323 if (hdev->bus->is_b_host)
Alan Stern24618b02008-04-28 11:06:28 -04004324 portchange &= ~(USB_PORT_STAT_C_CONNECTION |
4325 USB_PORT_STAT_C_ENABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004326#endif
4327
Alan Stern8808f002008-04-28 11:06:55 -04004328 /* Try to resuscitate an existing device */
Lan Tianyuff823c792012-09-05 13:44:32 +08004329 udev = hub->ports[port1 - 1]->child;
Alan Stern8808f002008-04-28 11:06:55 -04004330 if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
4331 udev->state != USB_STATE_NOTATTACHED) {
Alan Stern8808f002008-04-28 11:06:55 -04004332 usb_lock_device(udev);
4333 if (portstatus & USB_PORT_STAT_ENABLE) {
4334 status = 0; /* Nothing to do */
Alan Stern8808f002008-04-28 11:06:55 -04004335
4336#ifdef CONFIG_USB_SUSPEND
Alan Stern5257d972008-09-22 14:43:08 -04004337 } else if (udev->state == USB_STATE_SUSPENDED &&
4338 udev->persist_enabled) {
Alan Stern8808f002008-04-28 11:06:55 -04004339 /* For a suspended device, treat this as a
4340 * remote wakeup event.
4341 */
Alan Stern0534d462010-01-08 12:56:30 -05004342 status = usb_remote_wakeup(udev);
Alan Stern8808f002008-04-28 11:06:55 -04004343#endif
4344
4345 } else {
Alan Stern5257d972008-09-22 14:43:08 -04004346 status = -ENODEV; /* Don't resuscitate */
Alan Stern8808f002008-04-28 11:06:55 -04004347 }
4348 usb_unlock_device(udev);
4349
4350 if (status == 0) {
4351 clear_bit(port1, hub->change_bits);
4352 return;
4353 }
4354 }
4355
Alan Stern24618b02008-04-28 11:06:28 -04004356 /* Disconnect any existing devices under this port */
Peter Chenb76baa82012-11-09 09:44:43 +08004357 if (udev) {
4358 if (hcd->phy && !hdev->parent &&
4359 !(portstatus & USB_PORT_STAT_CONNECTION))
Peter Chenac965112012-11-09 09:44:44 +08004360 usb_phy_notify_disconnect(hcd->phy, udev->speed);
Lan Tianyuff823c792012-09-05 13:44:32 +08004361 usb_disconnect(&hub->ports[port1 - 1]->child);
Peter Chenb76baa82012-11-09 09:44:43 +08004362 }
Alan Stern24618b02008-04-28 11:06:28 -04004363 clear_bit(port1, hub->change_bits);
4364
Alan Stern253e0572009-10-27 15:20:13 -04004365 /* We can forget about a "removed" device when there's a physical
4366 * disconnect or the connect status changes.
4367 */
4368 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
4369 (portchange & USB_PORT_STAT_C_CONNECTION))
4370 clear_bit(port1, hub->removed_bits);
4371
Alan Stern5257d972008-09-22 14:43:08 -04004372 if (portchange & (USB_PORT_STAT_C_CONNECTION |
4373 USB_PORT_STAT_C_ENABLE)) {
Lan Tianyuad493e52013-01-23 04:26:30 +08004374 status = hub_port_debounce_be_stable(hub, port1);
Alan Stern5257d972008-09-22 14:43:08 -04004375 if (status < 0) {
4376 if (printk_ratelimit())
4377 dev_err(hub_dev, "connect-debounce failed, "
4378 "port %d disabled\n", port1);
4379 portstatus &= ~USB_PORT_STAT_CONNECTION;
4380 } else {
4381 portstatus = status;
4382 }
4383 }
4384
Alan Stern253e0572009-10-27 15:20:13 -04004385 /* Return now if debouncing failed or nothing is connected or
4386 * the device was "removed".
4387 */
4388 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
4389 test_bit(port1, hub->removed_bits)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004390
4391 /* maybe switch power back on (e.g. root hub was reset) */
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07004392 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
Andiry Xu0ed9a572011-04-27 18:07:43 +08004393 && !port_is_power_on(hub, portstatus))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004394 set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
Alan Stern5257d972008-09-22 14:43:08 -04004395
Linus Torvalds1da177e2005-04-16 15:20:36 -07004396 if (portstatus & USB_PORT_STAT_ENABLE)
4397 goto done;
4398 return;
4399 }
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004400 if (hub_is_superspeed(hub->hdev))
4401 unit_load = 150;
4402 else
4403 unit_load = 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004404
Linus Torvalds1da177e2005-04-16 15:20:36 -07004405 for (i = 0; i < SET_CONFIG_TRIES; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004406
4407 /* reallocate for each attempt, since references
4408 * to the previous one can escape in various ways
4409 */
4410 udev = usb_alloc_dev(hdev, hdev->bus, port1);
4411 if (!udev) {
4412 dev_err (hub_dev,
4413 "couldn't allocate port %d usb_device\n",
4414 port1);
4415 goto done;
4416 }
4417
4418 usb_set_device_state(udev, USB_STATE_POWERED);
Alan Stern55c52712005-11-23 12:03:12 -05004419 udev->bus_mA = hub->mA_per_port;
Alan Sternb6956ff2006-08-30 15:46:48 -04004420 udev->level = hdev->level + 1;
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07004421 udev->wusb = hub_is_wusb(hub);
Alan Stern55c52712005-11-23 12:03:12 -05004422
Sarah Sharp131dec32010-12-06 21:00:19 -08004423 /* Only USB 3.0 devices are connected to SuperSpeed hubs. */
4424 if (hub_is_superspeed(hub->hdev))
Sarah Sharpe7b77172009-04-27 19:54:26 -07004425 udev->speed = USB_SPEED_SUPER;
4426 else
4427 udev->speed = USB_SPEED_UNKNOWN;
4428
Alan Stern3b29b682011-02-22 09:53:41 -05004429 choose_devnum(udev);
Andiry Xuc8d4af82010-10-14 07:22:51 -07004430 if (udev->devnum <= 0) {
4431 status = -ENOTCONN; /* Don't retry */
4432 goto loop;
Sarah Sharpc6515272009-04-27 19:57:26 -07004433 }
4434
Sarah Sharpe7b77172009-04-27 19:54:26 -07004435 /* reset (non-USB 3.0 devices) and get descriptor */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004436 status = hub_port_init(hub, udev, port1, i);
4437 if (status < 0)
4438 goto loop;
4439
Phil Dibowitz93362a82010-07-22 00:05:01 +02004440 usb_detect_quirks(udev);
4441 if (udev->quirks & USB_QUIRK_DELAY_INIT)
4442 msleep(1000);
4443
Linus Torvalds1da177e2005-04-16 15:20:36 -07004444 /* consecutive bus-powered hubs aren't reliable; they can
4445 * violate the voltage drop budget. if the new child has
4446 * a "powered" LED, users should notice we didn't enable it
4447 * (without reading syslog), even without per-port LEDs
4448 * on the parent.
4449 */
4450 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004451 && udev->bus_mA <= unit_load) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004452 u16 devstat;
4453
4454 status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
4455 &devstat);
Alan Stern55c52712005-11-23 12:03:12 -05004456 if (status < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004457 dev_dbg(&udev->dev, "get status %d ?\n", status);
4458 goto loop_disable;
4459 }
Alan Stern55c52712005-11-23 12:03:12 -05004460 le16_to_cpus(&devstat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004461 if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
4462 dev_err(&udev->dev,
4463 "can't connect bus-powered hub "
4464 "to this port\n");
4465 if (hub->has_indicators) {
4466 hub->indicator[port1-1] =
4467 INDICATOR_AMBER_BLINK;
David Howellsc4028952006-11-22 14:57:56 +00004468 schedule_delayed_work (&hub->leds, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004469 }
4470 status = -ENOTCONN; /* Don't retry */
4471 goto loop_disable;
4472 }
4473 }
4474
4475 /* check for devices running slower than they could */
4476 if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
4477 && udev->speed == USB_SPEED_FULL
4478 && highspeed_hubs != 0)
4479 check_highspeed (hub, udev, port1);
4480
Greg Kroah-Hartmanfa286182012-05-14 09:20:37 -07004481 /* Store the parent's children[] pointer. At this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07004482 * udev becomes globally accessible, although presumably
4483 * no one will look at it until hdev is unlocked.
4484 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004485 status = 0;
4486
4487 /* We mustn't add new devices if the parent hub has
4488 * been disconnected; we would race with the
4489 * recursively_mark_NOTATTACHED() routine.
4490 */
4491 spin_lock_irq(&device_state_lock);
4492 if (hdev->state == USB_STATE_NOTATTACHED)
4493 status = -ENOTCONN;
4494 else
Lan Tianyuff823c792012-09-05 13:44:32 +08004495 hub->ports[port1 - 1]->child = udev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004496 spin_unlock_irq(&device_state_lock);
4497
4498 /* Run it through the hoops (find a driver, etc) */
4499 if (!status) {
4500 status = usb_new_device(udev);
4501 if (status) {
4502 spin_lock_irq(&device_state_lock);
Lan Tianyuff823c792012-09-05 13:44:32 +08004503 hub->ports[port1 - 1]->child = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004504 spin_unlock_irq(&device_state_lock);
4505 }
4506 }
4507
Linus Torvalds1da177e2005-04-16 15:20:36 -07004508 if (status)
4509 goto loop_disable;
4510
4511 status = hub_power_remaining(hub);
4512 if (status)
Alan Stern55c52712005-11-23 12:03:12 -05004513 dev_dbg(hub_dev, "%dmA power budget left\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004514
4515 return;
4516
4517loop_disable:
4518 hub_port_disable(hub, port1, 1);
4519loop:
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07004520 usb_ep0_reinit(udev);
Alan Stern3b29b682011-02-22 09:53:41 -05004521 release_devnum(udev);
Herbert Xuf7410ce2010-01-10 20:15:03 +11004522 hub_free_dev(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004523 usb_put_dev(udev);
Vikram Panditaffcdc182007-05-25 21:31:07 -07004524 if ((status == -ENOTCONN) || (status == -ENOTSUPP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004525 break;
4526 }
Alan Stern3a311552008-05-20 16:58:29 -04004527 if (hub->hdev->parent ||
4528 !hcd->driver->port_handed_over ||
4529 !(hcd->driver->port_handed_over)(hcd, port1))
4530 dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
4531 port1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004532
4533done:
4534 hub_port_disable(hub, port1, 1);
Balaji Rao90da0962007-11-22 01:58:14 +05304535 if (hcd->driver->relinquish_port && !hub->hdev->parent)
4536 hcd->driver->relinquish_port(hcd, port1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004537}
4538
Sarah Sharp714b07b2012-01-24 13:53:18 -08004539/* Returns 1 if there was a remote wakeup and a connect status change. */
4540static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
Sarah Sharp72937e12012-01-24 11:46:50 -08004541 u16 portstatus, u16 portchange)
Sarah Sharp714b07b2012-01-24 13:53:18 -08004542{
4543 struct usb_device *hdev;
4544 struct usb_device *udev;
4545 int connect_change = 0;
4546 int ret;
4547
4548 hdev = hub->hdev;
Lan Tianyuff823c792012-09-05 13:44:32 +08004549 udev = hub->ports[port - 1]->child;
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004550 if (!hub_is_superspeed(hdev)) {
4551 if (!(portchange & USB_PORT_STAT_C_SUSPEND))
4552 return 0;
Lan Tianyuad493e52013-01-23 04:26:30 +08004553 usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004554 } else {
4555 if (!udev || udev->state != USB_STATE_SUSPENDED ||
Sarah Sharp72937e12012-01-24 11:46:50 -08004556 (portstatus & USB_PORT_STAT_LINK_STATE) !=
4557 USB_SS_PORT_LS_U0)
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004558 return 0;
4559 }
4560
Sarah Sharp714b07b2012-01-24 13:53:18 -08004561 if (udev) {
4562 /* TRSMRCY = 10 msec */
4563 msleep(10);
4564
4565 usb_lock_device(udev);
4566 ret = usb_remote_wakeup(udev);
4567 usb_unlock_device(udev);
4568 if (ret < 0)
4569 connect_change = 1;
4570 } else {
4571 ret = -ENODEV;
4572 hub_port_disable(hub, port, 1);
4573 }
4574 dev_dbg(hub->intfdev, "resume on port %d, status %d\n",
4575 port, ret);
4576 return connect_change;
4577}
4578
Linus Torvalds1da177e2005-04-16 15:20:36 -07004579static void hub_events(void)
4580{
4581 struct list_head *tmp;
4582 struct usb_device *hdev;
4583 struct usb_interface *intf;
4584 struct usb_hub *hub;
4585 struct device *hub_dev;
4586 u16 hubstatus;
4587 u16 hubchange;
4588 u16 portstatus;
4589 u16 portchange;
4590 int i, ret;
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004591 int connect_change, wakeup_change;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004592
4593 /*
4594 * We restart the list every time to avoid a deadlock with
4595 * deleting hubs downstream from this one. This should be
4596 * safe since we delete the hub from the event list.
4597 * Not the most efficient, but avoids deadlocks.
4598 */
4599 while (1) {
4600
4601 /* Grab the first entry at the beginning of the list */
4602 spin_lock_irq(&hub_event_lock);
4603 if (list_empty(&hub_event_list)) {
4604 spin_unlock_irq(&hub_event_lock);
4605 break;
4606 }
4607
4608 tmp = hub_event_list.next;
4609 list_del_init(tmp);
4610
4611 hub = list_entry(tmp, struct usb_hub, event_list);
Alan Sterne8054852007-05-04 11:55:11 -04004612 kref_get(&hub->kref);
4613 spin_unlock_irq(&hub_event_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004614
Alan Sterne8054852007-05-04 11:55:11 -04004615 hdev = hub->hdev;
4616 hub_dev = hub->intfdev;
4617 intf = to_usb_interface(hub_dev);
Alan Stern40f122f2006-11-09 14:44:33 -05004618 dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004619 hdev->state, hub->descriptor
4620 ? hub->descriptor->bNbrPorts
4621 : 0,
4622 /* NOTE: expects max 15 ports... */
4623 (u16) hub->change_bits[0],
Alan Stern40f122f2006-11-09 14:44:33 -05004624 (u16) hub->event_bits[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004625
Linus Torvalds1da177e2005-04-16 15:20:36 -07004626 /* Lock the device, then check to see if we were
4627 * disconnected while waiting for the lock to succeed. */
Alan Stern06b84e82007-05-04 11:54:50 -04004628 usb_lock_device(hdev);
Alan Sterne8054852007-05-04 11:55:11 -04004629 if (unlikely(hub->disconnected))
Alan Stern9bbdf1e2010-01-08 12:57:28 -05004630 goto loop_disconnected;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004631
4632 /* If the hub has died, clean up after it */
4633 if (hdev->state == USB_STATE_NOTATTACHED) {
Alan Stern7de18d82006-06-01 13:37:24 -04004634 hub->error = -ENODEV;
Alan Stern43303542008-04-28 11:07:31 -04004635 hub_quiesce(hub, HUB_DISCONNECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004636 goto loop;
4637 }
4638
Alan Stern40f122f2006-11-09 14:44:33 -05004639 /* Autoresume */
4640 ret = usb_autopm_get_interface(intf);
4641 if (ret) {
4642 dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004643 goto loop;
Alan Stern40f122f2006-11-09 14:44:33 -05004644 }
4645
4646 /* If this is an inactive hub, do nothing */
4647 if (hub->quiescing)
4648 goto loop_autopm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004649
4650 if (hub->error) {
4651 dev_dbg (hub_dev, "resetting for error %d\n",
4652 hub->error);
4653
Ming Lei742120c2008-06-18 22:00:29 +08004654 ret = usb_reset_device(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004655 if (ret) {
4656 dev_dbg (hub_dev,
4657 "error resetting hub: %d\n", ret);
Alan Stern40f122f2006-11-09 14:44:33 -05004658 goto loop_autopm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004659 }
4660
4661 hub->nerrors = 0;
4662 hub->error = 0;
4663 }
4664
4665 /* deal with port status changes */
4666 for (i = 1; i <= hub->descriptor->bNbrPorts; i++) {
4667 if (test_bit(i, hub->busy_bits))
4668 continue;
4669 connect_change = test_bit(i, hub->change_bits);
Sarah Sharp72937e12012-01-24 11:46:50 -08004670 wakeup_change = test_and_clear_bit(i, hub->wakeup_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004671 if (!test_and_clear_bit(i, hub->event_bits) &&
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004672 !connect_change && !wakeup_change)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673 continue;
4674
4675 ret = hub_port_status(hub, i,
4676 &portstatus, &portchange);
4677 if (ret < 0)
4678 continue;
4679
Linus Torvalds1da177e2005-04-16 15:20:36 -07004680 if (portchange & USB_PORT_STAT_C_CONNECTION) {
Lan Tianyuad493e52013-01-23 04:26:30 +08004681 usb_clear_port_feature(hdev, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004682 USB_PORT_FEAT_C_CONNECTION);
4683 connect_change = 1;
4684 }
4685
4686 if (portchange & USB_PORT_STAT_C_ENABLE) {
4687 if (!connect_change)
4688 dev_dbg (hub_dev,
4689 "port %d enable change, "
4690 "status %08x\n",
4691 i, portstatus);
Lan Tianyuad493e52013-01-23 04:26:30 +08004692 usb_clear_port_feature(hdev, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004693 USB_PORT_FEAT_C_ENABLE);
4694
4695 /*
4696 * EM interference sometimes causes badly
4697 * shielded USB devices to be shutdown by
4698 * the hub, this hack enables them again.
4699 * Works at least with mouse driver.
4700 */
4701 if (!(portstatus & USB_PORT_STAT_ENABLE)
4702 && !connect_change
Lan Tianyuff823c792012-09-05 13:44:32 +08004703 && hub->ports[i - 1]->child) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004704 dev_err (hub_dev,
4705 "port %i "
4706 "disabled by hub (EMI?), "
4707 "re-enabling...\n",
4708 i);
4709 connect_change = 1;
4710 }
4711 }
4712
Sarah Sharp72937e12012-01-24 11:46:50 -08004713 if (hub_handle_remote_wakeup(hub, i,
4714 portstatus, portchange))
Sarah Sharp714b07b2012-01-24 13:53:18 -08004715 connect_change = 1;
Alan Stern8808f002008-04-28 11:06:55 -04004716
Linus Torvalds1da177e2005-04-16 15:20:36 -07004717 if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
Paul Bolle752d57a2011-03-11 18:03:52 +01004718 u16 status = 0;
4719 u16 unused;
4720
4721 dev_dbg(hub_dev, "over-current change on port "
4722 "%d\n", i);
Lan Tianyuad493e52013-01-23 04:26:30 +08004723 usb_clear_port_feature(hdev, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004724 USB_PORT_FEAT_C_OVER_CURRENT);
Paul Bolle752d57a2011-03-11 18:03:52 +01004725 msleep(100); /* Cool down */
Alan Stern8520f382008-09-22 14:44:26 -04004726 hub_power_on(hub, true);
Paul Bolle752d57a2011-03-11 18:03:52 +01004727 hub_port_status(hub, i, &status, &unused);
4728 if (status & USB_PORT_STAT_OVERCURRENT)
4729 dev_err(hub_dev, "over-current "
4730 "condition on port %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004731 }
4732
4733 if (portchange & USB_PORT_STAT_C_RESET) {
4734 dev_dbg (hub_dev,
4735 "reset change on port %d\n",
4736 i);
Lan Tianyuad493e52013-01-23 04:26:30 +08004737 usb_clear_port_feature(hdev, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004738 USB_PORT_FEAT_C_RESET);
4739 }
Sarah Sharpc7061572010-12-06 15:08:20 -08004740 if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
4741 hub_is_superspeed(hub->hdev)) {
4742 dev_dbg(hub_dev,
4743 "warm reset change on port %d\n",
4744 i);
Lan Tianyuad493e52013-01-23 04:26:30 +08004745 usb_clear_port_feature(hdev, i,
Sarah Sharpc7061572010-12-06 15:08:20 -08004746 USB_PORT_FEAT_C_BH_PORT_RESET);
4747 }
John Youndbe79bb2001-09-17 00:00:00 -07004748 if (portchange & USB_PORT_STAT_C_LINK_STATE) {
Lan Tianyuad493e52013-01-23 04:26:30 +08004749 usb_clear_port_feature(hub->hdev, i,
John Youndbe79bb2001-09-17 00:00:00 -07004750 USB_PORT_FEAT_C_PORT_LINK_STATE);
4751 }
4752 if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
4753 dev_warn(hub_dev,
4754 "config error on port %d\n",
4755 i);
Lan Tianyuad493e52013-01-23 04:26:30 +08004756 usb_clear_port_feature(hub->hdev, i,
John Youndbe79bb2001-09-17 00:00:00 -07004757 USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
4758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004759
Andiry Xu5e467f62011-04-27 18:07:54 +08004760 /* Warm reset a USB3 protocol port if it's in
4761 * SS.Inactive state.
4762 */
Stanislaw Ledwon8bea2bd2012-06-18 15:20:00 +02004763 if (hub_port_warm_reset_required(hub, portstatus)) {
Sarah Sharp65bdac52012-11-14 17:58:04 -08004764 int status;
Sarah Sharpd3b9d7a2012-11-01 11:20:44 -07004765 struct usb_device *udev =
4766 hub->ports[i - 1]->child;
Sarah Sharp65bdac52012-11-14 17:58:04 -08004767
Andiry Xu5e467f62011-04-27 18:07:54 +08004768 dev_dbg(hub_dev, "warm reset port %d\n", i);
Sarah Sharpd3b9d7a2012-11-01 11:20:44 -07004769 if (!udev) {
4770 status = hub_port_reset(hub, i,
4771 NULL, HUB_BH_RESET_TIME,
4772 true);
4773 if (status < 0)
4774 hub_port_disable(hub, i, 1);
4775 } else {
4776 usb_lock_device(udev);
4777 status = usb_reset_device(udev);
4778 usb_unlock_device(udev);
4779 }
Sarah Sharp65bdac52012-11-14 17:58:04 -08004780 connect_change = 0;
Andiry Xu5e467f62011-04-27 18:07:54 +08004781 }
4782
Linus Torvalds1da177e2005-04-16 15:20:36 -07004783 if (connect_change)
4784 hub_port_connect_change(hub, i,
4785 portstatus, portchange);
4786 } /* end for i */
4787
4788 /* deal with hub status changes */
4789 if (test_and_clear_bit(0, hub->event_bits) == 0)
4790 ; /* do nothing */
4791 else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
4792 dev_err (hub_dev, "get_hub_status failed\n");
4793 else {
4794 if (hubchange & HUB_CHANGE_LOCAL_POWER) {
4795 dev_dbg (hub_dev, "power change\n");
4796 clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
Alan Stern55c52712005-11-23 12:03:12 -05004797 if (hubstatus & HUB_STATUS_LOCAL_POWER)
4798 /* FIXME: Is this always true? */
Alan Stern55c52712005-11-23 12:03:12 -05004799 hub->limited_power = 1;
jidong xiao403fae72007-09-14 00:08:51 +08004800 else
4801 hub->limited_power = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004802 }
4803 if (hubchange & HUB_CHANGE_OVERCURRENT) {
Paul Bolle752d57a2011-03-11 18:03:52 +01004804 u16 status = 0;
4805 u16 unused;
4806
4807 dev_dbg(hub_dev, "over-current change\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004808 clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
Paul Bolle752d57a2011-03-11 18:03:52 +01004809 msleep(500); /* Cool down */
Alan Stern8520f382008-09-22 14:44:26 -04004810 hub_power_on(hub, true);
Paul Bolle752d57a2011-03-11 18:03:52 +01004811 hub_hub_status(hub, &status, &unused);
4812 if (status & HUB_STATUS_OVERCURRENT)
4813 dev_err(hub_dev, "over-current "
4814 "condition\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004815 }
4816 }
4817
Alan Stern8e4ceb32009-12-07 13:01:37 -05004818 loop_autopm:
4819 /* Balance the usb_autopm_get_interface() above */
4820 usb_autopm_put_interface_no_suspend(intf);
4821 loop:
4822 /* Balance the usb_autopm_get_interface_no_resume() in
4823 * kick_khubd() and allow autosuspend.
4824 */
4825 usb_autopm_put_interface(intf);
Alan Stern9bbdf1e2010-01-08 12:57:28 -05004826 loop_disconnected:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004827 usb_unlock_device(hdev);
Alan Sterne8054852007-05-04 11:55:11 -04004828 kref_put(&hub->kref, hub_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004829
4830 } /* end while (1) */
4831}
4832
4833static int hub_thread(void *__unused)
4834{
Alan Stern3bb1af52008-03-03 15:15:36 -05004835 /* khubd needs to be freezable to avoid intefering with USB-PERSIST
4836 * port handover. Otherwise it might see that a full-speed device
4837 * was gone before the EHCI controller had handed its port over to
4838 * the companion full-speed controller.
4839 */
Rafael J. Wysocki83144182007-07-17 04:03:35 -07004840 set_freezable();
Alan Stern3bb1af52008-03-03 15:15:36 -05004841
Linus Torvalds1da177e2005-04-16 15:20:36 -07004842 do {
4843 hub_events();
Rafael J. Wysockie42837b2007-10-18 03:04:45 -07004844 wait_event_freezable(khubd_wait,
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004845 !list_empty(&hub_event_list) ||
4846 kthread_should_stop());
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004847 } while (!kthread_should_stop() || !list_empty(&hub_event_list));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004848
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004849 pr_debug("%s: khubd exiting\n", usbcore_name);
4850 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004851}
4852
Németh Márton1e927d92010-01-10 15:34:53 +01004853static const struct usb_device_id hub_id_table[] = {
Ming Leie6f30de2012-10-24 11:59:24 +08004854 { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
4855 | USB_DEVICE_ID_MATCH_INT_CLASS,
4856 .idVendor = USB_VENDOR_GENESYS_LOGIC,
4857 .bInterfaceClass = USB_CLASS_HUB,
4858 .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
Linus Torvalds1da177e2005-04-16 15:20:36 -07004859 { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
4860 .bDeviceClass = USB_CLASS_HUB},
4861 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
4862 .bInterfaceClass = USB_CLASS_HUB},
4863 { } /* Terminating entry */
4864};
4865
4866MODULE_DEVICE_TABLE (usb, hub_id_table);
4867
4868static struct usb_driver hub_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004869 .name = "hub",
4870 .probe = hub_probe,
4871 .disconnect = hub_disconnect,
4872 .suspend = hub_suspend,
4873 .resume = hub_resume,
Alan Sternf07600c2007-05-30 15:38:16 -04004874 .reset_resume = hub_reset_resume,
Alan Stern7de18d82006-06-01 13:37:24 -04004875 .pre_reset = hub_pre_reset,
4876 .post_reset = hub_post_reset,
Andi Kleenc532b292010-06-01 23:04:41 +02004877 .unlocked_ioctl = hub_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004878 .id_table = hub_id_table,
Alan Stern40f122f2006-11-09 14:44:33 -05004879 .supports_autosuspend = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004880};
4881
4882int usb_hub_init(void)
4883{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004884 if (usb_register(&hub_driver) < 0) {
4885 printk(KERN_ERR "%s: can't register hub driver\n",
4886 usbcore_name);
4887 return -1;
4888 }
4889
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004890 khubd_task = kthread_run(hub_thread, NULL, "khubd");
4891 if (!IS_ERR(khubd_task))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004892 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004893
4894 /* Fall through if kernel_thread failed */
4895 usb_deregister(&hub_driver);
4896 printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);
4897
4898 return -1;
4899}
4900
4901void usb_hub_cleanup(void)
4902{
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004903 kthread_stop(khubd_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004904
4905 /*
4906 * Hub resources are freed for us by usb_deregister. It calls
4907 * usb_driver_purge on every device which in turn calls that
4908 * devices disconnect function if it is using this driver.
4909 * The hub_disconnect function takes care of releasing the
4910 * individual hub resources. -greg
4911 */
4912 usb_deregister(&hub_driver);
4913} /* usb_hub_cleanup() */
4914
Alan Sterneb764c42008-03-03 15:16:04 -05004915static int descriptors_changed(struct usb_device *udev,
4916 struct usb_device_descriptor *old_device_descriptor)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004917{
Alan Sterneb764c42008-03-03 15:16:04 -05004918 int changed = 0;
4919 unsigned index;
4920 unsigned serial_len = 0;
4921 unsigned len;
4922 unsigned old_length;
4923 int length;
4924 char *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004925
Alan Sterneb764c42008-03-03 15:16:04 -05004926 if (memcmp(&udev->descriptor, old_device_descriptor,
4927 sizeof(*old_device_descriptor)) != 0)
4928 return 1;
4929
4930 /* Since the idVendor, idProduct, and bcdDevice values in the
4931 * device descriptor haven't changed, we will assume the
4932 * Manufacturer and Product strings haven't changed either.
4933 * But the SerialNumber string could be different (e.g., a
4934 * different flash card of the same brand).
4935 */
4936 if (udev->serial)
4937 serial_len = strlen(udev->serial) + 1;
4938
4939 len = serial_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004940 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
Alan Sterneb764c42008-03-03 15:16:04 -05004941 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
4942 len = max(len, old_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004943 }
Alan Sterneb764c42008-03-03 15:16:04 -05004944
Oliver Neukum0cc1a512008-01-10 10:31:48 +01004945 buf = kmalloc(len, GFP_NOIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004946 if (buf == NULL) {
4947 dev_err(&udev->dev, "no mem to re-read configs after reset\n");
4948 /* assume the worst */
4949 return 1;
4950 }
4951 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
Alan Sterneb764c42008-03-03 15:16:04 -05004952 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004953 length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
4954 old_length);
Alan Sterneb764c42008-03-03 15:16:04 -05004955 if (length != old_length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004956 dev_dbg(&udev->dev, "config index %d, error %d\n",
4957 index, length);
Alan Sterneb764c42008-03-03 15:16:04 -05004958 changed = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004959 break;
4960 }
4961 if (memcmp (buf, udev->rawdescriptors[index], old_length)
4962 != 0) {
4963 dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
Alan Sterneb764c42008-03-03 15:16:04 -05004964 index,
4965 ((struct usb_config_descriptor *) buf)->
4966 bConfigurationValue);
4967 changed = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004968 break;
4969 }
4970 }
Alan Sterneb764c42008-03-03 15:16:04 -05004971
4972 if (!changed && serial_len) {
4973 length = usb_string(udev, udev->descriptor.iSerialNumber,
4974 buf, serial_len);
4975 if (length + 1 != serial_len) {
4976 dev_dbg(&udev->dev, "serial string error %d\n",
4977 length);
4978 changed = 1;
4979 } else if (memcmp(buf, udev->serial, length) != 0) {
4980 dev_dbg(&udev->dev, "serial string changed\n");
4981 changed = 1;
4982 }
4983 }
4984
Linus Torvalds1da177e2005-04-16 15:20:36 -07004985 kfree(buf);
Alan Sterneb764c42008-03-03 15:16:04 -05004986 return changed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004987}
4988
4989/**
Ming Lei742120c2008-06-18 22:00:29 +08004990 * usb_reset_and_verify_device - perform a USB port reset to reinitialize a device
Linus Torvalds1da177e2005-04-16 15:20:36 -07004991 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
4992 *
Alan Stern79efa092006-06-01 13:33:42 -04004993 * WARNING - don't use this routine to reset a composite device
4994 * (one with multiple interfaces owned by separate drivers)!
Ming Lei742120c2008-06-18 22:00:29 +08004995 * Use usb_reset_device() instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004996 *
4997 * Do a port reset, reassign the device's address, and establish its
4998 * former operating configuration. If the reset fails, or the device's
4999 * descriptors change from their values before the reset, or the original
5000 * configuration and altsettings cannot be restored, a flag will be set
5001 * telling khubd to pretend the device has been disconnected and then
5002 * re-connected. All drivers will be unbound, and the device will be
5003 * re-enumerated and probed all over again.
5004 *
5005 * Returns 0 if the reset succeeded, -ENODEV if the device has been
5006 * flagged for logical disconnection, or some other negative error code
5007 * if the reset wasn't even attempted.
5008 *
5009 * The caller must own the device lock. For example, it's safe to use
5010 * this from a driver probe() routine after downloading new firmware.
5011 * For calls that might not occur during probe(), drivers should lock
5012 * the device using usb_lock_device_for_reset().
Alan Stern6bc6cff2007-05-04 11:53:03 -04005013 *
5014 * Locking exception: This routine may also be called from within an
5015 * autoresume handler. Such usage won't conflict with other tasks
5016 * holding the device lock because these tasks should always call
5017 * usb_autopm_resume_device(), thereby preventing any unwanted autoresume.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005018 */
Ming Lei742120c2008-06-18 22:00:29 +08005019static int usb_reset_and_verify_device(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005020{
5021 struct usb_device *parent_hdev = udev->parent;
5022 struct usb_hub *parent_hub;
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005023 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005024 struct usb_device_descriptor descriptor = udev->descriptor;
Alan Stern12c3da32005-11-23 12:09:52 -05005025 int i, ret = 0;
5026 int port1 = udev->portnum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005027
5028 if (udev->state == USB_STATE_NOTATTACHED ||
5029 udev->state == USB_STATE_SUSPENDED) {
5030 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5031 udev->state);
5032 return -EINVAL;
5033 }
5034
5035 if (!parent_hdev) {
Wolfram Sang4bec9912010-08-29 18:17:14 +02005036 /* this requires hcd-specific logic; see ohci_restart() */
Harvey Harrison441b62c2008-03-03 16:08:34 -08005037 dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005038 return -EISDIR;
5039 }
Lan Tianyuad493e52013-01-23 04:26:30 +08005040 parent_hub = usb_hub_to_struct_hub(parent_hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005041
Sarah Sharpf74631e2012-06-25 12:08:08 -07005042 /* Disable LPM and LTM while we reset the device and reinstall the alt
5043 * settings. Device-initiated LPM settings, and system exit latency
5044 * settings are cleared when the device is reset, so we have to set
5045 * them up again.
Sarah Sharp6d1d0512012-07-03 22:49:04 -07005046 */
5047 ret = usb_unlocked_disable_lpm(udev);
5048 if (ret) {
5049 dev_err(&udev->dev, "%s Failed to disable LPM\n.", __func__);
5050 goto re_enumerate;
5051 }
Sarah Sharpf74631e2012-06-25 12:08:08 -07005052 ret = usb_disable_ltm(udev);
5053 if (ret) {
5054 dev_err(&udev->dev, "%s Failed to disable LTM\n.",
5055 __func__);
5056 goto re_enumerate;
5057 }
Sarah Sharp6d1d0512012-07-03 22:49:04 -07005058
Linus Torvalds1da177e2005-04-16 15:20:36 -07005059 set_bit(port1, parent_hub->busy_bits);
5060 for (i = 0; i < SET_CONFIG_TRIES; ++i) {
5061
5062 /* ep0 maxpacket size may change; let the HCD know about it.
5063 * Other endpoints will be handled by re-enumeration. */
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07005064 usb_ep0_reinit(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005065 ret = hub_port_init(parent_hub, udev, port1, i);
Alan Sterndd4dd192007-05-04 11:55:54 -04005066 if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005067 break;
5068 }
5069 clear_bit(port1, parent_hub->busy_bits);
Alan Sternd5cbad42006-08-11 16:52:39 -04005070
Linus Torvalds1da177e2005-04-16 15:20:36 -07005071 if (ret < 0)
5072 goto re_enumerate;
5073
5074 /* Device might have changed firmware (DFU or similar) */
Alan Sterneb764c42008-03-03 15:16:04 -05005075 if (descriptors_changed(udev, &descriptor)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005076 dev_info(&udev->dev, "device firmware changed\n");
5077 udev->descriptor = descriptor; /* for disconnect() calls */
5078 goto re_enumerate;
5079 }
Alan Stern4fe03872009-02-26 10:21:02 -05005080
5081 /* Restore the device's previous configuration */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005082 if (!udev->actconfig)
5083 goto done;
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005084
Sarah Sharpd673bfc2010-10-15 08:55:24 -07005085 mutex_lock(hcd->bandwidth_mutex);
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005086 ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
5087 if (ret < 0) {
5088 dev_warn(&udev->dev,
5089 "Busted HC? Not enough HCD resources for "
5090 "old configuration.\n");
Sarah Sharpd673bfc2010-10-15 08:55:24 -07005091 mutex_unlock(hcd->bandwidth_mutex);
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005092 goto re_enumerate;
5093 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005094 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
5095 USB_REQ_SET_CONFIGURATION, 0,
5096 udev->actconfig->desc.bConfigurationValue, 0,
5097 NULL, 0, USB_CTRL_SET_TIMEOUT);
5098 if (ret < 0) {
5099 dev_err(&udev->dev,
5100 "can't restore configuration #%d (error=%d)\n",
5101 udev->actconfig->desc.bConfigurationValue, ret);
Sarah Sharpd673bfc2010-10-15 08:55:24 -07005102 mutex_unlock(hcd->bandwidth_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005103 goto re_enumerate;
5104 }
Sarah Sharpd673bfc2010-10-15 08:55:24 -07005105 mutex_unlock(hcd->bandwidth_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005106 usb_set_device_state(udev, USB_STATE_CONFIGURED);
5107
Alan Stern4fe03872009-02-26 10:21:02 -05005108 /* Put interfaces back into the same altsettings as before.
5109 * Don't bother to send the Set-Interface request for interfaces
5110 * that were already in altsetting 0; besides being unnecessary,
5111 * many devices can't handle it. Instead just reset the host-side
5112 * endpoint state.
5113 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005114 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005115 struct usb_host_config *config = udev->actconfig;
5116 struct usb_interface *intf = config->interface[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07005117 struct usb_interface_descriptor *desc;
5118
Linus Torvalds1da177e2005-04-16 15:20:36 -07005119 desc = &intf->cur_altsetting->desc;
Alan Stern4fe03872009-02-26 10:21:02 -05005120 if (desc->bAlternateSetting == 0) {
5121 usb_disable_interface(udev, intf, true);
5122 usb_enable_interface(udev, intf, true);
5123 ret = 0;
5124 } else {
Sarah Sharp04a723e2010-01-06 10:16:51 -08005125 /* Let the bandwidth allocation function know that this
5126 * device has been reset, and it will have to use
5127 * alternate setting 0 as the current alternate setting.
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005128 */
Sarah Sharp04a723e2010-01-06 10:16:51 -08005129 intf->resetting_device = 1;
Alan Stern4fe03872009-02-26 10:21:02 -05005130 ret = usb_set_interface(udev, desc->bInterfaceNumber,
5131 desc->bAlternateSetting);
Sarah Sharp04a723e2010-01-06 10:16:51 -08005132 intf->resetting_device = 0;
Alan Stern4fe03872009-02-26 10:21:02 -05005133 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005134 if (ret < 0) {
5135 dev_err(&udev->dev, "failed to restore interface %d "
5136 "altsetting %d (error=%d)\n",
5137 desc->bInterfaceNumber,
5138 desc->bAlternateSetting,
5139 ret);
5140 goto re_enumerate;
5141 }
5142 }
5143
5144done:
Sarah Sharpf74631e2012-06-25 12:08:08 -07005145 /* Now that the alt settings are re-installed, enable LTM and LPM. */
Alan Stern78d9a482008-06-23 16:00:40 -04005146 usb_unlocked_enable_lpm(udev);
Sarah Sharpf74631e2012-06-25 12:08:08 -07005147 usb_enable_ltm(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005148 return 0;
5149
5150re_enumerate:
Sarah Sharp6d1d0512012-07-03 22:49:04 -07005151 /* LPM state doesn't matter when we're about to destroy the device. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005152 hub_port_logical_disconnect(parent_hub, port1);
5153 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005154}
5155
5156/**
5157 * usb_reset_device - warn interface drivers and perform a USB port reset
5158 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
5159 *
Alan Stern79efa092006-06-01 13:33:42 -04005160 * Warns all drivers bound to registered interfaces (using their pre_reset
5161 * method), performs the port reset, and then lets the drivers know that
Ming Lei742120c2008-06-18 22:00:29 +08005162 * the reset is over (using their post_reset method).
Alan Stern79efa092006-06-01 13:33:42 -04005163 *
Alan Stern79efa092006-06-01 13:33:42 -04005164 * Return value is the same as for usb_reset_and_verify_device().
5165 *
5166 * The caller must own the device lock. For example, it's safe to use
5167 * this from a driver probe() routine after downloading new firmware.
5168 * For calls that might not occur during probe(), drivers should lock
Ming Lei742120c2008-06-18 22:00:29 +08005169 * the device using usb_lock_device_for_reset().
Alan Stern79efa092006-06-01 13:33:42 -04005170 *
5171 * If an interface is currently being probed or disconnected, we assume
5172 * its driver knows how to handle resets. For all other interfaces,
5173 * if the driver doesn't have pre_reset and post_reset methods then
5174 * we attempt to unbind it and rebind afterward.
Alan Stern79efa092006-06-01 13:33:42 -04005175 */
Ming Lei742120c2008-06-18 22:00:29 +08005176int usb_reset_device(struct usb_device *udev)
Alan Stern79efa092006-06-01 13:33:42 -04005177{
5178 int ret;
Alan Stern852c4b42007-12-03 15:44:29 -05005179 int i;
Ming Lei4d769de2013-02-22 16:34:22 -08005180 unsigned int noio_flag;
Alan Stern79efa092006-06-01 13:33:42 -04005181 struct usb_host_config *config = udev->actconfig;
5182
5183 if (udev->state == USB_STATE_NOTATTACHED ||
5184 udev->state == USB_STATE_SUSPENDED) {
5185 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5186 udev->state);
5187 return -EINVAL;
5188 }
5189
Ming Lei4d769de2013-02-22 16:34:22 -08005190 /*
5191 * Don't allocate memory with GFP_KERNEL in current
5192 * context to avoid possible deadlock if usb mass
5193 * storage interface or usbnet interface(iSCSI case)
5194 * is included in current configuration. The easist
5195 * approach is to do it for every device reset,
5196 * because the device 'memalloc_noio' flag may have
5197 * not been set before reseting the usb device.
5198 */
5199 noio_flag = memalloc_noio_save();
5200
Alan Stern645daaa2006-08-30 15:47:02 -04005201 /* Prevent autosuspend during the reset */
Alan Stern94fcda12006-11-20 11:38:46 -05005202 usb_autoresume_device(udev);
Alan Stern645daaa2006-08-30 15:47:02 -04005203
Alan Stern79efa092006-06-01 13:33:42 -04005204 if (config) {
Alan Stern79efa092006-06-01 13:33:42 -04005205 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
Alan Stern852c4b42007-12-03 15:44:29 -05005206 struct usb_interface *cintf = config->interface[i];
5207 struct usb_driver *drv;
Alan Stern78d9a482008-06-23 16:00:40 -04005208 int unbind = 0;
Alan Stern852c4b42007-12-03 15:44:29 -05005209
5210 if (cintf->dev.driver) {
Alan Stern79efa092006-06-01 13:33:42 -04005211 drv = to_usb_driver(cintf->dev.driver);
Alan Stern78d9a482008-06-23 16:00:40 -04005212 if (drv->pre_reset && drv->post_reset)
5213 unbind = (drv->pre_reset)(cintf);
5214 else if (cintf->condition ==
5215 USB_INTERFACE_BOUND)
5216 unbind = 1;
5217 if (unbind)
5218 usb_forced_unbind_intf(cintf);
Alan Stern79efa092006-06-01 13:33:42 -04005219 }
5220 }
5221 }
5222
Ming Lei742120c2008-06-18 22:00:29 +08005223 ret = usb_reset_and_verify_device(udev);
Alan Stern79efa092006-06-01 13:33:42 -04005224
5225 if (config) {
Alan Stern79efa092006-06-01 13:33:42 -04005226 for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
Alan Stern852c4b42007-12-03 15:44:29 -05005227 struct usb_interface *cintf = config->interface[i];
5228 struct usb_driver *drv;
Alan Stern78d9a482008-06-23 16:00:40 -04005229 int rebind = cintf->needs_binding;
Alan Stern852c4b42007-12-03 15:44:29 -05005230
Alan Stern78d9a482008-06-23 16:00:40 -04005231 if (!rebind && cintf->dev.driver) {
Alan Stern79efa092006-06-01 13:33:42 -04005232 drv = to_usb_driver(cintf->dev.driver);
5233 if (drv->post_reset)
Alan Stern78d9a482008-06-23 16:00:40 -04005234 rebind = (drv->post_reset)(cintf);
5235 else if (cintf->condition ==
5236 USB_INTERFACE_BOUND)
5237 rebind = 1;
Alan Stern79efa092006-06-01 13:33:42 -04005238 }
Alan Stern6c640942008-10-21 15:40:03 -04005239 if (ret == 0 && rebind)
Alan Stern78d9a482008-06-23 16:00:40 -04005240 usb_rebind_intf(cintf);
Alan Stern79efa092006-06-01 13:33:42 -04005241 }
5242 }
5243
Alan Stern94fcda12006-11-20 11:38:46 -05005244 usb_autosuspend_device(udev);
Ming Lei4d769de2013-02-22 16:34:22 -08005245 memalloc_noio_restore(noio_flag);
Alan Stern79efa092006-06-01 13:33:42 -04005246 return ret;
5247}
Ming Lei742120c2008-06-18 22:00:29 +08005248EXPORT_SYMBOL_GPL(usb_reset_device);
Inaky Perez-Gonzalezdc023dc2008-11-13 10:31:35 -08005249
5250
5251/**
5252 * usb_queue_reset_device - Reset a USB device from an atomic context
5253 * @iface: USB interface belonging to the device to reset
5254 *
5255 * This function can be used to reset a USB device from an atomic
5256 * context, where usb_reset_device() won't work (as it blocks).
5257 *
5258 * Doing a reset via this method is functionally equivalent to calling
5259 * usb_reset_device(), except for the fact that it is delayed to a
5260 * workqueue. This means that any drivers bound to other interfaces
5261 * might be unbound, as well as users from usbfs in user space.
5262 *
5263 * Corner cases:
5264 *
5265 * - Scheduling two resets at the same time from two different drivers
5266 * attached to two different interfaces of the same device is
5267 * possible; depending on how the driver attached to each interface
5268 * handles ->pre_reset(), the second reset might happen or not.
5269 *
5270 * - If a driver is unbound and it had a pending reset, the reset will
5271 * be cancelled.
5272 *
5273 * - This function can be called during .probe() or .disconnect()
5274 * times. On return from .disconnect(), any pending resets will be
5275 * cancelled.
5276 *
5277 * There is no no need to lock/unlock the @reset_ws as schedule_work()
5278 * does its own.
5279 *
5280 * NOTE: We don't do any reference count tracking because it is not
5281 * needed. The lifecycle of the work_struct is tied to the
5282 * usb_interface. Before destroying the interface we cancel the
5283 * work_struct, so the fact that work_struct is queued and or
5284 * running means the interface (and thus, the device) exist and
5285 * are referenced.
5286 */
5287void usb_queue_reset_device(struct usb_interface *iface)
5288{
5289 schedule_work(&iface->reset_ws);
5290}
5291EXPORT_SYMBOL_GPL(usb_queue_reset_device);
Lan Tianyuff823c792012-09-05 13:44:32 +08005292
5293/**
5294 * usb_hub_find_child - Get the pointer of child device
5295 * attached to the port which is specified by @port1.
5296 * @hdev: USB device belonging to the usb hub
5297 * @port1: port num to indicate which port the child device
5298 * is attached to.
5299 *
5300 * USB drivers call this function to get hub's child device
5301 * pointer.
5302 *
5303 * Return NULL if input param is invalid and
5304 * child's usb_device pointer if non-NULL.
5305 */
5306struct usb_device *usb_hub_find_child(struct usb_device *hdev,
5307 int port1)
5308{
Lan Tianyuad493e52013-01-23 04:26:30 +08005309 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Lan Tianyuff823c792012-09-05 13:44:32 +08005310
5311 if (port1 < 1 || port1 > hdev->maxchild)
5312 return NULL;
5313 return hub->ports[port1 - 1]->child;
5314}
5315EXPORT_SYMBOL_GPL(usb_hub_find_child);
Lan Tianyud5575422012-09-05 13:44:33 +08005316
Lan Tianyu05f91682012-09-05 13:44:34 +08005317/**
5318 * usb_set_hub_port_connect_type - set hub port connect type.
5319 * @hdev: USB device belonging to the usb hub
5320 * @port1: port num of the port
5321 * @type: connect type of the port
5322 */
5323void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
5324 enum usb_port_connect_type type)
5325{
Lan Tianyuad493e52013-01-23 04:26:30 +08005326 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Lan Tianyu05f91682012-09-05 13:44:34 +08005327
5328 hub->ports[port1 - 1]->connect_type = type;
5329}
5330
5331/**
5332 * usb_get_hub_port_connect_type - Get the port's connect type
5333 * @hdev: USB device belonging to the usb hub
5334 * @port1: port num of the port
5335 *
5336 * Return connect type of the port and if input params are
5337 * invalid, return USB_PORT_CONNECT_TYPE_UNKNOWN.
5338 */
5339enum usb_port_connect_type
5340usb_get_hub_port_connect_type(struct usb_device *hdev, int port1)
5341{
Lan Tianyuad493e52013-01-23 04:26:30 +08005342 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Lan Tianyu05f91682012-09-05 13:44:34 +08005343
5344 return hub->ports[port1 - 1]->connect_type;
5345}
5346
Lan Tianyud2123fd2013-01-21 22:18:00 +08005347void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
5348 struct usb_hub_descriptor *desc)
5349{
5350 enum usb_port_connect_type connect_type;
5351 int i;
5352
5353 if (!hub_is_superspeed(hdev)) {
5354 for (i = 1; i <= hdev->maxchild; i++) {
5355 connect_type = usb_get_hub_port_connect_type(hdev, i);
5356
5357 if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
5358 u8 mask = 1 << (i%8);
5359
5360 if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
5361 dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
5362 i);
5363 desc->u.hs.DeviceRemovable[i/8] |= mask;
5364 }
5365 }
5366 }
5367 } else {
5368 u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);
5369
5370 for (i = 1; i <= hdev->maxchild; i++) {
5371 connect_type = usb_get_hub_port_connect_type(hdev, i);
5372
5373 if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
5374 u16 mask = 1 << i;
5375
5376 if (!(port_removable & mask)) {
5377 dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
5378 i);
5379 port_removable |= mask;
5380 }
5381 }
5382 }
5383
5384 desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
5385 }
5386}
5387
Lan Tianyud5575422012-09-05 13:44:33 +08005388#ifdef CONFIG_ACPI
5389/**
5390 * usb_get_hub_port_acpi_handle - Get the usb port's acpi handle
5391 * @hdev: USB device belonging to the usb hub
5392 * @port1: port num of the port
5393 *
5394 * Return port's acpi handle if successful, NULL if params are
5395 * invaild.
5396 */
5397acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
5398 int port1)
5399{
Lan Tianyuad493e52013-01-23 04:26:30 +08005400 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Lan Tianyud5575422012-09-05 13:44:33 +08005401
5402 return DEVICE_ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
5403}
5404#endif