1aa1f3bb5SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * USB hub driver. 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * (C) Copyright 1999 Linus Torvalds 61da177e4SLinus Torvalds * (C) Copyright 1999 Johannes Erdfelt 71da177e4SLinus Torvalds * (C) Copyright 1999 Gregory P. Smith 81da177e4SLinus Torvalds * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au) 91da177e4SLinus Torvalds * 10b65fba3dSGreg Kroah-Hartman * Released under the GPLv2 only. 111da177e4SLinus Torvalds */ 121da177e4SLinus Torvalds 131da177e4SLinus Torvalds #include <linux/kernel.h> 141da177e4SLinus Torvalds #include <linux/errno.h> 151da177e4SLinus Torvalds #include <linux/module.h> 161da177e4SLinus Torvalds #include <linux/moduleparam.h> 171da177e4SLinus Torvalds #include <linux/completion.h> 185b3cc15aSIngo Molnar #include <linux/sched/mm.h> 191da177e4SLinus Torvalds #include <linux/list.h> 201da177e4SLinus Torvalds #include <linux/slab.h> 2195d23dc2SAndrey Konovalov #include <linux/kcov.h> 221da177e4SLinus Torvalds #include <linux/ioctl.h> 231da177e4SLinus Torvalds #include <linux/usb.h> 241da177e4SLinus Torvalds #include <linux/usbdevice_fs.h> 2527729aadSEric Lescouet #include <linux/usb/hcd.h> 263a6bf4a0SMatthias Kaehlcke #include <linux/usb/onboard_hub.h> 27925aa46bSRichard Zhao #include <linux/usb/otg.h> 2893362a87SPhil Dibowitz #include <linux/usb/quirks.h> 2932a69589SPetr Mladek #include <linux/workqueue.h> 304186ecf8SArjan van de Ven #include <linux/mutex.h> 31b04b3156STheodore Ts'o #include <linux/random.h> 32ad493e5eSLan Tianyu #include <linux/pm_qos.h> 33201af55dSJon Flatley #include <linux/kobject.h> 341da177e4SLinus Torvalds 350299809bSThinh Nguyen #include <linux/bitfield.h> 367c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 371da177e4SLinus Torvalds #include <asm/byteorder.h> 381da177e4SLinus Torvalds 396e30d7cbSLan Tianyu #include "hub.h" 40f8f02d5cSGreg Kroah-Hartman #include "otg_productlist.h" 411da177e4SLinus Torvalds 42e6f30deaSMing Lei #define USB_VENDOR_GENESYS_LOGIC 0x05e3 431208f9e1SHardik Gajjar #define USB_VENDOR_SMSC 0x0424 4476e1ef1dSEugeniu Rosca #define USB_PRODUCT_USB5534B 0x5534 45a7d8d1c7SAndrew Lunn #define USB_VENDOR_CYPRESS 0x04b4 46a7d8d1c7SAndrew Lunn #define USB_PRODUCT_CY7C65632 0x6570 477171b0e2SFlavio Suligoi #define USB_VENDOR_TEXAS_INSTRUMENTS 0x0451 487171b0e2SFlavio Suligoi #define USB_PRODUCT_TUSB8041_USB3 0x8140 497171b0e2SFlavio Suligoi #define USB_PRODUCT_TUSB8041_USB2 0x8142 50915d900fSHardik Gajjar #define USB_VENDOR_MICROCHIP 0x0424 51915d900fSHardik Gajjar #define USB_PRODUCT_USB4913 0x4913 52915d900fSHardik Gajjar #define USB_PRODUCT_USB4914 0x4914 53915d900fSHardik Gajjar #define USB_PRODUCT_USB4915 0x4915 54cd72da00SHardik Gajjar #define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND BIT(0) 55cd72da00SHardik Gajjar #define HUB_QUIRK_DISABLE_AUTOSUSPEND BIT(1) 56915d900fSHardik Gajjar #define HUB_QUIRK_REDUCE_FRAME_INTR_BINTERVAL BIT(2) 57e6f30deaSMing Lei 58886ee36eSFelipe Balbi #define USB_TP_TRANSMISSION_DELAY 40 /* ns */ 59886ee36eSFelipe Balbi #define USB_TP_TRANSMISSION_DELAY_MAX 65535 /* ns */ 601bf2761cSMathias Nyman #define USB_PING_RESPONSE_TIME 400 /* ns */ 61915d900fSHardik Gajjar #define USB_REDUCE_FRAME_INTR_BINTERVAL 9 62886ee36eSFelipe Balbi 63fa286188SGreg Kroah-Hartman /* Protect struct usb_device->state and ->children members 649ad3d6ccSAlan Stern * Note: Both are also protected by ->dev.sem, except that ->state can 651da177e4SLinus Torvalds * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */ 661da177e4SLinus Torvalds static DEFINE_SPINLOCK(device_state_lock); 671da177e4SLinus Torvalds 6832a69589SPetr Mladek /* workqueue to process hub events */ 6932a69589SPetr Mladek static struct workqueue_struct *hub_wq; 7032a69589SPetr Mladek static void hub_event(struct work_struct *work); 711da177e4SLinus Torvalds 72d8521afeSDan Williams /* synchronize hub-port add/remove and peering operations */ 73d8521afeSDan Williams DEFINE_MUTEX(usb_port_peer_mutex); 74d8521afeSDan Williams 751da177e4SLinus Torvalds /* cycle leds on hubs that aren't blinking for attention */ 76a44007a4SSaurabh Sengar static bool blinkenlights; 771da177e4SLinus Torvalds module_param(blinkenlights, bool, S_IRUGO); 781da177e4SLinus Torvalds MODULE_PARM_DESC(blinkenlights, "true to cycle leds on hubs"); 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds /* 81fd7c519dSJaroslav Kysela * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about 82fd7c519dSJaroslav Kysela * 10 seconds to send reply for the initial 64-byte descriptor request. 83fd7c519dSJaroslav Kysela */ 84fd7c519dSJaroslav Kysela /* define initial 64-byte descriptor request timeout in milliseconds */ 85fd7c519dSJaroslav Kysela static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT; 86fd7c519dSJaroslav Kysela module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR); 87b9cef6c3SWu Fengguang MODULE_PARM_DESC(initial_descriptor_timeout, 88b9cef6c3SWu Fengguang "initial 64-byte descriptor request timeout in milliseconds " 89b9cef6c3SWu Fengguang "(default 5000 - 5.0 seconds)"); 90fd7c519dSJaroslav Kysela 91fd7c519dSJaroslav Kysela /* 921da177e4SLinus Torvalds * As of 2.6.10 we introduce a new USB device initialization scheme which 931da177e4SLinus Torvalds * closely resembles the way Windows works. Hopefully it will be compatible 941da177e4SLinus Torvalds * with a wider range of devices than the old scheme. However some previously 951da177e4SLinus Torvalds * working devices may start giving rise to "device not accepting address" 961da177e4SLinus Torvalds * errors; if that happens the user can try the old scheme by adjusting the 971da177e4SLinus Torvalds * following module parameters. 981da177e4SLinus Torvalds * 991da177e4SLinus Torvalds * For maximum flexibility there are two boolean parameters to control the 1001da177e4SLinus Torvalds * hub driver's behavior. On the first initialization attempt, if the 1011da177e4SLinus Torvalds * "old_scheme_first" parameter is set then the old scheme will be used, 1021da177e4SLinus Torvalds * otherwise the new scheme is used. If that fails and "use_both_schemes" 1031da177e4SLinus Torvalds * is set, then the driver will make another attempt, using the other scheme. 1041da177e4SLinus Torvalds */ 105a44007a4SSaurabh Sengar static bool old_scheme_first; 1061da177e4SLinus Torvalds module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR); 1071da177e4SLinus Torvalds MODULE_PARM_DESC(old_scheme_first, 1081da177e4SLinus Torvalds "start with the old device initialization scheme"); 1091da177e4SLinus Torvalds 110b9cf2cb5SJason Yan static bool use_both_schemes = true; 1111da177e4SLinus Torvalds module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR); 1121da177e4SLinus Torvalds MODULE_PARM_DESC(use_both_schemes, 1131da177e4SLinus Torvalds "try the other device initialization scheme if the " 1141da177e4SLinus Torvalds "first one fails"); 1151da177e4SLinus Torvalds 11632fe0198SAlan Stern /* Mutual exclusion for EHCI CF initialization. This interferes with 11732fe0198SAlan Stern * port reset on some companion controllers. 11832fe0198SAlan Stern */ 11932fe0198SAlan Stern DECLARE_RWSEM(ehci_cf_port_reset_rwsem); 12032fe0198SAlan Stern EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem); 12132fe0198SAlan Stern 122ad493e5eSLan Tianyu #define HUB_DEBOUNCE_TIMEOUT 2000 123948fea37SAlan Stern #define HUB_DEBOUNCE_STEP 25 124948fea37SAlan Stern #define HUB_DEBOUNCE_STABLE 100 125948fea37SAlan Stern 12632a69589SPetr Mladek static void hub_release(struct kref *kref); 127742120c6SMing Lei static int usb_reset_and_verify_device(struct usb_device *udev); 1283bc02bceSGeert Uytterhoeven static int hub_port_disable(struct usb_hub *hub, int port1, int set_state); 1294fdc1790SJan-Marek Glogowski static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1, 1304fdc1790SJan-Marek Glogowski u16 portstatus); 131742120c6SMing Lei 132131dec34SSarah Sharp static inline char *portspeed(struct usb_hub *hub, int portstatus) 1331da177e4SLinus Torvalds { 134d64aab0cSOliver Neukum if (hub_is_superspeedplus(hub->hdev)) 135d64aab0cSOliver Neukum return "10.0 Gb/s"; 136131dec34SSarah Sharp if (hub_is_superspeed(hub->hdev)) 137131dec34SSarah Sharp return "5.0 Gb/s"; 138288ead45SAlan Stern if (portstatus & USB_PORT_STAT_HIGH_SPEED) 1391da177e4SLinus Torvalds return "480 Mb/s"; 140288ead45SAlan Stern else if (portstatus & USB_PORT_STAT_LOW_SPEED) 1411da177e4SLinus Torvalds return "1.5 Mb/s"; 1421da177e4SLinus Torvalds else 1431da177e4SLinus Torvalds return "12 Mb/s"; 1441da177e4SLinus Torvalds } 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds /* Note that hdev or one of its children must be locked! */ 147ad493e5eSLan Tianyu struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev) 1481da177e4SLinus Torvalds { 149ff823c79SLan Tianyu if (!hdev || !hdev->actconfig || !hdev->maxchild) 15025118084SAlan Stern return NULL; 1511da177e4SLinus Torvalds return usb_get_intfdata(hdev->actconfig->interface[0]); 1521da177e4SLinus Torvalds } 1531da177e4SLinus Torvalds 1542d2a3167SLu Baolu int usb_device_supports_lpm(struct usb_device *udev) 155d9b2099cSSarah Sharp { 156ad87e032SAlan Stern /* Some devices have trouble with LPM */ 157ad87e032SAlan Stern if (udev->quirks & USB_QUIRK_NO_LPM) 158ad87e032SAlan Stern return 0; 159ad87e032SAlan Stern 160f74a7afcSRicardo Cañuelo /* Skip if the device BOS descriptor couldn't be read */ 161f74a7afcSRicardo Cañuelo if (!udev->bos) 162f74a7afcSRicardo Cañuelo return 0; 163f74a7afcSRicardo Cañuelo 164d9b2099cSSarah Sharp /* USB 2.1 (and greater) devices indicate LPM support through 165d9b2099cSSarah Sharp * their USB 2.0 Extended Capabilities BOS descriptor. 166d9b2099cSSarah Sharp */ 167a8425292SRupesh Tatiya if (udev->speed == USB_SPEED_HIGH || udev->speed == USB_SPEED_FULL) { 168d9b2099cSSarah Sharp if (udev->bos->ext_cap && 169d9b2099cSSarah Sharp (USB_LPM_SUPPORT & 170d9b2099cSSarah Sharp le32_to_cpu(udev->bos->ext_cap->bmAttributes))) 171d9b2099cSSarah Sharp return 1; 172d9b2099cSSarah Sharp return 0; 173d9b2099cSSarah Sharp } 17451e0a012SSarah Sharp 17525cd2882SSarah Sharp /* 17625cd2882SSarah Sharp * According to the USB 3.0 spec, all USB 3.0 devices must support LPM. 17725cd2882SSarah Sharp * However, there are some that don't, and they set the U1/U2 exit 17825cd2882SSarah Sharp * latencies to zero. 17951e0a012SSarah Sharp */ 18051e0a012SSarah Sharp if (!udev->bos->ss_cap) { 18125cd2882SSarah Sharp dev_info(&udev->dev, "No LPM exit latency info found, disabling LPM.\n"); 182d9b2099cSSarah Sharp return 0; 183d9b2099cSSarah Sharp } 18451e0a012SSarah Sharp 18525cd2882SSarah Sharp if (udev->bos->ss_cap->bU1devExitLat == 0 && 18625cd2882SSarah Sharp udev->bos->ss_cap->bU2DevExitLat == 0) { 18725cd2882SSarah Sharp if (udev->parent) 18825cd2882SSarah Sharp dev_info(&udev->dev, "LPM exit latency is zeroed, disabling LPM.\n"); 18925cd2882SSarah Sharp else 19025cd2882SSarah Sharp dev_info(&udev->dev, "We don't know the algorithms for LPM for this host, disabling LPM.\n"); 19125cd2882SSarah Sharp return 0; 19225cd2882SSarah Sharp } 19325cd2882SSarah Sharp 19425cd2882SSarah Sharp if (!udev->parent || udev->parent->lpm_capable) 19525cd2882SSarah Sharp return 1; 19651e0a012SSarah Sharp return 0; 19751e0a012SSarah Sharp } 19851e0a012SSarah Sharp 19951e0a012SSarah Sharp /* 2001bf2761cSMathias Nyman * Set the Maximum Exit Latency (MEL) for the host to wakup up the path from 2011bf2761cSMathias Nyman * U1/U2, send a PING to the device and receive a PING_RESPONSE. 2021bf2761cSMathias Nyman * See USB 3.1 section C.1.5.2 20351e0a012SSarah Sharp */ 20451e0a012SSarah Sharp static void usb_set_lpm_mel(struct usb_device *udev, 20551e0a012SSarah Sharp struct usb3_lpm_parameters *udev_lpm_params, 20651e0a012SSarah Sharp unsigned int udev_exit_latency, 20751e0a012SSarah Sharp struct usb_hub *hub, 20851e0a012SSarah Sharp struct usb3_lpm_parameters *hub_lpm_params, 20951e0a012SSarah Sharp unsigned int hub_exit_latency) 21051e0a012SSarah Sharp { 21151e0a012SSarah Sharp unsigned int total_mel; 21251e0a012SSarah Sharp 21351e0a012SSarah Sharp /* 2141bf2761cSMathias Nyman * tMEL1. time to transition path from host to device into U0. 2151bf2761cSMathias Nyman * MEL for parent already contains the delay up to parent, so only add 2161bf2761cSMathias Nyman * the exit latency for the last link (pick the slower exit latency), 2171bf2761cSMathias Nyman * and the hub header decode latency. See USB 3.1 section C 2.2.1 2181bf2761cSMathias Nyman * Store MEL in nanoseconds 21951e0a012SSarah Sharp */ 22051e0a012SSarah Sharp total_mel = hub_lpm_params->mel + 2211bf2761cSMathias Nyman max(udev_exit_latency, hub_exit_latency) * 1000 + 2221bf2761cSMathias Nyman hub->descriptor->u.ss.bHubHdrDecLat * 100; 22351e0a012SSarah Sharp 22451e0a012SSarah Sharp /* 2251bf2761cSMathias Nyman * tMEL2. Time to submit PING packet. Sum of tTPTransmissionDelay for 2261bf2761cSMathias Nyman * each link + wHubDelay for each hub. Add only for last link. 2271bf2761cSMathias Nyman * tMEL4, the time for PING_RESPONSE to traverse upstream is similar. 2281bf2761cSMathias Nyman * Multiply by 2 to include it as well. 22951e0a012SSarah Sharp */ 2301bf2761cSMathias Nyman total_mel += (__le16_to_cpu(hub->descriptor->u.ss.wHubDelay) + 2311bf2761cSMathias Nyman USB_TP_TRANSMISSION_DELAY) * 2; 2321bf2761cSMathias Nyman 2331bf2761cSMathias Nyman /* 2341bf2761cSMathias Nyman * tMEL3, tPingResponse. Time taken by device to generate PING_RESPONSE 2351bf2761cSMathias Nyman * after receiving PING. Also add 2100ns as stated in USB 3.1 C 1.5.2.4 2361bf2761cSMathias Nyman * to cover the delay if the PING_RESPONSE is queued behind a Max Packet 2371bf2761cSMathias Nyman * Size DP. 2381bf2761cSMathias Nyman * Note these delays should be added only once for the entire path, so 2391bf2761cSMathias Nyman * add them to the MEL of the device connected to the roothub. 2401bf2761cSMathias Nyman */ 2411bf2761cSMathias Nyman if (!hub->hdev->parent) 2421bf2761cSMathias Nyman total_mel += USB_PING_RESPONSE_TIME + 2100; 24351e0a012SSarah Sharp 24451e0a012SSarah Sharp udev_lpm_params->mel = total_mel; 24551e0a012SSarah Sharp } 24651e0a012SSarah Sharp 24751e0a012SSarah Sharp /* 24851e0a012SSarah Sharp * Set the maximum Device to Host Exit Latency (PEL) for the device to initiate 24951e0a012SSarah Sharp * a transition from either U1 or U2. 25051e0a012SSarah Sharp */ 25151e0a012SSarah Sharp static void usb_set_lpm_pel(struct usb_device *udev, 25251e0a012SSarah Sharp struct usb3_lpm_parameters *udev_lpm_params, 25351e0a012SSarah Sharp unsigned int udev_exit_latency, 25451e0a012SSarah Sharp struct usb_hub *hub, 25551e0a012SSarah Sharp struct usb3_lpm_parameters *hub_lpm_params, 25651e0a012SSarah Sharp unsigned int hub_exit_latency, 25751e0a012SSarah Sharp unsigned int port_to_port_exit_latency) 25851e0a012SSarah Sharp { 25951e0a012SSarah Sharp unsigned int first_link_pel; 26051e0a012SSarah Sharp unsigned int hub_pel; 26151e0a012SSarah Sharp 26251e0a012SSarah Sharp /* 26351e0a012SSarah Sharp * First, the device sends an LFPS to transition the link between the 26451e0a012SSarah Sharp * device and the parent hub into U0. The exit latency is the bigger of 26551e0a012SSarah Sharp * the device exit latency or the hub exit latency. 26651e0a012SSarah Sharp */ 26751e0a012SSarah Sharp if (udev_exit_latency > hub_exit_latency) 26851e0a012SSarah Sharp first_link_pel = udev_exit_latency * 1000; 26951e0a012SSarah Sharp else 27051e0a012SSarah Sharp first_link_pel = hub_exit_latency * 1000; 27151e0a012SSarah Sharp 27251e0a012SSarah Sharp /* 27351e0a012SSarah Sharp * When the hub starts to receive the LFPS, there is a slight delay for 27451e0a012SSarah Sharp * it to figure out that one of the ports is sending an LFPS. Then it 27551e0a012SSarah Sharp * will forward the LFPS to its upstream link. The exit latency is the 27651e0a012SSarah Sharp * delay, plus the PEL that we calculated for this hub. 27751e0a012SSarah Sharp */ 27851e0a012SSarah Sharp hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel; 27951e0a012SSarah Sharp 28051e0a012SSarah Sharp /* 28151e0a012SSarah Sharp * According to figure C-7 in the USB 3.0 spec, the PEL for this device 28251e0a012SSarah Sharp * is the greater of the two exit latencies. 28351e0a012SSarah Sharp */ 28451e0a012SSarah Sharp if (first_link_pel > hub_pel) 28551e0a012SSarah Sharp udev_lpm_params->pel = first_link_pel; 28651e0a012SSarah Sharp else 28751e0a012SSarah Sharp udev_lpm_params->pel = hub_pel; 28851e0a012SSarah Sharp } 28951e0a012SSarah Sharp 29051e0a012SSarah Sharp /* 29151e0a012SSarah Sharp * Set the System Exit Latency (SEL) to indicate the total worst-case time from 29251e0a012SSarah Sharp * when a device initiates a transition to U0, until when it will receive the 29351e0a012SSarah Sharp * first packet from the host controller. 29451e0a012SSarah Sharp * 29551e0a012SSarah Sharp * Section C.1.5.1 describes the four components to this: 29651e0a012SSarah Sharp * - t1: device PEL 29751e0a012SSarah Sharp * - t2: time for the ERDY to make it from the device to the host. 29851e0a012SSarah Sharp * - t3: a host-specific delay to process the ERDY. 29951e0a012SSarah Sharp * - t4: time for the packet to make it from the host to the device. 30051e0a012SSarah Sharp * 30151e0a012SSarah Sharp * t3 is specific to both the xHCI host and the platform the host is integrated 30251e0a012SSarah Sharp * into. The Intel HW folks have said it's negligible, FIXME if a different 30351e0a012SSarah Sharp * vendor says otherwise. 30451e0a012SSarah Sharp */ 30551e0a012SSarah Sharp static void usb_set_lpm_sel(struct usb_device *udev, 30651e0a012SSarah Sharp struct usb3_lpm_parameters *udev_lpm_params) 30751e0a012SSarah Sharp { 30851e0a012SSarah Sharp struct usb_device *parent; 30951e0a012SSarah Sharp unsigned int num_hubs; 31051e0a012SSarah Sharp unsigned int total_sel; 31151e0a012SSarah Sharp 31251e0a012SSarah Sharp /* t1 = device PEL */ 31351e0a012SSarah Sharp total_sel = udev_lpm_params->pel; 31451e0a012SSarah Sharp /* How many external hubs are in between the device & the root port. */ 31551e0a012SSarah Sharp for (parent = udev->parent, num_hubs = 0; parent->parent; 31651e0a012SSarah Sharp parent = parent->parent) 31751e0a012SSarah Sharp num_hubs++; 31851e0a012SSarah Sharp /* t2 = 2.1us + 250ns * (num_hubs - 1) */ 31951e0a012SSarah Sharp if (num_hubs > 0) 32051e0a012SSarah Sharp total_sel += 2100 + 250 * (num_hubs - 1); 32151e0a012SSarah Sharp 32251e0a012SSarah Sharp /* t4 = 250ns * num_hubs */ 32351e0a012SSarah Sharp total_sel += 250 * num_hubs; 32451e0a012SSarah Sharp 32551e0a012SSarah Sharp udev_lpm_params->sel = total_sel; 32651e0a012SSarah Sharp } 32751e0a012SSarah Sharp 32851e0a012SSarah Sharp static void usb_set_lpm_parameters(struct usb_device *udev) 32951e0a012SSarah Sharp { 33051e0a012SSarah Sharp struct usb_hub *hub; 33151e0a012SSarah Sharp unsigned int port_to_port_delay; 33251e0a012SSarah Sharp unsigned int udev_u1_del; 33351e0a012SSarah Sharp unsigned int udev_u2_del; 33451e0a012SSarah Sharp unsigned int hub_u1_del; 33551e0a012SSarah Sharp unsigned int hub_u2_del; 33651e0a012SSarah Sharp 3378a1b2725SMathias Nyman if (!udev->lpm_capable || udev->speed < USB_SPEED_SUPER) 33851e0a012SSarah Sharp return; 33951e0a012SSarah Sharp 340f74a7afcSRicardo Cañuelo /* Skip if the device BOS descriptor couldn't be read */ 341f74a7afcSRicardo Cañuelo if (!udev->bos) 342f74a7afcSRicardo Cañuelo return; 343f74a7afcSRicardo Cañuelo 344ad493e5eSLan Tianyu hub = usb_hub_to_struct_hub(udev->parent); 34551e0a012SSarah Sharp /* It doesn't take time to transition the roothub into U0, since it 34651e0a012SSarah Sharp * doesn't have an upstream link. 34751e0a012SSarah Sharp */ 34851e0a012SSarah Sharp if (!hub) 34951e0a012SSarah Sharp return; 35051e0a012SSarah Sharp 35151e0a012SSarah Sharp udev_u1_del = udev->bos->ss_cap->bU1devExitLat; 3524d967995SXenia Ragiadakou udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat); 35351e0a012SSarah Sharp hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat; 3544d967995SXenia Ragiadakou hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat); 35551e0a012SSarah Sharp 35651e0a012SSarah Sharp usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del, 35751e0a012SSarah Sharp hub, &udev->parent->u1_params, hub_u1_del); 35851e0a012SSarah Sharp 35951e0a012SSarah Sharp usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del, 36051e0a012SSarah Sharp hub, &udev->parent->u2_params, hub_u2_del); 36151e0a012SSarah Sharp 36251e0a012SSarah Sharp /* 36351e0a012SSarah Sharp * Appendix C, section C.2.2.2, says that there is a slight delay from 36451e0a012SSarah Sharp * when the parent hub notices the downstream port is trying to 36551e0a012SSarah Sharp * transition to U0 to when the hub initiates a U0 transition on its 36651e0a012SSarah Sharp * upstream port. The section says the delays are tPort2PortU1EL and 36751e0a012SSarah Sharp * tPort2PortU2EL, but it doesn't define what they are. 36851e0a012SSarah Sharp * 36951e0a012SSarah Sharp * The hub chapter, sections 10.4.2.4 and 10.4.2.5 seem to be talking 37051e0a012SSarah Sharp * about the same delays. Use the maximum delay calculations from those 37151e0a012SSarah Sharp * sections. For U1, it's tHubPort2PortExitLat, which is 1us max. For 37251e0a012SSarah Sharp * U2, it's tHubPort2PortExitLat + U2DevExitLat - U1DevExitLat. I 37351e0a012SSarah Sharp * assume the device exit latencies they are talking about are the hub 37451e0a012SSarah Sharp * exit latencies. 37551e0a012SSarah Sharp * 37651e0a012SSarah Sharp * What do we do if the U2 exit latency is less than the U1 exit 37751e0a012SSarah Sharp * latency? It's possible, although not likely... 37851e0a012SSarah Sharp */ 37951e0a012SSarah Sharp port_to_port_delay = 1; 38051e0a012SSarah Sharp 38151e0a012SSarah Sharp usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del, 38251e0a012SSarah Sharp hub, &udev->parent->u1_params, hub_u1_del, 38351e0a012SSarah Sharp port_to_port_delay); 38451e0a012SSarah Sharp 38551e0a012SSarah Sharp if (hub_u2_del > hub_u1_del) 38651e0a012SSarah Sharp port_to_port_delay = 1 + hub_u2_del - hub_u1_del; 38751e0a012SSarah Sharp else 38851e0a012SSarah Sharp port_to_port_delay = 1 + hub_u1_del; 38951e0a012SSarah Sharp 39051e0a012SSarah Sharp usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del, 39151e0a012SSarah Sharp hub, &udev->parent->u2_params, hub_u2_del, 39251e0a012SSarah Sharp port_to_port_delay); 39351e0a012SSarah Sharp 39451e0a012SSarah Sharp /* Now that we've got PEL, calculate SEL. */ 39551e0a012SSarah Sharp usb_set_lpm_sel(udev, &udev->u1_params); 39651e0a012SSarah Sharp usb_set_lpm_sel(udev, &udev->u2_params); 39751e0a012SSarah Sharp } 398d9b2099cSSarah Sharp 3991da177e4SLinus Torvalds /* USB 2.0 spec Section 11.24.4.5 */ 400bec444cdSJohan Hovold static int get_hub_descriptor(struct usb_device *hdev, 401bec444cdSJohan Hovold struct usb_hub_descriptor *desc) 4021da177e4SLinus Torvalds { 403dbe79bbeSJohn Youn int i, ret, size; 404dbe79bbeSJohn Youn unsigned dtype; 405dbe79bbeSJohn Youn 406dbe79bbeSJohn Youn if (hub_is_superspeed(hdev)) { 407dbe79bbeSJohn Youn dtype = USB_DT_SS_HUB; 408dbe79bbeSJohn Youn size = USB_DT_SS_HUB_SIZE; 409dbe79bbeSJohn Youn } else { 410dbe79bbeSJohn Youn dtype = USB_DT_HUB; 411dbe79bbeSJohn Youn size = sizeof(struct usb_hub_descriptor); 412dbe79bbeSJohn Youn } 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds for (i = 0; i < 3; i++) { 4151da177e4SLinus Torvalds ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 4161da177e4SLinus Torvalds USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 417bec444cdSJohan Hovold dtype << 8, 0, desc, size, 4181da177e4SLinus Torvalds USB_CTRL_GET_TIMEOUT); 4192c25a2c8SJohan Hovold if (hub_is_superspeed(hdev)) { 4202c25a2c8SJohan Hovold if (ret == size) 4211da177e4SLinus Torvalds return ret; 422bec444cdSJohan Hovold } else if (ret >= USB_DT_HUB_NONVAR_SIZE + 2) { 423bec444cdSJohan Hovold /* Make sure we have the DeviceRemovable field. */ 424bec444cdSJohan Hovold size = USB_DT_HUB_NONVAR_SIZE + desc->bNbrPorts / 8 + 1; 425bec444cdSJohan Hovold if (ret < size) 426bec444cdSJohan Hovold return -EMSGSIZE; 4272c25a2c8SJohan Hovold return ret; 4282c25a2c8SJohan Hovold } 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds return -EINVAL; 4311da177e4SLinus Torvalds } 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds /* 4341da177e4SLinus Torvalds * USB 2.0 spec Section 11.24.2.1 4351da177e4SLinus Torvalds */ 4361da177e4SLinus Torvalds static int clear_hub_feature(struct usb_device *hdev, int feature) 4371da177e4SLinus Torvalds { 4381afe33a7SOliver Neukum return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 4391afe33a7SOliver Neukum USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000); 4401da177e4SLinus Torvalds } 4411da177e4SLinus Torvalds 4421da177e4SLinus Torvalds /* 4431da177e4SLinus Torvalds * USB 2.0 spec Section 11.24.2.2 4441da177e4SLinus Torvalds */ 445ad493e5eSLan Tianyu int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature) 4461da177e4SLinus Torvalds { 4471afe33a7SOliver Neukum return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 4481afe33a7SOliver Neukum USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1, 4491afe33a7SOliver Neukum NULL, 0, 1000); 4501da177e4SLinus Torvalds } 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds /* 4531da177e4SLinus Torvalds * USB 2.0 spec Section 11.24.2.13 4541da177e4SLinus Torvalds */ 4551da177e4SLinus Torvalds static int set_port_feature(struct usb_device *hdev, int port1, int feature) 4561da177e4SLinus Torvalds { 4571afe33a7SOliver Neukum return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 4581afe33a7SOliver Neukum USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1, 4591afe33a7SOliver Neukum NULL, 0, 1000); 4601da177e4SLinus Torvalds } 4611da177e4SLinus Torvalds 462d99f6b41SDan Williams static char *to_led_name(int selector) 463d99f6b41SDan Williams { 464d99f6b41SDan Williams switch (selector) { 465d99f6b41SDan Williams case HUB_LED_AMBER: 466d99f6b41SDan Williams return "amber"; 467d99f6b41SDan Williams case HUB_LED_GREEN: 468d99f6b41SDan Williams return "green"; 469d99f6b41SDan Williams case HUB_LED_OFF: 470d99f6b41SDan Williams return "off"; 471d99f6b41SDan Williams case HUB_LED_AUTO: 472d99f6b41SDan Williams return "auto"; 473d99f6b41SDan Williams default: 474d99f6b41SDan Williams return "??"; 475d99f6b41SDan Williams } 476d99f6b41SDan Williams } 477d99f6b41SDan Williams 4781da177e4SLinus Torvalds /* 4791da177e4SLinus Torvalds * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7 4801da177e4SLinus Torvalds * for info about using port indicators 4811da177e4SLinus Torvalds */ 482d99f6b41SDan Williams static void set_port_led(struct usb_hub *hub, int port1, int selector) 4831da177e4SLinus Torvalds { 484d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 485d99f6b41SDan Williams int status; 486d99f6b41SDan Williams 487d99f6b41SDan Williams status = set_port_feature(hub->hdev, (selector << 8) | port1, 4881da177e4SLinus Torvalds USB_PORT_FEAT_INDICATOR); 489d99f6b41SDan Williams dev_dbg(&port_dev->dev, "indicator %s status %d\n", 490d99f6b41SDan Williams to_led_name(selector), status); 4911da177e4SLinus Torvalds } 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds #define LED_CYCLE_PERIOD ((2*HZ)/3) 4941da177e4SLinus Torvalds 495c4028958SDavid Howells static void led_work(struct work_struct *work) 4961da177e4SLinus Torvalds { 497c4028958SDavid Howells struct usb_hub *hub = 498c4028958SDavid Howells container_of(work, struct usb_hub, leds.work); 4991da177e4SLinus Torvalds struct usb_device *hdev = hub->hdev; 5001da177e4SLinus Torvalds unsigned i; 5011da177e4SLinus Torvalds unsigned changed = 0; 5021da177e4SLinus Torvalds int cursor = -1; 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing) 5051da177e4SLinus Torvalds return; 5061da177e4SLinus Torvalds 5073bbc47d8SKrzysztof Mazur for (i = 0; i < hdev->maxchild; i++) { 5081da177e4SLinus Torvalds unsigned selector, mode; 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds /* 30%-50% duty cycle */ 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds switch (hub->indicator[i]) { 5131da177e4SLinus Torvalds /* cycle marker */ 5141da177e4SLinus Torvalds case INDICATOR_CYCLE: 5151da177e4SLinus Torvalds cursor = i; 5161da177e4SLinus Torvalds selector = HUB_LED_AUTO; 5171da177e4SLinus Torvalds mode = INDICATOR_AUTO; 5181da177e4SLinus Torvalds break; 5191da177e4SLinus Torvalds /* blinking green = sw attention */ 5201da177e4SLinus Torvalds case INDICATOR_GREEN_BLINK: 5211da177e4SLinus Torvalds selector = HUB_LED_GREEN; 5221da177e4SLinus Torvalds mode = INDICATOR_GREEN_BLINK_OFF; 5231da177e4SLinus Torvalds break; 5241da177e4SLinus Torvalds case INDICATOR_GREEN_BLINK_OFF: 5251da177e4SLinus Torvalds selector = HUB_LED_OFF; 5261da177e4SLinus Torvalds mode = INDICATOR_GREEN_BLINK; 5271da177e4SLinus Torvalds break; 5281da177e4SLinus Torvalds /* blinking amber = hw attention */ 5291da177e4SLinus Torvalds case INDICATOR_AMBER_BLINK: 5301da177e4SLinus Torvalds selector = HUB_LED_AMBER; 5311da177e4SLinus Torvalds mode = INDICATOR_AMBER_BLINK_OFF; 5321da177e4SLinus Torvalds break; 5331da177e4SLinus Torvalds case INDICATOR_AMBER_BLINK_OFF: 5341da177e4SLinus Torvalds selector = HUB_LED_OFF; 5351da177e4SLinus Torvalds mode = INDICATOR_AMBER_BLINK; 5361da177e4SLinus Torvalds break; 5371da177e4SLinus Torvalds /* blink green/amber = reserved */ 5381da177e4SLinus Torvalds case INDICATOR_ALT_BLINK: 5391da177e4SLinus Torvalds selector = HUB_LED_GREEN; 5401da177e4SLinus Torvalds mode = INDICATOR_ALT_BLINK_OFF; 5411da177e4SLinus Torvalds break; 5421da177e4SLinus Torvalds case INDICATOR_ALT_BLINK_OFF: 5431da177e4SLinus Torvalds selector = HUB_LED_AMBER; 5441da177e4SLinus Torvalds mode = INDICATOR_ALT_BLINK; 5451da177e4SLinus Torvalds break; 5461da177e4SLinus Torvalds default: 5471da177e4SLinus Torvalds continue; 5481da177e4SLinus Torvalds } 5491da177e4SLinus Torvalds if (selector != HUB_LED_AUTO) 5501da177e4SLinus Torvalds changed = 1; 5511da177e4SLinus Torvalds set_port_led(hub, i + 1, selector); 5521da177e4SLinus Torvalds hub->indicator[i] = mode; 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds if (!changed && blinkenlights) { 5551da177e4SLinus Torvalds cursor++; 5563bbc47d8SKrzysztof Mazur cursor %= hdev->maxchild; 5571da177e4SLinus Torvalds set_port_led(hub, cursor + 1, HUB_LED_GREEN); 5581da177e4SLinus Torvalds hub->indicator[cursor] = INDICATOR_CYCLE; 5591da177e4SLinus Torvalds changed++; 5601da177e4SLinus Torvalds } 5611da177e4SLinus Torvalds if (changed) 56222f6a0f0SShaibal Dutta queue_delayed_work(system_power_efficient_wq, 56322f6a0f0SShaibal Dutta &hub->leds, LED_CYCLE_PERIOD); 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds /* use a short timeout for hub/port status fetches */ 5671da177e4SLinus Torvalds #define USB_STS_TIMEOUT 1000 5681da177e4SLinus Torvalds #define USB_STS_RETRIES 5 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds /* 5711da177e4SLinus Torvalds * USB 2.0 spec Section 11.24.2.6 5721da177e4SLinus Torvalds */ 5731da177e4SLinus Torvalds static int get_hub_status(struct usb_device *hdev, 5741da177e4SLinus Torvalds struct usb_hub_status *data) 5751da177e4SLinus Torvalds { 5761da177e4SLinus Torvalds int i, status = -ETIMEDOUT; 5771da177e4SLinus Torvalds 5783824c1ddSLibor Pechacek for (i = 0; i < USB_STS_RETRIES && 5793824c1ddSLibor Pechacek (status == -ETIMEDOUT || status == -EPIPE); i++) { 5801da177e4SLinus Torvalds status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 5811da177e4SLinus Torvalds USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0, 5821da177e4SLinus Torvalds data, sizeof(*data), USB_STS_TIMEOUT); 5831da177e4SLinus Torvalds } 5841da177e4SLinus Torvalds return status; 5851da177e4SLinus Torvalds } 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds /* 5881da177e4SLinus Torvalds * USB 2.0 spec Section 11.24.2.7 5890cdd49a1SMathias Nyman * USB 3.1 takes into use the wValue and wLength fields, spec Section 10.16.2.6 5901da177e4SLinus Torvalds */ 5911da177e4SLinus Torvalds static int get_port_status(struct usb_device *hdev, int port1, 5920cdd49a1SMathias Nyman void *data, u16 value, u16 length) 5931da177e4SLinus Torvalds { 5941da177e4SLinus Torvalds int i, status = -ETIMEDOUT; 5951da177e4SLinus Torvalds 5963824c1ddSLibor Pechacek for (i = 0; i < USB_STS_RETRIES && 5973824c1ddSLibor Pechacek (status == -ETIMEDOUT || status == -EPIPE); i++) { 5981da177e4SLinus Torvalds status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 5990cdd49a1SMathias Nyman USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, value, 6000cdd49a1SMathias Nyman port1, data, length, USB_STS_TIMEOUT); 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds return status; 6031da177e4SLinus Torvalds } 6041da177e4SLinus Torvalds 6050cdd49a1SMathias Nyman static int hub_ext_port_status(struct usb_hub *hub, int port1, int type, 6060cdd49a1SMathias Nyman u16 *status, u16 *change, u32 *ext_status) 6073eb14915SAlan Stern { 6083eb14915SAlan Stern int ret; 6090cdd49a1SMathias Nyman int len = 4; 6100cdd49a1SMathias Nyman 6110cdd49a1SMathias Nyman if (type != HUB_PORT_STATUS) 6120cdd49a1SMathias Nyman len = 8; 6133eb14915SAlan Stern 6143eb14915SAlan Stern mutex_lock(&hub->status_mutex); 6150cdd49a1SMathias Nyman ret = get_port_status(hub->hdev, port1, &hub->status->port, type, len); 6160cdd49a1SMathias Nyman if (ret < len) { 617e9e88fb7SAlan Stern if (ret != -ENODEV) 6183eb14915SAlan Stern dev_err(hub->intfdev, 6193eb14915SAlan Stern "%s failed (err = %d)\n", __func__, ret); 6203eb14915SAlan Stern if (ret >= 0) 6213eb14915SAlan Stern ret = -EIO; 6223eb14915SAlan Stern } else { 6233eb14915SAlan Stern *status = le16_to_cpu(hub->status->port.wPortStatus); 6243eb14915SAlan Stern *change = le16_to_cpu(hub->status->port.wPortChange); 6250cdd49a1SMathias Nyman if (type != HUB_PORT_STATUS && ext_status) 6260cdd49a1SMathias Nyman *ext_status = le32_to_cpu( 6270cdd49a1SMathias Nyman hub->status->port.dwExtPortStatus); 6283eb14915SAlan Stern ret = 0; 6293eb14915SAlan Stern } 6303eb14915SAlan Stern mutex_unlock(&hub->status_mutex); 6313eb14915SAlan Stern return ret; 6323eb14915SAlan Stern } 6333eb14915SAlan Stern 634f061f43dSMichael Grzeschik int usb_hub_port_status(struct usb_hub *hub, int port1, 6350cdd49a1SMathias Nyman u16 *status, u16 *change) 6360cdd49a1SMathias Nyman { 6370cdd49a1SMathias Nyman return hub_ext_port_status(hub, port1, HUB_PORT_STATUS, 6380cdd49a1SMathias Nyman status, change, NULL); 6390cdd49a1SMathias Nyman } 6400cdd49a1SMathias Nyman 6418eb58994SNicolas Saenz Julienne static void hub_resubmit_irq_urb(struct usb_hub *hub) 6428eb58994SNicolas Saenz Julienne { 6438eb58994SNicolas Saenz Julienne unsigned long flags; 6448eb58994SNicolas Saenz Julienne int status; 6458eb58994SNicolas Saenz Julienne 6468eb58994SNicolas Saenz Julienne spin_lock_irqsave(&hub->irq_urb_lock, flags); 6478eb58994SNicolas Saenz Julienne 6488eb58994SNicolas Saenz Julienne if (hub->quiescing) { 6498eb58994SNicolas Saenz Julienne spin_unlock_irqrestore(&hub->irq_urb_lock, flags); 6508eb58994SNicolas Saenz Julienne return; 6518eb58994SNicolas Saenz Julienne } 6528eb58994SNicolas Saenz Julienne 6538eb58994SNicolas Saenz Julienne status = usb_submit_urb(hub->urb, GFP_ATOMIC); 6548eb58994SNicolas Saenz Julienne if (status && status != -ENODEV && status != -EPERM && 6558eb58994SNicolas Saenz Julienne status != -ESHUTDOWN) { 6568eb58994SNicolas Saenz Julienne dev_err(hub->intfdev, "resubmit --> %d\n", status); 6578eb58994SNicolas Saenz Julienne mod_timer(&hub->irq_urb_retry, jiffies + HZ); 6588eb58994SNicolas Saenz Julienne } 6598eb58994SNicolas Saenz Julienne 6608eb58994SNicolas Saenz Julienne spin_unlock_irqrestore(&hub->irq_urb_lock, flags); 6618eb58994SNicolas Saenz Julienne } 6628eb58994SNicolas Saenz Julienne 6638eb58994SNicolas Saenz Julienne static void hub_retry_irq_urb(struct timer_list *t) 6648eb58994SNicolas Saenz Julienne { 6658eb58994SNicolas Saenz Julienne struct usb_hub *hub = from_timer(hub, t, irq_urb_retry); 6668eb58994SNicolas Saenz Julienne 6678eb58994SNicolas Saenz Julienne hub_resubmit_irq_urb(hub); 6688eb58994SNicolas Saenz Julienne } 6698eb58994SNicolas Saenz Julienne 6708eb58994SNicolas Saenz Julienne 67132a69589SPetr Mladek static void kick_hub_wq(struct usb_hub *hub) 6721da177e4SLinus Torvalds { 67332a69589SPetr Mladek struct usb_interface *intf; 6741da177e4SLinus Torvalds 67532a69589SPetr Mladek if (hub->disconnected || work_pending(&hub->events)) 67632a69589SPetr Mladek return; 6778e4ceb38SAlan Stern 67832a69589SPetr Mladek /* 67932a69589SPetr Mladek * Suppress autosuspend until the event is proceed. 68032a69589SPetr Mladek * 68132a69589SPetr Mladek * Be careful and make sure that the symmetric operation is 68232a69589SPetr Mladek * always called. We are here only when there is no pending 68332a69589SPetr Mladek * work for this hub. Therefore put the interface either when 68432a69589SPetr Mladek * the new work is called or when it is canceled. 68532a69589SPetr Mladek */ 68632a69589SPetr Mladek intf = to_usb_interface(hub->intfdev); 68732a69589SPetr Mladek usb_autopm_get_interface_no_resume(intf); 68832a69589SPetr Mladek kref_get(&hub->kref); 68932a69589SPetr Mladek 69032a69589SPetr Mladek if (queue_work(hub_wq, &hub->events)) 69132a69589SPetr Mladek return; 69232a69589SPetr Mladek 69332a69589SPetr Mladek /* the work has already been scheduled */ 69432a69589SPetr Mladek usb_autopm_put_interface_async(intf); 69532a69589SPetr Mladek kref_put(&hub->kref, hub_release); 6961da177e4SLinus Torvalds } 6971da177e4SLinus Torvalds 69859d48b3fSPetr Mladek void usb_kick_hub_wq(struct usb_device *hdev) 6991da177e4SLinus Torvalds { 700ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 70125118084SAlan Stern 70225118084SAlan Stern if (hub) 70332a69589SPetr Mladek kick_hub_wq(hub); 7041da177e4SLinus Torvalds } 7051da177e4SLinus Torvalds 7064ee823b8SSarah Sharp /* 7074ee823b8SSarah Sharp * Let the USB core know that a USB 3.0 device has sent a Function Wake Device 7084ee823b8SSarah Sharp * Notification, which indicates it had initiated remote wakeup. 7094ee823b8SSarah Sharp * 7104ee823b8SSarah Sharp * USB 3.0 hubs do not report the port link state change from U3 to U0 when the 7114ee823b8SSarah Sharp * device initiates resume, so the USB core will not receive notice of the 7124ee823b8SSarah Sharp * resume through the normal hub interrupt URB. 7134ee823b8SSarah Sharp */ 7144ee823b8SSarah Sharp void usb_wakeup_notification(struct usb_device *hdev, 7154ee823b8SSarah Sharp unsigned int portnum) 7164ee823b8SSarah Sharp { 7174ee823b8SSarah Sharp struct usb_hub *hub; 71883a62c51SRavi Chandra Sadineni struct usb_port *port_dev; 7194ee823b8SSarah Sharp 7204ee823b8SSarah Sharp if (!hdev) 7214ee823b8SSarah Sharp return; 7224ee823b8SSarah Sharp 723ad493e5eSLan Tianyu hub = usb_hub_to_struct_hub(hdev); 7244ee823b8SSarah Sharp if (hub) { 72583a62c51SRavi Chandra Sadineni port_dev = hub->ports[portnum - 1]; 72683a62c51SRavi Chandra Sadineni if (port_dev && port_dev->child) 72783a62c51SRavi Chandra Sadineni pm_wakeup_event(&port_dev->child->dev, 0); 72883a62c51SRavi Chandra Sadineni 7294ee823b8SSarah Sharp set_bit(portnum, hub->wakeup_bits); 73032a69589SPetr Mladek kick_hub_wq(hub); 7314ee823b8SSarah Sharp } 7324ee823b8SSarah Sharp } 7334ee823b8SSarah Sharp EXPORT_SYMBOL_GPL(usb_wakeup_notification); 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds /* completion function, fires on port status changes and various faults */ 7367d12e780SDavid Howells static void hub_irq(struct urb *urb) 7371da177e4SLinus Torvalds { 738ec17cf1cSTobias Klauser struct usb_hub *hub = urb->context; 739e015268dSAlan Stern int status = urb->status; 74071d2718fSRoel Kluin unsigned i; 7411da177e4SLinus Torvalds unsigned long bits; 7421da177e4SLinus Torvalds 743e015268dSAlan Stern switch (status) { 7441da177e4SLinus Torvalds case -ENOENT: /* synchronous unlink */ 7451da177e4SLinus Torvalds case -ECONNRESET: /* async unlink */ 7461da177e4SLinus Torvalds case -ESHUTDOWN: /* hardware going away */ 7471da177e4SLinus Torvalds return; 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds default: /* presumably an error */ 7501da177e4SLinus Torvalds /* Cause a hub reset after 10 consecutive errors */ 751e015268dSAlan Stern dev_dbg(hub->intfdev, "transfer --> %d\n", status); 7521da177e4SLinus Torvalds if ((++hub->nerrors < 10) || hub->error) 7531da177e4SLinus Torvalds goto resubmit; 754e015268dSAlan Stern hub->error = status; 755df561f66SGustavo A. R. Silva fallthrough; 7561da177e4SLinus Torvalds 75737ebb549SPetr Mladek /* let hub_wq handle things */ 7581da177e4SLinus Torvalds case 0: /* we got data: port status changed */ 7591da177e4SLinus Torvalds bits = 0; 7601da177e4SLinus Torvalds for (i = 0; i < urb->actual_length; ++i) 7611da177e4SLinus Torvalds bits |= ((unsigned long) ((*hub->buffer)[i])) 7621da177e4SLinus Torvalds << (i*8); 7631da177e4SLinus Torvalds hub->event_bits[0] = bits; 7641da177e4SLinus Torvalds break; 7651da177e4SLinus Torvalds } 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds hub->nerrors = 0; 7681da177e4SLinus Torvalds 76937ebb549SPetr Mladek /* Something happened, let hub_wq figure it out */ 77032a69589SPetr Mladek kick_hub_wq(hub); 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds resubmit: 7738eb58994SNicolas Saenz Julienne hub_resubmit_irq_urb(hub); 7741da177e4SLinus Torvalds } 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds /* USB 2.0 spec Section 11.24.2.3 */ 7771da177e4SLinus Torvalds static inline int 7781da177e4SLinus Torvalds hub_clear_tt_buffer(struct usb_device *hdev, u16 devinfo, u16 tt) 7791da177e4SLinus Torvalds { 7802c7b871bSWilliam Gulland /* Need to clear both directions for control ep */ 7812c7b871bSWilliam Gulland if (((devinfo >> 11) & USB_ENDPOINT_XFERTYPE_MASK) == 7822c7b871bSWilliam Gulland USB_ENDPOINT_XFER_CONTROL) { 7831afe33a7SOliver Neukum int status = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 7842c7b871bSWilliam Gulland HUB_CLEAR_TT_BUFFER, USB_RT_PORT, 7852c7b871bSWilliam Gulland devinfo ^ 0x8000, tt, NULL, 0, 1000); 7862c7b871bSWilliam Gulland if (status) 7872c7b871bSWilliam Gulland return status; 7882c7b871bSWilliam Gulland } 7891afe33a7SOliver Neukum return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 7901afe33a7SOliver Neukum HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo, 7911afe33a7SOliver Neukum tt, NULL, 0, 1000); 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds /* 79537ebb549SPetr Mladek * enumeration blocks hub_wq for a long time. we use keventd instead, since 7961da177e4SLinus Torvalds * long blocking there is the exception, not the rule. accordingly, HCDs 7971da177e4SLinus Torvalds * talking to TTs must queue control transfers (not just bulk and iso), so 7981da177e4SLinus Torvalds * both can talk to the same hub concurrently. 7991da177e4SLinus Torvalds */ 800cb88a1b8SAlan Stern static void hub_tt_work(struct work_struct *work) 8011da177e4SLinus Torvalds { 802c4028958SDavid Howells struct usb_hub *hub = 803cb88a1b8SAlan Stern container_of(work, struct usb_hub, tt.clear_work); 8041da177e4SLinus Torvalds unsigned long flags; 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds spin_lock_irqsave(&hub->tt.lock, flags); 8073b6054daSOctavian Purdila while (!list_empty(&hub->tt.clear_list)) { 808d0f830d3SH Hartley Sweeten struct list_head *next; 8091da177e4SLinus Torvalds struct usb_tt_clear *clear; 8101da177e4SLinus Torvalds struct usb_device *hdev = hub->hdev; 811cb88a1b8SAlan Stern const struct hc_driver *drv; 8121da177e4SLinus Torvalds int status; 8131da177e4SLinus Torvalds 814d0f830d3SH Hartley Sweeten next = hub->tt.clear_list.next; 815d0f830d3SH Hartley Sweeten clear = list_entry(next, struct usb_tt_clear, clear_list); 8161da177e4SLinus Torvalds list_del(&clear->clear_list); 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds /* drop lock so HCD can concurrently report other TT errors */ 8191da177e4SLinus Torvalds spin_unlock_irqrestore(&hub->tt.lock, flags); 8201da177e4SLinus Torvalds status = hub_clear_tt_buffer(hdev, clear->devinfo, clear->tt); 821e9e88fb7SAlan Stern if (status && status != -ENODEV) 8221da177e4SLinus Torvalds dev_err(&hdev->dev, 8231da177e4SLinus Torvalds "clear tt %d (%04x) error %d\n", 8241da177e4SLinus Torvalds clear->tt, clear->devinfo, status); 825cb88a1b8SAlan Stern 826cb88a1b8SAlan Stern /* Tell the HCD, even if the operation failed */ 827cb88a1b8SAlan Stern drv = clear->hcd->driver; 828cb88a1b8SAlan Stern if (drv->clear_tt_buffer_complete) 829cb88a1b8SAlan Stern (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep); 830cb88a1b8SAlan Stern 8311da177e4SLinus Torvalds kfree(clear); 832cb88a1b8SAlan Stern spin_lock_irqsave(&hub->tt.lock, flags); 8331da177e4SLinus Torvalds } 8341da177e4SLinus Torvalds spin_unlock_irqrestore(&hub->tt.lock, flags); 8351da177e4SLinus Torvalds } 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds /** 838971fcd49SLan Tianyu * usb_hub_set_port_power - control hub port's power state 83941341261SMathias Nyman * @hdev: USB device belonging to the usb hub 84041341261SMathias Nyman * @hub: target hub 841971fcd49SLan Tianyu * @port1: port index 842971fcd49SLan Tianyu * @set: expected status 843971fcd49SLan Tianyu * 844971fcd49SLan Tianyu * call this function to control port's power via setting or 845971fcd49SLan Tianyu * clearing the port's PORT_POWER feature. 846626f090cSYacine Belkadi * 847626f090cSYacine Belkadi * Return: 0 if successful. A negative error code otherwise. 848971fcd49SLan Tianyu */ 84941341261SMathias Nyman int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub, 85041341261SMathias Nyman int port1, bool set) 851971fcd49SLan Tianyu { 852971fcd49SLan Tianyu int ret; 853971fcd49SLan Tianyu 854971fcd49SLan Tianyu if (set) 855971fcd49SLan Tianyu ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER); 856971fcd49SLan Tianyu else 857ad493e5eSLan Tianyu ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER); 858ad493e5eSLan Tianyu 859d5c3834eSDan Williams if (ret) 860971fcd49SLan Tianyu return ret; 861d5c3834eSDan Williams 862d5c3834eSDan Williams if (set) 863d5c3834eSDan Williams set_bit(port1, hub->power_bits); 864d5c3834eSDan Williams else 865d5c3834eSDan Williams clear_bit(port1, hub->power_bits); 866d5c3834eSDan Williams return 0; 867971fcd49SLan Tianyu } 868971fcd49SLan Tianyu 869971fcd49SLan Tianyu /** 870cb88a1b8SAlan Stern * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub 871cb88a1b8SAlan Stern * @urb: an URB associated with the failed or incomplete split transaction 8721da177e4SLinus Torvalds * 8731da177e4SLinus Torvalds * High speed HCDs use this to tell the hub driver that some split control or 8741da177e4SLinus Torvalds * bulk transaction failed in a way that requires clearing internal state of 8751da177e4SLinus Torvalds * a transaction translator. This is normally detected (and reported) from 8761da177e4SLinus Torvalds * interrupt context. 8771da177e4SLinus Torvalds * 8781da177e4SLinus Torvalds * It may not be possible for that hub to handle additional full (or low) 8791da177e4SLinus Torvalds * speed transactions until that state is fully cleared out. 880626f090cSYacine Belkadi * 881626f090cSYacine Belkadi * Return: 0 if successful. A negative error code otherwise. 8821da177e4SLinus Torvalds */ 883cb88a1b8SAlan Stern int usb_hub_clear_tt_buffer(struct urb *urb) 8841da177e4SLinus Torvalds { 885cb88a1b8SAlan Stern struct usb_device *udev = urb->dev; 886cb88a1b8SAlan Stern int pipe = urb->pipe; 8871da177e4SLinus Torvalds struct usb_tt *tt = udev->tt; 8881da177e4SLinus Torvalds unsigned long flags; 8891da177e4SLinus Torvalds struct usb_tt_clear *clear; 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds /* we've got to cope with an arbitrary number of pending TT clears, 8921da177e4SLinus Torvalds * since each TT has "at least two" buffers that can need it (and 8931da177e4SLinus Torvalds * there can be many TTs per hub). even if they're uncommon. 8941da177e4SLinus Torvalds */ 895d544d273SGreg Kroah-Hartman clear = kmalloc(sizeof *clear, GFP_ATOMIC); 896d544d273SGreg Kroah-Hartman if (clear == NULL) { 8971da177e4SLinus Torvalds dev_err(&udev->dev, "can't save CLEAR_TT_BUFFER state\n"); 8981da177e4SLinus Torvalds /* FIXME recover somehow ... RESET_TT? */ 899cb88a1b8SAlan Stern return -ENOMEM; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds /* info that CLEAR_TT_BUFFER needs */ 9031da177e4SLinus Torvalds clear->tt = tt->multi ? udev->ttport : 1; 9041da177e4SLinus Torvalds clear->devinfo = usb_pipeendpoint (pipe); 9054998f1efSJim Lin clear->devinfo |= ((u16)udev->devaddr) << 4; 9061da177e4SLinus Torvalds clear->devinfo |= usb_pipecontrol(pipe) 9071da177e4SLinus Torvalds ? (USB_ENDPOINT_XFER_CONTROL << 11) 9081da177e4SLinus Torvalds : (USB_ENDPOINT_XFER_BULK << 11); 9091da177e4SLinus Torvalds if (usb_pipein(pipe)) 9101da177e4SLinus Torvalds clear->devinfo |= 1 << 15; 9111da177e4SLinus Torvalds 912cb88a1b8SAlan Stern /* info for completion callback */ 913cb88a1b8SAlan Stern clear->hcd = bus_to_hcd(udev->bus); 914cb88a1b8SAlan Stern clear->ep = urb->ep; 915cb88a1b8SAlan Stern 9161da177e4SLinus Torvalds /* tell keventd to clear state for this TT */ 9171da177e4SLinus Torvalds spin_lock_irqsave(&tt->lock, flags); 9181da177e4SLinus Torvalds list_add_tail(&clear->clear_list, &tt->clear_list); 919cb88a1b8SAlan Stern schedule_work(&tt->clear_work); 9201da177e4SLinus Torvalds spin_unlock_irqrestore(&tt->lock, flags); 921cb88a1b8SAlan Stern return 0; 9221da177e4SLinus Torvalds } 923cb88a1b8SAlan Stern EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer); 9241da177e4SLinus Torvalds 9257ad3c470SDan Williams static void hub_power_on(struct usb_hub *hub, bool do_delay) 9261da177e4SLinus Torvalds { 9271da177e4SLinus Torvalds int port1; 9281da177e4SLinus Torvalds 9294489a571SAlan Stern /* Enable power on each port. Some hubs have reserved values 9304489a571SAlan Stern * of LPSM (> 2) in their descriptors, even though they are 9314489a571SAlan Stern * USB 2.0 hubs. Some hubs do not implement port-power switching 9324489a571SAlan Stern * but only emulate it. In all cases, the ports won't work 9334489a571SAlan Stern * unless we send these messages to the hub. 9344489a571SAlan Stern */ 9359262c19dSDan Williams if (hub_is_port_power_switchable(hub)) 9361da177e4SLinus Torvalds dev_dbg(hub->intfdev, "enabling power on all ports\n"); 9374489a571SAlan Stern else 9384489a571SAlan Stern dev_dbg(hub->intfdev, "trying to enable port power on " 9394489a571SAlan Stern "non-switchable hub\n"); 9403bbc47d8SKrzysztof Mazur for (port1 = 1; port1 <= hub->hdev->maxchild; port1++) 941d5c3834eSDan Williams if (test_bit(port1, hub->power_bits)) 9424489a571SAlan Stern set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER); 943ad493e5eSLan Tianyu else 944ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 945ad493e5eSLan Tianyu USB_PORT_FEAT_POWER); 9468520f380SAlan Stern if (do_delay) 9477ad3c470SDan Williams msleep(hub_power_on_good_delay(hub)); 9481da177e4SLinus Torvalds } 9491da177e4SLinus Torvalds 9501da177e4SLinus Torvalds static int hub_hub_status(struct usb_hub *hub, 9511da177e4SLinus Torvalds u16 *status, u16 *change) 9521da177e4SLinus Torvalds { 9531da177e4SLinus Torvalds int ret; 9541da177e4SLinus Torvalds 955db90e7a1SAlan Stern mutex_lock(&hub->status_mutex); 9561da177e4SLinus Torvalds ret = get_hub_status(hub->hdev, &hub->status->hub); 957e9e88fb7SAlan Stern if (ret < 0) { 958e9e88fb7SAlan Stern if (ret != -ENODEV) 9591da177e4SLinus Torvalds dev_err(hub->intfdev, 960441b62c1SHarvey Harrison "%s failed (err = %d)\n", __func__, ret); 961e9e88fb7SAlan Stern } else { 9621da177e4SLinus Torvalds *status = le16_to_cpu(hub->status->hub.wHubStatus); 9631da177e4SLinus Torvalds *change = le16_to_cpu(hub->status->hub.wHubChange); 9641da177e4SLinus Torvalds ret = 0; 9651da177e4SLinus Torvalds } 966db90e7a1SAlan Stern mutex_unlock(&hub->status_mutex); 9671da177e4SLinus Torvalds return ret; 9681da177e4SLinus Torvalds } 9691da177e4SLinus Torvalds 97041e7e056SSarah Sharp static int hub_set_port_link_state(struct usb_hub *hub, int port1, 97141e7e056SSarah Sharp unsigned int link_status) 97241e7e056SSarah Sharp { 97341e7e056SSarah Sharp return set_port_feature(hub->hdev, 97441e7e056SSarah Sharp port1 | (link_status << 3), 97541e7e056SSarah Sharp USB_PORT_FEAT_LINK_STATE); 97641e7e056SSarah Sharp } 97741e7e056SSarah Sharp 97841e7e056SSarah Sharp /* 9796d42fcdbSJustin P. Mattock * Disable a port and mark a logical connect-change event, so that some 98037ebb549SPetr Mladek * time later hub_wq will disconnect() any existing usb_device on the port 9810458d5b4SAlan Stern * and will re-enumerate if there actually is a device attached. 9820458d5b4SAlan Stern */ 9830458d5b4SAlan Stern static void hub_port_logical_disconnect(struct usb_hub *hub, int port1) 9847d069b7dSAlan Stern { 985d99f6b41SDan Williams dev_dbg(&hub->ports[port1 - 1]->dev, "logical disconnect\n"); 9860458d5b4SAlan Stern hub_port_disable(hub, port1, 1); 9870458d5b4SAlan Stern 9880458d5b4SAlan Stern /* FIXME let caller ask to power down the port: 9890458d5b4SAlan Stern * - some devices won't enumerate without a VBUS power cycle 9900458d5b4SAlan Stern * - SRP saves power that way 9910458d5b4SAlan Stern * - ... new call, TBD ... 9920458d5b4SAlan Stern * That's easy if this hub can switch power per-port, and 99337ebb549SPetr Mladek * hub_wq reactivates the port later (timer, SRP, etc). 9940458d5b4SAlan Stern * Powerdown must be optional, because of reset/DFU. 9950458d5b4SAlan Stern */ 9960458d5b4SAlan Stern 9970458d5b4SAlan Stern set_bit(port1, hub->change_bits); 99832a69589SPetr Mladek kick_hub_wq(hub); 9990458d5b4SAlan Stern } 10000458d5b4SAlan Stern 1001253e0572SAlan Stern /** 1002253e0572SAlan Stern * usb_remove_device - disable a device's port on its parent hub 1003253e0572SAlan Stern * @udev: device to be disabled and removed 1004253e0572SAlan Stern * Context: @udev locked, must be able to sleep. 1005253e0572SAlan Stern * 100637ebb549SPetr Mladek * After @udev's port has been disabled, hub_wq is notified and it will 1007253e0572SAlan Stern * see that the device has been disconnected. When the device is 1008253e0572SAlan Stern * physically unplugged and something is plugged in, the events will 1009253e0572SAlan Stern * be received and processed normally. 1010626f090cSYacine Belkadi * 1011626f090cSYacine Belkadi * Return: 0 if successful. A negative error code otherwise. 1012253e0572SAlan Stern */ 1013253e0572SAlan Stern int usb_remove_device(struct usb_device *udev) 1014253e0572SAlan Stern { 1015253e0572SAlan Stern struct usb_hub *hub; 1016253e0572SAlan Stern struct usb_interface *intf; 101760e3f6e4SEugeniu Rosca int ret; 1018253e0572SAlan Stern 1019253e0572SAlan Stern if (!udev->parent) /* Can't remove a root hub */ 1020253e0572SAlan Stern return -EINVAL; 1021ad493e5eSLan Tianyu hub = usb_hub_to_struct_hub(udev->parent); 1022253e0572SAlan Stern intf = to_usb_interface(hub->intfdev); 1023253e0572SAlan Stern 102460e3f6e4SEugeniu Rosca ret = usb_autopm_get_interface(intf); 102560e3f6e4SEugeniu Rosca if (ret < 0) 102660e3f6e4SEugeniu Rosca return ret; 102760e3f6e4SEugeniu Rosca 1028253e0572SAlan Stern set_bit(udev->portnum, hub->removed_bits); 1029253e0572SAlan Stern hub_port_logical_disconnect(hub, udev->portnum); 1030253e0572SAlan Stern usb_autopm_put_interface(intf); 1031253e0572SAlan Stern return 0; 1032253e0572SAlan Stern } 1033253e0572SAlan Stern 10346ee0b270SAlan Stern enum hub_activation_type { 10358e4ceb38SAlan Stern HUB_INIT, HUB_INIT2, HUB_INIT3, /* INITs must come first */ 10368520f380SAlan Stern HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME, 10376ee0b270SAlan Stern }; 10385e6effaeSAlan Stern 10398520f380SAlan Stern static void hub_init_func2(struct work_struct *ws); 10408520f380SAlan Stern static void hub_init_func3(struct work_struct *ws); 10418520f380SAlan Stern 1042f2835219SAlan Stern static void hub_activate(struct usb_hub *hub, enum hub_activation_type type) 10435e6effaeSAlan Stern { 10445e6effaeSAlan Stern struct usb_device *hdev = hub->hdev; 1045653a39d1SSarah Sharp struct usb_hcd *hcd; 1046653a39d1SSarah Sharp int ret; 10475e6effaeSAlan Stern int port1; 1048f2835219SAlan Stern int status; 1049948fea37SAlan Stern bool need_debounce_delay = false; 10508520f380SAlan Stern unsigned delay; 10518520f380SAlan Stern 10528520f380SAlan Stern /* Continue a partial initialization */ 1053e50293efSAlan Stern if (type == HUB_INIT2 || type == HUB_INIT3) { 105407d316a2SAlan Stern device_lock(&hdev->dev); 1055e50293efSAlan Stern 1056e50293efSAlan Stern /* Was the hub disconnected while we were waiting? */ 1057ca5cbc8bSAlan Stern if (hub->disconnected) 1058ca5cbc8bSAlan Stern goto disconnected; 10598520f380SAlan Stern if (type == HUB_INIT2) 10608520f380SAlan Stern goto init2; 10618520f380SAlan Stern goto init3; 1062e50293efSAlan Stern } 1063e50293efSAlan Stern kref_get(&hub->kref); 10645e6effaeSAlan Stern 1065a45aa3b3SElric Fu /* The superspeed hub except for root hub has to use Hub Depth 1066a45aa3b3SElric Fu * value as an offset into the route string to locate the bits 1067a45aa3b3SElric Fu * it uses to determine the downstream port number. So hub driver 1068a45aa3b3SElric Fu * should send a set hub depth request to superspeed hub after 1069a45aa3b3SElric Fu * the superspeed hub is set configuration in initialization or 1070a45aa3b3SElric Fu * reset procedure. 1071a45aa3b3SElric Fu * 1072a45aa3b3SElric Fu * After a resume, port power should still be on. 1073f2835219SAlan Stern * For any other type of activation, turn it on. 1074f2835219SAlan Stern */ 10758520f380SAlan Stern if (type != HUB_RESUME) { 1076a45aa3b3SElric Fu if (hdev->parent && hub_is_superspeed(hdev)) { 10771afe33a7SOliver Neukum ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 10781afe33a7SOliver Neukum HUB_SET_DEPTH, USB_RT_HUB, 1079a45aa3b3SElric Fu hdev->level - 1, 0, NULL, 0, 1080a45aa3b3SElric Fu USB_CTRL_SET_TIMEOUT); 10811afe33a7SOliver Neukum if (ret < 0) 1082a45aa3b3SElric Fu dev_err(hub->intfdev, 1083a45aa3b3SElric Fu "set hub depth failed\n"); 1084a45aa3b3SElric Fu } 10858520f380SAlan Stern 10868520f380SAlan Stern /* Speed up system boot by using a delayed_work for the 10878520f380SAlan Stern * hub's initial power-up delays. This is pretty awkward 10888520f380SAlan Stern * and the implementation looks like a home-brewed sort of 10898520f380SAlan Stern * setjmp/longjmp, but it saves at least 100 ms for each 10908520f380SAlan Stern * root hub (assuming usbcore is compiled into the kernel 10918520f380SAlan Stern * rather than as a module). It adds up. 10928520f380SAlan Stern * 10938520f380SAlan Stern * This can't be done for HUB_RESUME or HUB_RESET_RESUME 10948520f380SAlan Stern * because for those activation types the ports have to be 10958520f380SAlan Stern * operational when we return. In theory this could be done 10968520f380SAlan Stern * for HUB_POST_RESET, but it's easier not to. 10978520f380SAlan Stern */ 10988520f380SAlan Stern if (type == HUB_INIT) { 109917a364e2SKris Borer delay = hub_power_on_good_delay(hub); 11007ad3c470SDan Williams 11017ad3c470SDan Williams hub_power_on(hub, false); 110277fa83cfSTejun Heo INIT_DELAYED_WORK(&hub->init_work, hub_init_func2); 110322f6a0f0SShaibal Dutta queue_delayed_work(system_power_efficient_wq, 110422f6a0f0SShaibal Dutta &hub->init_work, 11058520f380SAlan Stern msecs_to_jiffies(delay)); 110661fbeba1SAlan Stern 110761fbeba1SAlan Stern /* Suppress autosuspend until init is done */ 11088e4ceb38SAlan Stern usb_autopm_get_interface_no_resume( 11098e4ceb38SAlan Stern to_usb_interface(hub->intfdev)); 11108520f380SAlan Stern return; /* Continues at init2: below */ 1111653a39d1SSarah Sharp } else if (type == HUB_RESET_RESUME) { 1112653a39d1SSarah Sharp /* The internal host controller state for the hub device 1113653a39d1SSarah Sharp * may be gone after a host power loss on system resume. 1114653a39d1SSarah Sharp * Update the device's info so the HW knows it's a hub. 1115653a39d1SSarah Sharp */ 1116653a39d1SSarah Sharp hcd = bus_to_hcd(hdev->bus); 1117653a39d1SSarah Sharp if (hcd->driver->update_hub_device) { 1118653a39d1SSarah Sharp ret = hcd->driver->update_hub_device(hcd, hdev, 1119653a39d1SSarah Sharp &hub->tt, GFP_NOIO); 1120653a39d1SSarah Sharp if (ret < 0) { 11211ccc417eSJoe Perches dev_err(hub->intfdev, 11221ccc417eSJoe Perches "Host not accepting hub info update\n"); 11231ccc417eSJoe Perches dev_err(hub->intfdev, 11241ccc417eSJoe Perches "LS/FS devices and hubs may not work under this hub\n"); 1125653a39d1SSarah Sharp } 1126653a39d1SSarah Sharp } 1127653a39d1SSarah Sharp hub_power_on(hub, true); 11288520f380SAlan Stern } else { 11298520f380SAlan Stern hub_power_on(hub, true); 11308520f380SAlan Stern } 113100558586SKai-Heng Feng /* Give some time on remote wakeup to let links to transit to U0 */ 113200558586SKai-Heng Feng } else if (hub_is_superspeed(hub->hdev)) 113300558586SKai-Heng Feng msleep(20); 113400558586SKai-Heng Feng 11358520f380SAlan Stern init2: 1136f2835219SAlan Stern 1137d99f6b41SDan Williams /* 113837ebb549SPetr Mladek * Check each port and set hub->change_bits to let hub_wq know 11396ee0b270SAlan Stern * which ports need attention. 11405e6effaeSAlan Stern */ 11415e6effaeSAlan Stern for (port1 = 1; port1 <= hdev->maxchild; ++port1) { 1142d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 1143d99f6b41SDan Williams struct usb_device *udev = port_dev->child; 11445e6effaeSAlan Stern u16 portstatus, portchange; 11455e6effaeSAlan Stern 11466ee0b270SAlan Stern portstatus = portchange = 0; 1147f061f43dSMichael Grzeschik status = usb_hub_port_status(hub, port1, &portstatus, &portchange); 1148245b2eecSGuenter Roeck if (status) 1149245b2eecSGuenter Roeck goto abort; 1150245b2eecSGuenter Roeck 11516ee0b270SAlan Stern if (udev || (portstatus & USB_PORT_STAT_CONNECTION)) 1152d99f6b41SDan Williams dev_dbg(&port_dev->dev, "status %04x change %04x\n", 1153d99f6b41SDan Williams portstatus, portchange); 11545e6effaeSAlan Stern 1155d99f6b41SDan Williams /* 1156d99f6b41SDan Williams * After anything other than HUB_RESUME (i.e., initialization 11576ee0b270SAlan Stern * or any sort of reset), every port should be disabled. 11586ee0b270SAlan Stern * Unconnected ports should likewise be disabled (paranoia), 11596ee0b270SAlan Stern * and so should ports for which we have no usb_device. 11605e6effaeSAlan Stern */ 11616ee0b270SAlan Stern if ((portstatus & USB_PORT_STAT_ENABLE) && ( 11626ee0b270SAlan Stern type != HUB_RESUME || 11636ee0b270SAlan Stern !(portstatus & USB_PORT_STAT_CONNECTION) || 11646ee0b270SAlan Stern !udev || 11656ee0b270SAlan Stern udev->state == USB_STATE_NOTATTACHED)) { 11669f0a6cd3SAndiry Xu /* 11679f0a6cd3SAndiry Xu * USB3 protocol ports will automatically transition 11689f0a6cd3SAndiry Xu * to Enabled state when detect an USB3.0 device attach. 1169fd1ac4cfSDan Williams * Do not disable USB3 protocol ports, just pretend 1170fd1ac4cfSDan Williams * power was lost 11719f0a6cd3SAndiry Xu */ 1172fd1ac4cfSDan Williams portstatus &= ~USB_PORT_STAT_ENABLE; 1173fd1ac4cfSDan Williams if (!hub_is_superspeed(hdev)) 1174ad493e5eSLan Tianyu usb_clear_port_feature(hdev, port1, 11759f0a6cd3SAndiry Xu USB_PORT_FEAT_ENABLE); 11769f0a6cd3SAndiry Xu } 11776ee0b270SAlan Stern 11784fdc1790SJan-Marek Glogowski /* Make sure a warm-reset request is handled by port_event */ 11794fdc1790SJan-Marek Glogowski if (type == HUB_RESUME && 11804fdc1790SJan-Marek Glogowski hub_port_warm_reset_required(hub, port1, portstatus)) 11814fdc1790SJan-Marek Glogowski set_bit(port1, hub->event_bits); 11824fdc1790SJan-Marek Glogowski 1183e8610894SMathias Nyman /* 1184e8610894SMathias Nyman * Add debounce if USB3 link is in polling/link training state. 1185e8610894SMathias Nyman * Link will automatically transition to Enabled state after 1186e8610894SMathias Nyman * link training completes. 1187e8610894SMathias Nyman */ 1188e8610894SMathias Nyman if (hub_is_superspeed(hdev) && 1189e8610894SMathias Nyman ((portstatus & USB_PORT_STAT_LINK_STATE) == 1190e8610894SMathias Nyman USB_SS_PORT_LS_POLLING)) 1191e8610894SMathias Nyman need_debounce_delay = true; 1192e8610894SMathias Nyman 1193948fea37SAlan Stern /* Clear status-change flags; we'll debounce later */ 1194948fea37SAlan Stern if (portchange & USB_PORT_STAT_C_CONNECTION) { 1195948fea37SAlan Stern need_debounce_delay = true; 1196ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 1197948fea37SAlan Stern USB_PORT_FEAT_C_CONNECTION); 1198948fea37SAlan Stern } 1199948fea37SAlan Stern if (portchange & USB_PORT_STAT_C_ENABLE) { 1200948fea37SAlan Stern need_debounce_delay = true; 1201ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 1202948fea37SAlan Stern USB_PORT_FEAT_C_ENABLE); 1203948fea37SAlan Stern } 1204e92aee33SJulius Werner if (portchange & USB_PORT_STAT_C_RESET) { 1205e92aee33SJulius Werner need_debounce_delay = true; 1206e92aee33SJulius Werner usb_clear_port_feature(hub->hdev, port1, 1207e92aee33SJulius Werner USB_PORT_FEAT_C_RESET); 1208e92aee33SJulius Werner } 120979c3dd81SDon Zickus if ((portchange & USB_PORT_STAT_C_BH_RESET) && 121079c3dd81SDon Zickus hub_is_superspeed(hub->hdev)) { 121179c3dd81SDon Zickus need_debounce_delay = true; 1212ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 121379c3dd81SDon Zickus USB_PORT_FEAT_C_BH_PORT_RESET); 121479c3dd81SDon Zickus } 1215253e0572SAlan Stern /* We can forget about a "removed" device when there's a 1216253e0572SAlan Stern * physical disconnect or the connect status changes. 1217253e0572SAlan Stern */ 1218253e0572SAlan Stern if (!(portstatus & USB_PORT_STAT_CONNECTION) || 1219253e0572SAlan Stern (portchange & USB_PORT_STAT_C_CONNECTION)) 1220253e0572SAlan Stern clear_bit(port1, hub->removed_bits); 1221253e0572SAlan Stern 12226ee0b270SAlan Stern if (!udev || udev->state == USB_STATE_NOTATTACHED) { 122337ebb549SPetr Mladek /* Tell hub_wq to disconnect the device or 1224249a32b7SBin Liu * check for a new connection or over current condition. 1225249a32b7SBin Liu * Based on USB2.0 Spec Section 11.12.5, 1226249a32b7SBin Liu * C_PORT_OVER_CURRENT could be set while 1227249a32b7SBin Liu * PORT_OVER_CURRENT is not. So check for any of them. 12286ee0b270SAlan Stern */ 122908d1dec6SShen Guang if (udev || (portstatus & USB_PORT_STAT_CONNECTION) || 12309c06ac4cSKeiya Nobuta (portchange & USB_PORT_STAT_C_CONNECTION) || 1231249a32b7SBin Liu (portstatus & USB_PORT_STAT_OVERCURRENT) || 1232249a32b7SBin Liu (portchange & USB_PORT_STAT_C_OVERCURRENT)) 12336ee0b270SAlan Stern set_bit(port1, hub->change_bits); 12346ee0b270SAlan Stern 12356ee0b270SAlan Stern } else if (portstatus & USB_PORT_STAT_ENABLE) { 123672937e1eSSarah Sharp bool port_resumed = (portstatus & 123772937e1eSSarah Sharp USB_PORT_STAT_LINK_STATE) == 123872937e1eSSarah Sharp USB_SS_PORT_LS_U0; 12396ee0b270SAlan Stern /* The power session apparently survived the resume. 12406ee0b270SAlan Stern * If there was an overcurrent or suspend change 124137ebb549SPetr Mladek * (i.e., remote wakeup request), have hub_wq 124272937e1eSSarah Sharp * take care of it. Look at the port link state 124372937e1eSSarah Sharp * for USB 3.0 hubs, since they don't have a suspend 124472937e1eSSarah Sharp * change bit, and they don't set the port link change 124572937e1eSSarah Sharp * bit on device-initiated resume. 12466ee0b270SAlan Stern */ 124772937e1eSSarah Sharp if (portchange || (hub_is_superspeed(hub->hdev) && 124872937e1eSSarah Sharp port_resumed)) 12490f663729SAlan Stern set_bit(port1, hub->event_bits); 12506ee0b270SAlan Stern 12516ee0b270SAlan Stern } else if (udev->persist_enabled) { 12526ee0b270SAlan Stern #ifdef CONFIG_PM 12535e6effaeSAlan Stern udev->reset_resume = 1; 12546ee0b270SAlan Stern #endif 12559f952e26SAlan Stern /* Don't set the change_bits when the device 12569f952e26SAlan Stern * was powered off. 12579f952e26SAlan Stern */ 12589f952e26SAlan Stern if (test_bit(port1, hub->power_bits)) 12599f952e26SAlan Stern set_bit(port1, hub->change_bits); 12608808f00cSAlan Stern 12616ee0b270SAlan Stern } else { 126237ebb549SPetr Mladek /* The power session is gone; tell hub_wq */ 12636ee0b270SAlan Stern usb_set_device_state(udev, USB_STATE_NOTATTACHED); 12646ee0b270SAlan Stern set_bit(port1, hub->change_bits); 12655e6effaeSAlan Stern } 12665e6effaeSAlan Stern } 12675e6effaeSAlan Stern 1268948fea37SAlan Stern /* If no port-status-change flags were set, we don't need any 1269948fea37SAlan Stern * debouncing. If flags were set we can try to debounce the 127037ebb549SPetr Mladek * ports all at once right now, instead of letting hub_wq do them 1271948fea37SAlan Stern * one at a time later on. 1272948fea37SAlan Stern * 127337ebb549SPetr Mladek * If any port-status changes do occur during this delay, hub_wq 1274948fea37SAlan Stern * will see them later and handle them normally. 1275948fea37SAlan Stern */ 12768520f380SAlan Stern if (need_debounce_delay) { 12778520f380SAlan Stern delay = HUB_DEBOUNCE_STABLE; 1278f2835219SAlan Stern 12798520f380SAlan Stern /* Don't do a long sleep inside a workqueue routine */ 12808520f380SAlan Stern if (type == HUB_INIT2) { 128177fa83cfSTejun Heo INIT_DELAYED_WORK(&hub->init_work, hub_init_func3); 128222f6a0f0SShaibal Dutta queue_delayed_work(system_power_efficient_wq, 128322f6a0f0SShaibal Dutta &hub->init_work, 12848520f380SAlan Stern msecs_to_jiffies(delay)); 128507d316a2SAlan Stern device_unlock(&hdev->dev); 12868520f380SAlan Stern return; /* Continues at init3: below */ 12878520f380SAlan Stern } else { 12888520f380SAlan Stern msleep(delay); 12898520f380SAlan Stern } 12908520f380SAlan Stern } 12918520f380SAlan Stern init3: 1292f2835219SAlan Stern hub->quiescing = 0; 1293f2835219SAlan Stern 1294f2835219SAlan Stern status = usb_submit_urb(hub->urb, GFP_NOIO); 1295f2835219SAlan Stern if (status < 0) 1296f2835219SAlan Stern dev_err(hub->intfdev, "activate --> %d\n", status); 1297f2835219SAlan Stern if (hub->has_indicators && blinkenlights) 129822f6a0f0SShaibal Dutta queue_delayed_work(system_power_efficient_wq, 129922f6a0f0SShaibal Dutta &hub->leds, LED_CYCLE_PERIOD); 1300f2835219SAlan Stern 1301f2835219SAlan Stern /* Scan all ports that need attention */ 130232a69589SPetr Mladek kick_hub_wq(hub); 1303245b2eecSGuenter Roeck abort: 1304ca5cbc8bSAlan Stern if (type == HUB_INIT2 || type == HUB_INIT3) { 13058e4ceb38SAlan Stern /* Allow autosuspend if it was suppressed */ 1306ca5cbc8bSAlan Stern disconnected: 13078e4ceb38SAlan Stern usb_autopm_put_interface_async(to_usb_interface(hub->intfdev)); 130807d316a2SAlan Stern device_unlock(&hdev->dev); 1309ca5cbc8bSAlan Stern } 1310e50293efSAlan Stern 1311e50293efSAlan Stern kref_put(&hub->kref, hub_release); 13125e6effaeSAlan Stern } 13135e6effaeSAlan Stern 13148520f380SAlan Stern /* Implement the continuations for the delays above */ 13158520f380SAlan Stern static void hub_init_func2(struct work_struct *ws) 13168520f380SAlan Stern { 13178520f380SAlan Stern struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work); 13188520f380SAlan Stern 13198520f380SAlan Stern hub_activate(hub, HUB_INIT2); 13208520f380SAlan Stern } 13218520f380SAlan Stern 13228520f380SAlan Stern static void hub_init_func3(struct work_struct *ws) 13238520f380SAlan Stern { 13248520f380SAlan Stern struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work); 13258520f380SAlan Stern 13268520f380SAlan Stern hub_activate(hub, HUB_INIT3); 13278520f380SAlan Stern } 13288520f380SAlan Stern 13294330354fSAlan Stern enum hub_quiescing_type { 13304330354fSAlan Stern HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND 13314330354fSAlan Stern }; 13324330354fSAlan Stern 13334330354fSAlan Stern static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type) 13344330354fSAlan Stern { 13354330354fSAlan Stern struct usb_device *hdev = hub->hdev; 13368eb58994SNicolas Saenz Julienne unsigned long flags; 13374330354fSAlan Stern int i; 13384330354fSAlan Stern 133937ebb549SPetr Mladek /* hub_wq and related activity won't re-trigger */ 13408eb58994SNicolas Saenz Julienne spin_lock_irqsave(&hub->irq_urb_lock, flags); 13414330354fSAlan Stern hub->quiescing = 1; 13428eb58994SNicolas Saenz Julienne spin_unlock_irqrestore(&hub->irq_urb_lock, flags); 13434330354fSAlan Stern 13444330354fSAlan Stern if (type != HUB_SUSPEND) { 13454330354fSAlan Stern /* Disconnect all the children */ 13464330354fSAlan Stern for (i = 0; i < hdev->maxchild; ++i) { 1347ff823c79SLan Tianyu if (hub->ports[i]->child) 1348ff823c79SLan Tianyu usb_disconnect(&hub->ports[i]->child); 13494330354fSAlan Stern } 13504330354fSAlan Stern } 13514330354fSAlan Stern 135237ebb549SPetr Mladek /* Stop hub_wq and related activity */ 13538eb58994SNicolas Saenz Julienne del_timer_sync(&hub->irq_urb_retry); 13544330354fSAlan Stern usb_kill_urb(hub->urb); 13554330354fSAlan Stern if (hub->has_indicators) 13564330354fSAlan Stern cancel_delayed_work_sync(&hub->leds); 13574330354fSAlan Stern if (hub->tt.hub) 1358036546bfSOctavian Purdila flush_work(&hub->tt.clear_work); 13594330354fSAlan Stern } 13604330354fSAlan Stern 1361600856c2SAlan Stern static void hub_pm_barrier_for_all_ports(struct usb_hub *hub) 1362600856c2SAlan Stern { 1363600856c2SAlan Stern int i; 1364600856c2SAlan Stern 1365600856c2SAlan Stern for (i = 0; i < hub->hdev->maxchild; ++i) 1366600856c2SAlan Stern pm_runtime_barrier(&hub->ports[i]->dev); 1367600856c2SAlan Stern } 1368600856c2SAlan Stern 13693eb14915SAlan Stern /* caller has locked the hub device */ 13703eb14915SAlan Stern static int hub_pre_reset(struct usb_interface *intf) 13713eb14915SAlan Stern { 13723eb14915SAlan Stern struct usb_hub *hub = usb_get_intfdata(intf); 13733eb14915SAlan Stern 13744330354fSAlan Stern hub_quiesce(hub, HUB_PRE_RESET); 1375600856c2SAlan Stern hub->in_reset = 1; 1376600856c2SAlan Stern hub_pm_barrier_for_all_ports(hub); 1377f07600cfSAlan Stern return 0; 13787d069b7dSAlan Stern } 13797d069b7dSAlan Stern 13807d069b7dSAlan Stern /* caller has locked the hub device */ 1381f07600cfSAlan Stern static int hub_post_reset(struct usb_interface *intf) 13827d069b7dSAlan Stern { 13837de18d8bSAlan Stern struct usb_hub *hub = usb_get_intfdata(intf); 13847de18d8bSAlan Stern 1385600856c2SAlan Stern hub->in_reset = 0; 1386600856c2SAlan Stern hub_pm_barrier_for_all_ports(hub); 1387f2835219SAlan Stern hub_activate(hub, HUB_POST_RESET); 1388f07600cfSAlan Stern return 0; 13897d069b7dSAlan Stern } 13907d069b7dSAlan Stern 13911da177e4SLinus Torvalds static int hub_configure(struct usb_hub *hub, 13921da177e4SLinus Torvalds struct usb_endpoint_descriptor *endpoint) 13931da177e4SLinus Torvalds { 1394b356b7c7SSarah Sharp struct usb_hcd *hcd; 13951da177e4SLinus Torvalds struct usb_device *hdev = hub->hdev; 13961da177e4SLinus Torvalds struct device *hub_dev = hub->intfdev; 13971da177e4SLinus Torvalds u16 hubstatus, hubchange; 139874ad9bd2SGreg Kroah-Hartman u16 wHubCharacteristics; 13991da177e4SLinus Torvalds unsigned int pipe; 1400fa2a9566SLan Tianyu int maxp, ret, i; 14017cbe5dcaSAlan Stern char *message = "out of memory"; 1402430ee58eSSebastian Andrzej Siewior unsigned unit_load; 1403430ee58eSSebastian Andrzej Siewior unsigned full_load; 1404d8521afeSDan Williams unsigned maxchild; 14051da177e4SLinus Torvalds 1406d697cddaSAlan Stern hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL); 14071da177e4SLinus Torvalds if (!hub->buffer) { 14081da177e4SLinus Torvalds ret = -ENOMEM; 14091da177e4SLinus Torvalds goto fail; 14101da177e4SLinus Torvalds } 14111da177e4SLinus Torvalds 14121da177e4SLinus Torvalds hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL); 14131da177e4SLinus Torvalds if (!hub->status) { 14141da177e4SLinus Torvalds ret = -ENOMEM; 14151da177e4SLinus Torvalds goto fail; 14161da177e4SLinus Torvalds } 1417db90e7a1SAlan Stern mutex_init(&hub->status_mutex); 14181da177e4SLinus Torvalds 1419bec444cdSJohan Hovold hub->descriptor = kzalloc(sizeof(*hub->descriptor), GFP_KERNEL); 14201da177e4SLinus Torvalds if (!hub->descriptor) { 14211da177e4SLinus Torvalds ret = -ENOMEM; 14221da177e4SLinus Torvalds goto fail; 14231da177e4SLinus Torvalds } 14241da177e4SLinus Torvalds 14251da177e4SLinus Torvalds /* Request the entire hub descriptor. 14261da177e4SLinus Torvalds * hub->descriptor can handle USB_MAXCHILDREN ports, 14272c25a2c8SJohan Hovold * but a (non-SS) hub can/will return fewer bytes here. 14281da177e4SLinus Torvalds */ 1429dbe79bbeSJohn Youn ret = get_hub_descriptor(hdev, hub->descriptor); 14301da177e4SLinus Torvalds if (ret < 0) { 14311da177e4SLinus Torvalds message = "can't read hub descriptor"; 14321da177e4SLinus Torvalds goto fail; 143393491cedSJohan Hovold } 143493491cedSJohan Hovold 143593491cedSJohan Hovold maxchild = USB_MAXCHILDREN; 143693491cedSJohan Hovold if (hub_is_superspeed(hdev)) 143793491cedSJohan Hovold maxchild = min_t(unsigned, maxchild, USB_SS_MAXPORTS); 143893491cedSJohan Hovold 143993491cedSJohan Hovold if (hub->descriptor->bNbrPorts > maxchild) { 14401da177e4SLinus Torvalds message = "hub has too many ports!"; 14411da177e4SLinus Torvalds ret = -ENODEV; 14421da177e4SLinus Torvalds goto fail; 1443769d7368SDavid Linares } else if (hub->descriptor->bNbrPorts == 0) { 1444769d7368SDavid Linares message = "hub doesn't have any ports!"; 1445769d7368SDavid Linares ret = -ENODEV; 1446769d7368SDavid Linares goto fail; 14471da177e4SLinus Torvalds } 14481da177e4SLinus Torvalds 1449886ee36eSFelipe Balbi /* 1450886ee36eSFelipe Balbi * Accumulate wHubDelay + 40ns for every hub in the tree of devices. 1451886ee36eSFelipe Balbi * The resulting value will be used for SetIsochDelay() request. 1452886ee36eSFelipe Balbi */ 1453886ee36eSFelipe Balbi if (hub_is_superspeed(hdev) || hub_is_superspeedplus(hdev)) { 1454886ee36eSFelipe Balbi u32 delay = __le16_to_cpu(hub->descriptor->u.ss.wHubDelay); 1455886ee36eSFelipe Balbi 1456886ee36eSFelipe Balbi if (hdev->parent) 1457886ee36eSFelipe Balbi delay += hdev->parent->hub_delay; 1458886ee36eSFelipe Balbi 1459886ee36eSFelipe Balbi delay += USB_TP_TRANSMISSION_DELAY; 1460886ee36eSFelipe Balbi hdev->hub_delay = min_t(u32, delay, USB_TP_TRANSMISSION_DELAY_MAX); 1461886ee36eSFelipe Balbi } 1462886ee36eSFelipe Balbi 1463d8521afeSDan Williams maxchild = hub->descriptor->bNbrPorts; 1464d8521afeSDan Williams dev_info(hub_dev, "%d port%s detected\n", maxchild, 1465d8521afeSDan Williams (maxchild == 1) ? "" : "s"); 14661da177e4SLinus Torvalds 14676396bb22SKees Cook hub->ports = kcalloc(maxchild, sizeof(struct usb_port *), GFP_KERNEL); 1468ff823c79SLan Tianyu if (!hub->ports) { 14697cbe5dcaSAlan Stern ret = -ENOMEM; 14707cbe5dcaSAlan Stern goto fail; 14717cbe5dcaSAlan Stern } 14727cbe5dcaSAlan Stern 147374ad9bd2SGreg Kroah-Hartman wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics); 1474430ee58eSSebastian Andrzej Siewior if (hub_is_superspeed(hdev)) { 1475430ee58eSSebastian Andrzej Siewior unit_load = 150; 1476430ee58eSSebastian Andrzej Siewior full_load = 900; 1477430ee58eSSebastian Andrzej Siewior } else { 1478430ee58eSSebastian Andrzej Siewior unit_load = 100; 1479430ee58eSSebastian Andrzej Siewior full_load = 500; 1480430ee58eSSebastian Andrzej Siewior } 14811da177e4SLinus Torvalds 1482dbe79bbeSJohn Youn /* FIXME for USB 3.0, skip for now */ 1483dbe79bbeSJohn Youn if ((wHubCharacteristics & HUB_CHAR_COMPOUND) && 1484dbe79bbeSJohn Youn !(hub_is_superspeed(hdev))) { 14851da177e4SLinus Torvalds char portstr[USB_MAXCHILDREN + 1]; 14861da177e4SLinus Torvalds 1487d8521afeSDan Williams for (i = 0; i < maxchild; i++) 1488dbe79bbeSJohn Youn portstr[i] = hub->descriptor->u.hs.DeviceRemovable 14891da177e4SLinus Torvalds [((i + 1) / 8)] & (1 << ((i + 1) % 8)) 14901da177e4SLinus Torvalds ? 'F' : 'R'; 1491d8521afeSDan Williams portstr[maxchild] = 0; 14921da177e4SLinus Torvalds dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr); 14931da177e4SLinus Torvalds } else 14941da177e4SLinus Torvalds dev_dbg(hub_dev, "standalone hub\n"); 14951da177e4SLinus Torvalds 149674ad9bd2SGreg Kroah-Hartman switch (wHubCharacteristics & HUB_CHAR_LPSM) { 14977bf01185SAman Deep case HUB_CHAR_COMMON_LPSM: 14981da177e4SLinus Torvalds dev_dbg(hub_dev, "ganged power switching\n"); 14991da177e4SLinus Torvalds break; 15007bf01185SAman Deep case HUB_CHAR_INDV_PORT_LPSM: 15011da177e4SLinus Torvalds dev_dbg(hub_dev, "individual port power switching\n"); 15021da177e4SLinus Torvalds break; 15037bf01185SAman Deep case HUB_CHAR_NO_LPSM: 15047bf01185SAman Deep case HUB_CHAR_LPSM: 15051da177e4SLinus Torvalds dev_dbg(hub_dev, "no power switching (usb 1.0)\n"); 15061da177e4SLinus Torvalds break; 15071da177e4SLinus Torvalds } 15081da177e4SLinus Torvalds 150974ad9bd2SGreg Kroah-Hartman switch (wHubCharacteristics & HUB_CHAR_OCPM) { 15107bf01185SAman Deep case HUB_CHAR_COMMON_OCPM: 15111da177e4SLinus Torvalds dev_dbg(hub_dev, "global over-current protection\n"); 15121da177e4SLinus Torvalds break; 15137bf01185SAman Deep case HUB_CHAR_INDV_PORT_OCPM: 15141da177e4SLinus Torvalds dev_dbg(hub_dev, "individual port over-current protection\n"); 15151da177e4SLinus Torvalds break; 15167bf01185SAman Deep case HUB_CHAR_NO_OCPM: 15177bf01185SAman Deep case HUB_CHAR_OCPM: 15181da177e4SLinus Torvalds dev_dbg(hub_dev, "no over-current protection\n"); 15191da177e4SLinus Torvalds break; 15201da177e4SLinus Torvalds } 15211da177e4SLinus Torvalds 15221da177e4SLinus Torvalds spin_lock_init(&hub->tt.lock); 15231da177e4SLinus Torvalds INIT_LIST_HEAD(&hub->tt.clear_list); 1524cb88a1b8SAlan Stern INIT_WORK(&hub->tt.clear_work, hub_tt_work); 15251da177e4SLinus Torvalds switch (hdev->descriptor.bDeviceProtocol) { 15267bf01185SAman Deep case USB_HUB_PR_FS: 15271da177e4SLinus Torvalds break; 15287bf01185SAman Deep case USB_HUB_PR_HS_SINGLE_TT: 15291da177e4SLinus Torvalds dev_dbg(hub_dev, "Single TT\n"); 15301da177e4SLinus Torvalds hub->tt.hub = hdev; 15311da177e4SLinus Torvalds break; 15327bf01185SAman Deep case USB_HUB_PR_HS_MULTI_TT: 15331da177e4SLinus Torvalds ret = usb_set_interface(hdev, 0, 1); 15341da177e4SLinus Torvalds if (ret == 0) { 15351da177e4SLinus Torvalds dev_dbg(hub_dev, "TT per port\n"); 15361da177e4SLinus Torvalds hub->tt.multi = 1; 15371da177e4SLinus Torvalds } else 15381da177e4SLinus Torvalds dev_err(hub_dev, "Using single TT (err %d)\n", 15391da177e4SLinus Torvalds ret); 15401da177e4SLinus Torvalds hub->tt.hub = hdev; 15411da177e4SLinus Torvalds break; 15427bf01185SAman Deep case USB_HUB_PR_SS: 1543d2e9b4d6SSarah Sharp /* USB 3.0 hubs don't have a TT */ 1544d2e9b4d6SSarah Sharp break; 15451da177e4SLinus Torvalds default: 15461da177e4SLinus Torvalds dev_dbg(hub_dev, "Unrecognized hub protocol %d\n", 15471da177e4SLinus Torvalds hdev->descriptor.bDeviceProtocol); 15481da177e4SLinus Torvalds break; 15491da177e4SLinus Torvalds } 15501da177e4SLinus Torvalds 1551e09711aeSdavid-b@pacbell.net /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */ 155274ad9bd2SGreg Kroah-Hartman switch (wHubCharacteristics & HUB_CHAR_TTTT) { 1553e09711aeSdavid-b@pacbell.net case HUB_TTTT_8_BITS: 1554e09711aeSdavid-b@pacbell.net if (hdev->descriptor.bDeviceProtocol != 0) { 1555e09711aeSdavid-b@pacbell.net hub->tt.think_time = 666; 1556e09711aeSdavid-b@pacbell.net dev_dbg(hub_dev, "TT requires at most %d " 1557e09711aeSdavid-b@pacbell.net "FS bit times (%d ns)\n", 1558e09711aeSdavid-b@pacbell.net 8, hub->tt.think_time); 1559e09711aeSdavid-b@pacbell.net } 15601da177e4SLinus Torvalds break; 1561e09711aeSdavid-b@pacbell.net case HUB_TTTT_16_BITS: 1562e09711aeSdavid-b@pacbell.net hub->tt.think_time = 666 * 2; 1563e09711aeSdavid-b@pacbell.net dev_dbg(hub_dev, "TT requires at most %d " 1564e09711aeSdavid-b@pacbell.net "FS bit times (%d ns)\n", 1565e09711aeSdavid-b@pacbell.net 16, hub->tt.think_time); 15661da177e4SLinus Torvalds break; 1567e09711aeSdavid-b@pacbell.net case HUB_TTTT_24_BITS: 1568e09711aeSdavid-b@pacbell.net hub->tt.think_time = 666 * 3; 1569e09711aeSdavid-b@pacbell.net dev_dbg(hub_dev, "TT requires at most %d " 1570e09711aeSdavid-b@pacbell.net "FS bit times (%d ns)\n", 1571e09711aeSdavid-b@pacbell.net 24, hub->tt.think_time); 15721da177e4SLinus Torvalds break; 1573e09711aeSdavid-b@pacbell.net case HUB_TTTT_32_BITS: 1574e09711aeSdavid-b@pacbell.net hub->tt.think_time = 666 * 4; 1575e09711aeSdavid-b@pacbell.net dev_dbg(hub_dev, "TT requires at most %d " 1576e09711aeSdavid-b@pacbell.net "FS bit times (%d ns)\n", 1577e09711aeSdavid-b@pacbell.net 32, hub->tt.think_time); 15781da177e4SLinus Torvalds break; 15791da177e4SLinus Torvalds } 15801da177e4SLinus Torvalds 15811da177e4SLinus Torvalds /* probe() zeroes hub->indicator[] */ 158274ad9bd2SGreg Kroah-Hartman if (wHubCharacteristics & HUB_CHAR_PORTIND) { 15831da177e4SLinus Torvalds hub->has_indicators = 1; 15841da177e4SLinus Torvalds dev_dbg(hub_dev, "Port indicators are supported\n"); 15851da177e4SLinus Torvalds } 15861da177e4SLinus Torvalds 15871da177e4SLinus Torvalds dev_dbg(hub_dev, "power on to power good time: %dms\n", 15881da177e4SLinus Torvalds hub->descriptor->bPwrOn2PwrGood * 2); 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds /* power budgeting mostly matters with bus-powered hubs, 15911da177e4SLinus Torvalds * and battery-powered root hubs (may provide just 8 mA). 15921da177e4SLinus Torvalds */ 1593d9e1e148SFelipe Balbi ret = usb_get_std_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus); 159415b7336eSAlan Stern if (ret) { 15951da177e4SLinus Torvalds message = "can't get hub status"; 15961da177e4SLinus Torvalds goto fail; 15971da177e4SLinus Torvalds } 1598430ee58eSSebastian Andrzej Siewior hcd = bus_to_hcd(hdev->bus); 15997d35b929SAlan Stern if (hdev == hdev->bus->root_hub) { 1600430ee58eSSebastian Andrzej Siewior if (hcd->power_budget > 0) 1601430ee58eSSebastian Andrzej Siewior hdev->bus_mA = hcd->power_budget; 1602430ee58eSSebastian Andrzej Siewior else 1603d8521afeSDan Williams hdev->bus_mA = full_load * maxchild; 1604430ee58eSSebastian Andrzej Siewior if (hdev->bus_mA >= full_load) 1605430ee58eSSebastian Andrzej Siewior hub->mA_per_port = full_load; 160655c52718SAlan Stern else { 160755c52718SAlan Stern hub->mA_per_port = hdev->bus_mA; 160855c52718SAlan Stern hub->limited_power = 1; 160955c52718SAlan Stern } 16107d35b929SAlan Stern } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) { 161155c52718SAlan Stern int remaining = hdev->bus_mA - 161255c52718SAlan Stern hub->descriptor->bHubContrCurrent; 16131da177e4SLinus Torvalds 1614430ee58eSSebastian Andrzej Siewior dev_dbg(hub_dev, "hub controller current requirement: %dmA\n", 1615430ee58eSSebastian Andrzej Siewior hub->descriptor->bHubContrCurrent); 1616430ee58eSSebastian Andrzej Siewior hub->limited_power = 1; 1617430ee58eSSebastian Andrzej Siewior 1618d8521afeSDan Williams if (remaining < maxchild * unit_load) 161955c52718SAlan Stern dev_warn(hub_dev, 162055c52718SAlan Stern "insufficient power available " 162155c52718SAlan Stern "to use all downstream ports\n"); 1622430ee58eSSebastian Andrzej Siewior hub->mA_per_port = unit_load; /* 7.2.1 */ 1623430ee58eSSebastian Andrzej Siewior 162455c52718SAlan Stern } else { /* Self-powered external hub */ 162555c52718SAlan Stern /* FIXME: What about battery-powered external hubs that 162655c52718SAlan Stern * provide less current per port? */ 1627430ee58eSSebastian Andrzej Siewior hub->mA_per_port = full_load; 162855c52718SAlan Stern } 1629430ee58eSSebastian Andrzej Siewior if (hub->mA_per_port < full_load) 163055c52718SAlan Stern dev_dbg(hub_dev, "%umA bus power budget for each child\n", 163155c52718SAlan Stern hub->mA_per_port); 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds ret = hub_hub_status(hub, &hubstatus, &hubchange); 16341da177e4SLinus Torvalds if (ret < 0) { 16351da177e4SLinus Torvalds message = "can't get hub status"; 16361da177e4SLinus Torvalds goto fail; 16371da177e4SLinus Torvalds } 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds /* local power status reports aren't always correct */ 16401da177e4SLinus Torvalds if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER) 16411da177e4SLinus Torvalds dev_dbg(hub_dev, "local power source is %s\n", 16421da177e4SLinus Torvalds (hubstatus & HUB_STATUS_LOCAL_POWER) 16431da177e4SLinus Torvalds ? "lost (inactive)" : "good"); 16441da177e4SLinus Torvalds 164574ad9bd2SGreg Kroah-Hartman if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0) 16461da177e4SLinus Torvalds dev_dbg(hub_dev, "%sover-current condition exists\n", 16471da177e4SLinus Torvalds (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no "); 16481da177e4SLinus Torvalds 164988fafff9Sinaky@linux.intel.com /* set up the interrupt endpoint 165088fafff9Sinaky@linux.intel.com * We use the EP's maxpacket size instead of (PORTS+1+7)/8 165188fafff9Sinaky@linux.intel.com * bytes as USB2.0[11.12.3] says because some hubs are known 165288fafff9Sinaky@linux.intel.com * to send more data (and thus cause overflow). For root hubs, 165388fafff9Sinaky@linux.intel.com * maxpktsize is defined in hcd.c's fake endpoint descriptors 165488fafff9Sinaky@linux.intel.com * to be big enough for at least USB_MAXCHILDREN ports. */ 16551da177e4SLinus Torvalds pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress); 1656dcd2e49bSVincent Mailhol maxp = usb_maxpacket(hdev, pipe); 16571da177e4SLinus Torvalds 16581da177e4SLinus Torvalds if (maxp > sizeof(*hub->buffer)) 16591da177e4SLinus Torvalds maxp = sizeof(*hub->buffer); 16601da177e4SLinus Torvalds 16611da177e4SLinus Torvalds hub->urb = usb_alloc_urb(0, GFP_KERNEL); 16621da177e4SLinus Torvalds if (!hub->urb) { 16631da177e4SLinus Torvalds ret = -ENOMEM; 16641da177e4SLinus Torvalds goto fail; 16651da177e4SLinus Torvalds } 16661da177e4SLinus Torvalds 16671da177e4SLinus Torvalds usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq, 16681da177e4SLinus Torvalds hub, endpoint->bInterval); 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds /* maybe cycle the hub leds */ 16711da177e4SLinus Torvalds if (hub->has_indicators && blinkenlights) 16721da177e4SLinus Torvalds hub->indicator[0] = INDICATOR_CYCLE; 16731da177e4SLinus Torvalds 1674d8521afeSDan Williams mutex_lock(&usb_port_peer_mutex); 1675d8521afeSDan Williams for (i = 0; i < maxchild; i++) { 1676e58547ebSKrzysztof Mazur ret = usb_hub_create_port_device(hub, i + 1); 1677e58547ebSKrzysztof Mazur if (ret < 0) { 1678fa2a9566SLan Tianyu dev_err(hub->intfdev, 1679fa2a9566SLan Tianyu "couldn't create port%d device.\n", i + 1); 1680d8521afeSDan Williams break; 1681d8521afeSDan Williams } 1682d8521afeSDan Williams } 1683e58547ebSKrzysztof Mazur hdev->maxchild = i; 1684e3d10505SDan Williams for (i = 0; i < hdev->maxchild; i++) { 1685e3d10505SDan Williams struct usb_port *port_dev = hub->ports[i]; 1686e3d10505SDan Williams 1687e3d10505SDan Williams pm_runtime_put(&port_dev->dev); 1688e3d10505SDan Williams } 1689e3d10505SDan Williams 1690d8521afeSDan Williams mutex_unlock(&usb_port_peer_mutex); 1691d8521afeSDan Williams if (ret < 0) 1692d8521afeSDan Williams goto fail; 1693fa2a9566SLan Tianyu 169437ebb549SPetr Mladek /* Update the HCD's internal representation of this hub before hub_wq 1695e3d95580SDan Williams * starts getting port status changes for devices under the hub. 1696e3d95580SDan Williams */ 1697e3d95580SDan Williams if (hcd->driver->update_hub_device) { 1698e3d95580SDan Williams ret = hcd->driver->update_hub_device(hcd, hdev, 1699e3d95580SDan Williams &hub->tt, GFP_KERNEL); 1700e3d95580SDan Williams if (ret < 0) { 1701e3d95580SDan Williams message = "can't update HCD hub info"; 1702e3d95580SDan Williams goto fail; 1703e3d95580SDan Williams } 1704e3d95580SDan Williams } 1705e3d95580SDan Williams 1706d2123fd9SLan Tianyu usb_hub_adjust_deviceremovable(hdev, hub->descriptor); 1707d2123fd9SLan Tianyu 1708f2835219SAlan Stern hub_activate(hub, HUB_INIT); 17091da177e4SLinus Torvalds return 0; 17101da177e4SLinus Torvalds 17111da177e4SLinus Torvalds fail: 17121da177e4SLinus Torvalds dev_err(hub_dev, "config failed, %s (err %d)\n", 17131da177e4SLinus Torvalds message, ret); 17141da177e4SLinus Torvalds /* hub_disconnect() frees urb and descriptor */ 17151da177e4SLinus Torvalds return ret; 17161da177e4SLinus Torvalds } 17171da177e4SLinus Torvalds 1718e8054854SAlan Stern static void hub_release(struct kref *kref) 1719e8054854SAlan Stern { 1720e8054854SAlan Stern struct usb_hub *hub = container_of(kref, struct usb_hub, kref); 1721e8054854SAlan Stern 17225d14f323SPetr Mladek usb_put_dev(hub->hdev); 1723e8054854SAlan Stern usb_put_intf(to_usb_interface(hub->intfdev)); 1724e8054854SAlan Stern kfree(hub); 1725e8054854SAlan Stern } 1726e8054854SAlan Stern 17271da177e4SLinus Torvalds static unsigned highspeed_hubs; 17281da177e4SLinus Torvalds 17291da177e4SLinus Torvalds static void hub_disconnect(struct usb_interface *intf) 17301da177e4SLinus Torvalds { 17311da177e4SLinus Torvalds struct usb_hub *hub = usb_get_intfdata(intf); 1732fa286188SGreg Kroah-Hartman struct usb_device *hdev = interface_to_usbdev(intf); 1733543d7784SAlan Stern int port1; 1734fa2a9566SLan Tianyu 173532a69589SPetr Mladek /* 173632a69589SPetr Mladek * Stop adding new hub events. We do not want to block here and thus 173732a69589SPetr Mladek * will not try to remove any pending work item. 173832a69589SPetr Mladek */ 1739e8054854SAlan Stern hub->disconnected = 1; 17401da177e4SLinus Torvalds 17417de18d8bSAlan Stern /* Disconnect all children and quiesce the hub */ 17427de18d8bSAlan Stern hub->error = 0; 17434330354fSAlan Stern hub_quiesce(hub, HUB_DISCONNECT); 17447de18d8bSAlan Stern 1745d8521afeSDan Williams mutex_lock(&usb_port_peer_mutex); 1746d8521afeSDan Williams 1747543d7784SAlan Stern /* Avoid races with recursively_mark_NOTATTACHED() */ 1748543d7784SAlan Stern spin_lock_irq(&device_state_lock); 1749543d7784SAlan Stern port1 = hdev->maxchild; 1750543d7784SAlan Stern hdev->maxchild = 0; 17518b28c752SAlan Stern usb_set_intfdata(intf, NULL); 1752543d7784SAlan Stern spin_unlock_irq(&device_state_lock); 17531f2235b8SAlexander Shishkin 1754543d7784SAlan Stern for (; port1 > 0; --port1) 1755543d7784SAlan Stern usb_hub_remove_port_device(hub, port1); 17561da177e4SLinus Torvalds 1757d8521afeSDan Williams mutex_unlock(&usb_port_peer_mutex); 1758d8521afeSDan Williams 1759e8054854SAlan Stern if (hub->hdev->speed == USB_SPEED_HIGH) 17601da177e4SLinus Torvalds highspeed_hubs--; 17611da177e4SLinus Torvalds 17621da177e4SLinus Torvalds usb_free_urb(hub->urb); 1763fa2a9566SLan Tianyu kfree(hub->ports); 17641da177e4SLinus Torvalds kfree(hub->descriptor); 17651da177e4SLinus Torvalds kfree(hub->status); 1766d697cddaSAlan Stern kfree(hub->buffer); 17671da177e4SLinus Torvalds 1768971fcd49SLan Tianyu pm_suspend_ignore_children(&intf->dev, false); 17691208f9e1SHardik Gajjar 17701208f9e1SHardik Gajjar if (hub->quirk_disable_autosuspend) 17711208f9e1SHardik Gajjar usb_autopm_put_interface(intf); 17721208f9e1SHardik Gajjar 17733a6bf4a0SMatthias Kaehlcke onboard_hub_destroy_pdevs(&hub->onboard_hub_devs); 17743a6bf4a0SMatthias Kaehlcke 1775e8054854SAlan Stern kref_put(&hub->kref, hub_release); 17761da177e4SLinus Torvalds } 17771da177e4SLinus Torvalds 1778c94dc34fSEugene Korenevsky static bool hub_descriptor_is_sane(struct usb_host_interface *desc) 1779c94dc34fSEugene Korenevsky { 1780c94dc34fSEugene Korenevsky /* Some hubs have a subclass of 1, which AFAICT according to the */ 1781c94dc34fSEugene Korenevsky /* specs is not defined, but it works */ 1782c94dc34fSEugene Korenevsky if (desc->desc.bInterfaceSubClass != 0 && 1783c94dc34fSEugene Korenevsky desc->desc.bInterfaceSubClass != 1) 1784c94dc34fSEugene Korenevsky return false; 1785c94dc34fSEugene Korenevsky 1786c94dc34fSEugene Korenevsky /* Multiple endpoints? What kind of mutant ninja-hub is this? */ 1787c94dc34fSEugene Korenevsky if (desc->desc.bNumEndpoints != 1) 1788c94dc34fSEugene Korenevsky return false; 1789c94dc34fSEugene Korenevsky 1790c94dc34fSEugene Korenevsky /* If the first endpoint is not interrupt IN, we'd better punt! */ 1791c94dc34fSEugene Korenevsky if (!usb_endpoint_is_int_in(&desc->endpoint[0].desc)) 1792c94dc34fSEugene Korenevsky return false; 1793c94dc34fSEugene Korenevsky 1794c94dc34fSEugene Korenevsky return true; 1795c94dc34fSEugene Korenevsky } 1796c94dc34fSEugene Korenevsky 17971da177e4SLinus Torvalds static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id) 17981da177e4SLinus Torvalds { 17991da177e4SLinus Torvalds struct usb_host_interface *desc; 18001da177e4SLinus Torvalds struct usb_device *hdev; 18011da177e4SLinus Torvalds struct usb_hub *hub; 18021da177e4SLinus Torvalds 18031da177e4SLinus Torvalds desc = intf->cur_altsetting; 18041da177e4SLinus Torvalds hdev = interface_to_usbdev(intf); 18051da177e4SLinus Torvalds 1806596d789aSMing Lei /* 1807596d789aSMing Lei * Set default autosuspend delay as 0 to speedup bus suspend, 1808596d789aSMing Lei * based on the below considerations: 1809596d789aSMing Lei * 1810596d789aSMing Lei * - Unlike other drivers, the hub driver does not rely on the 1811596d789aSMing Lei * autosuspend delay to provide enough time to handle a wakeup 1812596d789aSMing Lei * event, and the submitted status URB is just to check future 1813596d789aSMing Lei * change on hub downstream ports, so it is safe to do it. 1814596d789aSMing Lei * 1815596d789aSMing Lei * - The patch might cause one or more auto supend/resume for 1816596d789aSMing Lei * below very rare devices when they are plugged into hub 1817596d789aSMing Lei * first time: 1818596d789aSMing Lei * 1819596d789aSMing Lei * devices having trouble initializing, and disconnect 1820596d789aSMing Lei * themselves from the bus and then reconnect a second 1821596d789aSMing Lei * or so later 1822596d789aSMing Lei * 1823596d789aSMing Lei * devices just for downloading firmware, and disconnects 1824596d789aSMing Lei * themselves after completing it 1825596d789aSMing Lei * 1826596d789aSMing Lei * For these quite rare devices, their drivers may change the 1827596d789aSMing Lei * autosuspend delay of their parent hub in the probe() to one 1828596d789aSMing Lei * appropriate value to avoid the subtle problem if someone 1829596d789aSMing Lei * does care it. 1830596d789aSMing Lei * 1831596d789aSMing Lei * - The patch may cause one or more auto suspend/resume on 1832596d789aSMing Lei * hub during running 'lsusb', but it is probably too 1833596d789aSMing Lei * infrequent to worry about. 1834596d789aSMing Lei * 1835596d789aSMing Lei * - Change autosuspend delay of hub can avoid unnecessary auto 1836596d789aSMing Lei * suspend timer for hub, also may decrease power consumption 1837596d789aSMing Lei * of USB bus. 1838bdd405d2SRoger Quadros * 1839bdd405d2SRoger Quadros * - If user has indicated to prevent autosuspend by passing 1840bdd405d2SRoger Quadros * usbcore.autosuspend = -1 then keep autosuspend disabled. 1841596d789aSMing Lei */ 1842ceb6c9c8SRafael J. Wysocki #ifdef CONFIG_PM 1843bdd405d2SRoger Quadros if (hdev->dev.power.autosuspend_delay >= 0) 1844596d789aSMing Lei pm_runtime_set_autosuspend_delay(&hdev->dev, 0); 1845a9ef803dSGreg Kroah-Hartman #endif 1846596d789aSMing Lei 18478ef42dddSAlan Stern /* 18488ef42dddSAlan Stern * Hubs have proper suspend/resume support, except for root hubs 18498ef42dddSAlan Stern * where the controller driver doesn't have bus_suspend and 18508ef42dddSAlan Stern * bus_resume methods. 18518ef42dddSAlan Stern */ 18528ef42dddSAlan Stern if (hdev->parent) { /* normal device */ 1853088f7fecSAlan Stern usb_enable_autosuspend(hdev); 18548ef42dddSAlan Stern } else { /* root hub */ 18558ef42dddSAlan Stern const struct hc_driver *drv = bus_to_hcd(hdev->bus)->driver; 18568ef42dddSAlan Stern 18578ef42dddSAlan Stern if (drv->bus_suspend && drv->bus_resume) 18588ef42dddSAlan Stern usb_enable_autosuspend(hdev); 18598ef42dddSAlan Stern } 1860088f7fecSAlan Stern 186138f3ad5eSFelipe Balbi if (hdev->level == MAX_TOPO_LEVEL) { 1862b9cef6c3SWu Fengguang dev_err(&intf->dev, 1863b9cef6c3SWu Fengguang "Unsupported bus topology: hub nested too deep\n"); 186438f3ad5eSFelipe Balbi return -E2BIG; 186538f3ad5eSFelipe Balbi } 186638f3ad5eSFelipe Balbi 18679af54301SGreg Kroah-Hartman #ifdef CONFIG_USB_OTG_DISABLE_EXTERNAL_HUB 186889ccbdc9SDavid Brownell if (hdev->parent) { 186989ccbdc9SDavid Brownell dev_warn(&intf->dev, "ignoring external hub\n"); 187089ccbdc9SDavid Brownell return -ENODEV; 187189ccbdc9SDavid Brownell } 187289ccbdc9SDavid Brownell #endif 187389ccbdc9SDavid Brownell 1874c94dc34fSEugene Korenevsky if (!hub_descriptor_is_sane(desc)) { 18751da177e4SLinus Torvalds dev_err(&intf->dev, "bad descriptor, ignoring hub\n"); 18761da177e4SLinus Torvalds return -EIO; 18771da177e4SLinus Torvalds } 18781da177e4SLinus Torvalds 18791da177e4SLinus Torvalds /* We found a hub */ 18801da177e4SLinus Torvalds dev_info(&intf->dev, "USB hub found\n"); 18811da177e4SLinus Torvalds 18820a1ef3b5SAlan Stern hub = kzalloc(sizeof(*hub), GFP_KERNEL); 1883b74e7062SWolfram Sang if (!hub) 18841da177e4SLinus Torvalds return -ENOMEM; 18851da177e4SLinus Torvalds 1886e8054854SAlan Stern kref_init(&hub->kref); 18871da177e4SLinus Torvalds hub->intfdev = &intf->dev; 18881da177e4SLinus Torvalds hub->hdev = hdev; 1889c4028958SDavid Howells INIT_DELAYED_WORK(&hub->leds, led_work); 18908520f380SAlan Stern INIT_DELAYED_WORK(&hub->init_work, NULL); 189132a69589SPetr Mladek INIT_WORK(&hub->events, hub_event); 18923a6bf4a0SMatthias Kaehlcke INIT_LIST_HEAD(&hub->onboard_hub_devs); 18938eb58994SNicolas Saenz Julienne spin_lock_init(&hub->irq_urb_lock); 18948eb58994SNicolas Saenz Julienne timer_setup(&hub->irq_urb_retry, hub_retry_irq_urb, 0); 1895e8054854SAlan Stern usb_get_intf(intf); 18965d14f323SPetr Mladek usb_get_dev(hdev); 18971da177e4SLinus Torvalds 18981da177e4SLinus Torvalds usb_set_intfdata(intf, hub); 189940f122f3SAlan Stern intf->needs_remote_wakeup = 1; 1900971fcd49SLan Tianyu pm_suspend_ignore_children(&intf->dev, true); 19011da177e4SLinus Torvalds 19021da177e4SLinus Torvalds if (hdev->speed == USB_SPEED_HIGH) 19031da177e4SLinus Torvalds highspeed_hubs++; 19041da177e4SLinus Torvalds 1905e6f30deaSMing Lei if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND) 1906e6f30deaSMing Lei hub->quirk_check_port_auto_suspend = 1; 1907e6f30deaSMing Lei 19081208f9e1SHardik Gajjar if (id->driver_info & HUB_QUIRK_DISABLE_AUTOSUSPEND) { 19091208f9e1SHardik Gajjar hub->quirk_disable_autosuspend = 1; 191063d6d7edSEugeniu Rosca usb_autopm_get_interface_no_resume(intf); 19111208f9e1SHardik Gajjar } 19121208f9e1SHardik Gajjar 1913915d900fSHardik Gajjar if ((id->driver_info & HUB_QUIRK_REDUCE_FRAME_INTR_BINTERVAL) && 1914915d900fSHardik Gajjar desc->endpoint[0].desc.bInterval > USB_REDUCE_FRAME_INTR_BINTERVAL) { 1915915d900fSHardik Gajjar desc->endpoint[0].desc.bInterval = 1916915d900fSHardik Gajjar USB_REDUCE_FRAME_INTR_BINTERVAL; 1917915d900fSHardik Gajjar /* Tell the HCD about the interrupt ep's new bInterval */ 1918915d900fSHardik Gajjar usb_set_interface(hdev, 0, 0); 1919915d900fSHardik Gajjar } 1920915d900fSHardik Gajjar 19213a6bf4a0SMatthias Kaehlcke if (hub_configure(hub, &desc->endpoint[0].desc) >= 0) { 19223a6bf4a0SMatthias Kaehlcke onboard_hub_create_pdevs(hdev, &hub->onboard_hub_devs); 19233a6bf4a0SMatthias Kaehlcke 19241da177e4SLinus Torvalds return 0; 19253a6bf4a0SMatthias Kaehlcke } 19261da177e4SLinus Torvalds 19271da177e4SLinus Torvalds hub_disconnect(intf); 19281da177e4SLinus Torvalds return -ENODEV; 19291da177e4SLinus Torvalds } 19301da177e4SLinus Torvalds 19311da177e4SLinus Torvalds static int 19321da177e4SLinus Torvalds hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data) 19331da177e4SLinus Torvalds { 19341da177e4SLinus Torvalds struct usb_device *hdev = interface_to_usbdev(intf); 1935ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 19361da177e4SLinus Torvalds 19371da177e4SLinus Torvalds /* assert ifno == 0 (part of hub spec) */ 19381da177e4SLinus Torvalds switch (code) { 19391da177e4SLinus Torvalds case USBDEVFS_HUB_PORTINFO: { 19401da177e4SLinus Torvalds struct usbdevfs_hub_portinfo *info = user_data; 19411da177e4SLinus Torvalds int i; 19421da177e4SLinus Torvalds 19431da177e4SLinus Torvalds spin_lock_irq(&device_state_lock); 19441da177e4SLinus Torvalds if (hdev->devnum <= 0) 19451da177e4SLinus Torvalds info->nports = 0; 19461da177e4SLinus Torvalds else { 19471da177e4SLinus Torvalds info->nports = hdev->maxchild; 19481da177e4SLinus Torvalds for (i = 0; i < info->nports; i++) { 1949ff823c79SLan Tianyu if (hub->ports[i]->child == NULL) 19501da177e4SLinus Torvalds info->port[i] = 0; 19511da177e4SLinus Torvalds else 19521da177e4SLinus Torvalds info->port[i] = 1953ff823c79SLan Tianyu hub->ports[i]->child->devnum; 19541da177e4SLinus Torvalds } 19551da177e4SLinus Torvalds } 19561da177e4SLinus Torvalds spin_unlock_irq(&device_state_lock); 19571da177e4SLinus Torvalds 19581da177e4SLinus Torvalds return info->nports + 1; 19591da177e4SLinus Torvalds } 19601da177e4SLinus Torvalds 19611da177e4SLinus Torvalds default: 19621da177e4SLinus Torvalds return -ENOSYS; 19631da177e4SLinus Torvalds } 19641da177e4SLinus Torvalds } 19651da177e4SLinus Torvalds 19667cbe5dcaSAlan Stern /* 19677cbe5dcaSAlan Stern * Allow user programs to claim ports on a hub. When a device is attached 19687cbe5dcaSAlan Stern * to one of these "claimed" ports, the program will "own" the device. 19697cbe5dcaSAlan Stern */ 19707cbe5dcaSAlan Stern static int find_port_owner(struct usb_device *hdev, unsigned port1, 19719b6f0c4bSValentina Manea struct usb_dev_state ***ppowner) 19727cbe5dcaSAlan Stern { 197341341261SMathias Nyman struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 197441341261SMathias Nyman 19757cbe5dcaSAlan Stern if (hdev->state == USB_STATE_NOTATTACHED) 19767cbe5dcaSAlan Stern return -ENODEV; 19777cbe5dcaSAlan Stern if (port1 == 0 || port1 > hdev->maxchild) 19787cbe5dcaSAlan Stern return -EINVAL; 19797cbe5dcaSAlan Stern 198041341261SMathias Nyman /* Devices not managed by the hub driver 19817cbe5dcaSAlan Stern * will always have maxchild equal to 0. 19827cbe5dcaSAlan Stern */ 198341341261SMathias Nyman *ppowner = &(hub->ports[port1 - 1]->port_owner); 19847cbe5dcaSAlan Stern return 0; 19857cbe5dcaSAlan Stern } 19867cbe5dcaSAlan Stern 19877cbe5dcaSAlan Stern /* In the following three functions, the caller must hold hdev's lock */ 1988336c5c31SLan Tianyu int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, 19899b6f0c4bSValentina Manea struct usb_dev_state *owner) 19907cbe5dcaSAlan Stern { 19917cbe5dcaSAlan Stern int rc; 19929b6f0c4bSValentina Manea struct usb_dev_state **powner; 19937cbe5dcaSAlan Stern 19947cbe5dcaSAlan Stern rc = find_port_owner(hdev, port1, &powner); 19957cbe5dcaSAlan Stern if (rc) 19967cbe5dcaSAlan Stern return rc; 19977cbe5dcaSAlan Stern if (*powner) 19987cbe5dcaSAlan Stern return -EBUSY; 19997cbe5dcaSAlan Stern *powner = owner; 20007cbe5dcaSAlan Stern return rc; 20017cbe5dcaSAlan Stern } 20026080cd0eSValentina Manea EXPORT_SYMBOL_GPL(usb_hub_claim_port); 20037cbe5dcaSAlan Stern 2004336c5c31SLan Tianyu int usb_hub_release_port(struct usb_device *hdev, unsigned port1, 20059b6f0c4bSValentina Manea struct usb_dev_state *owner) 20067cbe5dcaSAlan Stern { 20077cbe5dcaSAlan Stern int rc; 20089b6f0c4bSValentina Manea struct usb_dev_state **powner; 20097cbe5dcaSAlan Stern 20107cbe5dcaSAlan Stern rc = find_port_owner(hdev, port1, &powner); 20117cbe5dcaSAlan Stern if (rc) 20127cbe5dcaSAlan Stern return rc; 20137cbe5dcaSAlan Stern if (*powner != owner) 20147cbe5dcaSAlan Stern return -ENOENT; 20157cbe5dcaSAlan Stern *powner = NULL; 20167cbe5dcaSAlan Stern return rc; 20177cbe5dcaSAlan Stern } 20186080cd0eSValentina Manea EXPORT_SYMBOL_GPL(usb_hub_release_port); 20197cbe5dcaSAlan Stern 20209b6f0c4bSValentina Manea void usb_hub_release_all_ports(struct usb_device *hdev, struct usb_dev_state *owner) 20217cbe5dcaSAlan Stern { 2022ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 20237cbe5dcaSAlan Stern int n; 20247cbe5dcaSAlan Stern 2025fa2a9566SLan Tianyu for (n = 0; n < hdev->maxchild; n++) { 2026fa2a9566SLan Tianyu if (hub->ports[n]->port_owner == owner) 2027fa2a9566SLan Tianyu hub->ports[n]->port_owner = NULL; 20287cbe5dcaSAlan Stern } 2029fa2a9566SLan Tianyu 20307cbe5dcaSAlan Stern } 20317cbe5dcaSAlan Stern 20327cbe5dcaSAlan Stern /* The caller must hold udev's lock */ 20337cbe5dcaSAlan Stern bool usb_device_is_owned(struct usb_device *udev) 20347cbe5dcaSAlan Stern { 20357cbe5dcaSAlan Stern struct usb_hub *hub; 20367cbe5dcaSAlan Stern 20377cbe5dcaSAlan Stern if (udev->state == USB_STATE_NOTATTACHED || !udev->parent) 20387cbe5dcaSAlan Stern return false; 2039ad493e5eSLan Tianyu hub = usb_hub_to_struct_hub(udev->parent); 2040fa2a9566SLan Tianyu return !!hub->ports[udev->portnum - 1]->port_owner; 20417cbe5dcaSAlan Stern } 20427cbe5dcaSAlan Stern 204383cb2604SRoy Luo static void update_port_device_state(struct usb_device *udev) 204483cb2604SRoy Luo { 204583cb2604SRoy Luo struct usb_hub *hub; 204683cb2604SRoy Luo struct usb_port *port_dev; 204783cb2604SRoy Luo 204883cb2604SRoy Luo if (udev->parent) { 204983cb2604SRoy Luo hub = usb_hub_to_struct_hub(udev->parent); 2050*ed85777cSUdipto Goswami 2051*ed85777cSUdipto Goswami /* 2052*ed85777cSUdipto Goswami * The Link Layer Validation System Driver (lvstest) 2053*ed85777cSUdipto Goswami * has a test step to unbind the hub before running the 2054*ed85777cSUdipto Goswami * rest of the procedure. This triggers hub_disconnect 2055*ed85777cSUdipto Goswami * which will set the hub's maxchild to 0, further 2056*ed85777cSUdipto Goswami * resulting in usb_hub_to_struct_hub returning NULL. 2057*ed85777cSUdipto Goswami */ 2058*ed85777cSUdipto Goswami if (hub) { 205983cb2604SRoy Luo port_dev = hub->ports[udev->portnum - 1]; 206083cb2604SRoy Luo WRITE_ONCE(port_dev->state, udev->state); 206183cb2604SRoy Luo sysfs_notify_dirent(port_dev->state_kn); 206283cb2604SRoy Luo } 206383cb2604SRoy Luo } 2064*ed85777cSUdipto Goswami } 206583cb2604SRoy Luo 20661da177e4SLinus Torvalds static void recursively_mark_NOTATTACHED(struct usb_device *udev) 20671da177e4SLinus Torvalds { 2068ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(udev); 20691da177e4SLinus Torvalds int i; 20701da177e4SLinus Torvalds 20711da177e4SLinus Torvalds for (i = 0; i < udev->maxchild; ++i) { 2072ff823c79SLan Tianyu if (hub->ports[i]->child) 2073ff823c79SLan Tianyu recursively_mark_NOTATTACHED(hub->ports[i]->child); 20741da177e4SLinus Torvalds } 20759bbdf1e0SAlan Stern if (udev->state == USB_STATE_SUSPENDED) 207615123006SSarah Sharp udev->active_duration -= jiffies; 20771da177e4SLinus Torvalds udev->state = USB_STATE_NOTATTACHED; 207883cb2604SRoy Luo update_port_device_state(udev); 20791da177e4SLinus Torvalds } 20801da177e4SLinus Torvalds 20811da177e4SLinus Torvalds /** 20821da177e4SLinus Torvalds * usb_set_device_state - change a device's current state (usbcore, hcds) 20831da177e4SLinus Torvalds * @udev: pointer to device whose state should be changed 20841da177e4SLinus Torvalds * @new_state: new state value to be stored 20851da177e4SLinus Torvalds * 20861da177e4SLinus Torvalds * udev->state is _not_ fully protected by the device lock. Although 20871da177e4SLinus Torvalds * most transitions are made only while holding the lock, the state can 20881da177e4SLinus Torvalds * can change to USB_STATE_NOTATTACHED at almost any time. This 20891da177e4SLinus Torvalds * is so that devices can be marked as disconnected as soon as possible, 20901da177e4SLinus Torvalds * without having to wait for any semaphores to be released. As a result, 20911da177e4SLinus Torvalds * all changes to any device's state must be protected by the 20921da177e4SLinus Torvalds * device_state_lock spinlock. 20931da177e4SLinus Torvalds * 20941da177e4SLinus Torvalds * Once a device has been added to the device tree, all changes to its state 20951da177e4SLinus Torvalds * should be made using this routine. The state should _not_ be set directly. 20961da177e4SLinus Torvalds * 20971da177e4SLinus Torvalds * If udev->state is already USB_STATE_NOTATTACHED then no change is made. 20981da177e4SLinus Torvalds * Otherwise udev->state is set to new_state, and if new_state is 20991da177e4SLinus Torvalds * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set 21001da177e4SLinus Torvalds * to USB_STATE_NOTATTACHED. 21011da177e4SLinus Torvalds */ 21021da177e4SLinus Torvalds void usb_set_device_state(struct usb_device *udev, 21031da177e4SLinus Torvalds enum usb_device_state new_state) 21041da177e4SLinus Torvalds { 21051da177e4SLinus Torvalds unsigned long flags; 21064681b171SRafael J. Wysocki int wakeup = -1; 21071da177e4SLinus Torvalds 21081da177e4SLinus Torvalds spin_lock_irqsave(&device_state_lock, flags); 21091da177e4SLinus Torvalds if (udev->state == USB_STATE_NOTATTACHED) 21101da177e4SLinus Torvalds ; /* do nothing */ 2111b94dc6b5SDavid Brownell else if (new_state != USB_STATE_NOTATTACHED) { 2112fb669cc0SDavid Brownell 2113fb669cc0SDavid Brownell /* root hub wakeup capabilities are managed out-of-band 2114fb669cc0SDavid Brownell * and may involve silicon errata ... ignore them here. 2115fb669cc0SDavid Brownell */ 2116fb669cc0SDavid Brownell if (udev->parent) { 2117645daaabSAlan Stern if (udev->state == USB_STATE_SUSPENDED 2118645daaabSAlan Stern || new_state == USB_STATE_SUSPENDED) 2119645daaabSAlan Stern ; /* No change to wakeup settings */ 2120645daaabSAlan Stern else if (new_state == USB_STATE_CONFIGURED) 2121ddbe1fcaSLu Baolu wakeup = (udev->quirks & 2122ddbe1fcaSLu Baolu USB_QUIRK_IGNORE_REMOTE_WAKEUP) ? 0 : 2123ddbe1fcaSLu Baolu udev->actconfig->desc.bmAttributes & 2124ddbe1fcaSLu Baolu USB_CONFIG_ATT_WAKEUP; 2125645daaabSAlan Stern else 21264681b171SRafael J. Wysocki wakeup = 0; 2127fb669cc0SDavid Brownell } 212815123006SSarah Sharp if (udev->state == USB_STATE_SUSPENDED && 212915123006SSarah Sharp new_state != USB_STATE_SUSPENDED) 213015123006SSarah Sharp udev->active_duration -= jiffies; 213115123006SSarah Sharp else if (new_state == USB_STATE_SUSPENDED && 213215123006SSarah Sharp udev->state != USB_STATE_SUSPENDED) 213315123006SSarah Sharp udev->active_duration += jiffies; 2134645daaabSAlan Stern udev->state = new_state; 213583cb2604SRoy Luo update_port_device_state(udev); 2136b94dc6b5SDavid Brownell } else 21371da177e4SLinus Torvalds recursively_mark_NOTATTACHED(udev); 21381da177e4SLinus Torvalds spin_unlock_irqrestore(&device_state_lock, flags); 21394681b171SRafael J. Wysocki if (wakeup >= 0) 21404681b171SRafael J. Wysocki device_set_wakeup_capable(&udev->dev, wakeup); 21411da177e4SLinus Torvalds } 21426da9c990SDavid Vrabel EXPORT_SYMBOL_GPL(usb_set_device_state); 21431da177e4SLinus Torvalds 21448af548dcSInaky Perez-Gonzalez /* 21453b29b68bSAlan Stern * Choose a device number. 21463b29b68bSAlan Stern * 21473b29b68bSAlan Stern * Device numbers are used as filenames in usbfs. On USB-1.1 and 21483b29b68bSAlan Stern * USB-2.0 buses they are also used as device addresses, however on 21493b29b68bSAlan Stern * USB-3.0 buses the address is assigned by the controller hardware 21503b29b68bSAlan Stern * and it usually is not the same as the device number. 21513b29b68bSAlan Stern * 2152c6515272SSarah Sharp * Devices connected under xHCI are not as simple. The host controller 2153c6515272SSarah Sharp * supports virtualization, so the hardware assigns device addresses and 2154c6515272SSarah Sharp * the HCD must setup data structures before issuing a set address 2155c6515272SSarah Sharp * command to the hardware. 21568af548dcSInaky Perez-Gonzalez */ 21573b29b68bSAlan Stern static void choose_devnum(struct usb_device *udev) 21581da177e4SLinus Torvalds { 21591da177e4SLinus Torvalds int devnum; 21601da177e4SLinus Torvalds struct usb_bus *bus = udev->bus; 21611da177e4SLinus Torvalds 2162638139ebSPetr Mladek /* be safe when more hub events are proceed in parallel */ 2163feb26ac3SChris Bainbridge mutex_lock(&bus->devnum_next_mutex); 21641e4c5742SAlan Stern 21651e4c5742SAlan Stern /* Try to allocate the next devnum beginning at bus->devnum_next. */ 21661da177e4SLinus Torvalds devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 21671da177e4SLinus Torvalds bus->devnum_next); 21681da177e4SLinus Torvalds if (devnum >= 128) 21691e4c5742SAlan Stern devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 1); 21701da177e4SLinus Torvalds bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1); 21711da177e4SLinus Torvalds if (devnum < 128) { 21721da177e4SLinus Torvalds set_bit(devnum, bus->devmap.devicemap); 21731da177e4SLinus Torvalds udev->devnum = devnum; 21741da177e4SLinus Torvalds } 2175feb26ac3SChris Bainbridge mutex_unlock(&bus->devnum_next_mutex); 21761da177e4SLinus Torvalds } 21771da177e4SLinus Torvalds 21783b29b68bSAlan Stern static void release_devnum(struct usb_device *udev) 21791da177e4SLinus Torvalds { 21801da177e4SLinus Torvalds if (udev->devnum > 0) { 21811da177e4SLinus Torvalds clear_bit(udev->devnum, udev->bus->devmap.devicemap); 21821da177e4SLinus Torvalds udev->devnum = -1; 21831da177e4SLinus Torvalds } 21841da177e4SLinus Torvalds } 21851da177e4SLinus Torvalds 21863b29b68bSAlan Stern static void update_devnum(struct usb_device *udev, int devnum) 21874953d141SDavid Vrabel { 21884953d141SDavid Vrabel udev->devnum = devnum; 21894998f1efSJim Lin if (!udev->devaddr) 21904998f1efSJim Lin udev->devaddr = (u8)devnum; 21914953d141SDavid Vrabel } 21924953d141SDavid Vrabel 2193f7410cedSHerbert Xu static void hub_free_dev(struct usb_device *udev) 2194f7410cedSHerbert Xu { 2195f7410cedSHerbert Xu struct usb_hcd *hcd = bus_to_hcd(udev->bus); 2196f7410cedSHerbert Xu 2197f7410cedSHerbert Xu /* Root hubs aren't real devices, so don't free HCD resources */ 2198f7410cedSHerbert Xu if (hcd->driver->free_dev && udev->parent) 2199f7410cedSHerbert Xu hcd->driver->free_dev(hcd, udev); 2200f7410cedSHerbert Xu } 2201f7410cedSHerbert Xu 22027027df36SDan Williams static void hub_disconnect_children(struct usb_device *udev) 22037027df36SDan Williams { 22047027df36SDan Williams struct usb_hub *hub = usb_hub_to_struct_hub(udev); 22057027df36SDan Williams int i; 22067027df36SDan Williams 22077027df36SDan Williams /* Free up all the children before we remove this device */ 22087027df36SDan Williams for (i = 0; i < udev->maxchild; i++) { 22097027df36SDan Williams if (hub->ports[i]->child) 22107027df36SDan Williams usb_disconnect(&hub->ports[i]->child); 22117027df36SDan Williams } 22127027df36SDan Williams } 22137027df36SDan Williams 22141da177e4SLinus Torvalds /** 22151da177e4SLinus Torvalds * usb_disconnect - disconnect a device (usbcore-internal) 22161da177e4SLinus Torvalds * @pdev: pointer to device being disconnected 221741631d36SAhmed S. Darwish * 221841631d36SAhmed S. Darwish * Context: task context, might sleep 22191da177e4SLinus Torvalds * 22201da177e4SLinus Torvalds * Something got disconnected. Get rid of it and all of its children. 22211da177e4SLinus Torvalds * 22221da177e4SLinus Torvalds * If *pdev is a normal device then the parent hub must already be locked. 2223a4b5d606SHeiner Kallweit * If *pdev is a root hub then the caller must hold the usb_bus_idr_lock, 2224db8f2aa3SBjorn Helgaas * which protects the set of root hubs as well as the list of buses. 22251da177e4SLinus Torvalds * 22261da177e4SLinus Torvalds * Only hub drivers (including virtual root hub drivers for host 22271da177e4SLinus Torvalds * controllers) should ever call this. 22281da177e4SLinus Torvalds * 22291da177e4SLinus Torvalds * This call is synchronous, and may not be used in an interrupt context. 22301da177e4SLinus Torvalds */ 22311da177e4SLinus Torvalds void usb_disconnect(struct usb_device **pdev) 22321da177e4SLinus Torvalds { 22337027df36SDan Williams struct usb_port *port_dev = NULL; 22341da177e4SLinus Torvalds struct usb_device *udev = *pdev; 22355b1dc209SPeter Chen struct usb_hub *hub = NULL; 22365b1dc209SPeter Chen int port1 = 1; 22371da177e4SLinus Torvalds 22381da177e4SLinus Torvalds /* mark the device as inactive, so any further urb submissions for 22391da177e4SLinus Torvalds * this device (and any of its children) will fail immediately. 224025985edcSLucas De Marchi * this quiesces everything except pending urbs. 22411da177e4SLinus Torvalds */ 22421da177e4SLinus Torvalds usb_set_device_state(udev, USB_STATE_NOTATTACHED); 22433b29b68bSAlan Stern dev_info(&udev->dev, "USB disconnect, device number %d\n", 22443b29b68bSAlan Stern udev->devnum); 22451da177e4SLinus Torvalds 2246f5cccf49SGuenter Roeck /* 2247f5cccf49SGuenter Roeck * Ensure that the pm runtime code knows that the USB device 2248f5cccf49SGuenter Roeck * is in the process of being disconnected. 2249f5cccf49SGuenter Roeck */ 2250f5cccf49SGuenter Roeck pm_runtime_barrier(&udev->dev); 2251f5cccf49SGuenter Roeck 22529ad3d6ccSAlan Stern usb_lock_device(udev); 22539ad3d6ccSAlan Stern 22547027df36SDan Williams hub_disconnect_children(udev); 22551da177e4SLinus Torvalds 22561da177e4SLinus Torvalds /* deallocate hcd/hardware state ... nuking all pending urbs and 22571da177e4SLinus Torvalds * cleaning up all state associated with the current configuration 22581da177e4SLinus Torvalds * so that the hardware is now fully quiesced. 22591da177e4SLinus Torvalds */ 2260782da727SAlan Stern dev_dbg(&udev->dev, "unregistering device\n"); 22611da177e4SLinus Torvalds usb_disable_device(udev, 0); 2262cde217a5SAlan Stern usb_hcd_synchronize_unlinks(udev); 22631da177e4SLinus Torvalds 2264fde26380SLan Tianyu if (udev->parent) { 22657027df36SDan Williams port1 = udev->portnum; 22667027df36SDan Williams hub = usb_hub_to_struct_hub(udev->parent); 22677027df36SDan Williams port_dev = hub->ports[port1 - 1]; 2268fde26380SLan Tianyu 2269fde26380SLan Tianyu sysfs_remove_link(&udev->dev.kobj, "port"); 2270fde26380SLan Tianyu sysfs_remove_link(&port_dev->dev.kobj, "device"); 2271971fcd49SLan Tianyu 22727027df36SDan Williams /* 22737027df36SDan Williams * As usb_port_runtime_resume() de-references udev, make 22747027df36SDan Williams * sure no resumes occur during removal 22757027df36SDan Williams */ 22767027df36SDan Williams if (!test_and_set_bit(port1, hub->child_usage_bits)) 22777027df36SDan Williams pm_runtime_get_sync(&port_dev->dev); 2278fde26380SLan Tianyu } 2279fde26380SLan Tianyu 22803b23dd6fSAlan Stern usb_remove_ep_devs(&udev->ep0); 2281782da727SAlan Stern usb_unlock_device(udev); 22823099e75aSGreg Kroah-Hartman 2283782da727SAlan Stern /* Unregister the device. The device driver is responsible 22843b23dd6fSAlan Stern * for de-configuring the device and invoking the remove-device 22853b23dd6fSAlan Stern * notifier chain (used by usbfs and possibly others). 2286782da727SAlan Stern */ 2287782da727SAlan Stern device_del(&udev->dev); 2288782da727SAlan Stern 2289782da727SAlan Stern /* Free the device number and delete the parent's children[] 22901da177e4SLinus Torvalds * (or root_hub) pointer. 22911da177e4SLinus Torvalds */ 22923b29b68bSAlan Stern release_devnum(udev); 22931da177e4SLinus Torvalds 22941da177e4SLinus Torvalds /* Avoid races with recursively_mark_NOTATTACHED() */ 22951da177e4SLinus Torvalds spin_lock_irq(&device_state_lock); 22961da177e4SLinus Torvalds *pdev = NULL; 22971da177e4SLinus Torvalds spin_unlock_irq(&device_state_lock); 22981da177e4SLinus Torvalds 22997027df36SDan Williams if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits)) 23007027df36SDan Williams pm_runtime_put(&port_dev->dev); 23017027df36SDan Williams 2302f7410cedSHerbert Xu hub_free_dev(udev); 2303f7410cedSHerbert Xu 2304782da727SAlan Stern put_device(&udev->dev); 23051da177e4SLinus Torvalds } 23061da177e4SLinus Torvalds 2307f2a383e4SGreg Kroah-Hartman #ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES 23081da177e4SLinus Torvalds static void show_string(struct usb_device *udev, char *id, char *string) 23091da177e4SLinus Torvalds { 23101da177e4SLinus Torvalds if (!string) 23111da177e4SLinus Torvalds return; 2312f2ec522eSJoe Perches dev_info(&udev->dev, "%s: %s\n", id, string); 23131da177e4SLinus Torvalds } 23141da177e4SLinus Torvalds 2315f2a383e4SGreg Kroah-Hartman static void announce_device(struct usb_device *udev) 2316f2a383e4SGreg Kroah-Hartman { 231773c6d3b2SBenson Leung u16 bcdDevice = le16_to_cpu(udev->descriptor.bcdDevice); 231873c6d3b2SBenson Leung 231973c6d3b2SBenson Leung dev_info(&udev->dev, 232073c6d3b2SBenson Leung "New USB device found, idVendor=%04x, idProduct=%04x, bcdDevice=%2x.%02x\n", 2321f2a383e4SGreg Kroah-Hartman le16_to_cpu(udev->descriptor.idVendor), 232273c6d3b2SBenson Leung le16_to_cpu(udev->descriptor.idProduct), 232373c6d3b2SBenson Leung bcdDevice >> 8, bcdDevice & 0xff); 2324b9cef6c3SWu Fengguang dev_info(&udev->dev, 2325b9cef6c3SWu Fengguang "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n", 2326f2a383e4SGreg Kroah-Hartman udev->descriptor.iManufacturer, 2327f2a383e4SGreg Kroah-Hartman udev->descriptor.iProduct, 2328f2a383e4SGreg Kroah-Hartman udev->descriptor.iSerialNumber); 2329f2a383e4SGreg Kroah-Hartman show_string(udev, "Product", udev->product); 2330f2a383e4SGreg Kroah-Hartman show_string(udev, "Manufacturer", udev->manufacturer); 2331f2a383e4SGreg Kroah-Hartman show_string(udev, "SerialNumber", udev->serial); 2332f2a383e4SGreg Kroah-Hartman } 23331da177e4SLinus Torvalds #else 2334f2a383e4SGreg Kroah-Hartman static inline void announce_device(struct usb_device *udev) { } 23351da177e4SLinus Torvalds #endif 23361da177e4SLinus Torvalds 23371da177e4SLinus Torvalds 23383ede760fSOliver Neukum /** 23398d8558d1SAlan Stern * usb_enumerate_device_otg - FIXME (usbcore-internal) 23403ede760fSOliver Neukum * @udev: newly addressed device (in ADDRESS state) 23413ede760fSOliver Neukum * 23428d8558d1SAlan Stern * Finish enumeration for On-The-Go devices 2343626f090cSYacine Belkadi * 2344626f090cSYacine Belkadi * Return: 0 if successful. A negative error code otherwise. 23453ede760fSOliver Neukum */ 23468d8558d1SAlan Stern static int usb_enumerate_device_otg(struct usb_device *udev) 23471da177e4SLinus Torvalds { 2348d9d16e8aSInaky Perez-Gonzalez int err = 0; 23491da177e4SLinus Torvalds 23501da177e4SLinus Torvalds #ifdef CONFIG_USB_OTG 23511da177e4SLinus Torvalds /* 23521da177e4SLinus Torvalds * OTG-aware devices on OTG-capable root hubs may be able to use SRP, 23531da177e4SLinus Torvalds * to wake us after we've powered off VBUS; and HNP, switching roles 23541da177e4SLinus Torvalds * "host" to "peripheral". The OTG descriptor helps figure this out. 23551da177e4SLinus Torvalds */ 23561da177e4SLinus Torvalds if (!udev->bus->is_b_host 23571da177e4SLinus Torvalds && udev->config 23581da177e4SLinus Torvalds && udev->parent == udev->bus->root_hub) { 23592eb5052eSFelipe Balbi struct usb_otg_descriptor *desc = NULL; 23601da177e4SLinus Torvalds struct usb_bus *bus = udev->bus; 236112c3da34SAlan Stern unsigned port1 = udev->portnum; 23621da177e4SLinus Torvalds 23637d2d641cSLi Jun /* descriptor may appear anywhere in config */ 23647d2d641cSLi Jun err = __usb_get_extra_descriptor(udev->rawdescriptors[0], 23657d2d641cSLi Jun le16_to_cpu(udev->config[0].desc.wTotalLength), 2366704620afSMathias Payer USB_DT_OTG, (void **) &desc, sizeof(*desc)); 23677d2d641cSLi Jun if (err || !(desc->bmAttributes & USB_OTG_HNP)) 23687d2d641cSLi Jun return 0; 23697d2d641cSLi Jun 23707d2d641cSLi Jun dev_info(&udev->dev, "Dual-Role OTG device on %sHNP port\n", 23717d2d641cSLi Jun (port1 == bus->otg_port) ? "" : "non-"); 23721da177e4SLinus Torvalds 23731da177e4SLinus Torvalds /* enable HNP before suspend, it's simpler */ 23747d2d641cSLi Jun if (port1 == bus->otg_port) { 23751da177e4SLinus Torvalds bus->b_hnp_enable = 1; 23761afe33a7SOliver Neukum err = usb_control_msg(udev, 23771afe33a7SOliver Neukum usb_sndctrlpipe(udev, 0), 23781afe33a7SOliver Neukum USB_REQ_SET_FEATURE, 0, 23791afe33a7SOliver Neukum USB_DEVICE_B_HNP_ENABLE, 23801afe33a7SOliver Neukum 0, NULL, 0, 23811afe33a7SOliver Neukum USB_CTRL_SET_TIMEOUT); 23821afe33a7SOliver Neukum if (err < 0) { 23837d2d641cSLi Jun /* 23847d2d641cSLi Jun * OTG MESSAGE: report errors here, 23851da177e4SLinus Torvalds * customize to match your product. 23861da177e4SLinus Torvalds */ 23877d2d641cSLi Jun dev_err(&udev->dev, "can't set HNP mode: %d\n", 23881da177e4SLinus Torvalds err); 23891da177e4SLinus Torvalds bus->b_hnp_enable = 0; 23901da177e4SLinus Torvalds } 23917d2d641cSLi Jun } else if (desc->bLength == sizeof 23927d2d641cSLi Jun (struct usb_otg_descriptor)) { 2393eafeda9eSOliver Neukum /* 2394eafeda9eSOliver Neukum * We are operating on a legacy OTP device 2395eafeda9eSOliver Neukum * These should be told that they are operating 2396eafeda9eSOliver Neukum * on the wrong port if we have another port that does 2397eafeda9eSOliver Neukum * support HNP 2398eafeda9eSOliver Neukum */ 2399eafeda9eSOliver Neukum if (bus->otg_port != 0) { 24007d2d641cSLi Jun /* Set a_alt_hnp_support for legacy otg device */ 24011afe33a7SOliver Neukum err = usb_control_msg(udev, 24021afe33a7SOliver Neukum usb_sndctrlpipe(udev, 0), 24031afe33a7SOliver Neukum USB_REQ_SET_FEATURE, 0, 24041afe33a7SOliver Neukum USB_DEVICE_A_ALT_HNP_SUPPORT, 24051afe33a7SOliver Neukum 0, NULL, 0, 24061afe33a7SOliver Neukum USB_CTRL_SET_TIMEOUT); 24071afe33a7SOliver Neukum if (err < 0) 24087d2d641cSLi Jun dev_err(&udev->dev, 24097d2d641cSLi Jun "set a_alt_hnp_support failed: %d\n", 24107d2d641cSLi Jun err); 24111da177e4SLinus Torvalds } 24121da177e4SLinus Torvalds } 2413eafeda9eSOliver Neukum } 24141da177e4SLinus Torvalds #endif 2415d9d16e8aSInaky Perez-Gonzalez return err; 2416d9d16e8aSInaky Perez-Gonzalez } 24171da177e4SLinus Torvalds 2418d9d16e8aSInaky Perez-Gonzalez 2419d9d16e8aSInaky Perez-Gonzalez /** 24208d8558d1SAlan Stern * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal) 2421d9d16e8aSInaky Perez-Gonzalez * @udev: newly addressed device (in ADDRESS state) 2422d9d16e8aSInaky Perez-Gonzalez * 242345bf39f8SAlan Stern * This is only called by usb_new_device() -- all comments that apply there 242445bf39f8SAlan Stern * apply here wrt to environment. 2425d9d16e8aSInaky Perez-Gonzalez * 2426d9d16e8aSInaky Perez-Gonzalez * If the device is WUSB and not authorized, we don't attempt to read 2427d9d16e8aSInaky Perez-Gonzalez * the string descriptors, as they will be errored out by the device 2428d9d16e8aSInaky Perez-Gonzalez * until it has been authorized. 2429626f090cSYacine Belkadi * 2430626f090cSYacine Belkadi * Return: 0 if successful. A negative error code otherwise. 2431d9d16e8aSInaky Perez-Gonzalez */ 24328d8558d1SAlan Stern static int usb_enumerate_device(struct usb_device *udev) 2433d9d16e8aSInaky Perez-Gonzalez { 2434d9d16e8aSInaky Perez-Gonzalez int err; 2435026f3fcbSPeter Chen struct usb_hcd *hcd = bus_to_hcd(udev->bus); 2436d9d16e8aSInaky Perez-Gonzalez 2437d9d16e8aSInaky Perez-Gonzalez if (udev->config == NULL) { 2438d9d16e8aSInaky Perez-Gonzalez err = usb_get_configuration(udev); 2439d9d16e8aSInaky Perez-Gonzalez if (err < 0) { 2440e9e88fb7SAlan Stern if (err != -ENODEV) 2441d9d16e8aSInaky Perez-Gonzalez dev_err(&udev->dev, "can't read configurations, error %d\n", 2442d9d16e8aSInaky Perez-Gonzalez err); 244380da2e0dSLaurent Pinchart return err; 2444d9d16e8aSInaky Perez-Gonzalez } 2445d9d16e8aSInaky Perez-Gonzalez } 244683e83ecbSThomas Pugliese 2447d9d16e8aSInaky Perez-Gonzalez /* read the standard strings and cache them if present */ 2448d9d16e8aSInaky Perez-Gonzalez udev->product = usb_cache_string(udev, udev->descriptor.iProduct); 2449d9d16e8aSInaky Perez-Gonzalez udev->manufacturer = usb_cache_string(udev, 2450d9d16e8aSInaky Perez-Gonzalez udev->descriptor.iManufacturer); 2451d9d16e8aSInaky Perez-Gonzalez udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber); 245283e83ecbSThomas Pugliese 24538d8558d1SAlan Stern err = usb_enumerate_device_otg(udev); 245480da2e0dSLaurent Pinchart if (err < 0) 2455d9d16e8aSInaky Perez-Gonzalez return err; 245680da2e0dSLaurent Pinchart 2457f8f02d5cSGreg Kroah-Hartman if (IS_ENABLED(CONFIG_USB_OTG_PRODUCTLIST) && hcd->tpl_support && 2458e5a9d621SPeter Chen !is_targeted(udev)) { 2459026f3fcbSPeter Chen /* Maybe it can talk to us, though we can't talk to it. 2460026f3fcbSPeter Chen * (Includes HNP test device.) 2461026f3fcbSPeter Chen */ 2462e5a9d621SPeter Chen if (IS_ENABLED(CONFIG_USB_OTG) && (udev->bus->b_hnp_enable 2463e5a9d621SPeter Chen || udev->bus->is_b_host)) { 2464026f3fcbSPeter Chen err = usb_port_suspend(udev, PMSG_AUTO_SUSPEND); 2465026f3fcbSPeter Chen if (err < 0) 2466026f3fcbSPeter Chen dev_dbg(&udev->dev, "HNP fail, %d\n", err); 2467026f3fcbSPeter Chen } 2468026f3fcbSPeter Chen return -ENOTSUPP; 2469026f3fcbSPeter Chen } 2470026f3fcbSPeter Chen 247180da2e0dSLaurent Pinchart usb_detect_interface_quirks(udev); 247280da2e0dSLaurent Pinchart 247380da2e0dSLaurent Pinchart return 0; 2474d9d16e8aSInaky Perez-Gonzalez } 2475d9d16e8aSInaky Perez-Gonzalez 2476d35e70d5SMatthew Garrett static void set_usb_port_removable(struct usb_device *udev) 2477d35e70d5SMatthew Garrett { 2478d35e70d5SMatthew Garrett struct usb_device *hdev = udev->parent; 2479d35e70d5SMatthew Garrett struct usb_hub *hub; 2480d35e70d5SMatthew Garrett u8 port = udev->portnum; 2481d35e70d5SMatthew Garrett u16 wHubCharacteristics; 2482d35e70d5SMatthew Garrett bool removable = true; 2483d35e70d5SMatthew Garrett 248470f400d4SRajat Jain dev_set_removable(&udev->dev, DEVICE_REMOVABLE_UNKNOWN); 248570f400d4SRajat Jain 2486d35e70d5SMatthew Garrett if (!hdev) 2487d35e70d5SMatthew Garrett return; 2488d35e70d5SMatthew Garrett 2489ad493e5eSLan Tianyu hub = usb_hub_to_struct_hub(udev->parent); 2490d35e70d5SMatthew Garrett 249192bfbf71SMatthew Garrett /* 249292bfbf71SMatthew Garrett * If the platform firmware has provided information about a port, 249392bfbf71SMatthew Garrett * use that to determine whether it's removable. 249492bfbf71SMatthew Garrett */ 249592bfbf71SMatthew Garrett switch (hub->ports[udev->portnum - 1]->connect_type) { 249692bfbf71SMatthew Garrett case USB_PORT_CONNECT_TYPE_HOT_PLUG: 249770f400d4SRajat Jain dev_set_removable(&udev->dev, DEVICE_REMOVABLE); 249892bfbf71SMatthew Garrett return; 249992bfbf71SMatthew Garrett case USB_PORT_CONNECT_TYPE_HARD_WIRED: 250058339c2eSMatthew Garrett case USB_PORT_NOT_USED: 250170f400d4SRajat Jain dev_set_removable(&udev->dev, DEVICE_FIXED); 250292bfbf71SMatthew Garrett return; 250358339c2eSMatthew Garrett default: 250458339c2eSMatthew Garrett break; 250592bfbf71SMatthew Garrett } 250692bfbf71SMatthew Garrett 250792bfbf71SMatthew Garrett /* 250892bfbf71SMatthew Garrett * Otherwise, check whether the hub knows whether a port is removable 250992bfbf71SMatthew Garrett * or not 251092bfbf71SMatthew Garrett */ 2511d35e70d5SMatthew Garrett wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics); 2512d35e70d5SMatthew Garrett 2513d35e70d5SMatthew Garrett if (!(wHubCharacteristics & HUB_CHAR_COMPOUND)) 2514d35e70d5SMatthew Garrett return; 2515d35e70d5SMatthew Garrett 2516d35e70d5SMatthew Garrett if (hub_is_superspeed(hdev)) { 2517ca3c1539SLan Tianyu if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable) 2518ca3c1539SLan Tianyu & (1 << port)) 2519d35e70d5SMatthew Garrett removable = false; 2520d35e70d5SMatthew Garrett } else { 2521d35e70d5SMatthew Garrett if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8))) 2522d35e70d5SMatthew Garrett removable = false; 2523d35e70d5SMatthew Garrett } 2524d35e70d5SMatthew Garrett 2525d35e70d5SMatthew Garrett if (removable) 252670f400d4SRajat Jain dev_set_removable(&udev->dev, DEVICE_REMOVABLE); 2527d35e70d5SMatthew Garrett else 252870f400d4SRajat Jain dev_set_removable(&udev->dev, DEVICE_FIXED); 2529a4204ff0SDan Williams 2530d35e70d5SMatthew Garrett } 2531d9d16e8aSInaky Perez-Gonzalez 2532d9d16e8aSInaky Perez-Gonzalez /** 2533d9d16e8aSInaky Perez-Gonzalez * usb_new_device - perform initial device setup (usbcore-internal) 2534d9d16e8aSInaky Perez-Gonzalez * @udev: newly addressed device (in ADDRESS state) 2535d9d16e8aSInaky Perez-Gonzalez * 25368d8558d1SAlan Stern * This is called with devices which have been detected but not fully 25378d8558d1SAlan Stern * enumerated. The device descriptor is available, but not descriptors 2538d9d16e8aSInaky Perez-Gonzalez * for any device configuration. The caller must have locked either 2539d9d16e8aSInaky Perez-Gonzalez * the parent hub (if udev is a normal device) or else the 2540a4b5d606SHeiner Kallweit * usb_bus_idr_lock (if udev is a root hub). The parent's pointer to 2541d9d16e8aSInaky Perez-Gonzalez * udev has already been installed, but udev is not yet visible through 2542d9d16e8aSInaky Perez-Gonzalez * sysfs or other filesystem code. 2543d9d16e8aSInaky Perez-Gonzalez * 2544d9d16e8aSInaky Perez-Gonzalez * This call is synchronous, and may not be used in an interrupt context. 2545d9d16e8aSInaky Perez-Gonzalez * 2546d9d16e8aSInaky Perez-Gonzalez * Only the hub driver or root-hub registrar should ever call this. 2547626f090cSYacine Belkadi * 2548626f090cSYacine Belkadi * Return: Whether the device is configured properly or not. Zero if the 2549626f090cSYacine Belkadi * interface was registered with the driver core; else a negative errno 2550626f090cSYacine Belkadi * value. 2551626f090cSYacine Belkadi * 2552d9d16e8aSInaky Perez-Gonzalez */ 2553d9d16e8aSInaky Perez-Gonzalez int usb_new_device(struct usb_device *udev) 2554d9d16e8aSInaky Perez-Gonzalez { 2555d9d16e8aSInaky Perez-Gonzalez int err; 2556d9d16e8aSInaky Perez-Gonzalez 255716985408SDan Streetman if (udev->parent) { 255816985408SDan Streetman /* Initialize non-root-hub device wakeup to disabled; 255916985408SDan Streetman * device (un)configuration controls wakeup capable 256016985408SDan Streetman * sysfs power/wakeup controls wakeup enabled/disabled 256116985408SDan Streetman */ 256216985408SDan Streetman device_init_wakeup(&udev->dev, 0); 256316985408SDan Streetman } 256416985408SDan Streetman 25659bbdf1e0SAlan Stern /* Tell the runtime-PM framework the device is active */ 25669bbdf1e0SAlan Stern pm_runtime_set_active(&udev->dev); 2567c08512c7SAlan Stern pm_runtime_get_noresume(&udev->dev); 2568fcc4a01eSAlan Stern pm_runtime_use_autosuspend(&udev->dev); 25699bbdf1e0SAlan Stern pm_runtime_enable(&udev->dev); 25709bbdf1e0SAlan Stern 2571c08512c7SAlan Stern /* By default, forbid autosuspend for all devices. It will be 2572c08512c7SAlan Stern * allowed for hubs during binding. 2573c08512c7SAlan Stern */ 2574c08512c7SAlan Stern usb_disable_autosuspend(udev); 2575c08512c7SAlan Stern 25768d8558d1SAlan Stern err = usb_enumerate_device(udev); /* Read descriptors */ 2577d9d16e8aSInaky Perez-Gonzalez if (err < 0) 2578d9d16e8aSInaky Perez-Gonzalez goto fail; 2579c6515272SSarah Sharp dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n", 2580c6515272SSarah Sharp udev->devnum, udev->bus->busnum, 2581c6515272SSarah Sharp (((udev->bus->busnum-1) * 128) + (udev->devnum-1))); 25829f8b17e6SKay Sievers /* export the usbdev device-node for libusb */ 25839f8b17e6SKay Sievers udev->dev.devt = MKDEV(USB_DEVICE_MAJOR, 25849f8b17e6SKay Sievers (((udev->bus->busnum-1) * 128) + (udev->devnum-1))); 25859f8b17e6SKay Sievers 25866cd13201SAlan Stern /* Tell the world! */ 25876cd13201SAlan Stern announce_device(udev); 2588195af2ccSAlan Stern 2589b04b3156STheodore Ts'o if (udev->serial) 2590b04b3156STheodore Ts'o add_device_randomness(udev->serial, strlen(udev->serial)); 2591b04b3156STheodore Ts'o if (udev->product) 2592b04b3156STheodore Ts'o add_device_randomness(udev->product, strlen(udev->product)); 2593b04b3156STheodore Ts'o if (udev->manufacturer) 2594b04b3156STheodore Ts'o add_device_randomness(udev->manufacturer, 2595b04b3156STheodore Ts'o strlen(udev->manufacturer)); 2596b04b3156STheodore Ts'o 2597927bc916SRafael J. Wysocki device_enable_async_suspend(&udev->dev); 2598d35e70d5SMatthew Garrett 2599a4204ff0SDan Williams /* check whether the hub or firmware marks this port as non-removable */ 2600d35e70d5SMatthew Garrett set_usb_port_removable(udev); 2601d35e70d5SMatthew Garrett 2602782da727SAlan Stern /* Register the device. The device driver is responsible 26033b23dd6fSAlan Stern * for configuring the device and invoking the add-device 26043b23dd6fSAlan Stern * notifier chain (used by usbfs and possibly others). 2605782da727SAlan Stern */ 26061da177e4SLinus Torvalds err = device_add(&udev->dev); 26071da177e4SLinus Torvalds if (err) { 26081da177e4SLinus Torvalds dev_err(&udev->dev, "can't device_add, error %d\n", err); 26091da177e4SLinus Torvalds goto fail; 26101da177e4SLinus Torvalds } 26119ad3d6ccSAlan Stern 2612fde26380SLan Tianyu /* Create link files between child device and usb port device. */ 2613fde26380SLan Tianyu if (udev->parent) { 2614ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); 2615d5c3834eSDan Williams int port1 = udev->portnum; 2616d5c3834eSDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 2617fde26380SLan Tianyu 2618fde26380SLan Tianyu err = sysfs_create_link(&udev->dev.kobj, 2619fde26380SLan Tianyu &port_dev->dev.kobj, "port"); 2620fde26380SLan Tianyu if (err) 2621fde26380SLan Tianyu goto fail; 2622fde26380SLan Tianyu 2623fde26380SLan Tianyu err = sysfs_create_link(&port_dev->dev.kobj, 2624fde26380SLan Tianyu &udev->dev.kobj, "device"); 2625fde26380SLan Tianyu if (err) { 2626fde26380SLan Tianyu sysfs_remove_link(&udev->dev.kobj, "port"); 2627fde26380SLan Tianyu goto fail; 2628fde26380SLan Tianyu } 2629971fcd49SLan Tianyu 2630d5c3834eSDan Williams if (!test_and_set_bit(port1, hub->child_usage_bits)) 2631971fcd49SLan Tianyu pm_runtime_get_sync(&port_dev->dev); 2632fde26380SLan Tianyu } 2633fde26380SLan Tianyu 26343b23dd6fSAlan Stern (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev); 2635c08512c7SAlan Stern usb_mark_last_busy(udev); 2636c08512c7SAlan Stern pm_runtime_put_sync_autosuspend(&udev->dev); 2637c066475eSGreg Kroah-Hartman return err; 26381da177e4SLinus Torvalds 26391da177e4SLinus Torvalds fail: 26401da177e4SLinus Torvalds usb_set_device_state(udev, USB_STATE_NOTATTACHED); 26419bbdf1e0SAlan Stern pm_runtime_disable(&udev->dev); 26429bbdf1e0SAlan Stern pm_runtime_set_suspended(&udev->dev); 2643d9d16e8aSInaky Perez-Gonzalez return err; 26441da177e4SLinus Torvalds } 26451da177e4SLinus Torvalds 264693993a0aSInaky Perez-Gonzalez 264793993a0aSInaky Perez-Gonzalez /** 2648fd39c86bSRandy Dunlap * usb_deauthorize_device - deauthorize a device (usbcore-internal) 2649fd39c86bSRandy Dunlap * @usb_dev: USB device 2650fd39c86bSRandy Dunlap * 2651fd39c86bSRandy Dunlap * Move the USB device to a very basic state where interfaces are disabled 2652fd39c86bSRandy Dunlap * and the device is in fact unconfigured and unusable. 265393993a0aSInaky Perez-Gonzalez * 265493993a0aSInaky Perez-Gonzalez * We share a lock (that we have) with device_del(), so we need to 265593993a0aSInaky Perez-Gonzalez * defer its call. 2656626f090cSYacine Belkadi * 2657626f090cSYacine Belkadi * Return: 0. 265893993a0aSInaky Perez-Gonzalez */ 265993993a0aSInaky Perez-Gonzalez int usb_deauthorize_device(struct usb_device *usb_dev) 266093993a0aSInaky Perez-Gonzalez { 266193993a0aSInaky Perez-Gonzalez usb_lock_device(usb_dev); 266293993a0aSInaky Perez-Gonzalez if (usb_dev->authorized == 0) 266393993a0aSInaky Perez-Gonzalez goto out_unauthorized; 2664da307123SAlan Stern 266593993a0aSInaky Perez-Gonzalez usb_dev->authorized = 0; 266693993a0aSInaky Perez-Gonzalez usb_set_configuration(usb_dev, -1); 2667da307123SAlan Stern 266893993a0aSInaky Perez-Gonzalez out_unauthorized: 266993993a0aSInaky Perez-Gonzalez usb_unlock_device(usb_dev); 267093993a0aSInaky Perez-Gonzalez return 0; 267193993a0aSInaky Perez-Gonzalez } 267293993a0aSInaky Perez-Gonzalez 267393993a0aSInaky Perez-Gonzalez 267493993a0aSInaky Perez-Gonzalez int usb_authorize_device(struct usb_device *usb_dev) 267593993a0aSInaky Perez-Gonzalez { 267693993a0aSInaky Perez-Gonzalez int result = 0, c; 2677da307123SAlan Stern 267893993a0aSInaky Perez-Gonzalez usb_lock_device(usb_dev); 267993993a0aSInaky Perez-Gonzalez if (usb_dev->authorized == 1) 268093993a0aSInaky Perez-Gonzalez goto out_authorized; 2681da307123SAlan Stern 268293993a0aSInaky Perez-Gonzalez result = usb_autoresume_device(usb_dev); 268393993a0aSInaky Perez-Gonzalez if (result < 0) { 268493993a0aSInaky Perez-Gonzalez dev_err(&usb_dev->dev, 268593993a0aSInaky Perez-Gonzalez "can't autoresume for authorization: %d\n", result); 268693993a0aSInaky Perez-Gonzalez goto error_autoresume; 268793993a0aSInaky Perez-Gonzalez } 2688e50a322eSJosef Gajdusek 268993993a0aSInaky Perez-Gonzalez usb_dev->authorized = 1; 269093993a0aSInaky Perez-Gonzalez /* Choose and set the configuration. This registers the interfaces 269193993a0aSInaky Perez-Gonzalez * with the driver core and lets interface drivers bind to them. 269293993a0aSInaky Perez-Gonzalez */ 2693b5ea060fSGreg Kroah-Hartman c = usb_choose_configuration(usb_dev); 269493993a0aSInaky Perez-Gonzalez if (c >= 0) { 269593993a0aSInaky Perez-Gonzalez result = usb_set_configuration(usb_dev, c); 269693993a0aSInaky Perez-Gonzalez if (result) { 269793993a0aSInaky Perez-Gonzalez dev_err(&usb_dev->dev, 269893993a0aSInaky Perez-Gonzalez "can't set config #%d, error %d\n", c, result); 269993993a0aSInaky Perez-Gonzalez /* This need not be fatal. The user can try to 270093993a0aSInaky Perez-Gonzalez * set other configurations. */ 270193993a0aSInaky Perez-Gonzalez } 270293993a0aSInaky Perez-Gonzalez } 270393993a0aSInaky Perez-Gonzalez dev_info(&usb_dev->dev, "authorized to connect\n"); 2704da307123SAlan Stern 2705da307123SAlan Stern usb_autosuspend_device(usb_dev); 270693993a0aSInaky Perez-Gonzalez error_autoresume: 270793993a0aSInaky Perez-Gonzalez out_authorized: 2708781b2137SMatthias Beyer usb_unlock_device(usb_dev); /* complements locktree */ 270993993a0aSInaky Perez-Gonzalez return result; 271093993a0aSInaky Perez-Gonzalez } 271193993a0aSInaky Perez-Gonzalez 27120299809bSThinh Nguyen /** 27130299809bSThinh Nguyen * get_port_ssp_rate - Match the extended port status to SSP rate 27140299809bSThinh Nguyen * @hdev: The hub device 27150299809bSThinh Nguyen * @ext_portstatus: extended port status 27160299809bSThinh Nguyen * 27170299809bSThinh Nguyen * Match the extended port status speed id to the SuperSpeed Plus sublink speed 27180299809bSThinh Nguyen * capability attributes. Base on the number of connected lanes and speed, 27190299809bSThinh Nguyen * return the corresponding enum usb_ssp_rate. 27200299809bSThinh Nguyen */ 27210299809bSThinh Nguyen static enum usb_ssp_rate get_port_ssp_rate(struct usb_device *hdev, 27220299809bSThinh Nguyen u32 ext_portstatus) 27230299809bSThinh Nguyen { 2724f74a7afcSRicardo Cañuelo struct usb_ssp_cap_descriptor *ssp_cap; 27250299809bSThinh Nguyen u32 attr; 27260299809bSThinh Nguyen u8 speed_id; 27270299809bSThinh Nguyen u8 ssac; 27280299809bSThinh Nguyen u8 lanes; 27290299809bSThinh Nguyen int i; 27300299809bSThinh Nguyen 2731f74a7afcSRicardo Cañuelo if (!hdev->bos) 2732f74a7afcSRicardo Cañuelo goto out; 2733f74a7afcSRicardo Cañuelo 2734f74a7afcSRicardo Cañuelo ssp_cap = hdev->bos->ssp_cap; 27350299809bSThinh Nguyen if (!ssp_cap) 27360299809bSThinh Nguyen goto out; 27370299809bSThinh Nguyen 27380299809bSThinh Nguyen speed_id = ext_portstatus & USB_EXT_PORT_STAT_RX_SPEED_ID; 27390299809bSThinh Nguyen lanes = USB_EXT_PORT_RX_LANES(ext_portstatus) + 1; 27400299809bSThinh Nguyen 27410299809bSThinh Nguyen ssac = le32_to_cpu(ssp_cap->bmAttributes) & 27420299809bSThinh Nguyen USB_SSP_SUBLINK_SPEED_ATTRIBS; 27430299809bSThinh Nguyen 27440299809bSThinh Nguyen for (i = 0; i <= ssac; i++) { 27450299809bSThinh Nguyen u8 ssid; 27460299809bSThinh Nguyen 27470299809bSThinh Nguyen attr = le32_to_cpu(ssp_cap->bmSublinkSpeedAttr[i]); 27480299809bSThinh Nguyen ssid = FIELD_GET(USB_SSP_SUBLINK_SPEED_SSID, attr); 27490299809bSThinh Nguyen if (speed_id == ssid) { 27500299809bSThinh Nguyen u16 mantissa; 27510299809bSThinh Nguyen u8 lse; 27520299809bSThinh Nguyen u8 type; 27530299809bSThinh Nguyen 27540299809bSThinh Nguyen /* 27550299809bSThinh Nguyen * Note: currently asymmetric lane types are only 27560299809bSThinh Nguyen * applicable for SSIC operate in SuperSpeed protocol 27570299809bSThinh Nguyen */ 27580299809bSThinh Nguyen type = FIELD_GET(USB_SSP_SUBLINK_SPEED_ST, attr); 27590299809bSThinh Nguyen if (type == USB_SSP_SUBLINK_SPEED_ST_ASYM_RX || 27600299809bSThinh Nguyen type == USB_SSP_SUBLINK_SPEED_ST_ASYM_TX) 27610299809bSThinh Nguyen goto out; 27620299809bSThinh Nguyen 27630299809bSThinh Nguyen if (FIELD_GET(USB_SSP_SUBLINK_SPEED_LP, attr) != 27640299809bSThinh Nguyen USB_SSP_SUBLINK_SPEED_LP_SSP) 27650299809bSThinh Nguyen goto out; 27660299809bSThinh Nguyen 27670299809bSThinh Nguyen lse = FIELD_GET(USB_SSP_SUBLINK_SPEED_LSE, attr); 27680299809bSThinh Nguyen mantissa = FIELD_GET(USB_SSP_SUBLINK_SPEED_LSM, attr); 27690299809bSThinh Nguyen 27700299809bSThinh Nguyen /* Convert to Gbps */ 27710299809bSThinh Nguyen for (; lse < USB_SSP_SUBLINK_SPEED_LSE_GBPS; lse++) 27720299809bSThinh Nguyen mantissa /= 1000; 27730299809bSThinh Nguyen 27740299809bSThinh Nguyen if (mantissa >= 10 && lanes == 1) 27750299809bSThinh Nguyen return USB_SSP_GEN_2x1; 27760299809bSThinh Nguyen 27770299809bSThinh Nguyen if (mantissa >= 10 && lanes == 2) 27780299809bSThinh Nguyen return USB_SSP_GEN_2x2; 27790299809bSThinh Nguyen 27800299809bSThinh Nguyen if (mantissa >= 5 && lanes == 2) 27810299809bSThinh Nguyen return USB_SSP_GEN_1x2; 27820299809bSThinh Nguyen 27830299809bSThinh Nguyen goto out; 27840299809bSThinh Nguyen } 27850299809bSThinh Nguyen } 27860299809bSThinh Nguyen 27870299809bSThinh Nguyen out: 27880299809bSThinh Nguyen return USB_SSP_GEN_UNKNOWN; 27890299809bSThinh Nguyen } 27900299809bSThinh Nguyen 2791fb6f076dSAlan Stern #ifdef CONFIG_USB_FEW_INIT_RETRIES 2792fb6f076dSAlan Stern #define PORT_RESET_TRIES 2 2793fb6f076dSAlan Stern #define SET_ADDRESS_TRIES 1 2794fb6f076dSAlan Stern #define GET_DESCRIPTOR_TRIES 1 2795fb6f076dSAlan Stern #define GET_MAXPACKET0_TRIES 1 2796fb6f076dSAlan Stern #define PORT_INIT_TRIES 4 2797fb6f076dSAlan Stern 2798fb6f076dSAlan Stern #else 27991da177e4SLinus Torvalds #define PORT_RESET_TRIES 5 28001da177e4SLinus Torvalds #define SET_ADDRESS_TRIES 2 28011da177e4SLinus Torvalds #define GET_DESCRIPTOR_TRIES 2 2802fb6f076dSAlan Stern #define GET_MAXPACKET0_TRIES 3 280319502e69SAlan Stern #define PORT_INIT_TRIES 4 2804fb6f076dSAlan Stern #endif /* CONFIG_USB_FEW_INIT_RETRIES */ 28051da177e4SLinus Torvalds 2806f59f93cdSMathias Nyman #define DETECT_DISCONNECT_TRIES 5 2807f59f93cdSMathias Nyman 280874072baeSMathias Nyman #define HUB_ROOT_RESET_TIME 60 /* times are in msec */ 28091da177e4SLinus Torvalds #define HUB_SHORT_RESET_TIME 10 281075d7cf72SAndiry Xu #define HUB_BH_RESET_TIME 50 28111da177e4SLinus Torvalds #define HUB_LONG_RESET_TIME 200 281277c7f072SSarah Sharp #define HUB_RESET_TIMEOUT 800 28131da177e4SLinus Torvalds 281419502e69SAlan Stern static bool use_new_scheme(struct usb_device *udev, int retry, 281519502e69SAlan Stern struct usb_port *port_dev) 281619502e69SAlan Stern { 281719502e69SAlan Stern int old_scheme_first_port = 281819502e69SAlan Stern (port_dev->quirks & USB_PORT_QUIRK_OLD_SCHEME) || 281919502e69SAlan Stern old_scheme_first; 282019502e69SAlan Stern 282148fc7dbdSDan Williams /* 282248fc7dbdSDan Williams * "New scheme" enumeration causes an extra state transition to be 282348fc7dbdSDan Williams * exposed to an xhci host and causes USB3 devices to receive control 282448fc7dbdSDan Williams * commands in the default state. This has been seen to cause 282548fc7dbdSDan Williams * enumeration failures, so disable this enumeration scheme for USB3 282648fc7dbdSDan Williams * devices. 282748fc7dbdSDan Williams */ 28288a1b2725SMathias Nyman if (udev->speed >= USB_SPEED_SUPER) 282948fc7dbdSDan Williams return false; 283048fc7dbdSDan Williams 283119502e69SAlan Stern /* 283219502e69SAlan Stern * If use_both_schemes is set, use the first scheme (whichever 283319502e69SAlan Stern * it is) for the larger half of the retries, then use the other 283419502e69SAlan Stern * scheme. Otherwise, use the first scheme for all the retries. 283519502e69SAlan Stern */ 283619502e69SAlan Stern if (use_both_schemes && retry >= (PORT_INIT_TRIES + 1) / 2) 283719502e69SAlan Stern return old_scheme_first_port; /* Second half */ 283819502e69SAlan Stern return !old_scheme_first_port; /* First half or all */ 283948fc7dbdSDan Williams } 284048fc7dbdSDan Williams 2841025d4430SRahul Bedarkar /* Is a USB 3.0 port in the Inactive or Compliance Mode state? 2842d46a6024SHarry Pan * Port warm reset is required to recover 28438bea2bd3SStanislaw Ledwon */ 28443cd12f91SDan Williams static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1, 28453cd12f91SDan Williams u16 portstatus) 284610d674a8SSarah Sharp { 28473cd12f91SDan Williams u16 link_state; 28483cd12f91SDan Williams 28493cd12f91SDan Williams if (!hub_is_superspeed(hub->hdev)) 28503cd12f91SDan Williams return false; 28513cd12f91SDan Williams 28523cd12f91SDan Williams if (test_bit(port1, hub->warm_reset_bits)) 28533cd12f91SDan Williams return true; 28543cd12f91SDan Williams 28553cd12f91SDan Williams link_state = portstatus & USB_PORT_STAT_LINK_STATE; 28563cd12f91SDan Williams return link_state == USB_SS_PORT_LS_SS_INACTIVE 28573cd12f91SDan Williams || link_state == USB_SS_PORT_LS_COMP_MOD; 285810d674a8SSarah Sharp } 285910d674a8SSarah Sharp 28601da177e4SLinus Torvalds static int hub_port_wait_reset(struct usb_hub *hub, int port1, 286175d7cf72SAndiry Xu struct usb_device *udev, unsigned int delay, bool warm) 28621da177e4SLinus Torvalds { 28631da177e4SLinus Torvalds int delay_time, ret; 28641da177e4SLinus Torvalds u16 portstatus; 28651da177e4SLinus Torvalds u16 portchange; 28660cdd49a1SMathias Nyman u32 ext_portstatus = 0; 28671da177e4SLinus Torvalds 28681da177e4SLinus Torvalds for (delay_time = 0; 28691da177e4SLinus Torvalds delay_time < HUB_RESET_TIMEOUT; 28701da177e4SLinus Torvalds delay_time += delay) { 28711da177e4SLinus Torvalds /* wait to give the device a chance to reset */ 28721da177e4SLinus Torvalds msleep(delay); 28731da177e4SLinus Torvalds 28741da177e4SLinus Torvalds /* read and decode port status */ 28750cdd49a1SMathias Nyman if (hub_is_superspeedplus(hub->hdev)) 28760cdd49a1SMathias Nyman ret = hub_ext_port_status(hub, port1, 28770cdd49a1SMathias Nyman HUB_EXT_PORT_STATUS, 28780cdd49a1SMathias Nyman &portstatus, &portchange, 28790cdd49a1SMathias Nyman &ext_portstatus); 28800cdd49a1SMathias Nyman else 2881f061f43dSMichael Grzeschik ret = usb_hub_port_status(hub, port1, &portstatus, 28820cdd49a1SMathias Nyman &portchange); 28831da177e4SLinus Torvalds if (ret < 0) 28841da177e4SLinus Torvalds return ret; 28851da177e4SLinus Torvalds 288622547c4cSGuenter Roeck /* 288722547c4cSGuenter Roeck * The port state is unknown until the reset completes. 288822547c4cSGuenter Roeck * 288922547c4cSGuenter Roeck * On top of that, some chips may require additional time 289022547c4cSGuenter Roeck * to re-establish a connection after the reset is complete, 289122547c4cSGuenter Roeck * so also wait for the connection to be re-established. 289222547c4cSGuenter Roeck */ 289322547c4cSGuenter Roeck if (!(portstatus & USB_PORT_STAT_RESET) && 289422547c4cSGuenter Roeck (portstatus & USB_PORT_STAT_CONNECTION)) 2895470f0be8SSarah Sharp break; 2896470f0be8SSarah Sharp 2897470f0be8SSarah Sharp /* switch to the long delay after two short delay failures */ 2898470f0be8SSarah Sharp if (delay_time >= 2 * HUB_SHORT_RESET_TIME) 2899470f0be8SSarah Sharp delay = HUB_LONG_RESET_TIME; 2900470f0be8SSarah Sharp 2901d99f6b41SDan Williams dev_dbg(&hub->ports[port1 - 1]->dev, 2902d99f6b41SDan Williams "not %sreset yet, waiting %dms\n", 2903d99f6b41SDan Williams warm ? "warm " : "", delay); 2904470f0be8SSarah Sharp } 2905470f0be8SSarah Sharp 29064f43447eSSarah Sharp if ((portstatus & USB_PORT_STAT_RESET)) 2907470f0be8SSarah Sharp return -EBUSY; 29084f43447eSSarah Sharp 29093cd12f91SDan Williams if (hub_port_warm_reset_required(hub, port1, portstatus)) 2910a24a6078SSarah Sharp return -ENOTCONN; 291110d674a8SSarah Sharp 29121da177e4SLinus Torvalds /* Device went away? */ 29131da177e4SLinus Torvalds if (!(portstatus & USB_PORT_STAT_CONNECTION)) 29141da177e4SLinus Torvalds return -ENOTCONN; 29151da177e4SLinus Torvalds 29161ac7db63SMathias Nyman /* Retry if connect change is set but status is still connected. 29171ac7db63SMathias Nyman * A USB 3.0 connection may bounce if multiple warm resets were issued, 2918a24a6078SSarah Sharp * but the device may have successfully re-connected. Ignore it. 2919a24a6078SSarah Sharp */ 2920a24a6078SSarah Sharp if (!hub_is_superspeed(hub->hdev) && 29211ac7db63SMathias Nyman (portchange & USB_PORT_STAT_C_CONNECTION)) { 29221ac7db63SMathias Nyman usb_clear_port_feature(hub->hdev, port1, 29231ac7db63SMathias Nyman USB_PORT_FEAT_C_CONNECTION); 29241ac7db63SMathias Nyman return -EAGAIN; 29251ac7db63SMathias Nyman } 29261da177e4SLinus Torvalds 2927470f0be8SSarah Sharp if (!(portstatus & USB_PORT_STAT_ENABLE)) 2928470f0be8SSarah Sharp return -EBUSY; 2929470f0be8SSarah Sharp 29302d4fa940SSarah Sharp if (!udev) 29312d4fa940SSarah Sharp return 0; 29322d4fa940SSarah Sharp 2933013eedb8SMathias Nyman if (hub_is_superspeedplus(hub->hdev)) { 2934013eedb8SMathias Nyman /* extended portstatus Rx and Tx lane count are zero based */ 2935013eedb8SMathias Nyman udev->rx_lanes = USB_EXT_PORT_RX_LANES(ext_portstatus) + 1; 2936013eedb8SMathias Nyman udev->tx_lanes = USB_EXT_PORT_TX_LANES(ext_portstatus) + 1; 29370299809bSThinh Nguyen udev->ssp_rate = get_port_ssp_rate(hub->hdev, ext_portstatus); 2938013eedb8SMathias Nyman } else { 2939013eedb8SMathias Nyman udev->rx_lanes = 1; 2940013eedb8SMathias Nyman udev->tx_lanes = 1; 29410299809bSThinh Nguyen udev->ssp_rate = USB_SSP_GEN_UNKNOWN; 2942013eedb8SMathias Nyman } 29431e4c5742SAlan Stern if (udev->ssp_rate != USB_SSP_GEN_UNKNOWN) 29440cdd49a1SMathias Nyman udev->speed = USB_SPEED_SUPER_PLUS; 2945131dec34SSarah Sharp else if (hub_is_superspeed(hub->hdev)) 2946809cd1cbSSarah Sharp udev->speed = USB_SPEED_SUPER; 29470165de09SInaky Perez-Gonzalez else if (portstatus & USB_PORT_STAT_HIGH_SPEED) 29481da177e4SLinus Torvalds udev->speed = USB_SPEED_HIGH; 29491da177e4SLinus Torvalds else if (portstatus & USB_PORT_STAT_LOW_SPEED) 29501da177e4SLinus Torvalds udev->speed = USB_SPEED_LOW; 29511da177e4SLinus Torvalds else 29521da177e4SLinus Torvalds udev->speed = USB_SPEED_FULL; 29531da177e4SLinus Torvalds return 0; 29541da177e4SLinus Torvalds } 29551da177e4SLinus Torvalds 295675d7cf72SAndiry Xu /* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */ 295775d7cf72SAndiry Xu static int hub_port_reset(struct usb_hub *hub, int port1, 295875d7cf72SAndiry Xu struct usb_device *udev, unsigned int delay, bool warm) 295975d7cf72SAndiry Xu { 296075d7cf72SAndiry Xu int i, status; 2961a24a6078SSarah Sharp u16 portchange, portstatus; 2962d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 2963781f0766SKai-Heng Feng int reset_recovery_time; 296475d7cf72SAndiry Xu 296575d7cf72SAndiry Xu if (!hub_is_superspeed(hub->hdev)) { 29660fe51aa5SSarah Sharp if (warm) { 296775d7cf72SAndiry Xu dev_err(hub->intfdev, "only USB3 hub support " 296875d7cf72SAndiry Xu "warm reset\n"); 296975d7cf72SAndiry Xu return -EINVAL; 297075d7cf72SAndiry Xu } 29710fe51aa5SSarah Sharp /* Block EHCI CF initialization during the port reset. 29720fe51aa5SSarah Sharp * Some companion controllers don't like it when they mix. 29730fe51aa5SSarah Sharp */ 29740fe51aa5SSarah Sharp down_read(&ehci_cf_port_reset_rwsem); 2975d3b9d7a9SSarah Sharp } else if (!warm) { 2976d3b9d7a9SSarah Sharp /* 2977d3b9d7a9SSarah Sharp * If the caller hasn't explicitly requested a warm reset, 2978d3b9d7a9SSarah Sharp * double check and see if one is needed. 2979d3b9d7a9SSarah Sharp */ 2980f061f43dSMichael Grzeschik if (usb_hub_port_status(hub, port1, &portstatus, 2981f061f43dSMichael Grzeschik &portchange) == 0) 2982fb6d1f7dSRobert Schlabbach if (hub_port_warm_reset_required(hub, port1, 2983fb6d1f7dSRobert Schlabbach portstatus)) 2984d3b9d7a9SSarah Sharp warm = true; 298575d7cf72SAndiry Xu } 29863cd12f91SDan Williams clear_bit(port1, hub->warm_reset_bits); 298775d7cf72SAndiry Xu 298875d7cf72SAndiry Xu /* Reset the port */ 298975d7cf72SAndiry Xu for (i = 0; i < PORT_RESET_TRIES; i++) { 299075d7cf72SAndiry Xu status = set_port_feature(hub->hdev, port1, (warm ? 299175d7cf72SAndiry Xu USB_PORT_FEAT_BH_PORT_RESET : 299275d7cf72SAndiry Xu USB_PORT_FEAT_RESET)); 2993e9e88fb7SAlan Stern if (status == -ENODEV) { 2994e9e88fb7SAlan Stern ; /* The hub is gone */ 2995e9e88fb7SAlan Stern } else if (status) { 2996d99f6b41SDan Williams dev_err(&port_dev->dev, 2997d99f6b41SDan Williams "cannot %sreset (err = %d)\n", 2998d99f6b41SDan Williams warm ? "warm " : "", status); 299975d7cf72SAndiry Xu } else { 300075d7cf72SAndiry Xu status = hub_port_wait_reset(hub, port1, udev, delay, 300175d7cf72SAndiry Xu warm); 3002e9e88fb7SAlan Stern if (status && status != -ENOTCONN && status != -ENODEV) 300375d7cf72SAndiry Xu dev_dbg(hub->intfdev, 300475d7cf72SAndiry Xu "port_wait_reset: err = %d\n", 300575d7cf72SAndiry Xu status); 300675d7cf72SAndiry Xu } 300775d7cf72SAndiry Xu 3008c8968611SKai-Heng Feng /* 3009c8968611SKai-Heng Feng * Check for disconnect or reset, and bail out after several 3010c8968611SKai-Heng Feng * reset attempts to avoid warm reset loop. 3011c8968611SKai-Heng Feng */ 3012c8968611SKai-Heng Feng if (status == 0 || status == -ENOTCONN || status == -ENODEV || 3013c8968611SKai-Heng Feng (status == -EBUSY && i == PORT_RESET_TRIES - 1)) { 3014fb6d1f7dSRobert Schlabbach usb_clear_port_feature(hub->hdev, port1, 3015fb6d1f7dSRobert Schlabbach USB_PORT_FEAT_C_RESET); 3016a24a6078SSarah Sharp 3017a24a6078SSarah Sharp if (!hub_is_superspeed(hub->hdev)) 301832fe0198SAlan Stern goto done; 3019a24a6078SSarah Sharp 3020fb6d1f7dSRobert Schlabbach usb_clear_port_feature(hub->hdev, port1, 3021fb6d1f7dSRobert Schlabbach USB_PORT_FEAT_C_BH_PORT_RESET); 3022fb6d1f7dSRobert Schlabbach usb_clear_port_feature(hub->hdev, port1, 3023fb6d1f7dSRobert Schlabbach USB_PORT_FEAT_C_PORT_LINK_STATE); 302422454b79SDennis Wassenberg 302522454b79SDennis Wassenberg if (udev) 3026fb6d1f7dSRobert Schlabbach usb_clear_port_feature(hub->hdev, port1, 3027fb6d1f7dSRobert Schlabbach USB_PORT_FEAT_C_CONNECTION); 3028fb6d1f7dSRobert Schlabbach 3029a24a6078SSarah Sharp /* 3030a24a6078SSarah Sharp * If a USB 3.0 device migrates from reset to an error 3031a24a6078SSarah Sharp * state, re-issue the warm reset. 3032a24a6078SSarah Sharp */ 3033f061f43dSMichael Grzeschik if (usb_hub_port_status(hub, port1, 3034a24a6078SSarah Sharp &portstatus, &portchange) < 0) 3035a24a6078SSarah Sharp goto done; 3036a24a6078SSarah Sharp 30373cd12f91SDan Williams if (!hub_port_warm_reset_required(hub, port1, 30383cd12f91SDan Williams portstatus)) 3039a24a6078SSarah Sharp goto done; 3040a24a6078SSarah Sharp 3041a24a6078SSarah Sharp /* 3042a24a6078SSarah Sharp * If the port is in SS.Inactive or Compliance Mode, the 3043a24a6078SSarah Sharp * hot or warm reset failed. Try another warm reset. 3044a24a6078SSarah Sharp */ 3045a24a6078SSarah Sharp if (!warm) { 3046d99f6b41SDan Williams dev_dbg(&port_dev->dev, 3047d99f6b41SDan Williams "hot reset failed, warm reset\n"); 3048a24a6078SSarah Sharp warm = true; 3049a24a6078SSarah Sharp } 30501da177e4SLinus Torvalds } 30511da177e4SLinus Torvalds 3052d99f6b41SDan Williams dev_dbg(&port_dev->dev, 3053d99f6b41SDan Williams "not enabled, trying %sreset again...\n", 3054d99f6b41SDan Williams warm ? "warm " : ""); 30551da177e4SLinus Torvalds delay = HUB_LONG_RESET_TIME; 30561da177e4SLinus Torvalds } 30571da177e4SLinus Torvalds 3058d99f6b41SDan Williams dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n"); 30591da177e4SLinus Torvalds 306032fe0198SAlan Stern done: 3061fb6d1f7dSRobert Schlabbach if (status == 0) { 3062aa071a92SNicolas Boichat if (port_dev->quirks & USB_PORT_QUIRK_FAST_ENUM) 3063aa071a92SNicolas Boichat usleep_range(10000, 12000); 3064781f0766SKai-Heng Feng else { 3065781f0766SKai-Heng Feng /* TRSTRCY = 10 ms; plus some extra */ 3066781f0766SKai-Heng Feng reset_recovery_time = 10 + 40; 3067781f0766SKai-Heng Feng 3068781f0766SKai-Heng Feng /* Hub needs extra delay after resetting its port. */ 3069781f0766SKai-Heng Feng if (hub->hdev->quirks & USB_QUIRK_HUB_SLOW_RESET) 3070781f0766SKai-Heng Feng reset_recovery_time += 100; 3071781f0766SKai-Heng Feng 3072781f0766SKai-Heng Feng msleep(reset_recovery_time); 3073781f0766SKai-Heng Feng } 3074aa071a92SNicolas Boichat 3075fb6d1f7dSRobert Schlabbach if (udev) { 3076fb6d1f7dSRobert Schlabbach struct usb_hcd *hcd = bus_to_hcd(udev->bus); 3077fb6d1f7dSRobert Schlabbach 3078fb6d1f7dSRobert Schlabbach update_devnum(udev, 0); 3079fb6d1f7dSRobert Schlabbach /* The xHC may think the device is already reset, 3080fb6d1f7dSRobert Schlabbach * so ignore the status. 3081fb6d1f7dSRobert Schlabbach */ 3082fb6d1f7dSRobert Schlabbach if (hcd->driver->reset_device) 3083fb6d1f7dSRobert Schlabbach hcd->driver->reset_device(hcd, udev); 3084fb6d1f7dSRobert Schlabbach 3085fb6d1f7dSRobert Schlabbach usb_set_device_state(udev, USB_STATE_DEFAULT); 3086fb6d1f7dSRobert Schlabbach } 3087fb6d1f7dSRobert Schlabbach } else { 3088fb6d1f7dSRobert Schlabbach if (udev) 3089fb6d1f7dSRobert Schlabbach usb_set_device_state(udev, USB_STATE_NOTATTACHED); 3090fb6d1f7dSRobert Schlabbach } 3091fb6d1f7dSRobert Schlabbach 30920fe51aa5SSarah Sharp if (!hub_is_superspeed(hub->hdev)) 309332fe0198SAlan Stern up_read(&ehci_cf_port_reset_rwsem); 309475d7cf72SAndiry Xu 30951da177e4SLinus Torvalds return status; 30961da177e4SLinus Torvalds } 30971da177e4SLinus Torvalds 3098430d57f5SRay Chi /* 3099430d57f5SRay Chi * hub_port_stop_enumerate - stop USB enumeration or ignore port events 3100430d57f5SRay Chi * @hub: target hub 3101430d57f5SRay Chi * @port1: port num of the port 3102430d57f5SRay Chi * @retries: port retries number of hub_port_init() 3103430d57f5SRay Chi * 3104430d57f5SRay Chi * Return: 3105430d57f5SRay Chi * true: ignore port actions/events or give up connection attempts. 3106430d57f5SRay Chi * false: keep original behavior. 3107430d57f5SRay Chi * 3108430d57f5SRay Chi * This function will be based on retries to check whether the port which is 3109430d57f5SRay Chi * marked with early_stop attribute would stop enumeration or ignore events. 3110430d57f5SRay Chi * 3111430d57f5SRay Chi * Note: 3112430d57f5SRay Chi * This function didn't change anything if early_stop is not set, and it will 3113430d57f5SRay Chi * prevent all connection attempts when early_stop is set and the attempts of 3114430d57f5SRay Chi * the port are more than 1. 3115430d57f5SRay Chi */ 3116430d57f5SRay Chi static bool hub_port_stop_enumerate(struct usb_hub *hub, int port1, int retries) 3117430d57f5SRay Chi { 3118430d57f5SRay Chi struct usb_port *port_dev = hub->ports[port1 - 1]; 3119430d57f5SRay Chi 3120430d57f5SRay Chi if (port_dev->early_stop) { 3121430d57f5SRay Chi if (port_dev->ignore_event) 3122430d57f5SRay Chi return true; 3123430d57f5SRay Chi 3124430d57f5SRay Chi /* 3125430d57f5SRay Chi * We want unsuccessful attempts to fail quickly. 3126430d57f5SRay Chi * Since some devices may need one failure during 3127430d57f5SRay Chi * port initialization, we allow two tries but no 3128430d57f5SRay Chi * more. 3129430d57f5SRay Chi */ 3130430d57f5SRay Chi if (retries < 2) 3131430d57f5SRay Chi return false; 3132430d57f5SRay Chi 3133430d57f5SRay Chi port_dev->ignore_event = 1; 3134430d57f5SRay Chi } else 3135430d57f5SRay Chi port_dev->ignore_event = 0; 3136430d57f5SRay Chi 3137430d57f5SRay Chi return port_dev->ignore_event; 3138430d57f5SRay Chi } 3139430d57f5SRay Chi 31400ed9a57eSAndiry Xu /* Check if a port is power on */ 3141f061f43dSMichael Grzeschik int usb_port_is_power_on(struct usb_hub *hub, unsigned int portstatus) 31420ed9a57eSAndiry Xu { 31430ed9a57eSAndiry Xu int ret = 0; 31440ed9a57eSAndiry Xu 31450ed9a57eSAndiry Xu if (hub_is_superspeed(hub->hdev)) { 31460ed9a57eSAndiry Xu if (portstatus & USB_SS_PORT_STAT_POWER) 31470ed9a57eSAndiry Xu ret = 1; 31480ed9a57eSAndiry Xu } else { 31490ed9a57eSAndiry Xu if (portstatus & USB_PORT_STAT_POWER) 31500ed9a57eSAndiry Xu ret = 1; 31510ed9a57eSAndiry Xu } 31520ed9a57eSAndiry Xu 31530ed9a57eSAndiry Xu return ret; 31540ed9a57eSAndiry Xu } 31550ed9a57eSAndiry Xu 31565c79a1e3SDan Williams static void usb_lock_port(struct usb_port *port_dev) 31575c79a1e3SDan Williams __acquires(&port_dev->status_lock) 31585c79a1e3SDan Williams { 31595c79a1e3SDan Williams mutex_lock(&port_dev->status_lock); 31605c79a1e3SDan Williams __acquire(&port_dev->status_lock); 31615c79a1e3SDan Williams } 31625c79a1e3SDan Williams 31635c79a1e3SDan Williams static void usb_unlock_port(struct usb_port *port_dev) 31645c79a1e3SDan Williams __releases(&port_dev->status_lock) 31655c79a1e3SDan Williams { 31665c79a1e3SDan Williams mutex_unlock(&port_dev->status_lock); 31675c79a1e3SDan Williams __release(&port_dev->status_lock); 31685c79a1e3SDan Williams } 31695c79a1e3SDan Williams 3170d388dab7SAlan Stern #ifdef CONFIG_PM 31711da177e4SLinus Torvalds 31720ed9a57eSAndiry Xu /* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */ 31730ed9a57eSAndiry Xu static int port_is_suspended(struct usb_hub *hub, unsigned portstatus) 31740ed9a57eSAndiry Xu { 31750ed9a57eSAndiry Xu int ret = 0; 31760ed9a57eSAndiry Xu 31770ed9a57eSAndiry Xu if (hub_is_superspeed(hub->hdev)) { 31780ed9a57eSAndiry Xu if ((portstatus & USB_PORT_STAT_LINK_STATE) 31790ed9a57eSAndiry Xu == USB_SS_PORT_LS_U3) 31800ed9a57eSAndiry Xu ret = 1; 31810ed9a57eSAndiry Xu } else { 31820ed9a57eSAndiry Xu if (portstatus & USB_PORT_STAT_SUSPEND) 31830ed9a57eSAndiry Xu ret = 1; 31840ed9a57eSAndiry Xu } 31850ed9a57eSAndiry Xu 31860ed9a57eSAndiry Xu return ret; 31870ed9a57eSAndiry Xu } 3188b01b03f3SAlan Stern 3189b01b03f3SAlan Stern /* Determine whether the device on a port is ready for a normal resume, 3190b01b03f3SAlan Stern * is ready for a reset-resume, or should be disconnected. 3191b01b03f3SAlan Stern */ 3192b01b03f3SAlan Stern static int check_port_resume_type(struct usb_device *udev, 3193b01b03f3SAlan Stern struct usb_hub *hub, int port1, 31947fa40910SJulius Werner int status, u16 portchange, u16 portstatus) 3195b01b03f3SAlan Stern { 3196d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 31977fa40910SJulius Werner int retries = 3; 3198d99f6b41SDan Williams 31997fa40910SJulius Werner retry: 32003cd12f91SDan Williams /* Is a warm reset needed to recover the connection? */ 32013cd12f91SDan Williams if (status == 0 && udev->reset_resume 32023cd12f91SDan Williams && hub_port_warm_reset_required(hub, port1, portstatus)) { 32033cd12f91SDan Williams /* pass */; 32043cd12f91SDan Williams } 3205b01b03f3SAlan Stern /* Is the device still present? */ 32063cd12f91SDan Williams else if (status || port_is_suspended(hub, portstatus) || 3207f061f43dSMichael Grzeschik !usb_port_is_power_on(hub, portstatus)) { 3208b01b03f3SAlan Stern if (status >= 0) 3209b01b03f3SAlan Stern status = -ENODEV; 32107fa40910SJulius Werner } else if (!(portstatus & USB_PORT_STAT_CONNECTION)) { 32117fa40910SJulius Werner if (retries--) { 32127fa40910SJulius Werner usleep_range(200, 300); 3213f061f43dSMichael Grzeschik status = usb_hub_port_status(hub, port1, &portstatus, 32147fa40910SJulius Werner &portchange); 32157fa40910SJulius Werner goto retry; 32167fa40910SJulius Werner } 32177fa40910SJulius Werner status = -ENODEV; 3218b01b03f3SAlan Stern } 3219b01b03f3SAlan Stern 322086c57edfSAlan Stern /* Can't do a normal resume if the port isn't enabled, 322186c57edfSAlan Stern * so try a reset-resume instead. 322286c57edfSAlan Stern */ 322386c57edfSAlan Stern else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) { 322486c57edfSAlan Stern if (udev->persist_enabled) 322586c57edfSAlan Stern udev->reset_resume = 1; 322686c57edfSAlan Stern else 3227b01b03f3SAlan Stern status = -ENODEV; 322886c57edfSAlan Stern } 3229b01b03f3SAlan Stern 3230b01b03f3SAlan Stern if (status) { 3231d99f6b41SDan Williams dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n", 3232d99f6b41SDan Williams portchange, portstatus, status); 3233b01b03f3SAlan Stern } else if (udev->reset_resume) { 3234b01b03f3SAlan Stern 3235b01b03f3SAlan Stern /* Late port handoff can set status-change bits */ 3236b01b03f3SAlan Stern if (portchange & USB_PORT_STAT_C_CONNECTION) 3237ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 3238b01b03f3SAlan Stern USB_PORT_FEAT_C_CONNECTION); 3239b01b03f3SAlan Stern if (portchange & USB_PORT_STAT_C_ENABLE) 3240ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 3241b01b03f3SAlan Stern USB_PORT_FEAT_C_ENABLE); 32429f952e26SAlan Stern 32439f952e26SAlan Stern /* 32449f952e26SAlan Stern * Whatever made this reset-resume necessary may have 32459f952e26SAlan Stern * turned on the port1 bit in hub->change_bits. But after 32469f952e26SAlan Stern * a successful reset-resume we want the bit to be clear; 32479f952e26SAlan Stern * if it was on it would indicate that something happened 32489f952e26SAlan Stern * following the reset-resume. 32499f952e26SAlan Stern */ 32509f952e26SAlan Stern clear_bit(port1, hub->change_bits); 3251b01b03f3SAlan Stern } 3252b01b03f3SAlan Stern 3253b01b03f3SAlan Stern return status; 3254b01b03f3SAlan Stern } 3255b01b03f3SAlan Stern 3256f74631e3SSarah Sharp int usb_disable_ltm(struct usb_device *udev) 3257f74631e3SSarah Sharp { 3258f74631e3SSarah Sharp struct usb_hcd *hcd = bus_to_hcd(udev->bus); 3259f74631e3SSarah Sharp 3260f74631e3SSarah Sharp /* Check if the roothub and device supports LTM. */ 3261f74631e3SSarah Sharp if (!usb_device_supports_ltm(hcd->self.root_hub) || 3262f74631e3SSarah Sharp !usb_device_supports_ltm(udev)) 3263f74631e3SSarah Sharp return 0; 3264f74631e3SSarah Sharp 3265f74631e3SSarah Sharp /* Clear Feature LTM Enable can only be sent if the device is 3266f74631e3SSarah Sharp * configured. 3267f74631e3SSarah Sharp */ 3268f74631e3SSarah Sharp if (!udev->actconfig) 3269f74631e3SSarah Sharp return 0; 3270f74631e3SSarah Sharp 32711afe33a7SOliver Neukum return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 32721afe33a7SOliver Neukum USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE, 32731afe33a7SOliver Neukum USB_DEVICE_LTM_ENABLE, 0, NULL, 0, 32741afe33a7SOliver Neukum USB_CTRL_SET_TIMEOUT); 3275f74631e3SSarah Sharp } 3276f74631e3SSarah Sharp EXPORT_SYMBOL_GPL(usb_disable_ltm); 3277f74631e3SSarah Sharp 3278f74631e3SSarah Sharp void usb_enable_ltm(struct usb_device *udev) 3279f74631e3SSarah Sharp { 3280f74631e3SSarah Sharp struct usb_hcd *hcd = bus_to_hcd(udev->bus); 3281f74631e3SSarah Sharp 3282f74631e3SSarah Sharp /* Check if the roothub and device supports LTM. */ 3283f74631e3SSarah Sharp if (!usb_device_supports_ltm(hcd->self.root_hub) || 3284f74631e3SSarah Sharp !usb_device_supports_ltm(udev)) 3285f74631e3SSarah Sharp return; 3286f74631e3SSarah Sharp 3287f74631e3SSarah Sharp /* Set Feature LTM Enable can only be sent if the device is 3288f74631e3SSarah Sharp * configured. 3289f74631e3SSarah Sharp */ 3290f74631e3SSarah Sharp if (!udev->actconfig) 3291f74631e3SSarah Sharp return; 3292f74631e3SSarah Sharp 32931afe33a7SOliver Neukum usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 32941afe33a7SOliver Neukum USB_REQ_SET_FEATURE, USB_RECIP_DEVICE, 32951afe33a7SOliver Neukum USB_DEVICE_LTM_ENABLE, 0, NULL, 0, 32961afe33a7SOliver Neukum USB_CTRL_SET_TIMEOUT); 3297f74631e3SSarah Sharp } 3298f74631e3SSarah Sharp EXPORT_SYMBOL_GPL(usb_enable_ltm); 3299f74631e3SSarah Sharp 330054a3ac0cSLan Tianyu /* 330128e86165SAlan Stern * usb_enable_remote_wakeup - enable remote wakeup for a device 330254a3ac0cSLan Tianyu * @udev: target device 330354a3ac0cSLan Tianyu * 330428e86165SAlan Stern * For USB-2 devices: Set the device's remote wakeup feature. 330528e86165SAlan Stern * 330628e86165SAlan Stern * For USB-3 devices: Assume there's only one function on the device and 330728e86165SAlan Stern * enable remote wake for the first interface. FIXME if the interface 330828e86165SAlan Stern * association descriptor shows there's more than one function. 330954a3ac0cSLan Tianyu */ 331028e86165SAlan Stern static int usb_enable_remote_wakeup(struct usb_device *udev) 331154a3ac0cSLan Tianyu { 331228e86165SAlan Stern if (udev->speed < USB_SPEED_SUPER) 33131afe33a7SOliver Neukum return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 33141afe33a7SOliver Neukum USB_REQ_SET_FEATURE, USB_RECIP_DEVICE, 33151afe33a7SOliver Neukum USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0, 33161afe33a7SOliver Neukum USB_CTRL_SET_TIMEOUT); 331728e86165SAlan Stern else 33181afe33a7SOliver Neukum return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 33191afe33a7SOliver Neukum USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE, 332028e86165SAlan Stern USB_INTRF_FUNC_SUSPEND, 33211afe33a7SOliver Neukum USB_INTRF_FUNC_SUSPEND_RW | 33221afe33a7SOliver Neukum USB_INTRF_FUNC_SUSPEND_LP, 332328e86165SAlan Stern NULL, 0, USB_CTRL_SET_TIMEOUT); 332428e86165SAlan Stern } 332528e86165SAlan Stern 332628e86165SAlan Stern /* 332728e86165SAlan Stern * usb_disable_remote_wakeup - disable remote wakeup for a device 332828e86165SAlan Stern * @udev: target device 332928e86165SAlan Stern * 333028e86165SAlan Stern * For USB-2 devices: Clear the device's remote wakeup feature. 333128e86165SAlan Stern * 333228e86165SAlan Stern * For USB-3 devices: Assume there's only one function on the device and 333328e86165SAlan Stern * disable remote wake for the first interface. FIXME if the interface 333428e86165SAlan Stern * association descriptor shows there's more than one function. 333528e86165SAlan Stern */ 333628e86165SAlan Stern static int usb_disable_remote_wakeup(struct usb_device *udev) 333728e86165SAlan Stern { 333828e86165SAlan Stern if (udev->speed < USB_SPEED_SUPER) 33391afe33a7SOliver Neukum return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 33401afe33a7SOliver Neukum USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE, 334128e86165SAlan Stern USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0, 334228e86165SAlan Stern USB_CTRL_SET_TIMEOUT); 334328e86165SAlan Stern else 33441afe33a7SOliver Neukum return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 33451afe33a7SOliver Neukum USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE, 334654a3ac0cSLan Tianyu USB_INTRF_FUNC_SUSPEND, 0, NULL, 0, 334754a3ac0cSLan Tianyu USB_CTRL_SET_TIMEOUT); 334854a3ac0cSLan Tianyu } 33491da177e4SLinus Torvalds 3350e583d9dbSAlan Stern /* Count of wakeup-enabled devices at or below udev */ 33517a6127e3SDouglas Anderson unsigned usb_wakeup_enabled_descendants(struct usb_device *udev) 3352e583d9dbSAlan Stern { 3353e583d9dbSAlan Stern struct usb_hub *hub = usb_hub_to_struct_hub(udev); 3354e583d9dbSAlan Stern 3355e583d9dbSAlan Stern return udev->do_remote_wakeup + 3356e583d9dbSAlan Stern (hub ? hub->wakeup_enabled_descendants : 0); 3357e583d9dbSAlan Stern } 33587a6127e3SDouglas Anderson EXPORT_SYMBOL_GPL(usb_wakeup_enabled_descendants); 3359e583d9dbSAlan Stern 33601da177e4SLinus Torvalds /* 3361140d8f68SAlan Stern * usb_port_suspend - suspend a usb device's upstream port 3362624d6c07SAlan Stern * @udev: device that's no longer in active use, not a root hub 33635edbfb7cSDavid Brownell * Context: must be able to sleep; device not locked; pm locks held 33641da177e4SLinus Torvalds * 33651da177e4SLinus Torvalds * Suspends a USB device that isn't in active use, conserving power. 33661da177e4SLinus Torvalds * Devices may wake out of a suspend, if anything important happens, 33671da177e4SLinus Torvalds * using the remote wakeup mechanism. They may also be taken out of 3368140d8f68SAlan Stern * suspend by the host, using usb_port_resume(). It's also routine 33691da177e4SLinus Torvalds * to disconnect devices while they are suspended. 33701da177e4SLinus Torvalds * 3371390a8c34SDavid Brownell * This only affects the USB hardware for a device; its interfaces 3372390a8c34SDavid Brownell * (and, for hubs, child devices) must already have been suspended. 3373390a8c34SDavid Brownell * 3374624d6c07SAlan Stern * Selective port suspend reduces power; most suspended devices draw 3375624d6c07SAlan Stern * less than 500 uA. It's also used in OTG, along with remote wakeup. 3376624d6c07SAlan Stern * All devices below the suspended port are also suspended. 3377624d6c07SAlan Stern * 3378624d6c07SAlan Stern * Devices leave suspend state when the host wakes them up. Some devices 3379624d6c07SAlan Stern * also support "remote wakeup", where the device can activate the USB 3380624d6c07SAlan Stern * tree above them to deliver data, such as a keypress or packet. In 3381624d6c07SAlan Stern * some cases, this wakes the USB host. 3382624d6c07SAlan Stern * 33831da177e4SLinus Torvalds * Suspending OTG devices may trigger HNP, if that's been enabled 33841da177e4SLinus Torvalds * between a pair of dual-role devices. That will change roles, such 33851da177e4SLinus Torvalds * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral. 33861da177e4SLinus Torvalds * 33874956eccdSAlan Stern * Devices on USB hub ports have only one "suspend" state, corresponding 33884956eccdSAlan Stern * to ACPI D2, "may cause the device to lose some context". 33894956eccdSAlan Stern * State transitions include: 33904956eccdSAlan Stern * 33914956eccdSAlan Stern * - suspend, resume ... when the VBUS power link stays live 33924956eccdSAlan Stern * - suspend, disconnect ... VBUS lost 33934956eccdSAlan Stern * 33944956eccdSAlan Stern * Once VBUS drop breaks the circuit, the port it's using has to go through 33954956eccdSAlan Stern * normal re-enumeration procedures, starting with enabling VBUS power. 33964956eccdSAlan Stern * Other than re-initializing the hub (plug/unplug, except for root hubs), 339737ebb549SPetr Mladek * Linux (2.6) currently has NO mechanisms to initiate that: no hub_wq 33984956eccdSAlan Stern * timer, no SRP, no requests through sysfs. 33994956eccdSAlan Stern * 3400e583d9dbSAlan Stern * If Runtime PM isn't enabled or used, non-SuperSpeed devices may not get 3401e583d9dbSAlan Stern * suspended until their bus goes into global suspend (i.e., the root 34020aa2832dSAlan Stern * hub is suspended). Nevertheless, we change @udev->state to 34030aa2832dSAlan Stern * USB_STATE_SUSPENDED as this is the device's "logical" state. The actual 34040aa2832dSAlan Stern * upstream port setting is stored in @udev->port_is_suspended. 34054956eccdSAlan Stern * 34061da177e4SLinus Torvalds * Returns 0 on success, else negative errno. 34071da177e4SLinus Torvalds */ 340865bfd296SAlan Stern int usb_port_suspend(struct usb_device *udev, pm_message_t msg) 34091da177e4SLinus Torvalds { 3410ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); 3411ad493e5eSLan Tianyu struct usb_port *port_dev = hub->ports[udev->portnum - 1]; 3412624d6c07SAlan Stern int port1 = udev->portnum; 3413624d6c07SAlan Stern int status; 34140aa2832dSAlan Stern bool really_suspend = true; 34154956eccdSAlan Stern 34165c79a1e3SDan Williams usb_lock_port(port_dev); 34175c79a1e3SDan Williams 3418624d6c07SAlan Stern /* enable remote wakeup when appropriate; this lets the device 3419624d6c07SAlan Stern * wake up the upstream hub (including maybe the root hub). 3420624d6c07SAlan Stern * 3421624d6c07SAlan Stern * NOTE: OTG devices may issue remote wakeup (or SRP) even when 3422624d6c07SAlan Stern * we don't explicitly enable it here. 3423624d6c07SAlan Stern */ 3424624d6c07SAlan Stern if (udev->do_remote_wakeup) { 342528e86165SAlan Stern status = usb_enable_remote_wakeup(udev); 34260c487206SOliver Neukum if (status) { 3427624d6c07SAlan Stern dev_dbg(&udev->dev, "won't remote wakeup, status %d\n", 3428624d6c07SAlan Stern status); 34290c487206SOliver Neukum /* bail if autosuspend is requested */ 34305b1b0b81SAlan Stern if (PMSG_IS_AUTO(msg)) 34314fae6f0fSAlan Stern goto err_wakeup; 34320c487206SOliver Neukum } 3433624d6c07SAlan Stern } 3434624d6c07SAlan Stern 343565580b43SAndiry Xu /* disable USB2 hardware LPM */ 34367529b257SKai-Heng Feng usb_disable_usb2_hardware_lpm(udev); 343765580b43SAndiry Xu 3438f74631e3SSarah Sharp if (usb_disable_ltm(udev)) { 34391ccc417eSJoe Perches dev_err(&udev->dev, "Failed to disable LTM before suspend\n"); 34404fae6f0fSAlan Stern status = -ENOMEM; 34414fae6f0fSAlan Stern if (PMSG_IS_AUTO(msg)) 34424fae6f0fSAlan Stern goto err_ltm; 3443f74631e3SSarah Sharp } 34448306095fSSarah Sharp 3445624d6c07SAlan Stern /* see 7.1.7.6 */ 3446a7114230SAndiry Xu if (hub_is_superspeed(hub->hdev)) 3447c2f60db7SSarah Sharp status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3); 3448e583d9dbSAlan Stern 34490aa2832dSAlan Stern /* 34500aa2832dSAlan Stern * For system suspend, we do not need to enable the suspend feature 34510aa2832dSAlan Stern * on individual USB-2 ports. The devices will automatically go 34520aa2832dSAlan Stern * into suspend a few ms after the root hub stops sending packets. 34530aa2832dSAlan Stern * The USB 2.0 spec calls this "global suspend". 3454e583d9dbSAlan Stern * 3455e583d9dbSAlan Stern * However, many USB hubs have a bug: They don't relay wakeup requests 3456e583d9dbSAlan Stern * from a downstream port if the port's suspend feature isn't on. 3457e583d9dbSAlan Stern * Therefore we will turn on the suspend feature if udev or any of its 3458e583d9dbSAlan Stern * descendants is enabled for remote wakeup. 34590aa2832dSAlan Stern */ 34607a6127e3SDouglas Anderson else if (PMSG_IS_AUTO(msg) || usb_wakeup_enabled_descendants(udev) > 0) 3461e583d9dbSAlan Stern status = set_port_feature(hub->hdev, port1, 3462e583d9dbSAlan Stern USB_PORT_FEAT_SUSPEND); 34630aa2832dSAlan Stern else { 34640aa2832dSAlan Stern really_suspend = false; 34650aa2832dSAlan Stern status = 0; 34660aa2832dSAlan Stern } 3467624d6c07SAlan Stern if (status) { 346871424523SChris Chiu /* Check if the port has been suspended for the timeout case 346971424523SChris Chiu * to prevent the suspended port from incorrect handling. 347071424523SChris Chiu */ 347171424523SChris Chiu if (status == -ETIMEDOUT) { 347271424523SChris Chiu int ret; 347371424523SChris Chiu u16 portstatus, portchange; 347471424523SChris Chiu 347571424523SChris Chiu portstatus = portchange = 0; 3476f061f43dSMichael Grzeschik ret = usb_hub_port_status(hub, port1, &portstatus, 347771424523SChris Chiu &portchange); 347871424523SChris Chiu 347971424523SChris Chiu dev_dbg(&port_dev->dev, 348071424523SChris Chiu "suspend timeout, status %04x\n", portstatus); 348171424523SChris Chiu 348271424523SChris Chiu if (ret == 0 && port_is_suspended(hub, portstatus)) { 348371424523SChris Chiu status = 0; 348471424523SChris Chiu goto suspend_done; 348571424523SChris Chiu } 348671424523SChris Chiu } 348771424523SChris Chiu 3488d99f6b41SDan Williams dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status); 3489cbb33004SAlan Stern 3490d590c231SMathias Nyman /* Try to enable USB3 LTM again */ 34914fae6f0fSAlan Stern usb_enable_ltm(udev); 34924fae6f0fSAlan Stern err_ltm: 3493c3e751e4SAndiry Xu /* Try to enable USB2 hardware LPM again */ 34947529b257SKai-Heng Feng usb_enable_usb2_hardware_lpm(udev); 3495c3e751e4SAndiry Xu 34964fae6f0fSAlan Stern if (udev->do_remote_wakeup) 34974fae6f0fSAlan Stern (void) usb_disable_remote_wakeup(udev); 34984fae6f0fSAlan Stern err_wakeup: 34998306095fSSarah Sharp 3500cbb33004SAlan Stern /* System sleep transitions should never fail */ 35015b1b0b81SAlan Stern if (!PMSG_IS_AUTO(msg)) 3502cbb33004SAlan Stern status = 0; 3503624d6c07SAlan Stern } else { 350471424523SChris Chiu suspend_done: 350530b1a7a3SAlan Stern dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n", 350630b1a7a3SAlan Stern (PMSG_IS_AUTO(msg) ? "auto-" : ""), 350730b1a7a3SAlan Stern udev->do_remote_wakeup); 35080aa2832dSAlan Stern if (really_suspend) { 3509bfd1e910SAlan Stern udev->port_is_suspended = 1; 3510e583d9dbSAlan Stern 3511e583d9dbSAlan Stern /* device has up to 10 msec to fully suspend */ 3512624d6c07SAlan Stern msleep(10); 3513624d6c07SAlan Stern } 3514e583d9dbSAlan Stern usb_set_device_state(udev, USB_STATE_SUSPENDED); 35150aa2832dSAlan Stern } 3516ad493e5eSLan Tianyu 3517d5c3834eSDan Williams if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled 3518d5c3834eSDan Williams && test_and_clear_bit(port1, hub->child_usage_bits)) 3519ad493e5eSLan Tianyu pm_runtime_put_sync(&port_dev->dev); 3520ad493e5eSLan Tianyu 3521c08512c7SAlan Stern usb_mark_last_busy(hub->hdev); 35225c79a1e3SDan Williams 35235c79a1e3SDan Williams usb_unlock_port(port_dev); 35244956eccdSAlan Stern return status; 35251da177e4SLinus Torvalds } 3526f3f3253dSDavid Brownell 35271da177e4SLinus Torvalds /* 3528390a8c34SDavid Brownell * If the USB "suspend" state is in use (rather than "global suspend"), 3529390a8c34SDavid Brownell * many devices will be individually taken out of suspend state using 353054515fe5SAlan Stern * special "resume" signaling. This routine kicks in shortly after 35311da177e4SLinus Torvalds * hardware resume signaling is finished, either because of selective 35321da177e4SLinus Torvalds * resume (by host) or remote wakeup (by device) ... now see what changed 35331da177e4SLinus Torvalds * in the tree that's rooted at this device. 353454515fe5SAlan Stern * 353554515fe5SAlan Stern * If @udev->reset_resume is set then the device is reset before the 353654515fe5SAlan Stern * status check is done. 35371da177e4SLinus Torvalds */ 3538140d8f68SAlan Stern static int finish_port_resume(struct usb_device *udev) 35391da177e4SLinus Torvalds { 354054515fe5SAlan Stern int status = 0; 354107e72b95SOliver Neukum u16 devstatus = 0; 35421da177e4SLinus Torvalds 35431da177e4SLinus Torvalds /* caller owns the udev device lock */ 3544b9cef6c3SWu Fengguang dev_dbg(&udev->dev, "%s\n", 3545b9cef6c3SWu Fengguang udev->reset_resume ? "finish reset-resume" : "finish resume"); 35461da177e4SLinus Torvalds 35471da177e4SLinus Torvalds /* usb ch9 identifies four variants of SUSPENDED, based on what 35481da177e4SLinus Torvalds * state the device resumes to. Linux currently won't see the 35491da177e4SLinus Torvalds * first two on the host side; they'd be inside hub_port_init() 355037ebb549SPetr Mladek * during many timeouts, but hub_wq can't suspend until later. 35511da177e4SLinus Torvalds */ 35521da177e4SLinus Torvalds usb_set_device_state(udev, udev->actconfig 35531da177e4SLinus Torvalds ? USB_STATE_CONFIGURED 35541da177e4SLinus Torvalds : USB_STATE_ADDRESS); 35551da177e4SLinus Torvalds 355654515fe5SAlan Stern /* 10.5.4.5 says not to reset a suspended port if the attached 355754515fe5SAlan Stern * device is enabled for remote wakeup. Hence the reset 355854515fe5SAlan Stern * operation is carried out here, after the port has been 355954515fe5SAlan Stern * resumed. 356054515fe5SAlan Stern */ 35611d10255cSAlan Stern if (udev->reset_resume) { 35621d10255cSAlan Stern /* 35631d10255cSAlan Stern * If the device morphs or switches modes when it is reset, 35641d10255cSAlan Stern * we don't want to perform a reset-resume. We'll fail the 35651d10255cSAlan Stern * resume, which will cause a logical disconnect, and then 35661d10255cSAlan Stern * the device will be rediscovered. 35671d10255cSAlan Stern */ 356886c57edfSAlan Stern retry_reset_resume: 35691d10255cSAlan Stern if (udev->quirks & USB_QUIRK_RESET) 35701d10255cSAlan Stern status = -ENODEV; 35711d10255cSAlan Stern else 3572742120c6SMing Lei status = usb_reset_and_verify_device(udev); 35731d10255cSAlan Stern } 357454515fe5SAlan Stern 35751da177e4SLinus Torvalds /* 10.5.4.5 says be sure devices in the tree are still there. 35761da177e4SLinus Torvalds * For now let's assume the device didn't go crazy on resume, 35771da177e4SLinus Torvalds * and device drivers will know about any resume quirks. 35781da177e4SLinus Torvalds */ 357954515fe5SAlan Stern if (status == 0) { 358046dede46SAlan Stern devstatus = 0; 3581d9e1e148SFelipe Balbi status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, &devstatus); 358286c57edfSAlan Stern 358386c57edfSAlan Stern /* If a normal resume failed, try doing a reset-resume */ 358486c57edfSAlan Stern if (status && !udev->reset_resume && udev->persist_enabled) { 358586c57edfSAlan Stern dev_dbg(&udev->dev, "retry with reset-resume\n"); 358686c57edfSAlan Stern udev->reset_resume = 1; 358786c57edfSAlan Stern goto retry_reset_resume; 358886c57edfSAlan Stern } 358954515fe5SAlan Stern } 3590b40b7a90SAlan Stern 3591624d6c07SAlan Stern if (status) { 3592624d6c07SAlan Stern dev_dbg(&udev->dev, "gone after usb resume? status %d\n", 35931da177e4SLinus Torvalds status); 359407e72b95SOliver Neukum /* 359507e72b95SOliver Neukum * There are a few quirky devices which violate the standard 359607e72b95SOliver Neukum * by claiming to have remote wakeup enabled after a reset, 359707e72b95SOliver Neukum * which crash if the feature is cleared, hence check for 359807e72b95SOliver Neukum * udev->reset_resume 359907e72b95SOliver Neukum */ 360007e72b95SOliver Neukum } else if (udev->actconfig && !udev->reset_resume) { 360128e86165SAlan Stern if (udev->speed < USB_SPEED_SUPER) { 360254a3ac0cSLan Tianyu if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) 360328e86165SAlan Stern status = usb_disable_remote_wakeup(udev); 360454a3ac0cSLan Tianyu } else { 3605d9e1e148SFelipe Balbi status = usb_get_std_status(udev, USB_RECIP_INTERFACE, 0, 360654a3ac0cSLan Tianyu &devstatus); 360754a3ac0cSLan Tianyu if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP 360854a3ac0cSLan Tianyu | USB_INTRF_STAT_FUNC_RW)) 360928e86165SAlan Stern status = usb_disable_remote_wakeup(udev); 361054a3ac0cSLan Tianyu } 361154a3ac0cSLan Tianyu 3612a8e7c565SAlan Stern if (status) 3613b9cef6c3SWu Fengguang dev_dbg(&udev->dev, 3614b9cef6c3SWu Fengguang "disable remote wakeup, status %d\n", 3615b9cef6c3SWu Fengguang status); 36161da177e4SLinus Torvalds status = 0; 36171da177e4SLinus Torvalds } 36181da177e4SLinus Torvalds return status; 36191da177e4SLinus Torvalds } 36201da177e4SLinus Torvalds 3621624d6c07SAlan Stern /* 3622a40178b2SPratyush Anand * There are some SS USB devices which take longer time for link training. 3623a40178b2SPratyush Anand * XHCI specs 4.19.4 says that when Link training is successful, port 36246b82b122SAl Cooper * sets CCS bit to 1. So if SW reads port status before successful link 3625a40178b2SPratyush Anand * training, then it will not find device to be present. 3626a40178b2SPratyush Anand * USB Analyzer log with such buggy devices show that in some cases 3627a40178b2SPratyush Anand * device switch on the RX termination after long delay of host enabling 3628a40178b2SPratyush Anand * the VBUS. In few other cases it has been seen that device fails to 3629a40178b2SPratyush Anand * negotiate link training in first attempt. It has been 3630a40178b2SPratyush Anand * reported till now that few devices take as long as 2000 ms to train 3631a40178b2SPratyush Anand * the link after host enabling its VBUS and termination. Following 3632a40178b2SPratyush Anand * routine implements a 2000 ms timeout for link training. If in a case 3633a40178b2SPratyush Anand * link trains before timeout, loop will exit earlier. 3634a40178b2SPratyush Anand * 36356b82b122SAl Cooper * There are also some 2.0 hard drive based devices and 3.0 thumb 36366b82b122SAl Cooper * drives that, when plugged into a 2.0 only port, take a long 36376b82b122SAl Cooper * time to set CCS after VBUS enable. 36386b82b122SAl Cooper * 3639a40178b2SPratyush Anand * FIXME: If a device was connected before suspend, but was removed 3640a40178b2SPratyush Anand * while system was asleep, then the loop in the following routine will 3641a40178b2SPratyush Anand * only exit at timeout. 3642a40178b2SPratyush Anand * 36436b82b122SAl Cooper * This routine should only be called when persist is enabled. 3644a40178b2SPratyush Anand */ 36456b82b122SAl Cooper static int wait_for_connected(struct usb_device *udev, 3646b8f1ba99SDan Carpenter struct usb_hub *hub, int port1, 3647a40178b2SPratyush Anand u16 *portchange, u16 *portstatus) 3648a40178b2SPratyush Anand { 3649a40178b2SPratyush Anand int status = 0, delay_ms = 0; 3650a40178b2SPratyush Anand 3651a40178b2SPratyush Anand while (delay_ms < 2000) { 3652a40178b2SPratyush Anand if (status || *portstatus & USB_PORT_STAT_CONNECTION) 3653a40178b2SPratyush Anand break; 3654f061f43dSMichael Grzeschik if (!usb_port_is_power_on(hub, *portstatus)) { 36555d111f51SDominik Bozek status = -ENODEV; 36565d111f51SDominik Bozek break; 36575d111f51SDominik Bozek } 3658a40178b2SPratyush Anand msleep(20); 3659a40178b2SPratyush Anand delay_ms += 20; 3660f061f43dSMichael Grzeschik status = usb_hub_port_status(hub, port1, portstatus, portchange); 3661a40178b2SPratyush Anand } 36626b82b122SAl Cooper dev_dbg(&udev->dev, "Waited %dms for CONNECT\n", delay_ms); 3663a40178b2SPratyush Anand return status; 3664a40178b2SPratyush Anand } 3665a40178b2SPratyush Anand 3666a40178b2SPratyush Anand /* 3667624d6c07SAlan Stern * usb_port_resume - re-activate a suspended usb device's upstream port 3668624d6c07SAlan Stern * @udev: device to re-activate, not a root hub 3669624d6c07SAlan Stern * Context: must be able to sleep; device not locked; pm locks held 3670624d6c07SAlan Stern * 3671624d6c07SAlan Stern * This will re-activate the suspended device, increasing power usage 3672624d6c07SAlan Stern * while letting drivers communicate again with its endpoints. 3673624d6c07SAlan Stern * USB resume explicitly guarantees that the power session between 3674624d6c07SAlan Stern * the host and the device is the same as it was when the device 3675624d6c07SAlan Stern * suspended. 3676624d6c07SAlan Stern * 3677feccc30dSAlan Stern * If @udev->reset_resume is set then this routine won't check that the 3678feccc30dSAlan Stern * port is still enabled. Furthermore, finish_port_resume() above will 367954515fe5SAlan Stern * reset @udev. The end result is that a broken power session can be 368054515fe5SAlan Stern * recovered and @udev will appear to persist across a loss of VBUS power. 368154515fe5SAlan Stern * 368254515fe5SAlan Stern * For example, if a host controller doesn't maintain VBUS suspend current 368354515fe5SAlan Stern * during a system sleep or is reset when the system wakes up, all the USB 368454515fe5SAlan Stern * power sessions below it will be broken. This is especially troublesome 368554515fe5SAlan Stern * for mass-storage devices containing mounted filesystems, since the 368654515fe5SAlan Stern * device will appear to have disconnected and all the memory mappings 368754515fe5SAlan Stern * to it will be lost. Using the USB_PERSIST facility, the device can be 368854515fe5SAlan Stern * made to appear as if it had not disconnected. 368954515fe5SAlan Stern * 3690742120c6SMing Lei * This facility can be dangerous. Although usb_reset_and_verify_device() makes 3691feccc30dSAlan Stern * every effort to insure that the same device is present after the 369254515fe5SAlan Stern * reset as before, it cannot provide a 100% guarantee. Furthermore it's 369354515fe5SAlan Stern * quite possible for a device to remain unaltered but its media to be 369454515fe5SAlan Stern * changed. If the user replaces a flash memory card while the system is 369554515fe5SAlan Stern * asleep, he will have only himself to blame when the filesystem on the 369654515fe5SAlan Stern * new card is corrupted and the system crashes. 369754515fe5SAlan Stern * 3698624d6c07SAlan Stern * Returns 0 on success, else negative errno. 3699624d6c07SAlan Stern */ 370065bfd296SAlan Stern int usb_port_resume(struct usb_device *udev, pm_message_t msg) 37011da177e4SLinus Torvalds { 3702ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); 3703ad493e5eSLan Tianyu struct usb_port *port_dev = hub->ports[udev->portnum - 1]; 3704624d6c07SAlan Stern int port1 = udev->portnum; 37051da177e4SLinus Torvalds int status; 3706d25450c6SAlan Stern u16 portchange, portstatus; 3707d25450c6SAlan Stern 3708d5c3834eSDan Williams if (!test_and_set_bit(port1, hub->child_usage_bits)) { 3709025f97d1SBixuan Cui status = pm_runtime_resume_and_get(&port_dev->dev); 3710ad493e5eSLan Tianyu if (status < 0) { 3711ad493e5eSLan Tianyu dev_dbg(&udev->dev, "can't resume usb port, status %d\n", 3712ad493e5eSLan Tianyu status); 3713ad493e5eSLan Tianyu return status; 3714ad493e5eSLan Tianyu } 3715ad493e5eSLan Tianyu } 3716ad493e5eSLan Tianyu 37175c79a1e3SDan Williams usb_lock_port(port_dev); 37185c79a1e3SDan Williams 3719d25450c6SAlan Stern /* Skip the initial Clear-Suspend step for a remote wakeup */ 3720f061f43dSMichael Grzeschik status = usb_hub_port_status(hub, port1, &portstatus, &portchange); 372183a62c51SRavi Chandra Sadineni if (status == 0 && !port_is_suspended(hub, portstatus)) { 372283a62c51SRavi Chandra Sadineni if (portchange & USB_PORT_STAT_C_SUSPEND) 372383a62c51SRavi Chandra Sadineni pm_wakeup_event(&udev->dev, 0); 3724d25450c6SAlan Stern goto SuspendCleared; 372583a62c51SRavi Chandra Sadineni } 37261da177e4SLinus Torvalds 37271da177e4SLinus Torvalds /* see 7.1.7.7; affects power usage, but not budgeting */ 3728a7114230SAndiry Xu if (hub_is_superspeed(hub->hdev)) 3729c2f60db7SSarah Sharp status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0); 3730a7114230SAndiry Xu else 3731ad493e5eSLan Tianyu status = usb_clear_port_feature(hub->hdev, 37321da177e4SLinus Torvalds port1, USB_PORT_FEAT_SUSPEND); 37331da177e4SLinus Torvalds if (status) { 3734d99f6b41SDan Williams dev_dbg(&port_dev->dev, "can't resume, status %d\n", status); 37351da177e4SLinus Torvalds } else { 3736bbc78c07SFelipe Balbi /* drive resume for USB_RESUME_TIMEOUT msec */ 3737645daaabSAlan Stern dev_dbg(&udev->dev, "usb %sresume\n", 37385b1b0b81SAlan Stern (PMSG_IS_AUTO(msg) ? "auto-" : "")); 3739bbc78c07SFelipe Balbi msleep(USB_RESUME_TIMEOUT); 37401da177e4SLinus Torvalds 37411da177e4SLinus Torvalds /* Virtual root hubs can trigger on GET_PORT_STATUS to 37421da177e4SLinus Torvalds * stop resume signaling. Then finish the resume 37431da177e4SLinus Torvalds * sequence. 37441da177e4SLinus Torvalds */ 3745f061f43dSMichael Grzeschik status = usb_hub_port_status(hub, port1, &portstatus, &portchange); 37461da177e4SLinus Torvalds } 3747b01b03f3SAlan Stern 3748b01b03f3SAlan Stern SuspendCleared: 3749b01b03f3SAlan Stern if (status == 0) { 3750bfd1e910SAlan Stern udev->port_is_suspended = 0; 3751a7114230SAndiry Xu if (hub_is_superspeed(hub->hdev)) { 3752a7114230SAndiry Xu if (portchange & USB_PORT_STAT_C_LINK_STATE) 3753ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 3754a7114230SAndiry Xu USB_PORT_FEAT_C_PORT_LINK_STATE); 3755a7114230SAndiry Xu } else { 3756b01b03f3SAlan Stern if (portchange & USB_PORT_STAT_C_SUSPEND) 3757ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 3758b01b03f3SAlan Stern USB_PORT_FEAT_C_SUSPEND); 37591da177e4SLinus Torvalds } 3760975f94c7SChunfeng Yun 3761975f94c7SChunfeng Yun /* TRSMRCY = 10 msec */ 3762975f94c7SChunfeng Yun msleep(10); 3763a7114230SAndiry Xu } 37641da177e4SLinus Torvalds 37656b82b122SAl Cooper if (udev->persist_enabled) 3766b8f1ba99SDan Carpenter status = wait_for_connected(udev, hub, port1, &portchange, 3767a40178b2SPratyush Anand &portstatus); 3768a40178b2SPratyush Anand 3769b01b03f3SAlan Stern status = check_port_resume_type(udev, 3770b01b03f3SAlan Stern hub, port1, status, portchange, portstatus); 377154515fe5SAlan Stern if (status == 0) 377254515fe5SAlan Stern status = finish_port_resume(udev); 377354515fe5SAlan Stern if (status < 0) { 377454515fe5SAlan Stern dev_dbg(&udev->dev, "can't resume, status %d\n", status); 377554515fe5SAlan Stern hub_port_logical_disconnect(hub, port1); 377665580b43SAndiry Xu } else { 377765580b43SAndiry Xu /* Try to enable USB2 hardware LPM */ 37787529b257SKai-Heng Feng usb_enable_usb2_hardware_lpm(udev); 37798306095fSSarah Sharp 3780d590c231SMathias Nyman /* Try to enable USB3 LTM */ 3781f74631e3SSarah Sharp usb_enable_ltm(udev); 378254515fe5SAlan Stern } 378365580b43SAndiry Xu 37845c79a1e3SDan Williams usb_unlock_port(port_dev); 37855c79a1e3SDan Williams 37861da177e4SLinus Torvalds return status; 37871da177e4SLinus Torvalds } 37881da177e4SLinus Torvalds 37890534d468SAlan Stern int usb_remote_wakeup(struct usb_device *udev) 37901da177e4SLinus Torvalds { 37911da177e4SLinus Torvalds int status = 0; 37921da177e4SLinus Torvalds 37935c79a1e3SDan Williams usb_lock_device(udev); 37941da177e4SLinus Torvalds if (udev->state == USB_STATE_SUSPENDED) { 3795645daaabSAlan Stern dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-"); 37969bbdf1e0SAlan Stern status = usb_autoresume_device(udev); 37979bbdf1e0SAlan Stern if (status == 0) { 37989bbdf1e0SAlan Stern /* Let the drivers do their thing, then... */ 37999bbdf1e0SAlan Stern usb_autosuspend_device(udev); 38009bbdf1e0SAlan Stern } 3801d25450c6SAlan Stern } 38025c79a1e3SDan Williams usb_unlock_device(udev); 38031da177e4SLinus Torvalds return status; 38041da177e4SLinus Torvalds } 38051da177e4SLinus Torvalds 38067e73be22SDan Williams /* Returns 1 if there was a remote wakeup and a connect status change. */ 38077e73be22SDan Williams static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port, 38087e73be22SDan Williams u16 portstatus, u16 portchange) 38097e73be22SDan Williams __must_hold(&port_dev->status_lock) 38107e73be22SDan Williams { 38117e73be22SDan Williams struct usb_port *port_dev = hub->ports[port - 1]; 38127e73be22SDan Williams struct usb_device *hdev; 38137e73be22SDan Williams struct usb_device *udev; 38147e73be22SDan Williams int connect_change = 0; 3815e244c469SLee, Chiasheng u16 link_state; 38167e73be22SDan Williams int ret; 38177e73be22SDan Williams 38187e73be22SDan Williams hdev = hub->hdev; 38197e73be22SDan Williams udev = port_dev->child; 38207e73be22SDan Williams if (!hub_is_superspeed(hdev)) { 38217e73be22SDan Williams if (!(portchange & USB_PORT_STAT_C_SUSPEND)) 38227e73be22SDan Williams return 0; 38237e73be22SDan Williams usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND); 38247e73be22SDan Williams } else { 3825e244c469SLee, Chiasheng link_state = portstatus & USB_PORT_STAT_LINK_STATE; 38267e73be22SDan Williams if (!udev || udev->state != USB_STATE_SUSPENDED || 3827e244c469SLee, Chiasheng (link_state != USB_SS_PORT_LS_U0 && 3828e244c469SLee, Chiasheng link_state != USB_SS_PORT_LS_U1 && 3829e244c469SLee, Chiasheng link_state != USB_SS_PORT_LS_U2)) 38307e73be22SDan Williams return 0; 38317e73be22SDan Williams } 38327e73be22SDan Williams 38337e73be22SDan Williams if (udev) { 38347e73be22SDan Williams /* TRSMRCY = 10 msec */ 38357e73be22SDan Williams msleep(10); 38367e73be22SDan Williams 38377e73be22SDan Williams usb_unlock_port(port_dev); 38387e73be22SDan Williams ret = usb_remote_wakeup(udev); 38397e73be22SDan Williams usb_lock_port(port_dev); 38407e73be22SDan Williams if (ret < 0) 38417e73be22SDan Williams connect_change = 1; 38427e73be22SDan Williams } else { 38437e73be22SDan Williams ret = -ENODEV; 38447e73be22SDan Williams hub_port_disable(hub, port, 1); 38457e73be22SDan Williams } 38467e73be22SDan Williams dev_dbg(&port_dev->dev, "resume, status %d\n", ret); 38477e73be22SDan Williams return connect_change; 38487e73be22SDan Williams } 38497e73be22SDan Williams 3850e6f30deaSMing Lei static int check_ports_changed(struct usb_hub *hub) 3851e6f30deaSMing Lei { 3852e6f30deaSMing Lei int port1; 3853e6f30deaSMing Lei 3854e6f30deaSMing Lei for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) { 3855e6f30deaSMing Lei u16 portstatus, portchange; 3856e6f30deaSMing Lei int status; 3857e6f30deaSMing Lei 3858f061f43dSMichael Grzeschik status = usb_hub_port_status(hub, port1, &portstatus, &portchange); 3859e6f30deaSMing Lei if (!status && portchange) 3860e6f30deaSMing Lei return 1; 3861e6f30deaSMing Lei } 3862e6f30deaSMing Lei return 0; 3863e6f30deaSMing Lei } 3864e6f30deaSMing Lei 3865db690874SDavid Brownell static int hub_suspend(struct usb_interface *intf, pm_message_t msg) 38661da177e4SLinus Torvalds { 38671da177e4SLinus Torvalds struct usb_hub *hub = usb_get_intfdata(intf); 38681da177e4SLinus Torvalds struct usb_device *hdev = hub->hdev; 38691da177e4SLinus Torvalds unsigned port1; 38701da177e4SLinus Torvalds 3871e583d9dbSAlan Stern /* 3872e583d9dbSAlan Stern * Warn if children aren't already suspended. 3873e583d9dbSAlan Stern * Also, add up the number of wakeup-enabled descendants. 3874e583d9dbSAlan Stern */ 3875e583d9dbSAlan Stern hub->wakeup_enabled_descendants = 0; 38761da177e4SLinus Torvalds for (port1 = 1; port1 <= hdev->maxchild; port1++) { 3877d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 3878d99f6b41SDan Williams struct usb_device *udev = port_dev->child; 38791da177e4SLinus Torvalds 38806840d255SAlan Stern if (udev && udev->can_submit) { 3881b658b8f5SDan Williams dev_warn(&port_dev->dev, "device %s not suspended yet\n", 3882b658b8f5SDan Williams dev_name(&udev->dev)); 38835b1b0b81SAlan Stern if (PMSG_IS_AUTO(msg)) 3884c9f89fa4SDavid Brownell return -EBUSY; 3885c9f89fa4SDavid Brownell } 3886e583d9dbSAlan Stern if (udev) 3887e583d9dbSAlan Stern hub->wakeup_enabled_descendants += 38887a6127e3SDouglas Anderson usb_wakeup_enabled_descendants(udev); 38891da177e4SLinus Torvalds } 3890e6f30deaSMing Lei 3891e6f30deaSMing Lei if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) { 3892e6f30deaSMing Lei /* check if there are changes pending on hub ports */ 3893e6f30deaSMing Lei if (check_ports_changed(hub)) { 3894e6f30deaSMing Lei if (PMSG_IS_AUTO(msg)) 3895e6f30deaSMing Lei return -EBUSY; 3896e6f30deaSMing Lei pm_wakeup_event(&hdev->dev, 2000); 3897e6f30deaSMing Lei } 3898e6f30deaSMing Lei } 3899e6f30deaSMing Lei 39004296c70aSSarah Sharp if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) { 39014296c70aSSarah Sharp /* Enable hub to send remote wakeup for all ports. */ 39024296c70aSSarah Sharp for (port1 = 1; port1 <= hdev->maxchild; port1++) { 39033bee346bSMathieu Malaterre set_port_feature(hdev, 39044296c70aSSarah Sharp port1 | 39054296c70aSSarah Sharp USB_PORT_FEAT_REMOTE_WAKE_CONNECT | 39064296c70aSSarah Sharp USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT | 39074296c70aSSarah Sharp USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT, 39084296c70aSSarah Sharp USB_PORT_FEAT_REMOTE_WAKE_MASK); 39094296c70aSSarah Sharp } 39104296c70aSSarah Sharp } 39111da177e4SLinus Torvalds 3912441b62c1SHarvey Harrison dev_dbg(&intf->dev, "%s\n", __func__); 391340f122f3SAlan Stern 391437ebb549SPetr Mladek /* stop hub_wq and related activity */ 39154330354fSAlan Stern hub_quiesce(hub, HUB_SUSPEND); 3916b6f6436dSAlan Stern return 0; 39171da177e4SLinus Torvalds } 39181da177e4SLinus Torvalds 3919379cacc5SAlan Stern /* Report wakeup requests from the ports of a resuming root hub */ 3920379cacc5SAlan Stern static void report_wakeup_requests(struct usb_hub *hub) 3921379cacc5SAlan Stern { 3922379cacc5SAlan Stern struct usb_device *hdev = hub->hdev; 3923379cacc5SAlan Stern struct usb_device *udev; 3924379cacc5SAlan Stern struct usb_hcd *hcd; 3925379cacc5SAlan Stern unsigned long resuming_ports; 3926379cacc5SAlan Stern int i; 3927379cacc5SAlan Stern 3928379cacc5SAlan Stern if (hdev->parent) 3929379cacc5SAlan Stern return; /* Not a root hub */ 3930379cacc5SAlan Stern 3931379cacc5SAlan Stern hcd = bus_to_hcd(hdev->bus); 3932379cacc5SAlan Stern if (hcd->driver->get_resuming_ports) { 3933379cacc5SAlan Stern 3934379cacc5SAlan Stern /* 3935379cacc5SAlan Stern * The get_resuming_ports() method returns a bitmap (origin 0) 3936379cacc5SAlan Stern * of ports which have started wakeup signaling but have not 3937379cacc5SAlan Stern * yet finished resuming. During system resume we will 3938379cacc5SAlan Stern * resume all the enabled ports, regardless of any wakeup 3939379cacc5SAlan Stern * signals, which means the wakeup requests would be lost. 3940379cacc5SAlan Stern * To prevent this, report them to the PM core here. 3941379cacc5SAlan Stern */ 3942379cacc5SAlan Stern resuming_ports = hcd->driver->get_resuming_ports(hcd); 3943379cacc5SAlan Stern for (i = 0; i < hdev->maxchild; ++i) { 3944379cacc5SAlan Stern if (test_bit(i, &resuming_ports)) { 3945379cacc5SAlan Stern udev = hub->ports[i]->child; 3946379cacc5SAlan Stern if (udev) 3947379cacc5SAlan Stern pm_wakeup_event(&udev->dev, 0); 3948379cacc5SAlan Stern } 3949379cacc5SAlan Stern } 3950379cacc5SAlan Stern } 3951379cacc5SAlan Stern } 3952379cacc5SAlan Stern 39531da177e4SLinus Torvalds static int hub_resume(struct usb_interface *intf) 39541da177e4SLinus Torvalds { 39551da177e4SLinus Torvalds struct usb_hub *hub = usb_get_intfdata(intf); 39561da177e4SLinus Torvalds 39575e6effaeSAlan Stern dev_dbg(&intf->dev, "%s\n", __func__); 3958f2835219SAlan Stern hub_activate(hub, HUB_RESUME); 3959379cacc5SAlan Stern 3960379cacc5SAlan Stern /* 3961379cacc5SAlan Stern * This should be called only for system resume, not runtime resume. 3962379cacc5SAlan Stern * We can't tell the difference here, so some wakeup requests will be 3963379cacc5SAlan Stern * reported at the wrong time or more than once. This shouldn't 3964379cacc5SAlan Stern * matter much, so long as they do get reported. 3965379cacc5SAlan Stern */ 3966379cacc5SAlan Stern report_wakeup_requests(hub); 39671da177e4SLinus Torvalds return 0; 39681da177e4SLinus Torvalds } 39691da177e4SLinus Torvalds 3970b41a60ecSAlan Stern static int hub_reset_resume(struct usb_interface *intf) 3971f07600cfSAlan Stern { 3972b41a60ecSAlan Stern struct usb_hub *hub = usb_get_intfdata(intf); 3973f07600cfSAlan Stern 39745e6effaeSAlan Stern dev_dbg(&intf->dev, "%s\n", __func__); 3975f2835219SAlan Stern hub_activate(hub, HUB_RESET_RESUME); 3976f07600cfSAlan Stern return 0; 3977f07600cfSAlan Stern } 3978f07600cfSAlan Stern 397954515fe5SAlan Stern /** 398054515fe5SAlan Stern * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power 398154515fe5SAlan Stern * @rhdev: struct usb_device for the root hub 398254515fe5SAlan Stern * 398354515fe5SAlan Stern * The USB host controller driver calls this function when its root hub 398454515fe5SAlan Stern * is resumed and Vbus power has been interrupted or the controller 3985feccc30dSAlan Stern * has been reset. The routine marks @rhdev as having lost power. 3986feccc30dSAlan Stern * When the hub driver is resumed it will take notice and carry out 3987feccc30dSAlan Stern * power-session recovery for all the "USB-PERSIST"-enabled child devices; 3988feccc30dSAlan Stern * the others will be disconnected. 398954515fe5SAlan Stern */ 399054515fe5SAlan Stern void usb_root_hub_lost_power(struct usb_device *rhdev) 399154515fe5SAlan Stern { 39920442d7b0STomeu Vizoso dev_notice(&rhdev->dev, "root hub lost power or was reset\n"); 399354515fe5SAlan Stern rhdev->reset_resume = 1; 399454515fe5SAlan Stern } 399554515fe5SAlan Stern EXPORT_SYMBOL_GPL(usb_root_hub_lost_power); 399654515fe5SAlan Stern 39971ea7e0e8SSarah Sharp static const char * const usb3_lpm_names[] = { 39981ea7e0e8SSarah Sharp "U0", 39991ea7e0e8SSarah Sharp "U1", 40001ea7e0e8SSarah Sharp "U2", 40011ea7e0e8SSarah Sharp "U3", 40021ea7e0e8SSarah Sharp }; 40031ea7e0e8SSarah Sharp 40041ea7e0e8SSarah Sharp /* 40051ea7e0e8SSarah Sharp * Send a Set SEL control transfer to the device, prior to enabling 40061ea7e0e8SSarah Sharp * device-initiated U1 or U2. This lets the device know the exit latencies from 40071ea7e0e8SSarah Sharp * the time the device initiates a U1 or U2 exit, to the time it will receive a 40081ea7e0e8SSarah Sharp * packet from the host. 40091ea7e0e8SSarah Sharp * 40101ea7e0e8SSarah Sharp * This function will fail if the SEL or PEL values for udev are greater than 40111ea7e0e8SSarah Sharp * the maximum allowed values for the link state to be enabled. 40121ea7e0e8SSarah Sharp */ 4013e146caf3SMathias Nyman static int usb_req_set_sel(struct usb_device *udev) 40141ea7e0e8SSarah Sharp { 40151ea7e0e8SSarah Sharp struct usb_set_sel_req *sel_values; 40161ea7e0e8SSarah Sharp unsigned long long u1_sel; 40171ea7e0e8SSarah Sharp unsigned long long u1_pel; 40181ea7e0e8SSarah Sharp unsigned long long u2_sel; 40191ea7e0e8SSarah Sharp unsigned long long u2_pel; 40201ea7e0e8SSarah Sharp int ret; 40211ea7e0e8SSarah Sharp 4022e146caf3SMathias Nyman if (!udev->parent || udev->speed < USB_SPEED_SUPER || !udev->lpm_capable) 402338d7f688SXenia Ragiadakou return 0; 402438d7f688SXenia Ragiadakou 40251ea7e0e8SSarah Sharp /* Convert SEL and PEL stored in ns to us */ 40261ea7e0e8SSarah Sharp u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000); 40271ea7e0e8SSarah Sharp u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000); 40281ea7e0e8SSarah Sharp u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000); 40291ea7e0e8SSarah Sharp u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000); 40301ea7e0e8SSarah Sharp 40311ea7e0e8SSarah Sharp /* 40321ea7e0e8SSarah Sharp * Make sure that the calculated SEL and PEL values for the link 40331ea7e0e8SSarah Sharp * state we're enabling aren't bigger than the max SEL/PEL 40341ea7e0e8SSarah Sharp * value that will fit in the SET SEL control transfer. 40351ea7e0e8SSarah Sharp * Otherwise the device would get an incorrect idea of the exit 40361ea7e0e8SSarah Sharp * latency for the link state, and could start a device-initiated 40371ea7e0e8SSarah Sharp * U1/U2 when the exit latencies are too high. 40381ea7e0e8SSarah Sharp */ 4039e146caf3SMathias Nyman if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL || 4040e146caf3SMathias Nyman u1_pel > USB3_LPM_MAX_U1_SEL_PEL || 4041e146caf3SMathias Nyman u2_sel > USB3_LPM_MAX_U2_SEL_PEL || 4042e146caf3SMathias Nyman u2_pel > USB3_LPM_MAX_U2_SEL_PEL) { 4043e146caf3SMathias Nyman dev_dbg(&udev->dev, "Device-initiated U1/U2 disabled due to long SEL or PEL\n"); 40441ea7e0e8SSarah Sharp return -EINVAL; 40451ea7e0e8SSarah Sharp } 40461ea7e0e8SSarah Sharp 40471ea7e0e8SSarah Sharp /* 40481ea7e0e8SSarah Sharp * usb_enable_lpm() can be called as part of a failed device reset, 40491ea7e0e8SSarah Sharp * which may be initiated by an error path of a mass storage driver. 40501ea7e0e8SSarah Sharp * Therefore, use GFP_NOIO. 40511ea7e0e8SSarah Sharp */ 40521ea7e0e8SSarah Sharp sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO); 40531ea7e0e8SSarah Sharp if (!sel_values) 40541ea7e0e8SSarah Sharp return -ENOMEM; 40551ea7e0e8SSarah Sharp 40561ea7e0e8SSarah Sharp sel_values->u1_sel = u1_sel; 40571ea7e0e8SSarah Sharp sel_values->u1_pel = u1_pel; 40581ea7e0e8SSarah Sharp sel_values->u2_sel = cpu_to_le16(u2_sel); 40591ea7e0e8SSarah Sharp sel_values->u2_pel = cpu_to_le16(u2_pel); 40601ea7e0e8SSarah Sharp 40611ea7e0e8SSarah Sharp ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 40621ea7e0e8SSarah Sharp USB_REQ_SET_SEL, 40631ea7e0e8SSarah Sharp USB_RECIP_DEVICE, 40641ea7e0e8SSarah Sharp 0, 0, 40651ea7e0e8SSarah Sharp sel_values, sizeof *(sel_values), 40661ea7e0e8SSarah Sharp USB_CTRL_SET_TIMEOUT); 40671ea7e0e8SSarah Sharp kfree(sel_values); 4068e146caf3SMathias Nyman 4069e146caf3SMathias Nyman if (ret > 0) 4070e146caf3SMathias Nyman udev->lpm_devinit_allow = 1; 4071e146caf3SMathias Nyman 40721ea7e0e8SSarah Sharp return ret; 40731ea7e0e8SSarah Sharp } 40741ea7e0e8SSarah Sharp 40751ea7e0e8SSarah Sharp /* 40761ea7e0e8SSarah Sharp * Enable or disable device-initiated U1 or U2 transitions. 40771ea7e0e8SSarah Sharp */ 40781ea7e0e8SSarah Sharp static int usb_set_device_initiated_lpm(struct usb_device *udev, 40791ea7e0e8SSarah Sharp enum usb3_link_state state, bool enable) 40801ea7e0e8SSarah Sharp { 40811ea7e0e8SSarah Sharp int ret; 40821ea7e0e8SSarah Sharp int feature; 40831ea7e0e8SSarah Sharp 40841ea7e0e8SSarah Sharp switch (state) { 40851ea7e0e8SSarah Sharp case USB3_LPM_U1: 40861ea7e0e8SSarah Sharp feature = USB_DEVICE_U1_ENABLE; 40871ea7e0e8SSarah Sharp break; 40881ea7e0e8SSarah Sharp case USB3_LPM_U2: 40891ea7e0e8SSarah Sharp feature = USB_DEVICE_U2_ENABLE; 40901ea7e0e8SSarah Sharp break; 40911ea7e0e8SSarah Sharp default: 40921ea7e0e8SSarah Sharp dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n", 40931ea7e0e8SSarah Sharp __func__, enable ? "enable" : "disable"); 40941ea7e0e8SSarah Sharp return -EINVAL; 40951ea7e0e8SSarah Sharp } 40961ea7e0e8SSarah Sharp 40971ea7e0e8SSarah Sharp if (udev->state != USB_STATE_CONFIGURED) { 40981ea7e0e8SSarah Sharp dev_dbg(&udev->dev, "%s: Can't %s %s state " 40991ea7e0e8SSarah Sharp "for unconfigured device.\n", 41001ea7e0e8SSarah Sharp __func__, enable ? "enable" : "disable", 41011ea7e0e8SSarah Sharp usb3_lpm_names[state]); 41021ea7e0e8SSarah Sharp return 0; 41031ea7e0e8SSarah Sharp } 41041ea7e0e8SSarah Sharp 41051ea7e0e8SSarah Sharp if (enable) { 41061ea7e0e8SSarah Sharp /* 41071ea7e0e8SSarah Sharp * Now send the control transfer to enable device-initiated LPM 41081ea7e0e8SSarah Sharp * for either U1 or U2. 41091ea7e0e8SSarah Sharp */ 41101ea7e0e8SSarah Sharp ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 41111ea7e0e8SSarah Sharp USB_REQ_SET_FEATURE, 41121ea7e0e8SSarah Sharp USB_RECIP_DEVICE, 41131ea7e0e8SSarah Sharp feature, 41141ea7e0e8SSarah Sharp 0, NULL, 0, 41151ea7e0e8SSarah Sharp USB_CTRL_SET_TIMEOUT); 41161ea7e0e8SSarah Sharp } else { 41171ea7e0e8SSarah Sharp ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 41181ea7e0e8SSarah Sharp USB_REQ_CLEAR_FEATURE, 41191ea7e0e8SSarah Sharp USB_RECIP_DEVICE, 41201ea7e0e8SSarah Sharp feature, 41211ea7e0e8SSarah Sharp 0, NULL, 0, 41221ea7e0e8SSarah Sharp USB_CTRL_SET_TIMEOUT); 41231ea7e0e8SSarah Sharp } 41241ea7e0e8SSarah Sharp if (ret < 0) { 41251ea7e0e8SSarah Sharp dev_warn(&udev->dev, "%s of device-initiated %s failed.\n", 41261ea7e0e8SSarah Sharp enable ? "Enable" : "Disable", 41271ea7e0e8SSarah Sharp usb3_lpm_names[state]); 41281ea7e0e8SSarah Sharp return -EBUSY; 41291ea7e0e8SSarah Sharp } 41301ea7e0e8SSarah Sharp return 0; 41311ea7e0e8SSarah Sharp } 41321ea7e0e8SSarah Sharp 41331ea7e0e8SSarah Sharp static int usb_set_lpm_timeout(struct usb_device *udev, 41341ea7e0e8SSarah Sharp enum usb3_link_state state, int timeout) 41351ea7e0e8SSarah Sharp { 41361ea7e0e8SSarah Sharp int ret; 41371ea7e0e8SSarah Sharp int feature; 41381ea7e0e8SSarah Sharp 41391ea7e0e8SSarah Sharp switch (state) { 41401ea7e0e8SSarah Sharp case USB3_LPM_U1: 41411ea7e0e8SSarah Sharp feature = USB_PORT_FEAT_U1_TIMEOUT; 41421ea7e0e8SSarah Sharp break; 41431ea7e0e8SSarah Sharp case USB3_LPM_U2: 41441ea7e0e8SSarah Sharp feature = USB_PORT_FEAT_U2_TIMEOUT; 41451ea7e0e8SSarah Sharp break; 41461ea7e0e8SSarah Sharp default: 41471ea7e0e8SSarah Sharp dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n", 41481ea7e0e8SSarah Sharp __func__); 41491ea7e0e8SSarah Sharp return -EINVAL; 41501ea7e0e8SSarah Sharp } 41511ea7e0e8SSarah Sharp 41521ea7e0e8SSarah Sharp if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT && 41531ea7e0e8SSarah Sharp timeout != USB3_LPM_DEVICE_INITIATED) { 41541ea7e0e8SSarah Sharp dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, " 41551ea7e0e8SSarah Sharp "which is a reserved value.\n", 41561ea7e0e8SSarah Sharp usb3_lpm_names[state], timeout); 41571ea7e0e8SSarah Sharp return -EINVAL; 41581ea7e0e8SSarah Sharp } 41591ea7e0e8SSarah Sharp 41601ea7e0e8SSarah Sharp ret = set_port_feature(udev->parent, 41611ea7e0e8SSarah Sharp USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum, 41621ea7e0e8SSarah Sharp feature); 41631ea7e0e8SSarah Sharp if (ret < 0) { 41641ea7e0e8SSarah Sharp dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x," 41651ea7e0e8SSarah Sharp "error code %i\n", usb3_lpm_names[state], 41661ea7e0e8SSarah Sharp timeout, ret); 41671ea7e0e8SSarah Sharp return -EBUSY; 41681ea7e0e8SSarah Sharp } 41691ea7e0e8SSarah Sharp if (state == USB3_LPM_U1) 41701ea7e0e8SSarah Sharp udev->u1_params.timeout = timeout; 41711ea7e0e8SSarah Sharp else 41721ea7e0e8SSarah Sharp udev->u2_params.timeout = timeout; 41731ea7e0e8SSarah Sharp return 0; 41741ea7e0e8SSarah Sharp } 41751ea7e0e8SSarah Sharp 41761ea7e0e8SSarah Sharp /* 41771b7f56fbSMathias Nyman * Don't allow device intiated U1/U2 if the system exit latency + one bus 41781b7f56fbSMathias Nyman * interval is greater than the minimum service interval of any active 41791b7f56fbSMathias Nyman * periodic endpoint. See USB 3.2 section 9.4.9 41801b7f56fbSMathias Nyman */ 41811b7f56fbSMathias Nyman static bool usb_device_may_initiate_lpm(struct usb_device *udev, 41821b7f56fbSMathias Nyman enum usb3_link_state state) 41831b7f56fbSMathias Nyman { 41841b7f56fbSMathias Nyman unsigned int sel; /* us */ 41851b7f56fbSMathias Nyman int i, j; 41861b7f56fbSMathias Nyman 4187e146caf3SMathias Nyman if (!udev->lpm_devinit_allow) 4188e146caf3SMathias Nyman return false; 4189e146caf3SMathias Nyman 41901b7f56fbSMathias Nyman if (state == USB3_LPM_U1) 41911b7f56fbSMathias Nyman sel = DIV_ROUND_UP(udev->u1_params.sel, 1000); 41921b7f56fbSMathias Nyman else if (state == USB3_LPM_U2) 41931b7f56fbSMathias Nyman sel = DIV_ROUND_UP(udev->u2_params.sel, 1000); 41941b7f56fbSMathias Nyman else 41951b7f56fbSMathias Nyman return false; 41961b7f56fbSMathias Nyman 41971b7f56fbSMathias Nyman for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 41981b7f56fbSMathias Nyman struct usb_interface *intf; 41991b7f56fbSMathias Nyman struct usb_endpoint_descriptor *desc; 42001b7f56fbSMathias Nyman unsigned int interval; 42011b7f56fbSMathias Nyman 42021b7f56fbSMathias Nyman intf = udev->actconfig->interface[i]; 42031b7f56fbSMathias Nyman if (!intf) 42041b7f56fbSMathias Nyman continue; 42051b7f56fbSMathias Nyman 42061b7f56fbSMathias Nyman for (j = 0; j < intf->cur_altsetting->desc.bNumEndpoints; j++) { 42071b7f56fbSMathias Nyman desc = &intf->cur_altsetting->endpoint[j].desc; 42081b7f56fbSMathias Nyman 42091b7f56fbSMathias Nyman if (usb_endpoint_xfer_int(desc) || 42101b7f56fbSMathias Nyman usb_endpoint_xfer_isoc(desc)) { 42111b7f56fbSMathias Nyman interval = (1 << (desc->bInterval - 1)) * 125; 42121b7f56fbSMathias Nyman if (sel + 125 > interval) 42131b7f56fbSMathias Nyman return false; 42141b7f56fbSMathias Nyman } 42151b7f56fbSMathias Nyman } 42161b7f56fbSMathias Nyman } 42171b7f56fbSMathias Nyman return true; 42181b7f56fbSMathias Nyman } 42191b7f56fbSMathias Nyman 42201b7f56fbSMathias Nyman /* 42211ea7e0e8SSarah Sharp * Enable the hub-initiated U1/U2 idle timeouts, and enable device-initiated 42221ea7e0e8SSarah Sharp * U1/U2 entry. 42231ea7e0e8SSarah Sharp * 42241ea7e0e8SSarah Sharp * We will attempt to enable U1 or U2, but there are no guarantees that the 42251ea7e0e8SSarah Sharp * control transfers to set the hub timeout or enable device-initiated U1/U2 42261ea7e0e8SSarah Sharp * will be successful. 42271ea7e0e8SSarah Sharp * 422856175929SThinh Nguyen * If the control transfer to enable device-initiated U1/U2 entry fails, then 422956175929SThinh Nguyen * hub-initiated U1/U2 will be disabled. 423056175929SThinh Nguyen * 42311ea7e0e8SSarah Sharp * If we cannot set the parent hub U1/U2 timeout, we attempt to let the xHCI 42321ea7e0e8SSarah Sharp * driver know about it. If that call fails, it should be harmless, and just 42331ea7e0e8SSarah Sharp * take up more slightly more bus bandwidth for unnecessary U1/U2 exit latency. 42341ea7e0e8SSarah Sharp */ 42351ea7e0e8SSarah Sharp static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev, 42361ea7e0e8SSarah Sharp enum usb3_link_state state) 42371ea7e0e8SSarah Sharp { 4238e146caf3SMathias Nyman int timeout; 4239f74a7afcSRicardo Cañuelo __u8 u1_mel; 4240f74a7afcSRicardo Cañuelo __le16 u2_mel; 4241f74a7afcSRicardo Cañuelo 4242f74a7afcSRicardo Cañuelo /* Skip if the device BOS descriptor couldn't be read */ 4243f74a7afcSRicardo Cañuelo if (!udev->bos) 4244f74a7afcSRicardo Cañuelo return; 4245f74a7afcSRicardo Cañuelo 4246f74a7afcSRicardo Cañuelo u1_mel = udev->bos->ss_cap->bU1devExitLat; 4247f74a7afcSRicardo Cañuelo u2_mel = udev->bos->ss_cap->bU2DevExitLat; 4248ae8963adSSarah Sharp 4249ae8963adSSarah Sharp /* If the device says it doesn't have *any* exit latency to come out of 4250ae8963adSSarah Sharp * U1 or U2, it's probably lying. Assume it doesn't implement that link 4251ae8963adSSarah Sharp * state. 4252ae8963adSSarah Sharp */ 4253ae8963adSSarah Sharp if ((state == USB3_LPM_U1 && u1_mel == 0) || 4254ae8963adSSarah Sharp (state == USB3_LPM_U2 && u2_mel == 0)) 4255ae8963adSSarah Sharp return; 42561ea7e0e8SSarah Sharp 42571ea7e0e8SSarah Sharp /* We allow the host controller to set the U1/U2 timeout internally 42581ea7e0e8SSarah Sharp * first, so that it can change its schedule to account for the 42591ea7e0e8SSarah Sharp * additional latency to send data to a device in a lower power 42601ea7e0e8SSarah Sharp * link state. 42611ea7e0e8SSarah Sharp */ 42621ea7e0e8SSarah Sharp timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state); 42631ea7e0e8SSarah Sharp 42641ea7e0e8SSarah Sharp /* xHCI host controller doesn't want to enable this LPM state. */ 42651ea7e0e8SSarah Sharp if (timeout == 0) 42661ea7e0e8SSarah Sharp return; 42671ea7e0e8SSarah Sharp 42681ea7e0e8SSarah Sharp if (timeout < 0) { 42691ea7e0e8SSarah Sharp dev_warn(&udev->dev, "Could not enable %s link state, " 42701ea7e0e8SSarah Sharp "xHCI error %i.\n", usb3_lpm_names[state], 42711ea7e0e8SSarah Sharp timeout); 42721ea7e0e8SSarah Sharp return; 42731ea7e0e8SSarah Sharp } 42741ea7e0e8SSarah Sharp 4275bf5ce5bfSLu Baolu if (usb_set_lpm_timeout(udev, state, timeout)) { 42761ea7e0e8SSarah Sharp /* If we can't set the parent hub U1/U2 timeout, 42771ea7e0e8SSarah Sharp * device-initiated LPM won't be allowed either, so let the xHCI 42781ea7e0e8SSarah Sharp * host know that this link state won't be enabled. 42791ea7e0e8SSarah Sharp */ 42801ea7e0e8SSarah Sharp hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state); 428156175929SThinh Nguyen return; 428256175929SThinh Nguyen } 428356175929SThinh Nguyen 4284bf5ce5bfSLu Baolu /* Only a configured device will accept the Set Feature 4285bf5ce5bfSLu Baolu * U1/U2_ENABLE 4286bf5ce5bfSLu Baolu */ 428756175929SThinh Nguyen if (udev->actconfig && 42881b7f56fbSMathias Nyman usb_device_may_initiate_lpm(udev, state)) { 42891b7f56fbSMathias Nyman if (usb_set_device_initiated_lpm(udev, state, true)) { 42901b7f56fbSMathias Nyman /* 42911b7f56fbSMathias Nyman * Request to enable device initiated U1/U2 failed, 42921b7f56fbSMathias Nyman * better to turn off lpm in this case. 42931b7f56fbSMathias Nyman */ 42941b7f56fbSMathias Nyman usb_set_lpm_timeout(udev, state, 0); 42951b7f56fbSMathias Nyman hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state); 42961b7f56fbSMathias Nyman return; 42971b7f56fbSMathias Nyman } 42981b7f56fbSMathias Nyman } 42991b7f56fbSMathias Nyman 4300bf5ce5bfSLu Baolu if (state == USB3_LPM_U1) 4301bf5ce5bfSLu Baolu udev->usb3_lpm_u1_enabled = 1; 4302bf5ce5bfSLu Baolu else if (state == USB3_LPM_U2) 4303bf5ce5bfSLu Baolu udev->usb3_lpm_u2_enabled = 1; 4304bf5ce5bfSLu Baolu } 43051ea7e0e8SSarah Sharp /* 43061ea7e0e8SSarah Sharp * Disable the hub-initiated U1/U2 idle timeouts, and disable device-initiated 43071ea7e0e8SSarah Sharp * U1/U2 entry. 43081ea7e0e8SSarah Sharp * 43091ea7e0e8SSarah Sharp * If this function returns -EBUSY, the parent hub will still allow U1/U2 entry. 43101ea7e0e8SSarah Sharp * If zero is returned, the parent will not allow the link to go into U1/U2. 43111ea7e0e8SSarah Sharp * 43121ea7e0e8SSarah Sharp * If zero is returned, device-initiated U1/U2 entry may still be enabled, but 43131ea7e0e8SSarah Sharp * it won't have an effect on the bus link state because the parent hub will 43141ea7e0e8SSarah Sharp * still disallow device-initiated U1/U2 entry. 43151ea7e0e8SSarah Sharp * 43161ea7e0e8SSarah Sharp * If zero is returned, the xHCI host controller may still think U1/U2 entry is 43171ea7e0e8SSarah Sharp * possible. The result will be slightly more bus bandwidth will be taken up 43181ea7e0e8SSarah Sharp * (to account for U1/U2 exit latency), but it should be harmless. 43191ea7e0e8SSarah Sharp */ 43201ea7e0e8SSarah Sharp static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev, 43211ea7e0e8SSarah Sharp enum usb3_link_state state) 43221ea7e0e8SSarah Sharp { 43231ea7e0e8SSarah Sharp switch (state) { 43241ea7e0e8SSarah Sharp case USB3_LPM_U1: 43251ea7e0e8SSarah Sharp case USB3_LPM_U2: 43261ea7e0e8SSarah Sharp break; 43271ea7e0e8SSarah Sharp default: 43281ea7e0e8SSarah Sharp dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n", 43291ea7e0e8SSarah Sharp __func__); 43301ea7e0e8SSarah Sharp return -EINVAL; 43311ea7e0e8SSarah Sharp } 43321ea7e0e8SSarah Sharp 43331ea7e0e8SSarah Sharp if (usb_set_lpm_timeout(udev, state, 0)) 43341ea7e0e8SSarah Sharp return -EBUSY; 43351ea7e0e8SSarah Sharp 43361ea7e0e8SSarah Sharp usb_set_device_initiated_lpm(udev, state, false); 43371ea7e0e8SSarah Sharp 43381ea7e0e8SSarah Sharp if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state)) 43391ea7e0e8SSarah Sharp dev_warn(&udev->dev, "Could not disable xHCI %s timeout, " 43401ea7e0e8SSarah Sharp "bus schedule bandwidth may be impacted.\n", 43411ea7e0e8SSarah Sharp usb3_lpm_names[state]); 4342bf5ce5bfSLu Baolu 4343bf5ce5bfSLu Baolu /* As soon as usb_set_lpm_timeout(0) return 0, hub initiated LPM 4344bf5ce5bfSLu Baolu * is disabled. Hub will disallows link to enter U1/U2 as well, 4345bf5ce5bfSLu Baolu * even device is initiating LPM. Hence LPM is disabled if hub LPM 4346bf5ce5bfSLu Baolu * timeout set to 0, no matter device-initiated LPM is disabled or 4347bf5ce5bfSLu Baolu * not. 4348bf5ce5bfSLu Baolu */ 4349bf5ce5bfSLu Baolu if (state == USB3_LPM_U1) 4350bf5ce5bfSLu Baolu udev->usb3_lpm_u1_enabled = 0; 4351bf5ce5bfSLu Baolu else if (state == USB3_LPM_U2) 4352bf5ce5bfSLu Baolu udev->usb3_lpm_u2_enabled = 0; 4353bf5ce5bfSLu Baolu 43541ea7e0e8SSarah Sharp return 0; 43551ea7e0e8SSarah Sharp } 43561ea7e0e8SSarah Sharp 43571ea7e0e8SSarah Sharp /* 43581ea7e0e8SSarah Sharp * Disable hub-initiated and device-initiated U1 and U2 entry. 43591ea7e0e8SSarah Sharp * Caller must own the bandwidth_mutex. 43601ea7e0e8SSarah Sharp * 43611ea7e0e8SSarah Sharp * This will call usb_enable_lpm() on failure, which will decrement 43621ea7e0e8SSarah Sharp * lpm_disable_count, and will re-enable LPM if lpm_disable_count reaches zero. 43631ea7e0e8SSarah Sharp */ 43641ea7e0e8SSarah Sharp int usb_disable_lpm(struct usb_device *udev) 43651ea7e0e8SSarah Sharp { 43661ea7e0e8SSarah Sharp struct usb_hcd *hcd; 43671ea7e0e8SSarah Sharp 43681ea7e0e8SSarah Sharp if (!udev || !udev->parent || 43698a1b2725SMathias Nyman udev->speed < USB_SPEED_SUPER || 437051df62ffSPratyush Anand !udev->lpm_capable || 4371fea3af5eSThinh Nguyen udev->state < USB_STATE_CONFIGURED) 43721ea7e0e8SSarah Sharp return 0; 43731ea7e0e8SSarah Sharp 43741ea7e0e8SSarah Sharp hcd = bus_to_hcd(udev->bus); 43751ea7e0e8SSarah Sharp if (!hcd || !hcd->driver->disable_usb3_lpm_timeout) 43761ea7e0e8SSarah Sharp return 0; 43771ea7e0e8SSarah Sharp 43781ea7e0e8SSarah Sharp udev->lpm_disable_count++; 437955558c33SDan Carpenter if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0)) 43801ea7e0e8SSarah Sharp return 0; 43811ea7e0e8SSarah Sharp 43821ea7e0e8SSarah Sharp /* If LPM is enabled, attempt to disable it. */ 43831ea7e0e8SSarah Sharp if (usb_disable_link_state(hcd, udev, USB3_LPM_U1)) 43841ea7e0e8SSarah Sharp goto enable_lpm; 43851ea7e0e8SSarah Sharp if (usb_disable_link_state(hcd, udev, USB3_LPM_U2)) 43861ea7e0e8SSarah Sharp goto enable_lpm; 43871ea7e0e8SSarah Sharp 43881ea7e0e8SSarah Sharp return 0; 43891ea7e0e8SSarah Sharp 43901ea7e0e8SSarah Sharp enable_lpm: 43911ea7e0e8SSarah Sharp usb_enable_lpm(udev); 43921ea7e0e8SSarah Sharp return -EBUSY; 43931ea7e0e8SSarah Sharp } 43941ea7e0e8SSarah Sharp EXPORT_SYMBOL_GPL(usb_disable_lpm); 43951ea7e0e8SSarah Sharp 43961ea7e0e8SSarah Sharp /* Grab the bandwidth_mutex before calling usb_disable_lpm() */ 43971ea7e0e8SSarah Sharp int usb_unlocked_disable_lpm(struct usb_device *udev) 43981ea7e0e8SSarah Sharp { 43991ea7e0e8SSarah Sharp struct usb_hcd *hcd = bus_to_hcd(udev->bus); 44001ea7e0e8SSarah Sharp int ret; 44011ea7e0e8SSarah Sharp 44021ea7e0e8SSarah Sharp if (!hcd) 44031ea7e0e8SSarah Sharp return -EINVAL; 44041ea7e0e8SSarah Sharp 44051ea7e0e8SSarah Sharp mutex_lock(hcd->bandwidth_mutex); 44061ea7e0e8SSarah Sharp ret = usb_disable_lpm(udev); 44071ea7e0e8SSarah Sharp mutex_unlock(hcd->bandwidth_mutex); 44081ea7e0e8SSarah Sharp 44091ea7e0e8SSarah Sharp return ret; 44101ea7e0e8SSarah Sharp } 44111ea7e0e8SSarah Sharp EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm); 44121ea7e0e8SSarah Sharp 44131ea7e0e8SSarah Sharp /* 44141ea7e0e8SSarah Sharp * Attempt to enable device-initiated and hub-initiated U1 and U2 entry. The 44151ea7e0e8SSarah Sharp * xHCI host policy may prevent U1 or U2 from being enabled. 44161ea7e0e8SSarah Sharp * 44171ea7e0e8SSarah Sharp * Other callers may have disabled link PM, so U1 and U2 entry will be disabled 44181ea7e0e8SSarah Sharp * until the lpm_disable_count drops to zero. Caller must own the 44191ea7e0e8SSarah Sharp * bandwidth_mutex. 44201ea7e0e8SSarah Sharp */ 44211ea7e0e8SSarah Sharp void usb_enable_lpm(struct usb_device *udev) 44221ea7e0e8SSarah Sharp { 44231ea7e0e8SSarah Sharp struct usb_hcd *hcd; 4424513072d9SLu Baolu struct usb_hub *hub; 4425513072d9SLu Baolu struct usb_port *port_dev; 44261ea7e0e8SSarah Sharp 44271ea7e0e8SSarah Sharp if (!udev || !udev->parent || 44288a1b2725SMathias Nyman udev->speed < USB_SPEED_SUPER || 442951df62ffSPratyush Anand !udev->lpm_capable || 4430fea3af5eSThinh Nguyen udev->state < USB_STATE_CONFIGURED) 44311ea7e0e8SSarah Sharp return; 44321ea7e0e8SSarah Sharp 44331ea7e0e8SSarah Sharp udev->lpm_disable_count--; 44341ea7e0e8SSarah Sharp hcd = bus_to_hcd(udev->bus); 44351ea7e0e8SSarah Sharp /* Double check that we can both enable and disable LPM. 44361ea7e0e8SSarah Sharp * Device must be configured to accept set feature U1/U2 timeout. 44371ea7e0e8SSarah Sharp */ 44381ea7e0e8SSarah Sharp if (!hcd || !hcd->driver->enable_usb3_lpm_timeout || 44391ea7e0e8SSarah Sharp !hcd->driver->disable_usb3_lpm_timeout) 44401ea7e0e8SSarah Sharp return; 44411ea7e0e8SSarah Sharp 44421ea7e0e8SSarah Sharp if (udev->lpm_disable_count > 0) 44431ea7e0e8SSarah Sharp return; 44441ea7e0e8SSarah Sharp 4445513072d9SLu Baolu hub = usb_hub_to_struct_hub(udev->parent); 4446513072d9SLu Baolu if (!hub) 4447513072d9SLu Baolu return; 4448513072d9SLu Baolu 4449513072d9SLu Baolu port_dev = hub->ports[udev->portnum - 1]; 4450513072d9SLu Baolu 4451513072d9SLu Baolu if (port_dev->usb3_lpm_u1_permit) 44521ea7e0e8SSarah Sharp usb_enable_link_state(hcd, udev, USB3_LPM_U1); 4453513072d9SLu Baolu 4454513072d9SLu Baolu if (port_dev->usb3_lpm_u2_permit) 44551ea7e0e8SSarah Sharp usb_enable_link_state(hcd, udev, USB3_LPM_U2); 44561ea7e0e8SSarah Sharp } 44571ea7e0e8SSarah Sharp EXPORT_SYMBOL_GPL(usb_enable_lpm); 44581ea7e0e8SSarah Sharp 44591ea7e0e8SSarah Sharp /* Grab the bandwidth_mutex before calling usb_enable_lpm() */ 44601ea7e0e8SSarah Sharp void usb_unlocked_enable_lpm(struct usb_device *udev) 44611ea7e0e8SSarah Sharp { 44621ea7e0e8SSarah Sharp struct usb_hcd *hcd = bus_to_hcd(udev->bus); 44631ea7e0e8SSarah Sharp 44641ea7e0e8SSarah Sharp if (!hcd) 44651ea7e0e8SSarah Sharp return; 44661ea7e0e8SSarah Sharp 44671ea7e0e8SSarah Sharp mutex_lock(hcd->bandwidth_mutex); 44681ea7e0e8SSarah Sharp usb_enable_lpm(udev); 44691ea7e0e8SSarah Sharp mutex_unlock(hcd->bandwidth_mutex); 44701ea7e0e8SSarah Sharp } 44711ea7e0e8SSarah Sharp EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm); 44721ea7e0e8SSarah Sharp 447337be6676SMathias Nyman /* usb3 devices use U3 for disabled, make sure remote wakeup is disabled */ 447437be6676SMathias Nyman static void hub_usb3_port_prepare_disable(struct usb_hub *hub, 447537be6676SMathias Nyman struct usb_port *port_dev) 447637be6676SMathias Nyman { 447737be6676SMathias Nyman struct usb_device *udev = port_dev->child; 447837be6676SMathias Nyman int ret; 447937be6676SMathias Nyman 448037be6676SMathias Nyman if (udev && udev->port_is_suspended && udev->do_remote_wakeup) { 448137be6676SMathias Nyman ret = hub_set_port_link_state(hub, port_dev->portnum, 448237be6676SMathias Nyman USB_SS_PORT_LS_U0); 448337be6676SMathias Nyman if (!ret) { 448437be6676SMathias Nyman msleep(USB_RESUME_TIMEOUT); 448537be6676SMathias Nyman ret = usb_disable_remote_wakeup(udev); 448637be6676SMathias Nyman } 448737be6676SMathias Nyman if (ret) 448837be6676SMathias Nyman dev_warn(&udev->dev, 448937be6676SMathias Nyman "Port disable: can't disable remote wake\n"); 449037be6676SMathias Nyman udev->do_remote_wakeup = 0; 449137be6676SMathias Nyman } 449237be6676SMathias Nyman } 44931ea7e0e8SSarah Sharp 4494d388dab7SAlan Stern #else /* CONFIG_PM */ 4495d388dab7SAlan Stern 4496511366daSAndrew Morton #define hub_suspend NULL 4497511366daSAndrew Morton #define hub_resume NULL 4498f07600cfSAlan Stern #define hub_reset_resume NULL 44991ea7e0e8SSarah Sharp 450037be6676SMathias Nyman static inline void hub_usb3_port_prepare_disable(struct usb_hub *hub, 450137be6676SMathias Nyman struct usb_port *port_dev) { } 450237be6676SMathias Nyman 45031ea7e0e8SSarah Sharp int usb_disable_lpm(struct usb_device *udev) 45041ea7e0e8SSarah Sharp { 45051ea7e0e8SSarah Sharp return 0; 45061ea7e0e8SSarah Sharp } 4507e9261fb6SSarah Sharp EXPORT_SYMBOL_GPL(usb_disable_lpm); 45081ea7e0e8SSarah Sharp 45091ea7e0e8SSarah Sharp void usb_enable_lpm(struct usb_device *udev) { } 4510e9261fb6SSarah Sharp EXPORT_SYMBOL_GPL(usb_enable_lpm); 45111ea7e0e8SSarah Sharp 45121ea7e0e8SSarah Sharp int usb_unlocked_disable_lpm(struct usb_device *udev) 45131ea7e0e8SSarah Sharp { 45141ea7e0e8SSarah Sharp return 0; 45151ea7e0e8SSarah Sharp } 4516e9261fb6SSarah Sharp EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm); 45171ea7e0e8SSarah Sharp 45181ea7e0e8SSarah Sharp void usb_unlocked_enable_lpm(struct usb_device *udev) { } 4519e9261fb6SSarah Sharp EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm); 4520f74631e3SSarah Sharp 4521f74631e3SSarah Sharp int usb_disable_ltm(struct usb_device *udev) 4522f74631e3SSarah Sharp { 4523f74631e3SSarah Sharp return 0; 4524f74631e3SSarah Sharp } 4525f74631e3SSarah Sharp EXPORT_SYMBOL_GPL(usb_disable_ltm); 4526f74631e3SSarah Sharp 4527f74631e3SSarah Sharp void usb_enable_ltm(struct usb_device *udev) { } 4528f74631e3SSarah Sharp EXPORT_SYMBOL_GPL(usb_enable_ltm); 4529c4b51a43SAlan Stern 45304a95b1fcSStephen Rothwell static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port, 45314a95b1fcSStephen Rothwell u16 portstatus, u16 portchange) 45324a95b1fcSStephen Rothwell { 45334a95b1fcSStephen Rothwell return 0; 45344a95b1fcSStephen Rothwell } 45354a95b1fcSStephen Rothwell 4536e146caf3SMathias Nyman static int usb_req_set_sel(struct usb_device *udev) 4537e146caf3SMathias Nyman { 4538e146caf3SMathias Nyman return 0; 4539e146caf3SMathias Nyman } 4540e146caf3SMathias Nyman 4541c4b51a43SAlan Stern #endif /* CONFIG_PM */ 4542d388dab7SAlan Stern 45433bc02bceSGeert Uytterhoeven /* 45443bc02bceSGeert Uytterhoeven * USB-3 does not have a similar link state as USB-2 that will avoid negotiating 45453bc02bceSGeert Uytterhoeven * a connection with a plugged-in cable but will signal the host when the cable 45463bc02bceSGeert Uytterhoeven * is unplugged. Disable remote wake and set link state to U3 for USB-3 devices 45473bc02bceSGeert Uytterhoeven */ 45483bc02bceSGeert Uytterhoeven static int hub_port_disable(struct usb_hub *hub, int port1, int set_state) 45493bc02bceSGeert Uytterhoeven { 45503bc02bceSGeert Uytterhoeven struct usb_port *port_dev = hub->ports[port1 - 1]; 45513bc02bceSGeert Uytterhoeven struct usb_device *hdev = hub->hdev; 45523bc02bceSGeert Uytterhoeven int ret = 0; 45533bc02bceSGeert Uytterhoeven 45543bc02bceSGeert Uytterhoeven if (!hub->error) { 45553bc02bceSGeert Uytterhoeven if (hub_is_superspeed(hub->hdev)) { 45563bc02bceSGeert Uytterhoeven hub_usb3_port_prepare_disable(hub, port_dev); 45573bc02bceSGeert Uytterhoeven ret = hub_set_port_link_state(hub, port_dev->portnum, 45583bc02bceSGeert Uytterhoeven USB_SS_PORT_LS_U3); 45593bc02bceSGeert Uytterhoeven } else { 45603bc02bceSGeert Uytterhoeven ret = usb_clear_port_feature(hdev, port1, 45613bc02bceSGeert Uytterhoeven USB_PORT_FEAT_ENABLE); 45623bc02bceSGeert Uytterhoeven } 45633bc02bceSGeert Uytterhoeven } 45643bc02bceSGeert Uytterhoeven if (port_dev->child && set_state) 45653bc02bceSGeert Uytterhoeven usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED); 45663bc02bceSGeert Uytterhoeven if (ret && ret != -ENODEV) 45673bc02bceSGeert Uytterhoeven dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret); 45683bc02bceSGeert Uytterhoeven return ret; 45693bc02bceSGeert Uytterhoeven } 45703bc02bceSGeert Uytterhoeven 45718dd8d2c9SDaniel Drake /* 45728dd8d2c9SDaniel Drake * usb_port_disable - disable a usb device's upstream port 45738dd8d2c9SDaniel Drake * @udev: device to disable 45748dd8d2c9SDaniel Drake * Context: @udev locked, must be able to sleep. 45758dd8d2c9SDaniel Drake * 45768dd8d2c9SDaniel Drake * Disables a USB device that isn't in active use. 45778dd8d2c9SDaniel Drake */ 45788dd8d2c9SDaniel Drake int usb_port_disable(struct usb_device *udev) 45798dd8d2c9SDaniel Drake { 45808dd8d2c9SDaniel Drake struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); 45818dd8d2c9SDaniel Drake 45828dd8d2c9SDaniel Drake return hub_port_disable(hub, udev->portnum, 0); 45838dd8d2c9SDaniel Drake } 45841da177e4SLinus Torvalds 45851da177e4SLinus Torvalds /* USB 2.0 spec, 7.1.7.3 / fig 7-29: 45861da177e4SLinus Torvalds * 45871da177e4SLinus Torvalds * Between connect detection and reset signaling there must be a delay 45881da177e4SLinus Torvalds * of 100ms at least for debounce and power-settling. The corresponding 45891da177e4SLinus Torvalds * timer shall restart whenever the downstream port detects a disconnect. 45901da177e4SLinus Torvalds * 45911da177e4SLinus Torvalds * Apparently there are some bluetooth and irda-dongles and a number of 45921da177e4SLinus Torvalds * low-speed devices for which this debounce period may last over a second. 45931da177e4SLinus Torvalds * Not covered by the spec - but easy to deal with. 45941da177e4SLinus Torvalds * 45951da177e4SLinus Torvalds * This implementation uses a 1500ms total debounce timeout; if the 45961da177e4SLinus Torvalds * connection isn't stable by then it returns -ETIMEDOUT. It checks 45971da177e4SLinus Torvalds * every 25ms for transient disconnects. When the port status has been 45981da177e4SLinus Torvalds * unchanged for 100ms it returns the port status. 45991da177e4SLinus Torvalds */ 4600ad493e5eSLan Tianyu int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected) 46011da177e4SLinus Torvalds { 46021da177e4SLinus Torvalds int ret; 46031da177e4SLinus Torvalds u16 portchange, portstatus; 46041da177e4SLinus Torvalds unsigned connection = 0xffff; 4605d99f6b41SDan Williams int total_time, stable_time = 0; 4606d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 46071da177e4SLinus Torvalds 46081da177e4SLinus Torvalds for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) { 4609f061f43dSMichael Grzeschik ret = usb_hub_port_status(hub, port1, &portstatus, &portchange); 46101da177e4SLinus Torvalds if (ret < 0) 46111da177e4SLinus Torvalds return ret; 46121da177e4SLinus Torvalds 46131da177e4SLinus Torvalds if (!(portchange & USB_PORT_STAT_C_CONNECTION) && 46141da177e4SLinus Torvalds (portstatus & USB_PORT_STAT_CONNECTION) == connection) { 4615ad493e5eSLan Tianyu if (!must_be_connected || 4616ad493e5eSLan Tianyu (connection == USB_PORT_STAT_CONNECTION)) 46171da177e4SLinus Torvalds stable_time += HUB_DEBOUNCE_STEP; 46181da177e4SLinus Torvalds if (stable_time >= HUB_DEBOUNCE_STABLE) 46191da177e4SLinus Torvalds break; 46201da177e4SLinus Torvalds } else { 46211da177e4SLinus Torvalds stable_time = 0; 46221da177e4SLinus Torvalds connection = portstatus & USB_PORT_STAT_CONNECTION; 46231da177e4SLinus Torvalds } 46241da177e4SLinus Torvalds 46251da177e4SLinus Torvalds if (portchange & USB_PORT_STAT_C_CONNECTION) { 4626ad493e5eSLan Tianyu usb_clear_port_feature(hub->hdev, port1, 46271da177e4SLinus Torvalds USB_PORT_FEAT_C_CONNECTION); 46281da177e4SLinus Torvalds } 46291da177e4SLinus Torvalds 46301da177e4SLinus Torvalds if (total_time >= HUB_DEBOUNCE_TIMEOUT) 46311da177e4SLinus Torvalds break; 46321da177e4SLinus Torvalds msleep(HUB_DEBOUNCE_STEP); 46331da177e4SLinus Torvalds } 46341da177e4SLinus Torvalds 4635d99f6b41SDan Williams dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n", 4636d99f6b41SDan Williams total_time, stable_time, portstatus); 46371da177e4SLinus Torvalds 46381da177e4SLinus Torvalds if (stable_time < HUB_DEBOUNCE_STABLE) 46391da177e4SLinus Torvalds return -ETIMEDOUT; 46401da177e4SLinus Torvalds return portstatus; 46411da177e4SLinus Torvalds } 46421da177e4SLinus Torvalds 4643fc721f51SInaky Perez-Gonzalez void usb_ep0_reinit(struct usb_device *udev) 46441da177e4SLinus Torvalds { 4645ddeac4e7SAlan Stern usb_disable_endpoint(udev, 0 + USB_DIR_IN, true); 4646ddeac4e7SAlan Stern usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true); 46472caf7fcdSAlan Stern usb_enable_endpoint(udev, &udev->ep0, true); 46481da177e4SLinus Torvalds } 4649fc721f51SInaky Perez-Gonzalez EXPORT_SYMBOL_GPL(usb_ep0_reinit); 46501da177e4SLinus Torvalds 46511da177e4SLinus Torvalds #define usb_sndaddr0pipe() (PIPE_CONTROL << 30) 46521da177e4SLinus Torvalds #define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN) 46531da177e4SLinus Torvalds 46544326ed0bSAlan Stern static int hub_set_address(struct usb_device *udev, int devnum) 46551da177e4SLinus Torvalds { 46561da177e4SLinus Torvalds int retval; 4657c6515272SSarah Sharp struct usb_hcd *hcd = bus_to_hcd(udev->bus); 46581da177e4SLinus Torvalds 4659c6515272SSarah Sharp /* 4660c6515272SSarah Sharp * The host controller will choose the device address, 4661c6515272SSarah Sharp * instead of the core having chosen it earlier 4662c6515272SSarah Sharp */ 4663c6515272SSarah Sharp if (!hcd->driver->address_device && devnum <= 1) 46641da177e4SLinus Torvalds return -EINVAL; 46651da177e4SLinus Torvalds if (udev->state == USB_STATE_ADDRESS) 46661da177e4SLinus Torvalds return 0; 46671da177e4SLinus Torvalds if (udev->state != USB_STATE_DEFAULT) 46681da177e4SLinus Torvalds return -EINVAL; 4669c8d4af8eSAndiry Xu if (hcd->driver->address_device) 4670c6515272SSarah Sharp retval = hcd->driver->address_device(hcd, udev); 4671c8d4af8eSAndiry Xu else 46721da177e4SLinus Torvalds retval = usb_control_msg(udev, usb_sndaddr0pipe(), 46734326ed0bSAlan Stern USB_REQ_SET_ADDRESS, 0, devnum, 0, 46741da177e4SLinus Torvalds NULL, 0, USB_CTRL_SET_TIMEOUT); 46751da177e4SLinus Torvalds if (retval == 0) { 46763b29b68bSAlan Stern update_devnum(udev, devnum); 46774953d141SDavid Vrabel /* Device now using proper address. */ 46781da177e4SLinus Torvalds usb_set_device_state(udev, USB_STATE_ADDRESS); 4679fc721f51SInaky Perez-Gonzalez usb_ep0_reinit(udev); 46801da177e4SLinus Torvalds } 46811da177e4SLinus Torvalds return retval; 46821da177e4SLinus Torvalds } 46831da177e4SLinus Torvalds 4684890dae88SMathias Nyman /* 4685890dae88SMathias Nyman * There are reports of USB 3.0 devices that say they support USB 2.0 Link PM 4686890dae88SMathias Nyman * when they're plugged into a USB 2.0 port, but they don't work when LPM is 4687890dae88SMathias Nyman * enabled. 4688890dae88SMathias Nyman * 4689890dae88SMathias Nyman * Only enable USB 2.0 Link PM if the port is internal (hardwired), or the 4690890dae88SMathias Nyman * device says it supports the new USB 2.0 Link PM errata by setting the BESL 4691890dae88SMathias Nyman * support bit in the BOS descriptor. 4692890dae88SMathias Nyman */ 4693890dae88SMathias Nyman static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev) 4694890dae88SMathias Nyman { 4695d99f6b41SDan Williams struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); 4696d99f6b41SDan Williams int connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN; 4697890dae88SMathias Nyman 46987b2db29fSGuenter Roeck if (!udev->usb2_hw_lpm_capable || !udev->bos) 4699890dae88SMathias Nyman return; 4700890dae88SMathias Nyman 4701d99f6b41SDan Williams if (hub) 4702d99f6b41SDan Williams connect_type = hub->ports[udev->portnum - 1]->connect_type; 4703890dae88SMathias Nyman 470423c05820SBjørn Mork if ((udev->bos->ext_cap->bmAttributes & cpu_to_le32(USB_BESL_SUPPORT)) || 4705890dae88SMathias Nyman connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) { 4706890dae88SMathias Nyman udev->usb2_hw_lpm_allowed = 1; 47077529b257SKai-Heng Feng usb_enable_usb2_hardware_lpm(udev); 4708890dae88SMathias Nyman } 4709890dae88SMathias Nyman } 4710890dae88SMathias Nyman 471148fc7dbdSDan Williams static int hub_enable_device(struct usb_device *udev) 471248fc7dbdSDan Williams { 471348fc7dbdSDan Williams struct usb_hcd *hcd = bus_to_hcd(udev->bus); 471448fc7dbdSDan Williams 471548fc7dbdSDan Williams if (!hcd->driver->enable_device) 471648fc7dbdSDan Williams return 0; 471748fc7dbdSDan Williams if (udev->state == USB_STATE_ADDRESS) 471848fc7dbdSDan Williams return 0; 471948fc7dbdSDan Williams if (udev->state != USB_STATE_DEFAULT) 472048fc7dbdSDan Williams return -EINVAL; 472148fc7dbdSDan Williams 472248fc7dbdSDan Williams return hcd->driver->enable_device(hcd, udev); 472348fc7dbdSDan Williams } 472448fc7dbdSDan Williams 472585d07c55SAlan Stern /* 472685d07c55SAlan Stern * Get the bMaxPacketSize0 value during initialization by reading the 472785d07c55SAlan Stern * device's device descriptor. Since we don't already know this value, 472885d07c55SAlan Stern * the transfer is unsafe and it ignores I/O errors, only testing for 472985d07c55SAlan Stern * reasonable received values. 473085d07c55SAlan Stern * 473185d07c55SAlan Stern * For "old scheme" initialization, size will be 8 so we read just the 473285d07c55SAlan Stern * start of the device descriptor, which should work okay regardless of 473385d07c55SAlan Stern * the actual bMaxPacketSize0 value. For "new scheme" initialization, 473485d07c55SAlan Stern * size will be 64 (and buf will point to a sufficiently large buffer), 473585d07c55SAlan Stern * which might not be kosher according to the USB spec but it's what 473685d07c55SAlan Stern * Windows does and what many devices expect. 473785d07c55SAlan Stern * 473885d07c55SAlan Stern * Returns: bMaxPacketSize0 or a negative error code. 473985d07c55SAlan Stern */ 474085d07c55SAlan Stern static int get_bMaxPacketSize0(struct usb_device *udev, 474185d07c55SAlan Stern struct usb_device_descriptor *buf, int size, bool first_time) 474285d07c55SAlan Stern { 474385d07c55SAlan Stern int i, rc; 474485d07c55SAlan Stern 474585d07c55SAlan Stern /* 474685d07c55SAlan Stern * Retry on all errors; some devices are flakey. 474785d07c55SAlan Stern * 255 is for WUSB devices, we actually need to use 474885d07c55SAlan Stern * 512 (WUSB1.0[4.8.1]). 474985d07c55SAlan Stern */ 475085d07c55SAlan Stern for (i = 0; i < GET_MAXPACKET0_TRIES; ++i) { 475185d07c55SAlan Stern /* Start with invalid values in case the transfer fails */ 475285d07c55SAlan Stern buf->bDescriptorType = buf->bMaxPacketSize0 = 0; 475385d07c55SAlan Stern rc = usb_control_msg(udev, usb_rcvaddr0pipe(), 475485d07c55SAlan Stern USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 475585d07c55SAlan Stern USB_DT_DEVICE << 8, 0, 475685d07c55SAlan Stern buf, size, 475785d07c55SAlan Stern initial_descriptor_timeout); 475885d07c55SAlan Stern switch (buf->bMaxPacketSize0) { 475959cf4457SAlan Stern case 8: case 16: case 32: case 64: case 9: 476085d07c55SAlan Stern if (buf->bDescriptorType == USB_DT_DEVICE) { 476185d07c55SAlan Stern rc = buf->bMaxPacketSize0; 476285d07c55SAlan Stern break; 476385d07c55SAlan Stern } 476485d07c55SAlan Stern fallthrough; 476585d07c55SAlan Stern default: 476685d07c55SAlan Stern if (rc >= 0) 476785d07c55SAlan Stern rc = -EPROTO; 476885d07c55SAlan Stern break; 476985d07c55SAlan Stern } 477085d07c55SAlan Stern 477185d07c55SAlan Stern /* 477285d07c55SAlan Stern * Some devices time out if they are powered on 477385d07c55SAlan Stern * when already connected. They need a second 477485d07c55SAlan Stern * reset, so return early. But only on the first 477585d07c55SAlan Stern * attempt, lest we get into a time-out/reset loop. 477685d07c55SAlan Stern */ 477785d07c55SAlan Stern if (rc > 0 || (rc == -ETIMEDOUT && first_time && 477885d07c55SAlan Stern udev->speed > USB_SPEED_FULL)) 477985d07c55SAlan Stern break; 478085d07c55SAlan Stern } 478185d07c55SAlan Stern return rc; 478285d07c55SAlan Stern } 478385d07c55SAlan Stern 478485d07c55SAlan Stern #define GET_DESCRIPTOR_BUFSIZE 64 478585d07c55SAlan Stern 47861da177e4SLinus Torvalds /* Reset device, (re)assign address, get device descriptor. 47871da177e4SLinus Torvalds * Device connection must be stable, no more debouncing needed. 47881da177e4SLinus Torvalds * Returns device in USB_STATE_ADDRESS, except on error. 47891da177e4SLinus Torvalds * 47901da177e4SLinus Torvalds * If this is called for an already-existing device (as part of 47915c79a1e3SDan Williams * usb_reset_and_verify_device), the caller must own the device lock and 47925c79a1e3SDan Williams * the port lock. For a newly detected device that is not accessible 47935c79a1e3SDan Williams * through any global pointers, it's not necessary to lock the device, 47945c79a1e3SDan Williams * but it is still necessary to lock the port. 4795ff33299eSAlan Stern * 4796ff33299eSAlan Stern * For a newly detected device, @dev_descr must be NULL. The device 4797ff33299eSAlan Stern * descriptor retrieved from the device will then be stored in 4798ff33299eSAlan Stern * @udev->descriptor. For an already existing device, @dev_descr 4799ff33299eSAlan Stern * must be non-NULL. The device descriptor will be stored there, 4800ff33299eSAlan Stern * not in @udev->descriptor, because descriptors for registered 4801ff33299eSAlan Stern * devices are meant to be immutable. 48021da177e4SLinus Torvalds */ 48031da177e4SLinus Torvalds static int 48041da177e4SLinus Torvalds hub_port_init(struct usb_hub *hub, struct usb_device *udev, int port1, 4805ff33299eSAlan Stern int retry_counter, struct usb_device_descriptor *dev_descr) 48061da177e4SLinus Torvalds { 48071da177e4SLinus Torvalds struct usb_device *hdev = hub->hdev; 4808e7b77172SSarah Sharp struct usb_hcd *hcd = bus_to_hcd(hdev->bus); 480925244227SNicolas Boichat struct usb_port *port_dev = hub->ports[port1 - 1]; 48100d5ce778SOliver Neukum int retries, operations, retval, i; 48111da177e4SLinus Torvalds unsigned delay = HUB_SHORT_RESET_TIME; 48121da177e4SLinus Torvalds enum usb_device_speed oldspeed = udev->speed; 4813e538dfdaSMichal Nazarewicz const char *speed; 48144326ed0bSAlan Stern int devnum = udev->devnum; 48151bb90cf0SPeter Chen const char *driver_name; 481619502e69SAlan Stern bool do_new_scheme; 4817ff33299eSAlan Stern const bool initial = !dev_descr; 481885d07c55SAlan Stern int maxp0; 4819de28e469SAlan Stern struct usb_device_descriptor *buf, *descr; 482085d07c55SAlan Stern 482185d07c55SAlan Stern buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO); 482285d07c55SAlan Stern if (!buf) 482385d07c55SAlan Stern return -ENOMEM; 48241da177e4SLinus Torvalds 48251da177e4SLinus Torvalds /* root hub ports have a slightly longer reset period 48261da177e4SLinus Torvalds * (from USB 2.0 spec, section 7.1.7.5) 48271da177e4SLinus Torvalds */ 48281da177e4SLinus Torvalds if (!hdev->parent) { 48291da177e4SLinus Torvalds delay = HUB_ROOT_RESET_TIME; 48301da177e4SLinus Torvalds if (port1 == hdev->bus->otg_port) 48311da177e4SLinus Torvalds hdev->bus->b_hnp_enable = 0; 48321da177e4SLinus Torvalds } 48331da177e4SLinus Torvalds 48341da177e4SLinus Torvalds /* Some low speed devices have problems with the quick delay, so */ 48351da177e4SLinus Torvalds /* be a bit pessimistic with those devices. RHbug #23670 */ 48361da177e4SLinus Torvalds if (oldspeed == USB_SPEED_LOW) 48371da177e4SLinus Torvalds delay = HUB_LONG_RESET_TIME; 48381da177e4SLinus Torvalds 48391da177e4SLinus Torvalds /* Reset the device; full speed may morph to high speed */ 4840e7b77172SSarah Sharp /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */ 484175d7cf72SAndiry Xu retval = hub_port_reset(hub, port1, udev, delay, false); 48421da177e4SLinus Torvalds if (retval < 0) /* error or disconnect */ 48431da177e4SLinus Torvalds goto fail; 48441da177e4SLinus Torvalds /* success, speed is known */ 484507194ab7SLuben Tuikov 48461da177e4SLinus Torvalds retval = -ENODEV; 48471da177e4SLinus Torvalds 48488a1b2725SMathias Nyman /* Don't allow speed changes at reset, except usb 3.0 to faster */ 48498a1b2725SMathias Nyman if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed && 48508a1b2725SMathias Nyman !(oldspeed == USB_SPEED_SUPER && udev->speed > oldspeed)) { 48511da177e4SLinus Torvalds dev_dbg(&udev->dev, "device reset changed speed!\n"); 48521da177e4SLinus Torvalds goto fail; 48531da177e4SLinus Torvalds } 48541da177e4SLinus Torvalds oldspeed = udev->speed; 48551da177e4SLinus Torvalds 4856ff33299eSAlan Stern if (initial) { 48571da177e4SLinus Torvalds /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ... 48581da177e4SLinus Torvalds * it's fixed size except for full speed devices. 48591da177e4SLinus Torvalds */ 48601da177e4SLinus Torvalds switch (udev->speed) { 48618a1b2725SMathias Nyman case USB_SPEED_SUPER_PLUS: 48626b403b02SSarah Sharp case USB_SPEED_SUPER: 4863551509d2SHarvey Harrison udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512); 48645bb6e0aeSInaky Perez-Gonzalez break; 48651da177e4SLinus Torvalds case USB_SPEED_HIGH: /* fixed at 64 */ 4866551509d2SHarvey Harrison udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64); 48671da177e4SLinus Torvalds break; 48681da177e4SLinus Torvalds case USB_SPEED_FULL: /* 8, 16, 32, or 64 */ 48691da177e4SLinus Torvalds /* to determine the ep0 maxpacket size, try to read 48701da177e4SLinus Torvalds * the device descriptor to get bMaxPacketSize0 and 48711da177e4SLinus Torvalds * then correct our initial guess. 48721da177e4SLinus Torvalds */ 4873551509d2SHarvey Harrison udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64); 48741da177e4SLinus Torvalds break; 48751da177e4SLinus Torvalds case USB_SPEED_LOW: /* fixed at 8 */ 4876551509d2SHarvey Harrison udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8); 48771da177e4SLinus Torvalds break; 48781da177e4SLinus Torvalds default: 48791da177e4SLinus Torvalds goto fail; 48801da177e4SLinus Torvalds } 4881ff33299eSAlan Stern } 48821da177e4SLinus Torvalds 4883e538dfdaSMichal Nazarewicz speed = usb_speed_string(udev->speed); 4884e538dfdaSMichal Nazarewicz 48851bb90cf0SPeter Chen /* 48861bb90cf0SPeter Chen * The controller driver may be NULL if the controller device 48871bb90cf0SPeter Chen * is the middle device between platform device and roothub. 48881bb90cf0SPeter Chen * This middle device may not need a device driver due to 48891bb90cf0SPeter Chen * all hardware control can be at platform device driver, this 48901bb90cf0SPeter Chen * platform device is usually a dual-role USB controller device. 48911bb90cf0SPeter Chen */ 48921bb90cf0SPeter Chen if (udev->bus->controller->driver) 48931bb90cf0SPeter Chen driver_name = udev->bus->controller->driver->name; 48941bb90cf0SPeter Chen else 48951bb90cf0SPeter Chen driver_name = udev->bus->sysdev->driver->name; 48961bb90cf0SPeter Chen 48978a1b2725SMathias Nyman if (udev->speed < USB_SPEED_SUPER) 489883a07196SInaky Perez-Gonzalez dev_info(&udev->dev, 4899e538dfdaSMichal Nazarewicz "%s %s USB device number %d using %s\n", 4900ff33299eSAlan Stern (initial ? "new" : "reset"), speed, 49011bb90cf0SPeter Chen devnum, driver_name); 49021da177e4SLinus Torvalds 4903ff33299eSAlan Stern if (initial) { 49041da177e4SLinus Torvalds /* Set up TT records, if needed */ 49051da177e4SLinus Torvalds if (hdev->tt) { 49061da177e4SLinus Torvalds udev->tt = hdev->tt; 49071da177e4SLinus Torvalds udev->ttport = hdev->ttport; 49081da177e4SLinus Torvalds } else if (udev->speed != USB_SPEED_HIGH 49091da177e4SLinus Torvalds && hdev->speed == USB_SPEED_HIGH) { 4910d199c96dSAlan Stern if (!hub->tt.hub) { 4911d199c96dSAlan Stern dev_err(&udev->dev, "parent hub has no TT\n"); 4912d199c96dSAlan Stern retval = -EINVAL; 4913d199c96dSAlan Stern goto fail; 4914d199c96dSAlan Stern } 49151da177e4SLinus Torvalds udev->tt = &hub->tt; 49161da177e4SLinus Torvalds udev->ttport = port1; 49171da177e4SLinus Torvalds } 4918ff33299eSAlan Stern } 49191da177e4SLinus Torvalds 49201da177e4SLinus Torvalds /* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way? 49211da177e4SLinus Torvalds * Because device hardware and firmware is sometimes buggy in 49221da177e4SLinus Torvalds * this area, and this is how Linux has done it for ages. 49231da177e4SLinus Torvalds * Change it cautiously. 49241da177e4SLinus Torvalds * 492548fc7dbdSDan Williams * NOTE: If use_new_scheme() is true we will start by issuing 49261da177e4SLinus Torvalds * a 64-byte GET_DESCRIPTOR request. This is what Windows does, 49271da177e4SLinus Torvalds * so it may help with some non-standards-compliant devices. 49281da177e4SLinus Torvalds * Otherwise we start with SET_ADDRESS and then try to read the 49291da177e4SLinus Torvalds * first 8 bytes of the device descriptor to get the ep0 maxpacket 49301da177e4SLinus Torvalds * value. 49311da177e4SLinus Torvalds */ 493219502e69SAlan Stern do_new_scheme = use_new_scheme(udev, retry_counter, port_dev); 493348fc7dbdSDan Williams 493419502e69SAlan Stern for (retries = 0; retries < GET_DESCRIPTOR_TRIES; (++retries, msleep(100))) { 4935430d57f5SRay Chi if (hub_port_stop_enumerate(hub, port1, retries)) { 4936430d57f5SRay Chi retval = -ENODEV; 4937430d57f5SRay Chi break; 4938430d57f5SRay Chi } 4939430d57f5SRay Chi 494019502e69SAlan Stern if (do_new_scheme) { 494148fc7dbdSDan Williams retval = hub_enable_device(udev); 4942938569ebSOliver Neukum if (retval < 0) { 4943938569ebSOliver Neukum dev_err(&udev->dev, 4944938569ebSOliver Neukum "hub failed to enable device, error %d\n", 4945938569ebSOliver Neukum retval); 494648fc7dbdSDan Williams goto fail; 4947938569ebSOliver Neukum } 494848fc7dbdSDan Williams 494985d07c55SAlan Stern maxp0 = get_bMaxPacketSize0(udev, buf, 495085d07c55SAlan Stern GET_DESCRIPTOR_BUFSIZE, retries == 0); 4951ff33299eSAlan Stern if (maxp0 > 0 && !initial && 4952ff33299eSAlan Stern maxp0 != udev->descriptor.bMaxPacketSize0) { 4953ff33299eSAlan Stern dev_err(&udev->dev, "device reset changed ep0 maxpacket size!\n"); 4954ff33299eSAlan Stern retval = -ENODEV; 4955ff33299eSAlan Stern goto fail; 4956ff33299eSAlan Stern } 49571da177e4SLinus Torvalds 495875d7cf72SAndiry Xu retval = hub_port_reset(hub, port1, udev, delay, false); 49591da177e4SLinus Torvalds if (retval < 0) /* error or disconnect */ 49601da177e4SLinus Torvalds goto fail; 49611da177e4SLinus Torvalds if (oldspeed != udev->speed) { 49621da177e4SLinus Torvalds dev_dbg(&udev->dev, 49631da177e4SLinus Torvalds "device reset changed speed!\n"); 49641da177e4SLinus Torvalds retval = -ENODEV; 49651da177e4SLinus Torvalds goto fail; 49661da177e4SLinus Torvalds } 496785d07c55SAlan Stern if (maxp0 < 0) { 496885d07c55SAlan Stern if (maxp0 != -ENODEV) 4969e9e88fb7SAlan Stern dev_err(&udev->dev, "device descriptor read/64, error %d\n", 497085d07c55SAlan Stern maxp0); 497185d07c55SAlan Stern retval = maxp0; 49721da177e4SLinus Torvalds continue; 49731da177e4SLinus Torvalds } 49741da177e4SLinus Torvalds } 49751da177e4SLinus Torvalds 49760d5ce778SOliver Neukum for (operations = 0; operations < SET_ADDRESS_TRIES; ++operations) { 49774326ed0bSAlan Stern retval = hub_set_address(udev, devnum); 49781da177e4SLinus Torvalds if (retval >= 0) 49791da177e4SLinus Torvalds break; 49801da177e4SLinus Torvalds msleep(200); 49811da177e4SLinus Torvalds } 49821da177e4SLinus Torvalds if (retval < 0) { 4983e9e88fb7SAlan Stern if (retval != -ENODEV) 4984e9e88fb7SAlan Stern dev_err(&udev->dev, "device not accepting address %d, error %d\n", 49854326ed0bSAlan Stern devnum, retval); 49861da177e4SLinus Torvalds goto fail; 49871da177e4SLinus Torvalds } 49888a1b2725SMathias Nyman if (udev->speed >= USB_SPEED_SUPER) { 4989c6515272SSarah Sharp devnum = udev->devnum; 4990c6515272SSarah Sharp dev_info(&udev->dev, 499145455e4dSMathias Nyman "%s SuperSpeed%s%s USB device number %d using %s\n", 4992c6515272SSarah Sharp (udev->config) ? "reset" : "new", 499345455e4dSMathias Nyman (udev->speed == USB_SPEED_SUPER_PLUS) ? 49942d0e82c9SThinh Nguyen " Plus" : "", 49952d0e82c9SThinh Nguyen (udev->ssp_rate == USB_SSP_GEN_2x2) ? 49962d0e82c9SThinh Nguyen " Gen 2x2" : 49972d0e82c9SThinh Nguyen (udev->ssp_rate == USB_SSP_GEN_2x1) ? 49982d0e82c9SThinh Nguyen " Gen 2x1" : 49992d0e82c9SThinh Nguyen (udev->ssp_rate == USB_SSP_GEN_1x2) ? 50002d0e82c9SThinh Nguyen " Gen 1x2" : "", 50011bb90cf0SPeter Chen devnum, driver_name); 5002c6515272SSarah Sharp } 50031da177e4SLinus Torvalds 50041e4c5742SAlan Stern /* 50051e4c5742SAlan Stern * cope with hardware quirkiness: 50061da177e4SLinus Torvalds * - let SET_ADDRESS settle, some device hardware wants it 50071da177e4SLinus Torvalds * - read ep0 maxpacket even for high and low speed, 50081da177e4SLinus Torvalds */ 50091da177e4SLinus Torvalds msleep(10); 50101e4c5742SAlan Stern 501119502e69SAlan Stern if (do_new_scheme) 50121da177e4SLinus Torvalds break; 50131da177e4SLinus Torvalds 501485d07c55SAlan Stern maxp0 = get_bMaxPacketSize0(udev, buf, 8, retries == 0); 501585d07c55SAlan Stern if (maxp0 < 0) { 501685d07c55SAlan Stern retval = maxp0; 5017e9e88fb7SAlan Stern if (retval != -ENODEV) 5018b9cef6c3SWu Fengguang dev_err(&udev->dev, 5019b9cef6c3SWu Fengguang "device descriptor read/8, error %d\n", 5020b9cef6c3SWu Fengguang retval); 50211da177e4SLinus Torvalds } else { 5022886ee36eSFelipe Balbi u32 delay; 5023886ee36eSFelipe Balbi 5024ff33299eSAlan Stern if (!initial && maxp0 != udev->descriptor.bMaxPacketSize0) { 5025ff33299eSAlan Stern dev_err(&udev->dev, "device reset changed ep0 maxpacket size!\n"); 5026ff33299eSAlan Stern retval = -ENODEV; 5027ff33299eSAlan Stern goto fail; 5028ff33299eSAlan Stern } 5029ff33299eSAlan Stern 5030886ee36eSFelipe Balbi delay = udev->parent->hub_delay; 5031886ee36eSFelipe Balbi udev->hub_delay = min_t(u32, delay, 5032886ee36eSFelipe Balbi USB_TP_TRANSMISSION_DELAY_MAX); 5033886ee36eSFelipe Balbi retval = usb_set_isoch_delay(udev); 5034886ee36eSFelipe Balbi if (retval) { 5035886ee36eSFelipe Balbi dev_dbg(&udev->dev, 5036886ee36eSFelipe Balbi "Failed set isoch delay, error %d\n", 5037886ee36eSFelipe Balbi retval); 5038886ee36eSFelipe Balbi retval = 0; 5039886ee36eSFelipe Balbi } 50401da177e4SLinus Torvalds break; 50411da177e4SLinus Torvalds } 50421da177e4SLinus Torvalds } 50431da177e4SLinus Torvalds if (retval) 50441da177e4SLinus Torvalds goto fail; 50451da177e4SLinus Torvalds 504659cf4457SAlan Stern /* 504759cf4457SAlan Stern * Check the ep0 maxpacket guess and correct it if necessary. 504859cf4457SAlan Stern * maxp0 is the value stored in the device descriptor; 504959cf4457SAlan Stern * i is the value it encodes (logarithmic for SuperSpeed or greater). 505059cf4457SAlan Stern */ 505185d07c55SAlan Stern i = maxp0; 505259cf4457SAlan Stern if (udev->speed >= USB_SPEED_SUPER) { 505359cf4457SAlan Stern if (maxp0 <= 16) 505459cf4457SAlan Stern i = 1 << maxp0; 505559cf4457SAlan Stern else 505659cf4457SAlan Stern i = 0; /* Invalid */ 50571da177e4SLinus Torvalds } 505859cf4457SAlan Stern if (usb_endpoint_maxp(&udev->ep0.desc) == i) { 505959cf4457SAlan Stern ; /* Initial ep0 maxpacket guess is right */ 506059cf4457SAlan Stern } else if ((udev->speed == USB_SPEED_FULL || 506159cf4457SAlan Stern udev->speed == USB_SPEED_HIGH) && 506259cf4457SAlan Stern (i == 8 || i == 16 || i == 32 || i == 64)) { 506359cf4457SAlan Stern /* Initial guess is wrong; use the descriptor's value */ 506456626a72SAlan Stern if (udev->speed == USB_SPEED_FULL) 50651da177e4SLinus Torvalds dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i); 506656626a72SAlan Stern else 506756626a72SAlan Stern dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i); 50681da177e4SLinus Torvalds udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i); 5069fc721f51SInaky Perez-Gonzalez usb_ep0_reinit(udev); 507059cf4457SAlan Stern } else { 507159cf4457SAlan Stern /* Initial guess is wrong and descriptor's value is invalid */ 507259cf4457SAlan Stern dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", maxp0); 507359cf4457SAlan Stern retval = -EMSGSIZE; 507459cf4457SAlan Stern goto fail; 50751da177e4SLinus Torvalds } 50761da177e4SLinus Torvalds 5077de28e469SAlan Stern descr = usb_get_device_descriptor(udev); 5078de28e469SAlan Stern if (IS_ERR(descr)) { 5079de28e469SAlan Stern retval = PTR_ERR(descr); 5080e9e88fb7SAlan Stern if (retval != -ENODEV) 5081b9cef6c3SWu Fengguang dev_err(&udev->dev, "device descriptor read/all, error %d\n", 5082b9cef6c3SWu Fengguang retval); 50831da177e4SLinus Torvalds goto fail; 50841da177e4SLinus Torvalds } 5085ff33299eSAlan Stern if (initial) 5086de28e469SAlan Stern udev->descriptor = *descr; 5087ff33299eSAlan Stern else 5088ff33299eSAlan Stern *dev_descr = *descr; 5089de28e469SAlan Stern kfree(descr); 50901da177e4SLinus Torvalds 509185d07c55SAlan Stern /* 509285d07c55SAlan Stern * Some superspeed devices have finished the link training process 509385d07c55SAlan Stern * and attached to a superspeed hub port, but the device descriptor 509485d07c55SAlan Stern * got from those devices show they aren't superspeed devices. Warm 509585d07c55SAlan Stern * reset the port attached by the devices can fix them. 509685d07c55SAlan Stern */ 509785d07c55SAlan Stern if ((udev->speed >= USB_SPEED_SUPER) && 509885d07c55SAlan Stern (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) { 509985d07c55SAlan Stern dev_err(&udev->dev, "got a wrong device descriptor, warm reset device\n"); 510085d07c55SAlan Stern hub_port_reset(hub, port1, udev, HUB_BH_RESET_TIME, true); 510185d07c55SAlan Stern retval = -EINVAL; 510285d07c55SAlan Stern goto fail; 510385d07c55SAlan Stern } 510485d07c55SAlan Stern 5105ad87e032SAlan Stern usb_detect_quirks(udev); 5106ad87e032SAlan Stern 51071e4c5742SAlan Stern if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) { 51081ff4df56SAndiry Xu retval = usb_get_bos_descriptor(udev); 510951e0a012SSarah Sharp if (!retval) { 5110d9b2099cSSarah Sharp udev->lpm_capable = usb_device_supports_lpm(udev); 5111cd36facfSMathias Nyman udev->lpm_disable_count = 1; 511251e0a012SSarah Sharp usb_set_lpm_parameters(udev); 5113e146caf3SMathias Nyman usb_req_set_sel(udev); 511451e0a012SSarah Sharp } 51151ff4df56SAndiry Xu } 51163148bf04SAndiry Xu 51171da177e4SLinus Torvalds retval = 0; 511848f24970SAlek Du /* notify HCD that we have a device connected and addressed */ 511948f24970SAlek Du if (hcd->driver->update_device) 512048f24970SAlek Du hcd->driver->update_device(hcd, udev); 5121890dae88SMathias Nyman hub_set_initial_usb2_lpm_policy(udev); 51221da177e4SLinus Torvalds fail: 51234326ed0bSAlan Stern if (retval) { 51241da177e4SLinus Torvalds hub_port_disable(hub, port1, 0); 51253b29b68bSAlan Stern update_devnum(udev, devnum); /* for disconnect processing */ 51264326ed0bSAlan Stern } 512785d07c55SAlan Stern kfree(buf); 51281da177e4SLinus Torvalds return retval; 51291da177e4SLinus Torvalds } 51301da177e4SLinus Torvalds 51311da177e4SLinus Torvalds static void 51321da177e4SLinus Torvalds check_highspeed(struct usb_hub *hub, struct usb_device *udev, int port1) 51331da177e4SLinus Torvalds { 51341da177e4SLinus Torvalds struct usb_qualifier_descriptor *qual; 51351da177e4SLinus Torvalds int status; 51361da177e4SLinus Torvalds 51372a159389SJohan Hovold if (udev->quirks & USB_QUIRK_DEVICE_QUALIFIER) 51382a159389SJohan Hovold return; 51392a159389SJohan Hovold 5140e94b1766SChristoph Lameter qual = kmalloc(sizeof *qual, GFP_KERNEL); 51411da177e4SLinus Torvalds if (qual == NULL) 51421da177e4SLinus Torvalds return; 51431da177e4SLinus Torvalds 51441da177e4SLinus Torvalds status = usb_get_descriptor(udev, USB_DT_DEVICE_QUALIFIER, 0, 51451da177e4SLinus Torvalds qual, sizeof *qual); 51461da177e4SLinus Torvalds if (status == sizeof *qual) { 51471da177e4SLinus Torvalds dev_info(&udev->dev, "not running at top speed; " 51481da177e4SLinus Torvalds "connect to a high speed hub\n"); 51491da177e4SLinus Torvalds /* hub LEDs are probably harder to miss than syslog */ 51501da177e4SLinus Torvalds if (hub->has_indicators) { 51511da177e4SLinus Torvalds hub->indicator[port1-1] = INDICATOR_GREEN_BLINK; 515222f6a0f0SShaibal Dutta queue_delayed_work(system_power_efficient_wq, 515322f6a0f0SShaibal Dutta &hub->leds, 0); 51541da177e4SLinus Torvalds } 51551da177e4SLinus Torvalds } 51561da177e4SLinus Torvalds kfree(qual); 51571da177e4SLinus Torvalds } 51581da177e4SLinus Torvalds 51591da177e4SLinus Torvalds static unsigned 51601da177e4SLinus Torvalds hub_power_remaining(struct usb_hub *hub) 51611da177e4SLinus Torvalds { 51621da177e4SLinus Torvalds struct usb_device *hdev = hub->hdev; 51631da177e4SLinus Torvalds int remaining; 516455c52718SAlan Stern int port1; 51651da177e4SLinus Torvalds 516655c52718SAlan Stern if (!hub->limited_power) 51671da177e4SLinus Torvalds return 0; 51681da177e4SLinus Torvalds 516955c52718SAlan Stern remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent; 517055c52718SAlan Stern for (port1 = 1; port1 <= hdev->maxchild; ++port1) { 5171d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 5172d99f6b41SDan Williams struct usb_device *udev = port_dev->child; 5173430ee58eSSebastian Andrzej Siewior unsigned unit_load; 5174d99f6b41SDan Williams int delta; 51751da177e4SLinus Torvalds 51761da177e4SLinus Torvalds if (!udev) 51771da177e4SLinus Torvalds continue; 5178430ee58eSSebastian Andrzej Siewior if (hub_is_superspeed(udev)) 5179430ee58eSSebastian Andrzej Siewior unit_load = 150; 5180430ee58eSSebastian Andrzej Siewior else 5181430ee58eSSebastian Andrzej Siewior unit_load = 100; 51821da177e4SLinus Torvalds 5183430ee58eSSebastian Andrzej Siewior /* 5184430ee58eSSebastian Andrzej Siewior * Unconfigured devices may not use more than one unit load, 5185430ee58eSSebastian Andrzej Siewior * or 8mA for OTG ports 5186430ee58eSSebastian Andrzej Siewior */ 51871da177e4SLinus Torvalds if (udev->actconfig) 51888d8479dbSSebastian Andrzej Siewior delta = usb_get_max_power(udev, udev->actconfig); 518955c52718SAlan Stern else if (port1 != udev->bus->otg_port || hdev->parent) 5190430ee58eSSebastian Andrzej Siewior delta = unit_load; 51911da177e4SLinus Torvalds else 519255c52718SAlan Stern delta = 8; 519355c52718SAlan Stern if (delta > hub->mA_per_port) 5194d99f6b41SDan Williams dev_warn(&port_dev->dev, "%dmA is over %umA budget!\n", 5195d99f6b41SDan Williams delta, hub->mA_per_port); 51961da177e4SLinus Torvalds remaining -= delta; 51971da177e4SLinus Torvalds } 51981da177e4SLinus Torvalds if (remaining < 0) { 519955c52718SAlan Stern dev_warn(hub->intfdev, "%dmA over power budget!\n", 520055c52718SAlan Stern -remaining); 52011da177e4SLinus Torvalds remaining = 0; 52021da177e4SLinus Torvalds } 52031da177e4SLinus Torvalds return remaining; 52041da177e4SLinus Torvalds } 52051da177e4SLinus Torvalds 5206a4f55d8bSDavid Heinzelmann 5207a4f55d8bSDavid Heinzelmann static int descriptors_changed(struct usb_device *udev, 5208de28e469SAlan Stern struct usb_device_descriptor *new_device_descriptor, 5209a4f55d8bSDavid Heinzelmann struct usb_host_bos *old_bos) 5210a4f55d8bSDavid Heinzelmann { 5211a4f55d8bSDavid Heinzelmann int changed = 0; 5212a4f55d8bSDavid Heinzelmann unsigned index; 5213a4f55d8bSDavid Heinzelmann unsigned serial_len = 0; 5214a4f55d8bSDavid Heinzelmann unsigned len; 5215a4f55d8bSDavid Heinzelmann unsigned old_length; 5216a4f55d8bSDavid Heinzelmann int length; 5217a4f55d8bSDavid Heinzelmann char *buf; 5218a4f55d8bSDavid Heinzelmann 5219de28e469SAlan Stern if (memcmp(&udev->descriptor, new_device_descriptor, 5220de28e469SAlan Stern sizeof(*new_device_descriptor)) != 0) 5221a4f55d8bSDavid Heinzelmann return 1; 5222a4f55d8bSDavid Heinzelmann 5223a4f55d8bSDavid Heinzelmann if ((old_bos && !udev->bos) || (!old_bos && udev->bos)) 5224a4f55d8bSDavid Heinzelmann return 1; 5225a4f55d8bSDavid Heinzelmann if (udev->bos) { 5226a4f55d8bSDavid Heinzelmann len = le16_to_cpu(udev->bos->desc->wTotalLength); 5227a4f55d8bSDavid Heinzelmann if (len != le16_to_cpu(old_bos->desc->wTotalLength)) 5228a4f55d8bSDavid Heinzelmann return 1; 5229a4f55d8bSDavid Heinzelmann if (memcmp(udev->bos->desc, old_bos->desc, len)) 5230a4f55d8bSDavid Heinzelmann return 1; 5231a4f55d8bSDavid Heinzelmann } 5232a4f55d8bSDavid Heinzelmann 5233a4f55d8bSDavid Heinzelmann /* Since the idVendor, idProduct, and bcdDevice values in the 5234a4f55d8bSDavid Heinzelmann * device descriptor haven't changed, we will assume the 5235a4f55d8bSDavid Heinzelmann * Manufacturer and Product strings haven't changed either. 5236a4f55d8bSDavid Heinzelmann * But the SerialNumber string could be different (e.g., a 5237a4f55d8bSDavid Heinzelmann * different flash card of the same brand). 5238a4f55d8bSDavid Heinzelmann */ 5239a4f55d8bSDavid Heinzelmann if (udev->serial) 5240a4f55d8bSDavid Heinzelmann serial_len = strlen(udev->serial) + 1; 5241a4f55d8bSDavid Heinzelmann 5242a4f55d8bSDavid Heinzelmann len = serial_len; 5243a4f55d8bSDavid Heinzelmann for (index = 0; index < udev->descriptor.bNumConfigurations; index++) { 5244a4f55d8bSDavid Heinzelmann old_length = le16_to_cpu(udev->config[index].desc.wTotalLength); 5245a4f55d8bSDavid Heinzelmann len = max(len, old_length); 5246a4f55d8bSDavid Heinzelmann } 5247a4f55d8bSDavid Heinzelmann 5248a4f55d8bSDavid Heinzelmann buf = kmalloc(len, GFP_NOIO); 5249a4f55d8bSDavid Heinzelmann if (!buf) 5250a4f55d8bSDavid Heinzelmann /* assume the worst */ 5251a4f55d8bSDavid Heinzelmann return 1; 5252a4f55d8bSDavid Heinzelmann 5253a4f55d8bSDavid Heinzelmann for (index = 0; index < udev->descriptor.bNumConfigurations; index++) { 5254a4f55d8bSDavid Heinzelmann old_length = le16_to_cpu(udev->config[index].desc.wTotalLength); 5255a4f55d8bSDavid Heinzelmann length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf, 5256a4f55d8bSDavid Heinzelmann old_length); 5257a4f55d8bSDavid Heinzelmann if (length != old_length) { 5258a4f55d8bSDavid Heinzelmann dev_dbg(&udev->dev, "config index %d, error %d\n", 5259a4f55d8bSDavid Heinzelmann index, length); 5260a4f55d8bSDavid Heinzelmann changed = 1; 5261a4f55d8bSDavid Heinzelmann break; 5262a4f55d8bSDavid Heinzelmann } 5263a4f55d8bSDavid Heinzelmann if (memcmp(buf, udev->rawdescriptors[index], old_length) 5264a4f55d8bSDavid Heinzelmann != 0) { 5265a4f55d8bSDavid Heinzelmann dev_dbg(&udev->dev, "config index %d changed (#%d)\n", 5266a4f55d8bSDavid Heinzelmann index, 5267a4f55d8bSDavid Heinzelmann ((struct usb_config_descriptor *) buf)-> 5268a4f55d8bSDavid Heinzelmann bConfigurationValue); 5269a4f55d8bSDavid Heinzelmann changed = 1; 5270a4f55d8bSDavid Heinzelmann break; 5271a4f55d8bSDavid Heinzelmann } 5272a4f55d8bSDavid Heinzelmann } 5273a4f55d8bSDavid Heinzelmann 5274a4f55d8bSDavid Heinzelmann if (!changed && serial_len) { 5275a4f55d8bSDavid Heinzelmann length = usb_string(udev, udev->descriptor.iSerialNumber, 5276a4f55d8bSDavid Heinzelmann buf, serial_len); 5277a4f55d8bSDavid Heinzelmann if (length + 1 != serial_len) { 5278a4f55d8bSDavid Heinzelmann dev_dbg(&udev->dev, "serial string error %d\n", 5279a4f55d8bSDavid Heinzelmann length); 5280a4f55d8bSDavid Heinzelmann changed = 1; 5281a4f55d8bSDavid Heinzelmann } else if (memcmp(buf, udev->serial, length) != 0) { 5282a4f55d8bSDavid Heinzelmann dev_dbg(&udev->dev, "serial string changed\n"); 5283a4f55d8bSDavid Heinzelmann changed = 1; 5284a4f55d8bSDavid Heinzelmann } 5285a4f55d8bSDavid Heinzelmann } 5286a4f55d8bSDavid Heinzelmann 5287a4f55d8bSDavid Heinzelmann kfree(buf); 5288a4f55d8bSDavid Heinzelmann return changed; 5289a4f55d8bSDavid Heinzelmann } 5290a4f55d8bSDavid Heinzelmann 5291af376a46SDan Williams static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus, 5292af376a46SDan Williams u16 portchange) 52931da177e4SLinus Torvalds { 529494c43b98SAlan Stern int status = -ENODEV; 529594c43b98SAlan Stern int i; 5296430ee58eSSebastian Andrzej Siewior unsigned unit_load; 52971da177e4SLinus Torvalds struct usb_device *hdev = hub->hdev; 52981da177e4SLinus Torvalds struct usb_hcd *hcd = bus_to_hcd(hdev->bus); 5299d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 5300af376a46SDan Williams struct usb_device *udev = port_dev->child; 53015ee0f803SOliver Neukum static int unreliable_port = -1; 53026cca13deSMathias Nyman bool retry_locked; 53038808f00cSAlan Stern 530424618b0cSAlan Stern /* Disconnect any existing devices under this port */ 5305b76baa81SPeter Chen if (udev) { 5306b2108f1eSPeter Chen if (hcd->usb_phy && !hdev->parent) 53073d46e73dSAntoine Tenart usb_phy_notify_disconnect(hcd->usb_phy, udev->speed); 5308d99f6b41SDan Williams usb_disconnect(&port_dev->child); 5309b76baa81SPeter Chen } 531024618b0cSAlan Stern 5311253e0572SAlan Stern /* We can forget about a "removed" device when there's a physical 5312253e0572SAlan Stern * disconnect or the connect status changes. 5313253e0572SAlan Stern */ 5314253e0572SAlan Stern if (!(portstatus & USB_PORT_STAT_CONNECTION) || 5315253e0572SAlan Stern (portchange & USB_PORT_STAT_C_CONNECTION)) 5316253e0572SAlan Stern clear_bit(port1, hub->removed_bits); 5317253e0572SAlan Stern 53185257d97aSAlan Stern if (portchange & (USB_PORT_STAT_C_CONNECTION | 53195257d97aSAlan Stern USB_PORT_STAT_C_ENABLE)) { 5320ad493e5eSLan Tianyu status = hub_port_debounce_be_stable(hub, port1); 53215257d97aSAlan Stern if (status < 0) { 53225ee0f803SOliver Neukum if (status != -ENODEV && 53235ee0f803SOliver Neukum port1 != unreliable_port && 53245ee0f803SOliver Neukum printk_ratelimit()) 5325dd5f5006STakashi Iwai dev_err(&port_dev->dev, "connect-debounce failed\n"); 53265257d97aSAlan Stern portstatus &= ~USB_PORT_STAT_CONNECTION; 53275ee0f803SOliver Neukum unreliable_port = port1; 53285257d97aSAlan Stern } else { 53295257d97aSAlan Stern portstatus = status; 53305257d97aSAlan Stern } 53315257d97aSAlan Stern } 53325257d97aSAlan Stern 5333253e0572SAlan Stern /* Return now if debouncing failed or nothing is connected or 5334253e0572SAlan Stern * the device was "removed". 5335253e0572SAlan Stern */ 5336253e0572SAlan Stern if (!(portstatus & USB_PORT_STAT_CONNECTION) || 5337253e0572SAlan Stern test_bit(port1, hub->removed_bits)) { 53381da177e4SLinus Torvalds 5339fbaecff0SDeepak Das /* 5340fbaecff0SDeepak Das * maybe switch power back on (e.g. root hub was reset) 5341fbaecff0SDeepak Das * but only if the port isn't owned by someone else. 5342fbaecff0SDeepak Das */ 53439262c19dSDan Williams if (hub_is_port_power_switchable(hub) 5344f061f43dSMichael Grzeschik && !usb_port_is_power_on(hub, portstatus) 5345fbaecff0SDeepak Das && !port_dev->port_owner) 53461da177e4SLinus Torvalds set_port_feature(hdev, port1, USB_PORT_FEAT_POWER); 53471da177e4SLinus Torvalds 53481da177e4SLinus Torvalds if (portstatus & USB_PORT_STAT_ENABLE) 53491da177e4SLinus Torvalds goto done; 53501da177e4SLinus Torvalds return; 53511da177e4SLinus Torvalds } 5352430ee58eSSebastian Andrzej Siewior if (hub_is_superspeed(hub->hdev)) 5353430ee58eSSebastian Andrzej Siewior unit_load = 150; 5354430ee58eSSebastian Andrzej Siewior else 5355430ee58eSSebastian Andrzej Siewior unit_load = 100; 53561da177e4SLinus Torvalds 5357e9e88fb7SAlan Stern status = 0; 53586ae6dc22SMathias Nyman 535919502e69SAlan Stern for (i = 0; i < PORT_INIT_TRIES; i++) { 5360430d57f5SRay Chi if (hub_port_stop_enumerate(hub, port1, i)) { 5361430d57f5SRay Chi status = -ENODEV; 5362430d57f5SRay Chi break; 5363430d57f5SRay Chi } 5364430d57f5SRay Chi 53656cca13deSMathias Nyman usb_lock_port(port_dev); 53666cca13deSMathias Nyman mutex_lock(hcd->address0_mutex); 53676cca13deSMathias Nyman retry_locked = true; 53681da177e4SLinus Torvalds /* reallocate for each attempt, since references 53691da177e4SLinus Torvalds * to the previous one can escape in various ways 53701da177e4SLinus Torvalds */ 53711da177e4SLinus Torvalds udev = usb_alloc_dev(hdev, hdev->bus, port1); 53721da177e4SLinus Torvalds if (!udev) { 5373d99f6b41SDan Williams dev_err(&port_dev->dev, 5374d99f6b41SDan Williams "couldn't allocate usb_device\n"); 53756cca13deSMathias Nyman mutex_unlock(hcd->address0_mutex); 53766cca13deSMathias Nyman usb_unlock_port(port_dev); 53771da177e4SLinus Torvalds goto done; 53781da177e4SLinus Torvalds } 53791da177e4SLinus Torvalds 53801da177e4SLinus Torvalds usb_set_device_state(udev, USB_STATE_POWERED); 538155c52718SAlan Stern udev->bus_mA = hub->mA_per_port; 5382b6956ffaSAlan Stern udev->level = hdev->level + 1; 53831da177e4SLinus Torvalds 53848a1b2725SMathias Nyman /* Devices connected to SuperSpeed hubs are USB 3.0 or later */ 5385131dec34SSarah Sharp if (hub_is_superspeed(hub->hdev)) 5386e7b77172SSarah Sharp udev->speed = USB_SPEED_SUPER; 5387e7b77172SSarah Sharp else 5388e7b77172SSarah Sharp udev->speed = USB_SPEED_UNKNOWN; 5389e7b77172SSarah Sharp 53903b29b68bSAlan Stern choose_devnum(udev); 5391c6515272SSarah Sharp if (udev->devnum <= 0) { 5392c6515272SSarah Sharp status = -ENOTCONN; /* Don't retry */ 5393c6515272SSarah Sharp goto loop; 5394c6515272SSarah Sharp } 5395c6515272SSarah Sharp 5396e7b77172SSarah Sharp /* reset (non-USB 3.0 devices) and get descriptor */ 5397ff33299eSAlan Stern status = hub_port_init(hub, udev, port1, i, NULL); 53981da177e4SLinus Torvalds if (status < 0) 53991da177e4SLinus Torvalds goto loop; 54001da177e4SLinus Torvalds 54016ae6dc22SMathias Nyman mutex_unlock(hcd->address0_mutex); 54026cca13deSMathias Nyman usb_unlock_port(port_dev); 54036cca13deSMathias Nyman retry_locked = false; 54046ae6dc22SMathias Nyman 540593362a87SPhil Dibowitz if (udev->quirks & USB_QUIRK_DELAY_INIT) 5406b2a542bbSDmitry Fleytman msleep(2000); 540793362a87SPhil Dibowitz 54081da177e4SLinus Torvalds /* consecutive bus-powered hubs aren't reliable; they can 54091da177e4SLinus Torvalds * violate the voltage drop budget. if the new child has 54101da177e4SLinus Torvalds * a "powered" LED, users should notice we didn't enable it 54111da177e4SLinus Torvalds * (without reading syslog), even without per-port LEDs 54121da177e4SLinus Torvalds * on the parent. 54131da177e4SLinus Torvalds */ 54141da177e4SLinus Torvalds if (udev->descriptor.bDeviceClass == USB_CLASS_HUB 5415430ee58eSSebastian Andrzej Siewior && udev->bus_mA <= unit_load) { 54161da177e4SLinus Torvalds u16 devstat; 54171da177e4SLinus Torvalds 5418d9e1e148SFelipe Balbi status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, 54191da177e4SLinus Torvalds &devstat); 542015b7336eSAlan Stern if (status) { 54211da177e4SLinus Torvalds dev_dbg(&udev->dev, "get status %d ?\n", status); 54221da177e4SLinus Torvalds goto loop_disable; 54231da177e4SLinus Torvalds } 54241da177e4SLinus Torvalds if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) { 54251da177e4SLinus Torvalds dev_err(&udev->dev, 54261da177e4SLinus Torvalds "can't connect bus-powered hub " 54271da177e4SLinus Torvalds "to this port\n"); 54281da177e4SLinus Torvalds if (hub->has_indicators) { 54291da177e4SLinus Torvalds hub->indicator[port1-1] = 54301da177e4SLinus Torvalds INDICATOR_AMBER_BLINK; 543122f6a0f0SShaibal Dutta queue_delayed_work( 543222f6a0f0SShaibal Dutta system_power_efficient_wq, 543322f6a0f0SShaibal Dutta &hub->leds, 0); 54341da177e4SLinus Torvalds } 54351da177e4SLinus Torvalds status = -ENOTCONN; /* Don't retry */ 54361da177e4SLinus Torvalds goto loop_disable; 54371da177e4SLinus Torvalds } 54381da177e4SLinus Torvalds } 54391da177e4SLinus Torvalds 54401da177e4SLinus Torvalds /* check for devices running slower than they could */ 54411da177e4SLinus Torvalds if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200 54421da177e4SLinus Torvalds && udev->speed == USB_SPEED_FULL 54431da177e4SLinus Torvalds && highspeed_hubs != 0) 54441da177e4SLinus Torvalds check_highspeed(hub, udev, port1); 54451da177e4SLinus Torvalds 5446fa286188SGreg Kroah-Hartman /* Store the parent's children[] pointer. At this point 54471da177e4SLinus Torvalds * udev becomes globally accessible, although presumably 54481da177e4SLinus Torvalds * no one will look at it until hdev is unlocked. 54491da177e4SLinus Torvalds */ 54501da177e4SLinus Torvalds status = 0; 54511da177e4SLinus Torvalds 5452d8521afeSDan Williams mutex_lock(&usb_port_peer_mutex); 5453d8521afeSDan Williams 54541da177e4SLinus Torvalds /* We mustn't add new devices if the parent hub has 54551da177e4SLinus Torvalds * been disconnected; we would race with the 54561da177e4SLinus Torvalds * recursively_mark_NOTATTACHED() routine. 54571da177e4SLinus Torvalds */ 54581da177e4SLinus Torvalds spin_lock_irq(&device_state_lock); 54591da177e4SLinus Torvalds if (hdev->state == USB_STATE_NOTATTACHED) 54601da177e4SLinus Torvalds status = -ENOTCONN; 54611da177e4SLinus Torvalds else 5462d99f6b41SDan Williams port_dev->child = udev; 54631da177e4SLinus Torvalds spin_unlock_irq(&device_state_lock); 5464d8521afeSDan Williams mutex_unlock(&usb_port_peer_mutex); 54651da177e4SLinus Torvalds 54661da177e4SLinus Torvalds /* Run it through the hoops (find a driver, etc) */ 54671da177e4SLinus Torvalds if (!status) { 54681da177e4SLinus Torvalds status = usb_new_device(udev); 54691da177e4SLinus Torvalds if (status) { 5470d8521afeSDan Williams mutex_lock(&usb_port_peer_mutex); 54711da177e4SLinus Torvalds spin_lock_irq(&device_state_lock); 5472d99f6b41SDan Williams port_dev->child = NULL; 54731da177e4SLinus Torvalds spin_unlock_irq(&device_state_lock); 5474d8521afeSDan Williams mutex_unlock(&usb_port_peer_mutex); 547501ed67dcSTony Zheng } else { 547601ed67dcSTony Zheng if (hcd->usb_phy && !hdev->parent) 547701ed67dcSTony Zheng usb_phy_notify_connect(hcd->usb_phy, 547801ed67dcSTony Zheng udev->speed); 54791da177e4SLinus Torvalds } 54801da177e4SLinus Torvalds } 54811da177e4SLinus Torvalds 54821da177e4SLinus Torvalds if (status) 54831da177e4SLinus Torvalds goto loop_disable; 54841da177e4SLinus Torvalds 54851da177e4SLinus Torvalds status = hub_power_remaining(hub); 54861da177e4SLinus Torvalds if (status) 5487d99f6b41SDan Williams dev_dbg(hub->intfdev, "%dmA power budget left\n", status); 54881da177e4SLinus Torvalds 54891da177e4SLinus Torvalds return; 54901da177e4SLinus Torvalds 54911da177e4SLinus Torvalds loop_disable: 54921da177e4SLinus Torvalds hub_port_disable(hub, port1, 1); 54931da177e4SLinus Torvalds loop: 5494fc721f51SInaky Perez-Gonzalez usb_ep0_reinit(udev); 54953b29b68bSAlan Stern release_devnum(udev); 5496f7410cedSHerbert Xu hub_free_dev(udev); 54976cca13deSMathias Nyman if (retry_locked) { 54986cca13deSMathias Nyman mutex_unlock(hcd->address0_mutex); 54996cca13deSMathias Nyman usb_unlock_port(port_dev); 55006cca13deSMathias Nyman } 55011da177e4SLinus Torvalds usb_put_dev(udev); 5502ffcdc18dSVikram Pandita if ((status == -ENOTCONN) || (status == -ENOTSUPP)) 55031da177e4SLinus Torvalds break; 5504973593a9SMike Looijmans 5505973593a9SMike Looijmans /* When halfway through our retry count, power-cycle the port */ 550619502e69SAlan Stern if (i == (PORT_INIT_TRIES - 1) / 2) { 5507973593a9SMike Looijmans dev_info(&port_dev->dev, "attempt power cycle\n"); 5508973593a9SMike Looijmans usb_hub_set_port_power(hdev, hub, port1, false); 5509973593a9SMike Looijmans msleep(2 * hub_power_on_good_delay(hub)); 5510973593a9SMike Looijmans usb_hub_set_port_power(hdev, hub, port1, true); 5511973593a9SMike Looijmans msleep(hub_power_on_good_delay(hub)); 5512973593a9SMike Looijmans } 55131da177e4SLinus Torvalds } 55143a31155cSAlan Stern if (hub->hdev->parent || 55153a31155cSAlan Stern !hcd->driver->port_handed_over || 5516e9e88fb7SAlan Stern !(hcd->driver->port_handed_over)(hcd, port1)) { 5517e9e88fb7SAlan Stern if (status != -ENOTCONN && status != -ENODEV) 5518d99f6b41SDan Williams dev_err(&port_dev->dev, 5519d99f6b41SDan Williams "unable to enumerate USB device\n"); 5520e9e88fb7SAlan Stern } 55211da177e4SLinus Torvalds 55221da177e4SLinus Torvalds done: 55231da177e4SLinus Torvalds hub_port_disable(hub, port1, 1); 552494c43b98SAlan Stern if (hcd->driver->relinquish_port && !hub->hdev->parent) { 552594c43b98SAlan Stern if (status != -ENOTCONN && status != -ENODEV) 552690da096eSBalaji Rao hcd->driver->relinquish_port(hcd, port1); 552794c43b98SAlan Stern } 55281da177e4SLinus Torvalds } 55291da177e4SLinus Torvalds 5530af376a46SDan Williams /* Handle physical or logical connection change events. 5531af376a46SDan Williams * This routine is called when: 5532af376a46SDan Williams * a port connection-change occurs; 5533af376a46SDan Williams * a port enable-change occurs (often caused by EMI); 5534af376a46SDan Williams * usb_reset_and_verify_device() encounters changed descriptors (as from 5535af376a46SDan Williams * a firmware download) 5536af376a46SDan Williams * caller already locked the hub 5537af376a46SDan Williams */ 5538af376a46SDan Williams static void hub_port_connect_change(struct usb_hub *hub, int port1, 553972937e1eSSarah Sharp u16 portstatus, u16 portchange) 55405c79a1e3SDan Williams __must_hold(&port_dev->status_lock) 5541714b07beSSarah Sharp { 5542af376a46SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 5543af376a46SDan Williams struct usb_device *udev = port_dev->child; 5544de28e469SAlan Stern struct usb_device_descriptor *descr; 5545af376a46SDan Williams int status = -ENODEV; 5546714b07beSSarah Sharp 5547af376a46SDan Williams dev_dbg(&port_dev->dev, "status %04x, change %04x, %s\n", portstatus, 5548af376a46SDan Williams portchange, portspeed(hub, portstatus)); 5549af376a46SDan Williams 5550af376a46SDan Williams if (hub->has_indicators) { 5551af376a46SDan Williams set_port_led(hub, port1, HUB_LED_AUTO); 5552af376a46SDan Williams hub->indicator[port1-1] = INDICATOR_AUTO; 55534ee823b8SSarah Sharp } 5554714b07beSSarah Sharp 5555af376a46SDan Williams #ifdef CONFIG_USB_OTG 5556af376a46SDan Williams /* during HNP, don't repeat the debounce */ 5557af376a46SDan Williams if (hub->hdev->bus->is_b_host) 5558af376a46SDan Williams portchange &= ~(USB_PORT_STAT_C_CONNECTION | 5559af376a46SDan Williams USB_PORT_STAT_C_ENABLE); 5560af376a46SDan Williams #endif 5561714b07beSSarah Sharp 5562af376a46SDan Williams /* Try to resuscitate an existing device */ 5563af376a46SDan Williams if ((portstatus & USB_PORT_STAT_CONNECTION) && udev && 5564af376a46SDan Williams udev->state != USB_STATE_NOTATTACHED) { 5565af376a46SDan Williams if (portstatus & USB_PORT_STAT_ENABLE) { 5566a4f55d8bSDavid Heinzelmann /* 5567a4f55d8bSDavid Heinzelmann * USB-3 connections are initialized automatically by 5568a4f55d8bSDavid Heinzelmann * the hostcontroller hardware. Therefore check for 5569a4f55d8bSDavid Heinzelmann * changed device descriptors before resuscitating the 5570a4f55d8bSDavid Heinzelmann * device. 5571a4f55d8bSDavid Heinzelmann */ 5572de28e469SAlan Stern descr = usb_get_device_descriptor(udev); 5573de28e469SAlan Stern if (IS_ERR(descr)) { 5574a4f55d8bSDavid Heinzelmann dev_dbg(&udev->dev, 5575de28e469SAlan Stern "can't read device descriptor %ld\n", 5576de28e469SAlan Stern PTR_ERR(descr)); 5577a4f55d8bSDavid Heinzelmann } else { 5578de28e469SAlan Stern if (descriptors_changed(udev, descr, 5579a4f55d8bSDavid Heinzelmann udev->bos)) { 5580a4f55d8bSDavid Heinzelmann dev_dbg(&udev->dev, 5581a4f55d8bSDavid Heinzelmann "device descriptor has changed\n"); 5582a4f55d8bSDavid Heinzelmann } else { 5583af376a46SDan Williams status = 0; /* Nothing to do */ 5584a4f55d8bSDavid Heinzelmann } 5585de28e469SAlan Stern kfree(descr); 5586a4f55d8bSDavid Heinzelmann } 5587ceb6c9c8SRafael J. Wysocki #ifdef CONFIG_PM 5588af376a46SDan Williams } else if (udev->state == USB_STATE_SUSPENDED && 5589af376a46SDan Williams udev->persist_enabled) { 5590af376a46SDan Williams /* For a suspended device, treat this as a 5591af376a46SDan Williams * remote wakeup event. 5592af376a46SDan Williams */ 55935c79a1e3SDan Williams usb_unlock_port(port_dev); 5594af376a46SDan Williams status = usb_remote_wakeup(udev); 55955c79a1e3SDan Williams usb_lock_port(port_dev); 5596af376a46SDan Williams #endif 5597af376a46SDan Williams } else { 5598af376a46SDan Williams /* Don't resuscitate */; 5599af376a46SDan Williams } 5600af376a46SDan Williams } 5601af376a46SDan Williams clear_bit(port1, hub->change_bits); 5602af376a46SDan Williams 56035c79a1e3SDan Williams /* successfully revalidated the connection */ 5604af376a46SDan Williams if (status == 0) 5605af376a46SDan Williams return; 5606af376a46SDan Williams 56075c79a1e3SDan Williams usb_unlock_port(port_dev); 5608af376a46SDan Williams hub_port_connect(hub, port1, portstatus, portchange); 56095c79a1e3SDan Williams usb_lock_port(port_dev); 56101da177e4SLinus Torvalds } 56111da177e4SLinus Torvalds 5612201af55dSJon Flatley /* Handle notifying userspace about hub over-current events */ 5613201af55dSJon Flatley static void port_over_current_notify(struct usb_port *port_dev) 5614201af55dSJon Flatley { 56156c5ba739SBhuvanesh Surachari char *envp[3] = { NULL, NULL, NULL }; 5616201af55dSJon Flatley struct device *hub_dev; 5617201af55dSJon Flatley char *port_dev_path; 5618201af55dSJon Flatley 5619201af55dSJon Flatley sysfs_notify(&port_dev->dev.kobj, NULL, "over_current_count"); 5620201af55dSJon Flatley 5621201af55dSJon Flatley hub_dev = port_dev->dev.parent; 5622201af55dSJon Flatley 5623201af55dSJon Flatley if (!hub_dev) 5624201af55dSJon Flatley return; 5625201af55dSJon Flatley 5626201af55dSJon Flatley port_dev_path = kobject_get_path(&port_dev->dev.kobj, GFP_KERNEL); 5627201af55dSJon Flatley if (!port_dev_path) 5628201af55dSJon Flatley return; 5629201af55dSJon Flatley 5630201af55dSJon Flatley envp[0] = kasprintf(GFP_KERNEL, "OVER_CURRENT_PORT=%s", port_dev_path); 5631201af55dSJon Flatley if (!envp[0]) 56326c5ba739SBhuvanesh Surachari goto exit; 5633201af55dSJon Flatley 5634201af55dSJon Flatley envp[1] = kasprintf(GFP_KERNEL, "OVER_CURRENT_COUNT=%u", 5635201af55dSJon Flatley port_dev->over_current_count); 5636201af55dSJon Flatley if (!envp[1]) 5637201af55dSJon Flatley goto exit; 5638201af55dSJon Flatley 5639201af55dSJon Flatley kobject_uevent_env(&hub_dev->kobj, KOBJ_CHANGE, envp); 5640201af55dSJon Flatley 5641201af55dSJon Flatley exit: 56426c5ba739SBhuvanesh Surachari kfree(envp[1]); 5643201af55dSJon Flatley kfree(envp[0]); 5644bf7f547eSColin Ian King kfree(port_dev_path); 5645201af55dSJon Flatley } 5646201af55dSJon Flatley 5647af376a46SDan Williams static void port_event(struct usb_hub *hub, int port1) 56485c79a1e3SDan Williams __must_hold(&port_dev->status_lock) 5649af376a46SDan Williams { 56507671bd1eSZhuang Jin Can int connect_change; 5651af376a46SDan Williams struct usb_port *port_dev = hub->ports[port1 - 1]; 5652af376a46SDan Williams struct usb_device *udev = port_dev->child; 5653af376a46SDan Williams struct usb_device *hdev = hub->hdev; 5654af376a46SDan Williams u16 portstatus, portchange; 5655f59f93cdSMathias Nyman int i = 0; 5656af376a46SDan Williams 5657af376a46SDan Williams connect_change = test_bit(port1, hub->change_bits); 5658af376a46SDan Williams clear_bit(port1, hub->event_bits); 5659af376a46SDan Williams clear_bit(port1, hub->wakeup_bits); 5660af376a46SDan Williams 5661f061f43dSMichael Grzeschik if (usb_hub_port_status(hub, port1, &portstatus, &portchange) < 0) 5662af376a46SDan Williams return; 5663af376a46SDan Williams 5664af376a46SDan Williams if (portchange & USB_PORT_STAT_C_CONNECTION) { 5665af376a46SDan Williams usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION); 5666714b07beSSarah Sharp connect_change = 1; 5667714b07beSSarah Sharp } 5668af376a46SDan Williams 5669af376a46SDan Williams if (portchange & USB_PORT_STAT_C_ENABLE) { 5670af376a46SDan Williams if (!connect_change) 5671af376a46SDan Williams dev_dbg(&port_dev->dev, "enable change, status %08x\n", 5672af376a46SDan Williams portstatus); 5673af376a46SDan Williams usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE); 5674af376a46SDan Williams 5675af376a46SDan Williams /* 5676af376a46SDan Williams * EM interference sometimes causes badly shielded USB devices 5677af376a46SDan Williams * to be shutdown by the hub, this hack enables them again. 5678af376a46SDan Williams * Works at least with mouse driver. 5679af376a46SDan Williams */ 5680af376a46SDan Williams if (!(portstatus & USB_PORT_STAT_ENABLE) 5681af376a46SDan Williams && !connect_change && udev) { 5682af376a46SDan Williams dev_err(&port_dev->dev, "disabled by hub (EMI?), re-enabling...\n"); 5683af376a46SDan Williams connect_change = 1; 5684714b07beSSarah Sharp } 5685af376a46SDan Williams } 5686af376a46SDan Williams 5687af376a46SDan Williams if (portchange & USB_PORT_STAT_C_OVERCURRENT) { 5688af376a46SDan Williams u16 status = 0, unused; 56891cbd53c8SRichard Leitner port_dev->over_current_count++; 5690201af55dSJon Flatley port_over_current_notify(port_dev); 5691af376a46SDan Williams 56921cbd53c8SRichard Leitner dev_dbg(&port_dev->dev, "over-current change #%u\n", 56931cbd53c8SRichard Leitner port_dev->over_current_count); 5694af376a46SDan Williams usb_clear_port_feature(hdev, port1, 5695af376a46SDan Williams USB_PORT_FEAT_C_OVER_CURRENT); 5696af376a46SDan Williams msleep(100); /* Cool down */ 5697af376a46SDan Williams hub_power_on(hub, true); 5698f061f43dSMichael Grzeschik usb_hub_port_status(hub, port1, &status, &unused); 5699af376a46SDan Williams if (status & USB_PORT_STAT_OVERCURRENT) 5700af376a46SDan Williams dev_err(&port_dev->dev, "over-current condition\n"); 5701af376a46SDan Williams } 5702af376a46SDan Williams 5703af376a46SDan Williams if (portchange & USB_PORT_STAT_C_RESET) { 5704af376a46SDan Williams dev_dbg(&port_dev->dev, "reset change\n"); 5705af376a46SDan Williams usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_RESET); 5706af376a46SDan Williams } 5707af376a46SDan Williams if ((portchange & USB_PORT_STAT_C_BH_RESET) 5708af376a46SDan Williams && hub_is_superspeed(hdev)) { 5709af376a46SDan Williams dev_dbg(&port_dev->dev, "warm reset change\n"); 5710af376a46SDan Williams usb_clear_port_feature(hdev, port1, 5711af376a46SDan Williams USB_PORT_FEAT_C_BH_PORT_RESET); 5712af376a46SDan Williams } 5713af376a46SDan Williams if (portchange & USB_PORT_STAT_C_LINK_STATE) { 5714af376a46SDan Williams dev_dbg(&port_dev->dev, "link state change\n"); 5715af376a46SDan Williams usb_clear_port_feature(hdev, port1, 5716af376a46SDan Williams USB_PORT_FEAT_C_PORT_LINK_STATE); 5717af376a46SDan Williams } 5718af376a46SDan Williams if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) { 5719af376a46SDan Williams dev_warn(&port_dev->dev, "config error\n"); 5720af376a46SDan Williams usb_clear_port_feature(hdev, port1, 5721af376a46SDan Williams USB_PORT_FEAT_C_PORT_CONFIG_ERROR); 5722af376a46SDan Williams } 5723af376a46SDan Williams 5724097a155fSDan Williams /* skip port actions that require the port to be powered on */ 5725097a155fSDan Williams if (!pm_runtime_active(&port_dev->dev)) 5726097a155fSDan Williams return; 5727097a155fSDan Williams 5728430d57f5SRay Chi /* skip port actions if ignore_event and early_stop are true */ 5729430d57f5SRay Chi if (port_dev->ignore_event && port_dev->early_stop) 5730430d57f5SRay Chi return; 5731430d57f5SRay Chi 5732af376a46SDan Williams if (hub_handle_remote_wakeup(hub, port1, portstatus, portchange)) 5733af376a46SDan Williams connect_change = 1; 5734af376a46SDan Williams 5735af376a46SDan Williams /* 5736f59f93cdSMathias Nyman * Avoid trying to recover a USB3 SS.Inactive port with a warm reset if 5737f59f93cdSMathias Nyman * the device was disconnected. A 12ms disconnect detect timer in 5738f59f93cdSMathias Nyman * SS.Inactive state transitions the port to RxDetect automatically. 5739f59f93cdSMathias Nyman * SS.Inactive link error state is common during device disconnect. 5740af376a46SDan Williams */ 5741f59f93cdSMathias Nyman while (hub_port_warm_reset_required(hub, port1, portstatus)) { 5742f59f93cdSMathias Nyman if ((i++ < DETECT_DISCONNECT_TRIES) && udev) { 5743f59f93cdSMathias Nyman u16 unused; 5744f59f93cdSMathias Nyman 5745f59f93cdSMathias Nyman msleep(20); 5746f061f43dSMichael Grzeschik usb_hub_port_status(hub, port1, &portstatus, &unused); 5747f59f93cdSMathias Nyman dev_dbg(&port_dev->dev, "Wait for inactive link disconnect detect\n"); 5748f59f93cdSMathias Nyman continue; 5749f59f93cdSMathias Nyman } else if (!udev || !(portstatus & USB_PORT_STAT_CONNECTION) 5750af376a46SDan Williams || udev->state == USB_STATE_NOTATTACHED) { 5751f59f93cdSMathias Nyman dev_dbg(&port_dev->dev, "do warm reset, port only\n"); 5752af376a46SDan Williams if (hub_port_reset(hub, port1, NULL, 5753af376a46SDan Williams HUB_BH_RESET_TIME, true) < 0) 5754af376a46SDan Williams hub_port_disable(hub, port1, 1); 57557671bd1eSZhuang Jin Can } else { 5756f59f93cdSMathias Nyman dev_dbg(&port_dev->dev, "do warm reset, full device\n"); 57575c79a1e3SDan Williams usb_unlock_port(port_dev); 5758af376a46SDan Williams usb_lock_device(udev); 5759af376a46SDan Williams usb_reset_device(udev); 5760af376a46SDan Williams usb_unlock_device(udev); 57615c79a1e3SDan Williams usb_lock_port(port_dev); 5762af376a46SDan Williams connect_change = 0; 5763af376a46SDan Williams } 5764f59f93cdSMathias Nyman break; 57657671bd1eSZhuang Jin Can } 5766af376a46SDan Williams 5767af376a46SDan Williams if (connect_change) 5768af376a46SDan Williams hub_port_connect_change(hub, port1, portstatus, portchange); 5769af376a46SDan Williams } 5770af376a46SDan Williams 577132a69589SPetr Mladek static void hub_event(struct work_struct *work) 57721da177e4SLinus Torvalds { 57731da177e4SLinus Torvalds struct usb_device *hdev; 57741da177e4SLinus Torvalds struct usb_interface *intf; 57751da177e4SLinus Torvalds struct usb_hub *hub; 57761da177e4SLinus Torvalds struct device *hub_dev; 57771da177e4SLinus Torvalds u16 hubstatus; 57781da177e4SLinus Torvalds u16 hubchange; 57791da177e4SLinus Torvalds int i, ret; 57801da177e4SLinus Torvalds 578132a69589SPetr Mladek hub = container_of(work, struct usb_hub, events); 57825d14f323SPetr Mladek hdev = hub->hdev; 5783e8054854SAlan Stern hub_dev = hub->intfdev; 5784e8054854SAlan Stern intf = to_usb_interface(hub_dev); 578532a69589SPetr Mladek 578695d23dc2SAndrey Konovalov kcov_remote_start_usb((u64)hdev->bus->busnum); 578795d23dc2SAndrey Konovalov 578840f122f3SAlan Stern dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n", 57893bbc47d8SKrzysztof Mazur hdev->state, hdev->maxchild, 57901da177e4SLinus Torvalds /* NOTE: expects max 15 ports... */ 57911da177e4SLinus Torvalds (u16) hub->change_bits[0], 579240f122f3SAlan Stern (u16) hub->event_bits[0]); 57931da177e4SLinus Torvalds 57941da177e4SLinus Torvalds /* Lock the device, then check to see if we were 57951da177e4SLinus Torvalds * disconnected while waiting for the lock to succeed. */ 579606b84e8aSAlan Stern usb_lock_device(hdev); 5797e8054854SAlan Stern if (unlikely(hub->disconnected)) 579832a69589SPetr Mladek goto out_hdev_lock; 57991da177e4SLinus Torvalds 58001da177e4SLinus Torvalds /* If the hub has died, clean up after it */ 58011da177e4SLinus Torvalds if (hdev->state == USB_STATE_NOTATTACHED) { 58027de18d8bSAlan Stern hub->error = -ENODEV; 58034330354fSAlan Stern hub_quiesce(hub, HUB_DISCONNECT); 580432a69589SPetr Mladek goto out_hdev_lock; 58051da177e4SLinus Torvalds } 58061da177e4SLinus Torvalds 580740f122f3SAlan Stern /* Autoresume */ 580840f122f3SAlan Stern ret = usb_autopm_get_interface(intf); 580940f122f3SAlan Stern if (ret) { 581040f122f3SAlan Stern dev_dbg(hub_dev, "Can't autoresume: %d\n", ret); 581132a69589SPetr Mladek goto out_hdev_lock; 581240f122f3SAlan Stern } 581340f122f3SAlan Stern 581440f122f3SAlan Stern /* If this is an inactive hub, do nothing */ 581540f122f3SAlan Stern if (hub->quiescing) 5816eb6e2924SPetr Mladek goto out_autopm; 58171da177e4SLinus Torvalds 58181da177e4SLinus Torvalds if (hub->error) { 5819eb6e2924SPetr Mladek dev_dbg(hub_dev, "resetting for error %d\n", hub->error); 58201da177e4SLinus Torvalds 5821742120c6SMing Lei ret = usb_reset_device(hdev); 58221da177e4SLinus Torvalds if (ret) { 5823eb6e2924SPetr Mladek dev_dbg(hub_dev, "error resetting hub: %d\n", ret); 5824eb6e2924SPetr Mladek goto out_autopm; 58251da177e4SLinus Torvalds } 58261da177e4SLinus Torvalds 58271da177e4SLinus Torvalds hub->nerrors = 0; 58281da177e4SLinus Torvalds hub->error = 0; 58291da177e4SLinus Torvalds } 58301da177e4SLinus Torvalds 58311da177e4SLinus Torvalds /* deal with port status changes */ 58323bbc47d8SKrzysztof Mazur for (i = 1; i <= hdev->maxchild; i++) { 5833097a155fSDan Williams struct usb_port *port_dev = hub->ports[i - 1]; 5834a82b76f7SHans de Goede 58355c79a1e3SDan Williams if (test_bit(i, hub->event_bits) 5836af376a46SDan Williams || test_bit(i, hub->change_bits) 58375c79a1e3SDan Williams || test_bit(i, hub->wakeup_bits)) { 58381da177e4SLinus Torvalds /* 5839097a155fSDan Williams * The get_noresume and barrier ensure that if 5840097a155fSDan Williams * the port was in the process of resuming, we 5841097a155fSDan Williams * flush that work and keep the port active for 5842097a155fSDan Williams * the duration of the port_event(). However, 5843097a155fSDan Williams * if the port is runtime pm suspended 5844097a155fSDan Williams * (powered-off), we leave it in that state, run 5845097a155fSDan Williams * an abbreviated port_event(), and move on. 58461da177e4SLinus Torvalds */ 5847097a155fSDan Williams pm_runtime_get_noresume(&port_dev->dev); 5848097a155fSDan Williams pm_runtime_barrier(&port_dev->dev); 58495c79a1e3SDan Williams usb_lock_port(port_dev); 5850af376a46SDan Williams port_event(hub, i); 58515c79a1e3SDan Williams usb_unlock_port(port_dev); 5852097a155fSDan Williams pm_runtime_put_sync(&port_dev->dev); 58531da177e4SLinus Torvalds } 58541da177e4SLinus Torvalds } 58551da177e4SLinus Torvalds 58561da177e4SLinus Torvalds /* deal with hub status changes */ 58571da177e4SLinus Torvalds if (test_and_clear_bit(0, hub->event_bits) == 0) 58581da177e4SLinus Torvalds ; /* do nothing */ 58591da177e4SLinus Torvalds else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0) 58601da177e4SLinus Torvalds dev_err(hub_dev, "get_hub_status failed\n"); 58611da177e4SLinus Torvalds else { 58621da177e4SLinus Torvalds if (hubchange & HUB_CHANGE_LOCAL_POWER) { 58631da177e4SLinus Torvalds dev_dbg(hub_dev, "power change\n"); 58641da177e4SLinus Torvalds clear_hub_feature(hdev, C_HUB_LOCAL_POWER); 586555c52718SAlan Stern if (hubstatus & HUB_STATUS_LOCAL_POWER) 586655c52718SAlan Stern /* FIXME: Is this always true? */ 586755c52718SAlan Stern hub->limited_power = 1; 5868403fae78Sjidong xiao else 5869403fae78Sjidong xiao hub->limited_power = 0; 58701da177e4SLinus Torvalds } 58711da177e4SLinus Torvalds if (hubchange & HUB_CHANGE_OVERCURRENT) { 5872752d57a8SPaul Bolle u16 status = 0; 5873752d57a8SPaul Bolle u16 unused; 5874752d57a8SPaul Bolle 5875752d57a8SPaul Bolle dev_dbg(hub_dev, "over-current change\n"); 58761da177e4SLinus Torvalds clear_hub_feature(hdev, C_HUB_OVER_CURRENT); 5877752d57a8SPaul Bolle msleep(500); /* Cool down */ 58788520f380SAlan Stern hub_power_on(hub, true); 5879752d57a8SPaul Bolle hub_hub_status(hub, &status, &unused); 5880752d57a8SPaul Bolle if (status & HUB_STATUS_OVERCURRENT) 5881eb6e2924SPetr Mladek dev_err(hub_dev, "over-current condition\n"); 58821da177e4SLinus Torvalds } 58831da177e4SLinus Torvalds } 58841da177e4SLinus Torvalds 5885eb6e2924SPetr Mladek out_autopm: 58868e4ceb38SAlan Stern /* Balance the usb_autopm_get_interface() above */ 58878e4ceb38SAlan Stern usb_autopm_put_interface_no_suspend(intf); 588832a69589SPetr Mladek out_hdev_lock: 58891da177e4SLinus Torvalds usb_unlock_device(hdev); 589032a69589SPetr Mladek 589132a69589SPetr Mladek /* Balance the stuff in kick_hub_wq() and allow autosuspend */ 589232a69589SPetr Mladek usb_autopm_put_interface(intf); 5893e8054854SAlan Stern kref_put(&hub->kref, hub_release); 589495d23dc2SAndrey Konovalov 589595d23dc2SAndrey Konovalov kcov_remote_stop(); 58961da177e4SLinus Torvalds } 58971da177e4SLinus Torvalds 58981e927d96SNémeth Márton static const struct usb_device_id hub_id_table[] = { 589976e1ef1dSEugeniu Rosca { .match_flags = USB_DEVICE_ID_MATCH_VENDOR 590076e1ef1dSEugeniu Rosca | USB_DEVICE_ID_MATCH_PRODUCT 590176e1ef1dSEugeniu Rosca | USB_DEVICE_ID_MATCH_INT_CLASS, 59021208f9e1SHardik Gajjar .idVendor = USB_VENDOR_SMSC, 590376e1ef1dSEugeniu Rosca .idProduct = USB_PRODUCT_USB5534B, 59041208f9e1SHardik Gajjar .bInterfaceClass = USB_CLASS_HUB, 59051208f9e1SHardik Gajjar .driver_info = HUB_QUIRK_DISABLE_AUTOSUSPEND}, 5906e6f30deaSMing Lei { .match_flags = USB_DEVICE_ID_MATCH_VENDOR 5907a7d8d1c7SAndrew Lunn | USB_DEVICE_ID_MATCH_PRODUCT, 5908a7d8d1c7SAndrew Lunn .idVendor = USB_VENDOR_CYPRESS, 5909a7d8d1c7SAndrew Lunn .idProduct = USB_PRODUCT_CY7C65632, 5910a7d8d1c7SAndrew Lunn .driver_info = HUB_QUIRK_DISABLE_AUTOSUSPEND}, 5911a7d8d1c7SAndrew Lunn { .match_flags = USB_DEVICE_ID_MATCH_VENDOR 5912e6f30deaSMing Lei | USB_DEVICE_ID_MATCH_INT_CLASS, 5913e6f30deaSMing Lei .idVendor = USB_VENDOR_GENESYS_LOGIC, 5914e6f30deaSMing Lei .bInterfaceClass = USB_CLASS_HUB, 5915e6f30deaSMing Lei .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND}, 59167171b0e2SFlavio Suligoi { .match_flags = USB_DEVICE_ID_MATCH_VENDOR 59177171b0e2SFlavio Suligoi | USB_DEVICE_ID_MATCH_PRODUCT, 59187171b0e2SFlavio Suligoi .idVendor = USB_VENDOR_TEXAS_INSTRUMENTS, 59197171b0e2SFlavio Suligoi .idProduct = USB_PRODUCT_TUSB8041_USB2, 59207171b0e2SFlavio Suligoi .driver_info = HUB_QUIRK_DISABLE_AUTOSUSPEND}, 59217171b0e2SFlavio Suligoi { .match_flags = USB_DEVICE_ID_MATCH_VENDOR 59227171b0e2SFlavio Suligoi | USB_DEVICE_ID_MATCH_PRODUCT, 59237171b0e2SFlavio Suligoi .idVendor = USB_VENDOR_TEXAS_INSTRUMENTS, 59247171b0e2SFlavio Suligoi .idProduct = USB_PRODUCT_TUSB8041_USB3, 59257171b0e2SFlavio Suligoi .driver_info = HUB_QUIRK_DISABLE_AUTOSUSPEND}, 5926915d900fSHardik Gajjar { .match_flags = USB_DEVICE_ID_MATCH_VENDOR 5927915d900fSHardik Gajjar | USB_DEVICE_ID_MATCH_PRODUCT, 5928915d900fSHardik Gajjar .idVendor = USB_VENDOR_MICROCHIP, 5929915d900fSHardik Gajjar .idProduct = USB_PRODUCT_USB4913, 5930915d900fSHardik Gajjar .driver_info = HUB_QUIRK_REDUCE_FRAME_INTR_BINTERVAL}, 5931915d900fSHardik Gajjar { .match_flags = USB_DEVICE_ID_MATCH_VENDOR 5932915d900fSHardik Gajjar | USB_DEVICE_ID_MATCH_PRODUCT, 5933915d900fSHardik Gajjar .idVendor = USB_VENDOR_MICROCHIP, 5934915d900fSHardik Gajjar .idProduct = USB_PRODUCT_USB4914, 5935915d900fSHardik Gajjar .driver_info = HUB_QUIRK_REDUCE_FRAME_INTR_BINTERVAL}, 5936915d900fSHardik Gajjar { .match_flags = USB_DEVICE_ID_MATCH_VENDOR 5937915d900fSHardik Gajjar | USB_DEVICE_ID_MATCH_PRODUCT, 5938915d900fSHardik Gajjar .idVendor = USB_VENDOR_MICROCHIP, 5939915d900fSHardik Gajjar .idProduct = USB_PRODUCT_USB4915, 5940915d900fSHardik Gajjar .driver_info = HUB_QUIRK_REDUCE_FRAME_INTR_BINTERVAL}, 59411da177e4SLinus Torvalds { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS, 59421da177e4SLinus Torvalds .bDeviceClass = USB_CLASS_HUB}, 59431da177e4SLinus Torvalds { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS, 59441da177e4SLinus Torvalds .bInterfaceClass = USB_CLASS_HUB}, 59451da177e4SLinus Torvalds { } /* Terminating entry */ 59461da177e4SLinus Torvalds }; 59471da177e4SLinus Torvalds 59481da177e4SLinus Torvalds MODULE_DEVICE_TABLE(usb, hub_id_table); 59491da177e4SLinus Torvalds 59501da177e4SLinus Torvalds static struct usb_driver hub_driver = { 59511da177e4SLinus Torvalds .name = "hub", 59521da177e4SLinus Torvalds .probe = hub_probe, 59531da177e4SLinus Torvalds .disconnect = hub_disconnect, 59541da177e4SLinus Torvalds .suspend = hub_suspend, 59551da177e4SLinus Torvalds .resume = hub_resume, 5956f07600cfSAlan Stern .reset_resume = hub_reset_resume, 59577de18d8bSAlan Stern .pre_reset = hub_pre_reset, 59587de18d8bSAlan Stern .post_reset = hub_post_reset, 5959c532b29aSAndi Kleen .unlocked_ioctl = hub_ioctl, 59601da177e4SLinus Torvalds .id_table = hub_id_table, 596140f122f3SAlan Stern .supports_autosuspend = 1, 59621da177e4SLinus Torvalds }; 59631da177e4SLinus Torvalds 59641da177e4SLinus Torvalds int usb_hub_init(void) 59651da177e4SLinus Torvalds { 59661da177e4SLinus Torvalds if (usb_register(&hub_driver) < 0) { 59671da177e4SLinus Torvalds printk(KERN_ERR "%s: can't register hub driver\n", 59681da177e4SLinus Torvalds usbcore_name); 59691da177e4SLinus Torvalds return -1; 59701da177e4SLinus Torvalds } 59711da177e4SLinus Torvalds 597232a69589SPetr Mladek /* 597332a69589SPetr Mladek * The workqueue needs to be freezable to avoid interfering with 597432a69589SPetr Mladek * USB-PERSIST port handover. Otherwise it might see that a full-speed 597532a69589SPetr Mladek * device was gone before the EHCI controller had handed its port 597632a69589SPetr Mladek * over to the companion full-speed controller. 597732a69589SPetr Mladek */ 5978638139ebSPetr Mladek hub_wq = alloc_workqueue("usb_hub_wq", WQ_FREEZABLE, 0); 597932a69589SPetr Mladek if (hub_wq) 59801da177e4SLinus Torvalds return 0; 59811da177e4SLinus Torvalds 59821da177e4SLinus Torvalds /* Fall through if kernel_thread failed */ 59831da177e4SLinus Torvalds usb_deregister(&hub_driver); 598432a69589SPetr Mladek pr_err("%s: can't allocate workqueue for usb hub\n", usbcore_name); 59851da177e4SLinus Torvalds 59861da177e4SLinus Torvalds return -1; 59871da177e4SLinus Torvalds } 59881da177e4SLinus Torvalds 59891da177e4SLinus Torvalds void usb_hub_cleanup(void) 59901da177e4SLinus Torvalds { 599132a69589SPetr Mladek destroy_workqueue(hub_wq); 59921da177e4SLinus Torvalds 59931da177e4SLinus Torvalds /* 59941da177e4SLinus Torvalds * Hub resources are freed for us by usb_deregister. It calls 59951da177e4SLinus Torvalds * usb_driver_purge on every device which in turn calls that 59961da177e4SLinus Torvalds * devices disconnect function if it is using this driver. 59971da177e4SLinus Torvalds * The hub_disconnect function takes care of releasing the 59981da177e4SLinus Torvalds * individual hub resources. -greg 59991da177e4SLinus Torvalds */ 60001da177e4SLinus Torvalds usb_deregister(&hub_driver); 60011da177e4SLinus Torvalds } /* usb_hub_cleanup() */ 60021da177e4SLinus Torvalds 60031da177e4SLinus Torvalds /** 6004742120c6SMing Lei * usb_reset_and_verify_device - perform a USB port reset to reinitialize a device 60051da177e4SLinus Torvalds * @udev: device to reset (not in SUSPENDED or NOTATTACHED state) 60061da177e4SLinus Torvalds * 600779efa097SAlan Stern * WARNING - don't use this routine to reset a composite device 600879efa097SAlan Stern * (one with multiple interfaces owned by separate drivers)! 6009742120c6SMing Lei * Use usb_reset_device() instead. 60101da177e4SLinus Torvalds * 60111da177e4SLinus Torvalds * Do a port reset, reassign the device's address, and establish its 60121da177e4SLinus Torvalds * former operating configuration. If the reset fails, or the device's 60131da177e4SLinus Torvalds * descriptors change from their values before the reset, or the original 60141da177e4SLinus Torvalds * configuration and altsettings cannot be restored, a flag will be set 601537ebb549SPetr Mladek * telling hub_wq to pretend the device has been disconnected and then 60161da177e4SLinus Torvalds * re-connected. All drivers will be unbound, and the device will be 60171da177e4SLinus Torvalds * re-enumerated and probed all over again. 60181da177e4SLinus Torvalds * 6019626f090cSYacine Belkadi * Return: 0 if the reset succeeded, -ENODEV if the device has been 60201da177e4SLinus Torvalds * flagged for logical disconnection, or some other negative error code 60211da177e4SLinus Torvalds * if the reset wasn't even attempted. 60221da177e4SLinus Torvalds * 6023626f090cSYacine Belkadi * Note: 60245c79a1e3SDan Williams * The caller must own the device lock and the port lock, the latter is 60255c79a1e3SDan Williams * taken by usb_reset_device(). For example, it's safe to use 60265c79a1e3SDan Williams * usb_reset_device() from a driver probe() routine after downloading 60275c79a1e3SDan Williams * new firmware. For calls that might not occur during probe(), drivers 60285c79a1e3SDan Williams * should lock the device using usb_lock_device_for_reset(). 60296bc6cff5SAlan Stern * 60306bc6cff5SAlan Stern * Locking exception: This routine may also be called from within an 60316bc6cff5SAlan Stern * autoresume handler. Such usage won't conflict with other tasks 60326bc6cff5SAlan Stern * holding the device lock because these tasks should always call 60335c79a1e3SDan Williams * usb_autopm_resume_device(), thereby preventing any unwanted 60345c79a1e3SDan Williams * autoresume. The autoresume handler is expected to have already 60355c79a1e3SDan Williams * acquired the port lock before calling this routine. 60361da177e4SLinus Torvalds */ 6037742120c6SMing Lei static int usb_reset_and_verify_device(struct usb_device *udev) 60381da177e4SLinus Torvalds { 60391da177e4SLinus Torvalds struct usb_device *parent_hdev = udev->parent; 60401da177e4SLinus Torvalds struct usb_hub *parent_hub; 60413f0479e0SSarah Sharp struct usb_hcd *hcd = bus_to_hcd(udev->bus); 6042ff33299eSAlan Stern struct usb_device_descriptor descriptor; 6043e3376d6cSXenia Ragiadakou struct usb_host_bos *bos; 60447a7b562dSHans de Goede int i, j, ret = 0; 604512c3da34SAlan Stern int port1 = udev->portnum; 60461da177e4SLinus Torvalds 60471da177e4SLinus Torvalds if (udev->state == USB_STATE_NOTATTACHED || 60481da177e4SLinus Torvalds udev->state == USB_STATE_SUSPENDED) { 60491da177e4SLinus Torvalds dev_dbg(&udev->dev, "device reset not allowed in state %d\n", 60501da177e4SLinus Torvalds udev->state); 60511da177e4SLinus Torvalds return -EINVAL; 60521da177e4SLinus Torvalds } 60531da177e4SLinus Torvalds 60545c79a1e3SDan Williams if (!parent_hdev) 60551da177e4SLinus Torvalds return -EISDIR; 60565c79a1e3SDan Williams 6057ad493e5eSLan Tianyu parent_hub = usb_hub_to_struct_hub(parent_hdev); 60581da177e4SLinus Torvalds 6059dcc01c08SSarah Sharp /* Disable USB2 hardware LPM. 6060dcc01c08SSarah Sharp * It will be re-enabled by the enumeration process. 6061dcc01c08SSarah Sharp */ 60627529b257SKai-Heng Feng usb_disable_usb2_hardware_lpm(udev); 6063dcc01c08SSarah Sharp 6064464ad8c4SHans Yang bos = udev->bos; 6065e5bdfd50SGreg Kroah-Hartman udev->bos = NULL; 6066464ad8c4SHans Yang 60676ae6dc22SMathias Nyman mutex_lock(hcd->address0_mutex); 60686ae6dc22SMathias Nyman 606919502e69SAlan Stern for (i = 0; i < PORT_INIT_TRIES; ++i) { 6070430d57f5SRay Chi if (hub_port_stop_enumerate(parent_hub, port1, i)) { 6071430d57f5SRay Chi ret = -ENODEV; 6072430d57f5SRay Chi break; 6073430d57f5SRay Chi } 60741da177e4SLinus Torvalds 60751da177e4SLinus Torvalds /* ep0 maxpacket size may change; let the HCD know about it. 60761da177e4SLinus Torvalds * Other endpoints will be handled by re-enumeration. */ 6077fc721f51SInaky Perez-Gonzalez usb_ep0_reinit(udev); 6078ff33299eSAlan Stern ret = hub_port_init(parent_hub, udev, port1, i, &descriptor); 6079dd4dd19eSAlan Stern if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV) 60801da177e4SLinus Torvalds break; 60811da177e4SLinus Torvalds } 60826ae6dc22SMathias Nyman mutex_unlock(hcd->address0_mutex); 6083d5cbad4bSAlan Stern 60841da177e4SLinus Torvalds if (ret < 0) 60851da177e4SLinus Torvalds goto re_enumerate; 60861da177e4SLinus Torvalds 60871da177e4SLinus Torvalds /* Device might have changed firmware (DFU or similar) */ 6088e3376d6cSXenia Ragiadakou if (descriptors_changed(udev, &descriptor, bos)) { 60891da177e4SLinus Torvalds dev_info(&udev->dev, "device firmware changed\n"); 60901da177e4SLinus Torvalds goto re_enumerate; 60911da177e4SLinus Torvalds } 60921da177e4SLinus Torvalds 60934fe0387aSAlan Stern /* Restore the device's previous configuration */ 60941da177e4SLinus Torvalds if (!udev->actconfig) 60951da177e4SLinus Torvalds goto done; 60963f0479e0SSarah Sharp 6097d673bfcbSSarah Sharp mutex_lock(hcd->bandwidth_mutex); 60983f0479e0SSarah Sharp ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL); 60993f0479e0SSarah Sharp if (ret < 0) { 61003f0479e0SSarah Sharp dev_warn(&udev->dev, 61013f0479e0SSarah Sharp "Busted HC? Not enough HCD resources for " 61023f0479e0SSarah Sharp "old configuration.\n"); 6103d673bfcbSSarah Sharp mutex_unlock(hcd->bandwidth_mutex); 61043f0479e0SSarah Sharp goto re_enumerate; 61053f0479e0SSarah Sharp } 61061da177e4SLinus Torvalds ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 61071da177e4SLinus Torvalds USB_REQ_SET_CONFIGURATION, 0, 61081da177e4SLinus Torvalds udev->actconfig->desc.bConfigurationValue, 0, 61091da177e4SLinus Torvalds NULL, 0, USB_CTRL_SET_TIMEOUT); 61101da177e4SLinus Torvalds if (ret < 0) { 61111da177e4SLinus Torvalds dev_err(&udev->dev, 61121da177e4SLinus Torvalds "can't restore configuration #%d (error=%d)\n", 61131da177e4SLinus Torvalds udev->actconfig->desc.bConfigurationValue, ret); 6114d673bfcbSSarah Sharp mutex_unlock(hcd->bandwidth_mutex); 61151da177e4SLinus Torvalds goto re_enumerate; 61161da177e4SLinus Torvalds } 6117d673bfcbSSarah Sharp mutex_unlock(hcd->bandwidth_mutex); 61181da177e4SLinus Torvalds usb_set_device_state(udev, USB_STATE_CONFIGURED); 61191da177e4SLinus Torvalds 61204fe0387aSAlan Stern /* Put interfaces back into the same altsettings as before. 61214fe0387aSAlan Stern * Don't bother to send the Set-Interface request for interfaces 61224fe0387aSAlan Stern * that were already in altsetting 0; besides being unnecessary, 61234fe0387aSAlan Stern * many devices can't handle it. Instead just reset the host-side 61244fe0387aSAlan Stern * endpoint state. 61254fe0387aSAlan Stern */ 61261da177e4SLinus Torvalds for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 61273f0479e0SSarah Sharp struct usb_host_config *config = udev->actconfig; 61283f0479e0SSarah Sharp struct usb_interface *intf = config->interface[i]; 61291da177e4SLinus Torvalds struct usb_interface_descriptor *desc; 61301da177e4SLinus Torvalds 61311da177e4SLinus Torvalds desc = &intf->cur_altsetting->desc; 61324fe0387aSAlan Stern if (desc->bAlternateSetting == 0) { 61334fe0387aSAlan Stern usb_disable_interface(udev, intf, true); 61344fe0387aSAlan Stern usb_enable_interface(udev, intf, true); 61354fe0387aSAlan Stern ret = 0; 61364fe0387aSAlan Stern } else { 613704a723eaSSarah Sharp /* Let the bandwidth allocation function know that this 613804a723eaSSarah Sharp * device has been reset, and it will have to use 613904a723eaSSarah Sharp * alternate setting 0 as the current alternate setting. 61403f0479e0SSarah Sharp */ 614104a723eaSSarah Sharp intf->resetting_device = 1; 61421da177e4SLinus Torvalds ret = usb_set_interface(udev, desc->bInterfaceNumber, 61431da177e4SLinus Torvalds desc->bAlternateSetting); 614404a723eaSSarah Sharp intf->resetting_device = 0; 61454fe0387aSAlan Stern } 61461da177e4SLinus Torvalds if (ret < 0) { 61471da177e4SLinus Torvalds dev_err(&udev->dev, "failed to restore interface %d " 61481da177e4SLinus Torvalds "altsetting %d (error=%d)\n", 61491da177e4SLinus Torvalds desc->bInterfaceNumber, 61501da177e4SLinus Torvalds desc->bAlternateSetting, 61511da177e4SLinus Torvalds ret); 61521da177e4SLinus Torvalds goto re_enumerate; 61531da177e4SLinus Torvalds } 61547a7b562dSHans de Goede /* Resetting also frees any allocated streams */ 61557a7b562dSHans de Goede for (j = 0; j < intf->cur_altsetting->desc.bNumEndpoints; j++) 61567a7b562dSHans de Goede intf->cur_altsetting->endpoint[j].streams = 0; 61571da177e4SLinus Torvalds } 61581da177e4SLinus Torvalds 61591da177e4SLinus Torvalds done: 6160f74631e3SSarah Sharp /* Now that the alt settings are re-installed, enable LTM and LPM. */ 61617529b257SKai-Heng Feng usb_enable_usb2_hardware_lpm(udev); 616278d9a487SAlan Stern usb_unlocked_enable_lpm(udev); 6163f74631e3SSarah Sharp usb_enable_ltm(udev); 6164e3376d6cSXenia Ragiadakou usb_release_bos_descriptor(udev); 6165e3376d6cSXenia Ragiadakou udev->bos = bos; 61661da177e4SLinus Torvalds return 0; 61671da177e4SLinus Torvalds 61681da177e4SLinus Torvalds re_enumerate: 6169e3376d6cSXenia Ragiadakou usb_release_bos_descriptor(udev); 6170e3376d6cSXenia Ragiadakou udev->bos = bos; 6171464ad8c4SHans Yang hub_port_logical_disconnect(parent_hub, port1); 61721da177e4SLinus Torvalds return -ENODEV; 61731da177e4SLinus Torvalds } 61741da177e4SLinus Torvalds 61751da177e4SLinus Torvalds /** 61761da177e4SLinus Torvalds * usb_reset_device - warn interface drivers and perform a USB port reset 6177e76b3bf7SKai-Heng Feng * @udev: device to reset (not in NOTATTACHED state) 61781da177e4SLinus Torvalds * 617979efa097SAlan Stern * Warns all drivers bound to registered interfaces (using their pre_reset 618079efa097SAlan Stern * method), performs the port reset, and then lets the drivers know that 6181742120c6SMing Lei * the reset is over (using their post_reset method). 618279efa097SAlan Stern * 6183626f090cSYacine Belkadi * Return: The same as for usb_reset_and_verify_device(). 61849c6d7788SAlan Stern * However, if a reset is already in progress (for instance, if a 6185766a96dcSAlan Stern * driver doesn't have pre_reset() or post_reset() callbacks, and while 61869c6d7788SAlan Stern * being unbound or re-bound during the ongoing reset its disconnect() 61879c6d7788SAlan Stern * or probe() routine tries to perform a second, nested reset), the 61889c6d7788SAlan Stern * routine returns -EINPROGRESS. 618979efa097SAlan Stern * 6190626f090cSYacine Belkadi * Note: 619179efa097SAlan Stern * The caller must own the device lock. For example, it's safe to use 619279efa097SAlan Stern * this from a driver probe() routine after downloading new firmware. 619379efa097SAlan Stern * For calls that might not occur during probe(), drivers should lock 6194742120c6SMing Lei * the device using usb_lock_device_for_reset(). 619579efa097SAlan Stern * 619679efa097SAlan Stern * If an interface is currently being probed or disconnected, we assume 619779efa097SAlan Stern * its driver knows how to handle resets. For all other interfaces, 619879efa097SAlan Stern * if the driver doesn't have pre_reset and post_reset methods then 619979efa097SAlan Stern * we attempt to unbind it and rebind afterward. 620079efa097SAlan Stern */ 6201742120c6SMing Lei int usb_reset_device(struct usb_device *udev) 620279efa097SAlan Stern { 620379efa097SAlan Stern int ret; 6204852c4b43SAlan Stern int i; 62054d769defSMing Lei unsigned int noio_flag; 62065c79a1e3SDan Williams struct usb_port *port_dev; 620779efa097SAlan Stern struct usb_host_config *config = udev->actconfig; 62085c79a1e3SDan Williams struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); 620979efa097SAlan Stern 6210e76b3bf7SKai-Heng Feng if (udev->state == USB_STATE_NOTATTACHED) { 621179efa097SAlan Stern dev_dbg(&udev->dev, "device reset not allowed in state %d\n", 621279efa097SAlan Stern udev->state); 621379efa097SAlan Stern return -EINVAL; 621479efa097SAlan Stern } 621579efa097SAlan Stern 62165c79a1e3SDan Williams if (!udev->parent) { 62175c79a1e3SDan Williams /* this requires hcd-specific logic; see ohci_restart() */ 62185c79a1e3SDan Williams dev_dbg(&udev->dev, "%s for root hub!\n", __func__); 62195c79a1e3SDan Williams return -EISDIR; 62205c79a1e3SDan Williams } 62215c79a1e3SDan Williams 62229c6d7788SAlan Stern if (udev->reset_in_progress) 62239c6d7788SAlan Stern return -EINPROGRESS; 62249c6d7788SAlan Stern udev->reset_in_progress = 1; 62259c6d7788SAlan Stern 62265c79a1e3SDan Williams port_dev = hub->ports[udev->portnum - 1]; 62275c79a1e3SDan Williams 62284d769defSMing Lei /* 62294d769defSMing Lei * Don't allocate memory with GFP_KERNEL in current 62304d769defSMing Lei * context to avoid possible deadlock if usb mass 62314d769defSMing Lei * storage interface or usbnet interface(iSCSI case) 62324d769defSMing Lei * is included in current configuration. The easist 62334d769defSMing Lei * approach is to do it for every device reset, 62344d769defSMing Lei * because the device 'memalloc_noio' flag may have 62354d769defSMing Lei * not been set before reseting the usb device. 62364d769defSMing Lei */ 62374d769defSMing Lei noio_flag = memalloc_noio_save(); 62384d769defSMing Lei 6239645daaabSAlan Stern /* Prevent autosuspend during the reset */ 624094fcda1fSAlan Stern usb_autoresume_device(udev); 6241645daaabSAlan Stern 624279efa097SAlan Stern if (config) { 6243852c4b43SAlan Stern for (i = 0; i < config->desc.bNumInterfaces; ++i) { 6244852c4b43SAlan Stern struct usb_interface *cintf = config->interface[i]; 624579efa097SAlan Stern struct usb_driver *drv; 624678d9a487SAlan Stern int unbind = 0; 624779efa097SAlan Stern 6248852c4b43SAlan Stern if (cintf->dev.driver) { 624979efa097SAlan Stern drv = to_usb_driver(cintf->dev.driver); 625078d9a487SAlan Stern if (drv->pre_reset && drv->post_reset) 625178d9a487SAlan Stern unbind = (drv->pre_reset)(cintf); 625278d9a487SAlan Stern else if (cintf->condition == 625378d9a487SAlan Stern USB_INTERFACE_BOUND) 625478d9a487SAlan Stern unbind = 1; 625578d9a487SAlan Stern if (unbind) 625678d9a487SAlan Stern usb_forced_unbind_intf(cintf); 625779efa097SAlan Stern } 625879efa097SAlan Stern } 625979efa097SAlan Stern } 626079efa097SAlan Stern 62615c79a1e3SDan Williams usb_lock_port(port_dev); 6262742120c6SMing Lei ret = usb_reset_and_verify_device(udev); 62635c79a1e3SDan Williams usb_unlock_port(port_dev); 626479efa097SAlan Stern 626579efa097SAlan Stern if (config) { 6266852c4b43SAlan Stern for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) { 6267852c4b43SAlan Stern struct usb_interface *cintf = config->interface[i]; 626879efa097SAlan Stern struct usb_driver *drv; 626978d9a487SAlan Stern int rebind = cintf->needs_binding; 627079efa097SAlan Stern 627178d9a487SAlan Stern if (!rebind && cintf->dev.driver) { 627279efa097SAlan Stern drv = to_usb_driver(cintf->dev.driver); 627379efa097SAlan Stern if (drv->post_reset) 627478d9a487SAlan Stern rebind = (drv->post_reset)(cintf); 627578d9a487SAlan Stern else if (cintf->condition == 627678d9a487SAlan Stern USB_INTERFACE_BOUND) 627778d9a487SAlan Stern rebind = 1; 62786aec044cSAlan Stern if (rebind) 62796aec044cSAlan Stern cintf->needs_binding = 1; 628079efa097SAlan Stern } 628179efa097SAlan Stern } 6282381419faSAlan Stern 6283381419faSAlan Stern /* If the reset failed, hub_wq will unbind drivers later */ 6284381419faSAlan Stern if (ret == 0) 62856aec044cSAlan Stern usb_unbind_and_rebind_marked_interfaces(udev); 628679efa097SAlan Stern } 628779efa097SAlan Stern 628894fcda1fSAlan Stern usb_autosuspend_device(udev); 62894d769defSMing Lei memalloc_noio_restore(noio_flag); 62909c6d7788SAlan Stern udev->reset_in_progress = 0; 629179efa097SAlan Stern return ret; 629279efa097SAlan Stern } 6293742120c6SMing Lei EXPORT_SYMBOL_GPL(usb_reset_device); 6294dc023dceSInaky Perez-Gonzalez 6295dc023dceSInaky Perez-Gonzalez 6296dc023dceSInaky Perez-Gonzalez /** 6297dc023dceSInaky Perez-Gonzalez * usb_queue_reset_device - Reset a USB device from an atomic context 6298dc023dceSInaky Perez-Gonzalez * @iface: USB interface belonging to the device to reset 6299dc023dceSInaky Perez-Gonzalez * 6300dc023dceSInaky Perez-Gonzalez * This function can be used to reset a USB device from an atomic 6301dc023dceSInaky Perez-Gonzalez * context, where usb_reset_device() won't work (as it blocks). 6302dc023dceSInaky Perez-Gonzalez * 6303dc023dceSInaky Perez-Gonzalez * Doing a reset via this method is functionally equivalent to calling 6304dc023dceSInaky Perez-Gonzalez * usb_reset_device(), except for the fact that it is delayed to a 6305dc023dceSInaky Perez-Gonzalez * workqueue. This means that any drivers bound to other interfaces 6306dc023dceSInaky Perez-Gonzalez * might be unbound, as well as users from usbfs in user space. 6307dc023dceSInaky Perez-Gonzalez * 6308dc023dceSInaky Perez-Gonzalez * Corner cases: 6309dc023dceSInaky Perez-Gonzalez * 6310dc023dceSInaky Perez-Gonzalez * - Scheduling two resets at the same time from two different drivers 6311dc023dceSInaky Perez-Gonzalez * attached to two different interfaces of the same device is 6312dc023dceSInaky Perez-Gonzalez * possible; depending on how the driver attached to each interface 6313dc023dceSInaky Perez-Gonzalez * handles ->pre_reset(), the second reset might happen or not. 6314dc023dceSInaky Perez-Gonzalez * 6315524134d4SAlan Stern * - If the reset is delayed so long that the interface is unbound from 6316524134d4SAlan Stern * its driver, the reset will be skipped. 6317dc023dceSInaky Perez-Gonzalez * 6318524134d4SAlan Stern * - This function can be called during .probe(). It can also be called 6319524134d4SAlan Stern * during .disconnect(), but doing so is pointless because the reset 6320524134d4SAlan Stern * will not occur. If you really want to reset the device during 6321524134d4SAlan Stern * .disconnect(), call usb_reset_device() directly -- but watch out 6322524134d4SAlan Stern * for nested unbinding issues! 6323dc023dceSInaky Perez-Gonzalez */ 6324dc023dceSInaky Perez-Gonzalez void usb_queue_reset_device(struct usb_interface *iface) 6325dc023dceSInaky Perez-Gonzalez { 6326524134d4SAlan Stern if (schedule_work(&iface->reset_ws)) 6327524134d4SAlan Stern usb_get_intf(iface); 6328dc023dceSInaky Perez-Gonzalez } 6329dc023dceSInaky Perez-Gonzalez EXPORT_SYMBOL_GPL(usb_queue_reset_device); 6330ff823c79SLan Tianyu 6331ff823c79SLan Tianyu /** 6332ff823c79SLan Tianyu * usb_hub_find_child - Get the pointer of child device 6333ff823c79SLan Tianyu * attached to the port which is specified by @port1. 6334ff823c79SLan Tianyu * @hdev: USB device belonging to the usb hub 6335ff823c79SLan Tianyu * @port1: port num to indicate which port the child device 6336ff823c79SLan Tianyu * is attached to. 6337ff823c79SLan Tianyu * 6338ff823c79SLan Tianyu * USB drivers call this function to get hub's child device 6339ff823c79SLan Tianyu * pointer. 6340ff823c79SLan Tianyu * 6341626f090cSYacine Belkadi * Return: %NULL if input param is invalid and 6342ff823c79SLan Tianyu * child's usb_device pointer if non-NULL. 6343ff823c79SLan Tianyu */ 6344ff823c79SLan Tianyu struct usb_device *usb_hub_find_child(struct usb_device *hdev, 6345ff823c79SLan Tianyu int port1) 6346ff823c79SLan Tianyu { 6347ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 6348ff823c79SLan Tianyu 6349ff823c79SLan Tianyu if (port1 < 1 || port1 > hdev->maxchild) 6350ff823c79SLan Tianyu return NULL; 6351ff823c79SLan Tianyu return hub->ports[port1 - 1]->child; 6352ff823c79SLan Tianyu } 6353ff823c79SLan Tianyu EXPORT_SYMBOL_GPL(usb_hub_find_child); 6354d5575424SLan Tianyu 6355d2123fd9SLan Tianyu void usb_hub_adjust_deviceremovable(struct usb_device *hdev, 6356d2123fd9SLan Tianyu struct usb_hub_descriptor *desc) 6357d2123fd9SLan Tianyu { 6358d99f6b41SDan Williams struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 6359d2123fd9SLan Tianyu enum usb_port_connect_type connect_type; 6360d2123fd9SLan Tianyu int i; 6361d2123fd9SLan Tianyu 6362d99f6b41SDan Williams if (!hub) 6363d99f6b41SDan Williams return; 6364d99f6b41SDan Williams 6365d2123fd9SLan Tianyu if (!hub_is_superspeed(hdev)) { 6366d2123fd9SLan Tianyu for (i = 1; i <= hdev->maxchild; i++) { 6367d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[i - 1]; 6368d2123fd9SLan Tianyu 6369d99f6b41SDan Williams connect_type = port_dev->connect_type; 6370d2123fd9SLan Tianyu if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) { 6371d2123fd9SLan Tianyu u8 mask = 1 << (i%8); 6372d2123fd9SLan Tianyu 6373d2123fd9SLan Tianyu if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) { 6374d99f6b41SDan Williams dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n"); 6375d2123fd9SLan Tianyu desc->u.hs.DeviceRemovable[i/8] |= mask; 6376d2123fd9SLan Tianyu } 6377d2123fd9SLan Tianyu } 6378d2123fd9SLan Tianyu } 6379d2123fd9SLan Tianyu } else { 6380d2123fd9SLan Tianyu u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable); 6381d2123fd9SLan Tianyu 6382d2123fd9SLan Tianyu for (i = 1; i <= hdev->maxchild; i++) { 6383d99f6b41SDan Williams struct usb_port *port_dev = hub->ports[i - 1]; 6384d2123fd9SLan Tianyu 6385d99f6b41SDan Williams connect_type = port_dev->connect_type; 6386d2123fd9SLan Tianyu if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) { 6387d2123fd9SLan Tianyu u16 mask = 1 << i; 6388d2123fd9SLan Tianyu 6389d2123fd9SLan Tianyu if (!(port_removable & mask)) { 6390d99f6b41SDan Williams dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n"); 6391d2123fd9SLan Tianyu port_removable |= mask; 6392d2123fd9SLan Tianyu } 6393d2123fd9SLan Tianyu } 6394d2123fd9SLan Tianyu } 6395d2123fd9SLan Tianyu 6396d2123fd9SLan Tianyu desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable); 6397d2123fd9SLan Tianyu } 6398d2123fd9SLan Tianyu } 6399d2123fd9SLan Tianyu 6400d5575424SLan Tianyu #ifdef CONFIG_ACPI 6401d5575424SLan Tianyu /** 6402d5575424SLan Tianyu * usb_get_hub_port_acpi_handle - Get the usb port's acpi handle 6403d5575424SLan Tianyu * @hdev: USB device belonging to the usb hub 6404d5575424SLan Tianyu * @port1: port num of the port 6405d5575424SLan Tianyu * 6406626f090cSYacine Belkadi * Return: Port's acpi handle if successful, %NULL if params are 6407626f090cSYacine Belkadi * invalid. 6408d5575424SLan Tianyu */ 6409d5575424SLan Tianyu acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev, 6410d5575424SLan Tianyu int port1) 6411d5575424SLan Tianyu { 6412ad493e5eSLan Tianyu struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 6413d5575424SLan Tianyu 641441341261SMathias Nyman if (!hub) 641541341261SMathias Nyman return NULL; 641641341261SMathias Nyman 64173a83f992SRafael J. Wysocki return ACPI_HANDLE(&hub->ports[port1 - 1]->dev); 6418d5575424SLan Tianyu } 6419d5575424SLan Tianyu #endif 6420