linux/drivers/usb/core/hub.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * USB hub driver.
   4 *
   5 * (C) Copyright 1999 Linus Torvalds
   6 * (C) Copyright 1999 Johannes Erdfelt
   7 * (C) Copyright 1999 Gregory P. Smith
   8 * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
   9 *
  10 * Released under the GPLv2 only.
  11 */
  12
  13#include <linux/kernel.h>
  14#include <linux/errno.h>
  15#include <linux/module.h>
  16#include <linux/moduleparam.h>
  17#include <linux/completion.h>
  18#include <linux/sched/mm.h>
  19#include <linux/list.h>
  20#include <linux/slab.h>
  21#include <linux/kcov.h>
  22#include <linux/ioctl.h>
  23#include <linux/usb.h>
  24#include <linux/usbdevice_fs.h>
  25#include <linux/usb/hcd.h>
  26#include <linux/usb/otg.h>
  27#include <linux/usb/quirks.h>
  28#include <linux/workqueue.h>
  29#include <linux/mutex.h>
  30#include <linux/random.h>
  31#include <linux/pm_qos.h>
  32#include <linux/kobject.h>
  33
  34#include <linux/bitfield.h>
  35#include <linux/uaccess.h>
  36#include <asm/byteorder.h>
  37
  38#include "hub.h"
  39#include "otg_productlist.h"
  40
  41#define USB_VENDOR_GENESYS_LOGIC                0x05e3
  42#define USB_VENDOR_SMSC                         0x0424
  43#define USB_PRODUCT_USB5534B                    0x5534
  44#define USB_VENDOR_CYPRESS                      0x04b4
  45#define USB_PRODUCT_CY7C65632                   0x6570
  46#define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND        0x01
  47#define HUB_QUIRK_DISABLE_AUTOSUSPEND           0x02
  48
  49#define USB_TP_TRANSMISSION_DELAY       40      /* ns */
  50#define USB_TP_TRANSMISSION_DELAY_MAX   65535   /* ns */
  51#define USB_PING_RESPONSE_TIME          400     /* ns */
  52
  53/* Protect struct usb_device->state and ->children members
  54 * Note: Both are also protected by ->dev.sem, except that ->state can
  55 * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
  56static DEFINE_SPINLOCK(device_state_lock);
  57
  58/* workqueue to process hub events */
  59static struct workqueue_struct *hub_wq;
  60static void hub_event(struct work_struct *work);
  61
  62/* synchronize hub-port add/remove and peering operations */
  63DEFINE_MUTEX(usb_port_peer_mutex);
  64
  65/* cycle leds on hubs that aren't blinking for attention */
  66static bool blinkenlights;
  67module_param(blinkenlights, bool, S_IRUGO);
  68MODULE_PARM_DESC(blinkenlights, "true to cycle leds on hubs");
  69
  70/*
  71 * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about
  72 * 10 seconds to send reply for the initial 64-byte descriptor request.
  73 */
  74/* define initial 64-byte descriptor request timeout in milliseconds */
  75static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
  76module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
  77MODULE_PARM_DESC(initial_descriptor_timeout,
  78                "initial 64-byte descriptor request timeout in milliseconds "
  79                "(default 5000 - 5.0 seconds)");
  80
  81/*
  82 * As of 2.6.10 we introduce a new USB device initialization scheme which
  83 * closely resembles the way Windows works.  Hopefully it will be compatible
  84 * with a wider range of devices than the old scheme.  However some previously
  85 * working devices may start giving rise to "device not accepting address"
  86 * errors; if that happens the user can try the old scheme by adjusting the
  87 * following module parameters.
  88 *
  89 * For maximum flexibility there are two boolean parameters to control the
  90 * hub driver's behavior.  On the first initialization attempt, if the
  91 * "old_scheme_first" parameter is set then the old scheme will be used,
  92 * otherwise the new scheme is used.  If that fails and "use_both_schemes"
  93 * is set, then the driver will make another attempt, using the other scheme.
  94 */
  95static bool old_scheme_first;
  96module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
  97MODULE_PARM_DESC(old_scheme_first,
  98                 "start with the old device initialization scheme");
  99
 100static bool use_both_schemes = true;
 101module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
 102MODULE_PARM_DESC(use_both_schemes,
 103                "try the other device initialization scheme if the "
 104                "first one fails");
 105
 106/* Mutual exclusion for EHCI CF initialization.  This interferes with
 107 * port reset on some companion controllers.
 108 */
 109DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
 110EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
 111
 112#define HUB_DEBOUNCE_TIMEOUT    2000
 113#define HUB_DEBOUNCE_STEP         25
 114#define HUB_DEBOUNCE_STABLE      100
 115
 116static void hub_release(struct kref *kref);
 117static int usb_reset_and_verify_device(struct usb_device *udev);
 118static int hub_port_disable(struct usb_hub *hub, int port1, int set_state);
 119static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
 120                u16 portstatus);
 121
 122static inline char *portspeed(struct usb_hub *hub, int portstatus)
 123{
 124        if (hub_is_superspeedplus(hub->hdev))
 125                return "10.0 Gb/s";
 126        if (hub_is_superspeed(hub->hdev))
 127                return "5.0 Gb/s";
 128        if (portstatus & USB_PORT_STAT_HIGH_SPEED)
 129                return "480 Mb/s";
 130        else if (portstatus & USB_PORT_STAT_LOW_SPEED)
 131                return "1.5 Mb/s";
 132        else
 133                return "12 Mb/s";
 134}
 135
 136/* Note that hdev or one of its children must be locked! */
 137struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
 138{
 139        if (!hdev || !hdev->actconfig || !hdev->maxchild)
 140                return NULL;
 141        return usb_get_intfdata(hdev->actconfig->interface[0]);
 142}
 143
 144int usb_device_supports_lpm(struct usb_device *udev)
 145{
 146        /* Some devices have trouble with LPM */
 147        if (udev->quirks & USB_QUIRK_NO_LPM)
 148                return 0;
 149
 150        /* USB 2.1 (and greater) devices indicate LPM support through
 151         * their USB 2.0 Extended Capabilities BOS descriptor.
 152         */
 153        if (udev->speed == USB_SPEED_HIGH || udev->speed == USB_SPEED_FULL) {
 154                if (udev->bos->ext_cap &&
 155                        (USB_LPM_SUPPORT &
 156                         le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
 157                        return 1;
 158                return 0;
 159        }
 160
 161        /*
 162         * According to the USB 3.0 spec, all USB 3.0 devices must support LPM.
 163         * However, there are some that don't, and they set the U1/U2 exit
 164         * latencies to zero.
 165         */
 166        if (!udev->bos->ss_cap) {
 167                dev_info(&udev->dev, "No LPM exit latency info found, disabling LPM.\n");
 168                return 0;
 169        }
 170
 171        if (udev->bos->ss_cap->bU1devExitLat == 0 &&
 172                        udev->bos->ss_cap->bU2DevExitLat == 0) {
 173                if (udev->parent)
 174                        dev_info(&udev->dev, "LPM exit latency is zeroed, disabling LPM.\n");
 175                else
 176                        dev_info(&udev->dev, "We don't know the algorithms for LPM for this host, disabling LPM.\n");
 177                return 0;
 178        }
 179
 180        if (!udev->parent || udev->parent->lpm_capable)
 181                return 1;
 182        return 0;
 183}
 184
 185/*
 186 * Set the Maximum Exit Latency (MEL) for the host to wakup up the path from
 187 * U1/U2, send a PING to the device and receive a PING_RESPONSE.
 188 * See USB 3.1 section C.1.5.2
 189 */
 190static void usb_set_lpm_mel(struct usb_device *udev,
 191                struct usb3_lpm_parameters *udev_lpm_params,
 192                unsigned int udev_exit_latency,
 193                struct usb_hub *hub,
 194                struct usb3_lpm_parameters *hub_lpm_params,
 195                unsigned int hub_exit_latency)
 196{
 197        unsigned int total_mel;
 198
 199        /*
 200         * tMEL1. time to transition path from host to device into U0.
 201         * MEL for parent already contains the delay up to parent, so only add
 202         * the exit latency for the last link (pick the slower exit latency),
 203         * and the hub header decode latency. See USB 3.1 section C 2.2.1
 204         * Store MEL in nanoseconds
 205         */
 206        total_mel = hub_lpm_params->mel +
 207                max(udev_exit_latency, hub_exit_latency) * 1000 +
 208                hub->descriptor->u.ss.bHubHdrDecLat * 100;
 209
 210        /*
 211         * tMEL2. Time to submit PING packet. Sum of tTPTransmissionDelay for
 212         * each link + wHubDelay for each hub. Add only for last link.
 213         * tMEL4, the time for PING_RESPONSE to traverse upstream is similar.
 214         * Multiply by 2 to include it as well.
 215         */
 216        total_mel += (__le16_to_cpu(hub->descriptor->u.ss.wHubDelay) +
 217                      USB_TP_TRANSMISSION_DELAY) * 2;
 218
 219        /*
 220         * tMEL3, tPingResponse. Time taken by device to generate PING_RESPONSE
 221         * after receiving PING. Also add 2100ns as stated in USB 3.1 C 1.5.2.4
 222         * to cover the delay if the PING_RESPONSE is queued behind a Max Packet
 223         * Size DP.
 224         * Note these delays should be added only once for the entire path, so
 225         * add them to the MEL of the device connected to the roothub.
 226         */
 227        if (!hub->hdev->parent)
 228                total_mel += USB_PING_RESPONSE_TIME + 2100;
 229
 230        udev_lpm_params->mel = total_mel;
 231}
 232
 233/*
 234 * Set the maximum Device to Host Exit Latency (PEL) for the device to initiate
 235 * a transition from either U1 or U2.
 236 */
 237static void usb_set_lpm_pel(struct usb_device *udev,
 238                struct usb3_lpm_parameters *udev_lpm_params,
 239                unsigned int udev_exit_latency,
 240                struct usb_hub *hub,
 241                struct usb3_lpm_parameters *hub_lpm_params,
 242                unsigned int hub_exit_latency,
 243                unsigned int port_to_port_exit_latency)
 244{
 245        unsigned int first_link_pel;
 246        unsigned int hub_pel;
 247
 248        /*
 249         * First, the device sends an LFPS to transition the link between the
 250         * device and the parent hub into U0.  The exit latency is the bigger of
 251         * the device exit latency or the hub exit latency.
 252         */
 253        if (udev_exit_latency > hub_exit_latency)
 254                first_link_pel = udev_exit_latency * 1000;
 255        else
 256                first_link_pel = hub_exit_latency * 1000;
 257
 258        /*
 259         * When the hub starts to receive the LFPS, there is a slight delay for
 260         * it to figure out that one of the ports is sending an LFPS.  Then it
 261         * will forward the LFPS to its upstream link.  The exit latency is the
 262         * delay, plus the PEL that we calculated for this hub.
 263         */
 264        hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel;
 265
 266        /*
 267         * According to figure C-7 in the USB 3.0 spec, the PEL for this device
 268         * is the greater of the two exit latencies.
 269         */
 270        if (first_link_pel > hub_pel)
 271                udev_lpm_params->pel = first_link_pel;
 272        else
 273                udev_lpm_params->pel = hub_pel;
 274}
 275
 276/*
 277 * Set the System Exit Latency (SEL) to indicate the total worst-case time from
 278 * when a device initiates a transition to U0, until when it will receive the
 279 * first packet from the host controller.
 280 *
 281 * Section C.1.5.1 describes the four components to this:
 282 *  - t1: device PEL
 283 *  - t2: time for the ERDY to make it from the device to the host.
 284 *  - t3: a host-specific delay to process the ERDY.
 285 *  - t4: time for the packet to make it from the host to the device.
 286 *
 287 * t3 is specific to both the xHCI host and the platform the host is integrated
 288 * into.  The Intel HW folks have said it's negligible, FIXME if a different
 289 * vendor says otherwise.
 290 */
 291static void usb_set_lpm_sel(struct usb_device *udev,
 292                struct usb3_lpm_parameters *udev_lpm_params)
 293{
 294        struct usb_device *parent;
 295        unsigned int num_hubs;
 296        unsigned int total_sel;
 297
 298        /* t1 = device PEL */
 299        total_sel = udev_lpm_params->pel;
 300        /* How many external hubs are in between the device & the root port. */
 301        for (parent = udev->parent, num_hubs = 0; parent->parent;
 302                        parent = parent->parent)
 303                num_hubs++;
 304        /* t2 = 2.1us + 250ns * (num_hubs - 1) */
 305        if (num_hubs > 0)
 306                total_sel += 2100 + 250 * (num_hubs - 1);
 307
 308        /* t4 = 250ns * num_hubs */
 309        total_sel += 250 * num_hubs;
 310
 311        udev_lpm_params->sel = total_sel;
 312}
 313
 314static void usb_set_lpm_parameters(struct usb_device *udev)
 315{
 316        struct usb_hub *hub;
 317        unsigned int port_to_port_delay;
 318        unsigned int udev_u1_del;
 319        unsigned int udev_u2_del;
 320        unsigned int hub_u1_del;
 321        unsigned int hub_u2_del;
 322
 323        if (!udev->lpm_capable || udev->speed < USB_SPEED_SUPER)
 324                return;
 325
 326        hub = usb_hub_to_struct_hub(udev->parent);
 327        /* It doesn't take time to transition the roothub into U0, since it
 328         * doesn't have an upstream link.
 329         */
 330        if (!hub)
 331                return;
 332
 333        udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
 334        udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
 335        hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
 336        hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
 337
 338        usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
 339                        hub, &udev->parent->u1_params, hub_u1_del);
 340
 341        usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del,
 342                        hub, &udev->parent->u2_params, hub_u2_del);
 343
 344        /*
 345         * Appendix C, section C.2.2.2, says that there is a slight delay from
 346         * when the parent hub notices the downstream port is trying to
 347         * transition to U0 to when the hub initiates a U0 transition on its
 348         * upstream port.  The section says the delays are tPort2PortU1EL and
 349         * tPort2PortU2EL, but it doesn't define what they are.
 350         *
 351         * The hub chapter, sections 10.4.2.4 and 10.4.2.5 seem to be talking
 352         * about the same delays.  Use the maximum delay calculations from those
 353         * sections.  For U1, it's tHubPort2PortExitLat, which is 1us max.  For
 354         * U2, it's tHubPort2PortExitLat + U2DevExitLat - U1DevExitLat.  I
 355         * assume the device exit latencies they are talking about are the hub
 356         * exit latencies.
 357         *
 358         * What do we do if the U2 exit latency is less than the U1 exit
 359         * latency?  It's possible, although not likely...
 360         */
 361        port_to_port_delay = 1;
 362
 363        usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del,
 364                        hub, &udev->parent->u1_params, hub_u1_del,
 365                        port_to_port_delay);
 366
 367        if (hub_u2_del > hub_u1_del)
 368                port_to_port_delay = 1 + hub_u2_del - hub_u1_del;
 369        else
 370                port_to_port_delay = 1 + hub_u1_del;
 371
 372        usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del,
 373                        hub, &udev->parent->u2_params, hub_u2_del,
 374                        port_to_port_delay);
 375
 376        /* Now that we've got PEL, calculate SEL. */
 377        usb_set_lpm_sel(udev, &udev->u1_params);
 378        usb_set_lpm_sel(udev, &udev->u2_params);
 379}
 380
 381/* USB 2.0 spec Section 11.24.4.5 */
 382static int get_hub_descriptor(struct usb_device *hdev,
 383                struct usb_hub_descriptor *desc)
 384{
 385        int i, ret, size;
 386        unsigned dtype;
 387
 388        if (hub_is_superspeed(hdev)) {
 389                dtype = USB_DT_SS_HUB;
 390                size = USB_DT_SS_HUB_SIZE;
 391        } else {
 392                dtype = USB_DT_HUB;
 393                size = sizeof(struct usb_hub_descriptor);
 394        }
 395
 396        for (i = 0; i < 3; i++) {
 397                ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 398                        USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
 399                        dtype << 8, 0, desc, size,
 400                        USB_CTRL_GET_TIMEOUT);
 401                if (hub_is_superspeed(hdev)) {
 402                        if (ret == size)
 403                                return ret;
 404                } else if (ret >= USB_DT_HUB_NONVAR_SIZE + 2) {
 405                        /* Make sure we have the DeviceRemovable field. */
 406                        size = USB_DT_HUB_NONVAR_SIZE + desc->bNbrPorts / 8 + 1;
 407                        if (ret < size)
 408                                return -EMSGSIZE;
 409                        return ret;
 410                }
 411        }
 412        return -EINVAL;
 413}
 414
 415/*
 416 * USB 2.0 spec Section 11.24.2.1
 417 */
 418static int clear_hub_feature(struct usb_device *hdev, int feature)
 419{
 420        return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 421                USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
 422}
 423
 424/*
 425 * USB 2.0 spec Section 11.24.2.2
 426 */
 427int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
 428{
 429        return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 430                USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
 431                NULL, 0, 1000);
 432}
 433
 434/*
 435 * USB 2.0 spec Section 11.24.2.13
 436 */
 437static int set_port_feature(struct usb_device *hdev, int port1, int feature)
 438{
 439        return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 440                USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
 441                NULL, 0, 1000);
 442}
 443
 444static char *to_led_name(int selector)
 445{
 446        switch (selector) {
 447        case HUB_LED_AMBER:
 448                return "amber";
 449        case HUB_LED_GREEN:
 450                return "green";
 451        case HUB_LED_OFF:
 452                return "off";
 453        case HUB_LED_AUTO:
 454                return "auto";
 455        default:
 456                return "??";
 457        }
 458}
 459
 460/*
 461 * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
 462 * for info about using port indicators
 463 */
 464static void set_port_led(struct usb_hub *hub, int port1, int selector)
 465{
 466        struct usb_port *port_dev = hub->ports[port1 - 1];
 467        int status;
 468
 469        status = set_port_feature(hub->hdev, (selector << 8) | port1,
 470                        USB_PORT_FEAT_INDICATOR);
 471        dev_dbg(&port_dev->dev, "indicator %s status %d\n",
 472                to_led_name(selector), status);
 473}
 474
 475#define LED_CYCLE_PERIOD        ((2*HZ)/3)
 476
 477static void led_work(struct work_struct *work)
 478{
 479        struct usb_hub          *hub =
 480                container_of(work, struct usb_hub, leds.work);
 481        struct usb_device       *hdev = hub->hdev;
 482        unsigned                i;
 483        unsigned                changed = 0;
 484        int                     cursor = -1;
 485
 486        if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
 487                return;
 488
 489        for (i = 0; i < hdev->maxchild; i++) {
 490                unsigned        selector, mode;
 491
 492                /* 30%-50% duty cycle */
 493
 494                switch (hub->indicator[i]) {
 495                /* cycle marker */
 496                case INDICATOR_CYCLE:
 497                        cursor = i;
 498                        selector = HUB_LED_AUTO;
 499                        mode = INDICATOR_AUTO;
 500                        break;
 501                /* blinking green = sw attention */
 502                case INDICATOR_GREEN_BLINK:
 503                        selector = HUB_LED_GREEN;
 504                        mode = INDICATOR_GREEN_BLINK_OFF;
 505                        break;
 506                case INDICATOR_GREEN_BLINK_OFF:
 507                        selector = HUB_LED_OFF;
 508                        mode = INDICATOR_GREEN_BLINK;
 509                        break;
 510                /* blinking amber = hw attention */
 511                case INDICATOR_AMBER_BLINK:
 512                        selector = HUB_LED_AMBER;
 513                        mode = INDICATOR_AMBER_BLINK_OFF;
 514                        break;
 515                case INDICATOR_AMBER_BLINK_OFF:
 516                        selector = HUB_LED_OFF;
 517                        mode = INDICATOR_AMBER_BLINK;
 518                        break;
 519                /* blink green/amber = reserved */
 520                case INDICATOR_ALT_BLINK:
 521                        selector = HUB_LED_GREEN;
 522                        mode = INDICATOR_ALT_BLINK_OFF;
 523                        break;
 524                case INDICATOR_ALT_BLINK_OFF:
 525                        selector = HUB_LED_AMBER;
 526                        mode = INDICATOR_ALT_BLINK;
 527                        break;
 528                default:
 529                        continue;
 530                }
 531                if (selector != HUB_LED_AUTO)
 532                        changed = 1;
 533                set_port_led(hub, i + 1, selector);
 534                hub->indicator[i] = mode;
 535        }
 536        if (!changed && blinkenlights) {
 537                cursor++;
 538                cursor %= hdev->maxchild;
 539                set_port_led(hub, cursor + 1, HUB_LED_GREEN);
 540                hub->indicator[cursor] = INDICATOR_CYCLE;
 541                changed++;
 542        }
 543        if (changed)
 544                queue_delayed_work(system_power_efficient_wq,
 545                                &hub->leds, LED_CYCLE_PERIOD);
 546}
 547
 548/* use a short timeout for hub/port status fetches */
 549#define USB_STS_TIMEOUT         1000
 550#define USB_STS_RETRIES         5
 551
 552/*
 553 * USB 2.0 spec Section 11.24.2.6
 554 */
 555static int get_hub_status(struct usb_device *hdev,
 556                struct usb_hub_status *data)
 557{
 558        int i, status = -ETIMEDOUT;
 559
 560        for (i = 0; i < USB_STS_RETRIES &&
 561                        (status == -ETIMEDOUT || status == -EPIPE); i++) {
 562                status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 563                        USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
 564                        data, sizeof(*data), USB_STS_TIMEOUT);
 565        }
 566        return status;
 567}
 568
 569/*
 570 * USB 2.0 spec Section 11.24.2.7
 571 * USB 3.1 takes into use the wValue and wLength fields, spec Section 10.16.2.6
 572 */
 573static int get_port_status(struct usb_device *hdev, int port1,
 574                           void *data, u16 value, u16 length)
 575{
 576        int i, status = -ETIMEDOUT;
 577
 578        for (i = 0; i < USB_STS_RETRIES &&
 579                        (status == -ETIMEDOUT || status == -EPIPE); i++) {
 580                status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 581                        USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, value,
 582                        port1, data, length, USB_STS_TIMEOUT);
 583        }
 584        return status;
 585}
 586
 587static int hub_ext_port_status(struct usb_hub *hub, int port1, int type,
 588                               u16 *status, u16 *change, u32 *ext_status)
 589{
 590        int ret;
 591        int len = 4;
 592
 593        if (type != HUB_PORT_STATUS)
 594                len = 8;
 595
 596        mutex_lock(&hub->status_mutex);
 597        ret = get_port_status(hub->hdev, port1, &hub->status->port, type, len);
 598        if (ret < len) {
 599                if (ret != -ENODEV)
 600                        dev_err(hub->intfdev,
 601                                "%s failed (err = %d)\n", __func__, ret);
 602                if (ret >= 0)
 603                        ret = -EIO;
 604        } else {
 605                *status = le16_to_cpu(hub->status->port.wPortStatus);
 606                *change = le16_to_cpu(hub->status->port.wPortChange);
 607                if (type != HUB_PORT_STATUS && ext_status)
 608                        *ext_status = le32_to_cpu(
 609                                hub->status->port.dwExtPortStatus);
 610                ret = 0;
 611        }
 612        mutex_unlock(&hub->status_mutex);
 613        return ret;
 614}
 615
 616static int hub_port_status(struct usb_hub *hub, int port1,
 617                u16 *status, u16 *change)
 618{
 619        return hub_ext_port_status(hub, port1, HUB_PORT_STATUS,
 620                                   status, change, NULL);
 621}
 622
 623static void hub_resubmit_irq_urb(struct usb_hub *hub)
 624{
 625        unsigned long flags;
 626        int status;
 627
 628        spin_lock_irqsave(&hub->irq_urb_lock, flags);
 629
 630        if (hub->quiescing) {
 631                spin_unlock_irqrestore(&hub->irq_urb_lock, flags);
 632                return;
 633        }
 634
 635        status = usb_submit_urb(hub->urb, GFP_ATOMIC);
 636        if (status && status != -ENODEV && status != -EPERM &&
 637            status != -ESHUTDOWN) {
 638                dev_err(hub->intfdev, "resubmit --> %d\n", status);
 639                mod_timer(&hub->irq_urb_retry, jiffies + HZ);
 640        }
 641
 642        spin_unlock_irqrestore(&hub->irq_urb_lock, flags);
 643}
 644
 645static void hub_retry_irq_urb(struct timer_list *t)
 646{
 647        struct usb_hub *hub = from_timer(hub, t, irq_urb_retry);
 648
 649        hub_resubmit_irq_urb(hub);
 650}
 651
 652
 653static void kick_hub_wq(struct usb_hub *hub)
 654{
 655        struct usb_interface *intf;
 656
 657        if (hub->disconnected || work_pending(&hub->events))
 658                return;
 659
 660        /*
 661         * Suppress autosuspend until the event is proceed.
 662         *
 663         * Be careful and make sure that the symmetric operation is
 664         * always called. We are here only when there is no pending
 665         * work for this hub. Therefore put the interface either when
 666         * the new work is called or when it is canceled.
 667         */
 668        intf = to_usb_interface(hub->intfdev);
 669        usb_autopm_get_interface_no_resume(intf);
 670        kref_get(&hub->kref);
 671
 672        if (queue_work(hub_wq, &hub->events))
 673                return;
 674
 675        /* the work has already been scheduled */
 676        usb_autopm_put_interface_async(intf);
 677        kref_put(&hub->kref, hub_release);
 678}
 679
 680void usb_kick_hub_wq(struct usb_device *hdev)
 681{
 682        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 683
 684        if (hub)
 685                kick_hub_wq(hub);
 686}
 687
 688/*
 689 * Let the USB core know that a USB 3.0 device has sent a Function Wake Device
 690 * Notification, which indicates it had initiated remote wakeup.
 691 *
 692 * USB 3.0 hubs do not report the port link state change from U3 to U0 when the
 693 * device initiates resume, so the USB core will not receive notice of the
 694 * resume through the normal hub interrupt URB.
 695 */
 696void usb_wakeup_notification(struct usb_device *hdev,
 697                unsigned int portnum)
 698{
 699        struct usb_hub *hub;
 700        struct usb_port *port_dev;
 701
 702        if (!hdev)
 703                return;
 704
 705        hub = usb_hub_to_struct_hub(hdev);
 706        if (hub) {
 707                port_dev = hub->ports[portnum - 1];
 708                if (port_dev && port_dev->child)
 709                        pm_wakeup_event(&port_dev->child->dev, 0);
 710
 711                set_bit(portnum, hub->wakeup_bits);
 712                kick_hub_wq(hub);
 713        }
 714}
 715EXPORT_SYMBOL_GPL(usb_wakeup_notification);
 716
 717/* completion function, fires on port status changes and various faults */
 718static void hub_irq(struct urb *urb)
 719{
 720        struct usb_hub *hub = urb->context;
 721        int status = urb->status;
 722        unsigned i;
 723        unsigned long bits;
 724
 725        switch (status) {
 726        case -ENOENT:           /* synchronous unlink */
 727        case -ECONNRESET:       /* async unlink */
 728        case -ESHUTDOWN:        /* hardware going away */
 729                return;
 730
 731        default:                /* presumably an error */
 732                /* Cause a hub reset after 10 consecutive errors */
 733                dev_dbg(hub->intfdev, "transfer --> %d\n", status);
 734                if ((++hub->nerrors < 10) || hub->error)
 735                        goto resubmit;
 736                hub->error = status;
 737                fallthrough;
 738
 739        /* let hub_wq handle things */
 740        case 0:                 /* we got data:  port status changed */
 741                bits = 0;
 742                for (i = 0; i < urb->actual_length; ++i)
 743                        bits |= ((unsigned long) ((*hub->buffer)[i]))
 744                                        << (i*8);
 745                hub->event_bits[0] = bits;
 746                break;
 747        }
 748
 749        hub->nerrors = 0;
 750
 751        /* Something happened, let hub_wq figure it out */
 752        kick_hub_wq(hub);
 753
 754resubmit:
 755        hub_resubmit_irq_urb(hub);
 756}
 757
 758/* USB 2.0 spec Section 11.24.2.3 */
 759static inline int
 760hub_clear_tt_buffer(struct usb_device *hdev, u16 devinfo, u16 tt)
 761{
 762        /* Need to clear both directions for control ep */
 763        if (((devinfo >> 11) & USB_ENDPOINT_XFERTYPE_MASK) ==
 764                        USB_ENDPOINT_XFER_CONTROL) {
 765                int status = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 766                                HUB_CLEAR_TT_BUFFER, USB_RT_PORT,
 767                                devinfo ^ 0x8000, tt, NULL, 0, 1000);
 768                if (status)
 769                        return status;
 770        }
 771        return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 772                               HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
 773                               tt, NULL, 0, 1000);
 774}
 775
 776/*
 777 * enumeration blocks hub_wq for a long time. we use keventd instead, since
 778 * long blocking there is the exception, not the rule.  accordingly, HCDs
 779 * talking to TTs must queue control transfers (not just bulk and iso), so
 780 * both can talk to the same hub concurrently.
 781 */
 782static void hub_tt_work(struct work_struct *work)
 783{
 784        struct usb_hub          *hub =
 785                container_of(work, struct usb_hub, tt.clear_work);
 786        unsigned long           flags;
 787
 788        spin_lock_irqsave(&hub->tt.lock, flags);
 789        while (!list_empty(&hub->tt.clear_list)) {
 790                struct list_head        *next;
 791                struct usb_tt_clear     *clear;
 792                struct usb_device       *hdev = hub->hdev;
 793                const struct hc_driver  *drv;
 794                int                     status;
 795
 796                next = hub->tt.clear_list.next;
 797                clear = list_entry(next, struct usb_tt_clear, clear_list);
 798                list_del(&clear->clear_list);
 799
 800                /* drop lock so HCD can concurrently report other TT errors */
 801                spin_unlock_irqrestore(&hub->tt.lock, flags);
 802                status = hub_clear_tt_buffer(hdev, clear->devinfo, clear->tt);
 803                if (status && status != -ENODEV)
 804                        dev_err(&hdev->dev,
 805                                "clear tt %d (%04x) error %d\n",
 806                                clear->tt, clear->devinfo, status);
 807
 808                /* Tell the HCD, even if the operation failed */
 809                drv = clear->hcd->driver;
 810                if (drv->clear_tt_buffer_complete)
 811                        (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
 812
 813                kfree(clear);
 814                spin_lock_irqsave(&hub->tt.lock, flags);
 815        }
 816        spin_unlock_irqrestore(&hub->tt.lock, flags);
 817}
 818
 819/**
 820 * usb_hub_set_port_power - control hub port's power state
 821 * @hdev: USB device belonging to the usb hub
 822 * @hub: target hub
 823 * @port1: port index
 824 * @set: expected status
 825 *
 826 * call this function to control port's power via setting or
 827 * clearing the port's PORT_POWER feature.
 828 *
 829 * Return: 0 if successful. A negative error code otherwise.
 830 */
 831int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
 832                           int port1, bool set)
 833{
 834        int ret;
 835
 836        if (set)
 837                ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 838        else
 839                ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 840
 841        if (ret)
 842                return ret;
 843
 844        if (set)
 845                set_bit(port1, hub->power_bits);
 846        else
 847                clear_bit(port1, hub->power_bits);
 848        return 0;
 849}
 850
 851/**
 852 * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
 853 * @urb: an URB associated with the failed or incomplete split transaction
 854 *
 855 * High speed HCDs use this to tell the hub driver that some split control or
 856 * bulk transaction failed in a way that requires clearing internal state of
 857 * a transaction translator.  This is normally detected (and reported) from
 858 * interrupt context.
 859 *
 860 * It may not be possible for that hub to handle additional full (or low)
 861 * speed transactions until that state is fully cleared out.
 862 *
 863 * Return: 0 if successful. A negative error code otherwise.
 864 */
 865int usb_hub_clear_tt_buffer(struct urb *urb)
 866{
 867        struct usb_device       *udev = urb->dev;
 868        int                     pipe = urb->pipe;
 869        struct usb_tt           *tt = udev->tt;
 870        unsigned long           flags;
 871        struct usb_tt_clear     *clear;
 872
 873        /* we've got to cope with an arbitrary number of pending TT clears,
 874         * since each TT has "at least two" buffers that can need it (and
 875         * there can be many TTs per hub).  even if they're uncommon.
 876         */
 877        clear = kmalloc(sizeof *clear, GFP_ATOMIC);
 878        if (clear == NULL) {
 879                dev_err(&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
 880                /* FIXME recover somehow ... RESET_TT? */
 881                return -ENOMEM;
 882        }
 883
 884        /* info that CLEAR_TT_BUFFER needs */
 885        clear->tt = tt->multi ? udev->ttport : 1;
 886        clear->devinfo = usb_pipeendpoint (pipe);
 887        clear->devinfo |= ((u16)udev->devaddr) << 4;
 888        clear->devinfo |= usb_pipecontrol(pipe)
 889                        ? (USB_ENDPOINT_XFER_CONTROL << 11)
 890                        : (USB_ENDPOINT_XFER_BULK << 11);
 891        if (usb_pipein(pipe))
 892                clear->devinfo |= 1 << 15;
 893
 894        /* info for completion callback */
 895        clear->hcd = bus_to_hcd(udev->bus);
 896        clear->ep = urb->ep;
 897
 898        /* tell keventd to clear state for this TT */
 899        spin_lock_irqsave(&tt->lock, flags);
 900        list_add_tail(&clear->clear_list, &tt->clear_list);
 901        schedule_work(&tt->clear_work);
 902        spin_unlock_irqrestore(&tt->lock, flags);
 903        return 0;
 904}
 905EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
 906
 907static void hub_power_on(struct usb_hub *hub, bool do_delay)
 908{
 909        int port1;
 910
 911        /* Enable power on each port.  Some hubs have reserved values
 912         * of LPSM (> 2) in their descriptors, even though they are
 913         * USB 2.0 hubs.  Some hubs do not implement port-power switching
 914         * but only emulate it.  In all cases, the ports won't work
 915         * unless we send these messages to the hub.
 916         */
 917        if (hub_is_port_power_switchable(hub))
 918                dev_dbg(hub->intfdev, "enabling power on all ports\n");
 919        else
 920                dev_dbg(hub->intfdev, "trying to enable port power on "
 921                                "non-switchable hub\n");
 922        for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
 923                if (test_bit(port1, hub->power_bits))
 924                        set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
 925                else
 926                        usb_clear_port_feature(hub->hdev, port1,
 927                                                USB_PORT_FEAT_POWER);
 928        if (do_delay)
 929                msleep(hub_power_on_good_delay(hub));
 930}
 931
 932static int hub_hub_status(struct usb_hub *hub,
 933                u16 *status, u16 *change)
 934{
 935        int ret;
 936
 937        mutex_lock(&hub->status_mutex);
 938        ret = get_hub_status(hub->hdev, &hub->status->hub);
 939        if (ret < 0) {
 940                if (ret != -ENODEV)
 941                        dev_err(hub->intfdev,
 942                                "%s failed (err = %d)\n", __func__, ret);
 943        } else {
 944                *status = le16_to_cpu(hub->status->hub.wHubStatus);
 945                *change = le16_to_cpu(hub->status->hub.wHubChange);
 946                ret = 0;
 947        }
 948        mutex_unlock(&hub->status_mutex);
 949        return ret;
 950}
 951
 952static int hub_set_port_link_state(struct usb_hub *hub, int port1,
 953                        unsigned int link_status)
 954{
 955        return set_port_feature(hub->hdev,
 956                        port1 | (link_status << 3),
 957                        USB_PORT_FEAT_LINK_STATE);
 958}
 959
 960/*
 961 * Disable a port and mark a logical connect-change event, so that some
 962 * time later hub_wq will disconnect() any existing usb_device on the port
 963 * and will re-enumerate if there actually is a device attached.
 964 */
 965static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
 966{
 967        dev_dbg(&hub->ports[port1 - 1]->dev, "logical disconnect\n");
 968        hub_port_disable(hub, port1, 1);
 969
 970        /* FIXME let caller ask to power down the port:
 971         *  - some devices won't enumerate without a VBUS power cycle
 972         *  - SRP saves power that way
 973         *  - ... new call, TBD ...
 974         * That's easy if this hub can switch power per-port, and
 975         * hub_wq reactivates the port later (timer, SRP, etc).
 976         * Powerdown must be optional, because of reset/DFU.
 977         */
 978
 979        set_bit(port1, hub->change_bits);
 980        kick_hub_wq(hub);
 981}
 982
 983/**
 984 * usb_remove_device - disable a device's port on its parent hub
 985 * @udev: device to be disabled and removed
 986 * Context: @udev locked, must be able to sleep.
 987 *
 988 * After @udev's port has been disabled, hub_wq is notified and it will
 989 * see that the device has been disconnected.  When the device is
 990 * physically unplugged and something is plugged in, the events will
 991 * be received and processed normally.
 992 *
 993 * Return: 0 if successful. A negative error code otherwise.
 994 */
 995int usb_remove_device(struct usb_device *udev)
 996{
 997        struct usb_hub *hub;
 998        struct usb_interface *intf;
 999        int ret;
1000
1001        if (!udev->parent)      /* Can't remove a root hub */
1002                return -EINVAL;
1003        hub = usb_hub_to_struct_hub(udev->parent);
1004        intf = to_usb_interface(hub->intfdev);
1005
1006        ret = usb_autopm_get_interface(intf);
1007        if (ret < 0)
1008                return ret;
1009
1010        set_bit(udev->portnum, hub->removed_bits);
1011        hub_port_logical_disconnect(hub, udev->portnum);
1012        usb_autopm_put_interface(intf);
1013        return 0;
1014}
1015
1016enum hub_activation_type {
1017        HUB_INIT, HUB_INIT2, HUB_INIT3,         /* INITs must come first */
1018        HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
1019};
1020
1021static void hub_init_func2(struct work_struct *ws);
1022static void hub_init_func3(struct work_struct *ws);
1023
1024static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
1025{
1026        struct usb_device *hdev = hub->hdev;
1027        struct usb_hcd *hcd;
1028        int ret;
1029        int port1;
1030        int status;
1031        bool need_debounce_delay = false;
1032        unsigned delay;
1033
1034        /* Continue a partial initialization */
1035        if (type == HUB_INIT2 || type == HUB_INIT3) {
1036                device_lock(&hdev->dev);
1037
1038                /* Was the hub disconnected while we were waiting? */
1039                if (hub->disconnected)
1040                        goto disconnected;
1041                if (type == HUB_INIT2)
1042                        goto init2;
1043                goto init3;
1044        }
1045        kref_get(&hub->kref);
1046
1047        /* The superspeed hub except for root hub has to use Hub Depth
1048         * value as an offset into the route string to locate the bits
1049         * it uses to determine the downstream port number. So hub driver
1050         * should send a set hub depth request to superspeed hub after
1051         * the superspeed hub is set configuration in initialization or
1052         * reset procedure.
1053         *
1054         * After a resume, port power should still be on.
1055         * For any other type of activation, turn it on.
1056         */
1057        if (type != HUB_RESUME) {
1058                if (hdev->parent && hub_is_superspeed(hdev)) {
1059                        ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
1060                                        HUB_SET_DEPTH, USB_RT_HUB,
1061                                        hdev->level - 1, 0, NULL, 0,
1062                                        USB_CTRL_SET_TIMEOUT);
1063                        if (ret < 0)
1064                                dev_err(hub->intfdev,
1065                                                "set hub depth failed\n");
1066                }
1067
1068                /* Speed up system boot by using a delayed_work for the
1069                 * hub's initial power-up delays.  This is pretty awkward
1070                 * and the implementation looks like a home-brewed sort of
1071                 * setjmp/longjmp, but it saves at least 100 ms for each
1072                 * root hub (assuming usbcore is compiled into the kernel
1073                 * rather than as a module).  It adds up.
1074                 *
1075                 * This can't be done for HUB_RESUME or HUB_RESET_RESUME
1076                 * because for those activation types the ports have to be
1077                 * operational when we return.  In theory this could be done
1078                 * for HUB_POST_RESET, but it's easier not to.
1079                 */
1080                if (type == HUB_INIT) {
1081                        delay = hub_power_on_good_delay(hub);
1082
1083                        hub_power_on(hub, false);
1084                        INIT_DELAYED_WORK(&hub->init_work, hub_init_func2);
1085                        queue_delayed_work(system_power_efficient_wq,
1086                                        &hub->init_work,
1087                                        msecs_to_jiffies(delay));
1088
1089                        /* Suppress autosuspend until init is done */
1090                        usb_autopm_get_interface_no_resume(
1091                                        to_usb_interface(hub->intfdev));
1092                        return;         /* Continues at init2: below */
1093                } else if (type == HUB_RESET_RESUME) {
1094                        /* The internal host controller state for the hub device
1095                         * may be gone after a host power loss on system resume.
1096                         * Update the device's info so the HW knows it's a hub.
1097                         */
1098                        hcd = bus_to_hcd(hdev->bus);
1099                        if (hcd->driver->update_hub_device) {
1100                                ret = hcd->driver->update_hub_device(hcd, hdev,
1101                                                &hub->tt, GFP_NOIO);
1102                                if (ret < 0) {
1103                                        dev_err(hub->intfdev,
1104                                                "Host not accepting hub info update\n");
1105                                        dev_err(hub->intfdev,
1106                                                "LS/FS devices and hubs may not work under this hub\n");
1107                                }
1108                        }
1109                        hub_power_on(hub, true);
1110                } else {
1111                        hub_power_on(hub, true);
1112                }
1113        }
1114 init2:
1115
1116        /*
1117         * Check each port and set hub->change_bits to let hub_wq know
1118         * which ports need attention.
1119         */
1120        for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
1121                struct usb_port *port_dev = hub->ports[port1 - 1];
1122                struct usb_device *udev = port_dev->child;
1123                u16 portstatus, portchange;
1124
1125                portstatus = portchange = 0;
1126                status = hub_port_status(hub, port1, &portstatus, &portchange);
1127                if (status)
1128                        goto abort;
1129
1130                if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1131                        dev_dbg(&port_dev->dev, "status %04x change %04x\n",
1132                                        portstatus, portchange);
1133
1134                /*
1135                 * After anything other than HUB_RESUME (i.e., initialization
1136                 * or any sort of reset), every port should be disabled.
1137                 * Unconnected ports should likewise be disabled (paranoia),
1138                 * and so should ports for which we have no usb_device.
1139                 */
1140                if ((portstatus & USB_PORT_STAT_ENABLE) && (
1141                                type != HUB_RESUME ||
1142                                !(portstatus & USB_PORT_STAT_CONNECTION) ||
1143                                !udev ||
1144                                udev->state == USB_STATE_NOTATTACHED)) {
1145                        /*
1146                         * USB3 protocol ports will automatically transition
1147                         * to Enabled state when detect an USB3.0 device attach.
1148                         * Do not disable USB3 protocol ports, just pretend
1149                         * power was lost
1150                         */
1151                        portstatus &= ~USB_PORT_STAT_ENABLE;
1152                        if (!hub_is_superspeed(hdev))
1153                                usb_clear_port_feature(hdev, port1,
1154                                                   USB_PORT_FEAT_ENABLE);
1155                }
1156
1157                /* Make sure a warm-reset request is handled by port_event */
1158                if (type == HUB_RESUME &&
1159                    hub_port_warm_reset_required(hub, port1, portstatus))
1160                        set_bit(port1, hub->event_bits);
1161
1162                /*
1163                 * Add debounce if USB3 link is in polling/link training state.
1164                 * Link will automatically transition to Enabled state after
1165                 * link training completes.
1166                 */
1167                if (hub_is_superspeed(hdev) &&
1168                    ((portstatus & USB_PORT_STAT_LINK_STATE) ==
1169                                                USB_SS_PORT_LS_POLLING))
1170                        need_debounce_delay = true;
1171
1172                /* Clear status-change flags; we'll debounce later */
1173                if (portchange & USB_PORT_STAT_C_CONNECTION) {
1174                        need_debounce_delay = true;
1175                        usb_clear_port_feature(hub->hdev, port1,
1176                                        USB_PORT_FEAT_C_CONNECTION);
1177                }
1178                if (portchange & USB_PORT_STAT_C_ENABLE) {
1179                        need_debounce_delay = true;
1180                        usb_clear_port_feature(hub->hdev, port1,
1181                                        USB_PORT_FEAT_C_ENABLE);
1182                }
1183                if (portchange & USB_PORT_STAT_C_RESET) {
1184                        need_debounce_delay = true;
1185                        usb_clear_port_feature(hub->hdev, port1,
1186                                        USB_PORT_FEAT_C_RESET);
1187                }
1188                if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
1189                                hub_is_superspeed(hub->hdev)) {
1190                        need_debounce_delay = true;
1191                        usb_clear_port_feature(hub->hdev, port1,
1192                                        USB_PORT_FEAT_C_BH_PORT_RESET);
1193                }
1194                /* We can forget about a "removed" device when there's a
1195                 * physical disconnect or the connect status changes.
1196                 */
1197                if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
1198                                (portchange & USB_PORT_STAT_C_CONNECTION))
1199                        clear_bit(port1, hub->removed_bits);
1200
1201                if (!udev || udev->state == USB_STATE_NOTATTACHED) {
1202                        /* Tell hub_wq to disconnect the device or
1203                         * check for a new connection or over current condition.
1204                         * Based on USB2.0 Spec Section 11.12.5,
1205                         * C_PORT_OVER_CURRENT could be set while
1206                         * PORT_OVER_CURRENT is not. So check for any of them.
1207                         */
1208                        if (udev || (portstatus & USB_PORT_STAT_CONNECTION) ||
1209                            (portchange & USB_PORT_STAT_C_CONNECTION) ||
1210                            (portstatus & USB_PORT_STAT_OVERCURRENT) ||
1211                            (portchange & USB_PORT_STAT_C_OVERCURRENT))
1212                                set_bit(port1, hub->change_bits);
1213
1214                } else if (portstatus & USB_PORT_STAT_ENABLE) {
1215                        bool port_resumed = (portstatus &
1216                                        USB_PORT_STAT_LINK_STATE) ==
1217                                USB_SS_PORT_LS_U0;
1218                        /* The power session apparently survived the resume.
1219                         * If there was an overcurrent or suspend change
1220                         * (i.e., remote wakeup request), have hub_wq
1221                         * take care of it.  Look at the port link state
1222                         * for USB 3.0 hubs, since they don't have a suspend
1223                         * change bit, and they don't set the port link change
1224                         * bit on device-initiated resume.
1225                         */
1226                        if (portchange || (hub_is_superspeed(hub->hdev) &&
1227                                                port_resumed))
1228                                set_bit(port1, hub->change_bits);
1229
1230                } else if (udev->persist_enabled) {
1231#ifdef CONFIG_PM
1232                        udev->reset_resume = 1;
1233#endif
1234                        /* Don't set the change_bits when the device
1235                         * was powered off.
1236                         */
1237                        if (test_bit(port1, hub->power_bits))
1238                                set_bit(port1, hub->change_bits);
1239
1240                } else {
1241                        /* The power session is gone; tell hub_wq */
1242                        usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1243                        set_bit(port1, hub->change_bits);
1244                }
1245        }
1246
1247        /* If no port-status-change flags were set, we don't need any
1248         * debouncing.  If flags were set we can try to debounce the
1249         * ports all at once right now, instead of letting hub_wq do them
1250         * one at a time later on.
1251         *
1252         * If any port-status changes do occur during this delay, hub_wq
1253         * will see them later and handle them normally.
1254         */
1255        if (need_debounce_delay) {
1256                delay = HUB_DEBOUNCE_STABLE;
1257
1258                /* Don't do a long sleep inside a workqueue routine */
1259                if (type == HUB_INIT2) {
1260                        INIT_DELAYED_WORK(&hub->init_work, hub_init_func3);
1261                        queue_delayed_work(system_power_efficient_wq,
1262                                        &hub->init_work,
1263                                        msecs_to_jiffies(delay));
1264                        device_unlock(&hdev->dev);
1265                        return;         /* Continues at init3: below */
1266                } else {
1267                        msleep(delay);
1268                }
1269        }
1270 init3:
1271        hub->quiescing = 0;
1272
1273        status = usb_submit_urb(hub->urb, GFP_NOIO);
1274        if (status < 0)
1275                dev_err(hub->intfdev, "activate --> %d\n", status);
1276        if (hub->has_indicators && blinkenlights)
1277                queue_delayed_work(system_power_efficient_wq,
1278                                &hub->leds, LED_CYCLE_PERIOD);
1279
1280        /* Scan all ports that need attention */
1281        kick_hub_wq(hub);
1282 abort:
1283        if (type == HUB_INIT2 || type == HUB_INIT3) {
1284                /* Allow autosuspend if it was suppressed */
1285 disconnected:
1286                usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
1287                device_unlock(&hdev->dev);
1288        }
1289
1290        kref_put(&hub->kref, hub_release);
1291}
1292
1293/* Implement the continuations for the delays above */
1294static void hub_init_func2(struct work_struct *ws)
1295{
1296        struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1297
1298        hub_activate(hub, HUB_INIT2);
1299}
1300
1301static void hub_init_func3(struct work_struct *ws)
1302{
1303        struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1304
1305        hub_activate(hub, HUB_INIT3);
1306}
1307
1308enum hub_quiescing_type {
1309        HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
1310};
1311
1312static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
1313{
1314        struct usb_device *hdev = hub->hdev;
1315        unsigned long flags;
1316        int i;
1317
1318        /* hub_wq and related activity won't re-trigger */
1319        spin_lock_irqsave(&hub->irq_urb_lock, flags);
1320        hub->quiescing = 1;
1321        spin_unlock_irqrestore(&hub->irq_urb_lock, flags);
1322
1323        if (type != HUB_SUSPEND) {
1324                /* Disconnect all the children */
1325                for (i = 0; i < hdev->maxchild; ++i) {
1326                        if (hub->ports[i]->child)
1327                                usb_disconnect(&hub->ports[i]->child);
1328                }
1329        }
1330
1331        /* Stop hub_wq and related activity */
1332        del_timer_sync(&hub->irq_urb_retry);
1333        usb_kill_urb(hub->urb);
1334        if (hub->has_indicators)
1335                cancel_delayed_work_sync(&hub->leds);
1336        if (hub->tt.hub)
1337                flush_work(&hub->tt.clear_work);
1338}
1339
1340static void hub_pm_barrier_for_all_ports(struct usb_hub *hub)
1341{
1342        int i;
1343
1344        for (i = 0; i < hub->hdev->maxchild; ++i)
1345                pm_runtime_barrier(&hub->ports[i]->dev);
1346}
1347
1348/* caller has locked the hub device */
1349static int hub_pre_reset(struct usb_interface *intf)
1350{
1351        struct usb_hub *hub = usb_get_intfdata(intf);
1352
1353        hub_quiesce(hub, HUB_PRE_RESET);
1354        hub->in_reset = 1;
1355        hub_pm_barrier_for_all_ports(hub);
1356        return 0;
1357}
1358
1359/* caller has locked the hub device */
1360static int hub_post_reset(struct usb_interface *intf)
1361{
1362        struct usb_hub *hub = usb_get_intfdata(intf);
1363
1364        hub->in_reset = 0;
1365        hub_pm_barrier_for_all_ports(hub);
1366        hub_activate(hub, HUB_POST_RESET);
1367        return 0;
1368}
1369
1370static int hub_configure(struct usb_hub *hub,
1371        struct usb_endpoint_descriptor *endpoint)
1372{
1373        struct usb_hcd *hcd;
1374        struct usb_device *hdev = hub->hdev;
1375        struct device *hub_dev = hub->intfdev;
1376        u16 hubstatus, hubchange;
1377        u16 wHubCharacteristics;
1378        unsigned int pipe;
1379        int maxp, ret, i;
1380        char *message = "out of memory";
1381        unsigned unit_load;
1382        unsigned full_load;
1383        unsigned maxchild;
1384
1385        hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
1386        if (!hub->buffer) {
1387                ret = -ENOMEM;
1388                goto fail;
1389        }
1390
1391        hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
1392        if (!hub->status) {
1393                ret = -ENOMEM;
1394                goto fail;
1395        }
1396        mutex_init(&hub->status_mutex);
1397
1398        hub->descriptor = kzalloc(sizeof(*hub->descriptor), GFP_KERNEL);
1399        if (!hub->descriptor) {
1400                ret = -ENOMEM;
1401                goto fail;
1402        }
1403
1404        /* Request the entire hub descriptor.
1405         * hub->descriptor can handle USB_MAXCHILDREN ports,
1406         * but a (non-SS) hub can/will return fewer bytes here.
1407         */
1408        ret = get_hub_descriptor(hdev, hub->descriptor);
1409        if (ret < 0) {
1410                message = "can't read hub descriptor";
1411                goto fail;
1412        }
1413
1414        maxchild = USB_MAXCHILDREN;
1415        if (hub_is_superspeed(hdev))
1416                maxchild = min_t(unsigned, maxchild, USB_SS_MAXPORTS);
1417
1418        if (hub->descriptor->bNbrPorts > maxchild) {
1419                message = "hub has too many ports!";
1420                ret = -ENODEV;
1421                goto fail;
1422        } else if (hub->descriptor->bNbrPorts == 0) {
1423                message = "hub doesn't have any ports!";
1424                ret = -ENODEV;
1425                goto fail;
1426        }
1427
1428        /*
1429         * Accumulate wHubDelay + 40ns for every hub in the tree of devices.
1430         * The resulting value will be used for SetIsochDelay() request.
1431         */
1432        if (hub_is_superspeed(hdev) || hub_is_superspeedplus(hdev)) {
1433                u32 delay = __le16_to_cpu(hub->descriptor->u.ss.wHubDelay);
1434
1435                if (hdev->parent)
1436                        delay += hdev->parent->hub_delay;
1437
1438                delay += USB_TP_TRANSMISSION_DELAY;
1439                hdev->hub_delay = min_t(u32, delay, USB_TP_TRANSMISSION_DELAY_MAX);
1440        }
1441
1442        maxchild = hub->descriptor->bNbrPorts;
1443        dev_info(hub_dev, "%d port%s detected\n", maxchild,
1444                        (maxchild == 1) ? "" : "s");
1445
1446        hub->ports = kcalloc(maxchild, sizeof(struct usb_port *), GFP_KERNEL);
1447        if (!hub->ports) {
1448                ret = -ENOMEM;
1449                goto fail;
1450        }
1451
1452        wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
1453        if (hub_is_superspeed(hdev)) {
1454                unit_load = 150;
1455                full_load = 900;
1456        } else {
1457                unit_load = 100;
1458                full_load = 500;
1459        }
1460
1461        /* FIXME for USB 3.0, skip for now */
1462        if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
1463                        !(hub_is_superspeed(hdev))) {
1464                char    portstr[USB_MAXCHILDREN + 1];
1465
1466                for (i = 0; i < maxchild; i++)
1467                        portstr[i] = hub->descriptor->u.hs.DeviceRemovable
1468                                    [((i + 1) / 8)] & (1 << ((i + 1) % 8))
1469                                ? 'F' : 'R';
1470                portstr[maxchild] = 0;
1471                dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
1472        } else
1473                dev_dbg(hub_dev, "standalone hub\n");
1474
1475        switch (wHubCharacteristics & HUB_CHAR_LPSM) {
1476        case HUB_CHAR_COMMON_LPSM:
1477                dev_dbg(hub_dev, "ganged power switching\n");
1478                break;
1479        case HUB_CHAR_INDV_PORT_LPSM:
1480                dev_dbg(hub_dev, "individual port power switching\n");
1481                break;
1482        case HUB_CHAR_NO_LPSM:
1483        case HUB_CHAR_LPSM:
1484                dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
1485                break;
1486        }
1487
1488        switch (wHubCharacteristics & HUB_CHAR_OCPM) {
1489        case HUB_CHAR_COMMON_OCPM:
1490                dev_dbg(hub_dev, "global over-current protection\n");
1491                break;
1492        case HUB_CHAR_INDV_PORT_OCPM:
1493                dev_dbg(hub_dev, "individual port over-current protection\n");
1494                break;
1495        case HUB_CHAR_NO_OCPM:
1496        case HUB_CHAR_OCPM:
1497                dev_dbg(hub_dev, "no over-current protection\n");
1498                break;
1499        }
1500
1501        spin_lock_init(&hub->tt.lock);
1502        INIT_LIST_HEAD(&hub->tt.clear_list);
1503        INIT_WORK(&hub->tt.clear_work, hub_tt_work);
1504        switch (hdev->descriptor.bDeviceProtocol) {
1505        case USB_HUB_PR_FS:
1506                break;
1507        case USB_HUB_PR_HS_SINGLE_TT:
1508                dev_dbg(hub_dev, "Single TT\n");
1509                hub->tt.hub = hdev;
1510                break;
1511        case USB_HUB_PR_HS_MULTI_TT:
1512                ret = usb_set_interface(hdev, 0, 1);
1513                if (ret == 0) {
1514                        dev_dbg(hub_dev, "TT per port\n");
1515                        hub->tt.multi = 1;
1516                } else
1517                        dev_err(hub_dev, "Using single TT (err %d)\n",
1518                                ret);
1519                hub->tt.hub = hdev;
1520                break;
1521        case USB_HUB_PR_SS:
1522                /* USB 3.0 hubs don't have a TT */
1523                break;
1524        default:
1525                dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
1526                        hdev->descriptor.bDeviceProtocol);
1527                break;
1528        }
1529
1530        /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
1531        switch (wHubCharacteristics & HUB_CHAR_TTTT) {
1532        case HUB_TTTT_8_BITS:
1533                if (hdev->descriptor.bDeviceProtocol != 0) {
1534                        hub->tt.think_time = 666;
1535                        dev_dbg(hub_dev, "TT requires at most %d "
1536                                        "FS bit times (%d ns)\n",
1537                                8, hub->tt.think_time);
1538                }
1539                break;
1540        case HUB_TTTT_16_BITS:
1541                hub->tt.think_time = 666 * 2;
1542                dev_dbg(hub_dev, "TT requires at most %d "
1543                                "FS bit times (%d ns)\n",
1544                        16, hub->tt.think_time);
1545                break;
1546        case HUB_TTTT_24_BITS:
1547                hub->tt.think_time = 666 * 3;
1548                dev_dbg(hub_dev, "TT requires at most %d "
1549                                "FS bit times (%d ns)\n",
1550                        24, hub->tt.think_time);
1551                break;
1552        case HUB_TTTT_32_BITS:
1553                hub->tt.think_time = 666 * 4;
1554                dev_dbg(hub_dev, "TT requires at most %d "
1555                                "FS bit times (%d ns)\n",
1556                        32, hub->tt.think_time);
1557                break;
1558        }
1559
1560        /* probe() zeroes hub->indicator[] */
1561        if (wHubCharacteristics & HUB_CHAR_PORTIND) {
1562                hub->has_indicators = 1;
1563                dev_dbg(hub_dev, "Port indicators are supported\n");
1564        }
1565
1566        dev_dbg(hub_dev, "power on to power good time: %dms\n",
1567                hub->descriptor->bPwrOn2PwrGood * 2);
1568
1569        /* power budgeting mostly matters with bus-powered hubs,
1570         * and battery-powered root hubs (may provide just 8 mA).
1571         */
1572        ret = usb_get_std_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
1573        if (ret) {
1574                message = "can't get hub status";
1575                goto fail;
1576        }
1577        hcd = bus_to_hcd(hdev->bus);
1578        if (hdev == hdev->bus->root_hub) {
1579                if (hcd->power_budget > 0)
1580                        hdev->bus_mA = hcd->power_budget;
1581                else
1582                        hdev->bus_mA = full_load * maxchild;
1583                if (hdev->bus_mA >= full_load)
1584                        hub->mA_per_port = full_load;
1585                else {
1586                        hub->mA_per_port = hdev->bus_mA;
1587                        hub->limited_power = 1;
1588                }
1589        } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
1590                int remaining = hdev->bus_mA -
1591                        hub->descriptor->bHubContrCurrent;
1592
1593                dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
1594                        hub->descriptor->bHubContrCurrent);
1595                hub->limited_power = 1;
1596
1597                if (remaining < maxchild * unit_load)
1598                        dev_warn(hub_dev,
1599                                        "insufficient power available "
1600                                        "to use all downstream ports\n");
1601                hub->mA_per_port = unit_load;   /* 7.2.1 */
1602
1603        } else {        /* Self-powered external hub */
1604                /* FIXME: What about battery-powered external hubs that
1605                 * provide less current per port? */
1606                hub->mA_per_port = full_load;
1607        }
1608        if (hub->mA_per_port < full_load)
1609                dev_dbg(hub_dev, "%umA bus power budget for each child\n",
1610                                hub->mA_per_port);
1611
1612        ret = hub_hub_status(hub, &hubstatus, &hubchange);
1613        if (ret < 0) {
1614                message = "can't get hub status";
1615                goto fail;
1616        }
1617
1618        /* local power status reports aren't always correct */
1619        if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1620                dev_dbg(hub_dev, "local power source is %s\n",
1621                        (hubstatus & HUB_STATUS_LOCAL_POWER)
1622                        ? "lost (inactive)" : "good");
1623
1624        if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
1625                dev_dbg(hub_dev, "%sover-current condition exists\n",
1626                        (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
1627
1628        /* set up the interrupt endpoint
1629         * We use the EP's maxpacket size instead of (PORTS+1+7)/8
1630         * bytes as USB2.0[11.12.3] says because some hubs are known
1631         * to send more data (and thus cause overflow). For root hubs,
1632         * maxpktsize is defined in hcd.c's fake endpoint descriptors
1633         * to be big enough for at least USB_MAXCHILDREN ports. */
1634        pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
1635        maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
1636
1637        if (maxp > sizeof(*hub->buffer))
1638                maxp = sizeof(*hub->buffer);
1639
1640        hub->urb = usb_alloc_urb(0, GFP_KERNEL);
1641        if (!hub->urb) {
1642                ret = -ENOMEM;
1643                goto fail;
1644        }
1645
1646        usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
1647                hub, endpoint->bInterval);
1648
1649        /* maybe cycle the hub leds */
1650        if (hub->has_indicators && blinkenlights)
1651                hub->indicator[0] = INDICATOR_CYCLE;
1652
1653        mutex_lock(&usb_port_peer_mutex);
1654        for (i = 0; i < maxchild; i++) {
1655                ret = usb_hub_create_port_device(hub, i + 1);
1656                if (ret < 0) {
1657                        dev_err(hub->intfdev,
1658                                "couldn't create port%d device.\n", i + 1);
1659                        break;
1660                }
1661        }
1662        hdev->maxchild = i;
1663        for (i = 0; i < hdev->maxchild; i++) {
1664                struct usb_port *port_dev = hub->ports[i];
1665
1666                pm_runtime_put(&port_dev->dev);
1667        }
1668
1669        mutex_unlock(&usb_port_peer_mutex);
1670        if (ret < 0)
1671                goto fail;
1672
1673        /* Update the HCD's internal representation of this hub before hub_wq
1674         * starts getting port status changes for devices under the hub.
1675         */
1676        if (hcd->driver->update_hub_device) {
1677                ret = hcd->driver->update_hub_device(hcd, hdev,
1678                                &hub->tt, GFP_KERNEL);
1679                if (ret < 0) {
1680                        message = "can't update HCD hub info";
1681                        goto fail;
1682                }
1683        }
1684
1685        usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
1686
1687        hub_activate(hub, HUB_INIT);
1688        return 0;
1689
1690fail:
1691        dev_err(hub_dev, "config failed, %s (err %d)\n",
1692                        message, ret);
1693        /* hub_disconnect() frees urb and descriptor */
1694        return ret;
1695}
1696
1697static void hub_release(struct kref *kref)
1698{
1699        struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
1700
1701        usb_put_dev(hub->hdev);
1702        usb_put_intf(to_usb_interface(hub->intfdev));
1703        kfree(hub);
1704}
1705
1706static unsigned highspeed_hubs;
1707
1708static void hub_disconnect(struct usb_interface *intf)
1709{
1710        struct usb_hub *hub = usb_get_intfdata(intf);
1711        struct usb_device *hdev = interface_to_usbdev(intf);
1712        int port1;
1713
1714        /*
1715         * Stop adding new hub events. We do not want to block here and thus
1716         * will not try to remove any pending work item.
1717         */
1718        hub->disconnected = 1;
1719
1720        /* Disconnect all children and quiesce the hub */
1721        hub->error = 0;
1722        hub_quiesce(hub, HUB_DISCONNECT);
1723
1724        mutex_lock(&usb_port_peer_mutex);
1725
1726        /* Avoid races with recursively_mark_NOTATTACHED() */
1727        spin_lock_irq(&device_state_lock);
1728        port1 = hdev->maxchild;
1729        hdev->maxchild = 0;
1730        usb_set_intfdata(intf, NULL);
1731        spin_unlock_irq(&device_state_lock);
1732
1733        for (; port1 > 0; --port1)
1734                usb_hub_remove_port_device(hub, port1);
1735
1736        mutex_unlock(&usb_port_peer_mutex);
1737
1738        if (hub->hdev->speed == USB_SPEED_HIGH)
1739                highspeed_hubs--;
1740
1741        usb_free_urb(hub->urb);
1742        kfree(hub->ports);
1743        kfree(hub->descriptor);
1744        kfree(hub->status);
1745        kfree(hub->buffer);
1746
1747        pm_suspend_ignore_children(&intf->dev, false);
1748
1749        if (hub->quirk_disable_autosuspend)
1750                usb_autopm_put_interface(intf);
1751
1752        kref_put(&hub->kref, hub_release);
1753}
1754
1755static bool hub_descriptor_is_sane(struct usb_host_interface *desc)
1756{
1757        /* Some hubs have a subclass of 1, which AFAICT according to the */
1758        /*  specs is not defined, but it works */
1759        if (desc->desc.bInterfaceSubClass != 0 &&
1760            desc->desc.bInterfaceSubClass != 1)
1761                return false;
1762
1763        /* Multiple endpoints? What kind of mutant ninja-hub is this? */
1764        if (desc->desc.bNumEndpoints != 1)
1765                return false;
1766
1767        /* If the first endpoint is not interrupt IN, we'd better punt! */
1768        if (!usb_endpoint_is_int_in(&desc->endpoint[0].desc))
1769                return false;
1770
1771        return true;
1772}
1773
1774static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
1775{
1776        struct usb_host_interface *desc;
1777        struct usb_device *hdev;
1778        struct usb_hub *hub;
1779
1780        desc = intf->cur_altsetting;
1781        hdev = interface_to_usbdev(intf);
1782
1783        /*
1784         * Set default autosuspend delay as 0 to speedup bus suspend,
1785         * based on the below considerations:
1786         *
1787         * - Unlike other drivers, the hub driver does not rely on the
1788         *   autosuspend delay to provide enough time to handle a wakeup
1789         *   event, and the submitted status URB is just to check future
1790         *   change on hub downstream ports, so it is safe to do it.
1791         *
1792         * - The patch might cause one or more auto supend/resume for
1793         *   below very rare devices when they are plugged into hub
1794         *   first time:
1795         *
1796         *      devices having trouble initializing, and disconnect
1797         *      themselves from the bus and then reconnect a second
1798         *      or so later
1799         *
1800         *      devices just for downloading firmware, and disconnects
1801         *      themselves after completing it
1802         *
1803         *   For these quite rare devices, their drivers may change the
1804         *   autosuspend delay of their parent hub in the probe() to one
1805         *   appropriate value to avoid the subtle problem if someone
1806         *   does care it.
1807         *
1808         * - The patch may cause one or more auto suspend/resume on
1809         *   hub during running 'lsusb', but it is probably too
1810         *   infrequent to worry about.
1811         *
1812         * - Change autosuspend delay of hub can avoid unnecessary auto
1813         *   suspend timer for hub, also may decrease power consumption
1814         *   of USB bus.
1815         *
1816         * - If user has indicated to prevent autosuspend by passing
1817         *   usbcore.autosuspend = -1 then keep autosuspend disabled.
1818         */
1819#ifdef CONFIG_PM
1820        if (hdev->dev.power.autosuspend_delay >= 0)
1821                pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
1822#endif
1823
1824        /*
1825         * Hubs have proper suspend/resume support, except for root hubs
1826         * where the controller driver doesn't have bus_suspend and
1827         * bus_resume methods.
1828         */
1829        if (hdev->parent) {             /* normal device */
1830                usb_enable_autosuspend(hdev);
1831        } else {                        /* root hub */
1832                const struct hc_driver *drv = bus_to_hcd(hdev->bus)->driver;
1833
1834                if (drv->bus_suspend && drv->bus_resume)
1835                        usb_enable_autosuspend(hdev);
1836        }
1837
1838        if (hdev->level == MAX_TOPO_LEVEL) {
1839                dev_err(&intf->dev,
1840                        "Unsupported bus topology: hub nested too deep\n");
1841                return -E2BIG;
1842        }
1843
1844#ifdef  CONFIG_USB_OTG_DISABLE_EXTERNAL_HUB
1845        if (hdev->parent) {
1846                dev_warn(&intf->dev, "ignoring external hub\n");
1847                return -ENODEV;
1848        }
1849#endif
1850
1851        if (!hub_descriptor_is_sane(desc)) {
1852                dev_err(&intf->dev, "bad descriptor, ignoring hub\n");
1853                return -EIO;
1854        }
1855
1856        /* We found a hub */
1857        dev_info(&intf->dev, "USB hub found\n");
1858
1859        hub = kzalloc(sizeof(*hub), GFP_KERNEL);
1860        if (!hub)
1861                return -ENOMEM;
1862
1863        kref_init(&hub->kref);
1864        hub->intfdev = &intf->dev;
1865        hub->hdev = hdev;
1866        INIT_DELAYED_WORK(&hub->leds, led_work);
1867        INIT_DELAYED_WORK(&hub->init_work, NULL);
1868        INIT_WORK(&hub->events, hub_event);
1869        spin_lock_init(&hub->irq_urb_lock);
1870        timer_setup(&hub->irq_urb_retry, hub_retry_irq_urb, 0);
1871        usb_get_intf(intf);
1872        usb_get_dev(hdev);
1873
1874        usb_set_intfdata(intf, hub);
1875        intf->needs_remote_wakeup = 1;
1876        pm_suspend_ignore_children(&intf->dev, true);
1877
1878        if (hdev->speed == USB_SPEED_HIGH)
1879                highspeed_hubs++;
1880
1881        if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
1882                hub->quirk_check_port_auto_suspend = 1;
1883
1884        if (id->driver_info & HUB_QUIRK_DISABLE_AUTOSUSPEND) {
1885                hub->quirk_disable_autosuspend = 1;
1886                usb_autopm_get_interface_no_resume(intf);
1887        }
1888
1889        if (hub_configure(hub, &desc->endpoint[0].desc) >= 0)
1890                return 0;
1891
1892        hub_disconnect(intf);
1893        return -ENODEV;
1894}
1895
1896static int
1897hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
1898{
1899        struct usb_device *hdev = interface_to_usbdev(intf);
1900        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1901
1902        /* assert ifno == 0 (part of hub spec) */
1903        switch (code) {
1904        case USBDEVFS_HUB_PORTINFO: {
1905                struct usbdevfs_hub_portinfo *info = user_data;
1906                int i;
1907
1908                spin_lock_irq(&device_state_lock);
1909                if (hdev->devnum <= 0)
1910                        info->nports = 0;
1911                else {
1912                        info->nports = hdev->maxchild;
1913                        for (i = 0; i < info->nports; i++) {
1914                                if (hub->ports[i]->child == NULL)
1915                                        info->port[i] = 0;
1916                                else
1917                                        info->port[i] =
1918                                                hub->ports[i]->child->devnum;
1919                        }
1920                }
1921                spin_unlock_irq(&device_state_lock);
1922
1923                return info->nports + 1;
1924                }
1925
1926        default:
1927                return -ENOSYS;
1928        }
1929}
1930
1931/*
1932 * Allow user programs to claim ports on a hub.  When a device is attached
1933 * to one of these "claimed" ports, the program will "own" the device.
1934 */
1935static int find_port_owner(struct usb_device *hdev, unsigned port1,
1936                struct usb_dev_state ***ppowner)
1937{
1938        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1939
1940        if (hdev->state == USB_STATE_NOTATTACHED)
1941                return -ENODEV;
1942        if (port1 == 0 || port1 > hdev->maxchild)
1943                return -EINVAL;
1944
1945        /* Devices not managed by the hub driver
1946         * will always have maxchild equal to 0.
1947         */
1948        *ppowner = &(hub->ports[port1 - 1]->port_owner);
1949        return 0;
1950}
1951
1952/* In the following three functions, the caller must hold hdev's lock */
1953int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
1954                       struct usb_dev_state *owner)
1955{
1956        int rc;
1957        struct usb_dev_state **powner;
1958
1959        rc = find_port_owner(hdev, port1, &powner);
1960        if (rc)
1961                return rc;
1962        if (*powner)
1963                return -EBUSY;
1964        *powner = owner;
1965        return rc;
1966}
1967EXPORT_SYMBOL_GPL(usb_hub_claim_port);
1968
1969int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
1970                         struct usb_dev_state *owner)
1971{
1972        int rc;
1973        struct usb_dev_state **powner;
1974
1975        rc = find_port_owner(hdev, port1, &powner);
1976        if (rc)
1977                return rc;
1978        if (*powner != owner)
1979                return -ENOENT;
1980        *powner = NULL;
1981        return rc;
1982}
1983EXPORT_SYMBOL_GPL(usb_hub_release_port);
1984
1985void usb_hub_release_all_ports(struct usb_device *hdev, struct usb_dev_state *owner)
1986{
1987        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1988        int n;
1989
1990        for (n = 0; n < hdev->maxchild; n++) {
1991                if (hub->ports[n]->port_owner == owner)
1992                        hub->ports[n]->port_owner = NULL;
1993        }
1994
1995}
1996
1997/* The caller must hold udev's lock */
1998bool usb_device_is_owned(struct usb_device *udev)
1999{
2000        struct usb_hub *hub;
2001
2002        if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
2003                return false;
2004        hub = usb_hub_to_struct_hub(udev->parent);
2005        return !!hub->ports[udev->portnum - 1]->port_owner;
2006}
2007
2008static void recursively_mark_NOTATTACHED(struct usb_device *udev)
2009{
2010        struct usb_hub *hub = usb_hub_to_struct_hub(udev);
2011        int i;
2012
2013        for (i = 0; i < udev->maxchild; ++i) {
2014                if (hub->ports[i]->child)
2015                        recursively_mark_NOTATTACHED(hub->ports[i]->child);
2016        }
2017        if (udev->state == USB_STATE_SUSPENDED)
2018                udev->active_duration -= jiffies;
2019        udev->state = USB_STATE_NOTATTACHED;
2020}
2021
2022/**
2023 * usb_set_device_state - change a device's current state (usbcore, hcds)
2024 * @udev: pointer to device whose state should be changed
2025 * @new_state: new state value to be stored
2026 *
2027 * udev->state is _not_ fully protected by the device lock.  Although
2028 * most transitions are made only while holding the lock, the state can
2029 * can change to USB_STATE_NOTATTACHED at almost any time.  This
2030 * is so that devices can be marked as disconnected as soon as possible,
2031 * without having to wait for any semaphores to be released.  As a result,
2032 * all changes to any device's state must be protected by the
2033 * device_state_lock spinlock.
2034 *
2035 * Once a device has been added to the device tree, all changes to its state
2036 * should be made using this routine.  The state should _not_ be set directly.
2037 *
2038 * If udev->state is already USB_STATE_NOTATTACHED then no change is made.
2039 * Otherwise udev->state is set to new_state, and if new_state is
2040 * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
2041 * to USB_STATE_NOTATTACHED.
2042 */
2043void usb_set_device_state(struct usb_device *udev,
2044                enum usb_device_state new_state)
2045{
2046        unsigned long flags;
2047        int wakeup = -1;
2048
2049        spin_lock_irqsave(&device_state_lock, flags);
2050        if (udev->state == USB_STATE_NOTATTACHED)
2051                ;       /* do nothing */
2052        else if (new_state != USB_STATE_NOTATTACHED) {
2053
2054                /* root hub wakeup capabilities are managed out-of-band
2055                 * and may involve silicon errata ... ignore them here.
2056                 */
2057                if (udev->parent) {
2058                        if (udev->state == USB_STATE_SUSPENDED
2059                                        || new_state == USB_STATE_SUSPENDED)
2060                                ;       /* No change to wakeup settings */
2061                        else if (new_state == USB_STATE_CONFIGURED)
2062                                wakeup = (udev->quirks &
2063                                        USB_QUIRK_IGNORE_REMOTE_WAKEUP) ? 0 :
2064                                        udev->actconfig->desc.bmAttributes &
2065                                        USB_CONFIG_ATT_WAKEUP;
2066                        else
2067                                wakeup = 0;
2068                }
2069                if (udev->state == USB_STATE_SUSPENDED &&
2070                        new_state != USB_STATE_SUSPENDED)
2071                        udev->active_duration -= jiffies;
2072                else if (new_state == USB_STATE_SUSPENDED &&
2073                                udev->state != USB_STATE_SUSPENDED)
2074                        udev->active_duration += jiffies;
2075                udev->state = new_state;
2076        } else
2077                recursively_mark_NOTATTACHED(udev);
2078        spin_unlock_irqrestore(&device_state_lock, flags);
2079        if (wakeup >= 0)
2080                device_set_wakeup_capable(&udev->dev, wakeup);
2081}
2082EXPORT_SYMBOL_GPL(usb_set_device_state);
2083
2084/*
2085 * Choose a device number.
2086 *
2087 * Device numbers are used as filenames in usbfs.  On USB-1.1 and
2088 * USB-2.0 buses they are also used as device addresses, however on
2089 * USB-3.0 buses the address is assigned by the controller hardware
2090 * and it usually is not the same as the device number.
2091 *
2092 * WUSB devices are simple: they have no hubs behind, so the mapping
2093 * device <-> virtual port number becomes 1:1. Why? to simplify the
2094 * life of the device connection logic in
2095 * drivers/usb/wusbcore/devconnect.c. When we do the initial secret
2096 * handshake we need to assign a temporary address in the unauthorized
2097 * space. For simplicity we use the first virtual port number found to
2098 * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
2099 * and that becomes it's address [X < 128] or its unauthorized address
2100 * [X | 0x80].
2101 *
2102 * We add 1 as an offset to the one-based USB-stack port number
2103 * (zero-based wusb virtual port index) for two reasons: (a) dev addr
2104 * 0 is reserved by USB for default address; (b) Linux's USB stack
2105 * uses always #1 for the root hub of the controller. So USB stack's
2106 * port #1, which is wusb virtual-port #0 has address #2.
2107 *
2108 * Devices connected under xHCI are not as simple.  The host controller
2109 * supports virtualization, so the hardware assigns device addresses and
2110 * the HCD must setup data structures before issuing a set address
2111 * command to the hardware.
2112 */
2113static void choose_devnum(struct usb_device *udev)
2114{
2115        int             devnum;
2116        struct usb_bus  *bus = udev->bus;
2117
2118        /* be safe when more hub events are proceed in parallel */
2119        mutex_lock(&bus->devnum_next_mutex);
2120        if (udev->wusb) {
2121                devnum = udev->portnum + 1;
2122                BUG_ON(test_bit(devnum, bus->devmap.devicemap));
2123        } else {
2124                /* Try to allocate the next devnum beginning at
2125                 * bus->devnum_next. */
2126                devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
2127                                            bus->devnum_next);
2128                if (devnum >= 128)
2129                        devnum = find_next_zero_bit(bus->devmap.devicemap,
2130                                                    128, 1);
2131                bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
2132        }
2133        if (devnum < 128) {
2134                set_bit(devnum, bus->devmap.devicemap);
2135                udev->devnum = devnum;
2136        }
2137        mutex_unlock(&bus->devnum_next_mutex);
2138}
2139
2140static void release_devnum(struct usb_device *udev)
2141{
2142        if (udev->devnum > 0) {
2143                clear_bit(udev->devnum, udev->bus->devmap.devicemap);
2144                udev->devnum = -1;
2145        }
2146}
2147
2148static void update_devnum(struct usb_device *udev, int devnum)
2149{
2150        /* The address for a WUSB device is managed by wusbcore. */
2151        if (!udev->wusb)
2152                udev->devnum = devnum;
2153        if (!udev->devaddr)
2154                udev->devaddr = (u8)devnum;
2155}
2156
2157static void hub_free_dev(struct usb_device *udev)
2158{
2159        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2160
2161        /* Root hubs aren't real devices, so don't free HCD resources */
2162        if (hcd->driver->free_dev && udev->parent)
2163                hcd->driver->free_dev(hcd, udev);
2164}
2165
2166static void hub_disconnect_children(struct usb_device *udev)
2167{
2168        struct usb_hub *hub = usb_hub_to_struct_hub(udev);
2169        int i;
2170
2171        /* Free up all the children before we remove this device */
2172        for (i = 0; i < udev->maxchild; i++) {
2173                if (hub->ports[i]->child)
2174                        usb_disconnect(&hub->ports[i]->child);
2175        }
2176}
2177
2178/**
2179 * usb_disconnect - disconnect a device (usbcore-internal)
2180 * @pdev: pointer to device being disconnected
2181 *
2182 * Context: task context, might sleep
2183 *
2184 * Something got disconnected. Get rid of it and all of its children.
2185 *
2186 * If *pdev is a normal device then the parent hub must already be locked.
2187 * If *pdev is a root hub then the caller must hold the usb_bus_idr_lock,
2188 * which protects the set of root hubs as well as the list of buses.
2189 *
2190 * Only hub drivers (including virtual root hub drivers for host
2191 * controllers) should ever call this.
2192 *
2193 * This call is synchronous, and may not be used in an interrupt context.
2194 */
2195void usb_disconnect(struct usb_device **pdev)
2196{
2197        struct usb_port *port_dev = NULL;
2198        struct usb_device *udev = *pdev;
2199        struct usb_hub *hub = NULL;
2200        int port1 = 1;
2201
2202        /* mark the device as inactive, so any further urb submissions for
2203         * this device (and any of its children) will fail immediately.
2204         * this quiesces everything except pending urbs.
2205         */
2206        usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2207        dev_info(&udev->dev, "USB disconnect, device number %d\n",
2208                        udev->devnum);
2209
2210        /*
2211         * Ensure that the pm runtime code knows that the USB device
2212         * is in the process of being disconnected.
2213         */
2214        pm_runtime_barrier(&udev->dev);
2215
2216        usb_lock_device(udev);
2217
2218        hub_disconnect_children(udev);
2219
2220        /* deallocate hcd/hardware state ... nuking all pending urbs and
2221         * cleaning up all state associated with the current configuration
2222         * so that the hardware is now fully quiesced.
2223         */
2224        dev_dbg(&udev->dev, "unregistering device\n");
2225        usb_disable_device(udev, 0);
2226        usb_hcd_synchronize_unlinks(udev);
2227
2228        if (udev->parent) {
2229                port1 = udev->portnum;
2230                hub = usb_hub_to_struct_hub(udev->parent);
2231                port_dev = hub->ports[port1 - 1];
2232
2233                sysfs_remove_link(&udev->dev.kobj, "port");
2234                sysfs_remove_link(&port_dev->dev.kobj, "device");
2235
2236                /*
2237                 * As usb_port_runtime_resume() de-references udev, make
2238                 * sure no resumes occur during removal
2239                 */
2240                if (!test_and_set_bit(port1, hub->child_usage_bits))
2241                        pm_runtime_get_sync(&port_dev->dev);
2242        }
2243
2244        usb_remove_ep_devs(&udev->ep0);
2245        usb_unlock_device(udev);
2246
2247        /* Unregister the device.  The device driver is responsible
2248         * for de-configuring the device and invoking the remove-device
2249         * notifier chain (used by usbfs and possibly others).
2250         */
2251        device_del(&udev->dev);
2252
2253        /* Free the device number and delete the parent's children[]
2254         * (or root_hub) pointer.
2255         */
2256        release_devnum(udev);
2257
2258        /* Avoid races with recursively_mark_NOTATTACHED() */
2259        spin_lock_irq(&device_state_lock);
2260        *pdev = NULL;
2261        spin_unlock_irq(&device_state_lock);
2262
2263        if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits))
2264                pm_runtime_put(&port_dev->dev);
2265
2266        hub_free_dev(udev);
2267
2268        put_device(&udev->dev);
2269}
2270
2271#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
2272static void show_string(struct usb_device *udev, char *id, char *string)
2273{
2274        if (!string)
2275                return;
2276        dev_info(&udev->dev, "%s: %s\n", id, string);
2277}
2278
2279static void announce_device(struct usb_device *udev)
2280{
2281        u16 bcdDevice = le16_to_cpu(udev->descriptor.bcdDevice);
2282
2283        dev_info(&udev->dev,
2284                "New USB device found, idVendor=%04x, idProduct=%04x, bcdDevice=%2x.%02x\n",
2285                le16_to_cpu(udev->descriptor.idVendor),
2286                le16_to_cpu(udev->descriptor.idProduct),
2287                bcdDevice >> 8, bcdDevice & 0xff);
2288        dev_info(&udev->dev,
2289                "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
2290                udev->descriptor.iManufacturer,
2291                udev->descriptor.iProduct,
2292                udev->descriptor.iSerialNumber);
2293        show_string(udev, "Product", udev->product);
2294        show_string(udev, "Manufacturer", udev->manufacturer);
2295        show_string(udev, "SerialNumber", udev->serial);
2296}
2297#else
2298static inline void announce_device(struct usb_device *udev) { }
2299#endif
2300
2301
2302/**
2303 * usb_enumerate_device_otg - FIXME (usbcore-internal)
2304 * @udev: newly addressed device (in ADDRESS state)
2305 *
2306 * Finish enumeration for On-The-Go devices
2307 *
2308 * Return: 0 if successful. A negative error code otherwise.
2309 */
2310static int usb_enumerate_device_otg(struct usb_device *udev)
2311{
2312        int err = 0;
2313
2314#ifdef  CONFIG_USB_OTG
2315        /*
2316         * OTG-aware devices on OTG-capable root hubs may be able to use SRP,
2317         * to wake us after we've powered off VBUS; and HNP, switching roles
2318         * "host" to "peripheral".  The OTG descriptor helps figure this out.
2319         */
2320        if (!udev->bus->is_b_host
2321                        && udev->config
2322                        && udev->parent == udev->bus->root_hub) {
2323                struct usb_otg_descriptor       *desc = NULL;
2324                struct usb_bus                  *bus = udev->bus;
2325                unsigned                        port1 = udev->portnum;
2326
2327                /* descriptor may appear anywhere in config */
2328                err = __usb_get_extra_descriptor(udev->rawdescriptors[0],
2329                                le16_to_cpu(udev->config[0].desc.wTotalLength),
2330                                USB_DT_OTG, (void **) &desc, sizeof(*desc));
2331                if (err || !(desc->bmAttributes & USB_OTG_HNP))
2332                        return 0;
2333
2334                dev_info(&udev->dev, "Dual-Role OTG device on %sHNP port\n",
2335                                        (port1 == bus->otg_port) ? "" : "non-");
2336
2337                /* enable HNP before suspend, it's simpler */
2338                if (port1 == bus->otg_port) {
2339                        bus->b_hnp_enable = 1;
2340                        err = usb_control_msg(udev,
2341                                usb_sndctrlpipe(udev, 0),
2342                                USB_REQ_SET_FEATURE, 0,
2343                                USB_DEVICE_B_HNP_ENABLE,
2344                                0, NULL, 0,
2345                                USB_CTRL_SET_TIMEOUT);
2346                        if (err < 0) {
2347                                /*
2348                                 * OTG MESSAGE: report errors here,
2349                                 * customize to match your product.
2350                                 */
2351                                dev_err(&udev->dev, "can't set HNP mode: %d\n",
2352                                                                        err);
2353                                bus->b_hnp_enable = 0;
2354                        }
2355                } else if (desc->bLength == sizeof
2356                                (struct usb_otg_descriptor)) {
2357                        /* Set a_alt_hnp_support for legacy otg device */
2358                        err = usb_control_msg(udev,
2359                                usb_sndctrlpipe(udev, 0),
2360                                USB_REQ_SET_FEATURE, 0,
2361                                USB_DEVICE_A_ALT_HNP_SUPPORT,
2362                                0, NULL, 0,
2363                                USB_CTRL_SET_TIMEOUT);
2364                        if (err < 0)
2365                                dev_err(&udev->dev,
2366                                        "set a_alt_hnp_support failed: %d\n",
2367                                        err);
2368                }
2369        }
2370#endif
2371        return err;
2372}
2373
2374
2375/**
2376 * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
2377 * @udev: newly addressed device (in ADDRESS state)
2378 *
2379 * This is only called by usb_new_device() and usb_authorize_device()
2380 * and FIXME -- all comments that apply to them apply here wrt to
2381 * environment.
2382 *
2383 * If the device is WUSB and not authorized, we don't attempt to read
2384 * the string descriptors, as they will be errored out by the device
2385 * until it has been authorized.
2386 *
2387 * Return: 0 if successful. A negative error code otherwise.
2388 */
2389static int usb_enumerate_device(struct usb_device *udev)
2390{
2391        int err;
2392        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2393
2394        if (udev->config == NULL) {
2395                err = usb_get_configuration(udev);
2396                if (err < 0) {
2397                        if (err != -ENODEV)
2398                                dev_err(&udev->dev, "can't read configurations, error %d\n",
2399                                                err);
2400                        return err;
2401                }
2402        }
2403
2404        /* read the standard strings and cache them if present */
2405        udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
2406        udev->manufacturer = usb_cache_string(udev,
2407                                              udev->descriptor.iManufacturer);
2408        udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
2409
2410        err = usb_enumerate_device_otg(udev);
2411        if (err < 0)
2412                return err;
2413
2414        if (IS_ENABLED(CONFIG_USB_OTG_PRODUCTLIST) && hcd->tpl_support &&
2415                !is_targeted(udev)) {
2416                /* Maybe it can talk to us, though we can't talk to it.
2417                 * (Includes HNP test device.)
2418                 */
2419                if (IS_ENABLED(CONFIG_USB_OTG) && (udev->bus->b_hnp_enable
2420                        || udev->bus->is_b_host)) {
2421                        err = usb_port_suspend(udev, PMSG_AUTO_SUSPEND);
2422                        if (err < 0)
2423                                dev_dbg(&udev->dev, "HNP fail, %d\n", err);
2424                }
2425                return -ENOTSUPP;
2426        }
2427
2428        usb_detect_interface_quirks(udev);
2429
2430        return 0;
2431}
2432
2433static void set_usb_port_removable(struct usb_device *udev)
2434{
2435        struct usb_device *hdev = udev->parent;
2436        struct usb_hub *hub;
2437        u8 port = udev->portnum;
2438        u16 wHubCharacteristics;
2439        bool removable = true;
2440
2441        dev_set_removable(&udev->dev, DEVICE_REMOVABLE_UNKNOWN);
2442
2443        if (!hdev)
2444                return;
2445
2446        hub = usb_hub_to_struct_hub(udev->parent);
2447
2448        /*
2449         * If the platform firmware has provided information about a port,
2450         * use that to determine whether it's removable.
2451         */
2452        switch (hub->ports[udev->portnum - 1]->connect_type) {
2453        case USB_PORT_CONNECT_TYPE_HOT_PLUG:
2454                dev_set_removable(&udev->dev, DEVICE_REMOVABLE);
2455                return;
2456        case USB_PORT_CONNECT_TYPE_HARD_WIRED:
2457        case USB_PORT_NOT_USED:
2458                dev_set_removable(&udev->dev, DEVICE_FIXED);
2459                return;
2460        default:
2461                break;
2462        }
2463
2464        /*
2465         * Otherwise, check whether the hub knows whether a port is removable
2466         * or not
2467         */
2468        wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
2469
2470        if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
2471                return;
2472
2473        if (hub_is_superspeed(hdev)) {
2474                if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
2475                                & (1 << port))
2476                        removable = false;
2477        } else {
2478                if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
2479                        removable = false;
2480        }
2481
2482        if (removable)
2483                dev_set_removable(&udev->dev, DEVICE_REMOVABLE);
2484        else
2485                dev_set_removable(&udev->dev, DEVICE_FIXED);
2486
2487}
2488
2489/**
2490 * usb_new_device - perform initial device setup (usbcore-internal)
2491 * @udev: newly addressed device (in ADDRESS state)
2492 *
2493 * This is called with devices which have been detected but not fully
2494 * enumerated.  The device descriptor is available, but not descriptors
2495 * for any device configuration.  The caller must have locked either
2496 * the parent hub (if udev is a normal device) or else the
2497 * usb_bus_idr_lock (if udev is a root hub).  The parent's pointer to
2498 * udev has already been installed, but udev is not yet visible through
2499 * sysfs or other filesystem code.
2500 *
2501 * This call is synchronous, and may not be used in an interrupt context.
2502 *
2503 * Only the hub driver or root-hub registrar should ever call this.
2504 *
2505 * Return: Whether the device is configured properly or not. Zero if the
2506 * interface was registered with the driver core; else a negative errno
2507 * value.
2508 *
2509 */
2510int usb_new_device(struct usb_device *udev)
2511{
2512        int err;
2513
2514        if (udev->parent) {
2515                /* Initialize non-root-hub device wakeup to disabled;
2516                 * device (un)configuration controls wakeup capable
2517                 * sysfs power/wakeup controls wakeup enabled/disabled
2518                 */
2519                device_init_wakeup(&udev->dev, 0);
2520        }
2521
2522        /* Tell the runtime-PM framework the device is active */
2523        pm_runtime_set_active(&udev->dev);
2524        pm_runtime_get_noresume(&udev->dev);
2525        pm_runtime_use_autosuspend(&udev->dev);
2526        pm_runtime_enable(&udev->dev);
2527
2528        /* By default, forbid autosuspend for all devices.  It will be
2529         * allowed for hubs during binding.
2530         */
2531        usb_disable_autosuspend(udev);
2532
2533        err = usb_enumerate_device(udev);       /* Read descriptors */
2534        if (err < 0)
2535                goto fail;
2536        dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
2537                        udev->devnum, udev->bus->busnum,
2538                        (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2539        /* export the usbdev device-node for libusb */
2540        udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
2541                        (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2542
2543        /* Tell the world! */
2544        announce_device(udev);
2545
2546        if (udev->serial)
2547                add_device_randomness(udev->serial, strlen(udev->serial));
2548        if (udev->product)
2549                add_device_randomness(udev->product, strlen(udev->product));
2550        if (udev->manufacturer)
2551                add_device_randomness(udev->manufacturer,
2552                                      strlen(udev->manufacturer));
2553
2554        device_enable_async_suspend(&udev->dev);
2555
2556        /* check whether the hub or firmware marks this port as non-removable */
2557        set_usb_port_removable(udev);
2558
2559        /* Register the device.  The device driver is responsible
2560         * for configuring the device and invoking the add-device
2561         * notifier chain (used by usbfs and possibly others).
2562         */
2563        err = device_add(&udev->dev);
2564        if (err) {
2565                dev_err(&udev->dev, "can't device_add, error %d\n", err);
2566                goto fail;
2567        }
2568
2569        /* Create link files between child device and usb port device. */
2570        if (udev->parent) {
2571                struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2572                int port1 = udev->portnum;
2573                struct usb_port *port_dev = hub->ports[port1 - 1];
2574
2575                err = sysfs_create_link(&udev->dev.kobj,
2576                                &port_dev->dev.kobj, "port");
2577                if (err)
2578                        goto fail;
2579
2580                err = sysfs_create_link(&port_dev->dev.kobj,
2581                                &udev->dev.kobj, "device");
2582                if (err) {
2583                        sysfs_remove_link(&udev->dev.kobj, "port");
2584                        goto fail;
2585                }
2586
2587                if (!test_and_set_bit(port1, hub->child_usage_bits))
2588                        pm_runtime_get_sync(&port_dev->dev);
2589        }
2590
2591        (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
2592        usb_mark_last_busy(udev);
2593        pm_runtime_put_sync_autosuspend(&udev->dev);
2594        return err;
2595
2596fail:
2597        usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2598        pm_runtime_disable(&udev->dev);
2599        pm_runtime_set_suspended(&udev->dev);
2600        return err;
2601}
2602
2603
2604/**
2605 * usb_deauthorize_device - deauthorize a device (usbcore-internal)
2606 * @usb_dev: USB device
2607 *
2608 * Move the USB device to a very basic state where interfaces are disabled
2609 * and the device is in fact unconfigured and unusable.
2610 *
2611 * We share a lock (that we have) with device_del(), so we need to
2612 * defer its call.
2613 *
2614 * Return: 0.
2615 */
2616int usb_deauthorize_device(struct usb_device *usb_dev)
2617{
2618        usb_lock_device(usb_dev);
2619        if (usb_dev->authorized == 0)
2620                goto out_unauthorized;
2621
2622        usb_dev->authorized = 0;
2623        usb_set_configuration(usb_dev, -1);
2624
2625out_unauthorized:
2626        usb_unlock_device(usb_dev);
2627        return 0;
2628}
2629
2630
2631int usb_authorize_device(struct usb_device *usb_dev)
2632{
2633        int result = 0, c;
2634
2635        usb_lock_device(usb_dev);
2636        if (usb_dev->authorized == 1)
2637                goto out_authorized;
2638
2639        result = usb_autoresume_device(usb_dev);
2640        if (result < 0) {
2641                dev_err(&usb_dev->dev,
2642                        "can't autoresume for authorization: %d\n", result);
2643                goto error_autoresume;
2644        }
2645
2646        if (usb_dev->wusb) {
2647                result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
2648                if (result < 0) {
2649                        dev_err(&usb_dev->dev, "can't re-read device descriptor for "
2650                                "authorization: %d\n", result);
2651                        goto error_device_descriptor;
2652                }
2653        }
2654
2655        usb_dev->authorized = 1;
2656        /* Choose and set the configuration.  This registers the interfaces
2657         * with the driver core and lets interface drivers bind to them.
2658         */
2659        c = usb_choose_configuration(usb_dev);
2660        if (c >= 0) {
2661                result = usb_set_configuration(usb_dev, c);
2662                if (result) {
2663                        dev_err(&usb_dev->dev,
2664                                "can't set config #%d, error %d\n", c, result);
2665                        /* This need not be fatal.  The user can try to
2666                         * set other configurations. */
2667                }
2668        }
2669        dev_info(&usb_dev->dev, "authorized to connect\n");
2670
2671error_device_descriptor:
2672        usb_autosuspend_device(usb_dev);
2673error_autoresume:
2674out_authorized:
2675        usb_unlock_device(usb_dev);     /* complements locktree */
2676        return result;
2677}
2678
2679/**
2680 * get_port_ssp_rate - Match the extended port status to SSP rate
2681 * @hdev: The hub device
2682 * @ext_portstatus: extended port status
2683 *
2684 * Match the extended port status speed id to the SuperSpeed Plus sublink speed
2685 * capability attributes. Base on the number of connected lanes and speed,
2686 * return the corresponding enum usb_ssp_rate.
2687 */
2688static enum usb_ssp_rate get_port_ssp_rate(struct usb_device *hdev,
2689                                           u32 ext_portstatus)
2690{
2691        struct usb_ssp_cap_descriptor *ssp_cap = hdev->bos->ssp_cap;
2692        u32 attr;
2693        u8 speed_id;
2694        u8 ssac;
2695        u8 lanes;
2696        int i;
2697
2698        if (!ssp_cap)
2699                goto out;
2700
2701        speed_id = ext_portstatus & USB_EXT_PORT_STAT_RX_SPEED_ID;
2702        lanes = USB_EXT_PORT_RX_LANES(ext_portstatus) + 1;
2703
2704        ssac = le32_to_cpu(ssp_cap->bmAttributes) &
2705                USB_SSP_SUBLINK_SPEED_ATTRIBS;
2706
2707        for (i = 0; i <= ssac; i++) {
2708                u8 ssid;
2709
2710                attr = le32_to_cpu(ssp_cap->bmSublinkSpeedAttr[i]);
2711                ssid = FIELD_GET(USB_SSP_SUBLINK_SPEED_SSID, attr);
2712                if (speed_id == ssid) {
2713                        u16 mantissa;
2714                        u8 lse;
2715                        u8 type;
2716
2717                        /*
2718                         * Note: currently asymmetric lane types are only
2719                         * applicable for SSIC operate in SuperSpeed protocol
2720                         */
2721                        type = FIELD_GET(USB_SSP_SUBLINK_SPEED_ST, attr);
2722                        if (type == USB_SSP_SUBLINK_SPEED_ST_ASYM_RX ||
2723                            type == USB_SSP_SUBLINK_SPEED_ST_ASYM_TX)
2724                                goto out;
2725
2726                        if (FIELD_GET(USB_SSP_SUBLINK_SPEED_LP, attr) !=
2727                            USB_SSP_SUBLINK_SPEED_LP_SSP)
2728                                goto out;
2729
2730                        lse = FIELD_GET(USB_SSP_SUBLINK_SPEED_LSE, attr);
2731                        mantissa = FIELD_GET(USB_SSP_SUBLINK_SPEED_LSM, attr);
2732
2733                        /* Convert to Gbps */
2734                        for (; lse < USB_SSP_SUBLINK_SPEED_LSE_GBPS; lse++)
2735                                mantissa /= 1000;
2736
2737                        if (mantissa >= 10 && lanes == 1)
2738                                return USB_SSP_GEN_2x1;
2739
2740                        if (mantissa >= 10 && lanes == 2)
2741                                return USB_SSP_GEN_2x2;
2742
2743                        if (mantissa >= 5 && lanes == 2)
2744                                return USB_SSP_GEN_1x2;
2745
2746                        goto out;
2747                }
2748        }
2749
2750out:
2751        return USB_SSP_GEN_UNKNOWN;
2752}
2753
2754/* Returns 1 if @hub is a WUSB root hub, 0 otherwise */
2755static unsigned hub_is_wusb(struct usb_hub *hub)
2756{
2757        struct usb_hcd *hcd;
2758        if (hub->hdev->parent != NULL)  /* not a root hub? */
2759                return 0;
2760        hcd = bus_to_hcd(hub->hdev->bus);
2761        return hcd->wireless;
2762}
2763
2764
2765#ifdef CONFIG_USB_FEW_INIT_RETRIES
2766#define PORT_RESET_TRIES        2
2767#define SET_ADDRESS_TRIES       1
2768#define GET_DESCRIPTOR_TRIES    1
2769#define GET_MAXPACKET0_TRIES    1
2770#define PORT_INIT_TRIES         4
2771
2772#else
2773#define PORT_RESET_TRIES        5
2774#define SET_ADDRESS_TRIES       2
2775#define GET_DESCRIPTOR_TRIES    2
2776#define GET_MAXPACKET0_TRIES    3
2777#define PORT_INIT_TRIES         4
2778#endif  /* CONFIG_USB_FEW_INIT_RETRIES */
2779
2780#define HUB_ROOT_RESET_TIME     60      /* times are in msec */
2781#define HUB_SHORT_RESET_TIME    10
2782#define HUB_BH_RESET_TIME       50
2783#define HUB_LONG_RESET_TIME     200
2784#define HUB_RESET_TIMEOUT       800
2785
2786static bool use_new_scheme(struct usb_device *udev, int retry,
2787                           struct usb_port *port_dev)
2788{
2789        int old_scheme_first_port =
2790                (port_dev->quirks & USB_PORT_QUIRK_OLD_SCHEME) ||
2791                old_scheme_first;
2792
2793        /*
2794         * "New scheme" enumeration causes an extra state transition to be
2795         * exposed to an xhci host and causes USB3 devices to receive control
2796         * commands in the default state.  This has been seen to cause
2797         * enumeration failures, so disable this enumeration scheme for USB3
2798         * devices.
2799         */
2800        if (udev->speed >= USB_SPEED_SUPER)
2801                return false;
2802
2803        /*
2804         * If use_both_schemes is set, use the first scheme (whichever
2805         * it is) for the larger half of the retries, then use the other
2806         * scheme.  Otherwise, use the first scheme for all the retries.
2807         */
2808        if (use_both_schemes && retry >= (PORT_INIT_TRIES + 1) / 2)
2809                return old_scheme_first_port;   /* Second half */
2810        return !old_scheme_first_port;          /* First half or all */
2811}
2812
2813/* Is a USB 3.0 port in the Inactive or Compliance Mode state?
2814 * Port warm reset is required to recover
2815 */
2816static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
2817                u16 portstatus)
2818{
2819        u16 link_state;
2820
2821        if (!hub_is_superspeed(hub->hdev))
2822                return false;
2823
2824        if (test_bit(port1, hub->warm_reset_bits))
2825                return true;
2826
2827        link_state = portstatus & USB_PORT_STAT_LINK_STATE;
2828        return link_state == USB_SS_PORT_LS_SS_INACTIVE
2829                || link_state == USB_SS_PORT_LS_COMP_MOD;
2830}
2831
2832static int hub_port_wait_reset(struct usb_hub *hub, int port1,
2833                        struct usb_device *udev, unsigned int delay, bool warm)
2834{
2835        int delay_time, ret;
2836        u16 portstatus;
2837        u16 portchange;
2838        u32 ext_portstatus = 0;
2839
2840        for (delay_time = 0;
2841                        delay_time < HUB_RESET_TIMEOUT;
2842                        delay_time += delay) {
2843                /* wait to give the device a chance to reset */
2844                msleep(delay);
2845
2846                /* read and decode port status */
2847                if (hub_is_superspeedplus(hub->hdev))
2848                        ret = hub_ext_port_status(hub, port1,
2849                                                  HUB_EXT_PORT_STATUS,
2850                                                  &portstatus, &portchange,
2851                                                  &ext_portstatus);
2852                else
2853                        ret = hub_port_status(hub, port1, &portstatus,
2854                                              &portchange);
2855                if (ret < 0)
2856                        return ret;
2857
2858                /*
2859                 * The port state is unknown until the reset completes.
2860                 *
2861                 * On top of that, some chips may require additional time
2862                 * to re-establish a connection after the reset is complete,
2863                 * so also wait for the connection to be re-established.
2864                 */
2865                if (!(portstatus & USB_PORT_STAT_RESET) &&
2866                    (portstatus & USB_PORT_STAT_CONNECTION))
2867                        break;
2868
2869                /* switch to the long delay after two short delay failures */
2870                if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
2871                        delay = HUB_LONG_RESET_TIME;
2872
2873                dev_dbg(&hub->ports[port1 - 1]->dev,
2874                                "not %sreset yet, waiting %dms\n",
2875                                warm ? "warm " : "", delay);
2876        }
2877
2878        if ((portstatus & USB_PORT_STAT_RESET))
2879                return -EBUSY;
2880
2881        if (hub_port_warm_reset_required(hub, port1, portstatus))
2882                return -ENOTCONN;
2883
2884        /* Device went away? */
2885        if (!(portstatus & USB_PORT_STAT_CONNECTION))
2886                return -ENOTCONN;
2887
2888        /* Retry if connect change is set but status is still connected.
2889         * A USB 3.0 connection may bounce if multiple warm resets were issued,
2890         * but the device may have successfully re-connected. Ignore it.
2891         */
2892        if (!hub_is_superspeed(hub->hdev) &&
2893            (portchange & USB_PORT_STAT_C_CONNECTION)) {
2894                usb_clear_port_feature(hub->hdev, port1,
2895                                       USB_PORT_FEAT_C_CONNECTION);
2896                return -EAGAIN;
2897        }
2898
2899        if (!(portstatus & USB_PORT_STAT_ENABLE))
2900                return -EBUSY;
2901
2902        if (!udev)
2903                return 0;
2904
2905        if (hub_is_superspeedplus(hub->hdev)) {
2906                /* extended portstatus Rx and Tx lane count are zero based */
2907                udev->rx_lanes = USB_EXT_PORT_RX_LANES(ext_portstatus) + 1;
2908                udev->tx_lanes = USB_EXT_PORT_TX_LANES(ext_portstatus) + 1;
2909                udev->ssp_rate = get_port_ssp_rate(hub->hdev, ext_portstatus);
2910        } else {
2911                udev->rx_lanes = 1;
2912                udev->tx_lanes = 1;
2913                udev->ssp_rate = USB_SSP_GEN_UNKNOWN;
2914        }
2915        if (hub_is_wusb(hub))
2916                udev->speed = USB_SPEED_WIRELESS;
2917        else if (udev->ssp_rate != USB_SSP_GEN_UNKNOWN)
2918                udev->speed = USB_SPEED_SUPER_PLUS;
2919        else if (hub_is_superspeed(hub->hdev))
2920                udev->speed = USB_SPEED_SUPER;
2921        else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
2922                udev->speed = USB_SPEED_HIGH;
2923        else if (portstatus & USB_PORT_STAT_LOW_SPEED)
2924                udev->speed = USB_SPEED_LOW;
2925        else
2926                udev->speed = USB_SPEED_FULL;
2927        return 0;
2928}
2929
2930/* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
2931static int hub_port_reset(struct usb_hub *hub, int port1,
2932                        struct usb_device *udev, unsigned int delay, bool warm)
2933{
2934        int i, status;
2935        u16 portchange, portstatus;
2936        struct usb_port *port_dev = hub->ports[port1 - 1];
2937        int reset_recovery_time;
2938
2939        if (!hub_is_superspeed(hub->hdev)) {
2940                if (warm) {
2941                        dev_err(hub->intfdev, "only USB3 hub support "
2942                                                "warm reset\n");
2943                        return -EINVAL;
2944                }
2945                /* Block EHCI CF initialization during the port reset.
2946                 * Some companion controllers don't like it when they mix.
2947                 */
2948                down_read(&ehci_cf_port_reset_rwsem);
2949        } else if (!warm) {
2950                /*
2951                 * If the caller hasn't explicitly requested a warm reset,
2952                 * double check and see if one is needed.
2953                 */
2954                if (hub_port_status(hub, port1, &portstatus, &portchange) == 0)
2955                        if (hub_port_warm_reset_required(hub, port1,
2956                                                        portstatus))
2957                                warm = true;
2958        }
2959        clear_bit(port1, hub->warm_reset_bits);
2960
2961        /* Reset the port */
2962        for (i = 0; i < PORT_RESET_TRIES; i++) {
2963                status = set_port_feature(hub->hdev, port1, (warm ?
2964                                        USB_PORT_FEAT_BH_PORT_RESET :
2965                                        USB_PORT_FEAT_RESET));
2966                if (status == -ENODEV) {
2967                        ;       /* The hub is gone */
2968                } else if (status) {
2969                        dev_err(&port_dev->dev,
2970                                        "cannot %sreset (err = %d)\n",
2971                                        warm ? "warm " : "", status);
2972                } else {
2973                        status = hub_port_wait_reset(hub, port1, udev, delay,
2974                                                                warm);
2975                        if (status && status != -ENOTCONN && status != -ENODEV)
2976                                dev_dbg(hub->intfdev,
2977                                                "port_wait_reset: err = %d\n",
2978                                                status);
2979                }
2980
2981                /* Check for disconnect or reset */
2982                if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
2983                        usb_clear_port_feature(hub->hdev, port1,
2984                                        USB_PORT_FEAT_C_RESET);
2985
2986                        if (!hub_is_superspeed(hub->hdev))
2987                                goto done;
2988
2989                        usb_clear_port_feature(hub->hdev, port1,
2990                                        USB_PORT_FEAT_C_BH_PORT_RESET);
2991                        usb_clear_port_feature(hub->hdev, port1,
2992                                        USB_PORT_FEAT_C_PORT_LINK_STATE);
2993
2994                        if (udev)
2995                                usb_clear_port_feature(hub->hdev, port1,
2996                                        USB_PORT_FEAT_C_CONNECTION);
2997
2998                        /*
2999                         * If a USB 3.0 device migrates from reset to an error
3000                         * state, re-issue the warm reset.
3001                         */
3002                        if (hub_port_status(hub, port1,
3003                                        &portstatus, &portchange) < 0)
3004                                goto done;
3005
3006                        if (!hub_port_warm_reset_required(hub, port1,
3007                                        portstatus))
3008                                goto done;
3009
3010                        /*
3011                         * If the port is in SS.Inactive or Compliance Mode, the
3012                         * hot or warm reset failed.  Try another warm reset.
3013                         */
3014                        if (!warm) {
3015                                dev_dbg(&port_dev->dev,
3016                                                "hot reset failed, warm reset\n");
3017                                warm = true;
3018                        }
3019                }
3020
3021                dev_dbg(&port_dev->dev,
3022                                "not enabled, trying %sreset again...\n",
3023                                warm ? "warm " : "");
3024                delay = HUB_LONG_RESET_TIME;
3025        }
3026
3027        dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
3028
3029done:
3030        if (status == 0) {
3031                if (port_dev->quirks & USB_PORT_QUIRK_FAST_ENUM)
3032                        usleep_range(10000, 12000);
3033                else {
3034                        /* TRSTRCY = 10 ms; plus some extra */
3035                        reset_recovery_time = 10 + 40;
3036
3037                        /* Hub needs extra delay after resetting its port. */
3038                        if (hub->hdev->quirks & USB_QUIRK_HUB_SLOW_RESET)
3039                                reset_recovery_time += 100;
3040
3041                        msleep(reset_recovery_time);
3042                }
3043
3044                if (udev) {
3045                        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3046
3047                        update_devnum(udev, 0);
3048                        /* The xHC may think the device is already reset,
3049                         * so ignore the status.
3050                         */
3051                        if (hcd->driver->reset_device)
3052                                hcd->driver->reset_device(hcd, udev);
3053
3054                        usb_set_device_state(udev, USB_STATE_DEFAULT);
3055                }
3056        } else {
3057                if (udev)
3058                        usb_set_device_state(udev, USB_STATE_NOTATTACHED);
3059        }
3060
3061        if (!hub_is_superspeed(hub->hdev))
3062                up_read(&ehci_cf_port_reset_rwsem);
3063
3064        return status;
3065}
3066
3067/* Check if a port is power on */
3068static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
3069{
3070        int ret = 0;
3071
3072        if (hub_is_superspeed(hub->hdev)) {
3073                if (portstatus & USB_SS_PORT_STAT_POWER)
3074                        ret = 1;
3075        } else {
3076                if (portstatus & USB_PORT_STAT_POWER)
3077                        ret = 1;
3078        }
3079
3080        return ret;
3081}
3082
3083static void usb_lock_port(struct usb_port *port_dev)
3084                __acquires(&port_dev->status_lock)
3085{
3086        mutex_lock(&port_dev->status_lock);
3087        __acquire(&port_dev->status_lock);
3088}
3089
3090static void usb_unlock_port(struct usb_port *port_dev)
3091                __releases(&port_dev->status_lock)
3092{
3093        mutex_unlock(&port_dev->status_lock);
3094        __release(&port_dev->status_lock);
3095}
3096
3097#ifdef  CONFIG_PM
3098
3099/* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
3100static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
3101{
3102        int ret = 0;
3103
3104        if (hub_is_superspeed(hub->hdev)) {
3105                if ((portstatus & USB_PORT_STAT_LINK_STATE)
3106                                == USB_SS_PORT_LS_U3)
3107                        ret = 1;
3108        } else {
3109                if (portstatus & USB_PORT_STAT_SUSPEND)
3110                        ret = 1;
3111        }
3112
3113        return ret;
3114}
3115
3116/* Determine whether the device on a port is ready for a normal resume,
3117 * is ready for a reset-resume, or should be disconnected.
3118 */
3119static int check_port_resume_type(struct usb_device *udev,
3120                struct usb_hub *hub, int port1,
3121                int status, u16 portchange, u16 portstatus)
3122{
3123        struct usb_port *port_dev = hub->ports[port1 - 1];
3124        int retries = 3;
3125
3126 retry:
3127        /* Is a warm reset needed to recover the connection? */
3128        if (status == 0 && udev->reset_resume
3129                && hub_port_warm_reset_required(hub, port1, portstatus)) {
3130                /* pass */;
3131        }
3132        /* Is the device still present? */
3133        else if (status || port_is_suspended(hub, portstatus) ||
3134                        !port_is_power_on(hub, portstatus)) {
3135                if (status >= 0)
3136                        status = -ENODEV;
3137        } else if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
3138                if (retries--) {
3139                        usleep_range(200, 300);
3140                        status = hub_port_status(hub, port1, &portstatus,
3141                                                             &portchange);
3142                        goto retry;
3143                }
3144                status = -ENODEV;
3145        }
3146
3147        /* Can't do a normal resume if the port isn't enabled,
3148         * so try a reset-resume instead.
3149         */
3150        else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
3151                if (udev->persist_enabled)
3152                        udev->reset_resume = 1;
3153                else
3154                        status = -ENODEV;
3155        }
3156
3157        if (status) {
3158                dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n",
3159                                portchange, portstatus, status);
3160        } else if (udev->reset_resume) {
3161
3162                /* Late port handoff can set status-change bits */
3163                if (portchange & USB_PORT_STAT_C_CONNECTION)
3164                        usb_clear_port_feature(hub->hdev, port1,
3165                                        USB_PORT_FEAT_C_CONNECTION);
3166                if (portchange & USB_PORT_STAT_C_ENABLE)
3167                        usb_clear_port_feature(hub->hdev, port1,
3168                                        USB_PORT_FEAT_C_ENABLE);
3169
3170                /*
3171                 * Whatever made this reset-resume necessary may have
3172                 * turned on the port1 bit in hub->change_bits.  But after
3173                 * a successful reset-resume we want the bit to be clear;
3174                 * if it was on it would indicate that something happened
3175                 * following the reset-resume.
3176                 */
3177                clear_bit(port1, hub->change_bits);
3178        }
3179
3180        return status;
3181}
3182
3183int usb_disable_ltm(struct usb_device *udev)
3184{
3185        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3186
3187        /* Check if the roothub and device supports LTM. */
3188        if (!usb_device_supports_ltm(hcd->self.root_hub) ||
3189                        !usb_device_supports_ltm(udev))
3190                return 0;
3191
3192        /* Clear Feature LTM Enable can only be sent if the device is
3193         * configured.
3194         */
3195        if (!udev->actconfig)
3196                return 0;
3197
3198        return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3199                        USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
3200                        USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
3201                        USB_CTRL_SET_TIMEOUT);
3202}
3203EXPORT_SYMBOL_GPL(usb_disable_ltm);
3204
3205void usb_enable_ltm(struct usb_device *udev)
3206{
3207        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3208
3209        /* Check if the roothub and device supports LTM. */
3210        if (!usb_device_supports_ltm(hcd->self.root_hub) ||
3211                        !usb_device_supports_ltm(udev))
3212                return;
3213
3214        /* Set Feature LTM Enable can only be sent if the device is
3215         * configured.
3216         */
3217        if (!udev->actconfig)
3218                return;
3219
3220        usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3221                        USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
3222                        USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
3223                        USB_CTRL_SET_TIMEOUT);
3224}
3225EXPORT_SYMBOL_GPL(usb_enable_ltm);
3226
3227/*
3228 * usb_enable_remote_wakeup - enable remote wakeup for a device
3229 * @udev: target device
3230 *
3231 * For USB-2 devices: Set the device's remote wakeup feature.
3232 *
3233 * For USB-3 devices: Assume there's only one function on the device and
3234 * enable remote wake for the first interface.  FIXME if the interface
3235 * association descriptor shows there's more than one function.
3236 */
3237static int usb_enable_remote_wakeup(struct usb_device *udev)
3238{
3239        if (udev->speed < USB_SPEED_SUPER)
3240                return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3241                                USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
3242                                USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
3243                                USB_CTRL_SET_TIMEOUT);
3244        else
3245                return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3246                                USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
3247                                USB_INTRF_FUNC_SUSPEND,
3248                                USB_INTRF_FUNC_SUSPEND_RW |
3249                                        USB_INTRF_FUNC_SUSPEND_LP,
3250                                NULL, 0, USB_CTRL_SET_TIMEOUT);
3251}
3252
3253/*
3254 * usb_disable_remote_wakeup - disable remote wakeup for a device
3255 * @udev: target device
3256 *
3257 * For USB-2 devices: Clear the device's remote wakeup feature.
3258 *
3259 * For USB-3 devices: Assume there's only one function on the device and
3260 * disable remote wake for the first interface.  FIXME if the interface
3261 * association descriptor shows there's more than one function.
3262 */
3263static int usb_disable_remote_wakeup(struct usb_device *udev)
3264{
3265        if (udev->speed < USB_SPEED_SUPER)
3266                return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3267                                USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
3268                                USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
3269                                USB_CTRL_SET_TIMEOUT);
3270        else
3271                return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3272                                USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
3273                                USB_INTRF_FUNC_SUSPEND, 0, NULL, 0,
3274                                USB_CTRL_SET_TIMEOUT);
3275}
3276
3277/* Count of wakeup-enabled devices at or below udev */
3278unsigned usb_wakeup_enabled_descendants(struct usb_device *udev)
3279{
3280        struct usb_hub *hub = usb_hub_to_struct_hub(udev);
3281
3282        return udev->do_remote_wakeup +
3283                        (hub ? hub->wakeup_enabled_descendants : 0);
3284}
3285EXPORT_SYMBOL_GPL(usb_wakeup_enabled_descendants);
3286
3287/*
3288 * usb_port_suspend - suspend a usb device's upstream port
3289 * @udev: device that's no longer in active use, not a root hub
3290 * Context: must be able to sleep; device not locked; pm locks held
3291 *
3292 * Suspends a USB device that isn't in active use, conserving power.
3293 * Devices may wake out of a suspend, if anything important happens,
3294 * using the remote wakeup mechanism.  They may also be taken out of
3295 * suspend by the host, using usb_port_resume().  It's also routine
3296 * to disconnect devices while they are suspended.
3297 *
3298 * This only affects the USB hardware for a device; its interfaces
3299 * (and, for hubs, child devices) must already have been suspended.
3300 *
3301 * Selective port suspend reduces power; most suspended devices draw
3302 * less than 500 uA.  It's also used in OTG, along with remote wakeup.
3303 * All devices below the suspended port are also suspended.
3304 *
3305 * Devices leave suspend state when the host wakes them up.  Some devices
3306 * also support "remote wakeup", where the device can activate the USB
3307 * tree above them to deliver data, such as a keypress or packet.  In
3308 * some cases, this wakes the USB host.
3309 *
3310 * Suspending OTG devices may trigger HNP, if that's been enabled
3311 * between a pair of dual-role devices.  That will change roles, such
3312 * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
3313 *
3314 * Devices on USB hub ports have only one "suspend" state, corresponding
3315 * to ACPI D2, "may cause the device to lose some context".
3316 * State transitions include:
3317 *
3318 *   - suspend, resume ... when the VBUS power link stays live
3319 *   - suspend, disconnect ... VBUS lost
3320 *
3321 * Once VBUS drop breaks the circuit, the port it's using has to go through
3322 * normal re-enumeration procedures, starting with enabling VBUS power.
3323 * Other than re-initializing the hub (plug/unplug, except for root hubs),
3324 * Linux (2.6) currently has NO mechanisms to initiate that:  no hub_wq
3325 * timer, no SRP, no requests through sysfs.
3326 *
3327 * If Runtime PM isn't enabled or used, non-SuperSpeed devices may not get
3328 * suspended until their bus goes into global suspend (i.e., the root
3329 * hub is suspended).  Nevertheless, we change @udev->state to
3330 * USB_STATE_SUSPENDED as this is the device's "logical" state.  The actual
3331 * upstream port setting is stored in @udev->port_is_suspended.
3332 *
3333 * Returns 0 on success, else negative errno.
3334 */
3335int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
3336{
3337        struct usb_hub  *hub = usb_hub_to_struct_hub(udev->parent);
3338        struct usb_port *port_dev = hub->ports[udev->portnum - 1];
3339        int             port1 = udev->portnum;
3340        int             status;
3341        bool            really_suspend = true;
3342
3343        usb_lock_port(port_dev);
3344
3345        /* enable remote wakeup when appropriate; this lets the device
3346         * wake up the upstream hub (including maybe the root hub).
3347         *
3348         * NOTE:  OTG devices may issue remote wakeup (or SRP) even when
3349         * we don't explicitly enable it here.
3350         */
3351        if (udev->do_remote_wakeup) {
3352                status = usb_enable_remote_wakeup(udev);
3353                if (status) {
3354                        dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
3355                                        status);
3356                        /* bail if autosuspend is requested */
3357                        if (PMSG_IS_AUTO(msg))
3358                                goto err_wakeup;
3359                }
3360        }
3361
3362        /* disable USB2 hardware LPM */
3363        usb_disable_usb2_hardware_lpm(udev);
3364
3365        if (usb_disable_ltm(udev)) {
3366                dev_err(&udev->dev, "Failed to disable LTM before suspend\n");
3367                status = -ENOMEM;
3368                if (PMSG_IS_AUTO(msg))
3369                        goto err_ltm;
3370        }
3371
3372        /* see 7.1.7.6 */
3373        if (hub_is_superspeed(hub->hdev))
3374                status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
3375
3376        /*
3377         * For system suspend, we do not need to enable the suspend feature
3378         * on individual USB-2 ports.  The devices will automatically go
3379         * into suspend a few ms after the root hub stops sending packets.
3380         * The USB 2.0 spec calls this "global suspend".
3381         *
3382         * However, many USB hubs have a bug: They don't relay wakeup requests
3383         * from a downstream port if the port's suspend feature isn't on.
3384         * Therefore we will turn on the suspend feature if udev or any of its
3385         * descendants is enabled for remote wakeup.
3386         */
3387        else if (PMSG_IS_AUTO(msg) || usb_wakeup_enabled_descendants(udev) > 0)
3388                status = set_port_feature(hub->hdev, port1,
3389                                USB_PORT_FEAT_SUSPEND);
3390        else {
3391                really_suspend = false;
3392                status = 0;
3393        }
3394        if (status) {
3395                /* Check if the port has been suspended for the timeout case
3396                 * to prevent the suspended port from incorrect handling.
3397                 */
3398                if (status == -ETIMEDOUT) {
3399                        int ret;
3400                        u16 portstatus, portchange;
3401
3402                        portstatus = portchange = 0;
3403                        ret = hub_port_status(hub, port1, &portstatus,
3404                                        &portchange);
3405
3406                        dev_dbg(&port_dev->dev,
3407                                "suspend timeout, status %04x\n", portstatus);
3408
3409                        if (ret == 0 && port_is_suspended(hub, portstatus)) {
3410                                status = 0;
3411                                goto suspend_done;
3412                        }
3413                }
3414
3415                dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status);
3416
3417                /* Try to enable USB3 LTM again */
3418                usb_enable_ltm(udev);
3419 err_ltm:
3420                /* Try to enable USB2 hardware LPM again */
3421                usb_enable_usb2_hardware_lpm(udev);
3422
3423                if (udev->do_remote_wakeup)
3424                        (void) usb_disable_remote_wakeup(udev);
3425 err_wakeup:
3426
3427                /* System sleep transitions should never fail */
3428                if (!PMSG_IS_AUTO(msg))
3429                        status = 0;
3430        } else {
3431 suspend_done:
3432                dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
3433                                (PMSG_IS_AUTO(msg) ? "auto-" : ""),
3434                                udev->do_remote_wakeup);
3435                if (really_suspend) {
3436                        udev->port_is_suspended = 1;
3437
3438                        /* device has up to 10 msec to fully suspend */
3439                        msleep(10);
3440                }
3441                usb_set_device_state(udev, USB_STATE_SUSPENDED);
3442        }
3443
3444        if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled
3445                        && test_and_clear_bit(port1, hub->child_usage_bits))
3446                pm_runtime_put_sync(&port_dev->dev);
3447
3448        usb_mark_last_busy(hub->hdev);
3449
3450        usb_unlock_port(port_dev);
3451        return status;
3452}
3453
3454/*
3455 * If the USB "suspend" state is in use (rather than "global suspend"),
3456 * many devices will be individually taken out of suspend state using
3457 * special "resume" signaling.  This routine kicks in shortly after
3458 * hardware resume signaling is finished, either because of selective
3459 * resume (by host) or remote wakeup (by device) ... now see what changed
3460 * in the tree that's rooted at this device.
3461 *
3462 * If @udev->reset_resume is set then the device is reset before the
3463 * status check is done.
3464 */
3465static int finish_port_resume(struct usb_device *udev)
3466{
3467        int     status = 0;
3468        u16     devstatus = 0;
3469
3470        /* caller owns the udev device lock */
3471        dev_dbg(&udev->dev, "%s\n",
3472                udev->reset_resume ? "finish reset-resume" : "finish resume");
3473
3474        /* usb ch9 identifies four variants of SUSPENDED, based on what
3475         * state the device resumes to.  Linux currently won't see the
3476         * first two on the host side; they'd be inside hub_port_init()
3477         * during many timeouts, but hub_wq can't suspend until later.
3478         */
3479        usb_set_device_state(udev, udev->actconfig
3480                        ? USB_STATE_CONFIGURED
3481                        : USB_STATE_ADDRESS);
3482
3483        /* 10.5.4.5 says not to reset a suspended port if the attached
3484         * device is enabled for remote wakeup.  Hence the reset
3485         * operation is carried out here, after the port has been
3486         * resumed.
3487         */
3488        if (udev->reset_resume) {
3489                /*
3490                 * If the device morphs or switches modes when it is reset,
3491                 * we don't want to perform a reset-resume.  We'll fail the
3492                 * resume, which will cause a logical disconnect, and then
3493                 * the device will be rediscovered.
3494                 */
3495 retry_reset_resume:
3496                if (udev->quirks & USB_QUIRK_RESET)
3497                        status = -ENODEV;
3498                else
3499                        status = usb_reset_and_verify_device(udev);
3500        }
3501
3502        /* 10.5.4.5 says be sure devices in the tree are still there.
3503         * For now let's assume the device didn't go crazy on resume,
3504         * and device drivers will know about any resume quirks.
3505         */
3506        if (status == 0) {
3507                devstatus = 0;
3508                status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
3509
3510                /* If a normal resume failed, try doing a reset-resume */
3511                if (status && !udev->reset_resume && udev->persist_enabled) {
3512                        dev_dbg(&udev->dev, "retry with reset-resume\n");
3513                        udev->reset_resume = 1;
3514                        goto retry_reset_resume;
3515                }
3516        }
3517
3518        if (status) {
3519                dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
3520                                status);
3521        /*
3522         * There are a few quirky devices which violate the standard
3523         * by claiming to have remote wakeup enabled after a reset,
3524         * which crash if the feature is cleared, hence check for
3525         * udev->reset_resume
3526         */
3527        } else if (udev->actconfig && !udev->reset_resume) {
3528                if (udev->speed < USB_SPEED_SUPER) {
3529                        if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
3530                                status = usb_disable_remote_wakeup(udev);
3531                } else {
3532                        status = usb_get_std_status(udev, USB_RECIP_INTERFACE, 0,
3533                                        &devstatus);
3534                        if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
3535                                        | USB_INTRF_STAT_FUNC_RW))
3536                                status = usb_disable_remote_wakeup(udev);
3537                }
3538
3539                if (status)
3540                        dev_dbg(&udev->dev,
3541                                "disable remote wakeup, status %d\n",
3542                                status);
3543                status = 0;
3544        }
3545        return status;
3546}
3547
3548/*
3549 * There are some SS USB devices which take longer time for link training.
3550 * XHCI specs 4.19.4 says that when Link training is successful, port
3551 * sets CCS bit to 1. So if SW reads port status before successful link
3552 * training, then it will not find device to be present.
3553 * USB Analyzer log with such buggy devices show that in some cases
3554 * device switch on the RX termination after long delay of host enabling
3555 * the VBUS. In few other cases it has been seen that device fails to
3556 * negotiate link training in first attempt. It has been
3557 * reported till now that few devices take as long as 2000 ms to train
3558 * the link after host enabling its VBUS and termination. Following
3559 * routine implements a 2000 ms timeout for link training. If in a case
3560 * link trains before timeout, loop will exit earlier.
3561 *
3562 * There are also some 2.0 hard drive based devices and 3.0 thumb
3563 * drives that, when plugged into a 2.0 only port, take a long
3564 * time to set CCS after VBUS enable.
3565 *
3566 * FIXME: If a device was connected before suspend, but was removed
3567 * while system was asleep, then the loop in the following routine will
3568 * only exit at timeout.
3569 *
3570 * This routine should only be called when persist is enabled.
3571 */
3572static int wait_for_connected(struct usb_device *udev,
3573                struct usb_hub *hub, int *port1,
3574                u16 *portchange, u16 *portstatus)
3575{
3576        int status = 0, delay_ms = 0;
3577
3578        while (delay_ms < 2000) {
3579                if (status || *portstatus & USB_PORT_STAT_CONNECTION)
3580                        break;
3581                if (!port_is_power_on(hub, *portstatus)) {
3582                        status = -ENODEV;
3583                        break;
3584                }
3585                msleep(20);
3586                delay_ms += 20;
3587                status = hub_port_status(hub, *port1, portstatus, portchange);
3588        }
3589        dev_dbg(&udev->dev, "Waited %dms for CONNECT\n", delay_ms);
3590        return status;
3591}
3592
3593/*
3594 * usb_port_resume - re-activate a suspended usb device's upstream port
3595 * @udev: device to re-activate, not a root hub
3596 * Context: must be able to sleep; device not locked; pm locks held
3597 *
3598 * This will re-activate the suspended device, increasing power usage
3599 * while letting drivers communicate again with its endpoints.
3600 * USB resume explicitly guarantees that the power session between
3601 * the host and the device is the same as it was when the device
3602 * suspended.
3603 *
3604 * If @udev->reset_resume is set then this routine won't check that the
3605 * port is still enabled.  Furthermore, finish_port_resume() above will
3606 * reset @udev.  The end result is that a broken power session can be
3607 * recovered and @udev will appear to persist across a loss of VBUS power.
3608 *
3609 * For example, if a host controller doesn't maintain VBUS suspend current
3610 * during a system sleep or is reset when the system wakes up, all the USB
3611 * power sessions below it will be broken.  This is especially troublesome
3612 * for mass-storage devices containing mounted filesystems, since the
3613 * device will appear to have disconnected and all the memory mappings
3614 * to it will be lost.  Using the USB_PERSIST facility, the device can be
3615 * made to appear as if it had not disconnected.
3616 *
3617 * This facility can be dangerous.  Although usb_reset_and_verify_device() makes
3618 * every effort to insure that the same device is present after the
3619 * reset as before, it cannot provide a 100% guarantee.  Furthermore it's
3620 * quite possible for a device to remain unaltered but its media to be
3621 * changed.  If the user replaces a flash memory card while the system is
3622 * asleep, he will have only himself to blame when the filesystem on the
3623 * new card is corrupted and the system crashes.
3624 *
3625 * Returns 0 on success, else negative errno.
3626 */
3627int usb_port_resume(struct usb_device *udev, pm_message_t msg)
3628{
3629        struct usb_hub  *hub = usb_hub_to_struct_hub(udev->parent);
3630        struct usb_port *port_dev = hub->ports[udev->portnum  - 1];
3631        int             port1 = udev->portnum;
3632        int             status;
3633        u16             portchange, portstatus;
3634
3635        if (!test_and_set_bit(port1, hub->child_usage_bits)) {
3636                status = pm_runtime_resume_and_get(&port_dev->dev);
3637                if (status < 0) {
3638                        dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
3639                                        status);
3640                        return status;
3641                }
3642        }
3643
3644        usb_lock_port(port_dev);
3645
3646        /* Skip the initial Clear-Suspend step for a remote wakeup */
3647        status = hub_port_status(hub, port1, &portstatus, &portchange);
3648        if (status == 0 && !port_is_suspended(hub, portstatus)) {
3649                if (portchange & USB_PORT_STAT_C_SUSPEND)
3650                        pm_wakeup_event(&udev->dev, 0);
3651                goto SuspendCleared;
3652        }
3653
3654        /* see 7.1.7.7; affects power usage, but not budgeting */
3655        if (hub_is_superspeed(hub->hdev))
3656                status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
3657        else
3658                status = usb_clear_port_feature(hub->hdev,
3659                                port1, USB_PORT_FEAT_SUSPEND);
3660        if (status) {
3661                dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
3662        } else {
3663                /* drive resume for USB_RESUME_TIMEOUT msec */
3664                dev_dbg(&udev->dev, "usb %sresume\n",
3665                                (PMSG_IS_AUTO(msg) ? "auto-" : ""));
3666                msleep(USB_RESUME_TIMEOUT);
3667
3668                /* Virtual root hubs can trigger on GET_PORT_STATUS to
3669                 * stop resume signaling.  Then finish the resume
3670                 * sequence.
3671                 */
3672                status = hub_port_status(hub, port1, &portstatus, &portchange);
3673        }
3674
3675 SuspendCleared:
3676        if (status == 0) {
3677                udev->port_is_suspended = 0;
3678                if (hub_is_superspeed(hub->hdev)) {
3679                        if (portchange & USB_PORT_STAT_C_LINK_STATE)
3680                                usb_clear_port_feature(hub->hdev, port1,
3681                                        USB_PORT_FEAT_C_PORT_LINK_STATE);
3682                } else {
3683                        if (portchange & USB_PORT_STAT_C_SUSPEND)
3684                                usb_clear_port_feature(hub->hdev, port1,
3685                                                USB_PORT_FEAT_C_SUSPEND);
3686                }
3687
3688                /* TRSMRCY = 10 msec */
3689                msleep(10);
3690        }
3691
3692        if (udev->persist_enabled)
3693                status = wait_for_connected(udev, hub, &port1, &portchange,
3694                                &portstatus);
3695
3696        status = check_port_resume_type(udev,
3697                        hub, port1, status, portchange, portstatus);
3698        if (status == 0)
3699                status = finish_port_resume(udev);
3700        if (status < 0) {
3701                dev_dbg(&udev->dev, "can't resume, status %d\n", status);
3702                hub_port_logical_disconnect(hub, port1);
3703        } else  {
3704                /* Try to enable USB2 hardware LPM */
3705                usb_enable_usb2_hardware_lpm(udev);
3706
3707                /* Try to enable USB3 LTM */
3708                usb_enable_ltm(udev);
3709        }
3710
3711        usb_unlock_port(port_dev);
3712
3713        return status;
3714}
3715
3716int usb_remote_wakeup(struct usb_device *udev)
3717{
3718        int     status = 0;
3719
3720        usb_lock_device(udev);
3721        if (udev->state == USB_STATE_SUSPENDED) {
3722                dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
3723                status = usb_autoresume_device(udev);
3724                if (status == 0) {
3725                        /* Let the drivers do their thing, then... */
3726                        usb_autosuspend_device(udev);
3727                }
3728        }
3729        usb_unlock_device(udev);
3730        return status;
3731}
3732
3733/* Returns 1 if there was a remote wakeup and a connect status change. */
3734static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
3735                u16 portstatus, u16 portchange)
3736                __must_hold(&port_dev->status_lock)
3737{
3738        struct usb_port *port_dev = hub->ports[port - 1];
3739        struct usb_device *hdev;
3740        struct usb_device *udev;
3741        int connect_change = 0;
3742        u16 link_state;
3743        int ret;
3744
3745        hdev = hub->hdev;
3746        udev = port_dev->child;
3747        if (!hub_is_superspeed(hdev)) {
3748                if (!(portchange & USB_PORT_STAT_C_SUSPEND))
3749                        return 0;
3750                usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
3751        } else {
3752                link_state = portstatus & USB_PORT_STAT_LINK_STATE;
3753                if (!udev || udev->state != USB_STATE_SUSPENDED ||
3754                                (link_state != USB_SS_PORT_LS_U0 &&
3755                                 link_state != USB_SS_PORT_LS_U1 &&
3756                                 link_state != USB_SS_PORT_LS_U2))
3757                        return 0;
3758        }
3759
3760        if (udev) {
3761                /* TRSMRCY = 10 msec */
3762                msleep(10);
3763
3764                usb_unlock_port(port_dev);
3765                ret = usb_remote_wakeup(udev);
3766                usb_lock_port(port_dev);
3767                if (ret < 0)
3768                        connect_change = 1;
3769        } else {
3770                ret = -ENODEV;
3771                hub_port_disable(hub, port, 1);
3772        }
3773        dev_dbg(&port_dev->dev, "resume, status %d\n", ret);
3774        return connect_change;
3775}
3776
3777static int check_ports_changed(struct usb_hub *hub)
3778{
3779        int port1;
3780
3781        for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) {
3782                u16 portstatus, portchange;
3783                int status;
3784
3785                status = hub_port_status(hub, port1, &portstatus, &portchange);
3786                if (!status && portchange)
3787                        return 1;
3788        }
3789        return 0;
3790}
3791
3792static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
3793{
3794        struct usb_hub          *hub = usb_get_intfdata(intf);
3795        struct usb_device       *hdev = hub->hdev;
3796        unsigned                port1;
3797
3798        /*
3799         * Warn if children aren't already suspended.
3800         * Also, add up the number of wakeup-enabled descendants.
3801         */
3802        hub->wakeup_enabled_descendants = 0;
3803        for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3804                struct usb_port *port_dev = hub->ports[port1 - 1];
3805                struct usb_device *udev = port_dev->child;
3806
3807                if (udev && udev->can_submit) {
3808                        dev_warn(&port_dev->dev, "device %s not suspended yet\n",
3809                                        dev_name(&udev->dev));
3810                        if (PMSG_IS_AUTO(msg))
3811                                return -EBUSY;
3812                }
3813                if (udev)
3814                        hub->wakeup_enabled_descendants +=
3815                                        usb_wakeup_enabled_descendants(udev);
3816        }
3817
3818        if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) {
3819                /* check if there are changes pending on hub ports */
3820                if (check_ports_changed(hub)) {
3821                        if (PMSG_IS_AUTO(msg))
3822                                return -EBUSY;
3823                        pm_wakeup_event(&hdev->dev, 2000);
3824                }
3825        }
3826
3827        if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
3828                /* Enable hub to send remote wakeup for all ports. */
3829                for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3830                        set_port_feature(hdev,
3831                                         port1 |
3832                                         USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
3833                                         USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
3834                                         USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
3835                                         USB_PORT_FEAT_REMOTE_WAKE_MASK);
3836                }
3837        }
3838
3839        dev_dbg(&intf->dev, "%s\n", __func__);
3840
3841        /* stop hub_wq and related activity */
3842        hub_quiesce(hub, HUB_SUSPEND);
3843        return 0;
3844}
3845
3846/* Report wakeup requests from the ports of a resuming root hub */
3847static void report_wakeup_requests(struct usb_hub *hub)
3848{
3849        struct usb_device       *hdev = hub->hdev;
3850        struct usb_device       *udev;
3851        struct usb_hcd          *hcd;
3852        unsigned long           resuming_ports;
3853        int                     i;
3854
3855        if (hdev->parent)
3856                return;         /* Not a root hub */
3857
3858        hcd = bus_to_hcd(hdev->bus);
3859        if (hcd->driver->get_resuming_ports) {
3860
3861                /*
3862                 * The get_resuming_ports() method returns a bitmap (origin 0)
3863                 * of ports which have started wakeup signaling but have not
3864                 * yet finished resuming.  During system resume we will
3865                 * resume all the enabled ports, regardless of any wakeup
3866                 * signals, which means the wakeup requests would be lost.
3867                 * To prevent this, report them to the PM core here.
3868                 */
3869                resuming_ports = hcd->driver->get_resuming_ports(hcd);
3870                for (i = 0; i < hdev->maxchild; ++i) {
3871                        if (test_bit(i, &resuming_ports)) {
3872                                udev = hub->ports[i]->child;
3873                                if (udev)
3874                                        pm_wakeup_event(&udev->dev, 0);
3875                        }
3876                }
3877        }
3878}
3879
3880static int hub_resume(struct usb_interface *intf)
3881{
3882        struct usb_hub *hub = usb_get_intfdata(intf);
3883
3884        dev_dbg(&intf->dev, "%s\n", __func__);
3885        hub_activate(hub, HUB_RESUME);
3886
3887        /*
3888         * This should be called only for system resume, not runtime resume.
3889         * We can't tell the difference here, so some wakeup requests will be
3890         * reported at the wrong time or more than once.  This shouldn't
3891         * matter much, so long as they do get reported.
3892         */
3893        report_wakeup_requests(hub);
3894        return 0;
3895}
3896
3897static int hub_reset_resume(struct usb_interface *intf)
3898{
3899        struct usb_hub *hub = usb_get_intfdata(intf);
3900
3901        dev_dbg(&intf->dev, "%s\n", __func__);
3902        hub_activate(hub, HUB_RESET_RESUME);
3903        return 0;
3904}
3905
3906/**
3907 * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
3908 * @rhdev: struct usb_device for the root hub
3909 *
3910 * The USB host controller driver calls this function when its root hub
3911 * is resumed and Vbus power has been interrupted or the controller
3912 * has been reset.  The routine marks @rhdev as having lost power.
3913 * When the hub driver is resumed it will take notice and carry out
3914 * power-session recovery for all the "USB-PERSIST"-enabled child devices;
3915 * the others will be disconnected.
3916 */
3917void usb_root_hub_lost_power(struct usb_device *rhdev)
3918{
3919        dev_notice(&rhdev->dev, "root hub lost power or was reset\n");
3920        rhdev->reset_resume = 1;
3921}
3922EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
3923
3924static const char * const usb3_lpm_names[]  = {
3925        "U0",
3926        "U1",
3927        "U2",
3928        "U3",
3929};
3930
3931/*
3932 * Send a Set SEL control transfer to the device, prior to enabling
3933 * device-initiated U1 or U2.  This lets the device know the exit latencies from
3934 * the time the device initiates a U1 or U2 exit, to the time it will receive a
3935 * packet from the host.
3936 *
3937 * This function will fail if the SEL or PEL values for udev are greater than
3938 * the maximum allowed values for the link state to be enabled.
3939 */
3940static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
3941{
3942        struct usb_set_sel_req *sel_values;
3943        unsigned long long u1_sel;
3944        unsigned long long u1_pel;
3945        unsigned long long u2_sel;
3946        unsigned long long u2_pel;
3947        int ret;
3948
3949        if (udev->state != USB_STATE_CONFIGURED)
3950                return 0;
3951
3952        /* Convert SEL and PEL stored in ns to us */
3953        u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
3954        u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
3955        u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
3956        u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);
3957
3958        /*
3959         * Make sure that the calculated SEL and PEL values for the link
3960         * state we're enabling aren't bigger than the max SEL/PEL
3961         * value that will fit in the SET SEL control transfer.
3962         * Otherwise the device would get an incorrect idea of the exit
3963         * latency for the link state, and could start a device-initiated
3964         * U1/U2 when the exit latencies are too high.
3965         */
3966        if ((state == USB3_LPM_U1 &&
3967                                (u1_sel > USB3_LPM_MAX_U1_SEL_PEL ||
3968                                 u1_pel > USB3_LPM_MAX_U1_SEL_PEL)) ||
3969                        (state == USB3_LPM_U2 &&
3970                         (u2_sel > USB3_LPM_MAX_U2_SEL_PEL ||
3971                          u2_pel > USB3_LPM_MAX_U2_SEL_PEL))) {
3972                dev_dbg(&udev->dev, "Device-initiated %s disabled due to long SEL %llu us or PEL %llu us\n",
3973                                usb3_lpm_names[state], u1_sel, u1_pel);
3974                return -EINVAL;
3975        }
3976
3977        /*
3978         * If we're enabling device-initiated LPM for one link state,
3979         * but the other link state has a too high SEL or PEL value,
3980         * just set those values to the max in the Set SEL request.
3981         */
3982        if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL)
3983                u1_sel = USB3_LPM_MAX_U1_SEL_PEL;
3984
3985        if (u1_pel > USB3_LPM_MAX_U1_SEL_PEL)
3986                u1_pel = USB3_LPM_MAX_U1_SEL_PEL;
3987
3988        if (u2_sel > USB3_LPM_MAX_U2_SEL_PEL)
3989                u2_sel = USB3_LPM_MAX_U2_SEL_PEL;
3990
3991        if (u2_pel > USB3_LPM_MAX_U2_SEL_PEL)
3992                u2_pel = USB3_LPM_MAX_U2_SEL_PEL;
3993
3994        /*
3995         * usb_enable_lpm() can be called as part of a failed device reset,
3996         * which may be initiated by an error path of a mass storage driver.
3997         * Therefore, use GFP_NOIO.
3998         */
3999        sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
4000        if (!sel_values)
4001                return -ENOMEM;
4002
4003        sel_values->u1_sel = u1_sel;
4004        sel_values->u1_pel = u1_pel;
4005        sel_values->u2_sel = cpu_to_le16(u2_sel);
4006        sel_values->u2_pel = cpu_to_le16(u2_pel);
4007
4008        ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
4009                        USB_REQ_SET_SEL,
4010                        USB_RECIP_DEVICE,
4011                        0, 0,
4012                        sel_values, sizeof *(sel_values),
4013                        USB_CTRL_SET_TIMEOUT);
4014        kfree(sel_values);
4015        return ret;
4016}
4017
4018/*
4019 * Enable or disable device-initiated U1 or U2 transitions.
4020 */
4021static int usb_set_device_initiated_lpm(struct usb_device *udev,
4022                enum usb3_link_state state, bool enable)
4023{
4024        int ret;
4025        int feature;
4026
4027        switch (state) {
4028        case USB3_LPM_U1:
4029                feature = USB_DEVICE_U1_ENABLE;
4030                break;
4031        case USB3_LPM_U2:
4032                feature = USB_DEVICE_U2_ENABLE;
4033                break;
4034        default:
4035                dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n",
4036                                __func__, enable ? "enable" : "disable");
4037                return -EINVAL;
4038        }
4039
4040        if (udev->state != USB_STATE_CONFIGURED) {
4041                dev_dbg(&udev->dev, "%s: Can't %s %s state "
4042                                "for unconfigured device.\n",
4043                                __func__, enable ? "enable" : "disable",
4044                                usb3_lpm_names[state]);
4045                return 0;
4046        }
4047
4048        if (enable) {
4049                /*
4050                 * Now send the control transfer to enable device-initiated LPM
4051                 * for either U1 or U2.
4052                 */
4053                ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
4054                                USB_REQ_SET_FEATURE,
4055                                USB_RECIP_DEVICE,
4056                                feature,
4057                                0, NULL, 0,
4058                                USB_CTRL_SET_TIMEOUT);
4059        } else {
4060                ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
4061                                USB_REQ_CLEAR_FEATURE,
4062                                USB_RECIP_DEVICE,
4063                                feature,
4064                                0, NULL, 0,
4065                                USB_CTRL_SET_TIMEOUT);
4066        }
4067        if (ret < 0) {
4068                dev_warn(&udev->dev, "%s of device-initiated %s failed.\n",
4069                                enable ? "Enable" : "Disable",
4070                                usb3_lpm_names[state]);
4071                return -EBUSY;
4072        }
4073        return 0;
4074}
4075
4076static int usb_set_lpm_timeout(struct usb_device *udev,
4077                enum usb3_link_state state, int timeout)
4078{
4079        int ret;
4080        int feature;
4081
4082        switch (state) {
4083        case USB3_LPM_U1:
4084                feature = USB_PORT_FEAT_U1_TIMEOUT;
4085                break;
4086        case USB3_LPM_U2:
4087                feature = USB_PORT_FEAT_U2_TIMEOUT;
4088                break;
4089        default:
4090                dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n",
4091                                __func__);
4092                return -EINVAL;
4093        }
4094
4095        if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT &&
4096                        timeout != USB3_LPM_DEVICE_INITIATED) {
4097                dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, "
4098                                "which is a reserved value.\n",
4099                                usb3_lpm_names[state], timeout);
4100                return -EINVAL;
4101        }
4102
4103        ret = set_port_feature(udev->parent,
4104                        USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum,
4105                        feature);
4106        if (ret < 0) {
4107                dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x,"
4108                                "error code %i\n", usb3_lpm_names[state],
4109                                timeout, ret);
4110                return -EBUSY;
4111        }
4112        if (state == USB3_LPM_U1)
4113                udev->u1_params.timeout = timeout;
4114        else
4115                udev->u2_params.timeout = timeout;
4116        return 0;
4117}
4118
4119/*
4120 * Don't allow device intiated U1/U2 if the system exit latency + one bus
4121 * interval is greater than the minimum service interval of any active
4122 * periodic endpoint. See USB 3.2 section 9.4.9
4123 */
4124static bool usb_device_may_initiate_lpm(struct usb_device *udev,
4125                                        enum usb3_link_state state)
4126{
4127        unsigned int sel;               /* us */
4128        int i, j;
4129
4130        if (state == USB3_LPM_U1)
4131                sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
4132        else if (state == USB3_LPM_U2)
4133                sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
4134        else
4135                return false;
4136
4137        for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
4138                struct usb_interface *intf;
4139                struct usb_endpoint_descriptor *desc;
4140                unsigned int interval;
4141
4142                intf = udev->actconfig->interface[i];
4143                if (!intf)
4144                        continue;
4145
4146                for (j = 0; j < intf->cur_altsetting->desc.bNumEndpoints; j++) {
4147                        desc = &intf->cur_altsetting->endpoint[j].desc;
4148
4149                        if (usb_endpoint_xfer_int(desc) ||
4150                            usb_endpoint_xfer_isoc(desc)) {
4151                                interval = (1 << (desc->bInterval - 1)) * 125;
4152                                if (sel + 125 > interval)
4153                                        return false;
4154                        }
4155                }
4156        }
4157        return true;
4158}
4159
4160/*
4161 * Enable the hub-initiated U1/U2 idle timeouts, and enable device-initiated
4162 * U1/U2 entry.
4163 *
4164 * We will attempt to enable U1 or U2, but there are no guarantees that the
4165 * control transfers to set the hub timeout or enable device-initiated U1/U2
4166 * will be successful.
4167 *
4168 * If the control transfer to enable device-initiated U1/U2 entry fails, then
4169 * hub-initiated U1/U2 will be disabled.
4170 *
4171 * If we cannot set the parent hub U1/U2 timeout, we attempt to let the xHCI
4172 * driver know about it.  If that call fails, it should be harmless, and just
4173 * take up more slightly more bus bandwidth for unnecessary U1/U2 exit latency.
4174 */
4175static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
4176                enum usb3_link_state state)
4177{
4178        int timeout, ret;
4179        __u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
4180        __le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;
4181
4182        /* If the device says it doesn't have *any* exit latency to come out of
4183         * U1 or U2, it's probably lying.  Assume it doesn't implement that link
4184         * state.
4185         */
4186        if ((state == USB3_LPM_U1 && u1_mel == 0) ||
4187                        (state == USB3_LPM_U2 && u2_mel == 0))
4188                return;
4189
4190        /*
4191         * First, let the device know about the exit latencies
4192         * associated with the link state we're about to enable.
4193         */
4194        ret = usb_req_set_sel(udev, state);
4195        if (ret < 0) {
4196                dev_warn(&udev->dev, "Set SEL for device-initiated %s failed.\n",
4197                                usb3_lpm_names[state]);
4198                return;
4199        }
4200
4201        /* We allow the host controller to set the U1/U2 timeout internally
4202         * first, so that it can change its schedule to account for the
4203         * additional latency to send data to a device in a lower power
4204         * link state.
4205         */
4206        timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state);
4207
4208        /* xHCI host controller doesn't want to enable this LPM state. */
4209        if (timeout == 0)
4210                return;
4211
4212        if (timeout < 0) {
4213                dev_warn(&udev->dev, "Could not enable %s link state, "
4214                                "xHCI error %i.\n", usb3_lpm_names[state],
4215                                timeout);
4216                return;
4217        }
4218
4219        if (usb_set_lpm_timeout(udev, state, timeout)) {
4220                /* If we can't set the parent hub U1/U2 timeout,
4221                 * device-initiated LPM won't be allowed either, so let the xHCI
4222                 * host know that this link state won't be enabled.
4223                 */
4224                hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
4225                return;
4226        }
4227
4228        /* Only a configured device will accept the Set Feature
4229         * U1/U2_ENABLE
4230         */
4231        if (udev->actconfig &&
4232            usb_device_may_initiate_lpm(udev, state)) {
4233                if (usb_set_device_initiated_lpm(udev, state, true)) {
4234                        /*
4235                         * Request to enable device initiated U1/U2 failed,
4236                         * better to turn off lpm in this case.
4237                         */
4238                        usb_set_lpm_timeout(udev, state, 0);
4239                        hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
4240                        return;
4241                }
4242        }
4243
4244        if (state == USB3_LPM_U1)
4245                udev->usb3_lpm_u1_enabled = 1;
4246        else if (state == USB3_LPM_U2)
4247                udev->usb3_lpm_u2_enabled = 1;
4248}
4249/*
4250 * Disable the hub-initiated U1/U2 idle timeouts, and disable device-initiated
4251 * U1/U2 entry.
4252 *
4253 * If this function returns -EBUSY, the parent hub will still allow U1/U2 entry.
4254 * If zero is returned, the parent will not allow the link to go into U1/U2.
4255 *
4256 * If zero is returned, device-initiated U1/U2 entry may still be enabled, but
4257 * it won't have an effect on the bus link state because the parent hub will
4258 * still disallow device-initiated U1/U2 entry.
4259 *
4260 * If zero is returned, the xHCI host controller may still think U1/U2 entry is
4261 * possible.  The result will be slightly more bus bandwidth will be taken up
4262 * (to account for U1/U2 exit latency), but it should be harmless.
4263 */
4264static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
4265                enum usb3_link_state state)
4266{
4267        switch (state) {
4268        case USB3_LPM_U1:
4269        case USB3_LPM_U2:
4270                break;
4271        default:
4272                dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n",
4273                                __func__);
4274                return -EINVAL;
4275        }
4276
4277        if (usb_set_lpm_timeout(udev, state, 0))
4278                return -EBUSY;
4279
4280        usb_set_device_initiated_lpm(udev, state, false);
4281
4282        if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state))
4283                dev_warn(&udev->dev, "Could not disable xHCI %s timeout, "
4284                                "bus schedule bandwidth may be impacted.\n",
4285                                usb3_lpm_names[state]);
4286
4287        /* As soon as usb_set_lpm_timeout(0) return 0, hub initiated LPM
4288         * is disabled. Hub will disallows link to enter U1/U2 as well,
4289         * even device is initiating LPM. Hence LPM is disabled if hub LPM
4290         * timeout set to 0, no matter device-initiated LPM is disabled or
4291         * not.
4292         */
4293        if (state == USB3_LPM_U1)
4294                udev->usb3_lpm_u1_enabled = 0;
4295        else if (state == USB3_LPM_U2)
4296                udev->usb3_lpm_u2_enabled = 0;
4297
4298        return 0;
4299}
4300
4301/*
4302 * Disable hub-initiated and device-initiated U1 and U2 entry.
4303 * Caller must own the bandwidth_mutex.
4304 *
4305 * This will call usb_enable_lpm() on failure, which will decrement
4306 * lpm_disable_count, and will re-enable LPM if lpm_disable_count reaches zero.
4307 */
4308int usb_disable_lpm(struct usb_device *udev)
4309{
4310        struct usb_hcd *hcd;
4311
4312        if (!udev || !udev->parent ||
4313                        udev->speed < USB_SPEED_SUPER ||
4314                        !udev->lpm_capable ||
4315                        udev->state < USB_STATE_CONFIGURED)
4316                return 0;
4317
4318        hcd = bus_to_hcd(udev->bus);
4319        if (!hcd || !hcd->driver->disable_usb3_lpm_timeout)
4320                return 0;
4321
4322        udev->lpm_disable_count++;
4323        if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
4324                return 0;
4325
4326        /* If LPM is enabled, attempt to disable it. */
4327        if (usb_disable_link_state(hcd, udev, USB3_LPM_U1))
4328                goto enable_lpm;
4329        if (usb_disable_link_state(hcd, udev, USB3_LPM_U2))
4330                goto enable_lpm;
4331
4332        return 0;
4333
4334enable_lpm:
4335        usb_enable_lpm(udev);
4336        return -EBUSY;
4337}
4338EXPORT_SYMBOL_GPL(usb_disable_lpm);
4339
4340/* Grab the bandwidth_mutex before calling usb_disable_lpm() */
4341int usb_unlocked_disable_lpm(struct usb_device *udev)
4342{
4343        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4344        int ret;
4345
4346        if (!hcd)
4347                return -EINVAL;
4348
4349        mutex_lock(hcd->bandwidth_mutex);
4350        ret = usb_disable_lpm(udev);
4351        mutex_unlock(hcd->bandwidth_mutex);
4352
4353        return ret;
4354}
4355EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4356
4357/*
4358 * Attempt to enable device-initiated and hub-initiated U1 and U2 entry.  The
4359 * xHCI host policy may prevent U1 or U2 from being enabled.
4360 *
4361 * Other callers may have disabled link PM, so U1 and U2 entry will be disabled
4362 * until the lpm_disable_count drops to zero.  Caller must own the
4363 * bandwidth_mutex.
4364 */
4365void usb_enable_lpm(struct usb_device *udev)
4366{
4367        struct usb_hcd *hcd;
4368        struct usb_hub *hub;
4369        struct usb_port *port_dev;
4370
4371        if (!udev || !udev->parent ||
4372                        udev->speed < USB_SPEED_SUPER ||
4373                        !udev->lpm_capable ||
4374                        udev->state < USB_STATE_CONFIGURED)
4375                return;
4376
4377        udev->lpm_disable_count--;
4378        hcd = bus_to_hcd(udev->bus);
4379        /* Double check that we can both enable and disable LPM.
4380         * Device must be configured to accept set feature U1/U2 timeout.
4381         */
4382        if (!hcd || !hcd->driver->enable_usb3_lpm_timeout ||
4383                        !hcd->driver->disable_usb3_lpm_timeout)
4384                return;
4385
4386        if (udev->lpm_disable_count > 0)
4387                return;
4388
4389        hub = usb_hub_to_struct_hub(udev->parent);
4390        if (!hub)
4391                return;
4392
4393        port_dev = hub->ports[udev->portnum - 1];
4394
4395        if (port_dev->usb3_lpm_u1_permit)
4396                usb_enable_link_state(hcd, udev, USB3_LPM_U1);
4397
4398        if (port_dev->usb3_lpm_u2_permit)
4399                usb_enable_link_state(hcd, udev, USB3_LPM_U2);
4400}
4401EXPORT_SYMBOL_GPL(usb_enable_lpm);
4402
4403/* Grab the bandwidth_mutex before calling usb_enable_lpm() */
4404void usb_unlocked_enable_lpm(struct usb_device *udev)
4405{
4406        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4407
4408        if (!hcd)
4409                return;
4410
4411        mutex_lock(hcd->bandwidth_mutex);
4412        usb_enable_lpm(udev);
4413        mutex_unlock(hcd->bandwidth_mutex);
4414}
4415EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4416
4417/* usb3 devices use U3 for disabled, make sure remote wakeup is disabled */
4418static void hub_usb3_port_prepare_disable(struct usb_hub *hub,
4419                                          struct usb_port *port_dev)
4420{
4421        struct usb_device *udev = port_dev->child;
4422        int ret;
4423
4424        if (udev && udev->port_is_suspended && udev->do_remote_wakeup) {
4425                ret = hub_set_port_link_state(hub, port_dev->portnum,
4426                                              USB_SS_PORT_LS_U0);
4427                if (!ret) {
4428                        msleep(USB_RESUME_TIMEOUT);
4429                        ret = usb_disable_remote_wakeup(udev);
4430                }
4431                if (ret)
4432                        dev_warn(&udev->dev,
4433                                 "Port disable: can't disable remote wake\n");
4434                udev->do_remote_wakeup = 0;
4435        }
4436}
4437
4438#else   /* CONFIG_PM */
4439
4440#define hub_suspend             NULL
4441#define hub_resume              NULL
4442#define hub_reset_resume        NULL
4443
4444static inline void hub_usb3_port_prepare_disable(struct usb_hub *hub,
4445                                                 struct usb_port *port_dev) { }
4446
4447int usb_disable_lpm(struct usb_device *udev)
4448{
4449        return 0;
4450}
4451EXPORT_SYMBOL_GPL(usb_disable_lpm);
4452
4453void usb_enable_lpm(struct usb_device *udev) { }
4454EXPORT_SYMBOL_GPL(usb_enable_lpm);
4455
4456int usb_unlocked_disable_lpm(struct usb_device *udev)
4457{
4458        return 0;
4459}
4460EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4461
4462void usb_unlocked_enable_lpm(struct usb_device *udev) { }
4463EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4464
4465int usb_disable_ltm(struct usb_device *udev)
4466{
4467        return 0;
4468}
4469EXPORT_SYMBOL_GPL(usb_disable_ltm);
4470
4471void usb_enable_ltm(struct usb_device *udev) { }
4472EXPORT_SYMBOL_GPL(usb_enable_ltm);
4473
4474static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
4475                u16 portstatus, u16 portchange)
4476{
4477        return 0;
4478}
4479
4480#endif  /* CONFIG_PM */
4481
4482/*
4483 * USB-3 does not have a similar link state as USB-2 that will avoid negotiating
4484 * a connection with a plugged-in cable but will signal the host when the cable
4485 * is unplugged. Disable remote wake and set link state to U3 for USB-3 devices
4486 */
4487static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
4488{
4489        struct usb_port *port_dev = hub->ports[port1 - 1];
4490        struct usb_device *hdev = hub->hdev;
4491        int ret = 0;
4492
4493        if (!hub->error) {
4494                if (hub_is_superspeed(hub->hdev)) {
4495                        hub_usb3_port_prepare_disable(hub, port_dev);
4496                        ret = hub_set_port_link_state(hub, port_dev->portnum,
4497                                                      USB_SS_PORT_LS_U3);
4498                } else {
4499                        ret = usb_clear_port_feature(hdev, port1,
4500                                        USB_PORT_FEAT_ENABLE);
4501                }
4502        }
4503        if (port_dev->child && set_state)
4504                usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
4505        if (ret && ret != -ENODEV)
4506                dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
4507        return ret;
4508}
4509
4510/*
4511 * usb_port_disable - disable a usb device's upstream port
4512 * @udev: device to disable
4513 * Context: @udev locked, must be able to sleep.
4514 *
4515 * Disables a USB device that isn't in active use.
4516 */
4517int usb_port_disable(struct usb_device *udev)
4518{
4519        struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
4520
4521        return hub_port_disable(hub, udev->portnum, 0);
4522}
4523
4524/* USB 2.0 spec, 7.1.7.3 / fig 7-29:
4525 *
4526 * Between connect detection and reset signaling there must be a delay
4527 * of 100ms at least for debounce and power-settling.  The corresponding
4528 * timer shall restart whenever the downstream port detects a disconnect.
4529 *
4530 * Apparently there are some bluetooth and irda-dongles and a number of
4531 * low-speed devices for which this debounce period may last over a second.
4532 * Not covered by the spec - but easy to deal with.
4533 *
4534 * This implementation uses a 1500ms total debounce timeout; if the
4535 * connection isn't stable by then it returns -ETIMEDOUT.  It checks
4536 * every 25ms for transient disconnects.  When the port status has been
4537 * unchanged for 100ms it returns the port status.
4538 */
4539int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
4540{
4541        int ret;
4542        u16 portchange, portstatus;
4543        unsigned connection = 0xffff;
4544        int total_time, stable_time = 0;
4545        struct usb_port *port_dev = hub->ports[port1 - 1];
4546
4547        for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
4548                ret = hub_port_status(hub, port1, &portstatus, &portchange);
4549                if (ret < 0)
4550                        return ret;
4551
4552                if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
4553                     (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
4554                        if (!must_be_connected ||
4555                             (connection == USB_PORT_STAT_CONNECTION))
4556                                stable_time += HUB_DEBOUNCE_STEP;
4557                        if (stable_time >= HUB_DEBOUNCE_STABLE)
4558                                break;
4559                } else {
4560                        stable_time = 0;
4561                        connection = portstatus & USB_PORT_STAT_CONNECTION;
4562                }
4563
4564                if (portchange & USB_PORT_STAT_C_CONNECTION) {
4565                        usb_clear_port_feature(hub->hdev, port1,
4566                                        USB_PORT_FEAT_C_CONNECTION);
4567                }
4568
4569                if (total_time >= HUB_DEBOUNCE_TIMEOUT)
4570                        break;
4571                msleep(HUB_DEBOUNCE_STEP);
4572        }
4573
4574        dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n",
4575                        total_time, stable_time, portstatus);
4576
4577        if (stable_time < HUB_DEBOUNCE_STABLE)
4578                return -ETIMEDOUT;
4579        return portstatus;
4580}
4581
4582void usb_ep0_reinit(struct usb_device *udev)
4583{
4584        usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
4585        usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
4586        usb_enable_endpoint(udev, &udev->ep0, true);
4587}
4588EXPORT_SYMBOL_GPL(usb_ep0_reinit);
4589
4590#define usb_sndaddr0pipe()      (PIPE_CONTROL << 30)
4591#define usb_rcvaddr0pipe()      ((PIPE_CONTROL << 30) | USB_DIR_IN)
4592
4593static int hub_set_address(struct usb_device *udev, int devnum)