blob: d3a1d79d663dd30f51fe28047b7432d544fa70fb [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)
Matthias Beyer469271f2013-10-10 23:41:27 +0200123 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
Xenia Ragiadakou9df89d82013-08-31 18:09:12 +0300138int usb_device_supports_lpm(struct usb_device *udev)
Sarah Sharpd9b20992012-02-20 08:31:26 -0800139{
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 }
Xenia Ragiadakou9df89d82013-08-31 18:09:12 +0300159
160 /* udev is root hub */
161 if (!udev->parent)
162 return 1;
163
Sarah Sharp51e0a012012-02-20 12:02:19 -0800164 if (udev->parent->lpm_capable)
165 return 1;
166
167 dev_warn(&udev->dev, "Parent hub missing LPM exit latency info. "
168 "Power management will be impacted.\n");
Sarah Sharpd9b20992012-02-20 08:31:26 -0800169 return 0;
170}
171
Sarah Sharp51e0a012012-02-20 12:02:19 -0800172/*
173 * Set the Maximum Exit Latency (MEL) for the host to initiate a transition from
174 * either U1 or U2.
175 */
176static void usb_set_lpm_mel(struct usb_device *udev,
177 struct usb3_lpm_parameters *udev_lpm_params,
178 unsigned int udev_exit_latency,
179 struct usb_hub *hub,
180 struct usb3_lpm_parameters *hub_lpm_params,
181 unsigned int hub_exit_latency)
182{
183 unsigned int total_mel;
184 unsigned int device_mel;
185 unsigned int hub_mel;
186
187 /*
188 * Calculate the time it takes to transition all links from the roothub
189 * to the parent hub into U0. The parent hub must then decode the
190 * packet (hub header decode latency) to figure out which port it was
191 * bound for.
192 *
193 * The Hub Header decode latency is expressed in 0.1us intervals (0x1
194 * means 0.1us). Multiply that by 100 to get nanoseconds.
195 */
196 total_mel = hub_lpm_params->mel +
197 (hub->descriptor->u.ss.bHubHdrDecLat * 100);
198
199 /*
200 * How long will it take to transition the downstream hub's port into
201 * U0? The greater of either the hub exit latency or the device exit
202 * latency.
203 *
204 * The BOS U1/U2 exit latencies are expressed in 1us intervals.
205 * Multiply that by 1000 to get nanoseconds.
206 */
207 device_mel = udev_exit_latency * 1000;
208 hub_mel = hub_exit_latency * 1000;
209 if (device_mel > hub_mel)
210 total_mel += device_mel;
211 else
212 total_mel += hub_mel;
213
214 udev_lpm_params->mel = total_mel;
215}
216
217/*
218 * Set the maximum Device to Host Exit Latency (PEL) for the device to initiate
219 * a transition from either U1 or U2.
220 */
221static void usb_set_lpm_pel(struct usb_device *udev,
222 struct usb3_lpm_parameters *udev_lpm_params,
223 unsigned int udev_exit_latency,
224 struct usb_hub *hub,
225 struct usb3_lpm_parameters *hub_lpm_params,
226 unsigned int hub_exit_latency,
227 unsigned int port_to_port_exit_latency)
228{
229 unsigned int first_link_pel;
230 unsigned int hub_pel;
231
232 /*
233 * First, the device sends an LFPS to transition the link between the
234 * device and the parent hub into U0. The exit latency is the bigger of
235 * the device exit latency or the hub exit latency.
236 */
237 if (udev_exit_latency > hub_exit_latency)
238 first_link_pel = udev_exit_latency * 1000;
239 else
240 first_link_pel = hub_exit_latency * 1000;
241
242 /*
243 * When the hub starts to receive the LFPS, there is a slight delay for
244 * it to figure out that one of the ports is sending an LFPS. Then it
245 * will forward the LFPS to its upstream link. The exit latency is the
246 * delay, plus the PEL that we calculated for this hub.
247 */
248 hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel;
249
250 /*
251 * According to figure C-7 in the USB 3.0 spec, the PEL for this device
252 * is the greater of the two exit latencies.
253 */
254 if (first_link_pel > hub_pel)
255 udev_lpm_params->pel = first_link_pel;
256 else
257 udev_lpm_params->pel = hub_pel;
258}
259
260/*
261 * Set the System Exit Latency (SEL) to indicate the total worst-case time from
262 * when a device initiates a transition to U0, until when it will receive the
263 * first packet from the host controller.
264 *
265 * Section C.1.5.1 describes the four components to this:
266 * - t1: device PEL
267 * - t2: time for the ERDY to make it from the device to the host.
268 * - t3: a host-specific delay to process the ERDY.
269 * - t4: time for the packet to make it from the host to the device.
270 *
271 * t3 is specific to both the xHCI host and the platform the host is integrated
272 * into. The Intel HW folks have said it's negligible, FIXME if a different
273 * vendor says otherwise.
274 */
275static void usb_set_lpm_sel(struct usb_device *udev,
276 struct usb3_lpm_parameters *udev_lpm_params)
277{
278 struct usb_device *parent;
279 unsigned int num_hubs;
280 unsigned int total_sel;
281
282 /* t1 = device PEL */
283 total_sel = udev_lpm_params->pel;
284 /* How many external hubs are in between the device & the root port. */
285 for (parent = udev->parent, num_hubs = 0; parent->parent;
286 parent = parent->parent)
287 num_hubs++;
288 /* t2 = 2.1us + 250ns * (num_hubs - 1) */
289 if (num_hubs > 0)
290 total_sel += 2100 + 250 * (num_hubs - 1);
291
292 /* t4 = 250ns * num_hubs */
293 total_sel += 250 * num_hubs;
294
295 udev_lpm_params->sel = total_sel;
296}
297
298static void usb_set_lpm_parameters(struct usb_device *udev)
299{
300 struct usb_hub *hub;
301 unsigned int port_to_port_delay;
302 unsigned int udev_u1_del;
303 unsigned int udev_u2_del;
304 unsigned int hub_u1_del;
305 unsigned int hub_u2_del;
306
307 if (!udev->lpm_capable || udev->speed != USB_SPEED_SUPER)
308 return;
309
Lan Tianyuad493e52013-01-23 04:26:30 +0800310 hub = usb_hub_to_struct_hub(udev->parent);
Sarah Sharp51e0a012012-02-20 12:02:19 -0800311 /* It doesn't take time to transition the roothub into U0, since it
312 * doesn't have an upstream link.
313 */
314 if (!hub)
315 return;
316
317 udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
Xenia Ragiadakou4d967992013-08-31 18:09:13 +0300318 udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
Sarah Sharp51e0a012012-02-20 12:02:19 -0800319 hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
Xenia Ragiadakou4d967992013-08-31 18:09:13 +0300320 hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
Sarah Sharp51e0a012012-02-20 12:02:19 -0800321
322 usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
323 hub, &udev->parent->u1_params, hub_u1_del);
324
325 usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del,
326 hub, &udev->parent->u2_params, hub_u2_del);
327
328 /*
329 * Appendix C, section C.2.2.2, says that there is a slight delay from
330 * when the parent hub notices the downstream port is trying to
331 * transition to U0 to when the hub initiates a U0 transition on its
332 * upstream port. The section says the delays are tPort2PortU1EL and
333 * tPort2PortU2EL, but it doesn't define what they are.
334 *
335 * The hub chapter, sections 10.4.2.4 and 10.4.2.5 seem to be talking
336 * about the same delays. Use the maximum delay calculations from those
337 * sections. For U1, it's tHubPort2PortExitLat, which is 1us max. For
338 * U2, it's tHubPort2PortExitLat + U2DevExitLat - U1DevExitLat. I
339 * assume the device exit latencies they are talking about are the hub
340 * exit latencies.
341 *
342 * What do we do if the U2 exit latency is less than the U1 exit
343 * latency? It's possible, although not likely...
344 */
345 port_to_port_delay = 1;
346
347 usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del,
348 hub, &udev->parent->u1_params, hub_u1_del,
349 port_to_port_delay);
350
351 if (hub_u2_del > hub_u1_del)
352 port_to_port_delay = 1 + hub_u2_del - hub_u1_del;
353 else
354 port_to_port_delay = 1 + hub_u1_del;
355
356 usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del,
357 hub, &udev->parent->u2_params, hub_u2_del,
358 port_to_port_delay);
359
360 /* Now that we've got PEL, calculate SEL. */
361 usb_set_lpm_sel(udev, &udev->u1_params);
362 usb_set_lpm_sel(udev, &udev->u2_params);
363}
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365/* USB 2.0 spec Section 11.24.4.5 */
John Youndbe79bb2001-09-17 00:00:00 -0700366static int get_hub_descriptor(struct usb_device *hdev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
John Youndbe79bb2001-09-17 00:00:00 -0700368 int i, ret, size;
369 unsigned dtype;
370
371 if (hub_is_superspeed(hdev)) {
372 dtype = USB_DT_SS_HUB;
373 size = USB_DT_SS_HUB_SIZE;
374 } else {
375 dtype = USB_DT_HUB;
376 size = sizeof(struct usb_hub_descriptor);
377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
379 for (i = 0; i < 3; i++) {
380 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
381 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
John Youndbe79bb2001-09-17 00:00:00 -0700382 dtype << 8, 0, data, size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 USB_CTRL_GET_TIMEOUT);
384 if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
385 return ret;
386 }
387 return -EINVAL;
388}
389
390/*
391 * USB 2.0 spec Section 11.24.2.1
392 */
393static int clear_hub_feature(struct usb_device *hdev, int feature)
394{
395 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
396 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
397}
398
399/*
400 * USB 2.0 spec Section 11.24.2.2
401 */
Lan Tianyuad493e52013-01-23 04:26:30 +0800402int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
404 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
405 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
406 NULL, 0, 1000);
407}
408
409/*
410 * USB 2.0 spec Section 11.24.2.13
411 */
412static int set_port_feature(struct usb_device *hdev, int port1, int feature)
413{
414 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
415 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
416 NULL, 0, 1000);
417}
418
419/*
420 * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
421 * for info about using port indicators
422 */
423static void set_port_led(
424 struct usb_hub *hub,
425 int port1,
426 int selector
427)
428{
429 int status = set_port_feature(hub->hdev, (selector << 8) | port1,
430 USB_PORT_FEAT_INDICATOR);
431 if (status < 0)
432 dev_dbg (hub->intfdev,
433 "port %d indicator %s status %d\n",
434 port1,
435 ({ char *s; switch (selector) {
436 case HUB_LED_AMBER: s = "amber"; break;
437 case HUB_LED_GREEN: s = "green"; break;
438 case HUB_LED_OFF: s = "off"; break;
439 case HUB_LED_AUTO: s = "auto"; break;
440 default: s = "??"; break;
Joe Perches2b84f922013-10-08 16:01:37 -0700441 } s; }),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 status);
443}
444
445#define LED_CYCLE_PERIOD ((2*HZ)/3)
446
David Howellsc4028952006-11-22 14:57:56 +0000447static void led_work (struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448{
David Howellsc4028952006-11-22 14:57:56 +0000449 struct usb_hub *hub =
450 container_of(work, struct usb_hub, leds.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 struct usb_device *hdev = hub->hdev;
452 unsigned i;
453 unsigned changed = 0;
454 int cursor = -1;
455
456 if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
457 return;
458
Krzysztof Mazur3bbc47d2013-08-22 14:49:40 +0200459 for (i = 0; i < hdev->maxchild; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 unsigned selector, mode;
461
462 /* 30%-50% duty cycle */
463
464 switch (hub->indicator[i]) {
465 /* cycle marker */
466 case INDICATOR_CYCLE:
467 cursor = i;
468 selector = HUB_LED_AUTO;
469 mode = INDICATOR_AUTO;
470 break;
471 /* blinking green = sw attention */
472 case INDICATOR_GREEN_BLINK:
473 selector = HUB_LED_GREEN;
474 mode = INDICATOR_GREEN_BLINK_OFF;
475 break;
476 case INDICATOR_GREEN_BLINK_OFF:
477 selector = HUB_LED_OFF;
478 mode = INDICATOR_GREEN_BLINK;
479 break;
480 /* blinking amber = hw attention */
481 case INDICATOR_AMBER_BLINK:
482 selector = HUB_LED_AMBER;
483 mode = INDICATOR_AMBER_BLINK_OFF;
484 break;
485 case INDICATOR_AMBER_BLINK_OFF:
486 selector = HUB_LED_OFF;
487 mode = INDICATOR_AMBER_BLINK;
488 break;
489 /* blink green/amber = reserved */
490 case INDICATOR_ALT_BLINK:
491 selector = HUB_LED_GREEN;
492 mode = INDICATOR_ALT_BLINK_OFF;
493 break;
494 case INDICATOR_ALT_BLINK_OFF:
495 selector = HUB_LED_AMBER;
496 mode = INDICATOR_ALT_BLINK;
497 break;
498 default:
499 continue;
500 }
501 if (selector != HUB_LED_AUTO)
502 changed = 1;
503 set_port_led(hub, i + 1, selector);
504 hub->indicator[i] = mode;
505 }
506 if (!changed && blinkenlights) {
507 cursor++;
Krzysztof Mazur3bbc47d2013-08-22 14:49:40 +0200508 cursor %= hdev->maxchild;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 set_port_led(hub, cursor + 1, HUB_LED_GREEN);
510 hub->indicator[cursor] = INDICATOR_CYCLE;
511 changed++;
512 }
513 if (changed)
514 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
515}
516
517/* use a short timeout for hub/port status fetches */
518#define USB_STS_TIMEOUT 1000
519#define USB_STS_RETRIES 5
520
521/*
522 * USB 2.0 spec Section 11.24.2.6
523 */
524static int get_hub_status(struct usb_device *hdev,
525 struct usb_hub_status *data)
526{
527 int i, status = -ETIMEDOUT;
528
Libor Pechacek3824c1d2011-05-20 14:53:25 +0200529 for (i = 0; i < USB_STS_RETRIES &&
530 (status == -ETIMEDOUT || status == -EPIPE); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
532 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
533 data, sizeof(*data), USB_STS_TIMEOUT);
534 }
535 return status;
536}
537
538/*
539 * USB 2.0 spec Section 11.24.2.7
540 */
541static int get_port_status(struct usb_device *hdev, int port1,
542 struct usb_port_status *data)
543{
544 int i, status = -ETIMEDOUT;
545
Libor Pechacek3824c1d2011-05-20 14:53:25 +0200546 for (i = 0; i < USB_STS_RETRIES &&
547 (status == -ETIMEDOUT || status == -EPIPE); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
549 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
550 data, sizeof(*data), USB_STS_TIMEOUT);
551 }
552 return status;
553}
554
Alan Stern3eb14912008-03-03 15:15:43 -0500555static int hub_port_status(struct usb_hub *hub, int port1,
556 u16 *status, u16 *change)
557{
558 int ret;
559
560 mutex_lock(&hub->status_mutex);
561 ret = get_port_status(hub->hdev, port1, &hub->status->port);
562 if (ret < 4) {
Alan Sterne9e88fb2013-03-27 16:14:01 -0400563 if (ret != -ENODEV)
564 dev_err(hub->intfdev,
565 "%s failed (err = %d)\n", __func__, ret);
Alan Stern3eb14912008-03-03 15:15:43 -0500566 if (ret >= 0)
567 ret = -EIO;
568 } else {
569 *status = le16_to_cpu(hub->status->port.wPortStatus);
570 *change = le16_to_cpu(hub->status->port.wPortChange);
John Youndbe79bb2001-09-17 00:00:00 -0700571
Alan Stern3eb14912008-03-03 15:15:43 -0500572 ret = 0;
573 }
574 mutex_unlock(&hub->status_mutex);
575 return ret;
576}
577
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578static void kick_khubd(struct usb_hub *hub)
579{
580 unsigned long flags;
581
582 spin_lock_irqsave(&hub_event_lock, flags);
Roel Kluin2e2c5ee2007-10-26 23:54:35 +0200583 if (!hub->disconnected && list_empty(&hub->event_list)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 list_add_tail(&hub->event_list, &hub_event_list);
Alan Stern8e4ceb32009-12-07 13:01:37 -0500585
586 /* Suppress autosuspend until khubd runs */
587 usb_autopm_get_interface_no_resume(
588 to_usb_interface(hub->intfdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 wake_up(&khubd_wait);
590 }
591 spin_unlock_irqrestore(&hub_event_lock, flags);
592}
593
594void usb_kick_khubd(struct usb_device *hdev)
595{
Lan Tianyuad493e52013-01-23 04:26:30 +0800596 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Alan Stern251180842009-07-22 14:41:18 -0400597
598 if (hub)
599 kick_khubd(hub);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600}
601
Sarah Sharp4ee823b2011-11-14 18:00:01 -0800602/*
603 * Let the USB core know that a USB 3.0 device has sent a Function Wake Device
604 * Notification, which indicates it had initiated remote wakeup.
605 *
606 * USB 3.0 hubs do not report the port link state change from U3 to U0 when the
607 * device initiates resume, so the USB core will not receive notice of the
608 * resume through the normal hub interrupt URB.
609 */
610void usb_wakeup_notification(struct usb_device *hdev,
611 unsigned int portnum)
612{
613 struct usb_hub *hub;
614
615 if (!hdev)
616 return;
617
Lan Tianyuad493e52013-01-23 04:26:30 +0800618 hub = usb_hub_to_struct_hub(hdev);
Sarah Sharp4ee823b2011-11-14 18:00:01 -0800619 if (hub) {
620 set_bit(portnum, hub->wakeup_bits);
621 kick_khubd(hub);
622 }
623}
624EXPORT_SYMBOL_GPL(usb_wakeup_notification);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
626/* completion function, fires on port status changes and various faults */
David Howells7d12e782006-10-05 14:55:46 +0100627static void hub_irq(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628{
Tobias Klauserec17cf12006-09-13 21:38:41 +0200629 struct usb_hub *hub = urb->context;
Alan Sterne0152682007-08-24 15:42:52 -0400630 int status = urb->status;
Roel Kluin71d27182009-03-13 12:19:18 +0100631 unsigned i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 unsigned long bits;
633
Alan Sterne0152682007-08-24 15:42:52 -0400634 switch (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 case -ENOENT: /* synchronous unlink */
636 case -ECONNRESET: /* async unlink */
637 case -ESHUTDOWN: /* hardware going away */
638 return;
639
640 default: /* presumably an error */
641 /* Cause a hub reset after 10 consecutive errors */
Alan Sterne0152682007-08-24 15:42:52 -0400642 dev_dbg (hub->intfdev, "transfer --> %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 if ((++hub->nerrors < 10) || hub->error)
644 goto resubmit;
Alan Sterne0152682007-08-24 15:42:52 -0400645 hub->error = status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 /* FALL THROUGH */
Tobias Klauserec17cf12006-09-13 21:38:41 +0200647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 /* let khubd handle things */
649 case 0: /* we got data: port status changed */
650 bits = 0;
651 for (i = 0; i < urb->actual_length; ++i)
652 bits |= ((unsigned long) ((*hub->buffer)[i]))
653 << (i*8);
654 hub->event_bits[0] = bits;
655 break;
656 }
657
658 hub->nerrors = 0;
659
660 /* Something happened, let khubd figure it out */
661 kick_khubd(hub);
662
663resubmit:
664 if (hub->quiescing)
665 return;
666
667 if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
668 && status != -ENODEV && status != -EPERM)
669 dev_err (hub->intfdev, "resubmit --> %d\n", status);
670}
671
672/* USB 2.0 spec Section 11.24.2.3 */
673static inline int
674hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
675{
William Gulland2c7b8712013-06-27 16:10:20 -0700676 /* Need to clear both directions for control ep */
677 if (((devinfo >> 11) & USB_ENDPOINT_XFERTYPE_MASK) ==
678 USB_ENDPOINT_XFER_CONTROL) {
679 int status = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
680 HUB_CLEAR_TT_BUFFER, USB_RT_PORT,
681 devinfo ^ 0x8000, tt, NULL, 0, 1000);
682 if (status)
683 return status;
684 }
Alan Sternc2f65952009-11-18 11:37:15 -0500685 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
687 tt, NULL, 0, 1000);
688}
689
690/*
691 * enumeration blocks khubd for a long time. we use keventd instead, since
692 * long blocking there is the exception, not the rule. accordingly, HCDs
693 * talking to TTs must queue control transfers (not just bulk and iso), so
694 * both can talk to the same hub concurrently.
695 */
Alan Sterncb88a1b2009-06-29 10:43:32 -0400696static void hub_tt_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
David Howellsc4028952006-11-22 14:57:56 +0000698 struct usb_hub *hub =
Alan Sterncb88a1b2009-06-29 10:43:32 -0400699 container_of(work, struct usb_hub, tt.clear_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 unsigned long flags;
701
702 spin_lock_irqsave (&hub->tt.lock, flags);
Octavian Purdila3b6054d2012-10-01 22:21:12 +0300703 while (!list_empty(&hub->tt.clear_list)) {
H Hartley Sweetend0f830d2009-04-22 16:03:05 -0400704 struct list_head *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 struct usb_tt_clear *clear;
706 struct usb_device *hdev = hub->hdev;
Alan Sterncb88a1b2009-06-29 10:43:32 -0400707 const struct hc_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 int status;
709
H Hartley Sweetend0f830d2009-04-22 16:03:05 -0400710 next = hub->tt.clear_list.next;
711 clear = list_entry (next, struct usb_tt_clear, clear_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 list_del (&clear->clear_list);
713
714 /* drop lock so HCD can concurrently report other TT errors */
715 spin_unlock_irqrestore (&hub->tt.lock, flags);
716 status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
Alan Sterne9e88fb2013-03-27 16:14:01 -0400717 if (status && status != -ENODEV)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 dev_err (&hdev->dev,
719 "clear tt %d (%04x) error %d\n",
720 clear->tt, clear->devinfo, status);
Alan Sterncb88a1b2009-06-29 10:43:32 -0400721
722 /* Tell the HCD, even if the operation failed */
723 drv = clear->hcd->driver;
724 if (drv->clear_tt_buffer_complete)
725 (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
726
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -0700727 kfree(clear);
Alan Sterncb88a1b2009-06-29 10:43:32 -0400728 spin_lock_irqsave(&hub->tt.lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 }
730 spin_unlock_irqrestore (&hub->tt.lock, flags);
731}
732
733/**
Lan Tianyu971fcd42013-01-23 04:26:29 +0800734 * usb_hub_set_port_power - control hub port's power state
Mathias Nyman413412612013-06-18 17:28:48 +0300735 * @hdev: USB device belonging to the usb hub
736 * @hub: target hub
Lan Tianyu971fcd42013-01-23 04:26:29 +0800737 * @port1: port index
738 * @set: expected status
739 *
740 * call this function to control port's power via setting or
741 * clearing the port's PORT_POWER feature.
Yacine Belkadi626f0902013-08-02 20:10:04 +0200742 *
743 * Return: 0 if successful. A negative error code otherwise.
Lan Tianyu971fcd42013-01-23 04:26:29 +0800744 */
Mathias Nyman413412612013-06-18 17:28:48 +0300745int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
746 int port1, bool set)
Lan Tianyu971fcd42013-01-23 04:26:29 +0800747{
748 int ret;
Lan Tianyuad493e52013-01-23 04:26:30 +0800749 struct usb_port *port_dev = hub->ports[port1 - 1];
Lan Tianyu971fcd42013-01-23 04:26:29 +0800750
751 if (set)
752 ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
753 else
Lan Tianyuad493e52013-01-23 04:26:30 +0800754 ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
755
756 if (!ret)
757 port_dev->power_is_on = set;
Lan Tianyu971fcd42013-01-23 04:26:29 +0800758 return ret;
759}
760
761/**
Alan Sterncb88a1b2009-06-29 10:43:32 -0400762 * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
763 * @urb: an URB associated with the failed or incomplete split transaction
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 *
765 * High speed HCDs use this to tell the hub driver that some split control or
766 * bulk transaction failed in a way that requires clearing internal state of
767 * a transaction translator. This is normally detected (and reported) from
768 * interrupt context.
769 *
770 * It may not be possible for that hub to handle additional full (or low)
771 * speed transactions until that state is fully cleared out.
Yacine Belkadi626f0902013-08-02 20:10:04 +0200772 *
773 * Return: 0 if successful. A negative error code otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 */
Alan Sterncb88a1b2009-06-29 10:43:32 -0400775int usb_hub_clear_tt_buffer(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776{
Alan Sterncb88a1b2009-06-29 10:43:32 -0400777 struct usb_device *udev = urb->dev;
778 int pipe = urb->pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 struct usb_tt *tt = udev->tt;
780 unsigned long flags;
781 struct usb_tt_clear *clear;
782
783 /* we've got to cope with an arbitrary number of pending TT clears,
784 * since each TT has "at least two" buffers that can need it (and
785 * there can be many TTs per hub). even if they're uncommon.
786 */
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800787 if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
789 /* FIXME recover somehow ... RESET_TT? */
Alan Sterncb88a1b2009-06-29 10:43:32 -0400790 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 }
792
793 /* info that CLEAR_TT_BUFFER needs */
794 clear->tt = tt->multi ? udev->ttport : 1;
795 clear->devinfo = usb_pipeendpoint (pipe);
796 clear->devinfo |= udev->devnum << 4;
797 clear->devinfo |= usb_pipecontrol (pipe)
798 ? (USB_ENDPOINT_XFER_CONTROL << 11)
799 : (USB_ENDPOINT_XFER_BULK << 11);
800 if (usb_pipein (pipe))
801 clear->devinfo |= 1 << 15;
Alan Sterncb88a1b2009-06-29 10:43:32 -0400802
803 /* info for completion callback */
804 clear->hcd = bus_to_hcd(udev->bus);
805 clear->ep = urb->ep;
806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 /* tell keventd to clear state for this TT */
808 spin_lock_irqsave (&tt->lock, flags);
809 list_add_tail (&clear->clear_list, &tt->clear_list);
Alan Sterncb88a1b2009-06-29 10:43:32 -0400810 schedule_work(&tt->clear_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 spin_unlock_irqrestore (&tt->lock, flags);
Alan Sterncb88a1b2009-06-29 10:43:32 -0400812 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813}
Alan Sterncb88a1b2009-06-29 10:43:32 -0400814EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Alan Stern8520f382008-09-22 14:44:26 -0400816/* If do_delay is false, return the number of milliseconds the caller
817 * needs to delay.
818 */
819static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820{
821 int port1;
David Brownellb7896962005-08-31 10:41:44 -0700822 unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
Alan Stern8520f382008-09-22 14:44:26 -0400823 unsigned delay;
Alan Stern4489a572006-04-27 15:54:22 -0400824 u16 wHubCharacteristics =
825 le16_to_cpu(hub->descriptor->wHubCharacteristics);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Alan Stern4489a572006-04-27 15:54:22 -0400827 /* Enable power on each port. Some hubs have reserved values
828 * of LPSM (> 2) in their descriptors, even though they are
829 * USB 2.0 hubs. Some hubs do not implement port-power switching
830 * but only emulate it. In all cases, the ports won't work
831 * unless we send these messages to the hub.
832 */
833 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 dev_dbg(hub->intfdev, "enabling power on all ports\n");
Alan Stern4489a572006-04-27 15:54:22 -0400835 else
836 dev_dbg(hub->intfdev, "trying to enable port power on "
837 "non-switchable hub\n");
Krzysztof Mazur3bbc47d2013-08-22 14:49:40 +0200838 for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
Lan Tianyuad493e52013-01-23 04:26:30 +0800839 if (hub->ports[port1 - 1]->power_is_on)
840 set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
841 else
842 usb_clear_port_feature(hub->hdev, port1,
843 USB_PORT_FEAT_POWER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
David Brownellb7896962005-08-31 10:41:44 -0700845 /* Wait at least 100 msec for power to become stable */
Alan Stern8520f382008-09-22 14:44:26 -0400846 delay = max(pgood_delay, (unsigned) 100);
847 if (do_delay)
848 msleep(delay);
849 return delay;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850}
851
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852static int hub_hub_status(struct usb_hub *hub,
853 u16 *status, u16 *change)
854{
855 int ret;
856
Alan Sterndb90e7a2007-02-05 09:56:15 -0500857 mutex_lock(&hub->status_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 ret = get_hub_status(hub->hdev, &hub->status->hub);
Alan Sterne9e88fb2013-03-27 16:14:01 -0400859 if (ret < 0) {
860 if (ret != -ENODEV)
861 dev_err(hub->intfdev,
862 "%s failed (err = %d)\n", __func__, ret);
863 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 *status = le16_to_cpu(hub->status->hub.wHubStatus);
Matthias Beyer469271f2013-10-10 23:41:27 +0200865 *change = le16_to_cpu(hub->status->hub.wHubChange);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 ret = 0;
867 }
Alan Sterndb90e7a2007-02-05 09:56:15 -0500868 mutex_unlock(&hub->status_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 return ret;
870}
871
Sarah Sharp41e7e052012-11-14 16:42:32 -0800872static int hub_set_port_link_state(struct usb_hub *hub, int port1,
873 unsigned int link_status)
874{
875 return set_port_feature(hub->hdev,
876 port1 | (link_status << 3),
877 USB_PORT_FEAT_LINK_STATE);
878}
879
880/*
881 * If USB 3.0 ports are placed into the Disabled state, they will no longer
882 * detect any device connects or disconnects. This is generally not what the
883 * USB core wants, since it expects a disabled port to produce a port status
884 * change event when a new device connects.
885 *
886 * Instead, set the link state to Disabled, wait for the link to settle into
887 * that state, clear any change bits, and then put the port into the RxDetect
888 * state.
889 */
890static int hub_usb3_port_disable(struct usb_hub *hub, int port1)
891{
892 int ret;
893 int total_time;
894 u16 portchange, portstatus;
895
896 if (!hub_is_superspeed(hub->hdev))
897 return -EINVAL;
898
899 ret = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_SS_DISABLED);
Alan Sterne9e88fb2013-03-27 16:14:01 -0400900 if (ret)
Sarah Sharp41e7e052012-11-14 16:42:32 -0800901 return ret;
Sarah Sharp41e7e052012-11-14 16:42:32 -0800902
903 /* Wait for the link to enter the disabled state. */
904 for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
905 ret = hub_port_status(hub, port1, &portstatus, &portchange);
906 if (ret < 0)
907 return ret;
908
909 if ((portstatus & USB_PORT_STAT_LINK_STATE) ==
910 USB_SS_PORT_LS_SS_DISABLED)
911 break;
912 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
913 break;
914 msleep(HUB_DEBOUNCE_STEP);
915 }
916 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
917 dev_warn(hub->intfdev, "Could not disable port %d after %d ms\n",
918 port1, total_time);
919
920 return hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_RX_DETECT);
921}
922
Alan Stern8b28c752005-08-10 17:04:13 -0400923static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
924{
925 struct usb_device *hdev = hub->hdev;
Alan Stern0458d5b2007-05-04 11:52:20 -0400926 int ret = 0;
Alan Stern8b28c752005-08-10 17:04:13 -0400927
Lan Tianyuff823c792012-09-05 13:44:32 +0800928 if (hub->ports[port1 - 1]->child && set_state)
929 usb_set_device_state(hub->ports[port1 - 1]->child,
Alan Stern8b28c752005-08-10 17:04:13 -0400930 USB_STATE_NOTATTACHED);
Sarah Sharp41e7e052012-11-14 16:42:32 -0800931 if (!hub->error) {
932 if (hub_is_superspeed(hub->hdev))
933 ret = hub_usb3_port_disable(hub, port1);
934 else
Lan Tianyuad493e52013-01-23 04:26:30 +0800935 ret = usb_clear_port_feature(hdev, port1,
Sarah Sharp41e7e052012-11-14 16:42:32 -0800936 USB_PORT_FEAT_ENABLE);
937 }
Alan Sterne9e88fb2013-03-27 16:14:01 -0400938 if (ret && ret != -ENODEV)
Alan Stern8b28c752005-08-10 17:04:13 -0400939 dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
Alan Stern0458d5b2007-05-04 11:52:20 -0400940 port1, ret);
Alan Stern8b28c752005-08-10 17:04:13 -0400941 return ret;
942}
943
Alan Stern0458d5b2007-05-04 11:52:20 -0400944/*
Justin P. Mattock6d42fcd2011-02-26 20:33:56 -0800945 * Disable a port and mark a logical connect-change event, so that some
Alan Stern0458d5b2007-05-04 11:52:20 -0400946 * time later khubd will disconnect() any existing usb_device on the port
947 * and will re-enumerate if there actually is a device attached.
948 */
949static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
950{
951 dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
952 hub_port_disable(hub, port1, 1);
953
954 /* FIXME let caller ask to power down the port:
955 * - some devices won't enumerate without a VBUS power cycle
956 * - SRP saves power that way
957 * - ... new call, TBD ...
958 * That's easy if this hub can switch power per-port, and
959 * khubd reactivates the port later (timer, SRP, etc).
960 * Powerdown must be optional, because of reset/DFU.
961 */
962
963 set_bit(port1, hub->change_bits);
Matthias Beyer469271f2013-10-10 23:41:27 +0200964 kick_khubd(hub);
Alan Stern0458d5b2007-05-04 11:52:20 -0400965}
966
Alan Stern253e0572009-10-27 15:20:13 -0400967/**
968 * usb_remove_device - disable a device's port on its parent hub
969 * @udev: device to be disabled and removed
970 * Context: @udev locked, must be able to sleep.
971 *
972 * After @udev's port has been disabled, khubd is notified and it will
973 * see that the device has been disconnected. When the device is
974 * physically unplugged and something is plugged in, the events will
975 * be received and processed normally.
Yacine Belkadi626f0902013-08-02 20:10:04 +0200976 *
977 * Return: 0 if successful. A negative error code otherwise.
Alan Stern253e0572009-10-27 15:20:13 -0400978 */
979int usb_remove_device(struct usb_device *udev)
980{
981 struct usb_hub *hub;
982 struct usb_interface *intf;
983
984 if (!udev->parent) /* Can't remove a root hub */
985 return -EINVAL;
Lan Tianyuad493e52013-01-23 04:26:30 +0800986 hub = usb_hub_to_struct_hub(udev->parent);
Alan Stern253e0572009-10-27 15:20:13 -0400987 intf = to_usb_interface(hub->intfdev);
988
989 usb_autopm_get_interface(intf);
990 set_bit(udev->portnum, hub->removed_bits);
991 hub_port_logical_disconnect(hub, udev->portnum);
992 usb_autopm_put_interface(intf);
993 return 0;
994}
995
Alan Stern6ee0b272008-04-28 11:06:42 -0400996enum hub_activation_type {
Alan Stern8e4ceb32009-12-07 13:01:37 -0500997 HUB_INIT, HUB_INIT2, HUB_INIT3, /* INITs must come first */
Alan Stern8520f382008-09-22 14:44:26 -0400998 HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
Alan Stern6ee0b272008-04-28 11:06:42 -0400999};
Alan Stern5e6effa2008-03-03 15:15:51 -05001000
Alan Stern8520f382008-09-22 14:44:26 -04001001static void hub_init_func2(struct work_struct *ws);
1002static void hub_init_func3(struct work_struct *ws);
1003
Alan Sternf2835212008-04-28 11:07:17 -04001004static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
Alan Stern5e6effa2008-03-03 15:15:51 -05001005{
1006 struct usb_device *hdev = hub->hdev;
Sarah Sharp653a39d2010-12-23 11:12:42 -08001007 struct usb_hcd *hcd;
1008 int ret;
Alan Stern5e6effa2008-03-03 15:15:51 -05001009 int port1;
Alan Sternf2835212008-04-28 11:07:17 -04001010 int status;
Alan Stern948fea32008-04-28 11:07:07 -04001011 bool need_debounce_delay = false;
Alan Stern8520f382008-09-22 14:44:26 -04001012 unsigned delay;
1013
1014 /* Continue a partial initialization */
1015 if (type == HUB_INIT2)
1016 goto init2;
1017 if (type == HUB_INIT3)
1018 goto init3;
Alan Stern5e6effa2008-03-03 15:15:51 -05001019
Elric Fua45aa3b2012-02-18 13:32:27 +08001020 /* The superspeed hub except for root hub has to use Hub Depth
1021 * value as an offset into the route string to locate the bits
1022 * it uses to determine the downstream port number. So hub driver
1023 * should send a set hub depth request to superspeed hub after
1024 * the superspeed hub is set configuration in initialization or
1025 * reset procedure.
1026 *
1027 * After a resume, port power should still be on.
Alan Sternf2835212008-04-28 11:07:17 -04001028 * For any other type of activation, turn it on.
1029 */
Alan Stern8520f382008-09-22 14:44:26 -04001030 if (type != HUB_RESUME) {
Elric Fua45aa3b2012-02-18 13:32:27 +08001031 if (hdev->parent && hub_is_superspeed(hdev)) {
1032 ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
1033 HUB_SET_DEPTH, USB_RT_HUB,
1034 hdev->level - 1, 0, NULL, 0,
1035 USB_CTRL_SET_TIMEOUT);
1036 if (ret < 0)
1037 dev_err(hub->intfdev,
1038 "set hub depth failed\n");
1039 }
Alan Stern8520f382008-09-22 14:44:26 -04001040
1041 /* Speed up system boot by using a delayed_work for the
1042 * hub's initial power-up delays. This is pretty awkward
1043 * and the implementation looks like a home-brewed sort of
1044 * setjmp/longjmp, but it saves at least 100 ms for each
1045 * root hub (assuming usbcore is compiled into the kernel
1046 * rather than as a module). It adds up.
1047 *
1048 * This can't be done for HUB_RESUME or HUB_RESET_RESUME
1049 * because for those activation types the ports have to be
1050 * operational when we return. In theory this could be done
1051 * for HUB_POST_RESET, but it's easier not to.
1052 */
1053 if (type == HUB_INIT) {
1054 delay = hub_power_on(hub, false);
1055 PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func2);
1056 schedule_delayed_work(&hub->init_work,
1057 msecs_to_jiffies(delay));
Alan Stern61fbeba2008-10-27 12:07:44 -04001058
1059 /* Suppress autosuspend until init is done */
Alan Stern8e4ceb32009-12-07 13:01:37 -05001060 usb_autopm_get_interface_no_resume(
1061 to_usb_interface(hub->intfdev));
Alan Stern8520f382008-09-22 14:44:26 -04001062 return; /* Continues at init2: below */
Sarah Sharp653a39d2010-12-23 11:12:42 -08001063 } else if (type == HUB_RESET_RESUME) {
1064 /* The internal host controller state for the hub device
1065 * may be gone after a host power loss on system resume.
1066 * Update the device's info so the HW knows it's a hub.
1067 */
1068 hcd = bus_to_hcd(hdev->bus);
1069 if (hcd->driver->update_hub_device) {
1070 ret = hcd->driver->update_hub_device(hcd, hdev,
1071 &hub->tt, GFP_NOIO);
1072 if (ret < 0) {
1073 dev_err(hub->intfdev, "Host not "
1074 "accepting hub info "
1075 "update.\n");
1076 dev_err(hub->intfdev, "LS/FS devices "
1077 "and hubs may not work "
1078 "under this hub\n.");
1079 }
1080 }
1081 hub_power_on(hub, true);
Alan Stern8520f382008-09-22 14:44:26 -04001082 } else {
1083 hub_power_on(hub, true);
1084 }
1085 }
1086 init2:
Alan Sternf2835212008-04-28 11:07:17 -04001087
Alan Stern6ee0b272008-04-28 11:06:42 -04001088 /* Check each port and set hub->change_bits to let khubd know
1089 * which ports need attention.
Alan Stern5e6effa2008-03-03 15:15:51 -05001090 */
1091 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
Lan Tianyuff823c792012-09-05 13:44:32 +08001092 struct usb_device *udev = hub->ports[port1 - 1]->child;
Alan Stern5e6effa2008-03-03 15:15:51 -05001093 u16 portstatus, portchange;
1094
Alan Stern6ee0b272008-04-28 11:06:42 -04001095 portstatus = portchange = 0;
1096 status = hub_port_status(hub, port1, &portstatus, &portchange);
1097 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1098 dev_dbg(hub->intfdev,
1099 "port %d: status %04x change %04x\n",
1100 port1, portstatus, portchange);
Alan Stern5e6effa2008-03-03 15:15:51 -05001101
Alan Stern6ee0b272008-04-28 11:06:42 -04001102 /* After anything other than HUB_RESUME (i.e., initialization
1103 * or any sort of reset), every port should be disabled.
1104 * Unconnected ports should likewise be disabled (paranoia),
1105 * and so should ports for which we have no usb_device.
Alan Stern5e6effa2008-03-03 15:15:51 -05001106 */
Alan Stern6ee0b272008-04-28 11:06:42 -04001107 if ((portstatus & USB_PORT_STAT_ENABLE) && (
1108 type != HUB_RESUME ||
1109 !(portstatus & USB_PORT_STAT_CONNECTION) ||
1110 !udev ||
1111 udev->state == USB_STATE_NOTATTACHED)) {
Andiry Xu9f0a6cd2010-05-07 18:09:27 +08001112 /*
1113 * USB3 protocol ports will automatically transition
1114 * to Enabled state when detect an USB3.0 device attach.
1115 * Do not disable USB3 protocol ports.
Andiry Xu9f0a6cd2010-05-07 18:09:27 +08001116 */
Sarah Sharp131dec32010-12-06 21:00:19 -08001117 if (!hub_is_superspeed(hdev)) {
Lan Tianyuad493e52013-01-23 04:26:30 +08001118 usb_clear_port_feature(hdev, port1,
Andiry Xu9f0a6cd2010-05-07 18:09:27 +08001119 USB_PORT_FEAT_ENABLE);
1120 portstatus &= ~USB_PORT_STAT_ENABLE;
Sarah Sharp85f0ff42010-10-14 07:22:54 -07001121 } else {
1122 /* Pretend that power was lost for USB3 devs */
1123 portstatus &= ~USB_PORT_STAT_ENABLE;
Andiry Xu9f0a6cd2010-05-07 18:09:27 +08001124 }
Alan Stern6ee0b272008-04-28 11:06:42 -04001125 }
1126
Alan Stern948fea32008-04-28 11:07:07 -04001127 /* Clear status-change flags; we'll debounce later */
1128 if (portchange & USB_PORT_STAT_C_CONNECTION) {
1129 need_debounce_delay = true;
Lan Tianyuad493e52013-01-23 04:26:30 +08001130 usb_clear_port_feature(hub->hdev, port1,
Alan Stern948fea32008-04-28 11:07:07 -04001131 USB_PORT_FEAT_C_CONNECTION);
1132 }
1133 if (portchange & USB_PORT_STAT_C_ENABLE) {
1134 need_debounce_delay = true;
Lan Tianyuad493e52013-01-23 04:26:30 +08001135 usb_clear_port_feature(hub->hdev, port1,
Alan Stern948fea32008-04-28 11:07:07 -04001136 USB_PORT_FEAT_C_ENABLE);
1137 }
Don Zickus79c3dd82011-11-03 09:07:18 -04001138 if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
1139 hub_is_superspeed(hub->hdev)) {
1140 need_debounce_delay = true;
Lan Tianyuad493e52013-01-23 04:26:30 +08001141 usb_clear_port_feature(hub->hdev, port1,
Don Zickus79c3dd82011-11-03 09:07:18 -04001142 USB_PORT_FEAT_C_BH_PORT_RESET);
1143 }
Alan Stern253e0572009-10-27 15:20:13 -04001144 /* We can forget about a "removed" device when there's a
1145 * physical disconnect or the connect status changes.
1146 */
1147 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
1148 (portchange & USB_PORT_STAT_C_CONNECTION))
1149 clear_bit(port1, hub->removed_bits);
1150
Alan Stern6ee0b272008-04-28 11:06:42 -04001151 if (!udev || udev->state == USB_STATE_NOTATTACHED) {
1152 /* Tell khubd to disconnect the device or
1153 * check for a new connection
1154 */
1155 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1156 set_bit(port1, hub->change_bits);
1157
1158 } else if (portstatus & USB_PORT_STAT_ENABLE) {
Sarah Sharp72937e12012-01-24 11:46:50 -08001159 bool port_resumed = (portstatus &
1160 USB_PORT_STAT_LINK_STATE) ==
1161 USB_SS_PORT_LS_U0;
Alan Stern6ee0b272008-04-28 11:06:42 -04001162 /* The power session apparently survived the resume.
1163 * If there was an overcurrent or suspend change
1164 * (i.e., remote wakeup request), have khubd
Sarah Sharp72937e12012-01-24 11:46:50 -08001165 * take care of it. Look at the port link state
1166 * for USB 3.0 hubs, since they don't have a suspend
1167 * change bit, and they don't set the port link change
1168 * bit on device-initiated resume.
Alan Stern6ee0b272008-04-28 11:06:42 -04001169 */
Sarah Sharp72937e12012-01-24 11:46:50 -08001170 if (portchange || (hub_is_superspeed(hub->hdev) &&
1171 port_resumed))
Alan Stern6ee0b272008-04-28 11:06:42 -04001172 set_bit(port1, hub->change_bits);
1173
1174 } else if (udev->persist_enabled) {
Lan Tianyuad493e52013-01-23 04:26:30 +08001175 struct usb_port *port_dev = hub->ports[port1 - 1];
1176
Alan Stern6ee0b272008-04-28 11:06:42 -04001177#ifdef CONFIG_PM
Alan Stern5e6effa2008-03-03 15:15:51 -05001178 udev->reset_resume = 1;
Alan Stern6ee0b272008-04-28 11:06:42 -04001179#endif
Lan Tianyuad493e52013-01-23 04:26:30 +08001180 /* Don't set the change_bits when the device
1181 * was powered off.
1182 */
1183 if (port_dev->power_is_on)
1184 set_bit(port1, hub->change_bits);
Alan Stern8808f002008-04-28 11:06:55 -04001185
Alan Stern6ee0b272008-04-28 11:06:42 -04001186 } else {
1187 /* The power session is gone; tell khubd */
1188 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1189 set_bit(port1, hub->change_bits);
Alan Stern5e6effa2008-03-03 15:15:51 -05001190 }
Alan Stern5e6effa2008-03-03 15:15:51 -05001191 }
1192
Alan Stern948fea32008-04-28 11:07:07 -04001193 /* If no port-status-change flags were set, we don't need any
1194 * debouncing. If flags were set we can try to debounce the
1195 * ports all at once right now, instead of letting khubd do them
1196 * one at a time later on.
1197 *
1198 * If any port-status changes do occur during this delay, khubd
1199 * will see them later and handle them normally.
1200 */
Alan Stern8520f382008-09-22 14:44:26 -04001201 if (need_debounce_delay) {
1202 delay = HUB_DEBOUNCE_STABLE;
Alan Sternf2835212008-04-28 11:07:17 -04001203
Alan Stern8520f382008-09-22 14:44:26 -04001204 /* Don't do a long sleep inside a workqueue routine */
1205 if (type == HUB_INIT2) {
1206 PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func3);
1207 schedule_delayed_work(&hub->init_work,
1208 msecs_to_jiffies(delay));
1209 return; /* Continues at init3: below */
1210 } else {
1211 msleep(delay);
1212 }
1213 }
1214 init3:
Alan Sternf2835212008-04-28 11:07:17 -04001215 hub->quiescing = 0;
1216
1217 status = usb_submit_urb(hub->urb, GFP_NOIO);
1218 if (status < 0)
1219 dev_err(hub->intfdev, "activate --> %d\n", status);
1220 if (hub->has_indicators && blinkenlights)
1221 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
1222
1223 /* Scan all ports that need attention */
1224 kick_khubd(hub);
Alan Stern8e4ceb32009-12-07 13:01:37 -05001225
1226 /* Allow autosuspend if it was suppressed */
1227 if (type <= HUB_INIT3)
1228 usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
Alan Stern5e6effa2008-03-03 15:15:51 -05001229}
1230
Alan Stern8520f382008-09-22 14:44:26 -04001231/* Implement the continuations for the delays above */
1232static void hub_init_func2(struct work_struct *ws)
1233{
1234 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1235
1236 hub_activate(hub, HUB_INIT2);
1237}
1238
1239static void hub_init_func3(struct work_struct *ws)
1240{
1241 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1242
1243 hub_activate(hub, HUB_INIT3);
1244}
1245
Alan Stern43303542008-04-28 11:07:31 -04001246enum hub_quiescing_type {
1247 HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
1248};
1249
1250static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
1251{
1252 struct usb_device *hdev = hub->hdev;
1253 int i;
1254
Alan Stern8520f382008-09-22 14:44:26 -04001255 cancel_delayed_work_sync(&hub->init_work);
1256
Alan Stern43303542008-04-28 11:07:31 -04001257 /* khubd and related activity won't re-trigger */
1258 hub->quiescing = 1;
1259
1260 if (type != HUB_SUSPEND) {
1261 /* Disconnect all the children */
1262 for (i = 0; i < hdev->maxchild; ++i) {
Lan Tianyuff823c792012-09-05 13:44:32 +08001263 if (hub->ports[i]->child)
1264 usb_disconnect(&hub->ports[i]->child);
Alan Stern43303542008-04-28 11:07:31 -04001265 }
1266 }
1267
1268 /* Stop khubd and related activity */
1269 usb_kill_urb(hub->urb);
1270 if (hub->has_indicators)
1271 cancel_delayed_work_sync(&hub->leds);
1272 if (hub->tt.hub)
Octavian Purdila036546b2012-10-23 11:33:12 +03001273 flush_work(&hub->tt.clear_work);
Alan Stern43303542008-04-28 11:07:31 -04001274}
1275
Alan Stern3eb14912008-03-03 15:15:43 -05001276/* caller has locked the hub device */
1277static int hub_pre_reset(struct usb_interface *intf)
1278{
1279 struct usb_hub *hub = usb_get_intfdata(intf);
1280
Alan Stern43303542008-04-28 11:07:31 -04001281 hub_quiesce(hub, HUB_PRE_RESET);
Alan Sternf07600c2007-05-30 15:38:16 -04001282 return 0;
Alan Stern7d069b72005-11-18 12:06:34 -05001283}
1284
1285/* caller has locked the hub device */
Alan Sternf07600c2007-05-30 15:38:16 -04001286static int hub_post_reset(struct usb_interface *intf)
Alan Stern7d069b72005-11-18 12:06:34 -05001287{
Alan Stern7de18d82006-06-01 13:37:24 -04001288 struct usb_hub *hub = usb_get_intfdata(intf);
1289
Alan Sternf2835212008-04-28 11:07:17 -04001290 hub_activate(hub, HUB_POST_RESET);
Alan Sternf07600c2007-05-30 15:38:16 -04001291 return 0;
Alan Stern7d069b72005-11-18 12:06:34 -05001292}
1293
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294static int hub_configure(struct usb_hub *hub,
1295 struct usb_endpoint_descriptor *endpoint)
1296{
Sarah Sharpb356b7c2009-09-04 10:53:24 -07001297 struct usb_hcd *hcd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 struct usb_device *hdev = hub->hdev;
1299 struct device *hub_dev = hub->intfdev;
1300 u16 hubstatus, hubchange;
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001301 u16 wHubCharacteristics;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 unsigned int pipe;
Lan Tianyufa2a9562012-09-05 13:44:31 +08001303 int maxp, ret, i;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001304 char *message = "out of memory";
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001305 unsigned unit_load;
1306 unsigned full_load;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307
Alan Sternd697cdd2009-10-27 15:18:46 -04001308 hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 if (!hub->buffer) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 ret = -ENOMEM;
1311 goto fail;
1312 }
1313
1314 hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
1315 if (!hub->status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 ret = -ENOMEM;
1317 goto fail;
1318 }
Alan Sterndb90e7a2007-02-05 09:56:15 -05001319 mutex_init(&hub->status_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320
1321 hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
1322 if (!hub->descriptor) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 ret = -ENOMEM;
1324 goto fail;
1325 }
1326
1327 /* Request the entire hub descriptor.
1328 * hub->descriptor can handle USB_MAXCHILDREN ports,
1329 * but the hub can/will return fewer bytes here.
1330 */
John Youndbe79bb2001-09-17 00:00:00 -07001331 ret = get_hub_descriptor(hdev, hub->descriptor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 if (ret < 0) {
1333 message = "can't read hub descriptor";
1334 goto fail;
1335 } else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
1336 message = "hub has too many ports!";
1337 ret = -ENODEV;
1338 goto fail;
David Linares769d73682013-03-25 10:50:27 +00001339 } else if (hub->descriptor->bNbrPorts == 0) {
1340 message = "hub doesn't have any ports!";
1341 ret = -ENODEV;
1342 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 }
1344
1345 hdev->maxchild = hub->descriptor->bNbrPorts;
1346 dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
1347 (hdev->maxchild == 1) ? "" : "s");
1348
Lan Tianyufa2a9562012-09-05 13:44:31 +08001349 hub->ports = kzalloc(hdev->maxchild * sizeof(struct usb_port *),
1350 GFP_KERNEL);
Lan Tianyuff823c792012-09-05 13:44:32 +08001351 if (!hub->ports) {
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001352 ret = -ENOMEM;
1353 goto fail;
1354 }
1355
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001356 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001357 if (hub_is_superspeed(hdev)) {
1358 unit_load = 150;
1359 full_load = 900;
1360 } else {
1361 unit_load = 100;
1362 full_load = 500;
1363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364
John Youndbe79bb2001-09-17 00:00:00 -07001365 /* FIXME for USB 3.0, skip for now */
1366 if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
1367 !(hub_is_superspeed(hdev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 int i;
Matthias Beyer469271f2013-10-10 23:41:27 +02001369 char portstr[USB_MAXCHILDREN + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
1371 for (i = 0; i < hdev->maxchild; i++)
John Youndbe79bb2001-09-17 00:00:00 -07001372 portstr[i] = hub->descriptor->u.hs.DeviceRemovable
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 [((i + 1) / 8)] & (1 << ((i + 1) % 8))
1374 ? 'F' : 'R';
1375 portstr[hdev->maxchild] = 0;
1376 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
1377 } else
1378 dev_dbg(hub_dev, "standalone hub\n");
1379
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001380 switch (wHubCharacteristics & HUB_CHAR_LPSM) {
Aman Deep7bf01182011-12-08 12:05:22 +05301381 case HUB_CHAR_COMMON_LPSM:
1382 dev_dbg(hub_dev, "ganged power switching\n");
1383 break;
1384 case HUB_CHAR_INDV_PORT_LPSM:
1385 dev_dbg(hub_dev, "individual port power switching\n");
1386 break;
1387 case HUB_CHAR_NO_LPSM:
1388 case HUB_CHAR_LPSM:
1389 dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
1390 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 }
1392
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001393 switch (wHubCharacteristics & HUB_CHAR_OCPM) {
Aman Deep7bf01182011-12-08 12:05:22 +05301394 case HUB_CHAR_COMMON_OCPM:
1395 dev_dbg(hub_dev, "global over-current protection\n");
1396 break;
1397 case HUB_CHAR_INDV_PORT_OCPM:
1398 dev_dbg(hub_dev, "individual port over-current protection\n");
1399 break;
1400 case HUB_CHAR_NO_OCPM:
1401 case HUB_CHAR_OCPM:
1402 dev_dbg(hub_dev, "no over-current protection\n");
1403 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 }
1405
1406 spin_lock_init (&hub->tt.lock);
1407 INIT_LIST_HEAD (&hub->tt.clear_list);
Alan Sterncb88a1b2009-06-29 10:43:32 -04001408 INIT_WORK(&hub->tt.clear_work, hub_tt_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 switch (hdev->descriptor.bDeviceProtocol) {
Aman Deep7bf01182011-12-08 12:05:22 +05301410 case USB_HUB_PR_FS:
1411 break;
1412 case USB_HUB_PR_HS_SINGLE_TT:
1413 dev_dbg(hub_dev, "Single TT\n");
1414 hub->tt.hub = hdev;
1415 break;
1416 case USB_HUB_PR_HS_MULTI_TT:
1417 ret = usb_set_interface(hdev, 0, 1);
1418 if (ret == 0) {
1419 dev_dbg(hub_dev, "TT per port\n");
1420 hub->tt.multi = 1;
1421 } else
1422 dev_err(hub_dev, "Using single TT (err %d)\n",
1423 ret);
1424 hub->tt.hub = hdev;
1425 break;
1426 case USB_HUB_PR_SS:
1427 /* USB 3.0 hubs don't have a TT */
1428 break;
1429 default:
1430 dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
1431 hdev->descriptor.bDeviceProtocol);
1432 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 }
1434
david-b@pacbell.nete09711a2005-08-13 18:41:04 -07001435 /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001436 switch (wHubCharacteristics & HUB_CHAR_TTTT) {
Matthias Beyer469271f2013-10-10 23:41:27 +02001437 case HUB_TTTT_8_BITS:
1438 if (hdev->descriptor.bDeviceProtocol != 0) {
1439 hub->tt.think_time = 666;
david-b@pacbell.nete09711a2005-08-13 18:41:04 -07001440 dev_dbg(hub_dev, "TT requires at most %d "
1441 "FS bit times (%d ns)\n",
Matthias Beyer469271f2013-10-10 23:41:27 +02001442 8, hub->tt.think_time);
1443 }
1444 break;
1445 case HUB_TTTT_16_BITS:
1446 hub->tt.think_time = 666 * 2;
1447 dev_dbg(hub_dev, "TT requires at most %d "
1448 "FS bit times (%d ns)\n",
1449 16, hub->tt.think_time);
1450 break;
1451 case HUB_TTTT_24_BITS:
1452 hub->tt.think_time = 666 * 3;
1453 dev_dbg(hub_dev, "TT requires at most %d "
1454 "FS bit times (%d ns)\n",
1455 24, hub->tt.think_time);
1456 break;
1457 case HUB_TTTT_32_BITS:
1458 hub->tt.think_time = 666 * 4;
1459 dev_dbg(hub_dev, "TT requires at most %d "
1460 "FS bit times (%d ns)\n",
1461 32, hub->tt.think_time);
1462 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 }
1464
1465 /* probe() zeroes hub->indicator[] */
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001466 if (wHubCharacteristics & HUB_CHAR_PORTIND) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 hub->has_indicators = 1;
1468 dev_dbg(hub_dev, "Port indicators are supported\n");
1469 }
1470
1471 dev_dbg(hub_dev, "power on to power good time: %dms\n",
1472 hub->descriptor->bPwrOn2PwrGood * 2);
1473
1474 /* power budgeting mostly matters with bus-powered hubs,
1475 * and battery-powered root hubs (may provide just 8 mA).
1476 */
1477 ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
Alan Stern15b73362013-07-30 15:35:40 -04001478 if (ret) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 message = "can't get hub status";
1480 goto fail;
1481 }
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001482 hcd = bus_to_hcd(hdev->bus);
Alan Stern7d35b922005-04-25 11:18:32 -04001483 if (hdev == hdev->bus->root_hub) {
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001484 if (hcd->power_budget > 0)
1485 hdev->bus_mA = hcd->power_budget;
1486 else
1487 hdev->bus_mA = full_load * hdev->maxchild;
1488 if (hdev->bus_mA >= full_load)
1489 hub->mA_per_port = full_load;
Alan Stern55c52712005-11-23 12:03:12 -05001490 else {
1491 hub->mA_per_port = hdev->bus_mA;
1492 hub->limited_power = 1;
1493 }
Alan Stern7d35b922005-04-25 11:18:32 -04001494 } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001495 int remaining = hdev->bus_mA -
1496 hub->descriptor->bHubContrCurrent;
1497
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
1499 hub->descriptor->bHubContrCurrent);
Alan Stern55c52712005-11-23 12:03:12 -05001500 hub->limited_power = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001502 if (remaining < hdev->maxchild * unit_load)
1503 dev_warn(hub_dev,
Alan Stern55c52712005-11-23 12:03:12 -05001504 "insufficient power available "
1505 "to use all downstream ports\n");
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001506 hub->mA_per_port = unit_load; /* 7.2.1 */
1507
Alan Stern55c52712005-11-23 12:03:12 -05001508 } else { /* Self-powered external hub */
1509 /* FIXME: What about battery-powered external hubs that
1510 * provide less current per port? */
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001511 hub->mA_per_port = full_load;
Alan Stern55c52712005-11-23 12:03:12 -05001512 }
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01001513 if (hub->mA_per_port < full_load)
Alan Stern55c52712005-11-23 12:03:12 -05001514 dev_dbg(hub_dev, "%umA bus power budget for each child\n",
1515 hub->mA_per_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Sarah Sharpb356b7c2009-09-04 10:53:24 -07001517 /* Update the HCD's internal representation of this hub before khubd
1518 * starts getting port status changes for devices under the hub.
1519 */
Sarah Sharpb356b7c2009-09-04 10:53:24 -07001520 if (hcd->driver->update_hub_device) {
1521 ret = hcd->driver->update_hub_device(hcd, hdev,
1522 &hub->tt, GFP_KERNEL);
1523 if (ret < 0) {
1524 message = "can't update HCD hub info";
1525 goto fail;
1526 }
1527 }
1528
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 ret = hub_hub_status(hub, &hubstatus, &hubchange);
1530 if (ret < 0) {
1531 message = "can't get hub status";
1532 goto fail;
1533 }
1534
1535 /* local power status reports aren't always correct */
1536 if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1537 dev_dbg(hub_dev, "local power source is %s\n",
1538 (hubstatus & HUB_STATUS_LOCAL_POWER)
1539 ? "lost (inactive)" : "good");
1540
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07001541 if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 dev_dbg(hub_dev, "%sover-current condition exists\n",
1543 (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
1544
inaky@linux.intel.com88fafff2006-10-11 20:05:59 -07001545 /* set up the interrupt endpoint
1546 * We use the EP's maxpacket size instead of (PORTS+1+7)/8
1547 * bytes as USB2.0[11.12.3] says because some hubs are known
1548 * to send more data (and thus cause overflow). For root hubs,
1549 * maxpktsize is defined in hcd.c's fake endpoint descriptors
1550 * to be big enough for at least USB_MAXCHILDREN ports. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
1552 maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
1553
1554 if (maxp > sizeof(*hub->buffer))
1555 maxp = sizeof(*hub->buffer);
1556
1557 hub->urb = usb_alloc_urb(0, GFP_KERNEL);
1558 if (!hub->urb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 ret = -ENOMEM;
1560 goto fail;
1561 }
1562
1563 usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
1564 hub, endpoint->bInterval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565
1566 /* maybe cycle the hub leds */
1567 if (hub->has_indicators && blinkenlights)
Matthias Beyer469271f2013-10-10 23:41:27 +02001568 hub->indicator[0] = INDICATOR_CYCLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569
Krzysztof Mazure58547e2013-08-22 14:49:39 +02001570 for (i = 0; i < hdev->maxchild; i++) {
1571 ret = usb_hub_create_port_device(hub, i + 1);
1572 if (ret < 0) {
Lan Tianyufa2a9562012-09-05 13:44:31 +08001573 dev_err(hub->intfdev,
1574 "couldn't create port%d device.\n", i + 1);
Krzysztof Mazure58547e2013-08-22 14:49:39 +02001575 hdev->maxchild = i;
1576 goto fail_keep_maxchild;
1577 }
1578 }
Lan Tianyufa2a9562012-09-05 13:44:31 +08001579
Lan Tianyud2123fd2013-01-21 22:18:00 +08001580 usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
1581
Alan Sternf2835212008-04-28 11:07:17 -04001582 hub_activate(hub, HUB_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 return 0;
1584
1585fail:
Krzysztof Mazurd0308d42013-08-22 14:49:38 +02001586 hdev->maxchild = 0;
Krzysztof Mazure58547e2013-08-22 14:49:39 +02001587fail_keep_maxchild:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 dev_err (hub_dev, "config failed, %s (err %d)\n",
1589 message, ret);
1590 /* hub_disconnect() frees urb and descriptor */
1591 return ret;
1592}
1593
Alan Sterne8054852007-05-04 11:55:11 -04001594static void hub_release(struct kref *kref)
1595{
1596 struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
1597
1598 usb_put_intf(to_usb_interface(hub->intfdev));
1599 kfree(hub);
1600}
1601
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602static unsigned highspeed_hubs;
1603
1604static void hub_disconnect(struct usb_interface *intf)
1605{
Huajun Li88162302012-03-12 21:00:19 +08001606 struct usb_hub *hub = usb_get_intfdata(intf);
Greg Kroah-Hartmanfa286182012-05-14 09:20:37 -07001607 struct usb_device *hdev = interface_to_usbdev(intf);
Lan Tianyufa2a9562012-09-05 13:44:31 +08001608 int i;
1609
Alan Sterne8054852007-05-04 11:55:11 -04001610 /* Take the hub off the event list and don't let it be added again */
1611 spin_lock_irq(&hub_event_lock);
Alan Stern8e4ceb32009-12-07 13:01:37 -05001612 if (!list_empty(&hub->event_list)) {
1613 list_del_init(&hub->event_list);
1614 usb_autopm_put_interface_no_suspend(intf);
1615 }
Alan Sterne8054852007-05-04 11:55:11 -04001616 hub->disconnected = 1;
1617 spin_unlock_irq(&hub_event_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618
Alan Stern7de18d82006-06-01 13:37:24 -04001619 /* Disconnect all children and quiesce the hub */
1620 hub->error = 0;
Alan Stern43303542008-04-28 11:07:31 -04001621 hub_quiesce(hub, HUB_DISCONNECT);
Alan Stern7de18d82006-06-01 13:37:24 -04001622
Alan Stern8b28c752005-08-10 17:04:13 -04001623 usb_set_intfdata (intf, NULL);
Alexander Shishkin1f2235b2012-09-12 14:48:31 +03001624
1625 for (i = 0; i < hdev->maxchild; i++)
1626 usb_hub_remove_port_device(hub, i + 1);
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001627 hub->hdev->maxchild = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
Alan Sterne8054852007-05-04 11:55:11 -04001629 if (hub->hdev->speed == USB_SPEED_HIGH)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 highspeed_hubs--;
1631
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 usb_free_urb(hub->urb);
Lan Tianyufa2a9562012-09-05 13:44:31 +08001633 kfree(hub->ports);
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -07001634 kfree(hub->descriptor);
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -07001635 kfree(hub->status);
Alan Sternd697cdd2009-10-27 15:18:46 -04001636 kfree(hub->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
Lan Tianyu971fcd42013-01-23 04:26:29 +08001638 pm_suspend_ignore_children(&intf->dev, false);
Alan Sterne8054852007-05-04 11:55:11 -04001639 kref_put(&hub->kref, hub_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640}
1641
1642static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
1643{
1644 struct usb_host_interface *desc;
1645 struct usb_endpoint_descriptor *endpoint;
1646 struct usb_device *hdev;
1647 struct usb_hub *hub;
1648
1649 desc = intf->cur_altsetting;
1650 hdev = interface_to_usbdev(intf);
1651
Ming Lei596d7892012-10-24 11:59:25 +08001652 /*
1653 * Set default autosuspend delay as 0 to speedup bus suspend,
1654 * based on the below considerations:
1655 *
1656 * - Unlike other drivers, the hub driver does not rely on the
1657 * autosuspend delay to provide enough time to handle a wakeup
1658 * event, and the submitted status URB is just to check future
1659 * change on hub downstream ports, so it is safe to do it.
1660 *
1661 * - The patch might cause one or more auto supend/resume for
1662 * below very rare devices when they are plugged into hub
1663 * first time:
1664 *
1665 * devices having trouble initializing, and disconnect
1666 * themselves from the bus and then reconnect a second
1667 * or so later
1668 *
1669 * devices just for downloading firmware, and disconnects
1670 * themselves after completing it
1671 *
1672 * For these quite rare devices, their drivers may change the
1673 * autosuspend delay of their parent hub in the probe() to one
1674 * appropriate value to avoid the subtle problem if someone
1675 * does care it.
1676 *
1677 * - The patch may cause one or more auto suspend/resume on
1678 * hub during running 'lsusb', but it is probably too
1679 * infrequent to worry about.
1680 *
1681 * - Change autosuspend delay of hub can avoid unnecessary auto
1682 * suspend timer for hub, also may decrease power consumption
1683 * of USB bus.
1684 */
1685 pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
1686
Sarah Sharp2839f5b2012-01-06 16:27:25 -08001687 /* Hubs have proper suspend/resume support. */
1688 usb_enable_autosuspend(hdev);
Alan Stern088f7fe2010-01-08 12:56:54 -05001689
Felipe Balbi38f3ad52008-06-12 10:49:47 +03001690 if (hdev->level == MAX_TOPO_LEVEL) {
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08001691 dev_err(&intf->dev,
1692 "Unsupported bus topology: hub nested too deep\n");
Felipe Balbi38f3ad52008-06-12 10:49:47 +03001693 return -E2BIG;
1694 }
1695
David Brownell89ccbdc2006-04-02 10:18:09 -08001696#ifdef CONFIG_USB_OTG_BLACKLIST_HUB
1697 if (hdev->parent) {
1698 dev_warn(&intf->dev, "ignoring external hub\n");
1699 return -ENODEV;
1700 }
1701#endif
1702
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 /* Some hubs have a subclass of 1, which AFAICT according to the */
1704 /* specs is not defined, but it works */
1705 if ((desc->desc.bInterfaceSubClass != 0) &&
1706 (desc->desc.bInterfaceSubClass != 1)) {
1707descriptor_error:
1708 dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
1709 return -EIO;
1710 }
1711
1712 /* Multiple endpoints? What kind of mutant ninja-hub is this? */
1713 if (desc->desc.bNumEndpoints != 1)
1714 goto descriptor_error;
1715
1716 endpoint = &desc->endpoint[0].desc;
1717
Luiz Fernando N. Capitulinofbf81c22006-09-27 11:58:53 -07001718 /* If it's not an interrupt in endpoint, we'd better punt! */
1719 if (!usb_endpoint_is_int_in(endpoint))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 goto descriptor_error;
1721
1722 /* We found a hub */
1723 dev_info (&intf->dev, "USB hub found\n");
1724
Alan Stern0a1ef3b2005-10-24 15:38:24 -04001725 hub = kzalloc(sizeof(*hub), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 if (!hub) {
1727 dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
1728 return -ENOMEM;
1729 }
1730
Alan Sterne8054852007-05-04 11:55:11 -04001731 kref_init(&hub->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 INIT_LIST_HEAD(&hub->event_list);
1733 hub->intfdev = &intf->dev;
1734 hub->hdev = hdev;
David Howellsc4028952006-11-22 14:57:56 +00001735 INIT_DELAYED_WORK(&hub->leds, led_work);
Alan Stern8520f382008-09-22 14:44:26 -04001736 INIT_DELAYED_WORK(&hub->init_work, NULL);
Alan Sterne8054852007-05-04 11:55:11 -04001737 usb_get_intf(intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
1739 usb_set_intfdata (intf, hub);
Alan Stern40f122f2006-11-09 14:44:33 -05001740 intf->needs_remote_wakeup = 1;
Lan Tianyu971fcd42013-01-23 04:26:29 +08001741 pm_suspend_ignore_children(&intf->dev, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742
1743 if (hdev->speed == USB_SPEED_HIGH)
1744 highspeed_hubs++;
1745
Ming Leie6f30de2012-10-24 11:59:24 +08001746 if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
1747 hub->quirk_check_port_auto_suspend = 1;
1748
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 if (hub_configure(hub, endpoint) >= 0)
1750 return 0;
1751
1752 hub_disconnect (intf);
1753 return -ENODEV;
1754}
1755
1756static int
1757hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
1758{
1759 struct usb_device *hdev = interface_to_usbdev (intf);
Lan Tianyuad493e52013-01-23 04:26:30 +08001760 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761
1762 /* assert ifno == 0 (part of hub spec) */
1763 switch (code) {
1764 case USBDEVFS_HUB_PORTINFO: {
1765 struct usbdevfs_hub_portinfo *info = user_data;
1766 int i;
1767
1768 spin_lock_irq(&device_state_lock);
1769 if (hdev->devnum <= 0)
1770 info->nports = 0;
1771 else {
1772 info->nports = hdev->maxchild;
1773 for (i = 0; i < info->nports; i++) {
Lan Tianyuff823c792012-09-05 13:44:32 +08001774 if (hub->ports[i]->child == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 info->port[i] = 0;
1776 else
1777 info->port[i] =
Lan Tianyuff823c792012-09-05 13:44:32 +08001778 hub->ports[i]->child->devnum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 }
1780 }
1781 spin_unlock_irq(&device_state_lock);
1782
1783 return info->nports + 1;
1784 }
1785
1786 default:
1787 return -ENOSYS;
1788 }
1789}
1790
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001791/*
1792 * Allow user programs to claim ports on a hub. When a device is attached
1793 * to one of these "claimed" ports, the program will "own" the device.
1794 */
1795static int find_port_owner(struct usb_device *hdev, unsigned port1,
Lan Tianyu336c5c32012-07-06 14:13:52 +08001796 struct dev_state ***ppowner)
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001797{
Mathias Nyman413412612013-06-18 17:28:48 +03001798 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1799
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001800 if (hdev->state == USB_STATE_NOTATTACHED)
1801 return -ENODEV;
1802 if (port1 == 0 || port1 > hdev->maxchild)
1803 return -EINVAL;
1804
Mathias Nyman413412612013-06-18 17:28:48 +03001805 /* Devices not managed by the hub driver
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001806 * will always have maxchild equal to 0.
1807 */
Mathias Nyman413412612013-06-18 17:28:48 +03001808 *ppowner = &(hub->ports[port1 - 1]->port_owner);
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001809 return 0;
1810}
1811
1812/* In the following three functions, the caller must hold hdev's lock */
Lan Tianyu336c5c32012-07-06 14:13:52 +08001813int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
1814 struct dev_state *owner)
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001815{
1816 int rc;
Lan Tianyu336c5c32012-07-06 14:13:52 +08001817 struct dev_state **powner;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001818
1819 rc = find_port_owner(hdev, port1, &powner);
1820 if (rc)
1821 return rc;
1822 if (*powner)
1823 return -EBUSY;
1824 *powner = owner;
1825 return rc;
1826}
1827
Lan Tianyu336c5c32012-07-06 14:13:52 +08001828int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
1829 struct dev_state *owner)
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001830{
1831 int rc;
Lan Tianyu336c5c32012-07-06 14:13:52 +08001832 struct dev_state **powner;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001833
1834 rc = find_port_owner(hdev, port1, &powner);
1835 if (rc)
1836 return rc;
1837 if (*powner != owner)
1838 return -ENOENT;
1839 *powner = NULL;
1840 return rc;
1841}
1842
Lan Tianyu336c5c32012-07-06 14:13:52 +08001843void usb_hub_release_all_ports(struct usb_device *hdev, struct dev_state *owner)
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001844{
Lan Tianyuad493e52013-01-23 04:26:30 +08001845 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001846 int n;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001847
Lan Tianyufa2a9562012-09-05 13:44:31 +08001848 for (n = 0; n < hdev->maxchild; n++) {
1849 if (hub->ports[n]->port_owner == owner)
1850 hub->ports[n]->port_owner = NULL;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001851 }
Lan Tianyufa2a9562012-09-05 13:44:31 +08001852
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001853}
1854
1855/* The caller must hold udev's lock */
1856bool usb_device_is_owned(struct usb_device *udev)
1857{
1858 struct usb_hub *hub;
1859
1860 if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
1861 return false;
Lan Tianyuad493e52013-01-23 04:26:30 +08001862 hub = usb_hub_to_struct_hub(udev->parent);
Lan Tianyufa2a9562012-09-05 13:44:31 +08001863 return !!hub->ports[udev->portnum - 1]->port_owner;
Alan Stern7cbe5dc2009-06-29 10:56:54 -04001864}
1865
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866static void recursively_mark_NOTATTACHED(struct usb_device *udev)
1867{
Lan Tianyuad493e52013-01-23 04:26:30 +08001868 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 int i;
1870
1871 for (i = 0; i < udev->maxchild; ++i) {
Lan Tianyuff823c792012-09-05 13:44:32 +08001872 if (hub->ports[i]->child)
1873 recursively_mark_NOTATTACHED(hub->ports[i]->child);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 }
Alan Stern9bbdf1e2010-01-08 12:57:28 -05001875 if (udev->state == USB_STATE_SUSPENDED)
Sarah Sharp15123002007-12-21 16:54:15 -08001876 udev->active_duration -= jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 udev->state = USB_STATE_NOTATTACHED;
1878}
1879
1880/**
1881 * usb_set_device_state - change a device's current state (usbcore, hcds)
1882 * @udev: pointer to device whose state should be changed
1883 * @new_state: new state value to be stored
1884 *
1885 * udev->state is _not_ fully protected by the device lock. Although
1886 * most transitions are made only while holding the lock, the state can
1887 * can change to USB_STATE_NOTATTACHED at almost any time. This
1888 * is so that devices can be marked as disconnected as soon as possible,
1889 * without having to wait for any semaphores to be released. As a result,
1890 * all changes to any device's state must be protected by the
1891 * device_state_lock spinlock.
1892 *
1893 * Once a device has been added to the device tree, all changes to its state
1894 * should be made using this routine. The state should _not_ be set directly.
1895 *
1896 * If udev->state is already USB_STATE_NOTATTACHED then no change is made.
1897 * Otherwise udev->state is set to new_state, and if new_state is
1898 * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
1899 * to USB_STATE_NOTATTACHED.
1900 */
1901void usb_set_device_state(struct usb_device *udev,
1902 enum usb_device_state new_state)
1903{
1904 unsigned long flags;
Rafael J. Wysocki4681b172011-02-08 23:25:48 +01001905 int wakeup = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906
1907 spin_lock_irqsave(&device_state_lock, flags);
1908 if (udev->state == USB_STATE_NOTATTACHED)
1909 ; /* do nothing */
David Brownellb94dc6b2005-09-12 19:39:39 -07001910 else if (new_state != USB_STATE_NOTATTACHED) {
David Brownellfb669cc2006-01-24 08:40:27 -08001911
1912 /* root hub wakeup capabilities are managed out-of-band
1913 * and may involve silicon errata ... ignore them here.
1914 */
1915 if (udev->parent) {
Alan Stern645daaa2006-08-30 15:47:02 -04001916 if (udev->state == USB_STATE_SUSPENDED
1917 || new_state == USB_STATE_SUSPENDED)
1918 ; /* No change to wakeup settings */
1919 else if (new_state == USB_STATE_CONFIGURED)
Rafael J. Wysocki4681b172011-02-08 23:25:48 +01001920 wakeup = udev->actconfig->desc.bmAttributes
1921 & USB_CONFIG_ATT_WAKEUP;
Alan Stern645daaa2006-08-30 15:47:02 -04001922 else
Rafael J. Wysocki4681b172011-02-08 23:25:48 +01001923 wakeup = 0;
David Brownellfb669cc2006-01-24 08:40:27 -08001924 }
Sarah Sharp15123002007-12-21 16:54:15 -08001925 if (udev->state == USB_STATE_SUSPENDED &&
1926 new_state != USB_STATE_SUSPENDED)
1927 udev->active_duration -= jiffies;
1928 else if (new_state == USB_STATE_SUSPENDED &&
1929 udev->state != USB_STATE_SUSPENDED)
1930 udev->active_duration += jiffies;
Alan Stern645daaa2006-08-30 15:47:02 -04001931 udev->state = new_state;
David Brownellb94dc6b2005-09-12 19:39:39 -07001932 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 recursively_mark_NOTATTACHED(udev);
1934 spin_unlock_irqrestore(&device_state_lock, flags);
Rafael J. Wysocki4681b172011-02-08 23:25:48 +01001935 if (wakeup >= 0)
1936 device_set_wakeup_capable(&udev->dev, wakeup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937}
David Vrabel6da9c992009-02-18 14:43:47 +00001938EXPORT_SYMBOL_GPL(usb_set_device_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001940/*
Alan Stern3b29b682011-02-22 09:53:41 -05001941 * Choose a device number.
1942 *
1943 * Device numbers are used as filenames in usbfs. On USB-1.1 and
1944 * USB-2.0 buses they are also used as device addresses, however on
1945 * USB-3.0 buses the address is assigned by the controller hardware
1946 * and it usually is not the same as the device number.
1947 *
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001948 * WUSB devices are simple: they have no hubs behind, so the mapping
1949 * device <-> virtual port number becomes 1:1. Why? to simplify the
1950 * life of the device connection logic in
1951 * drivers/usb/wusbcore/devconnect.c. When we do the initial secret
1952 * handshake we need to assign a temporary address in the unauthorized
1953 * space. For simplicity we use the first virtual port number found to
1954 * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
1955 * and that becomes it's address [X < 128] or its unauthorized address
1956 * [X | 0x80].
1957 *
1958 * We add 1 as an offset to the one-based USB-stack port number
1959 * (zero-based wusb virtual port index) for two reasons: (a) dev addr
1960 * 0 is reserved by USB for default address; (b) Linux's USB stack
1961 * uses always #1 for the root hub of the controller. So USB stack's
1962 * port #1, which is wusb virtual-port #0 has address #2.
Sarah Sharpc6515272009-04-27 19:57:26 -07001963 *
1964 * Devices connected under xHCI are not as simple. The host controller
1965 * supports virtualization, so the hardware assigns device addresses and
1966 * the HCD must setup data structures before issuing a set address
1967 * command to the hardware.
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001968 */
Alan Stern3b29b682011-02-22 09:53:41 -05001969static void choose_devnum(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970{
1971 int devnum;
1972 struct usb_bus *bus = udev->bus;
1973
1974 /* If khubd ever becomes multithreaded, this will need a lock */
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001975 if (udev->wusb) {
1976 devnum = udev->portnum + 1;
1977 BUG_ON(test_bit(devnum, bus->devmap.devicemap));
1978 } else {
1979 /* Try to allocate the next devnum beginning at
1980 * bus->devnum_next. */
1981 devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
1982 bus->devnum_next);
1983 if (devnum >= 128)
1984 devnum = find_next_zero_bit(bus->devmap.devicemap,
1985 128, 1);
Matthias Beyer469271f2013-10-10 23:41:27 +02001986 bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07001987 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 if (devnum < 128) {
1989 set_bit(devnum, bus->devmap.devicemap);
1990 udev->devnum = devnum;
1991 }
1992}
1993
Alan Stern3b29b682011-02-22 09:53:41 -05001994static void release_devnum(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995{
1996 if (udev->devnum > 0) {
1997 clear_bit(udev->devnum, udev->bus->devmap.devicemap);
1998 udev->devnum = -1;
1999 }
2000}
2001
Alan Stern3b29b682011-02-22 09:53:41 -05002002static void update_devnum(struct usb_device *udev, int devnum)
David Vrabel4953d142008-04-08 13:24:46 -07002003{
2004 /* The address for a WUSB device is managed by wusbcore. */
2005 if (!udev->wusb)
2006 udev->devnum = devnum;
2007}
2008
Herbert Xuf7410ce2010-01-10 20:15:03 +11002009static void hub_free_dev(struct usb_device *udev)
2010{
2011 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2012
2013 /* Root hubs aren't real devices, so don't free HCD resources */
2014 if (hcd->driver->free_dev && udev->parent)
2015 hcd->driver->free_dev(hcd, udev);
2016}
2017
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018/**
2019 * usb_disconnect - disconnect a device (usbcore-internal)
2020 * @pdev: pointer to device being disconnected
2021 * Context: !in_interrupt ()
2022 *
2023 * Something got disconnected. Get rid of it and all of its children.
2024 *
2025 * If *pdev is a normal device then the parent hub must already be locked.
Bjorn Helgaasdb8f2aa2013-09-13 13:57:34 -06002026 * If *pdev is a root hub then the caller must hold the usb_bus_list_lock,
2027 * which protects the set of root hubs as well as the list of buses.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 *
2029 * Only hub drivers (including virtual root hub drivers for host
2030 * controllers) should ever call this.
2031 *
2032 * This call is synchronous, and may not be used in an interrupt context.
2033 */
2034void usb_disconnect(struct usb_device **pdev)
2035{
2036 struct usb_device *udev = *pdev;
Lan Tianyuad493e52013-01-23 04:26:30 +08002037 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 int i;
2039
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 /* mark the device as inactive, so any further urb submissions for
2041 * this device (and any of its children) will fail immediately.
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002042 * this quiesces everything except pending urbs.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 */
2044 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
Alan Stern3b29b682011-02-22 09:53:41 -05002045 dev_info(&udev->dev, "USB disconnect, device number %d\n",
2046 udev->devnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047
Alan Stern9ad3d6c2005-11-17 17:10:32 -05002048 usb_lock_device(udev);
2049
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 /* Free up all the children before we remove this device */
Huajun Li88162302012-03-12 21:00:19 +08002051 for (i = 0; i < udev->maxchild; i++) {
Lan Tianyuff823c792012-09-05 13:44:32 +08002052 if (hub->ports[i]->child)
2053 usb_disconnect(&hub->ports[i]->child);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 }
2055
2056 /* deallocate hcd/hardware state ... nuking all pending urbs and
2057 * cleaning up all state associated with the current configuration
2058 * so that the hardware is now fully quiesced.
2059 */
Alan Stern782da722006-07-01 22:09:35 -04002060 dev_dbg (&udev->dev, "unregistering device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 usb_disable_device(udev, 0);
Alan Sterncde217a2008-10-21 15:28:46 -04002062 usb_hcd_synchronize_unlinks(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063
Lan Tianyufde26382013-01-20 01:53:33 +08002064 if (udev->parent) {
Lan Tianyuad493e52013-01-23 04:26:30 +08002065 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2066 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
Lan Tianyufde26382013-01-20 01:53:33 +08002067
2068 sysfs_remove_link(&udev->dev.kobj, "port");
2069 sysfs_remove_link(&port_dev->dev.kobj, "device");
Lan Tianyu971fcd42013-01-23 04:26:29 +08002070
Lan Tianyuad493e52013-01-23 04:26:30 +08002071 if (!port_dev->did_runtime_put)
2072 pm_runtime_put(&port_dev->dev);
2073 else
2074 port_dev->did_runtime_put = false;
Lan Tianyufde26382013-01-20 01:53:33 +08002075 }
2076
Alan Stern3b23dd62008-12-05 14:10:34 -05002077 usb_remove_ep_devs(&udev->ep0);
Alan Stern782da722006-07-01 22:09:35 -04002078 usb_unlock_device(udev);
Greg Kroah-Hartman3099e752005-06-20 21:15:16 -07002079
Alan Stern782da722006-07-01 22:09:35 -04002080 /* Unregister the device. The device driver is responsible
Alan Stern3b23dd62008-12-05 14:10:34 -05002081 * for de-configuring the device and invoking the remove-device
2082 * notifier chain (used by usbfs and possibly others).
Alan Stern782da722006-07-01 22:09:35 -04002083 */
2084 device_del(&udev->dev);
2085
2086 /* Free the device number and delete the parent's children[]
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 * (or root_hub) pointer.
2088 */
Alan Stern3b29b682011-02-22 09:53:41 -05002089 release_devnum(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091 /* Avoid races with recursively_mark_NOTATTACHED() */
2092 spin_lock_irq(&device_state_lock);
2093 *pdev = NULL;
2094 spin_unlock_irq(&device_state_lock);
2095
Herbert Xuf7410ce2010-01-10 20:15:03 +11002096 hub_free_dev(udev);
2097
Alan Stern782da722006-07-01 22:09:35 -04002098 put_device(&udev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099}
2100
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -08002101#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102static void show_string(struct usb_device *udev, char *id, char *string)
2103{
2104 if (!string)
2105 return;
Joe Perchesf2ec5222012-10-28 01:05:51 -07002106 dev_info(&udev->dev, "%s: %s\n", id, string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107}
2108
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -08002109static void announce_device(struct usb_device *udev)
2110{
2111 dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
2112 le16_to_cpu(udev->descriptor.idVendor),
2113 le16_to_cpu(udev->descriptor.idProduct));
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08002114 dev_info(&udev->dev,
2115 "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -08002116 udev->descriptor.iManufacturer,
2117 udev->descriptor.iProduct,
2118 udev->descriptor.iSerialNumber);
2119 show_string(udev, "Product", udev->product);
2120 show_string(udev, "Manufacturer", udev->manufacturer);
2121 show_string(udev, "SerialNumber", udev->serial);
2122}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123#else
Greg Kroah-Hartmanf2a383e2007-11-26 22:11:55 -08002124static inline void announce_device(struct usb_device *udev) { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125#endif
2126
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127#ifdef CONFIG_USB_OTG
2128#include "otg_whitelist.h"
2129#endif
2130
Oliver Neukum3ede7602007-01-11 14:35:50 +01002131/**
Alan Stern8d8558d2009-12-08 15:50:41 -05002132 * usb_enumerate_device_otg - FIXME (usbcore-internal)
Oliver Neukum3ede7602007-01-11 14:35:50 +01002133 * @udev: newly addressed device (in ADDRESS state)
2134 *
Alan Stern8d8558d2009-12-08 15:50:41 -05002135 * Finish enumeration for On-The-Go devices
Yacine Belkadi626f0902013-08-02 20:10:04 +02002136 *
2137 * Return: 0 if successful. A negative error code otherwise.
Oliver Neukum3ede7602007-01-11 14:35:50 +01002138 */
Alan Stern8d8558d2009-12-08 15:50:41 -05002139static int usb_enumerate_device_otg(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140{
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002141 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142
2143#ifdef CONFIG_USB_OTG
2144 /*
2145 * OTG-aware devices on OTG-capable root hubs may be able to use SRP,
2146 * to wake us after we've powered off VBUS; and HNP, switching roles
2147 * "host" to "peripheral". The OTG descriptor helps figure this out.
2148 */
2149 if (!udev->bus->is_b_host
2150 && udev->config
2151 && udev->parent == udev->bus->root_hub) {
Felipe Balbi2eb50522009-12-04 15:47:43 +02002152 struct usb_otg_descriptor *desc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 struct usb_bus *bus = udev->bus;
2154
2155 /* descriptor may appear anywhere in config */
2156 if (__usb_get_extra_descriptor (udev->rawdescriptors[0],
2157 le16_to_cpu(udev->config[0].desc.wTotalLength),
2158 USB_DT_OTG, (void **) &desc) == 0) {
2159 if (desc->bmAttributes & USB_OTG_HNP) {
Alan Stern12c3da32005-11-23 12:09:52 -05002160 unsigned port1 = udev->portnum;
David Brownellfc849b82006-09-18 16:53:26 -07002161
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 dev_info(&udev->dev,
2163 "Dual-Role OTG device on %sHNP port\n",
2164 (port1 == bus->otg_port)
2165 ? "" : "non-");
2166
2167 /* enable HNP before suspend, it's simpler */
2168 if (port1 == bus->otg_port)
2169 bus->b_hnp_enable = 1;
2170 err = usb_control_msg(udev,
2171 usb_sndctrlpipe(udev, 0),
2172 USB_REQ_SET_FEATURE, 0,
2173 bus->b_hnp_enable
2174 ? USB_DEVICE_B_HNP_ENABLE
2175 : USB_DEVICE_A_ALT_HNP_SUPPORT,
2176 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
2177 if (err < 0) {
2178 /* OTG MESSAGE: report errors here,
2179 * customize to match your product.
2180 */
2181 dev_info(&udev->dev,
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08002182 "can't set HNP mode: %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 err);
2184 bus->b_hnp_enable = 0;
2185 }
2186 }
2187 }
2188 }
2189
2190 if (!is_targeted(udev)) {
2191
2192 /* Maybe it can talk to us, though we can't talk to it.
2193 * (Includes HNP test device.)
2194 */
2195 if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
David Brownell634a84f2009-01-15 13:51:28 -08002196 err = usb_port_suspend(udev, PMSG_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 if (err < 0)
2198 dev_dbg(&udev->dev, "HNP fail, %d\n", err);
2199 }
Vikram Panditaffcdc182007-05-25 21:31:07 -07002200 err = -ENOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 goto fail;
2202 }
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002203fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204#endif
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002205 return err;
2206}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002208
2209/**
Alan Stern8d8558d2009-12-08 15:50:41 -05002210 * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002211 * @udev: newly addressed device (in ADDRESS state)
2212 *
2213 * This is only called by usb_new_device() and usb_authorize_device()
2214 * and FIXME -- all comments that apply to them apply here wrt to
2215 * environment.
2216 *
2217 * If the device is WUSB and not authorized, we don't attempt to read
2218 * the string descriptors, as they will be errored out by the device
2219 * until it has been authorized.
Yacine Belkadi626f0902013-08-02 20:10:04 +02002220 *
2221 * Return: 0 if successful. A negative error code otherwise.
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002222 */
Alan Stern8d8558d2009-12-08 15:50:41 -05002223static int usb_enumerate_device(struct usb_device *udev)
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002224{
2225 int err;
2226
2227 if (udev->config == NULL) {
2228 err = usb_get_configuration(udev);
2229 if (err < 0) {
Alan Sterne9e88fb2013-03-27 16:14:01 -04002230 if (err != -ENODEV)
2231 dev_err(&udev->dev, "can't read configurations, error %d\n",
2232 err);
Laurent Pinchart80da2e02012-07-19 12:39:13 +02002233 return err;
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002234 }
2235 }
2236 if (udev->wusb == 1 && udev->authorized == 0) {
2237 udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
2238 udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
2239 udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
Matthias Beyer469271f2013-10-10 23:41:27 +02002240 } else {
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002241 /* read the standard strings and cache them if present */
2242 udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
2243 udev->manufacturer = usb_cache_string(udev,
2244 udev->descriptor.iManufacturer);
2245 udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
2246 }
Alan Stern8d8558d2009-12-08 15:50:41 -05002247 err = usb_enumerate_device_otg(udev);
Laurent Pinchart80da2e02012-07-19 12:39:13 +02002248 if (err < 0)
2249 return err;
2250
2251 usb_detect_interface_quirks(udev);
2252
2253 return 0;
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002254}
2255
Matthew Garrettd35e70d2012-02-03 17:11:55 -05002256static void set_usb_port_removable(struct usb_device *udev)
2257{
2258 struct usb_device *hdev = udev->parent;
2259 struct usb_hub *hub;
2260 u8 port = udev->portnum;
2261 u16 wHubCharacteristics;
2262 bool removable = true;
2263
2264 if (!hdev)
2265 return;
2266
Lan Tianyuad493e52013-01-23 04:26:30 +08002267 hub = usb_hub_to_struct_hub(udev->parent);
Matthew Garrettd35e70d2012-02-03 17:11:55 -05002268
2269 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
2270
2271 if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
2272 return;
2273
2274 if (hub_is_superspeed(hdev)) {
Lan Tianyuca3c1532012-09-11 04:22:36 +08002275 if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
2276 & (1 << port))
Matthew Garrettd35e70d2012-02-03 17:11:55 -05002277 removable = false;
2278 } else {
2279 if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
2280 removable = false;
2281 }
2282
2283 if (removable)
2284 udev->removable = USB_DEVICE_REMOVABLE;
2285 else
2286 udev->removable = USB_DEVICE_FIXED;
2287}
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002288
2289/**
2290 * usb_new_device - perform initial device setup (usbcore-internal)
2291 * @udev: newly addressed device (in ADDRESS state)
2292 *
Alan Stern8d8558d2009-12-08 15:50:41 -05002293 * This is called with devices which have been detected but not fully
2294 * enumerated. The device descriptor is available, but not descriptors
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002295 * for any device configuration. The caller must have locked either
2296 * the parent hub (if udev is a normal device) or else the
2297 * usb_bus_list_lock (if udev is a root hub). The parent's pointer to
2298 * udev has already been installed, but udev is not yet visible through
2299 * sysfs or other filesystem code.
2300 *
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002301 * This call is synchronous, and may not be used in an interrupt context.
2302 *
2303 * Only the hub driver or root-hub registrar should ever call this.
Yacine Belkadi626f0902013-08-02 20:10:04 +02002304 *
2305 * Return: Whether the device is configured properly or not. Zero if the
2306 * interface was registered with the driver core; else a negative errno
2307 * value.
2308 *
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002309 */
2310int usb_new_device(struct usb_device *udev)
2311{
2312 int err;
2313
Dan Streetman16985402010-01-06 09:56:53 -05002314 if (udev->parent) {
Dan Streetman16985402010-01-06 09:56:53 -05002315 /* Initialize non-root-hub device wakeup to disabled;
2316 * device (un)configuration controls wakeup capable
2317 * sysfs power/wakeup controls wakeup enabled/disabled
2318 */
2319 device_init_wakeup(&udev->dev, 0);
Dan Streetman16985402010-01-06 09:56:53 -05002320 }
2321
Alan Stern9bbdf1e2010-01-08 12:57:28 -05002322 /* Tell the runtime-PM framework the device is active */
2323 pm_runtime_set_active(&udev->dev);
Alan Sternc08512c2010-11-15 15:57:58 -05002324 pm_runtime_get_noresume(&udev->dev);
Alan Sternfcc4a012010-11-15 15:57:51 -05002325 pm_runtime_use_autosuspend(&udev->dev);
Alan Stern9bbdf1e2010-01-08 12:57:28 -05002326 pm_runtime_enable(&udev->dev);
2327
Alan Sternc08512c2010-11-15 15:57:58 -05002328 /* By default, forbid autosuspend for all devices. It will be
2329 * allowed for hubs during binding.
2330 */
2331 usb_disable_autosuspend(udev);
2332
Alan Stern8d8558d2009-12-08 15:50:41 -05002333 err = usb_enumerate_device(udev); /* Read descriptors */
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002334 if (err < 0)
2335 goto fail;
Sarah Sharpc6515272009-04-27 19:57:26 -07002336 dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
2337 udev->devnum, udev->bus->busnum,
2338 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
Kay Sievers9f8b17e2007-03-13 15:59:31 +01002339 /* export the usbdev device-node for libusb */
2340 udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
2341 (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2342
Alan Stern6cd13202008-11-13 15:08:30 -05002343 /* Tell the world! */
2344 announce_device(udev);
Alan Stern195af2c2007-07-16 15:28:19 -04002345
Theodore Ts'ob04b3152012-07-04 11:22:20 -04002346 if (udev->serial)
2347 add_device_randomness(udev->serial, strlen(udev->serial));
2348 if (udev->product)
2349 add_device_randomness(udev->product, strlen(udev->product));
2350 if (udev->manufacturer)
2351 add_device_randomness(udev->manufacturer,
2352 strlen(udev->manufacturer));
2353
Rafael J. Wysocki927bc912010-02-08 19:18:16 +01002354 device_enable_async_suspend(&udev->dev);
Matthew Garrettd35e70d2012-02-03 17:11:55 -05002355
2356 /*
2357 * check whether the hub marks this port as non-removable. Do it
2358 * now so that platform-specific data can override it in
2359 * device_add()
2360 */
2361 if (udev->parent)
2362 set_usb_port_removable(udev);
2363
Alan Stern782da722006-07-01 22:09:35 -04002364 /* Register the device. The device driver is responsible
Alan Stern3b23dd62008-12-05 14:10:34 -05002365 * for configuring the device and invoking the add-device
2366 * notifier chain (used by usbfs and possibly others).
Alan Stern782da722006-07-01 22:09:35 -04002367 */
Kay Sievers9f8b17e2007-03-13 15:59:31 +01002368 err = device_add(&udev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 if (err) {
2370 dev_err(&udev->dev, "can't device_add, error %d\n", err);
2371 goto fail;
2372 }
Alan Stern9ad3d6c2005-11-17 17:10:32 -05002373
Lan Tianyufde26382013-01-20 01:53:33 +08002374 /* Create link files between child device and usb port device. */
2375 if (udev->parent) {
Lan Tianyuad493e52013-01-23 04:26:30 +08002376 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2377 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
Lan Tianyufde26382013-01-20 01:53:33 +08002378
2379 err = sysfs_create_link(&udev->dev.kobj,
2380 &port_dev->dev.kobj, "port");
2381 if (err)
2382 goto fail;
2383
2384 err = sysfs_create_link(&port_dev->dev.kobj,
2385 &udev->dev.kobj, "device");
2386 if (err) {
2387 sysfs_remove_link(&udev->dev.kobj, "port");
2388 goto fail;
2389 }
Lan Tianyu971fcd42013-01-23 04:26:29 +08002390
2391 pm_runtime_get_sync(&port_dev->dev);
Lan Tianyufde26382013-01-20 01:53:33 +08002392 }
2393
Alan Stern3b23dd62008-12-05 14:10:34 -05002394 (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
Alan Sternc08512c2010-11-15 15:57:58 -05002395 usb_mark_last_busy(udev);
2396 pm_runtime_put_sync_autosuspend(&udev->dev);
Greg Kroah-Hartmanc0664752006-08-11 01:55:12 -07002397 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398
2399fail:
2400 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
Alan Stern9bbdf1e2010-01-08 12:57:28 -05002401 pm_runtime_disable(&udev->dev);
2402 pm_runtime_set_suspended(&udev->dev);
Inaky Perez-Gonzalezd9d16e82007-07-31 20:34:05 -07002403 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404}
2405
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002406
2407/**
Randy Dunlapfd39c862007-10-15 17:30:02 -07002408 * usb_deauthorize_device - deauthorize a device (usbcore-internal)
2409 * @usb_dev: USB device
2410 *
2411 * Move the USB device to a very basic state where interfaces are disabled
2412 * and the device is in fact unconfigured and unusable.
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002413 *
2414 * We share a lock (that we have) with device_del(), so we need to
2415 * defer its call.
Yacine Belkadi626f0902013-08-02 20:10:04 +02002416 *
2417 * Return: 0.
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002418 */
2419int usb_deauthorize_device(struct usb_device *usb_dev)
2420{
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002421 usb_lock_device(usb_dev);
2422 if (usb_dev->authorized == 0)
2423 goto out_unauthorized;
Alan Sternda307122009-12-08 15:54:44 -05002424
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002425 usb_dev->authorized = 0;
2426 usb_set_configuration(usb_dev, -1);
Alan Sternda307122009-12-08 15:54:44 -05002427
2428 kfree(usb_dev->product);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002429 usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
Alan Sternda307122009-12-08 15:54:44 -05002430 kfree(usb_dev->manufacturer);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002431 usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
Alan Sternda307122009-12-08 15:54:44 -05002432 kfree(usb_dev->serial);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002433 usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
Alan Sternda307122009-12-08 15:54:44 -05002434
2435 usb_destroy_configuration(usb_dev);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002436 usb_dev->descriptor.bNumConfigurations = 0;
Alan Sternda307122009-12-08 15:54:44 -05002437
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002438out_unauthorized:
2439 usb_unlock_device(usb_dev);
2440 return 0;
2441}
2442
2443
2444int usb_authorize_device(struct usb_device *usb_dev)
2445{
2446 int result = 0, c;
Alan Sternda307122009-12-08 15:54:44 -05002447
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002448 usb_lock_device(usb_dev);
2449 if (usb_dev->authorized == 1)
2450 goto out_authorized;
Alan Sternda307122009-12-08 15:54:44 -05002451
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002452 result = usb_autoresume_device(usb_dev);
2453 if (result < 0) {
2454 dev_err(&usb_dev->dev,
2455 "can't autoresume for authorization: %d\n", result);
2456 goto error_autoresume;
2457 }
2458 result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
2459 if (result < 0) {
2460 dev_err(&usb_dev->dev, "can't re-read device descriptor for "
2461 "authorization: %d\n", result);
2462 goto error_device_descriptor;
2463 }
Alan Sternda307122009-12-08 15:54:44 -05002464
2465 kfree(usb_dev->product);
2466 usb_dev->product = NULL;
2467 kfree(usb_dev->manufacturer);
2468 usb_dev->manufacturer = NULL;
2469 kfree(usb_dev->serial);
2470 usb_dev->serial = NULL;
2471
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002472 usb_dev->authorized = 1;
Alan Stern8d8558d2009-12-08 15:50:41 -05002473 result = usb_enumerate_device(usb_dev);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002474 if (result < 0)
Alan Stern8d8558d2009-12-08 15:50:41 -05002475 goto error_enumerate;
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002476 /* Choose and set the configuration. This registers the interfaces
2477 * with the driver core and lets interface drivers bind to them.
2478 */
Greg Kroah-Hartmanb5ea0602007-08-02 22:44:27 -06002479 c = usb_choose_configuration(usb_dev);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002480 if (c >= 0) {
2481 result = usb_set_configuration(usb_dev, c);
2482 if (result) {
2483 dev_err(&usb_dev->dev,
2484 "can't set config #%d, error %d\n", c, result);
2485 /* This need not be fatal. The user can try to
2486 * set other configurations. */
2487 }
2488 }
2489 dev_info(&usb_dev->dev, "authorized to connect\n");
Alan Sternda307122009-12-08 15:54:44 -05002490
Alan Stern8d8558d2009-12-08 15:50:41 -05002491error_enumerate:
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002492error_device_descriptor:
Alan Sternda307122009-12-08 15:54:44 -05002493 usb_autosuspend_device(usb_dev);
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002494error_autoresume:
2495out_authorized:
Matthias Beyer781b2132013-10-10 23:41:29 +02002496 usb_unlock_device(usb_dev); /* complements locktree */
Inaky Perez-Gonzalez93993a02007-07-31 20:34:06 -07002497 return result;
2498}
2499
2500
Inaky Perez-Gonzalez0165de02006-08-25 19:35:29 -07002501/* Returns 1 if @hub is a WUSB root hub, 0 otherwise */
2502static unsigned hub_is_wusb(struct usb_hub *hub)
2503{
2504 struct usb_hcd *hcd;
2505 if (hub->hdev->parent != NULL) /* not a root hub? */
2506 return 0;
2507 hcd = container_of(hub->hdev->bus, struct usb_hcd, self);
2508 return hcd->wireless;
2509}
2510
2511
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512#define PORT_RESET_TRIES 5
2513#define SET_ADDRESS_TRIES 2
2514#define GET_DESCRIPTOR_TRIES 2
2515#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))
Rusty Russell90ab5ee2012-01-13 09:32:20 +10302516#define USE_NEW_SCHEME(i) ((i) / 2 == (int)old_scheme_first)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517
2518#define HUB_ROOT_RESET_TIME 50 /* times are in msec */
2519#define HUB_SHORT_RESET_TIME 10
Andiry Xu75d7cf72011-09-13 16:41:11 -07002520#define HUB_BH_RESET_TIME 50
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521#define HUB_LONG_RESET_TIME 200
Sarah Sharp77c7f072012-11-14 17:16:52 -08002522#define HUB_RESET_TIMEOUT 800
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523
Sarah Sharp10d674a2011-09-14 14:24:52 -07002524static int hub_port_reset(struct usb_hub *hub, int port1,
2525 struct usb_device *udev, unsigned int delay, bool warm);
2526
Stanislaw Ledwon8bea2bd2012-06-18 15:20:00 +02002527/* Is a USB 3.0 port in the Inactive or Complinance Mode state?
2528 * Port worm reset is required to recover
2529 */
2530static bool hub_port_warm_reset_required(struct usb_hub *hub, u16 portstatus)
Sarah Sharp10d674a2011-09-14 14:24:52 -07002531{
2532 return hub_is_superspeed(hub->hdev) &&
Stanislaw Ledwon8bea2bd2012-06-18 15:20:00 +02002533 (((portstatus & USB_PORT_STAT_LINK_STATE) ==
2534 USB_SS_PORT_LS_SS_INACTIVE) ||
2535 ((portstatus & USB_PORT_STAT_LINK_STATE) ==
2536 USB_SS_PORT_LS_COMP_MOD)) ;
Sarah Sharp10d674a2011-09-14 14:24:52 -07002537}
2538
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539static int hub_port_wait_reset(struct usb_hub *hub, int port1,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002540 struct usb_device *udev, unsigned int delay, bool warm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541{
2542 int delay_time, ret;
2543 u16 portstatus;
2544 u16 portchange;
2545
2546 for (delay_time = 0;
2547 delay_time < HUB_RESET_TIMEOUT;
2548 delay_time += delay) {
2549 /* wait to give the device a chance to reset */
2550 msleep(delay);
2551
2552 /* read and decode port status */
2553 ret = hub_port_status(hub, port1, &portstatus, &portchange);
2554 if (ret < 0)
2555 return ret;
2556
Sarah Sharp4f434472012-11-15 14:58:04 -08002557 /* The port state is unknown until the reset completes. */
Sarah Sharp470f0be2012-12-11 10:14:03 -08002558 if (!(portstatus & USB_PORT_STAT_RESET))
2559 break;
Sarah Sharp4f434472012-11-15 14:58:04 -08002560
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 /* switch to the long delay after two short delay failures */
2562 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
2563 delay = HUB_LONG_RESET_TIME;
2564
2565 dev_dbg (hub->intfdev,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002566 "port %d not %sreset yet, waiting %dms\n",
2567 port1, warm ? "warm " : "", delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 }
2569
Sarah Sharp470f0be2012-12-11 10:14:03 -08002570 if ((portstatus & USB_PORT_STAT_RESET))
2571 return -EBUSY;
2572
2573 if (hub_port_warm_reset_required(hub, portstatus))
2574 return -ENOTCONN;
2575
2576 /* Device went away? */
2577 if (!(portstatus & USB_PORT_STAT_CONNECTION))
2578 return -ENOTCONN;
2579
2580 /* bomb out completely if the connection bounced. A USB 3.0
2581 * connection may bounce if multiple warm resets were issued,
2582 * but the device may have successfully re-connected. Ignore it.
2583 */
2584 if (!hub_is_superspeed(hub->hdev) &&
2585 (portchange & USB_PORT_STAT_C_CONNECTION))
2586 return -ENOTCONN;
2587
2588 if (!(portstatus & USB_PORT_STAT_ENABLE))
2589 return -EBUSY;
2590
2591 if (!udev)
2592 return 0;
2593
2594 if (hub_is_wusb(hub))
2595 udev->speed = USB_SPEED_WIRELESS;
2596 else if (hub_is_superspeed(hub->hdev))
2597 udev->speed = USB_SPEED_SUPER;
2598 else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
2599 udev->speed = USB_SPEED_HIGH;
2600 else if (portstatus & USB_PORT_STAT_LOW_SPEED)
2601 udev->speed = USB_SPEED_LOW;
2602 else
2603 udev->speed = USB_SPEED_FULL;
2604 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605}
2606
Andiry Xu75d7cf72011-09-13 16:41:11 -07002607static void hub_port_finish_reset(struct usb_hub *hub, int port1,
Sarah Sharpa24a6072012-11-01 11:20:44 -07002608 struct usb_device *udev, int *status)
Andiry Xu75d7cf72011-09-13 16:41:11 -07002609{
2610 switch (*status) {
2611 case 0:
Sarah Sharpa24a6072012-11-01 11:20:44 -07002612 /* TRSTRCY = 10 ms; plus some extra */
2613 msleep(10 + 40);
2614 if (udev) {
2615 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2616
2617 update_devnum(udev, 0);
2618 /* The xHC may think the device is already reset,
2619 * so ignore the status.
2620 */
2621 if (hcd->driver->reset_device)
2622 hcd->driver->reset_device(hcd, udev);
Andiry Xu75d7cf72011-09-13 16:41:11 -07002623 }
2624 /* FALL THROUGH */
2625 case -ENOTCONN:
2626 case -ENODEV:
Lan Tianyuad493e52013-01-23 04:26:30 +08002627 usb_clear_port_feature(hub->hdev,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002628 port1, USB_PORT_FEAT_C_RESET);
Sarah Sharp1c7439c62012-11-14 15:58:52 -08002629 if (hub_is_superspeed(hub->hdev)) {
Lan Tianyuad493e52013-01-23 04:26:30 +08002630 usb_clear_port_feature(hub->hdev, port1,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002631 USB_PORT_FEAT_C_BH_PORT_RESET);
Lan Tianyuad493e52013-01-23 04:26:30 +08002632 usb_clear_port_feature(hub->hdev, port1,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002633 USB_PORT_FEAT_C_PORT_LINK_STATE);
Lan Tianyuad493e52013-01-23 04:26:30 +08002634 usb_clear_port_feature(hub->hdev, port1,
Sarah Sharpa24a6072012-11-01 11:20:44 -07002635 USB_PORT_FEAT_C_CONNECTION);
Sarah Sharp1c7439c62012-11-14 15:58:52 -08002636 }
Sarah Sharpa24a6072012-11-01 11:20:44 -07002637 if (udev)
Andiry Xu75d7cf72011-09-13 16:41:11 -07002638 usb_set_device_state(udev, *status
2639 ? USB_STATE_NOTATTACHED
2640 : USB_STATE_DEFAULT);
Andiry Xu75d7cf72011-09-13 16:41:11 -07002641 break;
2642 }
2643}
2644
2645/* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646static int hub_port_reset(struct usb_hub *hub, int port1,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002647 struct usb_device *udev, unsigned int delay, bool warm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648{
2649 int i, status;
Sarah Sharpa24a6072012-11-01 11:20:44 -07002650 u16 portchange, portstatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651
Sarah Sharp0fe51aa2012-11-01 11:20:44 -07002652 if (!hub_is_superspeed(hub->hdev)) {
2653 if (warm) {
Andiry Xu75d7cf72011-09-13 16:41:11 -07002654 dev_err(hub->intfdev, "only USB3 hub support "
2655 "warm reset\n");
2656 return -EINVAL;
2657 }
Sarah Sharp0fe51aa2012-11-01 11:20:44 -07002658 /* Block EHCI CF initialization during the port reset.
2659 * Some companion controllers don't like it when they mix.
2660 */
2661 down_read(&ehci_cf_port_reset_rwsem);
Sarah Sharpd3b9d7a2012-11-01 11:20:44 -07002662 } else if (!warm) {
2663 /*
2664 * If the caller hasn't explicitly requested a warm reset,
2665 * double check and see if one is needed.
2666 */
2667 status = hub_port_status(hub, port1,
2668 &portstatus, &portchange);
2669 if (status < 0)
2670 goto done;
2671
2672 if (hub_port_warm_reset_required(hub, portstatus))
2673 warm = true;
Andiry Xu75d7cf72011-09-13 16:41:11 -07002674 }
Alan Stern32fe0192007-10-10 16:27:07 -04002675
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676 /* Reset the port */
2677 for (i = 0; i < PORT_RESET_TRIES; i++) {
Andiry Xu75d7cf72011-09-13 16:41:11 -07002678 status = set_port_feature(hub->hdev, port1, (warm ?
2679 USB_PORT_FEAT_BH_PORT_RESET :
2680 USB_PORT_FEAT_RESET));
Alan Sterne9e88fb2013-03-27 16:14:01 -04002681 if (status == -ENODEV) {
2682 ; /* The hub is gone */
2683 } else if (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 dev_err(hub->intfdev,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002685 "cannot %sreset port %d (err = %d)\n",
2686 warm ? "warm " : "", port1, status);
2687 } else {
2688 status = hub_port_wait_reset(hub, port1, udev, delay,
2689 warm);
Alan Sterne9e88fb2013-03-27 16:14:01 -04002690 if (status && status != -ENOTCONN && status != -ENODEV)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691 dev_dbg(hub->intfdev,
2692 "port_wait_reset: err = %d\n",
2693 status);
2694 }
2695
Sarah Sharpa24a6072012-11-01 11:20:44 -07002696 /* Check for disconnect or reset */
Andiry Xu75d7cf72011-09-13 16:41:11 -07002697 if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
Sarah Sharpa24a6072012-11-01 11:20:44 -07002698 hub_port_finish_reset(hub, port1, udev, &status);
2699
2700 if (!hub_is_superspeed(hub->hdev))
2701 goto done;
2702
2703 /*
2704 * If a USB 3.0 device migrates from reset to an error
2705 * state, re-issue the warm reset.
2706 */
2707 if (hub_port_status(hub, port1,
2708 &portstatus, &portchange) < 0)
2709 goto done;
2710
2711 if (!hub_port_warm_reset_required(hub, portstatus))
2712 goto done;
2713
2714 /*
2715 * If the port is in SS.Inactive or Compliance Mode, the
2716 * hot or warm reset failed. Try another warm reset.
2717 */
2718 if (!warm) {
2719 dev_dbg(hub->intfdev, "hot reset failed, warm reset port %d\n",
2720 port1);
2721 warm = true;
2722 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 }
2724
2725 dev_dbg (hub->intfdev,
Andiry Xu75d7cf72011-09-13 16:41:11 -07002726 "port %d not enabled, trying %sreset again...\n",
2727 port1, warm ? "warm " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728 delay = HUB_LONG_RESET_TIME;
2729 }
2730
2731 dev_err (hub->intfdev,
2732 "Cannot enable port %i. Maybe the USB cable is bad?\n",
2733 port1);
2734
Andiry Xu75d7cf72011-09-13 16:41:11 -07002735done:
Sarah Sharp0fe51aa2012-11-01 11:20:44 -07002736 if (!hub_is_superspeed(hub->hdev))
Andiry Xu75d7cf72011-09-13 16:41:11 -07002737 up_read(&ehci_cf_port_reset_rwsem);
2738
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 return status;
2740}
2741
Andiry Xu0ed9a572011-04-27 18:07:43 +08002742/* Check if a port is power on */
2743static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
2744{
2745 int ret = 0;
2746
2747 if (hub_is_superspeed(hub->hdev)) {
2748 if (portstatus & USB_SS_PORT_STAT_POWER)
2749 ret = 1;
2750 } else {
2751 if (portstatus & USB_PORT_STAT_POWER)
2752 ret = 1;
2753 }
2754
2755 return ret;
2756}
2757
Alan Sternd388dab2006-07-01 22:14:24 -04002758#ifdef CONFIG_PM
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759
Andiry Xu0ed9a572011-04-27 18:07:43 +08002760/* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
2761static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
2762{
2763 int ret = 0;
2764
2765 if (hub_is_superspeed(hub->hdev)) {
2766 if ((portstatus & USB_PORT_STAT_LINK_STATE)
2767 == USB_SS_PORT_LS_U3)
2768 ret = 1;
2769 } else {
2770 if (portstatus & USB_PORT_STAT_SUSPEND)
2771 ret = 1;
2772 }
2773
2774 return ret;
2775}
Alan Sternb01b03f2008-04-28 11:06:11 -04002776
2777/* Determine whether the device on a port is ready for a normal resume,
2778 * is ready for a reset-resume, or should be disconnected.
2779 */
2780static int check_port_resume_type(struct usb_device *udev,
2781 struct usb_hub *hub, int port1,
2782 int status, unsigned portchange, unsigned portstatus)
2783{
2784 /* Is the device still present? */
Andiry Xu0ed9a572011-04-27 18:07:43 +08002785 if (status || port_is_suspended(hub, portstatus) ||
2786 !port_is_power_on(hub, portstatus) ||
2787 !(portstatus & USB_PORT_STAT_CONNECTION)) {
Alan Sternb01b03f2008-04-28 11:06:11 -04002788 if (status >= 0)
2789 status = -ENODEV;
2790 }
2791
Alan Stern86c57ed2008-06-30 11:14:43 -04002792 /* Can't do a normal resume if the port isn't enabled,
2793 * so try a reset-resume instead.
2794 */
2795 else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
2796 if (udev->persist_enabled)
2797 udev->reset_resume = 1;
2798 else
2799 status = -ENODEV;
2800 }
Alan Sternb01b03f2008-04-28 11:06:11 -04002801
2802 if (status) {
2803 dev_dbg(hub->intfdev,
2804 "port %d status %04x.%04x after resume, %d\n",
2805 port1, portchange, portstatus, status);
2806 } else if (udev->reset_resume) {
2807
2808 /* Late port handoff can set status-change bits */
2809 if (portchange & USB_PORT_STAT_C_CONNECTION)
Lan Tianyuad493e52013-01-23 04:26:30 +08002810 usb_clear_port_feature(hub->hdev, port1,
Alan Sternb01b03f2008-04-28 11:06:11 -04002811 USB_PORT_FEAT_C_CONNECTION);
2812 if (portchange & USB_PORT_STAT_C_ENABLE)
Lan Tianyuad493e52013-01-23 04:26:30 +08002813 usb_clear_port_feature(hub->hdev, port1,
Alan Sternb01b03f2008-04-28 11:06:11 -04002814 USB_PORT_FEAT_C_ENABLE);
2815 }
2816
2817 return status;
2818}
2819
Sarah Sharpf74631e2012-06-25 12:08:08 -07002820int usb_disable_ltm(struct usb_device *udev)
2821{
2822 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2823
2824 /* Check if the roothub and device supports LTM. */
2825 if (!usb_device_supports_ltm(hcd->self.root_hub) ||
2826 !usb_device_supports_ltm(udev))
2827 return 0;
2828
2829 /* Clear Feature LTM Enable can only be sent if the device is
2830 * configured.
2831 */
2832 if (!udev->actconfig)
2833 return 0;
2834
2835 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2836 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
2837 USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
2838 USB_CTRL_SET_TIMEOUT);
2839}
2840EXPORT_SYMBOL_GPL(usb_disable_ltm);
2841
2842void usb_enable_ltm(struct usb_device *udev)
2843{
2844 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2845
2846 /* Check if the roothub and device supports LTM. */
2847 if (!usb_device_supports_ltm(hcd->self.root_hub) ||
2848 !usb_device_supports_ltm(udev))
2849 return;
2850
2851 /* Set Feature LTM Enable can only be sent if the device is
2852 * configured.
2853 */
2854 if (!udev->actconfig)
2855 return;
2856
2857 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2858 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
2859 USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
2860 USB_CTRL_SET_TIMEOUT);
2861}
2862EXPORT_SYMBOL_GPL(usb_enable_ltm);
2863
Lan Tianyu54a3ac02013-01-24 10:31:28 +08002864/*
Alan Stern28e861652013-07-30 15:37:33 -04002865 * usb_enable_remote_wakeup - enable remote wakeup for a device
Lan Tianyu54a3ac02013-01-24 10:31:28 +08002866 * @udev: target device
2867 *
Alan Stern28e861652013-07-30 15:37:33 -04002868 * For USB-2 devices: Set the device's remote wakeup feature.
2869 *
2870 * For USB-3 devices: Assume there's only one function on the device and
2871 * enable remote wake for the first interface. FIXME if the interface
2872 * association descriptor shows there's more than one function.
Lan Tianyu54a3ac02013-01-24 10:31:28 +08002873 */
Alan Stern28e861652013-07-30 15:37:33 -04002874static int usb_enable_remote_wakeup(struct usb_device *udev)
Lan Tianyu54a3ac02013-01-24 10:31:28 +08002875{
Alan Stern28e861652013-07-30 15:37:33 -04002876 if (udev->speed < USB_SPEED_SUPER)
2877 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2878 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
2879 USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
2880 USB_CTRL_SET_TIMEOUT);
2881 else
2882 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2883 USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
2884 USB_INTRF_FUNC_SUSPEND,
2885 USB_INTRF_FUNC_SUSPEND_RW |
2886 USB_INTRF_FUNC_SUSPEND_LP,
2887 NULL, 0, USB_CTRL_SET_TIMEOUT);
2888}
2889
2890/*
2891 * usb_disable_remote_wakeup - disable remote wakeup for a device
2892 * @udev: target device
2893 *
2894 * For USB-2 devices: Clear the device's remote wakeup feature.
2895 *
2896 * For USB-3 devices: Assume there's only one function on the device and
2897 * disable remote wake for the first interface. FIXME if the interface
2898 * association descriptor shows there's more than one function.
2899 */
2900static int usb_disable_remote_wakeup(struct usb_device *udev)
2901{
2902 if (udev->speed < USB_SPEED_SUPER)
2903 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2904 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
2905 USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
2906 USB_CTRL_SET_TIMEOUT);
2907 else
2908 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
Lan Tianyu54a3ac02013-01-24 10:31:28 +08002909 USB_REQ_CLEAR_FEATURE, USB_RECIP_INTERFACE,
2910 USB_INTRF_FUNC_SUSPEND, 0, NULL, 0,
2911 USB_CTRL_SET_TIMEOUT);
2912}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913
Alan Sterne583d9d2013-07-11 14:58:04 -04002914/* Count of wakeup-enabled devices at or below udev */
2915static unsigned wakeup_enabled_descendants(struct usb_device *udev)
2916{
2917 struct usb_hub *hub = usb_hub_to_struct_hub(udev);
2918
2919 return udev->do_remote_wakeup +
2920 (hub ? hub->wakeup_enabled_descendants : 0);
2921}
2922
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923/*
Alan Stern140d8f62006-07-01 22:07:21 -04002924 * usb_port_suspend - suspend a usb device's upstream port
Alan Stern624d6c02007-05-30 15:35:16 -04002925 * @udev: device that's no longer in active use, not a root hub
David Brownell5edbfb72005-09-22 22:45:26 -07002926 * Context: must be able to sleep; device not locked; pm locks held
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 *
2928 * Suspends a USB device that isn't in active use, conserving power.
2929 * Devices may wake out of a suspend, if anything important happens,
2930 * using the remote wakeup mechanism. They may also be taken out of
Alan Stern140d8f62006-07-01 22:07:21 -04002931 * suspend by the host, using usb_port_resume(). It's also routine
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 * to disconnect devices while they are suspended.
2933 *
David Brownell390a8c32005-09-13 19:57:27 -07002934 * This only affects the USB hardware for a device; its interfaces
2935 * (and, for hubs, child devices) must already have been suspended.
2936 *
Alan Stern624d6c02007-05-30 15:35:16 -04002937 * Selective port suspend reduces power; most suspended devices draw
2938 * less than 500 uA. It's also used in OTG, along with remote wakeup.
2939 * All devices below the suspended port are also suspended.
2940 *
2941 * Devices leave suspend state when the host wakes them up. Some devices
2942 * also support "remote wakeup", where the device can activate the USB
2943 * tree above them to deliver data, such as a keypress or packet. In
2944 * some cases, this wakes the USB host.
2945 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946 * Suspending OTG devices may trigger HNP, if that's been enabled
2947 * between a pair of dual-role devices. That will change roles, such
2948 * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
2949 *
Alan Stern4956ecc2007-05-30 16:51:28 -04002950 * Devices on USB hub ports have only one "suspend" state, corresponding
2951 * to ACPI D2, "may cause the device to lose some context".
2952 * State transitions include:
2953 *
2954 * - suspend, resume ... when the VBUS power link stays live
2955 * - suspend, disconnect ... VBUS lost
2956 *
2957 * Once VBUS drop breaks the circuit, the port it's using has to go through
2958 * normal re-enumeration procedures, starting with enabling VBUS power.
2959 * Other than re-initializing the hub (plug/unplug, except for root hubs),
2960 * Linux (2.6) currently has NO mechanisms to initiate that: no khubd
2961 * timer, no SRP, no requests through sysfs.
2962 *
Alan Sterne583d9d2013-07-11 14:58:04 -04002963 * If Runtime PM isn't enabled or used, non-SuperSpeed devices may not get
2964 * suspended until their bus goes into global suspend (i.e., the root
Alan Stern0aa28322013-03-27 16:14:19 -04002965 * hub is suspended). Nevertheless, we change @udev->state to
2966 * USB_STATE_SUSPENDED as this is the device's "logical" state. The actual
2967 * upstream port setting is stored in @udev->port_is_suspended.
Alan Stern4956ecc2007-05-30 16:51:28 -04002968 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969 * Returns 0 on success, else negative errno.
2970 */
Alan Stern65bfd292008-11-25 16:39:18 -05002971int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972{
Lan Tianyuad493e52013-01-23 04:26:30 +08002973 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2974 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
Alan Stern624d6c02007-05-30 15:35:16 -04002975 int port1 = udev->portnum;
2976 int status;
Alan Stern0aa28322013-03-27 16:14:19 -04002977 bool really_suspend = true;
Alan Stern4956ecc2007-05-30 16:51:28 -04002978
Alan Stern624d6c02007-05-30 15:35:16 -04002979 /* enable remote wakeup when appropriate; this lets the device
2980 * wake up the upstream hub (including maybe the root hub).
2981 *
2982 * NOTE: OTG devices may issue remote wakeup (or SRP) even when
2983 * we don't explicitly enable it here.
2984 */
2985 if (udev->do_remote_wakeup) {
Alan Stern28e861652013-07-30 15:37:33 -04002986 status = usb_enable_remote_wakeup(udev);
Oliver Neukum0c487202009-10-19 13:19:41 +02002987 if (status) {
Alan Stern624d6c02007-05-30 15:35:16 -04002988 dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
2989 status);
Oliver Neukum0c487202009-10-19 13:19:41 +02002990 /* bail if autosuspend is requested */
Alan Stern5b1b0b82011-08-19 23:49:48 +02002991 if (PMSG_IS_AUTO(msg))
Alan Stern4fae6f02013-07-30 15:39:02 -04002992 goto err_wakeup;
Oliver Neukum0c487202009-10-19 13:19:41 +02002993 }
Alan Stern624d6c02007-05-30 15:35:16 -04002994 }
2995
Andiry Xu65580b432011-09-23 14:19:52 -07002996 /* disable USB2 hardware LPM */
2997 if (udev->usb2_hw_lpm_enabled == 1)
2998 usb_set_usb2_hardware_lpm(udev, 0);
2999
Sarah Sharpf74631e2012-06-25 12:08:08 -07003000 if (usb_disable_ltm(udev)) {
Alan Stern4fae6f02013-07-30 15:39:02 -04003001 dev_err(&udev->dev, "Failed to disable LTM before suspend\n.");
3002 status = -ENOMEM;
3003 if (PMSG_IS_AUTO(msg))
3004 goto err_ltm;
Sarah Sharpf74631e2012-06-25 12:08:08 -07003005 }
Sarah Sharp83060952012-05-02 14:25:52 -07003006 if (usb_unlocked_disable_lpm(udev)) {
Alan Stern4fae6f02013-07-30 15:39:02 -04003007 dev_err(&udev->dev, "Failed to disable LPM before suspend\n.");
3008 status = -ENOMEM;
3009 if (PMSG_IS_AUTO(msg))
3010 goto err_lpm3;
Sarah Sharp83060952012-05-02 14:25:52 -07003011 }
3012
Alan Stern624d6c02007-05-30 15:35:16 -04003013 /* see 7.1.7.6 */
Andiry Xua7114232011-04-27 18:07:50 +08003014 if (hub_is_superspeed(hub->hdev))
Sarah Sharpc2f60db2012-12-10 15:43:08 -08003015 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
Alan Sterne583d9d2013-07-11 14:58:04 -04003016
Alan Stern0aa28322013-03-27 16:14:19 -04003017 /*
3018 * For system suspend, we do not need to enable the suspend feature
3019 * on individual USB-2 ports. The devices will automatically go
3020 * into suspend a few ms after the root hub stops sending packets.
3021 * The USB 2.0 spec calls this "global suspend".
Alan Sterne583d9d2013-07-11 14:58:04 -04003022 *
3023 * However, many USB hubs have a bug: They don't relay wakeup requests
3024 * from a downstream port if the port's suspend feature isn't on.
3025 * Therefore we will turn on the suspend feature if udev or any of its
3026 * descendants is enabled for remote wakeup.
Alan Stern0aa28322013-03-27 16:14:19 -04003027 */
Alan Sterne583d9d2013-07-11 14:58:04 -04003028 else if (PMSG_IS_AUTO(msg) || wakeup_enabled_descendants(udev) > 0)
3029 status = set_port_feature(hub->hdev, port1,
3030 USB_PORT_FEAT_SUSPEND);
Alan Stern0aa28322013-03-27 16:14:19 -04003031 else {
3032 really_suspend = false;
3033 status = 0;
3034 }
Alan Stern624d6c02007-05-30 15:35:16 -04003035 if (status) {
3036 dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
3037 port1, status);
Alan Sterncbb33002011-06-15 16:29:16 -04003038
Alan Stern4fae6f02013-07-30 15:39:02 -04003039 /* Try to enable USB3 LPM and LTM again */
3040 usb_unlocked_enable_lpm(udev);
3041 err_lpm3:
3042 usb_enable_ltm(udev);
3043 err_ltm:
Andiry Xuc3e751e2012-05-05 00:50:10 +08003044 /* Try to enable USB2 hardware LPM again */
3045 if (udev->usb2_hw_lpm_capable == 1)
3046 usb_set_usb2_hardware_lpm(udev, 1);
3047
Alan Stern4fae6f02013-07-30 15:39:02 -04003048 if (udev->do_remote_wakeup)
3049 (void) usb_disable_remote_wakeup(udev);
3050 err_wakeup:
Sarah Sharp83060952012-05-02 14:25:52 -07003051
Alan Sterncbb33002011-06-15 16:29:16 -04003052 /* System sleep transitions should never fail */
Alan Stern5b1b0b82011-08-19 23:49:48 +02003053 if (!PMSG_IS_AUTO(msg))
Alan Sterncbb33002011-06-15 16:29:16 -04003054 status = 0;
Alan Stern624d6c02007-05-30 15:35:16 -04003055 } else {
Alan Stern30b1a7a2011-09-27 21:54:22 +02003056 dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
3057 (PMSG_IS_AUTO(msg) ? "auto-" : ""),
3058 udev->do_remote_wakeup);
Alan Stern0aa28322013-03-27 16:14:19 -04003059 if (really_suspend) {
3060 udev->port_is_suspended = 1;
Alan Sterne583d9d2013-07-11 14:58:04 -04003061
3062 /* device has up to 10 msec to fully suspend */
Alan Stern0aa28322013-03-27 16:14:19 -04003063 msleep(10);
3064 }
Alan Sterne583d9d2013-07-11 14:58:04 -04003065 usb_set_device_state(udev, USB_STATE_SUSPENDED);
Alan Stern624d6c02007-05-30 15:35:16 -04003066 }
Lan Tianyuad493e52013-01-23 04:26:30 +08003067
Alan Stern4fae6f02013-07-30 15:39:02 -04003068 if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled) {
Lan Tianyu98a4f1f2013-07-03 22:17:54 +08003069 pm_runtime_put_sync(&port_dev->dev);
3070 port_dev->did_runtime_put = true;
Lan Tianyuad493e52013-01-23 04:26:30 +08003071 }
3072
Alan Sternc08512c2010-11-15 15:57:58 -05003073 usb_mark_last_busy(hub->hdev);
Alan Stern4956ecc2007-05-30 16:51:28 -04003074 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075}
David Brownellf3f32532005-09-22 22:37:29 -07003076
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077/*
David Brownell390a8c32005-09-13 19:57:27 -07003078 * If the USB "suspend" state is in use (rather than "global suspend"),
3079 * many devices will be individually taken out of suspend state using
Alan Stern54515fe2007-05-30 15:38:58 -04003080 * special "resume" signaling. This routine kicks in shortly after
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081 * hardware resume signaling is finished, either because of selective
3082 * resume (by host) or remote wakeup (by device) ... now see what changed
3083 * in the tree that's rooted at this device.
Alan Stern54515fe2007-05-30 15:38:58 -04003084 *
3085 * If @udev->reset_resume is set then the device is reset before the
3086 * status check is done.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087 */
Alan Stern140d8f62006-07-01 22:07:21 -04003088static int finish_port_resume(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089{
Alan Stern54515fe2007-05-30 15:38:58 -04003090 int status = 0;
Oliver Neukum07e72b92012-11-29 15:05:57 +01003091 u16 devstatus = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092
3093 /* caller owns the udev device lock */
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08003094 dev_dbg(&udev->dev, "%s\n",
3095 udev->reset_resume ? "finish reset-resume" : "finish resume");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096
3097 /* usb ch9 identifies four variants of SUSPENDED, based on what
3098 * state the device resumes to. Linux currently won't see the
3099 * first two on the host side; they'd be inside hub_port_init()
3100 * during many timeouts, but khubd can't suspend until later.
3101 */
3102 usb_set_device_state(udev, udev->actconfig
3103 ? USB_STATE_CONFIGURED
3104 : USB_STATE_ADDRESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105
Alan Stern54515fe2007-05-30 15:38:58 -04003106 /* 10.5.4.5 says not to reset a suspended port if the attached
3107 * device is enabled for remote wakeup. Hence the reset
3108 * operation is carried out here, after the port has been
3109 * resumed.
3110 */
3111 if (udev->reset_resume)
Alan Stern86c57ed2008-06-30 11:14:43 -04003112 retry_reset_resume:
Ming Lei742120c2008-06-18 22:00:29 +08003113 status = usb_reset_and_verify_device(udev);
Alan Stern54515fe2007-05-30 15:38:58 -04003114
Matthias Beyer469271f2013-10-10 23:41:27 +02003115 /* 10.5.4.5 says be sure devices in the tree are still there.
3116 * For now let's assume the device didn't go crazy on resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 * and device drivers will know about any resume quirks.
3118 */
Alan Stern54515fe2007-05-30 15:38:58 -04003119 if (status == 0) {
Alan Stern46dede42007-08-14 10:56:10 -04003120 devstatus = 0;
Alan Stern54515fe2007-05-30 15:38:58 -04003121 status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
Alan Stern86c57ed2008-06-30 11:14:43 -04003122
3123 /* If a normal resume failed, try doing a reset-resume */
3124 if (status && !udev->reset_resume && udev->persist_enabled) {
3125 dev_dbg(&udev->dev, "retry with reset-resume\n");
3126 udev->reset_resume = 1;
3127 goto retry_reset_resume;
3128 }
Alan Stern54515fe2007-05-30 15:38:58 -04003129 }
Alan Sternb40b7a92006-06-19 15:12:38 -04003130
Alan Stern624d6c02007-05-30 15:35:16 -04003131 if (status) {
3132 dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
3133 status);
Oliver Neukum07e72b92012-11-29 15:05:57 +01003134 /*
3135 * There are a few quirky devices which violate the standard
3136 * by claiming to have remote wakeup enabled after a reset,
3137 * which crash if the feature is cleared, hence check for
3138 * udev->reset_resume
3139 */
3140 } else if (udev->actconfig && !udev->reset_resume) {
Alan Stern28e861652013-07-30 15:37:33 -04003141 if (udev->speed < USB_SPEED_SUPER) {
Lan Tianyu54a3ac02013-01-24 10:31:28 +08003142 if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
Alan Stern28e861652013-07-30 15:37:33 -04003143 status = usb_disable_remote_wakeup(udev);
Lan Tianyu54a3ac02013-01-24 10:31:28 +08003144 } else {
3145 status = usb_get_status(udev, USB_RECIP_INTERFACE, 0,
3146 &devstatus);
Lan Tianyu54a3ac02013-01-24 10:31:28 +08003147 if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
3148 | USB_INTRF_STAT_FUNC_RW))
Alan Stern28e861652013-07-30 15:37:33 -04003149 status = usb_disable_remote_wakeup(udev);
Alan Stern4bf0ba82005-11-21 11:58:07 -05003150 }
Lan Tianyu54a3ac02013-01-24 10:31:28 +08003151
3152 if (status)
3153 dev_dbg(&udev->dev,
3154 "disable remote wakeup, status %d\n",
3155 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157 }
3158 return status;
3159}
3160
Alan Stern624d6c02007-05-30 15:35:16 -04003161/*
3162 * usb_port_resume - re-activate a suspended usb device's upstream port
3163 * @udev: device to re-activate, not a root hub
3164 * Context: must be able to sleep; device not locked; pm locks held
3165 *
3166 * This will re-activate the suspended device, increasing power usage
3167 * while letting drivers communicate again with its endpoints.
3168 * USB resume explicitly guarantees that the power session between
3169 * the host and the device is the same as it was when the device
3170 * suspended.
3171 *
Alan Sternfeccc302008-03-03 15:15:59 -05003172 * If @udev->reset_resume is set then this routine won't check that the
3173 * port is still enabled. Furthermore, finish_port_resume() above will
Alan Stern54515fe2007-05-30 15:38:58 -04003174 * reset @udev. The end result is that a broken power session can be
3175 * recovered and @udev will appear to persist across a loss of VBUS power.
3176 *
3177 * For example, if a host controller doesn't maintain VBUS suspend current
3178 * during a system sleep or is reset when the system wakes up, all the USB
3179 * power sessions below it will be broken. This is especially troublesome
3180 * for mass-storage devices containing mounted filesystems, since the
3181 * device will appear to have disconnected and all the memory mappings
3182 * to it will be lost. Using the USB_PERSIST facility, the device can be
3183 * made to appear as if it had not disconnected.
3184 *
Ming Lei742120c2008-06-18 22:00:29 +08003185 * This facility can be dangerous. Although usb_reset_and_verify_device() makes
Alan Sternfeccc302008-03-03 15:15:59 -05003186 * every effort to insure that the same device is present after the
Alan Stern54515fe2007-05-30 15:38:58 -04003187 * reset as before, it cannot provide a 100% guarantee. Furthermore it's
3188 * quite possible for a device to remain unaltered but its media to be
3189 * changed. If the user replaces a flash memory card while the system is
3190 * asleep, he will have only himself to blame when the filesystem on the
3191 * new card is corrupted and the system crashes.
3192 *
Alan Stern624d6c02007-05-30 15:35:16 -04003193 * Returns 0 on success, else negative errno.
3194 */
Alan Stern65bfd292008-11-25 16:39:18 -05003195int usb_port_resume(struct usb_device *udev, pm_message_t msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196{
Lan Tianyuad493e52013-01-23 04:26:30 +08003197 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
3198 struct usb_port *port_dev = hub->ports[udev->portnum - 1];
Alan Stern624d6c02007-05-30 15:35:16 -04003199 int port1 = udev->portnum;
3200 int status;
3201 u16 portchange, portstatus;
Alan Sternd25450c2006-11-20 11:14:30 -05003202
Lan Tianyuad493e52013-01-23 04:26:30 +08003203 if (port_dev->did_runtime_put) {
3204 status = pm_runtime_get_sync(&port_dev->dev);
3205 port_dev->did_runtime_put = false;
3206 if (status < 0) {
3207 dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
3208 status);
3209 return status;
3210 }
3211 }
3212
Alan Sternd25450c2006-11-20 11:14:30 -05003213 /* Skip the initial Clear-Suspend step for a remote wakeup */
3214 status = hub_port_status(hub, port1, &portstatus, &portchange);
Andiry Xu0ed9a572011-04-27 18:07:43 +08003215 if (status == 0 && !port_is_suspended(hub, portstatus))
Alan Sternd25450c2006-11-20 11:14:30 -05003216 goto SuspendCleared;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217
Matthias Beyer781b2132013-10-10 23:41:29 +02003218 /* dev_dbg(hub->intfdev, "resume port %d\n", port1); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219
Alan Sternd5cbad42006-08-11 16:52:39 -04003220 set_bit(port1, hub->busy_bits);
3221
Linus Torvalds1da177e2005-04-16 15:20:36 -07003222 /* see 7.1.7.7; affects power usage, but not budgeting */
Andiry Xua7114232011-04-27 18:07:50 +08003223 if (hub_is_superspeed(hub->hdev))
Sarah Sharpc2f60db2012-12-10 15:43:08 -08003224 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
Andiry Xua7114232011-04-27 18:07:50 +08003225 else
Lan Tianyuad493e52013-01-23 04:26:30 +08003226 status = usb_clear_port_feature(hub->hdev,
Andiry Xua7114232011-04-27 18:07:50 +08003227 port1, USB_PORT_FEAT_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228 if (status) {
Alan Stern624d6c02007-05-30 15:35:16 -04003229 dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
3230 port1, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232 /* drive resume for at least 20 msec */
Alan Stern686314c2007-05-30 15:34:36 -04003233 dev_dbg(&udev->dev, "usb %sresume\n",
Alan Stern5b1b0b82011-08-19 23:49:48 +02003234 (PMSG_IS_AUTO(msg) ? "auto-" : ""));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 msleep(25);
3236
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 /* Virtual root hubs can trigger on GET_PORT_STATUS to
3238 * stop resume signaling. Then finish the resume
3239 * sequence.
3240 */
Alan Sternd25450c2006-11-20 11:14:30 -05003241 status = hub_port_status(hub, port1, &portstatus, &portchange);
Alan Stern54515fe2007-05-30 15:38:58 -04003242
Alan Sternb01b03f2008-04-28 11:06:11 -04003243 /* TRSMRCY = 10 msec */
3244 msleep(10);
3245 }
Alan Stern54515fe2007-05-30 15:38:58 -04003246
Alan Sternb01b03f2008-04-28 11:06:11 -04003247 SuspendCleared:
3248 if (status == 0) {
Alan Sternbfd1e912012-10-19 11:03:39 -04003249 udev->port_is_suspended = 0;
Andiry Xua7114232011-04-27 18:07:50 +08003250 if (hub_is_superspeed(hub->hdev)) {
3251 if (portchange & USB_PORT_STAT_C_LINK_STATE)
Lan Tianyuad493e52013-01-23 04:26:30 +08003252 usb_clear_port_feature(hub->hdev, port1,
Andiry Xua7114232011-04-27 18:07:50 +08003253 USB_PORT_FEAT_C_PORT_LINK_STATE);
3254 } else {
3255 if (portchange & USB_PORT_STAT_C_SUSPEND)
Lan Tianyuad493e52013-01-23 04:26:30 +08003256 usb_clear_port_feature(hub->hdev, port1,
Andiry Xua7114232011-04-27 18:07:50 +08003257 USB_PORT_FEAT_C_SUSPEND);
3258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260
Alan Sternd5cbad42006-08-11 16:52:39 -04003261 clear_bit(port1, hub->busy_bits);
Alan Sternd5cbad42006-08-11 16:52:39 -04003262
Alan Sternb01b03f2008-04-28 11:06:11 -04003263 status = check_port_resume_type(udev,
3264 hub, port1, status, portchange, portstatus);
Alan Stern54515fe2007-05-30 15:38:58 -04003265 if (status == 0)
3266 status = finish_port_resume(udev);
3267 if (status < 0) {
3268 dev_dbg(&udev->dev, "can't resume, status %d\n", status);
3269 hub_port_logical_disconnect(hub, port1);
Andiry Xu65580b432011-09-23 14:19:52 -07003270 } else {
3271 /* Try to enable USB2 hardware LPM */
3272 if (udev->usb2_hw_lpm_capable == 1)
3273 usb_set_usb2_hardware_lpm(udev, 1);
Sarah Sharp83060952012-05-02 14:25:52 -07003274
Sarah Sharpf74631e2012-06-25 12:08:08 -07003275 /* Try to enable USB3 LTM and LPM */
3276 usb_enable_ltm(udev);
Sarah Sharp83060952012-05-02 14:25:52 -07003277 usb_unlocked_enable_lpm(udev);
Alan Stern54515fe2007-05-30 15:38:58 -04003278 }
Andiry Xu65580b432011-09-23 14:19:52 -07003279
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280 return status;
3281}
3282
Alan Stern84ebc102013-03-27 16:14:46 -04003283#ifdef CONFIG_PM_RUNTIME
3284
Alan Stern8808f002008-04-28 11:06:55 -04003285/* caller has locked udev */
Alan Stern0534d462010-01-08 12:56:30 -05003286int usb_remote_wakeup(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003287{
3288 int status = 0;
3289
Linus Torvalds1da177e2005-04-16 15:20:36 -07003290 if (udev->state == USB_STATE_SUSPENDED) {
Alan Stern645daaa2006-08-30 15:47:02 -04003291 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
Alan Stern9bbdf1e2010-01-08 12:57:28 -05003292 status = usb_autoresume_device(udev);
3293 if (status == 0) {
3294 /* Let the drivers do their thing, then... */
3295 usb_autosuspend_device(udev);
3296 }
Alan Sternd25450c2006-11-20 11:14:30 -05003297 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298 return status;
3299}
3300
Alan Sternd388dab2006-07-01 22:14:24 -04003301#endif
3302
Ming Leie6f30de2012-10-24 11:59:24 +08003303static int check_ports_changed(struct usb_hub *hub)
3304{
3305 int port1;
3306
3307 for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) {
3308 u16 portstatus, portchange;
3309 int status;
3310
3311 status = hub_port_status(hub, port1, &portstatus, &portchange);
3312 if (!status && portchange)
3313 return 1;
3314 }
3315 return 0;
3316}
3317
David Brownelldb690872005-09-13 19:56:33 -07003318static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319{
3320 struct usb_hub *hub = usb_get_intfdata (intf);
3321 struct usb_device *hdev = hub->hdev;
3322 unsigned port1;
Sarah Sharp4296c70a2012-01-06 10:34:31 -08003323 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324
Alan Sterne583d9d2013-07-11 14:58:04 -04003325 /*
3326 * Warn if children aren't already suspended.
3327 * Also, add up the number of wakeup-enabled descendants.
3328 */
3329 hub->wakeup_enabled_descendants = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003330 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3331 struct usb_device *udev;
3332
Lan Tianyuff823c792012-09-05 13:44:32 +08003333 udev = hub->ports[port1 - 1]->child;
Alan Stern6840d252007-09-10 11:34:26 -04003334 if (udev && udev->can_submit) {
Alan Sterncbb33002011-06-15 16:29:16 -04003335 dev_warn(&intf->dev, "port %d nyet suspended\n", port1);
Alan Stern5b1b0b82011-08-19 23:49:48 +02003336 if (PMSG_IS_AUTO(msg))
Alan Sterncbb33002011-06-15 16:29:16 -04003337 return -EBUSY;
David Brownellc9f89fa2005-09-13 19:57:04 -07003338 }
Alan Sterne583d9d2013-07-11 14:58:04 -04003339 if (udev)
3340 hub->wakeup_enabled_descendants +=
3341 wakeup_enabled_descendants(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342 }
Ming Leie6f30de2012-10-24 11:59:24 +08003343
3344 if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) {
3345 /* check if there are changes pending on hub ports */
3346 if (check_ports_changed(hub)) {
3347 if (PMSG_IS_AUTO(msg))
3348 return -EBUSY;
3349 pm_wakeup_event(&hdev->dev, 2000);
3350 }
3351 }
3352
Sarah Sharp4296c70a2012-01-06 10:34:31 -08003353 if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
3354 /* Enable hub to send remote wakeup for all ports. */
3355 for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3356 status = set_port_feature(hdev,
3357 port1 |
3358 USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
3359 USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
3360 USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
3361 USB_PORT_FEAT_REMOTE_WAKE_MASK);
3362 }
3363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003364
Harvey Harrison441b62c2008-03-03 16:08:34 -08003365 dev_dbg(&intf->dev, "%s\n", __func__);
Alan Stern40f122f2006-11-09 14:44:33 -05003366
David Brownellc9f89fa2005-09-13 19:57:04 -07003367 /* stop khubd and related activity */
Alan Stern43303542008-04-28 11:07:31 -04003368 hub_quiesce(hub, HUB_SUSPEND);
Alan Sternb6f64362007-05-04 11:51:54 -04003369 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370}
3371
3372static int hub_resume(struct usb_interface *intf)
3373{
Alan Stern5e6effa2008-03-03 15:15:51 -05003374 struct usb_hub *hub = usb_get_intfdata(intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003375
Alan Stern5e6effa2008-03-03 15:15:51 -05003376 dev_dbg(&intf->dev, "%s\n", __func__);
Alan Sternf2835212008-04-28 11:07:17 -04003377 hub_activate(hub, HUB_RESUME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378 return 0;
3379}
3380
Alan Sternb41a60e2007-05-30 15:39:33 -04003381static int hub_reset_resume(struct usb_interface *intf)
Alan Sternf07600c2007-05-30 15:38:16 -04003382{
Alan Sternb41a60e2007-05-30 15:39:33 -04003383 struct usb_hub *hub = usb_get_intfdata(intf);
Alan Sternf07600c2007-05-30 15:38:16 -04003384
Alan Stern5e6effa2008-03-03 15:15:51 -05003385 dev_dbg(&intf->dev, "%s\n", __func__);
Alan Sternf2835212008-04-28 11:07:17 -04003386 hub_activate(hub, HUB_RESET_RESUME);
Alan Sternf07600c2007-05-30 15:38:16 -04003387 return 0;
3388}
3389
Alan Stern54515fe2007-05-30 15:38:58 -04003390/**
3391 * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
3392 * @rhdev: struct usb_device for the root hub
3393 *
3394 * The USB host controller driver calls this function when its root hub
3395 * is resumed and Vbus power has been interrupted or the controller
Alan Sternfeccc302008-03-03 15:15:59 -05003396 * has been reset. The routine marks @rhdev as having lost power.
3397 * When the hub driver is resumed it will take notice and carry out
3398 * power-session recovery for all the "USB-PERSIST"-enabled child devices;
3399 * the others will be disconnected.
Alan Stern54515fe2007-05-30 15:38:58 -04003400 */
3401void usb_root_hub_lost_power(struct usb_device *rhdev)
3402{
3403 dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
3404 rhdev->reset_resume = 1;
3405}
3406EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
3407
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003408static const char * const usb3_lpm_names[] = {
3409 "U0",
3410 "U1",
3411 "U2",
3412 "U3",
3413};
3414
3415/*
3416 * Send a Set SEL control transfer to the device, prior to enabling
3417 * device-initiated U1 or U2. This lets the device know the exit latencies from
3418 * the time the device initiates a U1 or U2 exit, to the time it will receive a
3419 * packet from the host.
3420 *
3421 * This function will fail if the SEL or PEL values for udev are greater than
3422 * the maximum allowed values for the link state to be enabled.
3423 */
3424static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
3425{
3426 struct usb_set_sel_req *sel_values;
3427 unsigned long long u1_sel;
3428 unsigned long long u1_pel;
3429 unsigned long long u2_sel;
3430 unsigned long long u2_pel;
3431 int ret;
3432
Xenia Ragiadakou38d7f682013-09-04 17:24:45 +03003433 if (udev->state != USB_STATE_CONFIGURED)
3434 return 0;
3435
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003436 /* Convert SEL and PEL stored in ns to us */
3437 u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
3438 u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
3439 u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
3440 u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);
3441
3442 /*
3443 * Make sure that the calculated SEL and PEL values for the link
3444 * state we're enabling aren't bigger than the max SEL/PEL
3445 * value that will fit in the SET SEL control transfer.
3446 * Otherwise the device would get an incorrect idea of the exit
3447 * latency for the link state, and could start a device-initiated
3448 * U1/U2 when the exit latencies are too high.
3449 */
3450 if ((state == USB3_LPM_U1 &&
3451 (u1_sel > USB3_LPM_MAX_U1_SEL_PEL ||
3452 u1_pel > USB3_LPM_MAX_U1_SEL_PEL)) ||
3453 (state == USB3_LPM_U2 &&
3454 (u2_sel > USB3_LPM_MAX_U2_SEL_PEL ||
3455 u2_pel > USB3_LPM_MAX_U2_SEL_PEL))) {
Sarah Sharp1510a1a2012-10-05 10:30:35 -07003456 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 -07003457 usb3_lpm_names[state], u1_sel, u1_pel);
3458 return -EINVAL;
3459 }
3460
3461 /*
3462 * If we're enabling device-initiated LPM for one link state,
3463 * but the other link state has a too high SEL or PEL value,
3464 * just set those values to the max in the Set SEL request.
3465 */
3466 if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL)
3467 u1_sel = USB3_LPM_MAX_U1_SEL_PEL;
3468
3469 if (u1_pel > USB3_LPM_MAX_U1_SEL_PEL)
3470 u1_pel = USB3_LPM_MAX_U1_SEL_PEL;
3471
3472 if (u2_sel > USB3_LPM_MAX_U2_SEL_PEL)
3473 u2_sel = USB3_LPM_MAX_U2_SEL_PEL;
3474
3475 if (u2_pel > USB3_LPM_MAX_U2_SEL_PEL)
3476 u2_pel = USB3_LPM_MAX_U2_SEL_PEL;
3477
3478 /*
3479 * usb_enable_lpm() can be called as part of a failed device reset,
3480 * which may be initiated by an error path of a mass storage driver.
3481 * Therefore, use GFP_NOIO.
3482 */
3483 sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
3484 if (!sel_values)
3485 return -ENOMEM;
3486
3487 sel_values->u1_sel = u1_sel;
3488 sel_values->u1_pel = u1_pel;
3489 sel_values->u2_sel = cpu_to_le16(u2_sel);
3490 sel_values->u2_pel = cpu_to_le16(u2_pel);
3491
3492 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3493 USB_REQ_SET_SEL,
3494 USB_RECIP_DEVICE,
3495 0, 0,
3496 sel_values, sizeof *(sel_values),
3497 USB_CTRL_SET_TIMEOUT);
3498 kfree(sel_values);
3499 return ret;
3500}
3501
3502/*
3503 * Enable or disable device-initiated U1 or U2 transitions.
3504 */
3505static int usb_set_device_initiated_lpm(struct usb_device *udev,
3506 enum usb3_link_state state, bool enable)
3507{
3508 int ret;
3509 int feature;
3510
3511 switch (state) {
3512 case USB3_LPM_U1:
3513 feature = USB_DEVICE_U1_ENABLE;
3514 break;
3515 case USB3_LPM_U2:
3516 feature = USB_DEVICE_U2_ENABLE;
3517 break;
3518 default:
3519 dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n",
3520 __func__, enable ? "enable" : "disable");
3521 return -EINVAL;
3522 }
3523
3524 if (udev->state != USB_STATE_CONFIGURED) {
3525 dev_dbg(&udev->dev, "%s: Can't %s %s state "
3526 "for unconfigured device.\n",
3527 __func__, enable ? "enable" : "disable",
3528 usb3_lpm_names[state]);
3529 return 0;
3530 }
3531
3532 if (enable) {
3533 /*
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003534 * Now send the control transfer to enable device-initiated LPM
3535 * for either U1 or U2.
3536 */
3537 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3538 USB_REQ_SET_FEATURE,
3539 USB_RECIP_DEVICE,
3540 feature,
3541 0, NULL, 0,
3542 USB_CTRL_SET_TIMEOUT);
3543 } else {
3544 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3545 USB_REQ_CLEAR_FEATURE,
3546 USB_RECIP_DEVICE,
3547 feature,
3548 0, NULL, 0,
3549 USB_CTRL_SET_TIMEOUT);
3550 }
3551 if (ret < 0) {
3552 dev_warn(&udev->dev, "%s of device-initiated %s failed.\n",
3553 enable ? "Enable" : "Disable",
3554 usb3_lpm_names[state]);
3555 return -EBUSY;
3556 }
3557 return 0;
3558}
3559
3560static int usb_set_lpm_timeout(struct usb_device *udev,
3561 enum usb3_link_state state, int timeout)
3562{
3563 int ret;
3564 int feature;
3565
3566 switch (state) {
3567 case USB3_LPM_U1:
3568 feature = USB_PORT_FEAT_U1_TIMEOUT;
3569 break;
3570 case USB3_LPM_U2:
3571 feature = USB_PORT_FEAT_U2_TIMEOUT;
3572 break;
3573 default:
3574 dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n",
3575 __func__);
3576 return -EINVAL;
3577 }
3578
3579 if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT &&
3580 timeout != USB3_LPM_DEVICE_INITIATED) {
3581 dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, "
3582 "which is a reserved value.\n",
3583 usb3_lpm_names[state], timeout);
3584 return -EINVAL;
3585 }
3586
3587 ret = set_port_feature(udev->parent,
3588 USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum,
3589 feature);
3590 if (ret < 0) {
3591 dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x,"
3592 "error code %i\n", usb3_lpm_names[state],
3593 timeout, ret);
3594 return -EBUSY;
3595 }
3596 if (state == USB3_LPM_U1)
3597 udev->u1_params.timeout = timeout;
3598 else
3599 udev->u2_params.timeout = timeout;
3600 return 0;
3601}
3602
3603/*
3604 * Enable the hub-initiated U1/U2 idle timeouts, and enable device-initiated
3605 * U1/U2 entry.
3606 *
3607 * We will attempt to enable U1 or U2, but there are no guarantees that the
3608 * control transfers to set the hub timeout or enable device-initiated U1/U2
3609 * will be successful.
3610 *
3611 * If we cannot set the parent hub U1/U2 timeout, we attempt to let the xHCI
3612 * driver know about it. If that call fails, it should be harmless, and just
3613 * take up more slightly more bus bandwidth for unnecessary U1/U2 exit latency.
3614 */
3615static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
3616 enum usb3_link_state state)
3617{
Sarah Sharp65a95b72012-10-05 10:32:07 -07003618 int timeout, ret;
Sarah Sharpae8963a2012-10-03 11:18:05 -07003619 __u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
3620 __le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;
3621
3622 /* If the device says it doesn't have *any* exit latency to come out of
3623 * U1 or U2, it's probably lying. Assume it doesn't implement that link
3624 * state.
3625 */
3626 if ((state == USB3_LPM_U1 && u1_mel == 0) ||
3627 (state == USB3_LPM_U2 && u2_mel == 0))
3628 return;
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003629
Sarah Sharp65a95b72012-10-05 10:32:07 -07003630 /*
3631 * First, let the device know about the exit latencies
3632 * associated with the link state we're about to enable.
3633 */
3634 ret = usb_req_set_sel(udev, state);
3635 if (ret < 0) {
3636 dev_warn(&udev->dev, "Set SEL for device-initiated %s failed.\n",
3637 usb3_lpm_names[state]);
3638 return;
3639 }
3640
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003641 /* We allow the host controller to set the U1/U2 timeout internally
3642 * first, so that it can change its schedule to account for the
3643 * additional latency to send data to a device in a lower power
3644 * link state.
3645 */
3646 timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state);
3647
3648 /* xHCI host controller doesn't want to enable this LPM state. */
3649 if (timeout == 0)
3650 return;
3651
3652 if (timeout < 0) {
3653 dev_warn(&udev->dev, "Could not enable %s link state, "
3654 "xHCI error %i.\n", usb3_lpm_names[state],
3655 timeout);
3656 return;
3657 }
3658
3659 if (usb_set_lpm_timeout(udev, state, timeout))
3660 /* If we can't set the parent hub U1/U2 timeout,
3661 * device-initiated LPM won't be allowed either, so let the xHCI
3662 * host know that this link state won't be enabled.
3663 */
3664 hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
3665
3666 /* Only a configured device will accept the Set Feature U1/U2_ENABLE */
3667 else if (udev->actconfig)
3668 usb_set_device_initiated_lpm(udev, state, true);
3669
3670}
3671
3672/*
3673 * Disable the hub-initiated U1/U2 idle timeouts, and disable device-initiated
3674 * U1/U2 entry.
3675 *
3676 * If this function returns -EBUSY, the parent hub will still allow U1/U2 entry.
3677 * If zero is returned, the parent will not allow the link to go into U1/U2.
3678 *
3679 * If zero is returned, device-initiated U1/U2 entry may still be enabled, but
3680 * it won't have an effect on the bus link state because the parent hub will
3681 * still disallow device-initiated U1/U2 entry.
3682 *
3683 * If zero is returned, the xHCI host controller may still think U1/U2 entry is
3684 * possible. The result will be slightly more bus bandwidth will be taken up
3685 * (to account for U1/U2 exit latency), but it should be harmless.
3686 */
3687static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
3688 enum usb3_link_state state)
3689{
3690 int feature;
3691
3692 switch (state) {
3693 case USB3_LPM_U1:
3694 feature = USB_PORT_FEAT_U1_TIMEOUT;
3695 break;
3696 case USB3_LPM_U2:
3697 feature = USB_PORT_FEAT_U2_TIMEOUT;
3698 break;
3699 default:
3700 dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n",
3701 __func__);
3702 return -EINVAL;
3703 }
3704
3705 if (usb_set_lpm_timeout(udev, state, 0))
3706 return -EBUSY;
3707
3708 usb_set_device_initiated_lpm(udev, state, false);
3709
3710 if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state))
3711 dev_warn(&udev->dev, "Could not disable xHCI %s timeout, "
3712 "bus schedule bandwidth may be impacted.\n",
3713 usb3_lpm_names[state]);
3714 return 0;
3715}
3716
3717/*
3718 * Disable hub-initiated and device-initiated U1 and U2 entry.
3719 * Caller must own the bandwidth_mutex.
3720 *
3721 * This will call usb_enable_lpm() on failure, which will decrement
3722 * lpm_disable_count, and will re-enable LPM if lpm_disable_count reaches zero.
3723 */
3724int usb_disable_lpm(struct usb_device *udev)
3725{
3726 struct usb_hcd *hcd;
3727
3728 if (!udev || !udev->parent ||
3729 udev->speed != USB_SPEED_SUPER ||
3730 !udev->lpm_capable)
3731 return 0;
3732
3733 hcd = bus_to_hcd(udev->bus);
3734 if (!hcd || !hcd->driver->disable_usb3_lpm_timeout)
3735 return 0;
3736
3737 udev->lpm_disable_count++;
Dan Carpenter55558c32012-05-22 20:54:34 +03003738 if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003739 return 0;
3740
3741 /* If LPM is enabled, attempt to disable it. */
3742 if (usb_disable_link_state(hcd, udev, USB3_LPM_U1))
3743 goto enable_lpm;
3744 if (usb_disable_link_state(hcd, udev, USB3_LPM_U2))
3745 goto enable_lpm;
3746
3747 return 0;
3748
3749enable_lpm:
3750 usb_enable_lpm(udev);
3751 return -EBUSY;
3752}
3753EXPORT_SYMBOL_GPL(usb_disable_lpm);
3754
3755/* Grab the bandwidth_mutex before calling usb_disable_lpm() */
3756int usb_unlocked_disable_lpm(struct usb_device *udev)
3757{
3758 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3759 int ret;
3760
3761 if (!hcd)
3762 return -EINVAL;
3763
3764 mutex_lock(hcd->bandwidth_mutex);
3765 ret = usb_disable_lpm(udev);
3766 mutex_unlock(hcd->bandwidth_mutex);
3767
3768 return ret;
3769}
3770EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
3771
3772/*
3773 * Attempt to enable device-initiated and hub-initiated U1 and U2 entry. The
3774 * xHCI host policy may prevent U1 or U2 from being enabled.
3775 *
3776 * Other callers may have disabled link PM, so U1 and U2 entry will be disabled
3777 * until the lpm_disable_count drops to zero. Caller must own the
3778 * bandwidth_mutex.
3779 */
3780void usb_enable_lpm(struct usb_device *udev)
3781{
3782 struct usb_hcd *hcd;
3783
3784 if (!udev || !udev->parent ||
3785 udev->speed != USB_SPEED_SUPER ||
3786 !udev->lpm_capable)
3787 return;
3788
3789 udev->lpm_disable_count--;
3790 hcd = bus_to_hcd(udev->bus);
3791 /* Double check that we can both enable and disable LPM.
3792 * Device must be configured to accept set feature U1/U2 timeout.
3793 */
3794 if (!hcd || !hcd->driver->enable_usb3_lpm_timeout ||
3795 !hcd->driver->disable_usb3_lpm_timeout)
3796 return;
3797
3798 if (udev->lpm_disable_count > 0)
3799 return;
3800
3801 usb_enable_link_state(hcd, udev, USB3_LPM_U1);
3802 usb_enable_link_state(hcd, udev, USB3_LPM_U2);
3803}
3804EXPORT_SYMBOL_GPL(usb_enable_lpm);
3805
3806/* Grab the bandwidth_mutex before calling usb_enable_lpm() */
3807void usb_unlocked_enable_lpm(struct usb_device *udev)
3808{
3809 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3810
3811 if (!hcd)
3812 return;
3813
3814 mutex_lock(hcd->bandwidth_mutex);
3815 usb_enable_lpm(udev);
3816 mutex_unlock(hcd->bandwidth_mutex);
3817}
3818EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
3819
3820
Alan Sternd388dab2006-07-01 22:14:24 -04003821#else /* CONFIG_PM */
3822
Alan Sternf07600c2007-05-30 15:38:16 -04003823#define hub_suspend NULL
3824#define hub_resume NULL
3825#define hub_reset_resume NULL
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003826
3827int usb_disable_lpm(struct usb_device *udev)
3828{
3829 return 0;
3830}
Sarah Sharpe9261fb2012-05-21 08:29:01 -07003831EXPORT_SYMBOL_GPL(usb_disable_lpm);
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003832
3833void usb_enable_lpm(struct usb_device *udev) { }
Sarah Sharpe9261fb2012-05-21 08:29:01 -07003834EXPORT_SYMBOL_GPL(usb_enable_lpm);
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003835
3836int usb_unlocked_disable_lpm(struct usb_device *udev)
3837{
3838 return 0;
3839}
Sarah Sharpe9261fb2012-05-21 08:29:01 -07003840EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
Sarah Sharp1ea7e0e2012-04-24 17:21:50 -07003841
3842void usb_unlocked_enable_lpm(struct usb_device *udev) { }
Sarah Sharpe9261fb2012-05-21 08:29:01 -07003843EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
Sarah Sharpf74631e2012-06-25 12:08:08 -07003844
3845int usb_disable_ltm(struct usb_device *udev)
3846{
3847 return 0;
3848}
3849EXPORT_SYMBOL_GPL(usb_disable_ltm);
3850
3851void usb_enable_ltm(struct usb_device *udev) { }
3852EXPORT_SYMBOL_GPL(usb_enable_ltm);
Alan Sternc4b51a42013-07-11 14:58:23 -04003853
3854#endif /* CONFIG_PM */
Alan Sternd388dab2006-07-01 22:14:24 -04003855
Linus Torvalds1da177e2005-04-16 15:20:36 -07003856
3857/* USB 2.0 spec, 7.1.7.3 / fig 7-29:
3858 *
3859 * Between connect detection and reset signaling there must be a delay
3860 * of 100ms at least for debounce and power-settling. The corresponding
3861 * timer shall restart whenever the downstream port detects a disconnect.
Matthias Beyer469271f2013-10-10 23:41:27 +02003862 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003863 * Apparently there are some bluetooth and irda-dongles and a number of
3864 * low-speed devices for which this debounce period may last over a second.
3865 * Not covered by the spec - but easy to deal with.
3866 *
3867 * This implementation uses a 1500ms total debounce timeout; if the
3868 * connection isn't stable by then it returns -ETIMEDOUT. It checks
3869 * every 25ms for transient disconnects. When the port status has been
3870 * unchanged for 100ms it returns the port status.
3871 */
Lan Tianyuad493e52013-01-23 04:26:30 +08003872int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003873{
3874 int ret;
3875 int total_time, stable_time = 0;
3876 u16 portchange, portstatus;
3877 unsigned connection = 0xffff;
3878
3879 for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
3880 ret = hub_port_status(hub, port1, &portstatus, &portchange);
3881 if (ret < 0)
3882 return ret;
3883
3884 if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
3885 (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
Lan Tianyuad493e52013-01-23 04:26:30 +08003886 if (!must_be_connected ||
3887 (connection == USB_PORT_STAT_CONNECTION))
3888 stable_time += HUB_DEBOUNCE_STEP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003889 if (stable_time >= HUB_DEBOUNCE_STABLE)
3890 break;
3891 } else {
3892 stable_time = 0;
3893 connection = portstatus & USB_PORT_STAT_CONNECTION;
3894 }
3895
3896 if (portchange & USB_PORT_STAT_C_CONNECTION) {
Lan Tianyuad493e52013-01-23 04:26:30 +08003897 usb_clear_port_feature(hub->hdev, port1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003898 USB_PORT_FEAT_C_CONNECTION);
3899 }
3900
3901 if (total_time >= HUB_DEBOUNCE_TIMEOUT)
3902 break;
3903 msleep(HUB_DEBOUNCE_STEP);
3904 }
3905
3906 dev_dbg (hub->intfdev,
3907 "debounce: port %d: total %dms stable %dms status 0x%x\n",
3908 port1, total_time, stable_time, portstatus);
3909
3910 if (stable_time < HUB_DEBOUNCE_STABLE)
3911 return -ETIMEDOUT;
3912 return portstatus;
3913}
3914
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07003915void usb_ep0_reinit(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003916{
Alan Sternddeac4e2009-01-15 17:03:33 -05003917 usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
3918 usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
Alan Stern2caf7fc2008-12-31 11:31:33 -05003919 usb_enable_endpoint(udev, &udev->ep0, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920}
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07003921EXPORT_SYMBOL_GPL(usb_ep0_reinit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003922
3923#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)
3924#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN)
3925
Alan Stern4326ed02007-07-30 17:08:43 -04003926static int hub_set_address(struct usb_device *udev, int devnum)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003927{
3928 int retval;
Sarah Sharpc6515272009-04-27 19:57:26 -07003929 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003930
Sarah Sharpc6515272009-04-27 19:57:26 -07003931 /*
3932 * The host controller will choose the device address,
3933 * instead of the core having chosen it earlier
3934 */
3935 if (!hcd->driver->address_device && devnum <= 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003936 return -EINVAL;
3937 if (udev->state == USB_STATE_ADDRESS)
3938 return 0;
3939 if (udev->state != USB_STATE_DEFAULT)
3940 return -EINVAL;
Andiry Xuc8d4af82010-10-14 07:22:51 -07003941 if (hcd->driver->address_device)
Sarah Sharpc6515272009-04-27 19:57:26 -07003942 retval = hcd->driver->address_device(hcd, udev);
Andiry Xuc8d4af82010-10-14 07:22:51 -07003943 else
Sarah Sharpc6515272009-04-27 19:57:26 -07003944 retval = usb_control_msg(udev, usb_sndaddr0pipe(),
3945 USB_REQ_SET_ADDRESS, 0, devnum, 0,
3946 NULL, 0, USB_CTRL_SET_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003947 if (retval == 0) {
Alan Stern3b29b682011-02-22 09:53:41 -05003948 update_devnum(udev, devnum);
David Vrabel4953d142008-04-08 13:24:46 -07003949 /* Device now using proper address. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003950 usb_set_device_state(udev, USB_STATE_ADDRESS);
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07003951 usb_ep0_reinit(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003952 }
3953 return retval;
3954}
3955
3956/* Reset device, (re)assign address, get device descriptor.
3957 * Device connection must be stable, no more debouncing needed.
3958 * Returns device in USB_STATE_ADDRESS, except on error.
3959 *
3960 * If this is called for an already-existing device (as part of
Ming Lei742120c2008-06-18 22:00:29 +08003961 * usb_reset_and_verify_device), the caller must own the device lock. For a
Linus Torvalds1da177e2005-04-16 15:20:36 -07003962 * newly detected device that is not accessible through any global
3963 * pointers, it's not necessary to lock the device.
3964 */
3965static int
3966hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
3967 int retry_counter)
3968{
Arjan van de Ven4186ecf2006-01-11 15:55:29 +01003969 static DEFINE_MUTEX(usb_address0_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003970
3971 struct usb_device *hdev = hub->hdev;
Sarah Sharpe7b77172009-04-27 19:54:26 -07003972 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003973 int i, j, retval;
3974 unsigned delay = HUB_SHORT_RESET_TIME;
3975 enum usb_device_speed oldspeed = udev->speed;
Michal Nazarewicze538dfd2011-08-30 17:11:19 +02003976 const char *speed;
Alan Stern4326ed02007-07-30 17:08:43 -04003977 int devnum = udev->devnum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003978
3979 /* root hub ports have a slightly longer reset period
3980 * (from USB 2.0 spec, section 7.1.7.5)
3981 */
3982 if (!hdev->parent) {
3983 delay = HUB_ROOT_RESET_TIME;
3984 if (port1 == hdev->bus->otg_port)
3985 hdev->bus->b_hnp_enable = 0;
3986 }
3987
3988 /* Some low speed devices have problems with the quick delay, so */
3989 /* be a bit pessimistic with those devices. RHbug #23670 */
3990 if (oldspeed == USB_SPEED_LOW)
3991 delay = HUB_LONG_RESET_TIME;
3992
Arjan van de Ven4186ecf2006-01-11 15:55:29 +01003993 mutex_lock(&usb_address0_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003994
Luben Tuikov07194ab2011-02-11 11:33:10 -08003995 /* Reset the device; full speed may morph to high speed */
3996 /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
Andiry Xu75d7cf72011-09-13 16:41:11 -07003997 retval = hub_port_reset(hub, port1, udev, delay, false);
Luben Tuikov07194ab2011-02-11 11:33:10 -08003998 if (retval < 0) /* error or disconnect */
3999 goto fail;
4000 /* success, speed is known */
4001
Linus Torvalds1da177e2005-04-16 15:20:36 -07004002 retval = -ENODEV;
4003
4004 if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {
4005 dev_dbg(&udev->dev, "device reset changed speed!\n");
4006 goto fail;
4007 }
4008 oldspeed = udev->speed;
Alan Stern4326ed02007-07-30 17:08:43 -04004009
Linus Torvalds1da177e2005-04-16 15:20:36 -07004010 /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
4011 * it's fixed size except for full speed devices.
Inaky Perez-Gonzalez5bb6e0a2006-08-25 19:35:30 -07004012 * For Wireless USB devices, ep0 max packet is always 512 (tho
4013 * reported as 0xff in the device descriptor). WUSB1.0[4.8.1].
Linus Torvalds1da177e2005-04-16 15:20:36 -07004014 */
4015 switch (udev->speed) {
Sarah Sharp6b403b02009-04-27 19:54:10 -07004016 case USB_SPEED_SUPER:
Greg Kroah-Hartman551cdbb2010-01-14 11:08:04 -08004017 case USB_SPEED_WIRELESS: /* fixed at 512 */
Harvey Harrison551509d2009-02-11 14:11:36 -08004018 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
Inaky Perez-Gonzalez5bb6e0a2006-08-25 19:35:30 -07004019 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004020 case USB_SPEED_HIGH: /* fixed at 64 */
Harvey Harrison551509d2009-02-11 14:11:36 -08004021 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004022 break;
4023 case USB_SPEED_FULL: /* 8, 16, 32, or 64 */
4024 /* to determine the ep0 maxpacket size, try to read
4025 * the device descriptor to get bMaxPacketSize0 and
4026 * then correct our initial guess.
4027 */
Harvey Harrison551509d2009-02-11 14:11:36 -08004028 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004029 break;
4030 case USB_SPEED_LOW: /* fixed at 8 */
Harvey Harrison551509d2009-02-11 14:11:36 -08004031 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004032 break;
4033 default:
4034 goto fail;
4035 }
Michal Nazarewicze538dfd2011-08-30 17:11:19 +02004036
4037 if (udev->speed == USB_SPEED_WIRELESS)
4038 speed = "variable speed Wireless";
4039 else
4040 speed = usb_speed_string(udev->speed);
4041
Sarah Sharpc6515272009-04-27 19:57:26 -07004042 if (udev->speed != USB_SPEED_SUPER)
4043 dev_info(&udev->dev,
Michal Nazarewicze538dfd2011-08-30 17:11:19 +02004044 "%s %s USB device number %d using %s\n",
4045 (udev->config) ? "reset" : "new", speed,
Alan Stern3b29b682011-02-22 09:53:41 -05004046 devnum, udev->bus->controller->driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004047
4048 /* Set up TT records, if needed */
4049 if (hdev->tt) {
4050 udev->tt = hdev->tt;
4051 udev->ttport = hdev->ttport;
4052 } else if (udev->speed != USB_SPEED_HIGH
4053 && hdev->speed == USB_SPEED_HIGH) {
Alan Sternd199c962011-01-31 10:56:37 -05004054 if (!hub->tt.hub) {
4055 dev_err(&udev->dev, "parent hub has no TT\n");
4056 retval = -EINVAL;
4057 goto fail;
4058 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004059 udev->tt = &hub->tt;
4060 udev->ttport = port1;
4061 }
Matthias Beyer469271f2013-10-10 23:41:27 +02004062
Linus Torvalds1da177e2005-04-16 15:20:36 -07004063 /* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
4064 * Because device hardware and firmware is sometimes buggy in
4065 * this area, and this is how Linux has done it for ages.
4066 * Change it cautiously.
4067 *
4068 * NOTE: If USE_NEW_SCHEME() is true we will start by issuing
4069 * a 64-byte GET_DESCRIPTOR request. This is what Windows does,
4070 * so it may help with some non-standards-compliant devices.
4071 * Otherwise we start with SET_ADDRESS and then try to read the
4072 * first 8 bytes of the device descriptor to get the ep0 maxpacket
4073 * value.
4074 */
4075 for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
Sarah Sharpc6515272009-04-27 19:57:26 -07004076 if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004077 struct usb_device_descriptor *buf;
4078 int r = 0;
4079
4080#define GET_DESCRIPTOR_BUFSIZE 64
4081 buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
4082 if (!buf) {
4083 retval = -ENOMEM;
4084 continue;
4085 }
4086
Alan Sternb89ee192007-05-11 10:19:04 -04004087 /* Retry on all errors; some devices are flakey.
4088 * 255 is for WUSB devices, we actually need to use
4089 * 512 (WUSB1.0[4.8.1]).
Linus Torvalds1da177e2005-04-16 15:20:36 -07004090 */
4091 for (j = 0; j < 3; ++j) {
4092 buf->bMaxPacketSize0 = 0;
4093 r = usb_control_msg(udev, usb_rcvaddr0pipe(),
4094 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
4095 USB_DT_DEVICE << 8, 0,
4096 buf, GET_DESCRIPTOR_BUFSIZE,
Jaroslav Kyselafd7c5192008-10-10 16:24:45 +02004097 initial_descriptor_timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004098 switch (buf->bMaxPacketSize0) {
Inaky Perez-Gonzalez5bb6e0a2006-08-25 19:35:30 -07004099 case 8: case 16: case 32: case 64: case 255:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100 if (buf->bDescriptorType ==
4101 USB_DT_DEVICE) {
4102 r = 0;
4103 break;
4104 }
4105 /* FALL THROUGH */
4106 default:
4107 if (r == 0)
4108 r = -EPROTO;
4109 break;
4110 }
4111 if (r == 0)
4112 break;
4113 }
4114 udev->descriptor.bMaxPacketSize0 =
4115 buf->bMaxPacketSize0;
4116 kfree(buf);
4117
Andiry Xu75d7cf72011-09-13 16:41:11 -07004118 retval = hub_port_reset(hub, port1, udev, delay, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004119 if (retval < 0) /* error or disconnect */
4120 goto fail;
4121 if (oldspeed != udev->speed) {
4122 dev_dbg(&udev->dev,
4123 "device reset changed speed!\n");
4124 retval = -ENODEV;
4125 goto fail;
4126 }
4127 if (r) {
Alan Sterne9e88fb2013-03-27 16:14:01 -04004128 if (r != -ENODEV)
4129 dev_err(&udev->dev, "device descriptor read/64, error %d\n",
4130 r);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004131 retval = -EMSGSIZE;
4132 continue;
4133 }
4134#undef GET_DESCRIPTOR_BUFSIZE
4135 }
4136
Matthias Beyer469271f2013-10-10 23:41:27 +02004137 /*
4138 * If device is WUSB, we already assigned an
4139 * unauthorized address in the Connect Ack sequence;
4140 * authorization will assign the final address.
4141 */
Sarah Sharpc6515272009-04-27 19:57:26 -07004142 if (udev->wusb == 0) {
Inaky Perez-Gonzalez6c529cd2008-04-08 13:24:46 -07004143 for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
4144 retval = hub_set_address(udev, devnum);
4145 if (retval >= 0)
4146 break;
4147 msleep(200);
4148 }
4149 if (retval < 0) {
Alan Sterne9e88fb2013-03-27 16:14:01 -04004150 if (retval != -ENODEV)
4151 dev_err(&udev->dev, "device not accepting address %d, error %d\n",
4152 devnum, retval);
Inaky Perez-Gonzalez6c529cd2008-04-08 13:24:46 -07004153 goto fail;
4154 }
Sarah Sharpc6515272009-04-27 19:57:26 -07004155 if (udev->speed == USB_SPEED_SUPER) {
4156 devnum = udev->devnum;
4157 dev_info(&udev->dev,
Alan Stern3b29b682011-02-22 09:53:41 -05004158 "%s SuperSpeed USB device number %d using %s\n",
Sarah Sharpc6515272009-04-27 19:57:26 -07004159 (udev->config) ? "reset" : "new",
Alan Stern3b29b682011-02-22 09:53:41 -05004160 devnum, udev->bus->controller->driver->name);
Sarah Sharpc6515272009-04-27 19:57:26 -07004161 }
Inaky Perez-Gonzalez6c529cd2008-04-08 13:24:46 -07004162
4163 /* cope with hardware quirkiness:
4164 * - let SET_ADDRESS settle, some device hardware wants it
4165 * - read ep0 maxpacket even for high and low speed,
4166 */
4167 msleep(10);
Sarah Sharpc6515272009-04-27 19:57:26 -07004168 if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004169 break;
Matthias Beyer469271f2013-10-10 23:41:27 +02004170 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004171
4172 retval = usb_get_device_descriptor(udev, 8);
4173 if (retval < 8) {
Alan Sterne9e88fb2013-03-27 16:14:01 -04004174 if (retval != -ENODEV)
4175 dev_err(&udev->dev,
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08004176 "device descriptor read/8, error %d\n",
4177 retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004178 if (retval >= 0)
4179 retval = -EMSGSIZE;
4180 } else {
4181 retval = 0;
4182 break;
4183 }
4184 }
4185 if (retval)
4186 goto fail;
4187
Peter Chenb76baa82012-11-09 09:44:43 +08004188 if (hcd->phy && !hdev->parent)
Peter Chenac965112012-11-09 09:44:44 +08004189 usb_phy_notify_connect(hcd->phy, udev->speed);
Peter Chenb76baa82012-11-09 09:44:43 +08004190
Elric Fud8aec3d2012-03-26 21:16:02 +08004191 /*
4192 * Some superspeed devices have finished the link training process
4193 * and attached to a superspeed hub port, but the device descriptor
4194 * got from those devices show they aren't superspeed devices. Warm
4195 * reset the port attached by the devices can fix them.
4196 */
4197 if ((udev->speed == USB_SPEED_SUPER) &&
4198 (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
4199 dev_err(&udev->dev, "got a wrong device descriptor, "
4200 "warm reset device\n");
4201 hub_port_reset(hub, port1, udev,
4202 HUB_BH_RESET_TIME, true);
4203 retval = -EINVAL;
4204 goto fail;
4205 }
4206
Sarah Sharp6b403b02009-04-27 19:54:10 -07004207 if (udev->descriptor.bMaxPacketSize0 == 0xff ||
4208 udev->speed == USB_SPEED_SUPER)
4209 i = 512;
4210 else
4211 i = udev->descriptor.bMaxPacketSize0;
Kuninori Morimoto29cc8892011-08-23 03:12:03 -07004212 if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
Alan Stern56626a72010-10-14 15:25:21 -04004213 if (udev->speed == USB_SPEED_LOW ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07004214 !(i == 8 || i == 16 || i == 32 || i == 64)) {
Alan Stern56626a72010-10-14 15:25:21 -04004215 dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004216 retval = -EMSGSIZE;
4217 goto fail;
4218 }
Alan Stern56626a72010-10-14 15:25:21 -04004219 if (udev->speed == USB_SPEED_FULL)
4220 dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
4221 else
4222 dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004223 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07004224 usb_ep0_reinit(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004225 }
Matthias Beyer469271f2013-10-10 23:41:27 +02004226
Linus Torvalds1da177e2005-04-16 15:20:36 -07004227 retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
4228 if (retval < (signed)sizeof(udev->descriptor)) {
Alan Sterne9e88fb2013-03-27 16:14:01 -04004229 if (retval != -ENODEV)
4230 dev_err(&udev->dev, "device descriptor read/all, error %d\n",
4231 retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004232 if (retval >= 0)
4233 retval = -ENOMSG;
4234 goto fail;
4235 }
4236
Andiry Xu1ff4df52011-09-23 14:19:48 -07004237 if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
4238 retval = usb_get_bos_descriptor(udev);
Sarah Sharp51e0a012012-02-20 12:02:19 -08004239 if (!retval) {
Sarah Sharpd9b20992012-02-20 08:31:26 -08004240 udev->lpm_capable = usb_device_supports_lpm(udev);
Sarah Sharp51e0a012012-02-20 12:02:19 -08004241 usb_set_lpm_parameters(udev);
4242 }
Andiry Xu1ff4df52011-09-23 14:19:48 -07004243 }
Andiry Xu3148bf02011-09-23 14:19:47 -07004244
Linus Torvalds1da177e2005-04-16 15:20:36 -07004245 retval = 0;
Alek Du48f24972010-06-04 15:47:55 +08004246 /* notify HCD that we have a device connected and addressed */
4247 if (hcd->driver->update_device)
4248 hcd->driver->update_device(hcd, udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004249fail:
Alan Stern4326ed02007-07-30 17:08:43 -04004250 if (retval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004251 hub_port_disable(hub, port1, 0);
Alan Stern3b29b682011-02-22 09:53:41 -05004252 update_devnum(udev, devnum); /* for disconnect processing */
Alan Stern4326ed02007-07-30 17:08:43 -04004253 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +01004254 mutex_unlock(&usb_address0_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004255 return retval;
4256}
4257
4258static void
4259check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
4260{
4261 struct usb_qualifier_descriptor *qual;
4262 int status;
4263
Christoph Lametere94b1762006-12-06 20:33:17 -08004264 qual = kmalloc (sizeof *qual, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004265 if (qual == NULL)
4266 return;
4267
4268 status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0,
4269 qual, sizeof *qual);
4270 if (status == sizeof *qual) {
4271 dev_info(&udev->dev, "not running at top speed; "
4272 "connect to a high speed hub\n");
4273 /* hub LEDs are probably harder to miss than syslog */
4274 if (hub->has_indicators) {
4275 hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
David Howellsc4028952006-11-22 14:57:56 +00004276 schedule_delayed_work (&hub->leds, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004277 }
4278 }
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -07004279 kfree(qual);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004280}
4281
4282static unsigned
4283hub_power_remaining (struct usb_hub *hub)
4284{
4285 struct usb_device *hdev = hub->hdev;
4286 int remaining;
Alan Stern55c52712005-11-23 12:03:12 -05004287 int port1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004288
Alan Stern55c52712005-11-23 12:03:12 -05004289 if (!hub->limited_power)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004290 return 0;
4291
Alan Stern55c52712005-11-23 12:03:12 -05004292 remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
4293 for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
Lan Tianyuff823c792012-09-05 13:44:32 +08004294 struct usb_device *udev = hub->ports[port1 - 1]->child;
Alan Stern55c52712005-11-23 12:03:12 -05004295 int delta;
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004296 unsigned unit_load;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004297
4298 if (!udev)
4299 continue;
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004300 if (hub_is_superspeed(udev))
4301 unit_load = 150;
4302 else
4303 unit_load = 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004304
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004305 /*
4306 * Unconfigured devices may not use more than one unit load,
4307 * or 8mA for OTG ports
4308 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004309 if (udev->actconfig)
Sebastian Andrzej Siewior8d8479d2012-12-18 15:25:46 +01004310 delta = usb_get_max_power(udev, udev->actconfig);
Alan Stern55c52712005-11-23 12:03:12 -05004311 else if (port1 != udev->bus->otg_port || hdev->parent)
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004312 delta = unit_load;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004313 else
Alan Stern55c52712005-11-23 12:03:12 -05004314 delta = 8;
4315 if (delta > hub->mA_per_port)
Wu Fengguangb9cef6c2008-12-15 15:32:01 +08004316 dev_warn(&udev->dev,
4317 "%dmA is over %umA budget for port %d!\n",
4318 delta, hub->mA_per_port, port1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004319 remaining -= delta;
4320 }
4321 if (remaining < 0) {
Alan Stern55c52712005-11-23 12:03:12 -05004322 dev_warn(hub->intfdev, "%dmA over power budget!\n",
Matthias Beyer469271f2013-10-10 23:41:27 +02004323 -remaining);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004324 remaining = 0;
4325 }
4326 return remaining;
4327}
4328
4329/* Handle physical or logical connection change events.
4330 * This routine is called when:
4331 * a port connection-change occurs;
4332 * a port enable-change occurs (often caused by EMI);
Ming Lei742120c2008-06-18 22:00:29 +08004333 * usb_reset_and_verify_device() encounters changed descriptors (as from
Linus Torvalds1da177e2005-04-16 15:20:36 -07004334 * a firmware download)
4335 * caller already locked the hub
4336 */
4337static void hub_port_connect_change(struct usb_hub *hub, int port1,
4338 u16 portstatus, u16 portchange)
4339{
4340 struct usb_device *hdev = hub->hdev;
4341 struct device *hub_dev = hub->intfdev;
Balaji Rao90da0962007-11-22 01:58:14 +05304342 struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
Alan Stern24618b02008-04-28 11:06:28 -04004343 unsigned wHubCharacteristics =
4344 le16_to_cpu(hub->descriptor->wHubCharacteristics);
Alan Stern8808f002008-04-28 11:06:55 -04004345 struct usb_device *udev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004346 int status, i;
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004347 unsigned unit_load;
Alan Stern24618b02008-04-28 11:06:28 -04004348
Linus Torvalds1da177e2005-04-16 15:20:36 -07004349 dev_dbg (hub_dev,
4350 "port %d, status %04x, change %04x, %s\n",
Sarah Sharp131dec32010-12-06 21:00:19 -08004351 port1, portstatus, portchange, portspeed(hub, portstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004352
4353 if (hub->has_indicators) {
4354 set_port_led(hub, port1, HUB_LED_AUTO);
4355 hub->indicator[port1-1] = INDICATOR_AUTO;
4356 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004357
4358#ifdef CONFIG_USB_OTG
4359 /* during HNP, don't repeat the debounce */
4360 if (hdev->bus->is_b_host)
Alan Stern24618b02008-04-28 11:06:28 -04004361 portchange &= ~(USB_PORT_STAT_C_CONNECTION |
4362 USB_PORT_STAT_C_ENABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004363#endif
4364
Alan Stern8808f002008-04-28 11:06:55 -04004365 /* Try to resuscitate an existing device */
Lan Tianyuff823c792012-09-05 13:44:32 +08004366 udev = hub->ports[port1 - 1]->child;
Alan Stern8808f002008-04-28 11:06:55 -04004367 if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
4368 udev->state != USB_STATE_NOTATTACHED) {
Alan Stern8808f002008-04-28 11:06:55 -04004369 usb_lock_device(udev);
4370 if (portstatus & USB_PORT_STAT_ENABLE) {
4371 status = 0; /* Nothing to do */
Alan Stern8808f002008-04-28 11:06:55 -04004372
Alan Stern84ebc102013-03-27 16:14:46 -04004373#ifdef CONFIG_PM_RUNTIME
Alan Stern5257d972008-09-22 14:43:08 -04004374 } else if (udev->state == USB_STATE_SUSPENDED &&
4375 udev->persist_enabled) {
Alan Stern8808f002008-04-28 11:06:55 -04004376 /* For a suspended device, treat this as a
4377 * remote wakeup event.
4378 */
Alan Stern0534d462010-01-08 12:56:30 -05004379 status = usb_remote_wakeup(udev);
Alan Stern8808f002008-04-28 11:06:55 -04004380#endif
4381
4382 } else {
Alan Stern5257d972008-09-22 14:43:08 -04004383 status = -ENODEV; /* Don't resuscitate */
Alan Stern8808f002008-04-28 11:06:55 -04004384 }
4385 usb_unlock_device(udev);
4386
4387 if (status == 0) {
4388 clear_bit(port1, hub->change_bits);
4389 return;
4390 }
4391 }
4392
Alan Stern24618b02008-04-28 11:06:28 -04004393 /* Disconnect any existing devices under this port */
Peter Chenb76baa82012-11-09 09:44:43 +08004394 if (udev) {
4395 if (hcd->phy && !hdev->parent &&
4396 !(portstatus & USB_PORT_STAT_CONNECTION))
Peter Chenac965112012-11-09 09:44:44 +08004397 usb_phy_notify_disconnect(hcd->phy, udev->speed);
Lan Tianyuff823c792012-09-05 13:44:32 +08004398 usb_disconnect(&hub->ports[port1 - 1]->child);
Peter Chenb76baa82012-11-09 09:44:43 +08004399 }
Alan Stern24618b02008-04-28 11:06:28 -04004400 clear_bit(port1, hub->change_bits);
4401
Alan Stern253e0572009-10-27 15:20:13 -04004402 /* We can forget about a "removed" device when there's a physical
4403 * disconnect or the connect status changes.
4404 */
4405 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
4406 (portchange & USB_PORT_STAT_C_CONNECTION))
4407 clear_bit(port1, hub->removed_bits);
4408
Alan Stern5257d972008-09-22 14:43:08 -04004409 if (portchange & (USB_PORT_STAT_C_CONNECTION |
4410 USB_PORT_STAT_C_ENABLE)) {
Lan Tianyuad493e52013-01-23 04:26:30 +08004411 status = hub_port_debounce_be_stable(hub, port1);
Alan Stern5257d972008-09-22 14:43:08 -04004412 if (status < 0) {
Alan Sterne9e88fb2013-03-27 16:14:01 -04004413 if (status != -ENODEV && printk_ratelimit())
Alan Stern5257d972008-09-22 14:43:08 -04004414 dev_err(hub_dev, "connect-debounce failed, "
4415 "port %d disabled\n", port1);
4416 portstatus &= ~USB_PORT_STAT_CONNECTION;
4417 } else {
4418 portstatus = status;
4419 }
4420 }
4421
Alan Stern253e0572009-10-27 15:20:13 -04004422 /* Return now if debouncing failed or nothing is connected or
4423 * the device was "removed".
4424 */
4425 if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
4426 test_bit(port1, hub->removed_bits)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004427
4428 /* maybe switch power back on (e.g. root hub was reset) */
Greg Kroah-Hartman74ad9bd2005-06-20 21:15:16 -07004429 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
Andiry Xu0ed9a572011-04-27 18:07:43 +08004430 && !port_is_power_on(hub, portstatus))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004431 set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
Alan Stern5257d972008-09-22 14:43:08 -04004432
Linus Torvalds1da177e2005-04-16 15:20:36 -07004433 if (portstatus & USB_PORT_STAT_ENABLE)
Matthias Beyer469271f2013-10-10 23:41:27 +02004434 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004435 return;
4436 }
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004437 if (hub_is_superspeed(hub->hdev))
4438 unit_load = 150;
4439 else
4440 unit_load = 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004441
Alan Sterne9e88fb2013-03-27 16:14:01 -04004442 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004443 for (i = 0; i < SET_CONFIG_TRIES; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004444
4445 /* reallocate for each attempt, since references
4446 * to the previous one can escape in various ways
4447 */
4448 udev = usb_alloc_dev(hdev, hdev->bus, port1);
4449 if (!udev) {
4450 dev_err (hub_dev,
4451 "couldn't allocate port %d usb_device\n",
4452 port1);
4453 goto done;
4454 }
4455
4456 usb_set_device_state(udev, USB_STATE_POWERED);
Matthias Beyer469271f2013-10-10 23:41:27 +02004457 udev->bus_mA = hub->mA_per_port;
Alan Sternb6956ff2006-08-30 15:46:48 -04004458 udev->level = hdev->level + 1;
Inaky Perez-Gonzalez8af548d2008-04-08 13:24:46 -07004459 udev->wusb = hub_is_wusb(hub);
Alan Stern55c52712005-11-23 12:03:12 -05004460
Sarah Sharp131dec32010-12-06 21:00:19 -08004461 /* Only USB 3.0 devices are connected to SuperSpeed hubs. */
4462 if (hub_is_superspeed(hub->hdev))
Sarah Sharpe7b77172009-04-27 19:54:26 -07004463 udev->speed = USB_SPEED_SUPER;
4464 else
4465 udev->speed = USB_SPEED_UNKNOWN;
4466
Alan Stern3b29b682011-02-22 09:53:41 -05004467 choose_devnum(udev);
Andiry Xuc8d4af82010-10-14 07:22:51 -07004468 if (udev->devnum <= 0) {
4469 status = -ENOTCONN; /* Don't retry */
4470 goto loop;
Sarah Sharpc6515272009-04-27 19:57:26 -07004471 }
4472
Sarah Sharpe7b77172009-04-27 19:54:26 -07004473 /* reset (non-USB 3.0 devices) and get descriptor */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004474 status = hub_port_init(hub, udev, port1, i);
4475 if (status < 0)
4476 goto loop;
4477
Phil Dibowitz93362a82010-07-22 00:05:01 +02004478 usb_detect_quirks(udev);
4479 if (udev->quirks & USB_QUIRK_DELAY_INIT)
4480 msleep(1000);
4481
Linus Torvalds1da177e2005-04-16 15:20:36 -07004482 /* consecutive bus-powered hubs aren't reliable; they can
4483 * violate the voltage drop budget. if the new child has
4484 * a "powered" LED, users should notice we didn't enable it
4485 * (without reading syslog), even without per-port LEDs
4486 * on the parent.
4487 */
4488 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
Sebastian Andrzej Siewior430ee582012-12-18 15:25:47 +01004489 && udev->bus_mA <= unit_load) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004490 u16 devstat;
4491
4492 status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
4493 &devstat);
Alan Stern15b73362013-07-30 15:35:40 -04004494 if (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004495 dev_dbg(&udev->dev, "get status %d ?\n", status);
4496 goto loop_disable;
4497 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004498 if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
4499 dev_err(&udev->dev,
4500 "can't connect bus-powered hub "
4501 "to this port\n");
4502 if (hub->has_indicators) {
4503 hub->indicator[port1-1] =
4504 INDICATOR_AMBER_BLINK;
David Howellsc4028952006-11-22 14:57:56 +00004505 schedule_delayed_work (&hub->leds, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004506 }
4507 status = -ENOTCONN; /* Don't retry */
4508 goto loop_disable;
4509 }
4510 }
Matthias Beyer469271f2013-10-10 23:41:27 +02004511
Linus Torvalds1da177e2005-04-16 15:20:36 -07004512 /* check for devices running slower than they could */
4513 if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
4514 && udev->speed == USB_SPEED_FULL
4515 && highspeed_hubs != 0)
4516 check_highspeed (hub, udev, port1);
4517
Greg Kroah-Hartmanfa286182012-05-14 09:20:37 -07004518 /* Store the parent's children[] pointer. At this point
Linus Torvalds1da177e2005-04-16 15:20:36 -07004519 * udev becomes globally accessible, although presumably
4520 * no one will look at it until hdev is unlocked.
4521 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004522 status = 0;
4523
4524 /* We mustn't add new devices if the parent hub has
4525 * been disconnected; we would race with the
4526 * recursively_mark_NOTATTACHED() routine.
4527 */
4528 spin_lock_irq(&device_state_lock);
4529 if (hdev->state == USB_STATE_NOTATTACHED)
4530 status = -ENOTCONN;
4531 else
Lan Tianyuff823c792012-09-05 13:44:32 +08004532 hub->ports[port1 - 1]->child = udev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004533 spin_unlock_irq(&device_state_lock);
4534
4535 /* Run it through the hoops (find a driver, etc) */
4536 if (!status) {
4537 status = usb_new_device(udev);
4538 if (status) {
4539 spin_lock_irq(&device_state_lock);
Lan Tianyuff823c792012-09-05 13:44:32 +08004540 hub->ports[port1 - 1]->child = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004541 spin_unlock_irq(&device_state_lock);
4542 }
4543 }
4544
Linus Torvalds1da177e2005-04-16 15:20:36 -07004545 if (status)
4546 goto loop_disable;
4547
4548 status = hub_power_remaining(hub);
4549 if (status)
Alan Stern55c52712005-11-23 12:03:12 -05004550 dev_dbg(hub_dev, "%dmA power budget left\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004551
4552 return;
4553
4554loop_disable:
4555 hub_port_disable(hub, port1, 1);
4556loop:
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07004557 usb_ep0_reinit(udev);
Alan Stern3b29b682011-02-22 09:53:41 -05004558 release_devnum(udev);
Herbert Xuf7410ce2010-01-10 20:15:03 +11004559 hub_free_dev(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004560 usb_put_dev(udev);
Vikram Panditaffcdc182007-05-25 21:31:07 -07004561 if ((status == -ENOTCONN) || (status == -ENOTSUPP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004562 break;
4563 }
Alan Stern3a311552008-05-20 16:58:29 -04004564 if (hub->hdev->parent ||
4565 !hcd->driver->port_handed_over ||
Alan Sterne9e88fb2013-03-27 16:14:01 -04004566 !(hcd->driver->port_handed_over)(hcd, port1)) {
4567 if (status != -ENOTCONN && status != -ENODEV)
4568 dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
4569 port1);
4570 }
Matthias Beyer469271f2013-10-10 23:41:27 +02004571
Linus Torvalds1da177e2005-04-16 15:20:36 -07004572done:
4573 hub_port_disable(hub, port1, 1);
Balaji Rao90da0962007-11-22 01:58:14 +05304574 if (hcd->driver->relinquish_port && !hub->hdev->parent)
4575 hcd->driver->relinquish_port(hcd, port1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004576}
4577
Sarah Sharp714b07b2012-01-24 13:53:18 -08004578/* Returns 1 if there was a remote wakeup and a connect status change. */
4579static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
Sarah Sharp72937e12012-01-24 11:46:50 -08004580 u16 portstatus, u16 portchange)
Sarah Sharp714b07b2012-01-24 13:53:18 -08004581{
4582 struct usb_device *hdev;
4583 struct usb_device *udev;
4584 int connect_change = 0;
4585 int ret;
4586
4587 hdev = hub->hdev;
Lan Tianyuff823c792012-09-05 13:44:32 +08004588 udev = hub->ports[port - 1]->child;
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004589 if (!hub_is_superspeed(hdev)) {
4590 if (!(portchange & USB_PORT_STAT_C_SUSPEND))
4591 return 0;
Lan Tianyuad493e52013-01-23 04:26:30 +08004592 usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004593 } else {
4594 if (!udev || udev->state != USB_STATE_SUSPENDED ||
Sarah Sharp72937e12012-01-24 11:46:50 -08004595 (portstatus & USB_PORT_STAT_LINK_STATE) !=
4596 USB_SS_PORT_LS_U0)
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004597 return 0;
4598 }
4599
Sarah Sharp714b07b2012-01-24 13:53:18 -08004600 if (udev) {
4601 /* TRSMRCY = 10 msec */
4602 msleep(10);
4603
4604 usb_lock_device(udev);
4605 ret = usb_remote_wakeup(udev);
4606 usb_unlock_device(udev);
4607 if (ret < 0)
4608 connect_change = 1;
4609 } else {
4610 ret = -ENODEV;
4611 hub_port_disable(hub, port, 1);
4612 }
4613 dev_dbg(hub->intfdev, "resume on port %d, status %d\n",
4614 port, ret);
4615 return connect_change;
4616}
4617
Linus Torvalds1da177e2005-04-16 15:20:36 -07004618static void hub_events(void)
4619{
4620 struct list_head *tmp;
4621 struct usb_device *hdev;
4622 struct usb_interface *intf;
4623 struct usb_hub *hub;
4624 struct device *hub_dev;
4625 u16 hubstatus;
4626 u16 hubchange;
4627 u16 portstatus;
4628 u16 portchange;
4629 int i, ret;
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004630 int connect_change, wakeup_change;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004631
4632 /*
4633 * We restart the list every time to avoid a deadlock with
4634 * deleting hubs downstream from this one. This should be
4635 * safe since we delete the hub from the event list.
4636 * Not the most efficient, but avoids deadlocks.
4637 */
4638 while (1) {
4639
4640 /* Grab the first entry at the beginning of the list */
4641 spin_lock_irq(&hub_event_lock);
4642 if (list_empty(&hub_event_list)) {
4643 spin_unlock_irq(&hub_event_lock);
4644 break;
4645 }
4646
4647 tmp = hub_event_list.next;
4648 list_del_init(tmp);
4649
4650 hub = list_entry(tmp, struct usb_hub, event_list);
Alan Sterne8054852007-05-04 11:55:11 -04004651 kref_get(&hub->kref);
4652 spin_unlock_irq(&hub_event_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004653
Alan Sterne8054852007-05-04 11:55:11 -04004654 hdev = hub->hdev;
4655 hub_dev = hub->intfdev;
4656 intf = to_usb_interface(hub_dev);
Alan Stern40f122f2006-11-09 14:44:33 -05004657 dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
Krzysztof Mazur3bbc47d2013-08-22 14:49:40 +02004658 hdev->state, hdev->maxchild,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004659 /* NOTE: expects max 15 ports... */
4660 (u16) hub->change_bits[0],
Alan Stern40f122f2006-11-09 14:44:33 -05004661 (u16) hub->event_bits[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004662
Linus Torvalds1da177e2005-04-16 15:20:36 -07004663 /* Lock the device, then check to see if we were
4664 * disconnected while waiting for the lock to succeed. */
Alan Stern06b84e82007-05-04 11:54:50 -04004665 usb_lock_device(hdev);
Alan Sterne8054852007-05-04 11:55:11 -04004666 if (unlikely(hub->disconnected))
Alan Stern9bbdf1e2010-01-08 12:57:28 -05004667 goto loop_disconnected;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004668
4669 /* If the hub has died, clean up after it */
4670 if (hdev->state == USB_STATE_NOTATTACHED) {
Alan Stern7de18d82006-06-01 13:37:24 -04004671 hub->error = -ENODEV;
Alan Stern43303542008-04-28 11:07:31 -04004672 hub_quiesce(hub, HUB_DISCONNECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673 goto loop;
4674 }
4675
Alan Stern40f122f2006-11-09 14:44:33 -05004676 /* Autoresume */
4677 ret = usb_autopm_get_interface(intf);
4678 if (ret) {
4679 dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004680 goto loop;
Alan Stern40f122f2006-11-09 14:44:33 -05004681 }
4682
4683 /* If this is an inactive hub, do nothing */
4684 if (hub->quiescing)
4685 goto loop_autopm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004686
4687 if (hub->error) {
4688 dev_dbg (hub_dev, "resetting for error %d\n",
4689 hub->error);
4690
Ming Lei742120c2008-06-18 22:00:29 +08004691 ret = usb_reset_device(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004692 if (ret) {
4693 dev_dbg (hub_dev,
4694 "error resetting hub: %d\n", ret);
Alan Stern40f122f2006-11-09 14:44:33 -05004695 goto loop_autopm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004696 }
4697
4698 hub->nerrors = 0;
4699 hub->error = 0;
4700 }
4701
4702 /* deal with port status changes */
Krzysztof Mazur3bbc47d2013-08-22 14:49:40 +02004703 for (i = 1; i <= hdev->maxchild; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004704 if (test_bit(i, hub->busy_bits))
4705 continue;
4706 connect_change = test_bit(i, hub->change_bits);
Sarah Sharp72937e12012-01-24 11:46:50 -08004707 wakeup_change = test_and_clear_bit(i, hub->wakeup_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004708 if (!test_and_clear_bit(i, hub->event_bits) &&
Sarah Sharp4ee823b2011-11-14 18:00:01 -08004709 !connect_change && !wakeup_change)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004710 continue;
4711
4712 ret = hub_port_status(hub, i,
4713 &portstatus, &portchange);
4714 if (ret < 0)
4715 continue;
4716
Linus Torvalds1da177e2005-04-16 15:20:36 -07004717 if (portchange & USB_PORT_STAT_C_CONNECTION) {
Lan Tianyuad493e52013-01-23 04:26:30 +08004718 usb_clear_port_feature(hdev, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004719 USB_PORT_FEAT_C_CONNECTION);
4720 connect_change = 1;
4721 }
4722
4723 if (portchange & USB_PORT_STAT_C_ENABLE) {
4724 if (!connect_change)
4725 dev_dbg (hub_dev,
4726 "port %d enable change, "
4727 "status %08x\n",
4728 i, portstatus);
Lan Tianyuad493e52013-01-23 04:26:30 +08004729 usb_clear_port_feature(hdev, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004730 USB_PORT_FEAT_C_ENABLE);
4731
4732 /*
4733 * EM interference sometimes causes badly
4734 * shielded USB devices to be shutdown by
4735 * the hub, this hack enables them again.
Matthias Beyer469271f2013-10-10 23:41:27 +02004736 * Works at least with mouse driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004737 */
4738 if (!(portstatus & USB_PORT_STAT_ENABLE)
4739 && !connect_change
Lan Tianyuff823c792012-09-05 13:44:32 +08004740 && hub->ports[i - 1]->child) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004741 dev_err (hub_dev,
4742 "port %i "
4743 "disabled by hub (EMI?), "
4744 "re-enabling...\n",
4745 i);
4746 connect_change = 1;
4747 }
4748 }
4749
Sarah Sharp72937e12012-01-24 11:46:50 -08004750 if (hub_handle_remote_wakeup(hub, i,
4751 portstatus, portchange))
Sarah Sharp714b07b2012-01-24 13:53:18 -08004752 connect_change = 1;
Alan Stern8808f002008-04-28 11:06:55 -04004753
Linus Torvalds1da177e2005-04-16 15:20:36 -07004754 if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
Paul Bolle752d57a2011-03-11 18:03:52 +01004755 u16 status = 0;
4756 u16 unused;
4757
4758 dev_dbg(hub_dev, "over-current change on port "
4759 "%d\n", i);
Lan Tianyuad493e52013-01-23 04:26:30 +08004760 usb_clear_port_feature(hdev, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004761 USB_PORT_FEAT_C_OVER_CURRENT);
Paul Bolle752d57a2011-03-11 18:03:52 +01004762 msleep(100); /* Cool down */
Alan Stern8520f382008-09-22 14:44:26 -04004763 hub_power_on(hub, true);
Paul Bolle752d57a2011-03-11 18:03:52 +01004764 hub_port_status(hub, i, &status, &unused);
4765 if (status & USB_PORT_STAT_OVERCURRENT)
4766 dev_err(hub_dev, "over-current "
4767 "condition on port %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004768 }
4769
4770 if (portchange & USB_PORT_STAT_C_RESET) {
4771 dev_dbg (hub_dev,
4772 "reset change on port %d\n",
4773 i);
Lan Tianyuad493e52013-01-23 04:26:30 +08004774 usb_clear_port_feature(hdev, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004775 USB_PORT_FEAT_C_RESET);
4776 }
Sarah Sharpc7061572010-12-06 15:08:20 -08004777 if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
4778 hub_is_superspeed(hub->hdev)) {
4779 dev_dbg(hub_dev,
4780 "warm reset change on port %d\n",
4781 i);
Lan Tianyuad493e52013-01-23 04:26:30 +08004782 usb_clear_port_feature(hdev, i,
Sarah Sharpc7061572010-12-06 15:08:20 -08004783 USB_PORT_FEAT_C_BH_PORT_RESET);
4784 }
John Youndbe79bb2001-09-17 00:00:00 -07004785 if (portchange & USB_PORT_STAT_C_LINK_STATE) {
Lan Tianyuad493e52013-01-23 04:26:30 +08004786 usb_clear_port_feature(hub->hdev, i,
John Youndbe79bb2001-09-17 00:00:00 -07004787 USB_PORT_FEAT_C_PORT_LINK_STATE);
4788 }
4789 if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
4790 dev_warn(hub_dev,
4791 "config error on port %d\n",
4792 i);
Lan Tianyuad493e52013-01-23 04:26:30 +08004793 usb_clear_port_feature(hub->hdev, i,
John Youndbe79bb2001-09-17 00:00:00 -07004794 USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
4795 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004796
Andiry Xu5e467f62011-04-27 18:07:54 +08004797 /* Warm reset a USB3 protocol port if it's in
4798 * SS.Inactive state.
4799 */
Stanislaw Ledwon8bea2bd2012-06-18 15:20:00 +02004800 if (hub_port_warm_reset_required(hub, portstatus)) {
Sarah Sharp65bdac52012-11-14 17:58:04 -08004801 int status;
Sarah Sharpd3b9d7a2012-11-01 11:20:44 -07004802 struct usb_device *udev =
4803 hub->ports[i - 1]->child;
Sarah Sharp65bdac52012-11-14 17:58:04 -08004804
Andiry Xu5e467f62011-04-27 18:07:54 +08004805 dev_dbg(hub_dev, "warm reset port %d\n", i);
Julius Wernerf3e94aa2013-07-30 19:51:20 -07004806 if (!udev || !(portstatus &
4807 USB_PORT_STAT_CONNECTION)) {
Sarah Sharpd3b9d7a2012-11-01 11:20:44 -07004808 status = hub_port_reset(hub, i,
4809 NULL, HUB_BH_RESET_TIME,
4810 true);
4811 if (status < 0)
4812 hub_port_disable(hub, i, 1);
4813 } else {
4814 usb_lock_device(udev);
4815 status = usb_reset_device(udev);
4816 usb_unlock_device(udev);
Julius Wernerf3e94aa2013-07-30 19:51:20 -07004817 connect_change = 0;
Sarah Sharpd3b9d7a2012-11-01 11:20:44 -07004818 }
Andiry Xu5e467f62011-04-27 18:07:54 +08004819 }
4820
Linus Torvalds1da177e2005-04-16 15:20:36 -07004821 if (connect_change)
4822 hub_port_connect_change(hub, i,
4823 portstatus, portchange);
4824 } /* end for i */
4825
4826 /* deal with hub status changes */
4827 if (test_and_clear_bit(0, hub->event_bits) == 0)
4828 ; /* do nothing */
4829 else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
4830 dev_err (hub_dev, "get_hub_status failed\n");
4831 else {
4832 if (hubchange & HUB_CHANGE_LOCAL_POWER) {
4833 dev_dbg (hub_dev, "power change\n");
4834 clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
Alan Stern55c52712005-11-23 12:03:12 -05004835 if (hubstatus & HUB_STATUS_LOCAL_POWER)
4836 /* FIXME: Is this always true? */
Alan Stern55c52712005-11-23 12:03:12 -05004837 hub->limited_power = 1;
jidong xiao403fae72007-09-14 00:08:51 +08004838 else
4839 hub->limited_power = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004840 }
4841 if (hubchange & HUB_CHANGE_OVERCURRENT) {
Paul Bolle752d57a2011-03-11 18:03:52 +01004842 u16 status = 0;
4843 u16 unused;
4844
4845 dev_dbg(hub_dev, "over-current change\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004846 clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
Paul Bolle752d57a2011-03-11 18:03:52 +01004847 msleep(500); /* Cool down */
Matthias Beyer469271f2013-10-10 23:41:27 +02004848 hub_power_on(hub, true);
Paul Bolle752d57a2011-03-11 18:03:52 +01004849 hub_hub_status(hub, &status, &unused);
4850 if (status & HUB_STATUS_OVERCURRENT)
4851 dev_err(hub_dev, "over-current "
4852 "condition\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004853 }
4854 }
4855
Alan Stern8e4ceb32009-12-07 13:01:37 -05004856 loop_autopm:
4857 /* Balance the usb_autopm_get_interface() above */
4858 usb_autopm_put_interface_no_suspend(intf);
4859 loop:
4860 /* Balance the usb_autopm_get_interface_no_resume() in
4861 * kick_khubd() and allow autosuspend.
4862 */
4863 usb_autopm_put_interface(intf);
Alan Stern9bbdf1e2010-01-08 12:57:28 -05004864 loop_disconnected:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004865 usb_unlock_device(hdev);
Alan Sterne8054852007-05-04 11:55:11 -04004866 kref_put(&hub->kref, hub_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004867
Matthias Beyer469271f2013-10-10 23:41:27 +02004868 } /* end while (1) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004869}
4870
4871static int hub_thread(void *__unused)
4872{
Alan Stern3bb1af52008-03-03 15:15:36 -05004873 /* khubd needs to be freezable to avoid intefering with USB-PERSIST
4874 * port handover. Otherwise it might see that a full-speed device
4875 * was gone before the EHCI controller had handed its port over to
4876 * the companion full-speed controller.
4877 */
Rafael J. Wysocki83144182007-07-17 04:03:35 -07004878 set_freezable();
Alan Stern3bb1af52008-03-03 15:15:36 -05004879
Linus Torvalds1da177e2005-04-16 15:20:36 -07004880 do {
4881 hub_events();
Rafael J. Wysockie42837b2007-10-18 03:04:45 -07004882 wait_event_freezable(khubd_wait,
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004883 !list_empty(&hub_event_list) ||
4884 kthread_should_stop());
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004885 } while (!kthread_should_stop() || !list_empty(&hub_event_list));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004886
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004887 pr_debug("%s: khubd exiting\n", usbcore_name);
4888 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004889}
4890
Németh Márton1e927d92010-01-10 15:34:53 +01004891static const struct usb_device_id hub_id_table[] = {
Ming Leie6f30de2012-10-24 11:59:24 +08004892 { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
Matthias Beyer469271f2013-10-10 23:41:27 +02004893 | USB_DEVICE_ID_MATCH_INT_CLASS,
Ming Leie6f30de2012-10-24 11:59:24 +08004894 .idVendor = USB_VENDOR_GENESYS_LOGIC,
4895 .bInterfaceClass = USB_CLASS_HUB,
4896 .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
Linus Torvalds1da177e2005-04-16 15:20:36 -07004897 { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
4898 .bDeviceClass = USB_CLASS_HUB},
4899 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
4900 .bInterfaceClass = USB_CLASS_HUB},
4901 { } /* Terminating entry */
4902};
4903
4904MODULE_DEVICE_TABLE (usb, hub_id_table);
4905
4906static struct usb_driver hub_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004907 .name = "hub",
4908 .probe = hub_probe,
4909 .disconnect = hub_disconnect,
4910 .suspend = hub_suspend,
4911 .resume = hub_resume,
Alan Sternf07600c2007-05-30 15:38:16 -04004912 .reset_resume = hub_reset_resume,
Alan Stern7de18d82006-06-01 13:37:24 -04004913 .pre_reset = hub_pre_reset,
4914 .post_reset = hub_post_reset,
Andi Kleenc532b292010-06-01 23:04:41 +02004915 .unlocked_ioctl = hub_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004916 .id_table = hub_id_table,
Alan Stern40f122f2006-11-09 14:44:33 -05004917 .supports_autosuspend = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004918};
4919
4920int usb_hub_init(void)
4921{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004922 if (usb_register(&hub_driver) < 0) {
4923 printk(KERN_ERR "%s: can't register hub driver\n",
4924 usbcore_name);
4925 return -1;
4926 }
4927
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004928 khubd_task = kthread_run(hub_thread, NULL, "khubd");
4929 if (!IS_ERR(khubd_task))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004930 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004931
4932 /* Fall through if kernel_thread failed */
4933 usb_deregister(&hub_driver);
4934 printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);
4935
4936 return -1;
4937}
4938
4939void usb_hub_cleanup(void)
4940{
akpm@osdl.org9c8d6172005-06-20 14:29:58 -07004941 kthread_stop(khubd_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004942
4943 /*
4944 * Hub resources are freed for us by usb_deregister. It calls
4945 * usb_driver_purge on every device which in turn calls that
4946 * devices disconnect function if it is using this driver.
4947 * The hub_disconnect function takes care of releasing the
4948 * individual hub resources. -greg
4949 */
4950 usb_deregister(&hub_driver);
4951} /* usb_hub_cleanup() */
4952
Alan Sterneb764c42008-03-03 15:16:04 -05004953static int descriptors_changed(struct usb_device *udev,
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03004954 struct usb_device_descriptor *old_device_descriptor,
4955 struct usb_host_bos *old_bos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004956{
Alan Sterneb764c42008-03-03 15:16:04 -05004957 int changed = 0;
4958 unsigned index;
4959 unsigned serial_len = 0;
4960 unsigned len;
4961 unsigned old_length;
4962 int length;
4963 char *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004964
Alan Sterneb764c42008-03-03 15:16:04 -05004965 if (memcmp(&udev->descriptor, old_device_descriptor,
4966 sizeof(*old_device_descriptor)) != 0)
4967 return 1;
4968
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03004969 if ((old_bos && !udev->bos) || (!old_bos && udev->bos))
4970 return 1;
4971 if (udev->bos) {
Xenia Ragiadakoub9a10482013-08-31 04:40:49 +03004972 len = le16_to_cpu(udev->bos->desc->wTotalLength);
4973 if (len != le16_to_cpu(old_bos->desc->wTotalLength))
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03004974 return 1;
Xenia Ragiadakoub9a10482013-08-31 04:40:49 +03004975 if (memcmp(udev->bos->desc, old_bos->desc, len))
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03004976 return 1;
4977 }
4978
Alan Sterneb764c42008-03-03 15:16:04 -05004979 /* Since the idVendor, idProduct, and bcdDevice values in the
4980 * device descriptor haven't changed, we will assume the
4981 * Manufacturer and Product strings haven't changed either.
4982 * But the SerialNumber string could be different (e.g., a
4983 * different flash card of the same brand).
4984 */
4985 if (udev->serial)
4986 serial_len = strlen(udev->serial) + 1;
4987
4988 len = serial_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004989 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
Alan Sterneb764c42008-03-03 15:16:04 -05004990 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
4991 len = max(len, old_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004992 }
Alan Sterneb764c42008-03-03 15:16:04 -05004993
Oliver Neukum0cc1a512008-01-10 10:31:48 +01004994 buf = kmalloc(len, GFP_NOIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004995 if (buf == NULL) {
4996 dev_err(&udev->dev, "no mem to re-read configs after reset\n");
4997 /* assume the worst */
4998 return 1;
4999 }
5000 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
Alan Sterneb764c42008-03-03 15:16:04 -05005001 old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005002 length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
5003 old_length);
Alan Sterneb764c42008-03-03 15:16:04 -05005004 if (length != old_length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005005 dev_dbg(&udev->dev, "config index %d, error %d\n",
5006 index, length);
Alan Sterneb764c42008-03-03 15:16:04 -05005007 changed = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005008 break;
5009 }
5010 if (memcmp (buf, udev->rawdescriptors[index], old_length)
5011 != 0) {
5012 dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
Alan Sterneb764c42008-03-03 15:16:04 -05005013 index,
5014 ((struct usb_config_descriptor *) buf)->
5015 bConfigurationValue);
5016 changed = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005017 break;
5018 }
5019 }
Alan Sterneb764c42008-03-03 15:16:04 -05005020
5021 if (!changed && serial_len) {
5022 length = usb_string(udev, udev->descriptor.iSerialNumber,
5023 buf, serial_len);
5024 if (length + 1 != serial_len) {
5025 dev_dbg(&udev->dev, "serial string error %d\n",
5026 length);
5027 changed = 1;
5028 } else if (memcmp(buf, udev->serial, length) != 0) {
5029 dev_dbg(&udev->dev, "serial string changed\n");
5030 changed = 1;
5031 }
5032 }
5033
Linus Torvalds1da177e2005-04-16 15:20:36 -07005034 kfree(buf);
Alan Sterneb764c42008-03-03 15:16:04 -05005035 return changed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005036}
5037
5038/**
Ming Lei742120c2008-06-18 22:00:29 +08005039 * usb_reset_and_verify_device - perform a USB port reset to reinitialize a device
Linus Torvalds1da177e2005-04-16 15:20:36 -07005040 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
5041 *
Alan Stern79efa092006-06-01 13:33:42 -04005042 * WARNING - don't use this routine to reset a composite device
5043 * (one with multiple interfaces owned by separate drivers)!
Ming Lei742120c2008-06-18 22:00:29 +08005044 * Use usb_reset_device() instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005045 *
5046 * Do a port reset, reassign the device's address, and establish its
5047 * former operating configuration. If the reset fails, or the device's
5048 * descriptors change from their values before the reset, or the original
5049 * configuration and altsettings cannot be restored, a flag will be set
5050 * telling khubd to pretend the device has been disconnected and then
5051 * re-connected. All drivers will be unbound, and the device will be
5052 * re-enumerated and probed all over again.
5053 *
Yacine Belkadi626f0902013-08-02 20:10:04 +02005054 * Return: 0 if the reset succeeded, -ENODEV if the device has been
Linus Torvalds1da177e2005-04-16 15:20:36 -07005055 * flagged for logical disconnection, or some other negative error code
5056 * if the reset wasn't even attempted.
5057 *
Yacine Belkadi626f0902013-08-02 20:10:04 +02005058 * Note:
Linus Torvalds1da177e2005-04-16 15:20:36 -07005059 * The caller must own the device lock. For example, it's safe to use
5060 * this from a driver probe() routine after downloading new firmware.
5061 * For calls that might not occur during probe(), drivers should lock
5062 * the device using usb_lock_device_for_reset().
Alan Stern6bc6cff2007-05-04 11:53:03 -04005063 *
5064 * Locking exception: This routine may also be called from within an
5065 * autoresume handler. Such usage won't conflict with other tasks
5066 * holding the device lock because these tasks should always call
5067 * usb_autopm_resume_device(), thereby preventing any unwanted autoresume.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005068 */
Ming Lei742120c2008-06-18 22:00:29 +08005069static int usb_reset_and_verify_device(struct usb_device *udev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005070{
5071 struct usb_device *parent_hdev = udev->parent;
5072 struct usb_hub *parent_hub;
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005073 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005074 struct usb_device_descriptor descriptor = udev->descriptor;
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03005075 struct usb_host_bos *bos;
Alan Stern12c3da32005-11-23 12:09:52 -05005076 int i, ret = 0;
5077 int port1 = udev->portnum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005078
5079 if (udev->state == USB_STATE_NOTATTACHED ||
5080 udev->state == USB_STATE_SUSPENDED) {
5081 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5082 udev->state);
5083 return -EINVAL;
5084 }
5085
5086 if (!parent_hdev) {
Wolfram Sang4bec9912010-08-29 18:17:14 +02005087 /* this requires hcd-specific logic; see ohci_restart() */
Harvey Harrison441b62c2008-03-03 16:08:34 -08005088 dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005089 return -EISDIR;
5090 }
Lan Tianyuad493e52013-01-23 04:26:30 +08005091 parent_hub = usb_hub_to_struct_hub(parent_hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005092
Sarah Sharpdcc01c02013-09-30 17:26:29 +03005093 /* Disable USB2 hardware LPM.
5094 * It will be re-enabled by the enumeration process.
5095 */
5096 if (udev->usb2_hw_lpm_enabled == 1)
5097 usb_set_usb2_hardware_lpm(udev, 0);
5098
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03005099 bos = udev->bos;
5100 udev->bos = NULL;
5101
Sarah Sharpf74631e2012-06-25 12:08:08 -07005102 /* Disable LPM and LTM while we reset the device and reinstall the alt
5103 * settings. Device-initiated LPM settings, and system exit latency
5104 * settings are cleared when the device is reset, so we have to set
5105 * them up again.
Sarah Sharp6d1d0512012-07-03 22:49:04 -07005106 */
5107 ret = usb_unlocked_disable_lpm(udev);
5108 if (ret) {
5109 dev_err(&udev->dev, "%s Failed to disable LPM\n.", __func__);
5110 goto re_enumerate;
5111 }
Sarah Sharpf74631e2012-06-25 12:08:08 -07005112 ret = usb_disable_ltm(udev);
5113 if (ret) {
5114 dev_err(&udev->dev, "%s Failed to disable LTM\n.",
5115 __func__);
5116 goto re_enumerate;
5117 }
Sarah Sharp6d1d0512012-07-03 22:49:04 -07005118
Linus Torvalds1da177e2005-04-16 15:20:36 -07005119 set_bit(port1, parent_hub->busy_bits);
5120 for (i = 0; i < SET_CONFIG_TRIES; ++i) {
5121
5122 /* ep0 maxpacket size may change; let the HCD know about it.
5123 * Other endpoints will be handled by re-enumeration. */
Inaky Perez-Gonzalezfc721f52008-04-08 13:24:46 -07005124 usb_ep0_reinit(udev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005125 ret = hub_port_init(parent_hub, udev, port1, i);
Alan Sterndd4dd192007-05-04 11:55:54 -04005126 if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005127 break;
5128 }
5129 clear_bit(port1, parent_hub->busy_bits);
Alan Sternd5cbad42006-08-11 16:52:39 -04005130
Linus Torvalds1da177e2005-04-16 15:20:36 -07005131 if (ret < 0)
5132 goto re_enumerate;
Matthias Beyer469271f2013-10-10 23:41:27 +02005133
Linus Torvalds1da177e2005-04-16 15:20:36 -07005134 /* Device might have changed firmware (DFU or similar) */
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03005135 if (descriptors_changed(udev, &descriptor, bos)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005136 dev_info(&udev->dev, "device firmware changed\n");
5137 udev->descriptor = descriptor; /* for disconnect() calls */
5138 goto re_enumerate;
Matthias Beyer469271f2013-10-10 23:41:27 +02005139 }
Alan Stern4fe03872009-02-26 10:21:02 -05005140
5141 /* Restore the device's previous configuration */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005142 if (!udev->actconfig)
5143 goto done;
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005144
Sarah Sharpd673bfc2010-10-15 08:55:24 -07005145 mutex_lock(hcd->bandwidth_mutex);
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005146 ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
5147 if (ret < 0) {
5148 dev_warn(&udev->dev,
5149 "Busted HC? Not enough HCD resources for "
5150 "old configuration.\n");
Sarah Sharpd673bfc2010-10-15 08:55:24 -07005151 mutex_unlock(hcd->bandwidth_mutex);
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005152 goto re_enumerate;
5153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005154 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
5155 USB_REQ_SET_CONFIGURATION, 0,
5156 udev->actconfig->desc.bConfigurationValue, 0,
5157 NULL, 0, USB_CTRL_SET_TIMEOUT);
5158 if (ret < 0) {
5159 dev_err(&udev->dev,
5160 "can't restore configuration #%d (error=%d)\n",
5161 udev->actconfig->desc.bConfigurationValue, ret);
Sarah Sharpd673bfc2010-10-15 08:55:24 -07005162 mutex_unlock(hcd->bandwidth_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005163 goto re_enumerate;
Matthias Beyer469271f2013-10-10 23:41:27 +02005164 }
Sarah Sharpd673bfc2010-10-15 08:55:24 -07005165 mutex_unlock(hcd->bandwidth_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005166 usb_set_device_state(udev, USB_STATE_CONFIGURED);
5167
Alan Stern4fe03872009-02-26 10:21:02 -05005168 /* Put interfaces back into the same altsettings as before.
5169 * Don't bother to send the Set-Interface request for interfaces
5170 * that were already in altsetting 0; besides being unnecessary,
5171 * many devices can't handle it. Instead just reset the host-side
5172 * endpoint state.
5173 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005174 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005175 struct usb_host_config *config = udev->actconfig;
5176 struct usb_interface *intf = config->interface[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07005177 struct usb_interface_descriptor *desc;
5178
Linus Torvalds1da177e2005-04-16 15:20:36 -07005179 desc = &intf->cur_altsetting->desc;
Alan Stern4fe03872009-02-26 10:21:02 -05005180 if (desc->bAlternateSetting == 0) {
5181 usb_disable_interface(udev, intf, true);
5182 usb_enable_interface(udev, intf, true);
5183 ret = 0;
5184 } else {
Sarah Sharp04a723e2010-01-06 10:16:51 -08005185 /* Let the bandwidth allocation function know that this
5186 * device has been reset, and it will have to use
5187 * alternate setting 0 as the current alternate setting.
Sarah Sharp3f0479e2009-12-03 09:44:36 -08005188 */
Sarah Sharp04a723e2010-01-06 10:16:51 -08005189 intf->resetting_device = 1;
Alan Stern4fe03872009-02-26 10:21:02 -05005190 ret = usb_set_interface(udev, desc->bInterfaceNumber,
5191 desc->bAlternateSetting);
Sarah Sharp04a723e2010-01-06 10:16:51 -08005192 intf->resetting_device = 0;
Alan Stern4fe03872009-02-26 10:21:02 -05005193 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005194 if (ret < 0) {
5195 dev_err(&udev->dev, "failed to restore interface %d "
5196 "altsetting %d (error=%d)\n",
5197 desc->bInterfaceNumber,
5198 desc->bAlternateSetting,
5199 ret);
5200 goto re_enumerate;
5201 }
5202 }
5203
5204done:
Sarah Sharpf74631e2012-06-25 12:08:08 -07005205 /* Now that the alt settings are re-installed, enable LTM and LPM. */
Alan Stern78d9a482008-06-23 16:00:40 -04005206 usb_unlocked_enable_lpm(udev);
Sarah Sharpf74631e2012-06-25 12:08:08 -07005207 usb_enable_ltm(udev);
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03005208 usb_release_bos_descriptor(udev);
5209 udev->bos = bos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005210 return 0;
Matthias Beyer469271f2013-10-10 23:41:27 +02005211
Linus Torvalds1da177e2005-04-16 15:20:36 -07005212re_enumerate:
Sarah Sharp6d1d0512012-07-03 22:49:04 -07005213 /* LPM state doesn't matter when we're about to destroy the device. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005214 hub_port_logical_disconnect(parent_hub, port1);
Xenia Ragiadakoue3376d62013-08-29 21:45:48 +03005215 usb_release_bos_descriptor(udev);
5216 udev->bos = bos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005217 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005218}
5219
5220/**
5221 * usb_reset_device - warn interface drivers and perform a USB port reset
5222 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
5223 *
Alan Stern79efa092006-06-01 13:33:42 -04005224 * Warns all drivers bound to registered interfaces (using their pre_reset
5225 * method), performs the port reset, and then lets the drivers know that
Ming Lei742120c2008-06-18 22:00:29 +08005226 * the reset is over (using their post_reset method).
Alan Stern79efa092006-06-01 13:33:42 -04005227 *
Yacine Belkadi626f0902013-08-02 20:10:04 +02005228 * Return: The same as for usb_reset_and_verify_device().
Alan Stern79efa092006-06-01 13:33:42 -04005229 *
Yacine Belkadi626f0902013-08-02 20:10:04 +02005230 * Note:
Alan Stern79efa092006-06-01 13:33:42 -04005231 * The caller must own the device lock. For example, it's safe to use
5232 * this from a driver probe() routine after downloading new firmware.
5233 * For calls that might not occur during probe(), drivers should lock
Ming Lei742120c2008-06-18 22:00:29 +08005234 * the device using usb_lock_device_for_reset().
Alan Stern79efa092006-06-01 13:33:42 -04005235 *
5236 * If an interface is currently being probed or disconnected, we assume
5237 * its driver knows how to handle resets. For all other interfaces,
5238 * if the driver doesn't have pre_reset and post_reset methods then
5239 * we attempt to unbind it and rebind afterward.
Alan Stern79efa092006-06-01 13:33:42 -04005240 */
Ming Lei742120c2008-06-18 22:00:29 +08005241int usb_reset_device(struct usb_device *udev)
Alan Stern79efa092006-06-01 13:33:42 -04005242{
5243 int ret;
Alan Stern852c4b42007-12-03 15:44:29 -05005244 int i;
Ming Lei4d769de2013-02-22 16:34:22 -08005245 unsigned int noio_flag;
Alan Stern79efa092006-06-01 13:33:42 -04005246 struct usb_host_config *config = udev->actconfig;
5247
5248 if (udev->state == USB_STATE_NOTATTACHED ||
5249 udev->state == USB_STATE_SUSPENDED) {
5250 dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5251 udev->state);
5252 return -EINVAL;
5253 }
5254
Ming Lei4d769de2013-02-22 16:34:22 -08005255 /*
5256 * Don't allocate memory with GFP_KERNEL in current
5257 * context to avoid possible deadlock if usb mass
5258 * storage interface or usbnet interface(iSCSI case)
5259 * is included in current configuration. The easist
5260 * approach is to do it for every device reset,
5261 * because the device 'memalloc_noio' flag may have
5262 * not been set before reseting the usb device.
5263 */
5264 noio_flag = memalloc_noio_save();
5265
Alan Stern645daaa2006-08-30 15:47:02 -04005266 /* Prevent autosuspend during the reset */
Alan Stern94fcda12006-11-20 11:38:46 -05005267 usb_autoresume_device(udev);
Alan Stern645daaa2006-08-30 15:47:02 -04005268
Alan Stern79efa092006-06-01 13:33:42 -04005269 if (config) {
Alan Stern79efa092006-06-01 13:33:42 -04005270 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
Alan Stern852c4b42007-12-03 15:44:29 -05005271 struct usb_interface *cintf = config->interface[i];
5272 struct usb_driver *drv;
Alan Stern78d9a482008-06-23 16:00:40 -04005273 int unbind = 0;
Alan Stern852c4b42007-12-03 15:44:29 -05005274
5275 if (cintf->dev.driver) {
Alan Stern79efa092006-06-01 13:33:42 -04005276 drv = to_usb_driver(cintf->dev.driver);
Alan Stern78d9a482008-06-23 16:00:40 -04005277 if (drv->pre_reset && drv->post_reset)
5278 unbind = (drv->pre_reset)(cintf);
5279 else if (cintf->condition ==
5280 USB_INTERFACE_BOUND)
5281 unbind = 1;
5282 if (unbind)
5283 usb_forced_unbind_intf(cintf);
Alan Stern79efa092006-06-01 13:33:42 -04005284 }
5285 }
5286 }
5287
Ming Lei742120c2008-06-18 22:00:29 +08005288 ret = usb_reset_and_verify_device(udev);
Alan Stern79efa092006-06-01 13:33:42 -04005289
5290 if (config) {
Alan Stern79efa092006-06-01 13:33:42 -04005291 for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
Alan Stern852c4b42007-12-03 15:44:29 -05005292 struct usb_interface *cintf = config->interface[i];
5293 struct usb_driver *drv;
Alan Stern78d9a482008-06-23 16:00:40 -04005294 int rebind = cintf->needs_binding;
Alan Stern852c4b42007-12-03 15:44:29 -05005295
Alan Stern78d9a482008-06-23 16:00:40 -04005296 if (!rebind && cintf->dev.driver) {
Alan Stern79efa092006-06-01 13:33:42 -04005297 drv = to_usb_driver(cintf->dev.driver);
5298 if (drv->post_reset)
Alan Stern78d9a482008-06-23 16:00:40 -04005299 rebind = (drv->post_reset)(cintf);
5300 else if (cintf->condition ==
5301 USB_INTERFACE_BOUND)
5302 rebind = 1;
Alan Stern79efa092006-06-01 13:33:42 -04005303 }
Alan Stern6c640942008-10-21 15:40:03 -04005304 if (ret == 0 && rebind)
Alan Stern78d9a482008-06-23 16:00:40 -04005305 usb_rebind_intf(cintf);
Alan Stern79efa092006-06-01 13:33:42 -04005306 }
5307 }
5308
Alan Stern94fcda12006-11-20 11:38:46 -05005309 usb_autosuspend_device(udev);
Ming Lei4d769de2013-02-22 16:34:22 -08005310 memalloc_noio_restore(noio_flag);
Alan Stern79efa092006-06-01 13:33:42 -04005311 return ret;
5312}
Ming Lei742120c2008-06-18 22:00:29 +08005313EXPORT_SYMBOL_GPL(usb_reset_device);
Inaky Perez-Gonzalezdc023dc2008-11-13 10:31:35 -08005314
5315
5316/**
5317 * usb_queue_reset_device - Reset a USB device from an atomic context
5318 * @iface: USB interface belonging to the device to reset
5319 *
5320 * This function can be used to reset a USB device from an atomic
5321 * context, where usb_reset_device() won't work (as it blocks).
5322 *
5323 * Doing a reset via this method is functionally equivalent to calling
5324 * usb_reset_device(), except for the fact that it is delayed to a
5325 * workqueue. This means that any drivers bound to other interfaces
5326 * might be unbound, as well as users from usbfs in user space.
5327 *
5328 * Corner cases:
5329 *
5330 * - Scheduling two resets at the same time from two different drivers
5331 * attached to two different interfaces of the same device is
5332 * possible; depending on how the driver attached to each interface
5333 * handles ->pre_reset(), the second reset might happen or not.
5334 *
5335 * - If a driver is unbound and it had a pending reset, the reset will
5336 * be cancelled.
5337 *
5338 * - This function can be called during .probe() or .disconnect()
5339 * times. On return from .disconnect(), any pending resets will be
5340 * cancelled.
5341 *
5342 * There is no no need to lock/unlock the @reset_ws as schedule_work()
5343 * does its own.
5344 *
5345 * NOTE: We don't do any reference count tracking because it is not
5346 * needed. The lifecycle of the work_struct is tied to the
5347 * usb_interface. Before destroying the interface we cancel the
5348 * work_struct, so the fact that work_struct is queued and or
5349 * running means the interface (and thus, the device) exist and
5350 * are referenced.
5351 */
5352void usb_queue_reset_device(struct usb_interface *iface)
5353{
5354 schedule_work(&iface->reset_ws);
5355}
5356EXPORT_SYMBOL_GPL(usb_queue_reset_device);
Lan Tianyuff823c792012-09-05 13:44:32 +08005357
5358/**
5359 * usb_hub_find_child - Get the pointer of child device
5360 * attached to the port which is specified by @port1.
5361 * @hdev: USB device belonging to the usb hub
5362 * @port1: port num to indicate which port the child device
5363 * is attached to.
5364 *
5365 * USB drivers call this function to get hub's child device
5366 * pointer.
5367 *
Yacine Belkadi626f0902013-08-02 20:10:04 +02005368 * Return: %NULL if input param is invalid and
Lan Tianyuff823c792012-09-05 13:44:32 +08005369 * child's usb_device pointer if non-NULL.
5370 */
5371struct usb_device *usb_hub_find_child(struct usb_device *hdev,
5372 int port1)
5373{
Lan Tianyuad493e52013-01-23 04:26:30 +08005374 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Lan Tianyuff823c792012-09-05 13:44:32 +08005375
5376 if (port1 < 1 || port1 > hdev->maxchild)
5377 return NULL;
5378 return hub->ports[port1 - 1]->child;
5379}
5380EXPORT_SYMBOL_GPL(usb_hub_find_child);
Lan Tianyud5575422012-09-05 13:44:33 +08005381
Lan Tianyu05f91682012-09-05 13:44:34 +08005382/**
5383 * usb_set_hub_port_connect_type - set hub port connect type.
5384 * @hdev: USB device belonging to the usb hub
5385 * @port1: port num of the port
5386 * @type: connect type of the port
5387 */
5388void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
5389 enum usb_port_connect_type type)
5390{
Lan Tianyuad493e52013-01-23 04:26:30 +08005391 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Lan Tianyu05f91682012-09-05 13:44:34 +08005392
Mathias Nyman413412612013-06-18 17:28:48 +03005393 if (hub)
5394 hub->ports[port1 - 1]->connect_type = type;
Lan Tianyu05f91682012-09-05 13:44:34 +08005395}
5396
5397/**
5398 * usb_get_hub_port_connect_type - Get the port's connect type
5399 * @hdev: USB device belonging to the usb hub
5400 * @port1: port num of the port
5401 *
Yacine Belkadi626f0902013-08-02 20:10:04 +02005402 * Return: The connect type of the port if successful. Or
5403 * USB_PORT_CONNECT_TYPE_UNKNOWN if input params are invalid.
Lan Tianyu05f91682012-09-05 13:44:34 +08005404 */
5405enum usb_port_connect_type
5406usb_get_hub_port_connect_type(struct usb_device *hdev, int port1)
5407{
Lan Tianyuad493e52013-01-23 04:26:30 +08005408 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Lan Tianyu05f91682012-09-05 13:44:34 +08005409
Mathias Nyman413412612013-06-18 17:28:48 +03005410 if (!hub)
5411 return USB_PORT_CONNECT_TYPE_UNKNOWN;
5412
Lan Tianyu05f91682012-09-05 13:44:34 +08005413 return hub->ports[port1 - 1]->connect_type;
5414}
5415
Lan Tianyud2123fd2013-01-21 22:18:00 +08005416void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
5417 struct usb_hub_descriptor *desc)
5418{
5419 enum usb_port_connect_type connect_type;
5420 int i;
5421
5422 if (!hub_is_superspeed(hdev)) {
5423 for (i = 1; i <= hdev->maxchild; i++) {
5424 connect_type = usb_get_hub_port_connect_type(hdev, i);
5425
5426 if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
5427 u8 mask = 1 << (i%8);
5428
5429 if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
5430 dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
5431 i);
5432 desc->u.hs.DeviceRemovable[i/8] |= mask;
5433 }
5434 }
5435 }
5436 } else {
5437 u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);
5438
5439 for (i = 1; i <= hdev->maxchild; i++) {
5440 connect_type = usb_get_hub_port_connect_type(hdev, i);
5441
5442 if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
5443 u16 mask = 1 << i;
5444
5445 if (!(port_removable & mask)) {
5446 dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
5447 i);
5448 port_removable |= mask;
5449 }
5450 }
5451 }
5452
5453 desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
5454 }
5455}
5456
Lan Tianyud5575422012-09-05 13:44:33 +08005457#ifdef CONFIG_ACPI
5458/**
5459 * usb_get_hub_port_acpi_handle - Get the usb port's acpi handle
5460 * @hdev: USB device belonging to the usb hub
5461 * @port1: port num of the port
5462 *
Yacine Belkadi626f0902013-08-02 20:10:04 +02005463 * Return: Port's acpi handle if successful, %NULL if params are
5464 * invalid.
Lan Tianyud5575422012-09-05 13:44:33 +08005465 */
5466acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
5467 int port1)
5468{
Lan Tianyuad493e52013-01-23 04:26:30 +08005469 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
Lan Tianyud5575422012-09-05 13:44:33 +08005470
Mathias Nyman413412612013-06-18 17:28:48 +03005471 if (!hub)
5472 return NULL;
5473
Lan Tianyud5575422012-09-05 13:44:33 +08005474 return DEVICE_ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
5475}
5476#endif