/drivers/usb/core/hub.c
https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t · C · 4051 lines · 2699 code · 486 blank · 866 comment · 636 complexity · 391473d5e0cab8c688aa1a8fac051e4a MD5 · raw file
Large files are truncated click here to view the full file
- /*
- * USB hub driver.
- *
- * (C) Copyright 1999 Linus Torvalds
- * (C) Copyright 1999 Johannes Erdfelt
- * (C) Copyright 1999 Gregory P. Smith
- * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
- *
- */
- #include <linux/kernel.h>
- #include <linux/errno.h>
- #include <linux/module.h>
- #include <linux/moduleparam.h>
- #include <linux/completion.h>
- #include <linux/sched.h>
- #include <linux/list.h>
- #include <linux/slab.h>
- #include <linux/ioctl.h>
- #include <linux/usb.h>
- #include <linux/usbdevice_fs.h>
- #include <linux/usb/hcd.h>
- #include <linux/usb/quirks.h>
- #include <linux/kthread.h>
- #include <linux/mutex.h>
- #include <linux/freezer.h>
- #include <asm/uaccess.h>
- #include <asm/byteorder.h>
- #include "usb.h"
- /* if we are in debug mode, always announce new devices */
- #ifdef DEBUG
- #ifndef CONFIG_USB_ANNOUNCE_NEW_DEVICES
- #define CONFIG_USB_ANNOUNCE_NEW_DEVICES
- #endif
- #endif
- struct usb_hub {
- struct device *intfdev; /* the "interface" device */
- struct usb_device *hdev;
- struct kref kref;
- struct urb *urb; /* for interrupt polling pipe */
- /* buffer for urb ... with extra space in case of babble */
- char (*buffer)[8];
- union {
- struct usb_hub_status hub;
- struct usb_port_status port;
- } *status; /* buffer for status reports */
- struct mutex status_mutex; /* for the status buffer */
- int error; /* last reported error */
- int nerrors; /* track consecutive errors */
- struct list_head event_list; /* hubs w/data or errs ready */
- unsigned long event_bits[1]; /* status change bitmask */
- unsigned long change_bits[1]; /* ports with logical connect
- status change */
- unsigned long busy_bits[1]; /* ports being reset or
- resumed */
- unsigned long removed_bits[1]; /* ports with a "removed"
- device present */
- #if USB_MAXCHILDREN > 31 /* 8*sizeof(unsigned long) - 1 */
- #error event_bits[] is too short!
- #endif
- struct usb_hub_descriptor *descriptor; /* class descriptor */
- struct usb_tt tt; /* Transaction Translator */
- unsigned mA_per_port; /* current for each child */
- unsigned limited_power:1;
- unsigned quiescing:1;
- unsigned disconnected:1;
- unsigned has_indicators:1;
- u8 indicator[USB_MAXCHILDREN];
- struct delayed_work leds;
- struct delayed_work init_work;
- void **port_owners;
- };
- static inline int hub_is_superspeed(struct usb_device *hdev)
- {
- return (hdev->descriptor.bDeviceProtocol == 3);
- }
- /* Protect struct usb_device->state and ->children members
- * Note: Both are also protected by ->dev.sem, except that ->state can
- * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
- static DEFINE_SPINLOCK(device_state_lock);
- /* khubd's worklist and its lock */
- static DEFINE_SPINLOCK(hub_event_lock);
- static LIST_HEAD(hub_event_list); /* List of hubs needing servicing */
- /* Wakes up khubd */
- static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
- static struct task_struct *khubd_task;
- /* cycle leds on hubs that aren't blinking for attention */
- static int blinkenlights = 0;
- module_param (blinkenlights, bool, S_IRUGO);
- MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");
- /*
- * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about
- * 10 seconds to send reply for the initial 64-byte descriptor request.
- */
- /* define initial 64-byte descriptor request timeout in milliseconds */
- static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
- module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
- MODULE_PARM_DESC(initial_descriptor_timeout,
- "initial 64-byte descriptor request timeout in milliseconds "
- "(default 5000 - 5.0 seconds)");
- /*
- * As of 2.6.10 we introduce a new USB device initialization scheme which
- * closely resembles the way Windows works. Hopefully it will be compatible
- * with a wider range of devices than the old scheme. However some previously
- * working devices may start giving rise to "device not accepting address"
- * errors; if that happens the user can try the old scheme by adjusting the
- * following module parameters.
- *
- * For maximum flexibility there are two boolean parameters to control the
- * hub driver's behavior. On the first initialization attempt, if the
- * "old_scheme_first" parameter is set then the old scheme will be used,
- * otherwise the new scheme is used. If that fails and "use_both_schemes"
- * is set, then the driver will make another attempt, using the other scheme.
- */
- static int old_scheme_first = 0;
- module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
- MODULE_PARM_DESC(old_scheme_first,
- "start with the old device initialization scheme");
- static int use_both_schemes = 1;
- module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
- MODULE_PARM_DESC(use_both_schemes,
- "try the other device initialization scheme if the "
- "first one fails");
- /* Mutual exclusion for EHCI CF initialization. This interferes with
- * port reset on some companion controllers.
- */
- DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
- EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
- #define HUB_DEBOUNCE_TIMEOUT 1500
- #define HUB_DEBOUNCE_STEP 25
- #define HUB_DEBOUNCE_STABLE 100
- static int usb_reset_and_verify_device(struct usb_device *udev);
- static inline char *portspeed(struct usb_hub *hub, int portstatus)
- {
- if (hub_is_superspeed(hub->hdev))
- return "5.0 Gb/s";
- if (portstatus & USB_PORT_STAT_HIGH_SPEED)
- return "480 Mb/s";
- else if (portstatus & USB_PORT_STAT_LOW_SPEED)
- return "1.5 Mb/s";
- else
- return "12 Mb/s";
- }
- /* Note that hdev or one of its children must be locked! */
- static struct usb_hub *hdev_to_hub(struct usb_device *hdev)
- {
- if (!hdev || !hdev->actconfig)
- return NULL;
- return usb_get_intfdata(hdev->actconfig->interface[0]);
- }
- /* USB 2.0 spec Section 11.24.4.5 */
- static int get_hub_descriptor(struct usb_device *hdev, void *data)
- {
- int i, ret, size;
- unsigned dtype;
- if (hub_is_superspeed(hdev)) {
- dtype = USB_DT_SS_HUB;
- size = USB_DT_SS_HUB_SIZE;
- } else {
- dtype = USB_DT_HUB;
- size = sizeof(struct usb_hub_descriptor);
- }
- for (i = 0; i < 3; i++) {
- ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
- USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
- dtype << 8, 0, data, size,
- USB_CTRL_GET_TIMEOUT);
- if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
- return ret;
- }
- return -EINVAL;
- }
- /*
- * USB 2.0 spec Section 11.24.2.1
- */
- static int clear_hub_feature(struct usb_device *hdev, int feature)
- {
- return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
- USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
- }
- /*
- * USB 2.0 spec Section 11.24.2.2
- */
- static int clear_port_feature(struct usb_device *hdev, int port1, int feature)
- {
- return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
- USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
- NULL, 0, 1000);
- }
- /*
- * USB 2.0 spec Section 11.24.2.13
- */
- static int set_port_feature(struct usb_device *hdev, int port1, int feature)
- {
- return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
- USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
- NULL, 0, 1000);
- }
- /*
- * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
- * for info about using port indicators
- */
- static void set_port_led(
- struct usb_hub *hub,
- int port1,
- int selector
- )
- {
- int status = set_port_feature(hub->hdev, (selector << 8) | port1,
- USB_PORT_FEAT_INDICATOR);
- if (status < 0)
- dev_dbg (hub->intfdev,
- "port %d indicator %s status %d\n",
- port1,
- ({ char *s; switch (selector) {
- case HUB_LED_AMBER: s = "amber"; break;
- case HUB_LED_GREEN: s = "green"; break;
- case HUB_LED_OFF: s = "off"; break;
- case HUB_LED_AUTO: s = "auto"; break;
- default: s = "??"; break;
- }; s; }),
- status);
- }
- #define LED_CYCLE_PERIOD ((2*HZ)/3)
- static void led_work (struct work_struct *work)
- {
- struct usb_hub *hub =
- container_of(work, struct usb_hub, leds.work);
- struct usb_device *hdev = hub->hdev;
- unsigned i;
- unsigned changed = 0;
- int cursor = -1;
- if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
- return;
- for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
- unsigned selector, mode;
- /* 30%-50% duty cycle */
- switch (hub->indicator[i]) {
- /* cycle marker */
- case INDICATOR_CYCLE:
- cursor = i;
- selector = HUB_LED_AUTO;
- mode = INDICATOR_AUTO;
- break;
- /* blinking green = sw attention */
- case INDICATOR_GREEN_BLINK:
- selector = HUB_LED_GREEN;
- mode = INDICATOR_GREEN_BLINK_OFF;
- break;
- case INDICATOR_GREEN_BLINK_OFF:
- selector = HUB_LED_OFF;
- mode = INDICATOR_GREEN_BLINK;
- break;
- /* blinking amber = hw attention */
- case INDICATOR_AMBER_BLINK:
- selector = HUB_LED_AMBER;
- mode = INDICATOR_AMBER_BLINK_OFF;
- break;
- case INDICATOR_AMBER_BLINK_OFF:
- selector = HUB_LED_OFF;
- mode = INDICATOR_AMBER_BLINK;
- break;
- /* blink green/amber = reserved */
- case INDICATOR_ALT_BLINK:
- selector = HUB_LED_GREEN;
- mode = INDICATOR_ALT_BLINK_OFF;
- break;
- case INDICATOR_ALT_BLINK_OFF:
- selector = HUB_LED_AMBER;
- mode = INDICATOR_ALT_BLINK;
- break;
- default:
- continue;
- }
- if (selector != HUB_LED_AUTO)
- changed = 1;
- set_port_led(hub, i + 1, selector);
- hub->indicator[i] = mode;
- }
- if (!changed && blinkenlights) {
- cursor++;
- cursor %= hub->descriptor->bNbrPorts;
- set_port_led(hub, cursor + 1, HUB_LED_GREEN);
- hub->indicator[cursor] = INDICATOR_CYCLE;
- changed++;
- }
- if (changed)
- schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
- }
- /* use a short timeout for hub/port status fetches */
- #define USB_STS_TIMEOUT 1000
- #define USB_STS_RETRIES 5
- /*
- * USB 2.0 spec Section 11.24.2.6
- */
- static int get_hub_status(struct usb_device *hdev,
- struct usb_hub_status *data)
- {
- int i, status = -ETIMEDOUT;
- for (i = 0; i < USB_STS_RETRIES &&
- (status == -ETIMEDOUT || status == -EPIPE); i++) {
- status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
- USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
- data, sizeof(*data), USB_STS_TIMEOUT);
- }
- return status;
- }
- /*
- * USB 2.0 spec Section 11.24.2.7
- */
- static int get_port_status(struct usb_device *hdev, int port1,
- struct usb_port_status *data)
- {
- int i, status = -ETIMEDOUT;
- for (i = 0; i < USB_STS_RETRIES &&
- (status == -ETIMEDOUT || status == -EPIPE); i++) {
- status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
- USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
- data, sizeof(*data), USB_STS_TIMEOUT);
- }
- return status;
- }
- static int hub_port_status(struct usb_hub *hub, int port1,
- u16 *status, u16 *change)
- {
- int ret;
- mutex_lock(&hub->status_mutex);
- ret = get_port_status(hub->hdev, port1, &hub->status->port);
- if (ret < 4) {
- dev_err(hub->intfdev,
- "%s failed (err = %d)\n", __func__, ret);
- if (ret >= 0)
- ret = -EIO;
- } else {
- *status = le16_to_cpu(hub->status->port.wPortStatus);
- *change = le16_to_cpu(hub->status->port.wPortChange);
- ret = 0;
- }
- mutex_unlock(&hub->status_mutex);
- return ret;
- }
- static void kick_khubd(struct usb_hub *hub)
- {
- unsigned long flags;
- spin_lock_irqsave(&hub_event_lock, flags);
- if (!hub->disconnected && list_empty(&hub->event_list)) {
- list_add_tail(&hub->event_list, &hub_event_list);
- /* Suppress autosuspend until khubd runs */
- usb_autopm_get_interface_no_resume(
- to_usb_interface(hub->intfdev));
- wake_up(&khubd_wait);
- }
- spin_unlock_irqrestore(&hub_event_lock, flags);
- }
- void usb_kick_khubd(struct usb_device *hdev)
- {
- struct usb_hub *hub = hdev_to_hub(hdev);
- if (hub)
- kick_khubd(hub);
- }
- /* completion function, fires on port status changes and various faults */
- static void hub_irq(struct urb *urb)
- {
- struct usb_hub *hub = urb->context;
- int status = urb->status;
- unsigned i;
- unsigned long bits;
- switch (status) {
- case -ENOENT: /* synchronous unlink */
- case -ECONNRESET: /* async unlink */
- case -ESHUTDOWN: /* hardware going away */
- return;
- default: /* presumably an error */
- /* Cause a hub reset after 10 consecutive errors */
- dev_dbg (hub->intfdev, "transfer --> %d\n", status);
- if ((++hub->nerrors < 10) || hub->error)
- goto resubmit;
- hub->error = status;
- /* FALL THROUGH */
- /* let khubd handle things */
- case 0: /* we got data: port status changed */
- bits = 0;
- for (i = 0; i < urb->actual_length; ++i)
- bits |= ((unsigned long) ((*hub->buffer)[i]))
- << (i*8);
- hub->event_bits[0] = bits;
- break;
- }
- hub->nerrors = 0;
- /* Something happened, let khubd figure it out */
- kick_khubd(hub);
- resubmit:
- if (hub->quiescing)
- return;
- if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
- && status != -ENODEV && status != -EPERM)
- dev_err (hub->intfdev, "resubmit --> %d\n", status);
- }
- /* USB 2.0 spec Section 11.24.2.3 */
- static inline int
- hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
- {
- return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
- HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
- tt, NULL, 0, 1000);
- }
- /*
- * enumeration blocks khubd for a long time. we use keventd instead, since
- * long blocking there is the exception, not the rule. accordingly, HCDs
- * talking to TTs must queue control transfers (not just bulk and iso), so
- * both can talk to the same hub concurrently.
- */
- static void hub_tt_work(struct work_struct *work)
- {
- struct usb_hub *hub =
- container_of(work, struct usb_hub, tt.clear_work);
- unsigned long flags;
- int limit = 100;
- spin_lock_irqsave (&hub->tt.lock, flags);
- while (--limit && !list_empty (&hub->tt.clear_list)) {
- struct list_head *next;
- struct usb_tt_clear *clear;
- struct usb_device *hdev = hub->hdev;
- const struct hc_driver *drv;
- int status;
- next = hub->tt.clear_list.next;
- clear = list_entry (next, struct usb_tt_clear, clear_list);
- list_del (&clear->clear_list);
- /* drop lock so HCD can concurrently report other TT errors */
- spin_unlock_irqrestore (&hub->tt.lock, flags);
- status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
- if (status)
- dev_err (&hdev->dev,
- "clear tt %d (%04x) error %d\n",
- clear->tt, clear->devinfo, status);
- /* Tell the HCD, even if the operation failed */
- drv = clear->hcd->driver;
- if (drv->clear_tt_buffer_complete)
- (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
- kfree(clear);
- spin_lock_irqsave(&hub->tt.lock, flags);
- }
- spin_unlock_irqrestore (&hub->tt.lock, flags);
- }
- /**
- * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
- * @urb: an URB associated with the failed or incomplete split transaction
- *
- * High speed HCDs use this to tell the hub driver that some split control or
- * bulk transaction failed in a way that requires clearing internal state of
- * a transaction translator. This is normally detected (and reported) from
- * interrupt context.
- *
- * It may not be possible for that hub to handle additional full (or low)
- * speed transactions until that state is fully cleared out.
- */
- int usb_hub_clear_tt_buffer(struct urb *urb)
- {
- struct usb_device *udev = urb->dev;
- int pipe = urb->pipe;
- struct usb_tt *tt = udev->tt;
- unsigned long flags;
- struct usb_tt_clear *clear;
- /* we've got to cope with an arbitrary number of pending TT clears,
- * since each TT has "at least two" buffers that can need it (and
- * there can be many TTs per hub). even if they're uncommon.
- */
- if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) {
- dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
- /* FIXME recover somehow ... RESET_TT? */
- return -ENOMEM;
- }
- /* info that CLEAR_TT_BUFFER needs */
- clear->tt = tt->multi ? udev->ttport : 1;
- clear->devinfo = usb_pipeendpoint (pipe);
- clear->devinfo |= udev->devnum << 4;
- clear->devinfo |= usb_pipecontrol (pipe)
- ? (USB_ENDPOINT_XFER_CONTROL << 11)
- : (USB_ENDPOINT_XFER_BULK << 11);
- if (usb_pipein (pipe))
- clear->devinfo |= 1 << 15;
- /* info for completion callback */
- clear->hcd = bus_to_hcd(udev->bus);
- clear->ep = urb->ep;
- /* tell keventd to clear state for this TT */
- spin_lock_irqsave (&tt->lock, flags);
- list_add_tail (&clear->clear_list, &tt->clear_list);
- schedule_work(&tt->clear_work);
- spin_unlock_irqrestore (&tt->lock, flags);
- return 0;
- }
- EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
- /* If do_delay is false, return the number of milliseconds the caller
- * needs to delay.
- */
- static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
- {
- int port1;
- unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
- unsigned delay;
- u16 wHubCharacteristics =
- le16_to_cpu(hub->descriptor->wHubCharacteristics);
- /* Enable power on each port. Some hubs have reserved values
- * of LPSM (> 2) in their descriptors, even though they are
- * USB 2.0 hubs. Some hubs do not implement port-power switching
- * but only emulate it. In all cases, the ports won't work
- * unless we send these messages to the hub.
- */
- if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
- dev_dbg(hub->intfdev, "enabling power on all ports\n");
- else
- dev_dbg(hub->intfdev, "trying to enable port power on "
- "non-switchable hub\n");
- for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
- set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
- /* Wait at least 100 msec for power to become stable */
- delay = max(pgood_delay, (unsigned) 100);
- if (do_delay)
- msleep(delay);
- return delay;
- }
- static int hub_hub_status(struct usb_hub *hub,
- u16 *status, u16 *change)
- {
- int ret;
- mutex_lock(&hub->status_mutex);
- ret = get_hub_status(hub->hdev, &hub->status->hub);
- if (ret < 0)
- dev_err (hub->intfdev,
- "%s failed (err = %d)\n", __func__, ret);
- else {
- *status = le16_to_cpu(hub->status->hub.wHubStatus);
- *change = le16_to_cpu(hub->status->hub.wHubChange);
- ret = 0;
- }
- mutex_unlock(&hub->status_mutex);
- return ret;
- }
- static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
- {
- struct usb_device *hdev = hub->hdev;
- int ret = 0;
- if (hdev->children[port1-1] && set_state)
- usb_set_device_state(hdev->children[port1-1],
- USB_STATE_NOTATTACHED);
- if (!hub->error && !hub_is_superspeed(hub->hdev))
- ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
- if (ret)
- dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
- port1, ret);
- return ret;
- }
- /*
- * Disable a port and mark a logical connect-change event, so that some
- * time later khubd will disconnect() any existing usb_device on the port
- * and will re-enumerate if there actually is a device attached.
- */
- static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
- {
- dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
- hub_port_disable(hub, port1, 1);
- /* FIXME let caller ask to power down the port:
- * - some devices won't enumerate without a VBUS power cycle
- * - SRP saves power that way
- * - ... new call, TBD ...
- * That's easy if this hub can switch power per-port, and
- * khubd reactivates the port later (timer, SRP, etc).
- * Powerdown must be optional, because of reset/DFU.
- */
- set_bit(port1, hub->change_bits);
- kick_khubd(hub);
- }
- /**
- * usb_remove_device - disable a device's port on its parent hub
- * @udev: device to be disabled and removed
- * Context: @udev locked, must be able to sleep.
- *
- * After @udev's port has been disabled, khubd is notified and it will
- * see that the device has been disconnected. When the device is
- * physically unplugged and something is plugged in, the events will
- * be received and processed normally.
- */
- int usb_remove_device(struct usb_device *udev)
- {
- struct usb_hub *hub;
- struct usb_interface *intf;
- if (!udev->parent) /* Can't remove a root hub */
- return -EINVAL;
- hub = hdev_to_hub(udev->parent);
- intf = to_usb_interface(hub->intfdev);
- usb_autopm_get_interface(intf);
- set_bit(udev->portnum, hub->removed_bits);
- hub_port_logical_disconnect(hub, udev->portnum);
- usb_autopm_put_interface(intf);
- return 0;
- }
- enum hub_activation_type {
- HUB_INIT, HUB_INIT2, HUB_INIT3, /* INITs must come first */
- HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
- };
- static void hub_init_func2(struct work_struct *ws);
- static void hub_init_func3(struct work_struct *ws);
- static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
- {
- struct usb_device *hdev = hub->hdev;
- struct usb_hcd *hcd;
- int ret;
- int port1;
- int status;
- bool need_debounce_delay = false;
- unsigned delay;
- /* Continue a partial initialization */
- if (type == HUB_INIT2)
- goto init2;
- if (type == HUB_INIT3)
- goto init3;
- /* After a resume, port power should still be on.
- * For any other type of activation, turn it on.
- */
- if (type != HUB_RESUME) {
- /* Speed up system boot by using a delayed_work for the
- * hub's initial power-up delays. This is pretty awkward
- * and the implementation looks like a home-brewed sort of
- * setjmp/longjmp, but it saves at least 100 ms for each
- * root hub (assuming usbcore is compiled into the kernel
- * rather than as a module). It adds up.
- *
- * This can't be done for HUB_RESUME or HUB_RESET_RESUME
- * because for those activation types the ports have to be
- * operational when we return. In theory this could be done
- * for HUB_POST_RESET, but it's easier not to.
- */
- if (type == HUB_INIT) {
- delay = hub_power_on(hub, false);
- PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func2);
- schedule_delayed_work(&hub->init_work,
- msecs_to_jiffies(delay));
- /* Suppress autosuspend until init is done */
- usb_autopm_get_interface_no_resume(
- to_usb_interface(hub->intfdev));
- return; /* Continues at init2: below */
- } else if (type == HUB_RESET_RESUME) {
- /* The internal host controller state for the hub device
- * may be gone after a host power loss on system resume.
- * Update the device's info so the HW knows it's a hub.
- */
- hcd = bus_to_hcd(hdev->bus);
- if (hcd->driver->update_hub_device) {
- ret = hcd->driver->update_hub_device(hcd, hdev,
- &hub->tt, GFP_NOIO);
- if (ret < 0) {
- dev_err(hub->intfdev, "Host not "
- "accepting hub info "
- "update.\n");
- dev_err(hub->intfdev, "LS/FS devices "
- "and hubs may not work "
- "under this hub\n.");
- }
- }
- hub_power_on(hub, true);
- } else {
- hub_power_on(hub, true);
- }
- }
- init2:
- /* Check each port and set hub->change_bits to let khubd know
- * which ports need attention.
- */
- for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
- struct usb_device *udev = hdev->children[port1-1];
- u16 portstatus, portchange;
- portstatus = portchange = 0;
- status = hub_port_status(hub, port1, &portstatus, &portchange);
- if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
- dev_dbg(hub->intfdev,
- "port %d: status %04x change %04x\n",
- port1, portstatus, portchange);
- /* After anything other than HUB_RESUME (i.e., initialization
- * or any sort of reset), every port should be disabled.
- * Unconnected ports should likewise be disabled (paranoia),
- * and so should ports for which we have no usb_device.
- */
- if ((portstatus & USB_PORT_STAT_ENABLE) && (
- type != HUB_RESUME ||
- !(portstatus & USB_PORT_STAT_CONNECTION) ||
- !udev ||
- udev->state == USB_STATE_NOTATTACHED)) {
- /*
- * USB3 protocol ports will automatically transition
- * to Enabled state when detect an USB3.0 device attach.
- * Do not disable USB3 protocol ports.
- */
- if (!hub_is_superspeed(hdev)) {
- clear_port_feature(hdev, port1,
- USB_PORT_FEAT_ENABLE);
- portstatus &= ~USB_PORT_STAT_ENABLE;
- } else {
- /* Pretend that power was lost for USB3 devs */
- portstatus &= ~USB_PORT_STAT_ENABLE;
- }
- }
- /* Clear status-change flags; we'll debounce later */
- if (portchange & USB_PORT_STAT_C_CONNECTION) {
- need_debounce_delay = true;
- clear_port_feature(hub->hdev, port1,
- USB_PORT_FEAT_C_CONNECTION);
- }
- if (portchange & USB_PORT_STAT_C_ENABLE) {
- need_debounce_delay = true;
- clear_port_feature(hub->hdev, port1,
- USB_PORT_FEAT_C_ENABLE);
- }
- if (portchange & USB_PORT_STAT_C_LINK_STATE) {
- need_debounce_delay = true;
- clear_port_feature(hub->hdev, port1,
- USB_PORT_FEAT_C_PORT_LINK_STATE);
- }
- if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
- hub_is_superspeed(hub->hdev)) {
- need_debounce_delay = true;
- clear_port_feature(hub->hdev, port1,
- USB_PORT_FEAT_C_BH_PORT_RESET);
- }
- /* We can forget about a "removed" device when there's a
- * physical disconnect or the connect status changes.
- */
- if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
- (portchange & USB_PORT_STAT_C_CONNECTION))
- clear_bit(port1, hub->removed_bits);
- if (!udev || udev->state == USB_STATE_NOTATTACHED) {
- /* Tell khubd to disconnect the device or
- * check for a new connection
- */
- if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
- set_bit(port1, hub->change_bits);
- } else if (portstatus & USB_PORT_STAT_ENABLE) {
- /* The power session apparently survived the resume.
- * If there was an overcurrent or suspend change
- * (i.e., remote wakeup request), have khubd
- * take care of it.
- */
- if (portchange)
- set_bit(port1, hub->change_bits);
- } else if (udev->persist_enabled) {
- #ifdef CONFIG_PM
- udev->reset_resume = 1;
- #endif
- set_bit(port1, hub->change_bits);
- } else {
- /* The power session is gone; tell khubd */
- usb_set_device_state(udev, USB_STATE_NOTATTACHED);
- set_bit(port1, hub->change_bits);
- }
- }
- /* If no port-status-change flags were set, we don't need any
- * debouncing. If flags were set we can try to debounce the
- * ports all at once right now, instead of letting khubd do them
- * one at a time later on.
- *
- * If any port-status changes do occur during this delay, khubd
- * will see them later and handle them normally.
- */
- if (need_debounce_delay) {
- delay = HUB_DEBOUNCE_STABLE;
- /* Don't do a long sleep inside a workqueue routine */
- if (type == HUB_INIT2) {
- PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func3);
- schedule_delayed_work(&hub->init_work,
- msecs_to_jiffies(delay));
- return; /* Continues at init3: below */
- } else {
- msleep(delay);
- }
- }
- init3:
- hub->quiescing = 0;
- status = usb_submit_urb(hub->urb, GFP_NOIO);
- if (status < 0)
- dev_err(hub->intfdev, "activate --> %d\n", status);
- if (hub->has_indicators && blinkenlights)
- schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
- /* Scan all ports that need attention */
- kick_khubd(hub);
- /* Allow autosuspend if it was suppressed */
- if (type <= HUB_INIT3)
- usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
- }
- /* Implement the continuations for the delays above */
- static void hub_init_func2(struct work_struct *ws)
- {
- struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
- hub_activate(hub, HUB_INIT2);
- }
- static void hub_init_func3(struct work_struct *ws)
- {
- struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
- hub_activate(hub, HUB_INIT3);
- }
- enum hub_quiescing_type {
- HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
- };
- static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
- {
- struct usb_device *hdev = hub->hdev;
- int i;
- cancel_delayed_work_sync(&hub->init_work);
- /* khubd and related activity won't re-trigger */
- hub->quiescing = 1;
- if (type != HUB_SUSPEND) {
- /* Disconnect all the children */
- for (i = 0; i < hdev->maxchild; ++i) {
- if (hdev->children[i])
- usb_disconnect(&hdev->children[i]);
- }
- }
- /* Stop khubd and related activity */
- usb_kill_urb(hub->urb);
- if (hub->has_indicators)
- cancel_delayed_work_sync(&hub->leds);
- if (hub->tt.hub)
- cancel_work_sync(&hub->tt.clear_work);
- }
- /* caller has locked the hub device */
- static int hub_pre_reset(struct usb_interface *intf)
- {
- struct usb_hub *hub = usb_get_intfdata(intf);
- hub_quiesce(hub, HUB_PRE_RESET);
- return 0;
- }
- /* caller has locked the hub device */
- static int hub_post_reset(struct usb_interface *intf)
- {
- struct usb_hub *hub = usb_get_intfdata(intf);
- hub_activate(hub, HUB_POST_RESET);
- return 0;
- }
- static int hub_configure(struct usb_hub *hub,
- struct usb_endpoint_descriptor *endpoint)
- {
- struct usb_hcd *hcd;
- struct usb_device *hdev = hub->hdev;
- struct device *hub_dev = hub->intfdev;
- u16 hubstatus, hubchange;
- u16 wHubCharacteristics;
- unsigned int pipe;
- int maxp, ret;
- char *message = "out of memory";
- hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
- if (!hub->buffer) {
- ret = -ENOMEM;
- goto fail;
- }
- hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
- if (!hub->status) {
- ret = -ENOMEM;
- goto fail;
- }
- mutex_init(&hub->status_mutex);
- hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
- if (!hub->descriptor) {
- ret = -ENOMEM;
- goto fail;
- }
- if (hub_is_superspeed(hdev) && (hdev->parent != NULL)) {
- ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
- HUB_SET_DEPTH, USB_RT_HUB,
- hdev->level - 1, 0, NULL, 0,
- USB_CTRL_SET_TIMEOUT);
- if (ret < 0) {
- message = "can't set hub depth";
- goto fail;
- }
- }
- /* Request the entire hub descriptor.
- * hub->descriptor can handle USB_MAXCHILDREN ports,
- * but the hub can/will return fewer bytes here.
- */
- ret = get_hub_descriptor(hdev, hub->descriptor);
- if (ret < 0) {
- message = "can't read hub descriptor";
- goto fail;
- } else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
- message = "hub has too many ports!";
- ret = -ENODEV;
- goto fail;
- }
- hdev->maxchild = hub->descriptor->bNbrPorts;
- dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
- (hdev->maxchild == 1) ? "" : "s");
- hub->port_owners = kzalloc(hdev->maxchild * sizeof(void *), GFP_KERNEL);
- if (!hub->port_owners) {
- ret = -ENOMEM;
- goto fail;
- }
- wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
- /* FIXME for USB 3.0, skip for now */
- if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
- !(hub_is_superspeed(hdev))) {
- int i;
- char portstr [USB_MAXCHILDREN + 1];
- for (i = 0; i < hdev->maxchild; i++)
- portstr[i] = hub->descriptor->u.hs.DeviceRemovable
- [((i + 1) / 8)] & (1 << ((i + 1) % 8))
- ? 'F' : 'R';
- portstr[hdev->maxchild] = 0;
- dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
- } else
- dev_dbg(hub_dev, "standalone hub\n");
- switch (wHubCharacteristics & HUB_CHAR_LPSM) {
- case 0x00:
- dev_dbg(hub_dev, "ganged power switching\n");
- break;
- case 0x01:
- dev_dbg(hub_dev, "individual port power switching\n");
- break;
- case 0x02:
- case 0x03:
- dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
- break;
- }
- switch (wHubCharacteristics & HUB_CHAR_OCPM) {
- case 0x00:
- dev_dbg(hub_dev, "global over-current protection\n");
- break;
- case 0x08:
- dev_dbg(hub_dev, "individual port over-current protection\n");
- break;
- case 0x10:
- case 0x18:
- dev_dbg(hub_dev, "no over-current protection\n");
- break;
- }
- spin_lock_init (&hub->tt.lock);
- INIT_LIST_HEAD (&hub->tt.clear_list);
- INIT_WORK(&hub->tt.clear_work, hub_tt_work);
- switch (hdev->descriptor.bDeviceProtocol) {
- case 0:
- break;
- case 1:
- dev_dbg(hub_dev, "Single TT\n");
- hub->tt.hub = hdev;
- break;
- case 2:
- ret = usb_set_interface(hdev, 0, 1);
- if (ret == 0) {
- dev_dbg(hub_dev, "TT per port\n");
- hub->tt.multi = 1;
- } else
- dev_err(hub_dev, "Using single TT (err %d)\n",
- ret);
- hub->tt.hub = hdev;
- break;
- case 3:
- /* USB 3.0 hubs don't have a TT */
- break;
- default:
- dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
- hdev->descriptor.bDeviceProtocol);
- break;
- }
- /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
- switch (wHubCharacteristics & HUB_CHAR_TTTT) {
- case HUB_TTTT_8_BITS:
- if (hdev->descriptor.bDeviceProtocol != 0) {
- hub->tt.think_time = 666;
- dev_dbg(hub_dev, "TT requires at most %d "
- "FS bit times (%d ns)\n",
- 8, hub->tt.think_time);
- }
- break;
- case HUB_TTTT_16_BITS:
- hub->tt.think_time = 666 * 2;
- dev_dbg(hub_dev, "TT requires at most %d "
- "FS bit times (%d ns)\n",
- 16, hub->tt.think_time);
- break;
- case HUB_TTTT_24_BITS:
- hub->tt.think_time = 666 * 3;
- dev_dbg(hub_dev, "TT requires at most %d "
- "FS bit times (%d ns)\n",
- 24, hub->tt.think_time);
- break;
- case HUB_TTTT_32_BITS:
- hub->tt.think_time = 666 * 4;
- dev_dbg(hub_dev, "TT requires at most %d "
- "FS bit times (%d ns)\n",
- 32, hub->tt.think_time);
- break;
- }
- /* probe() zeroes hub->indicator[] */
- if (wHubCharacteristics & HUB_CHAR_PORTIND) {
- hub->has_indicators = 1;
- dev_dbg(hub_dev, "Port indicators are supported\n");
- }
- dev_dbg(hub_dev, "power on to power good time: %dms\n",
- hub->descriptor->bPwrOn2PwrGood * 2);
- /* power budgeting mostly matters with bus-powered hubs,
- * and battery-powered root hubs (may provide just 8 mA).
- */
- ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
- if (ret < 2) {
- message = "can't get hub status";
- goto fail;
- }
- le16_to_cpus(&hubstatus);
- if (hdev == hdev->bus->root_hub) {
- if (hdev->bus_mA == 0 || hdev->bus_mA >= 500)
- hub->mA_per_port = 500;
- else {
- hub->mA_per_port = hdev->bus_mA;
- hub->limited_power = 1;
- }
- } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
- dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
- hub->descriptor->bHubContrCurrent);
- hub->limited_power = 1;
- if (hdev->maxchild > 0) {
- int remaining = hdev->bus_mA -
- hub->descriptor->bHubContrCurrent;
- if (remaining < hdev->maxchild * 100)
- dev_warn(hub_dev,
- "insufficient power available "
- "to use all downstream ports\n");
- hub->mA_per_port = 100; /* 7.2.1.1 */
- }
- } else { /* Self-powered external hub */
- /* FIXME: What about battery-powered external hubs that
- * provide less current per port? */
- hub->mA_per_port = 500;
- }
- if (hub->mA_per_port < 500)
- dev_dbg(hub_dev, "%umA bus power budget for each child\n",
- hub->mA_per_port);
- /* Update the HCD's internal representation of this hub before khubd
- * starts getting port status changes for devices under the hub.
- */
- hcd = bus_to_hcd(hdev->bus);
- if (hcd->driver->update_hub_device) {
- ret = hcd->driver->update_hub_device(hcd, hdev,
- &hub->tt, GFP_KERNEL);
- if (ret < 0) {
- message = "can't update HCD hub info";
- goto fail;
- }
- }
- ret = hub_hub_status(hub, &hubstatus, &hubchange);
- if (ret < 0) {
- message = "can't get hub status";
- goto fail;
- }
- /* local power status reports aren't always correct */
- if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
- dev_dbg(hub_dev, "local power source is %s\n",
- (hubstatus & HUB_STATUS_LOCAL_POWER)
- ? "lost (inactive)" : "good");
- if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
- dev_dbg(hub_dev, "%sover-current condition exists\n",
- (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
- /* set up the interrupt endpoint
- * We use the EP's maxpacket size instead of (PORTS+1+7)/8
- * bytes as USB2.0[11.12.3] says because some hubs are known
- * to send more data (and thus cause overflow). For root hubs,
- * maxpktsize is defined in hcd.c's fake endpoint descriptors
- * to be big enough for at least USB_MAXCHILDREN ports. */
- pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
- maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
- if (maxp > sizeof(*hub->buffer))
- maxp = sizeof(*hub->buffer);
- hub->urb = usb_alloc_urb(0, GFP_KERNEL);
- if (!hub->urb) {
- ret = -ENOMEM;
- goto fail;
- }
- usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
- hub, endpoint->bInterval);
- /* maybe cycle the hub leds */
- if (hub->has_indicators && blinkenlights)
- hub->indicator [0] = INDICATOR_CYCLE;
- hub_activate(hub, HUB_INIT);
- return 0;
- fail:
- dev_err (hub_dev, "config failed, %s (err %d)\n",
- message, ret);
- /* hub_disconnect() frees urb and descriptor */
- return ret;
- }
- static void hub_release(struct kref *kref)
- {
- struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
- usb_put_intf(to_usb_interface(hub->intfdev));
- kfree(hub);
- }
- static unsigned highspeed_hubs;
- static void hub_disconnect(struct usb_interface *intf)
- {
- struct usb_hub *hub = usb_get_intfdata (intf);
- /* Take the hub off the event list and don't let it be added again */
- spin_lock_irq(&hub_event_lock);
- if (!list_empty(&hub->event_list)) {
- list_del_init(&hub->event_list);
- usb_autopm_put_interface_no_suspend(intf);
- }
- hub->disconnected = 1;
- spin_unlock_irq(&hub_event_lock);
- /* Disconnect all children and quiesce the hub */
- hub->error = 0;
- hub_quiesce(hub, HUB_DISCONNECT);
- usb_set_intfdata (intf, NULL);
- hub->hdev->maxchild = 0;
- if (hub->hdev->speed == USB_SPEED_HIGH)
- highspeed_hubs--;
- usb_free_urb(hub->urb);
- kfree(hub->port_owners);
- kfree(hub->descriptor);
- kfree(hub->status);
- kfree(hub->buffer);
- kref_put(&hub->kref, hub_release);
- }
- static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
- {
- struct usb_host_interface *desc;
- struct usb_endpoint_descriptor *endpoint;
- struct usb_device *hdev;
- struct usb_hub *hub;
- desc = intf->cur_altsetting;
- hdev = interface_to_usbdev(intf);
- /* Hubs have proper suspend/resume support. USB 3.0 device suspend is
- * different from USB 2.0/1.1 device suspend, and unfortunately we
- * don't support it yet. So leave autosuspend disabled for USB 3.0
- * external hubs for now. Enable autosuspend for USB 3.0 roothubs,
- * since that isn't a "real" hub.
- */
- if (!hub_is_superspeed(hdev) || !hdev->parent)
- usb_enable_autosuspend(hdev);
- if (hdev->level == MAX_TOPO_LEVEL) {
- dev_err(&intf->dev,
- "Unsupported bus topology: hub nested too deep\n");
- return -E2BIG;
- }
- #ifdef CONFIG_USB_OTG_BLACKLIST_HUB
- if (hdev->parent) {
- dev_warn(&intf->dev, "ignoring external hub\n");
- return -ENODEV;
- }
- #endif
- /* Some hubs have a subclass of 1, which AFAICT according to the */
- /* specs is not defined, but it works */
- if ((desc->desc.bInterfaceSubClass != 0) &&
- (desc->desc.bInterfaceSubClass != 1)) {
- descriptor_error:
- dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
- return -EIO;
- }
- /* Multiple endpoints? What kind of mutant ninja-hub is this? */
- if (desc->desc.bNumEndpoints != 1)
- goto descriptor_error;
- endpoint = &desc->endpoint[0].desc;
- /* If it's not an interrupt in endpoint, we'd better punt! */
- if (!usb_endpoint_is_int_in(endpoint))
- goto descriptor_error;
- /* We found a hub */
- dev_info (&intf->dev, "USB hub found\n");
- hub = kzalloc(sizeof(*hub), GFP_KERNEL);
- if (!hub) {
- dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
- return -ENOMEM;
- }
- kref_init(&hub->kref);
- INIT_LIST_HEAD(&hub->event_list);
- hub->intfdev = &intf->dev;
- hub->hdev = hdev;
- INIT_DELAYED_WORK(&hub->leds, led_work);
- INIT_DELAYED_WORK(&hub->init_work, NULL);
- usb_get_intf(intf);
- usb_set_intfdata (intf, hub);
- intf->needs_remote_wakeup = 1;
- if (hdev->speed == USB_SPEED_HIGH)
- highspeed_hubs++;
- if (hub_configure(hub, endpoint) >= 0)
- return 0;
- hub_disconnect (intf);
- return -ENODEV;
- }
- /* No BKL needed */
- static int
- hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
- {
- struct usb_device *hdev = interface_to_usbdev (intf);
- /* assert ifno == 0 (part of hub spec) */
- switch (code) {
- case USBDEVFS_HUB_PORTINFO: {
- struct usbdevfs_hub_portinfo *info = user_data;
- int i;
- spin_lock_irq(&device_state_lock);
- if (hdev->devnum <= 0)
- info->nports = 0;
- else {
- info->nports = hdev->maxchild;
- for (i = 0; i < info->nports; i++) {
- if (hdev->children[i] == NULL)
- info->port[i] = 0;
- else
- info->port[i] =
- hdev->children[i]->devnum;
- }
- }
- spin_unlock_irq(&device_state_lock);
- return info->nports + 1;
- }
- default:
- return -ENOSYS;
- }
- }
- /*
- * Allow user programs to claim ports on a hub. When a device is attached
- * to one of these "claimed" ports, the program will "own" the device.
- */
- static int find_port_owner(struct usb_device *hdev, unsigned port1,
- void ***ppowner)
- {
- if (hdev->state == USB_STATE_NOTATTACHED)
- return -ENODEV;
- if (port1 == 0 || port1 > hdev->maxchild)
- return -EINVAL;
- /* This assumes that devices not managed by the hub driver
- * will always have maxchild equal to 0.
- */
- *ppowner = &(hdev_to_hub(hdev)->port_owners[port1 - 1]);
- return 0;
- }
- /* In the following three functions, the caller must hold hdev's lock */
- int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner)
- {
- int rc;
- void **powner;
- rc = find_port_owner(hdev, port1, &powner);
- if (rc)
- return rc;
- if (*powner)
- return -EBUSY;
- *powner = owner;
- return rc;
- }
- int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner)
- {
- int rc;
- void **powner;
- rc = find_port_owner(hdev, port1, &powner);
- if (rc)
- return rc;
- if (*powner != owner)
- return -ENOENT;
- *powner = NULL;
- return rc;
- }
- void usb_hub_release_all_ports(struct usb_device *hdev, void *owner)
- {
- int n;
- void **powner;
- n = find_port_owner(hdev, 1, &powner);
- if (n == 0) {
- for (; n < hdev->maxchild; (++n, ++powner)) {
- if (*powner == owner)
- *powner = NULL;
- }
- }
- }
- /* The caller must hold udev's lock */
- bool usb_device_is_owned(struct usb_device *udev)
- {
- struct usb_hub *hub;
- if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
- return false;
- hub = hdev_to_hub(udev->parent);
- return !!hub->port_owners[udev->portnum - 1];
- }
- static void recursively_mark_NOTATTACHED(struct usb_device *udev)
- {
- int i;
- for (i = 0; i < udev->maxchild; ++i) {
- if (udev->children[i])
- recursively_mark_NOTATTACHED(udev->children[i]);
- }
- if (udev->state == USB_STATE_SUSPENDED)
- udev->active_duration -= jiffies;
- udev->state = USB_STATE_NOTATTACHED;
- }
- /**
- * usb_set_device_state - change a device's current state (usbcore, hcds)
- * @udev: pointer to device whose state should be changed
- * @new_state: new state value to be stored
- *
- * udev->state is _not_ fully protected by the device lock. Although
- * most transitions are made only while holding the lock, the state can
- * can change to USB_STATE_NOTATTACHED at almost any time. This
- * is so that devices can be marked as disconnected as soon as possible,
- * without having to wait for any semaphores to be released. As a result,
- * all changes to any device's state must be protected by the
- * device_state_lock spinlock.
- *
- * Once a device has been added to the device tree, all changes to its state
- * should be made using this routine. The state should _not_ be set directly.
- *
- * If udev->state is already USB_STATE_NOTATTACHED then no change is made.
- * Otherwise udev->state is set to new_state, and if new_state is
- * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
- * to USB_STATE_NOTATTACHED.
- */
- void usb_set_device_state(struct usb_device *udev,
- enum usb_device_state new_state)
- {
- unsigned long flags;
- int wakeup = -1;
- spin_lock_irqsave(&device_state_lock, flags);
- if (udev->state == USB_STATE_NOTATTACHED)
- ; /* do nothing */
- else if (new_state != USB_STATE_NOTATTACHED) {
- /* root hub wakeup capabilities are managed out-of-band
- * and may involve silicon errata ... ignore them here.
- */
- if (udev->parent) {
- if (udev->state == USB_STATE_SUSPENDED
- || new_state == USB_STATE_SUSPENDED)
- ; /* No change to wakeup settings */
- else if (new_state == USB_STATE_CONFIGURED)
- wakeup = udev->actconfig->desc.bmAttributes
- & USB_CONFIG_ATT_WAKEUP;
- else
- wakeup = 0;
- }
- if (udev->state == USB_STATE_SUSPENDED &&
- new_state != USB_STATE_SUSPENDED)
- udev->active_duration -= jiffies;
- else if (new_state == USB_STATE_SUSPENDED &&
- udev->state != USB_STATE_SUSPENDED)
- udev->active_duration += jiffies;
- udev->state = new_state;
- } else
- recursively_mark_NOTATTACHED(udev);
- spin_unlock_irqrestore(&device_state_lock, flags);
- if (wakeup >= 0)
- device_set_wakeup_capable(&udev->dev, wakeup);
- }
- EXPORT_SYMBOL_GPL(usb_set_device_state);
- /*
- * Choose a device number.
- *
- * Device numbers are used as filenames in usbfs. On USB-1.1 and
- * USB-2.0 buses they are also used as device addresses, however on
- * USB-3.0 buses the address is assigned by the controller hardware
- * and it usually is not the same as the device number.
- *
- * WUSB devices are simple: they have no hubs behind, so the mapping
- * device <-> virtual port number becomes 1:1. Why? to simplify the
- * life of the device connection logic in
- * drivers/usb/wusbcore/devconnect.c. When we do the initial secret
- * handshake we need to assign a temporary address in the unauthorized
- * space. For simplicity we use the first virtual port number found to
- * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
- * and that becomes it's address [X < 128] or its unauthorized address
- * [X | 0x80].
- *
- * We add 1 as an offset to the one-based USB-stack port number
- * (zero-based wusb virtual port index) for two reasons: (a) dev addr
- * 0 is reserved by USB for default address; (b) Linux's USB stack
- * uses always #1 for the root hub of the controller. So USB stack's
- * port #1, which is wusb virtual-port #0 has address #2.
- *
- * Devices connected under xHCI are not as simple. The host controller
- * supports virtualization, so the hardware assigns device addresses and
- * the HCD must setup data structures before issuing a set address
- * command to the hardware.
- */
- static void choose_devnum(struct usb_device *udev)
- {
- int devnum;
- struct usb_bus *bus = udev->bus;
- /* If khubd ever becomes multithreaded, this will need a lock */
- if (udev->wusb) {
- devnum = udev->portnum + 1;
- BUG_ON(test_bit(devnum, bus->devmap.devicemap));
- } else {
- /* Try to allocate the next devnum beginning at
- * bus->devnum_next. */
- devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
- bus->devnum_next);
- if (devnum >= 128)
- devnum = find_next_zero_bit(bus->devmap.devicemap,
- 128, 1);
- bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);
- }
- if (devnum < 128) {
- set_bit(devnum, bus->devmap.devicemap);
- udev->devnum = devnum;
- }
- }
- static void release_devnum(struct usb_device *udev)
- {
- if (udev->devnum > 0) {
- clear_bit(udev->devnum, udev->bus->devmap.devicemap);
- udev->devnum = -1;
- }
- }
- static void update_devnum(struct usb_device *udev, int devnum)
- {
- /* The address for a WUSB device is managed by wusbcore. */
- if (!udev->wusb)
- udev->devnum = devnum;
- }
- static void hub_free_dev(struct usb_device *udev)
- {
- struct usb_hcd *hcd = bus_to_hcd(udev->bus);
- /* Root hubs aren't real devices, so don't free HCD resources */
- if (hcd->driver->free_dev && udev->parent)
- hcd->driver->free_dev(hcd, udev);
- }
- /**
- * usb_disconnect - disconnect a device (usbcore-internal)
- * @pdev: pointer to device being disconnected
- * Context: !in_interrupt ()
- *
- * Something got disconnected. Get rid of it and all of its children.
- *
- * If *pdev is a normal device then the parent hub must already be locked.
- * If *pdev is a root hub then this routine will acquire the
- * usb_bus_list_lock on behalf of the caller.
- *
- * Only hub drivers (including virtual root hub drivers for host
- * controllers) should ever call this.
- *
- * This call is synchronous, and may not be used in an interrupt context.
- */
- void usb_disconnect(struct usb_device **pdev)
- {
- struct usb_device *udev = *pdev;
- int i;
- struct usb_hcd *hcd = bus_to_hcd(udev->bus);
- if (!udev) {
- pr_debug ("%s nodev\n", __func__);
- return;
- }
- /* mark the device as inactive, so any further urb submissions for
- * this device (and any of its children) will fail immediately.
- * this quiesces everything except pending urbs.
- */
- usb_set_device_state(udev, USB_STATE_NOTATTACHED);
- dev_info(&udev->dev, "USB disconnect, device number %d\n",
- udev->devnum);
- usb_lock_device(udev);
- /* Free up all the children before we remove this device */
- for (i = 0; i < USB_MAXCHILDREN; i++) {
- if (udev->children[i])
- usb_disconnect(&udev->children[i]);
- }
- /* deallocate hcd/hardware state ... nuking all pending urbs and
- * cleaning up all state associated with the current configuration
- * so that the hardware is now fully quiesced.
- */
- dev_dbg (&udev->dev, "unregistering device\n");
- mutex_lock(hcd->bandwidth_mutex);
- usb_disable_device(udev, 0);
- mutex_unlock(hcd->bandwidth_mutex);
- usb_hcd_synchronize_unlinks(udev);
- usb_remove_ep_devs(&udev->ep0);
- usb_unlock_device(udev);
- /* Unregister the device. The device driver is responsible
- * for de-configuring the device and invoking the remove-device
- * notifier chain (used by usbfs and possibly others).
- */
- device_del(&udev->dev);
- /* Free the device number and delete the parent's children[]
- * (or root_hub) pointer.
- */
- release_devnum(udev);
- /* Avoid races with recursively_mark_NOTATTACHED() */
- spin_lock_irq(&device_state_lock);
- *pdev = NULL;
- spin_unlock_irq(&device_state_lock);
- hub_free_dev(udev);
- put_device(&udev->dev);
- }
- #ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
- static void show_string(struct usb_device *udev, char *id, char *string)
- {
- if (!string)
- return;
- dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string);
- }
- static void announce_device(struct usb_device *udev)
- {
- dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
- le16_to_cpu(udev->descriptor.idVendor),
- le16_to_cpu(udev->descriptor.idProduct));
- dev_info(&udev->dev,
- "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
- udev->descriptor.iManufacturer,
- udev->descriptor.iProduct,
- udev->descriptor.iSerialNumber);
- show_string(udev, "Product", udev->product);
- show_string(udev, "Manufacturer", udev->manufacturer);
- show_string(udev, "SerialNumber", udev->serial);
- }
- #else
- static inline void announce_device(struct usb_device *udev) { }
- #endif
- #ifdef CONFIG_USB_OTG
- #include "otg_whitelist.h"
- #endif
- /**
- * usb_enumerate_device_otg - FIXME (usbcore-internal)
- * @udev: newly addressed device (in ADDRESS state)
- *
- * Finish enumeration for On-The-Go devices
- */
- static int usb_enumerate_device_otg(struct usb_device *udev)
- {
- int err = 0;
- #ifdef CONFIG_USB_OTG
- /*
- * OTG-aware devices on OTG-capable root hubs may be able to use SRP,
- * to wake us after we've powered off VBUS; and HNP, switching roles
- * "host" to "peripheral". The OTG descriptor helps figure this out.
- */
- if (!udev->bus->is_b_host
- && udev->config
- && udev->parent == udev->…