| /* |
| * (C) Copyright Linus Torvalds 1999 |
| * (C) Copyright Johannes Erdfelt 1999-2001 |
| * (C) Copyright Andreas Gal 1999 |
| * (C) Copyright Gregory P. Smith 1999 |
| * (C) Copyright Deti Fliegl 1999 |
| * (C) Copyright Randy Dunlap 2000 |
| * (C) Copyright David Brownell 2000-2002 |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation; either version 2 of the License, or (at your |
| * option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
| * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software Foundation, |
| * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/version.h> |
| #include <linux/kernel.h> |
| #include <linux/slab.h> |
| #include <linux/completion.h> |
| #include <linux/utsname.h> |
| #include <linux/mm.h> |
| #include <asm/io.h> |
| #include <linux/device.h> |
| #include <linux/dma-mapping.h> |
| #include <linux/mutex.h> |
| #include <asm/irq.h> |
| #include <asm/byteorder.h> |
| #include <asm/unaligned.h> |
| #include <linux/platform_device.h> |
| #include <linux/workqueue.h> |
| #include <linux/mutex.h> |
| |
| #include <linux/usb.h> |
| |
| #include "usb.h" |
| #include "hcd.h" |
| #include "hub.h" |
| |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* |
| * USB Host Controller Driver framework |
| * |
| * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing |
| * HCD-specific behaviors/bugs. |
| * |
| * This does error checks, tracks devices and urbs, and delegates to a |
| * "hc_driver" only for code (and data) that really needs to know about |
| * hardware differences. That includes root hub registers, i/o queues, |
| * and so on ... but as little else as possible. |
| * |
| * Shared code includes most of the "root hub" code (these are emulated, |
| * though each HC's hardware works differently) and PCI glue, plus request |
| * tracking overhead. The HCD code should only block on spinlocks or on |
| * hardware handshaking; blocking on software events (such as other kernel |
| * threads releasing resources, or completing actions) is all generic. |
| * |
| * Happens the USB 2.0 spec says this would be invisible inside the "USBD", |
| * and includes mostly a "HCDI" (HCD Interface) along with some APIs used |
| * only by the hub driver ... and that neither should be seen or used by |
| * usb client device drivers. |
| * |
| * Contributors of ideas or unattributed patches include: David Brownell, |
| * Roman Weissgaerber, Rory Bolt, Greg Kroah-Hartman, ... |
| * |
| * HISTORY: |
| * 2002-02-21 Pull in most of the usb_bus support from usb.c; some |
| * associated cleanup. "usb_hcd" still != "usb_bus". |
| * 2001-12-12 Initial patch version for Linux 2.5.1 kernel. |
| */ |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* Keep track of which host controller drivers are loaded */ |
| unsigned long usb_hcds_loaded; |
| EXPORT_SYMBOL_GPL(usb_hcds_loaded); |
| |
| /* host controllers we manage */ |
| LIST_HEAD (usb_bus_list); |
| EXPORT_SYMBOL_GPL (usb_bus_list); |
| |
| /* used when allocating bus numbers */ |
| #define USB_MAXBUS 64 |
| struct usb_busmap { |
| unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))]; |
| }; |
| static struct usb_busmap busmap; |
| |
| /* used when updating list of hcds */ |
| DEFINE_MUTEX(usb_bus_list_lock); /* exported only for usbfs */ |
| EXPORT_SYMBOL_GPL (usb_bus_list_lock); |
| |
| /* used for controlling access to virtual root hubs */ |
| static DEFINE_SPINLOCK(hcd_root_hub_lock); |
| |
| /* used when updating an endpoint's URB list */ |
| static DEFINE_SPINLOCK(hcd_urb_list_lock); |
| |
| /* used to protect against unlinking URBs after the device is gone */ |
| static DEFINE_SPINLOCK(hcd_urb_unlink_lock); |
| |
| /* wait queue for synchronous unlinks */ |
| DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue); |
| |
| static inline int is_root_hub(struct usb_device *udev) |
| { |
| return (udev->parent == NULL); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* |
| * Sharable chunks of root hub code. |
| */ |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| #define KERNEL_REL ((LINUX_VERSION_CODE >> 16) & 0x0ff) |
| #define KERNEL_VER ((LINUX_VERSION_CODE >> 8) & 0x0ff) |
| |
| /* usb 3.0 root hub device descriptor */ |
| static const u8 usb3_rh_dev_descriptor[18] = { |
| 0x12, /* __u8 bLength; */ |
| 0x01, /* __u8 bDescriptorType; Device */ |
| 0x00, 0x03, /* __le16 bcdUSB; v3.0 */ |
| |
| 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */ |
| 0x00, /* __u8 bDeviceSubClass; */ |
| 0x03, /* __u8 bDeviceProtocol; USB 3.0 hub */ |
| 0x09, /* __u8 bMaxPacketSize0; 2^9 = 512 Bytes */ |
| |
| 0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */ |
| 0x02, 0x00, /* __le16 idProduct; device 0x0002 */ |
| KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */ |
| |
| 0x03, /* __u8 iManufacturer; */ |
| 0x02, /* __u8 iProduct; */ |
| 0x01, /* __u8 iSerialNumber; */ |
| 0x01 /* __u8 bNumConfigurations; */ |
| }; |
| |
| /* usb 2.0 root hub device descriptor */ |
| static const u8 usb2_rh_dev_descriptor [18] = { |
| 0x12, /* __u8 bLength; */ |
| 0x01, /* __u8 bDescriptorType; Device */ |
| 0x00, 0x02, /* __le16 bcdUSB; v2.0 */ |
| |
| 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */ |
| 0x00, /* __u8 bDeviceSubClass; */ |
| 0x00, /* __u8 bDeviceProtocol; [ usb 2.0 no TT ] */ |
| 0x40, /* __u8 bMaxPacketSize0; 64 Bytes */ |
| |
| 0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */ |
| 0x02, 0x00, /* __le16 idProduct; device 0x0002 */ |
| KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */ |
| |
| 0x03, /* __u8 iManufacturer; */ |
| 0x02, /* __u8 iProduct; */ |
| 0x01, /* __u8 iSerialNumber; */ |
| 0x01 /* __u8 bNumConfigurations; */ |
| }; |
| |
| /* no usb 2.0 root hub "device qualifier" descriptor: one speed only */ |
| |
| /* usb 1.1 root hub device descriptor */ |
| static const u8 usb11_rh_dev_descriptor [18] = { |
| 0x12, /* __u8 bLength; */ |
| 0x01, /* __u8 bDescriptorType; Device */ |
| 0x10, 0x01, /* __le16 bcdUSB; v1.1 */ |
| |
| 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */ |
| 0x00, /* __u8 bDeviceSubClass; */ |
| 0x00, /* __u8 bDeviceProtocol; [ low/full speeds only ] */ |
| 0x40, /* __u8 bMaxPacketSize0; 64 Bytes */ |
| |
| 0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */ |
| 0x01, 0x00, /* __le16 idProduct; device 0x0001 */ |
| KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */ |
| |
| 0x03, /* __u8 iManufacturer; */ |
| 0x02, /* __u8 iProduct; */ |
| 0x01, /* __u8 iSerialNumber; */ |
| 0x01 /* __u8 bNumConfigurations; */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* Configuration descriptors for our root hubs */ |
| |
| static const u8 fs_rh_config_descriptor [] = { |
| |
| /* one configuration */ |
| 0x09, /* __u8 bLength; */ |
| 0x02, /* __u8 bDescriptorType; Configuration */ |
| 0x19, 0x00, /* __le16 wTotalLength; */ |
| 0x01, /* __u8 bNumInterfaces; (1) */ |
| 0x01, /* __u8 bConfigurationValue; */ |
| 0x00, /* __u8 iConfiguration; */ |
| 0xc0, /* __u8 bmAttributes; |
| Bit 7: must be set, |
| 6: Self-powered, |
| 5: Remote wakeup, |
| 4..0: resvd */ |
| 0x00, /* __u8 MaxPower; */ |
| |
| /* USB 1.1: |
| * USB 2.0, single TT organization (mandatory): |
| * one interface, protocol 0 |
| * |
| * USB 2.0, multiple TT organization (optional): |
| * two interfaces, protocols 1 (like single TT) |
| * and 2 (multiple TT mode) ... config is |
| * sometimes settable |
| * NOT IMPLEMENTED |
| */ |
| |
| /* one interface */ |
| 0x09, /* __u8 if_bLength; */ |
| 0x04, /* __u8 if_bDescriptorType; Interface */ |
| 0x00, /* __u8 if_bInterfaceNumber; */ |
| 0x00, /* __u8 if_bAlternateSetting; */ |
| 0x01, /* __u8 if_bNumEndpoints; */ |
| 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */ |
| 0x00, /* __u8 if_bInterfaceSubClass; */ |
| 0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */ |
| 0x00, /* __u8 if_iInterface; */ |
| |
| /* one endpoint (status change endpoint) */ |
| 0x07, /* __u8 ep_bLength; */ |
| 0x05, /* __u8 ep_bDescriptorType; Endpoint */ |
| 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */ |
| 0x03, /* __u8 ep_bmAttributes; Interrupt */ |
| 0x02, 0x00, /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */ |
| 0xff /* __u8 ep_bInterval; (255ms -- usb 2.0 spec) */ |
| }; |
| |
| static const u8 hs_rh_config_descriptor [] = { |
| |
| /* one configuration */ |
| 0x09, /* __u8 bLength; */ |
| 0x02, /* __u8 bDescriptorType; Configuration */ |
| 0x19, 0x00, /* __le16 wTotalLength; */ |
| 0x01, /* __u8 bNumInterfaces; (1) */ |
| 0x01, /* __u8 bConfigurationValue; */ |
| 0x00, /* __u8 iConfiguration; */ |
| 0xc0, /* __u8 bmAttributes; |
| Bit 7: must be set, |
| 6: Self-powered, |
| 5: Remote wakeup, |
| 4..0: resvd */ |
| 0x00, /* __u8 MaxPower; */ |
| |
| /* USB 1.1: |
| * USB 2.0, single TT organization (mandatory): |
| * one interface, protocol 0 |
| * |
| * USB 2.0, multiple TT organization (optional): |
| * two interfaces, protocols 1 (like single TT) |
| * and 2 (multiple TT mode) ... config is |
| * sometimes settable |
| * NOT IMPLEMENTED |
| */ |
| |
| /* one interface */ |
| 0x09, /* __u8 if_bLength; */ |
| 0x04, /* __u8 if_bDescriptorType; Interface */ |
| 0x00, /* __u8 if_bInterfaceNumber; */ |
| 0x00, /* __u8 if_bAlternateSetting; */ |
| 0x01, /* __u8 if_bNumEndpoints; */ |
| 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */ |
| 0x00, /* __u8 if_bInterfaceSubClass; */ |
| 0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */ |
| 0x00, /* __u8 if_iInterface; */ |
| |
| /* one endpoint (status change endpoint) */ |
| 0x07, /* __u8 ep_bLength; */ |
| 0x05, /* __u8 ep_bDescriptorType; Endpoint */ |
| 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */ |
| 0x03, /* __u8 ep_bmAttributes; Interrupt */ |
| /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) |
| * see hub.c:hub_configure() for details. */ |
| (USB_MAXCHILDREN + 1 + 7) / 8, 0x00, |
| 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */ |
| }; |
| |
| static const u8 ss_rh_config_descriptor[] = { |
| /* one configuration */ |
| 0x09, /* __u8 bLength; */ |
| 0x02, /* __u8 bDescriptorType; Configuration */ |
| 0x19, 0x00, /* __le16 wTotalLength; FIXME */ |
| 0x01, /* __u8 bNumInterfaces; (1) */ |
| 0x01, /* __u8 bConfigurationValue; */ |
| 0x00, /* __u8 iConfiguration; */ |
| 0xc0, /* __u8 bmAttributes; |
| Bit 7: must be set, |
| 6: Self-powered, |
| 5: Remote wakeup, |
| 4..0: resvd */ |
| 0x00, /* __u8 MaxPower; */ |
| |
| /* one interface */ |
| 0x09, /* __u8 if_bLength; */ |
| 0x04, /* __u8 if_bDescriptorType; Interface */ |
| 0x00, /* __u8 if_bInterfaceNumber; */ |
| 0x00, /* __u8 if_bAlternateSetting; */ |
| 0x01, /* __u8 if_bNumEndpoints; */ |
| 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */ |
| 0x00, /* __u8 if_bInterfaceSubClass; */ |
| 0x00, /* __u8 if_bInterfaceProtocol; */ |
| 0x00, /* __u8 if_iInterface; */ |
| |
| /* one endpoint (status change endpoint) */ |
| 0x07, /* __u8 ep_bLength; */ |
| 0x05, /* __u8 ep_bDescriptorType; Endpoint */ |
| 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */ |
| 0x03, /* __u8 ep_bmAttributes; Interrupt */ |
| /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) |
| * see hub.c:hub_configure() for details. */ |
| (USB_MAXCHILDREN + 1 + 7) / 8, 0x00, |
| 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */ |
| /* |
| * All 3.0 hubs should have an endpoint companion descriptor, |
| * but we're ignoring that for now. FIXME? |
| */ |
| }; |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * ascii2desc() - Helper routine for producing UTF-16LE string descriptors |
| * @s: Null-terminated ASCII (actually ISO-8859-1) string |
| * @buf: Buffer for USB string descriptor (header + UTF-16LE) |
| * @len: Length (in bytes; may be odd) of descriptor buffer. |
| * |
| * The return value is the number of bytes filled in: 2 + 2*strlen(s) or |
| * buflen, whichever is less. |
| * |
| * USB String descriptors can contain at most 126 characters; input |
| * strings longer than that are truncated. |
| */ |
| static unsigned |
| ascii2desc(char const *s, u8 *buf, unsigned len) |
| { |
| unsigned n, t = 2 + 2*strlen(s); |
| |
| if (t > 254) |
| t = 254; /* Longest possible UTF string descriptor */ |
| if (len > t) |
| len = t; |
| |
| t += USB_DT_STRING << 8; /* Now t is first 16 bits to store */ |
| |
| n = len; |
| while (n--) { |
| *buf++ = t; |
| if (!n--) |
| break; |
| *buf++ = t >> 8; |
| t = (unsigned char)*s++; |
| } |
| return len; |
| } |
| |
| /** |
| * rh_string() - provides string descriptors for root hub |
| * @id: the string ID number (0: langids, 1: serial #, 2: product, 3: vendor) |
| * @hcd: the host controller for this root hub |
| * @data: buffer for output packet |
| * @len: length of the provided buffer |
| * |
| * Produces either a manufacturer, product or serial number string for the |
| * virtual root hub device. |
| * Returns the number of bytes filled in: the length of the descriptor or |
| * of the provided buffer, whichever is less. |
| */ |
| static unsigned |
| rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len) |
| { |
| char buf[100]; |
| char const *s; |
| static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04}; |
| |
| // language ids |
| switch (id) { |
| case 0: |
| /* Array of LANGID codes (0x0409 is MSFT-speak for "en-us") */ |
| /* See http://www.usb.org/developers/docs/USB_LANGIDs.pdf */ |
| if (len > 4) |
| len = 4; |
| memcpy(data, langids, len); |
| return len; |
| case 1: |
| /* Serial number */ |
| s = hcd->self.bus_name; |
| break; |
| case 2: |
| /* Product name */ |
| s = hcd->product_desc; |
| break; |
| case 3: |
| /* Manufacturer */ |
| snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname, |
| init_utsname()->release, hcd->driver->description); |
| s = buf; |
| break; |
| default: |
| /* Can't happen; caller guarantees it */ |
| return 0; |
| } |
| |
| return ascii2desc(s, data, len); |
| } |
| |
| |
| /* Root hub control transfers execute synchronously */ |
| static int rh_call_control (struct usb_hcd *hcd, struct urb *urb) |
| { |
| struct usb_ctrlrequest *cmd; |
| u16 typeReq, wValue, wIndex, wLength; |
| u8 *ubuf = urb->transfer_buffer; |
| u8 tbuf [sizeof (struct usb_hub_descriptor)] |
| __attribute__((aligned(4))); |
| const u8 *bufp = tbuf; |
| unsigned len = 0; |
| int status; |
| u8 patch_wakeup = 0; |
| u8 patch_protocol = 0; |
| |
| might_sleep(); |
| |
| spin_lock_irq(&hcd_root_hub_lock); |
| status = usb_hcd_link_urb_to_ep(hcd, urb); |
| spin_unlock_irq(&hcd_root_hub_lock); |
| if (status) |
| return status; |
| urb->hcpriv = hcd; /* Indicate it's queued */ |
| |
| cmd = (struct usb_ctrlrequest *) urb->setup_packet; |
| typeReq = (cmd->bRequestType << 8) | cmd->bRequest; |
| wValue = le16_to_cpu (cmd->wValue); |
| wIndex = le16_to_cpu (cmd->wIndex); |
| wLength = le16_to_cpu (cmd->wLength); |
| |
| if (wLength > urb->transfer_buffer_length) |
| goto error; |
| |
| urb->actual_length = 0; |
| switch (typeReq) { |
| |
| /* DEVICE REQUESTS */ |
| |
| /* The root hub's remote wakeup enable bit is implemented using |
| * driver model wakeup flags. If this system supports wakeup |
| * through USB, userspace may change the default "allow wakeup" |
| * policy through sysfs or these calls. |
| * |
| * Most root hubs support wakeup from downstream devices, for |
| * runtime power management (disabling USB clocks and reducing |
| * VBUS power usage). However, not all of them do so; silicon, |
| * board, and BIOS bugs here are not uncommon, so these can't |
| * be treated quite like external hubs. |
| * |
| * Likewise, not all root hubs will pass wakeup events upstream, |
| * to wake up the whole system. So don't assume root hub and |
| * controller capabilities are identical. |
| */ |
| |
| case DeviceRequest | USB_REQ_GET_STATUS: |
| tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev) |
| << USB_DEVICE_REMOTE_WAKEUP) |
| | (1 << USB_DEVICE_SELF_POWERED); |
| tbuf [1] = 0; |
| len = 2; |
| break; |
| case DeviceOutRequest | USB_REQ_CLEAR_FEATURE: |
| if (wValue == USB_DEVICE_REMOTE_WAKEUP) |
| device_set_wakeup_enable(&hcd->self.root_hub->dev, 0); |
| else |
| goto error; |
| break; |
| case DeviceOutRequest | USB_REQ_SET_FEATURE: |
| if (device_can_wakeup(&hcd->self.root_hub->dev) |
| && wValue == USB_DEVICE_REMOTE_WAKEUP) |
| device_set_wakeup_enable(&hcd->self.root_hub->dev, 1); |
| else |
| goto error; |
| break; |
| case DeviceRequest | USB_REQ_GET_CONFIGURATION: |
| tbuf [0] = 1; |
| len = 1; |
| /* FALLTHROUGH */ |
| case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: |
| break; |
| case DeviceRequest | USB_REQ_GET_DESCRIPTOR: |
| switch (wValue & 0xff00) { |
| case USB_DT_DEVICE << 8: |
| switch (hcd->driver->flags & HCD_MASK) { |
| case HCD_USB3: |
| bufp = usb3_rh_dev_descriptor; |
| break; |
| case HCD_USB2: |
| bufp = usb2_rh_dev_descriptor; |
| break; |
| case HCD_USB11: |
| bufp = usb11_rh_dev_descriptor; |
| break; |
| default: |
| goto error; |
| } |
| len = 18; |
| if (hcd->has_tt) |
| patch_protocol = 1; |
| break; |
| case USB_DT_CONFIG << 8: |
| switch (hcd->driver->flags & HCD_MASK) { |
| case HCD_USB3: |
| bufp = ss_rh_config_descriptor; |
| len = sizeof ss_rh_config_descriptor; |
| break; |
| case HCD_USB2: |
| bufp = hs_rh_config_descriptor; |
| len = sizeof hs_rh_config_descriptor; |
| break; |
| case HCD_USB11: |
| bufp = fs_rh_config_descriptor; |
| len = sizeof fs_rh_config_descriptor; |
| break; |
| default: |
| goto error; |
| } |
| if (device_can_wakeup(&hcd->self.root_hub->dev)) |
| patch_wakeup = 1; |
| break; |
| case USB_DT_STRING << 8: |
| if ((wValue & 0xff) < 4) |
| urb->actual_length = rh_string(wValue & 0xff, |
| hcd, ubuf, wLength); |
| else /* unsupported IDs --> "protocol stall" */ |
| goto error; |
| break; |
| default: |
| goto error; |
| } |
| break; |
| case DeviceRequest | USB_REQ_GET_INTERFACE: |
| tbuf [0] = 0; |
| len = 1; |
| /* FALLTHROUGH */ |
| case DeviceOutRequest | USB_REQ_SET_INTERFACE: |
| break; |
| case DeviceOutRequest | USB_REQ_SET_ADDRESS: |
| // wValue == urb->dev->devaddr |
| dev_dbg (hcd->self.controller, "root hub device address %d\n", |
| wValue); |
| break; |
| |
| /* INTERFACE REQUESTS (no defined feature/status flags) */ |
| |
| /* ENDPOINT REQUESTS */ |
| |
| case EndpointRequest | USB_REQ_GET_STATUS: |
| // ENDPOINT_HALT flag |
| tbuf [0] = 0; |
| tbuf [1] = 0; |
| len = 2; |
| /* FALLTHROUGH */ |
| case EndpointOutRequest | USB_REQ_CLEAR_FEATURE: |
| case EndpointOutRequest | USB_REQ_SET_FEATURE: |
| dev_dbg (hcd->self.controller, "no endpoint features yet\n"); |
| break; |
| |
| /* CLASS REQUESTS (and errors) */ |
| |
| default: |
| /* non-generic request */ |
| switch (typeReq) { |
| case GetHubStatus: |
| case GetPortStatus: |
| len = 4; |
| break; |
| case GetHubDescriptor: |
| len = sizeof (struct usb_hub_descriptor); |
| break; |
| } |
| status = hcd->driver->hub_control (hcd, |
| typeReq, wValue, wIndex, |
| tbuf, wLength); |
| break; |
| error: |
| /* "protocol stall" on error */ |
| status = -EPIPE; |
| } |
| |
| if (status) { |
| len = 0; |
| if (status != -EPIPE) { |
| dev_dbg (hcd->self.controller, |
| "CTRL: TypeReq=0x%x val=0x%x " |
| "idx=0x%x len=%d ==> %d\n", |
| typeReq, wValue, wIndex, |
| wLength, status); |
| } |
| } |
| if (len) { |
| if (urb->transfer_buffer_length < len) |
| len = urb->transfer_buffer_length; |
| urb->actual_length = len; |
| // always USB_DIR_IN, toward host |
| memcpy (ubuf, bufp, len); |
| |
| /* report whether RH hardware supports remote wakeup */ |
| if (patch_wakeup && |
| len > offsetof (struct usb_config_descriptor, |
| bmAttributes)) |
| ((struct usb_config_descriptor *)ubuf)->bmAttributes |
| |= USB_CONFIG_ATT_WAKEUP; |
| |
| /* report whether RH hardware has an integrated TT */ |
| if (patch_protocol && |
| len > offsetof(struct usb_device_descriptor, |
| bDeviceProtocol)) |
| ((struct usb_device_descriptor *) ubuf)-> |
| bDeviceProtocol = 1; |
| } |
| |
| /* any errors get returned through the urb completion */ |
| spin_lock_irq(&hcd_root_hub_lock); |
| usb_hcd_unlink_urb_from_ep(hcd, urb); |
| |
| /* This peculiar use of spinlocks echoes what real HC drivers do. |
| * Avoiding calls to local_irq_disable/enable makes the code |
| * RT-friendly. |
| */ |
| spin_unlock(&hcd_root_hub_lock); |
| usb_hcd_giveback_urb(hcd, urb, status); |
| spin_lock(&hcd_root_hub_lock); |
| |
| spin_unlock_irq(&hcd_root_hub_lock); |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* |
| * Root Hub interrupt transfers are polled using a timer if the |
| * driver requests it; otherwise the driver is responsible for |
| * calling usb_hcd_poll_rh_status() when an event occurs. |
| * |
| * Completions are called in_interrupt(), but they may or may not |
| * be in_irq(). |
| */ |
| void usb_hcd_poll_rh_status(struct usb_hcd *hcd) |
| { |
| struct urb *urb; |
| int length; |
| unsigned long flags; |
| char buffer[6]; /* Any root hubs with > 31 ports? */ |
| |
| if (unlikely(!hcd->rh_registered)) |
| return; |
| if (!hcd->uses_new_polling && !hcd->status_urb) |
| return; |
| |
| length = hcd->driver->hub_status_data(hcd, buffer); |
| if (length > 0) { |
| |
| /* try to complete the status urb */ |
| spin_lock_irqsave(&hcd_root_hub_lock, flags); |
| urb = hcd->status_urb; |
| if (urb) { |
| hcd->poll_pending = 0; |
| hcd->status_urb = NULL; |
| urb->actual_length = length; |
| memcpy(urb->transfer_buffer, buffer, length); |
| |
| usb_hcd_unlink_urb_from_ep(hcd, urb); |
| spin_unlock(&hcd_root_hub_lock); |
| usb_hcd_giveback_urb(hcd, urb, 0); |
| spin_lock(&hcd_root_hub_lock); |
| } else { |
| length = 0; |
| hcd->poll_pending = 1; |
| } |
| spin_unlock_irqrestore(&hcd_root_hub_lock, flags); |
| } |
| |
| /* The USB 2.0 spec says 256 ms. This is close enough and won't |
| * exceed that limit if HZ is 100. The math is more clunky than |
| * maybe expected, this is to make sure that all timers for USB devices |
| * fire at the same time to give the CPU a break inbetween */ |
| if (hcd->uses_new_polling ? hcd->poll_rh : |
| (length == 0 && hcd->status_urb != NULL)) |
| mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4)); |
| } |
| EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status); |
| |
| /* timer callback */ |
| static void rh_timer_func (unsigned long _hcd) |
| { |
| usb_hcd_poll_rh_status((struct usb_hcd *) _hcd); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb) |
| { |
| int retval; |
| unsigned long flags; |
| unsigned len = 1 + (urb->dev->maxchild / 8); |
| |
| spin_lock_irqsave (&hcd_root_hub_lock, flags); |
| if (hcd->status_urb || urb->transfer_buffer_length < len) { |
| dev_dbg (hcd->self.controller, "not queuing rh status urb\n"); |
| retval = -EINVAL; |
| goto done; |
| } |
| |
| retval = usb_hcd_link_urb_to_ep(hcd, urb); |
| if (retval) |
| goto done; |
| |
| hcd->status_urb = urb; |
| urb->hcpriv = hcd; /* indicate it's queued */ |
| if (!hcd->uses_new_polling) |
| mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4)); |
| |
| /* If a status change has already occurred, report it ASAP */ |
| else if (hcd->poll_pending) |
| mod_timer(&hcd->rh_timer, jiffies); |
| retval = 0; |
| done: |
| spin_unlock_irqrestore (&hcd_root_hub_lock, flags); |
| return retval; |
| } |
| |
| static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb) |
| { |
| if (usb_endpoint_xfer_int(&urb->ep->desc)) |
| return rh_queue_status (hcd, urb); |
| if (usb_endpoint_xfer_control(&urb->ep->desc)) |
| return rh_call_control (hcd, urb); |
| return -EINVAL; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* Unlinks of root-hub control URBs are legal, but they don't do anything |
| * since these URBs always execute synchronously. |
| */ |
| static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) |
| { |
| unsigned long flags; |
| int rc; |
| |
| spin_lock_irqsave(&hcd_root_hub_lock, flags); |
| rc = usb_hcd_check_unlink_urb(hcd, urb, status); |
| if (rc) |
| goto done; |
| |
| if (usb_endpoint_num(&urb->ep->desc) == 0) { /* Control URB */ |
| ; /* Do nothing */ |
| |
| } else { /* Status URB */ |
| if (!hcd->uses_new_polling) |
| del_timer (&hcd->rh_timer); |
| if (urb == hcd->status_urb) { |
| hcd->status_urb = NULL; |
| usb_hcd_unlink_urb_from_ep(hcd, urb); |
| |
| spin_unlock(&hcd_root_hub_lock); |
| usb_hcd_giveback_urb(hcd, urb, status); |
| spin_lock(&hcd_root_hub_lock); |
| } |
| } |
| done: |
| spin_unlock_irqrestore(&hcd_root_hub_lock, flags); |
| return rc; |
| } |
| |
| |
| |
| /* |
| * Show & store the current value of authorized_default |
| */ |
| static ssize_t usb_host_authorized_default_show(struct device *dev, |
| struct device_attribute *attr, |
| char *buf) |
| { |
| struct usb_device *rh_usb_dev = to_usb_device(dev); |
| struct usb_bus *usb_bus = rh_usb_dev->bus; |
| struct usb_hcd *usb_hcd; |
| |
| if (usb_bus == NULL) /* FIXME: not sure if this case is possible */ |
| return -ENODEV; |
| usb_hcd = bus_to_hcd(usb_bus); |
| return snprintf(buf, PAGE_SIZE, "%u\n", usb_hcd->authorized_default); |
| } |
| |
| static ssize_t usb_host_authorized_default_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t size) |
| { |
| ssize_t result; |
| unsigned val; |
| struct usb_device *rh_usb_dev = to_usb_device(dev); |
| struct usb_bus *usb_bus = rh_usb_dev->bus; |
| struct usb_hcd *usb_hcd; |
| |
| if (usb_bus == NULL) /* FIXME: not sure if this case is possible */ |
| return -ENODEV; |
| usb_hcd = bus_to_hcd(usb_bus); |
| result = sscanf(buf, "%u\n", &val); |
| if (result == 1) { |
| usb_hcd->authorized_default = val? 1 : 0; |
| result = size; |
| } |
| else |
| result = -EINVAL; |
| return result; |
| } |
| |
| static DEVICE_ATTR(authorized_default, 0644, |
| usb_host_authorized_default_show, |
| usb_host_authorized_default_store); |
| |
| |
| /* Group all the USB bus attributes */ |
| static struct attribute *usb_bus_attrs[] = { |
| &dev_attr_authorized_default.attr, |
| NULL, |
| }; |
| |
| static struct attribute_group usb_bus_attr_group = { |
| .name = NULL, /* we want them in the same directory */ |
| .attrs = usb_bus_attrs, |
| }; |
| |
| |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * usb_bus_init - shared initialization code |
| * @bus: the bus structure being initialized |
| * |
| * This code is used to initialize a usb_bus structure, memory for which is |
| * separately managed. |
| */ |
| static void usb_bus_init (struct usb_bus *bus) |
| { |
| memset (&bus->devmap, 0, sizeof(struct usb_devmap)); |
| |
| bus->devnum_next = 1; |
| |
| bus->root_hub = NULL; |
| bus->busnum = -1; |
| bus->bandwidth_allocated = 0; |
| bus->bandwidth_int_reqs = 0; |
| bus->bandwidth_isoc_reqs = 0; |
| |
| INIT_LIST_HEAD (&bus->bus_list); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * usb_register_bus - registers the USB host controller with the usb core |
| * @bus: pointer to the bus to register |
| * Context: !in_interrupt() |
| * |
| * Assigns a bus number, and links the controller into usbcore data |
| * structures so that it can be seen by scanning the bus list. |
| */ |
| static int usb_register_bus(struct usb_bus *bus) |
| { |
| int result = -E2BIG; |
| int busnum; |
| |
| mutex_lock(&usb_bus_list_lock); |
| busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1); |
| if (busnum >= USB_MAXBUS) { |
| printk (KERN_ERR "%s: too many buses\n", usbcore_name); |
| goto error_find_busnum; |
| } |
| set_bit (busnum, busmap.busmap); |
| bus->busnum = busnum; |
| |
| /* Add it to the local list of buses */ |
| list_add (&bus->bus_list, &usb_bus_list); |
| mutex_unlock(&usb_bus_list_lock); |
| |
| usb_notify_add_bus(bus); |
| |
| dev_info (bus->controller, "new USB bus registered, assigned bus " |
| "number %d\n", bus->busnum); |
| return 0; |
| |
| error_find_busnum: |
| mutex_unlock(&usb_bus_list_lock); |
| return result; |
| } |
| |
| /** |
| * usb_deregister_bus - deregisters the USB host controller |
| * @bus: pointer to the bus to deregister |
| * Context: !in_interrupt() |
| * |
| * Recycles the bus number, and unlinks the controller from usbcore data |
| * structures so that it won't be seen by scanning the bus list. |
| */ |
| static void usb_deregister_bus (struct usb_bus *bus) |
| { |
| dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum); |
| |
| /* |
| * NOTE: make sure that all the devices are removed by the |
| * controller code, as well as having it call this when cleaning |
| * itself up |
| */ |
| mutex_lock(&usb_bus_list_lock); |
| list_del (&bus->bus_list); |
| mutex_unlock(&usb_bus_list_lock); |
| |
| usb_notify_remove_bus(bus); |
| |
| clear_bit (bus->busnum, busmap.busmap); |
| } |
| |
| /** |
| * register_root_hub - called by usb_add_hcd() to register a root hub |
| * @hcd: host controller for this root hub |
| * |
| * This function registers the root hub with the USB subsystem. It sets up |
| * the device properly in the device tree and then calls usb_new_device() |
| * to register the usb device. It also assigns the root hub's USB address |
| * (always 1). |
| */ |
| static int register_root_hub(struct usb_hcd *hcd) |
| { |
| struct device *parent_dev = hcd->self.controller; |
| struct usb_device *usb_dev = hcd->self.root_hub; |
| const int devnum = 1; |
| int retval; |
| |
| usb_dev->devnum = devnum; |
| usb_dev->bus->devnum_next = devnum + 1; |
| memset (&usb_dev->bus->devmap.devicemap, 0, |
| sizeof usb_dev->bus->devmap.devicemap); |
| set_bit (devnum, usb_dev->bus->devmap.devicemap); |
| usb_set_device_state(usb_dev, USB_STATE_ADDRESS); |
| |
| mutex_lock(&usb_bus_list_lock); |
| |
| usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64); |
| retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE); |
| if (retval != sizeof usb_dev->descriptor) { |
| mutex_unlock(&usb_bus_list_lock); |
| dev_dbg (parent_dev, "can't read %s device descriptor %d\n", |
| dev_name(&usb_dev->dev), retval); |
| return (retval < 0) ? retval : -EMSGSIZE; |
| } |
| |
| retval = usb_new_device (usb_dev); |
| if (retval) { |
| dev_err (parent_dev, "can't register root hub for %s, %d\n", |
| dev_name(&usb_dev->dev), retval); |
| } |
| mutex_unlock(&usb_bus_list_lock); |
| |
| if (retval == 0) { |
| spin_lock_irq (&hcd_root_hub_lock); |
| hcd->rh_registered = 1; |
| spin_unlock_irq (&hcd_root_hub_lock); |
| |
| /* Did the HC die before the root hub was registered? */ |
| if (hcd->state == HC_STATE_HALT) |
| usb_hc_died (hcd); /* This time clean up */ |
| } |
| |
| return retval; |
| } |
| |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * usb_calc_bus_time - approximate periodic transaction time in nanoseconds |
| * @speed: from dev->speed; USB_SPEED_{LOW,FULL,HIGH} |
| * @is_input: true iff the transaction sends data to the host |
| * @isoc: true for isochronous transactions, false for interrupt ones |
| * @bytecount: how many bytes in the transaction. |
| * |
| * Returns approximate bus time in nanoseconds for a periodic transaction. |
| * See USB 2.0 spec section 5.11.3; only periodic transfers need to be |
| * scheduled in software, this function is only used for such scheduling. |
| */ |
| long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount) |
| { |
| unsigned long tmp; |
| |
| switch (speed) { |
| case USB_SPEED_LOW: /* INTR only */ |
| if (is_input) { |
| tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L; |
| return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp); |
| } else { |
| tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L; |
| return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp); |
| } |
| case USB_SPEED_FULL: /* ISOC or INTR */ |
| if (isoc) { |
| tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L; |
| return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp); |
| } else { |
| tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L; |
| return (9107L + BW_HOST_DELAY + tmp); |
| } |
| case USB_SPEED_HIGH: /* ISOC or INTR */ |
| // FIXME adjust for input vs output |
| if (isoc) |
| tmp = HS_NSECS_ISO (bytecount); |
| else |
| tmp = HS_NSECS (bytecount); |
| return tmp; |
| default: |
| pr_debug ("%s: bogus device speed!\n", usbcore_name); |
| return -1; |
| } |
| } |
| EXPORT_SYMBOL_GPL(usb_calc_bus_time); |
| |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* |
| * Generic HC operations. |
| */ |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * usb_hcd_link_urb_to_ep - add an URB to its endpoint queue |
| * @hcd: host controller to which @urb was submitted |
| * @urb: URB being submitted |
| * |
| * Host controller drivers should call this routine in their enqueue() |
| * method. The HCD's private spinlock must be held and interrupts must |
| * be disabled. The actions carried out here are required for URB |
| * submission, as well as for endpoint shutdown and for usb_kill_urb. |
| * |
| * Returns 0 for no error, otherwise a negative error code (in which case |
| * the enqueue() method must fail). If no error occurs but enqueue() fails |
| * anyway, it must call usb_hcd_unlink_urb_from_ep() before releasing |
| * the private spinlock and returning. |
| */ |
| int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb) |
| { |
| int rc = 0; |
| |
| spin_lock(&hcd_urb_list_lock); |
| |
| /* Check that the URB isn't being killed */ |
| if (unlikely(atomic_read(&urb->reject))) { |
| rc = -EPERM; |
| goto done; |
| } |
| |
| if (unlikely(!urb->ep->enabled)) { |
| rc = -ENOENT; |
| goto done; |
| } |
| |
| if (unlikely(!urb->dev->can_submit)) { |
| rc = -EHOSTUNREACH; |
| goto done; |
| } |
| |
| /* |
| * Check the host controller's state and add the URB to the |
| * endpoint's queue. |
| */ |
| switch (hcd->state) { |
| case HC_STATE_RUNNING: |
| case HC_STATE_RESUMING: |
| urb->unlinked = 0; |
| list_add_tail(&urb->urb_list, &urb->ep->urb_list); |
| break; |
| default: |
| rc = -ESHUTDOWN; |
| goto done; |
| } |
| done: |
| spin_unlock(&hcd_urb_list_lock); |
| return rc; |
| } |
| EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep); |
| |
| /** |
| * usb_hcd_check_unlink_urb - check whether an URB may be unlinked |
| * @hcd: host controller to which @urb was submitted |
| * @urb: URB being checked for unlinkability |
| * @status: error code to store in @urb if the unlink succeeds |
| * |
| * Host controller drivers should call this routine in their dequeue() |
| * method. The HCD's private spinlock must be held and interrupts must |
| * be disabled. The actions carried out here are required for making |
| * sure than an unlink is valid. |
| * |
| * Returns 0 for no error, otherwise a negative error code (in which case |
| * the dequeue() method must fail). The possible error codes are: |
| * |
| * -EIDRM: @urb was not submitted or has already completed. |
| * The completion function may not have been called yet. |
| * |
| * -EBUSY: @urb has already been unlinked. |
| */ |
| int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb, |
| int status) |
| { |
| struct list_head *tmp; |
| |
| /* insist the urb is still queued */ |
| list_for_each(tmp, &urb->ep->urb_list) { |
| if (tmp == &urb->urb_list) |
| break; |
| } |
| if (tmp != &urb->urb_list) |
| return -EIDRM; |
| |
| /* Any status except -EINPROGRESS means something already started to |
| * unlink this URB from the hardware. So there's no more work to do. |
| */ |
| if (urb->unlinked) |
| return -EBUSY; |
| urb->unlinked = status; |
| |
| /* IRQ setup can easily be broken so that USB controllers |
| * never get completion IRQs ... maybe even the ones we need to |
| * finish unlinking the initial failed usb_set_address() |
| * or device descriptor fetch. |
| */ |
| if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) && |
| !is_root_hub(urb->dev)) { |
| dev_warn(hcd->self.controller, "Unlink after no-IRQ? " |
| "Controller is probably using the wrong IRQ.\n"); |
| set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags); |
| } |
| |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb); |
| |
| /** |
| * usb_hcd_unlink_urb_from_ep - remove an URB from its endpoint queue |
| * @hcd: host controller to which @urb was submitted |
| * @urb: URB being unlinked |
| * |
| * Host controller drivers should call this routine before calling |
| * usb_hcd_giveback_urb(). The HCD's private spinlock must be held and |
| * interrupts must be disabled. The actions carried out here are required |
| * for URB completion. |
| */ |
| void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb) |
| { |
| /* clear all state linking urb to this dev (and hcd) */ |
| spin_lock(&hcd_urb_list_lock); |
| list_del_init(&urb->urb_list); |
| spin_unlock(&hcd_urb_list_lock); |
| } |
| EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep); |
| |
| /* |
| * Some usb host controllers can only perform dma using a small SRAM area. |
| * The usb core itself is however optimized for host controllers that can dma |
| * using regular system memory - like pci devices doing bus mastering. |
| * |
| * To support host controllers with limited dma capabilites we provide dma |
| * bounce buffers. This feature can be enabled using the HCD_LOCAL_MEM flag. |
| * For this to work properly the host controller code must first use the |
| * function dma_declare_coherent_memory() to point out which memory area |
| * that should be used for dma allocations. |
| * |
| * The HCD_LOCAL_MEM flag then tells the usb code to allocate all data for |
| * dma using dma_alloc_coherent() which in turn allocates from the memory |
| * area pointed out with dma_declare_coherent_memory(). |
| * |
| * So, to summarize... |
| * |
| * - We need "local" memory, canonical example being |
| * a small SRAM on a discrete controller being the |
| * only memory that the controller can read ... |
| * (a) "normal" kernel memory is no good, and |
| * (b) there's not enough to share |
| * |
| * - The only *portable* hook for such stuff in the |
| * DMA framework is dma_declare_coherent_memory() |
| * |
| * - So we use that, even though the primary requirement |
| * is that the memory be "local" (hence addressible |
| * by that device), not "coherent". |
| * |
| */ |
| |
| static int hcd_alloc_coherent(struct usb_bus *bus, |
| gfp_t mem_flags, dma_addr_t *dma_handle, |
| void **vaddr_handle, size_t size, |
| enum dma_data_direction dir) |
| { |
| unsigned char *vaddr; |
| |
| vaddr = hcd_buffer_alloc(bus, size + sizeof(vaddr), |
| mem_flags, dma_handle); |
| if (!vaddr) |
| return -ENOMEM; |
| |
| /* |
| * Store the virtual address of the buffer at the end |
| * of the allocated dma buffer. The size of the buffer |
| * may be uneven so use unaligned functions instead |
| * of just rounding up. It makes sense to optimize for |
| * memory footprint over access speed since the amount |
| * of memory available for dma may be limited. |
| */ |
| put_unaligned((unsigned long)*vaddr_handle, |
| (unsigned long *)(vaddr + size)); |
| |
| if (dir == DMA_TO_DEVICE) |
| memcpy(vaddr, *vaddr_handle, size); |
| |
| *vaddr_handle = vaddr; |
| return 0; |
| } |
| |
| static void hcd_free_coherent(struct usb_bus *bus, dma_addr_t *dma_handle, |
| void **vaddr_handle, size_t size, |
| enum dma_data_direction dir) |
| { |
| unsigned char *vaddr = *vaddr_handle; |
| |
| vaddr = (void *)get_unaligned((unsigned long *)(vaddr + size)); |
| |
| if (dir == DMA_FROM_DEVICE) |
| memcpy(vaddr, *vaddr_handle, size); |
| |
| hcd_buffer_free(bus, size + sizeof(vaddr), *vaddr_handle, *dma_handle); |
| |
| *vaddr_handle = vaddr; |
| *dma_handle = 0; |
| } |
| |
| static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, |
| gfp_t mem_flags) |
| { |
| enum dma_data_direction dir; |
| int ret = 0; |
| |
| /* Map the URB's buffers for DMA access. |
| * Lower level HCD code should use *_dma exclusively, |
| * unless it uses pio or talks to another transport, |
| * or uses the provided scatter gather list for bulk. |
| */ |
| if (is_root_hub(urb->dev)) |
| return 0; |
| |
| if (usb_endpoint_xfer_control(&urb->ep->desc) |
| && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) { |
| if (hcd->self.uses_dma) { |
| urb->setup_dma = dma_map_single( |
| hcd->self.controller, |
| urb->setup_packet, |
| sizeof(struct usb_ctrlrequest), |
| DMA_TO_DEVICE); |
| if (dma_mapping_error(hcd->self.controller, |
| urb->setup_dma)) |
| return -EAGAIN; |
| } else if (hcd->driver->flags & HCD_LOCAL_MEM) |
| ret = hcd_alloc_coherent( |
| urb->dev->bus, mem_flags, |
| &urb->setup_dma, |
| (void **)&urb->setup_packet, |
| sizeof(struct usb_ctrlrequest), |
| DMA_TO_DEVICE); |
| } |
| |
| dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE; |
| if (ret == 0 && urb->transfer_buffer_length != 0 |
| && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) { |
| if (hcd->self.uses_dma) { |
| urb->transfer_dma = dma_map_single ( |
| hcd->self.controller, |
| urb->transfer_buffer, |
| urb->transfer_buffer_length, |
| dir); |
| if (dma_mapping_error(hcd->self.controller, |
| urb->transfer_dma)) |
| return -EAGAIN; |
| } else if (hcd->driver->flags & HCD_LOCAL_MEM) { |
| ret = hcd_alloc_coherent( |
| urb->dev->bus, mem_flags, |
| &urb->transfer_dma, |
| &urb->transfer_buffer, |
| urb->transfer_buffer_length, |
| dir); |
| |
| if (ret && usb_endpoint_xfer_control(&urb->ep->desc) |
| && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) |
| hcd_free_coherent(urb->dev->bus, |
| &urb->setup_dma, |
| (void **)&urb->setup_packet, |
| sizeof(struct usb_ctrlrequest), |
| DMA_TO_DEVICE); |
| } |
| } |
| return ret; |
| } |
| |
| static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb) |
| { |
| enum dma_data_direction dir; |
| |
| if (is_root_hub(urb->dev)) |
| return; |
| |
| if (usb_endpoint_xfer_control(&urb->ep->desc) |
| && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) { |
| if (hcd->self.uses_dma) |
| dma_unmap_single(hcd->self.controller, urb->setup_dma, |
| sizeof(struct usb_ctrlrequest), |
| DMA_TO_DEVICE); |
| else if (hcd->driver->flags & HCD_LOCAL_MEM) |
| hcd_free_coherent(urb->dev->bus, &urb->setup_dma, |
| (void **)&urb->setup_packet, |
| sizeof(struct usb_ctrlrequest), |
| DMA_TO_DEVICE); |
| } |
| |
| dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE; |
| if (urb->transfer_buffer_length != 0 |
| && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) { |
| if (hcd->self.uses_dma) |
| dma_unmap_single(hcd->self.controller, |
| urb->transfer_dma, |
| urb->transfer_buffer_length, |
| dir); |
| else if (hcd->driver->flags & HCD_LOCAL_MEM) |
| hcd_free_coherent(urb->dev->bus, &urb->transfer_dma, |
| &urb->transfer_buffer, |
| urb->transfer_buffer_length, |
| dir); |
| } |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* may be called in any context with a valid urb->dev usecount |
| * caller surrenders "ownership" of urb |
| * expects usb_submit_urb() to have sanity checked and conditioned all |
| * inputs in the urb |
| */ |
| int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags) |
| { |
| int status; |
| struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus); |
| |
| /* increment urb's reference count as part of giving it to the HCD |
| * (which will control it). HCD guarantees that it either returns |
| * an error or calls giveback(), but not both. |
| */ |
| usb_get_urb(urb); |
| atomic_inc(&urb->use_count); |
| atomic_inc(&urb->dev->urbnum); |
| usbmon_urb_submit(&hcd->self, urb); |
| |
| /* NOTE requirements on root-hub callers (usbfs and the hub |
| * driver, for now): URBs' urb->transfer_buffer must be |
| * valid and usb_buffer_{sync,unmap}() not be needed, since |
| * they could clobber root hub response data. Also, control |
| * URBs must be submitted in process context with interrupts |
| * enabled. |
| */ |
| status = map_urb_for_dma(hcd, urb, mem_flags); |
| if (unlikely(status)) { |
| usbmon_urb_submit_error(&hcd->self, urb, status); |
| goto error; |
| } |
| |
| if (is_root_hub(urb->dev)) |
| status = rh_urb_enqueue(hcd, urb); |
| else |
| status = hcd->driver->urb_enqueue(hcd, urb, mem_flags); |
| |
| if (unlikely(status)) { |
| usbmon_urb_submit_error(&hcd->self, urb, status); |
| unmap_urb_for_dma(hcd, urb); |
| error: |
| urb->hcpriv = NULL; |
| INIT_LIST_HEAD(&urb->urb_list); |
| atomic_dec(&urb->use_count); |
| atomic_dec(&urb->dev->urbnum); |
| if (atomic_read(&urb->reject)) |
| wake_up(&usb_kill_urb_queue); |
| usb_put_urb(urb); |
| } |
| return status; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* this makes the hcd giveback() the urb more quickly, by kicking it |
| * off hardware queues (which may take a while) and returning it as |
| * soon as practical. we've already set up the urb's return status, |
| * but we can't know if the callback completed already. |
| */ |
| static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status) |
| { |
| int value; |
| |
| if (is_root_hub(urb->dev)) |
| value = usb_rh_urb_dequeue(hcd, urb, status); |
| else { |
| |
| /* The only reason an HCD might fail this call is if |
| * it has not yet fully queued the urb to begin with. |
| * Such failures should be harmless. */ |
| value = hcd->driver->urb_dequeue(hcd, urb, status); |
| } |
| return value; |
| } |
| |
| /* |
| * called in any context |
| * |
| * caller guarantees urb won't be recycled till both unlink() |
| * and the urb's completion function return |
| */ |
| int usb_hcd_unlink_urb (struct urb *urb, int status) |
| { |
| struct usb_hcd *hcd; |
| int retval = -EIDRM; |
| unsigned long flags; |
| |
| /* Prevent the device and bus from going away while |
| * the unlink is carried out. If they are already gone |
| * then urb->use_count must be 0, since disconnected |
| * devices can't have any active URBs. |
| */ |
| spin_lock_irqsave(&hcd_urb_unlink_lock, flags); |
| if (atomic_read(&urb->use_count) > 0) { |
| retval = 0; |
| usb_get_dev(urb->dev); |
| } |
| spin_unlock_irqrestore(&hcd_urb_unlink_lock, flags); |
| if (retval == 0) { |
| hcd = bus_to_hcd(urb->dev->bus); |
| retval = unlink1(hcd, urb, status); |
| usb_put_dev(urb->dev); |
| } |
| |
| if (retval == 0) |
| retval = -EINPROGRESS; |
| else if (retval != -EIDRM && retval != -EBUSY) |
| dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n", |
| urb, retval); |
| return retval; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * usb_hcd_giveback_urb - return URB from HCD to device driver |
| * @hcd: host controller returning the URB |
| * @urb: urb being returned to the USB device driver. |
| * @status: completion status code for the URB. |
| * Context: in_interrupt() |
| * |
| * This hands the URB from HCD to its USB device driver, using its |
| * completion function. The HCD has freed all per-urb resources |
| * (and is done using urb->hcpriv). It also released all HCD locks; |
| * the device driver won't cause problems if it frees, modifies, |
| * or resubmits this URB. |
| * |
| * If @urb was unlinked, the value of @status will be overridden by |
| * @urb->unlinked. Erroneous short transfers are detected in case |
| * the HCD hasn't checked for them. |
| */ |
| void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status) |
| { |
| urb->hcpriv = NULL; |
| if (unlikely(urb->unlinked)) |
| status = urb->unlinked; |
| else if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) && |
| urb->actual_length < urb->transfer_buffer_length && |
| !status)) |
| status = -EREMOTEIO; |
| |
| unmap_urb_for_dma(hcd, urb); |
| usbmon_urb_complete(&hcd->self, urb, status); |
| usb_unanchor_urb(urb); |
| |
| /* pass ownership to the completion handler */ |
| urb->status = status; |
| urb->complete (urb); |
| atomic_dec (&urb->use_count); |
| if (unlikely(atomic_read(&urb->reject))) |
| wake_up (&usb_kill_urb_queue); |
| usb_put_urb (urb); |
| } |
| EXPORT_SYMBOL_GPL(usb_hcd_giveback_urb); |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* Cancel all URBs pending on this endpoint and wait for the endpoint's |
| * queue to drain completely. The caller must first insure that no more |
| * URBs can be submitted for this endpoint. |
| */ |
| void usb_hcd_flush_endpoint(struct usb_device *udev, |
| struct usb_host_endpoint *ep) |
| { |
| struct usb_hcd *hcd; |
| struct urb *urb; |
| |
| if (!ep) |
| return; |
| might_sleep(); |
| hcd = bus_to_hcd(udev->bus); |
| |
| /* No more submits can occur */ |
| spin_lock_irq(&hcd_urb_list_lock); |
| rescan: |
| list_for_each_entry (urb, &ep->urb_list, urb_list) { |
| int is_in; |
| |
| if (urb->unlinked) |
| continue; |
| usb_get_urb (urb); |
| is_in = usb_urb_dir_in(urb); |
| spin_unlock(&hcd_urb_list_lock); |
| |
| /* kick hcd */ |
| unlink1(hcd, urb, -ESHUTDOWN); |
| dev_dbg (hcd->self.controller, |
| "shutdown urb %p ep%d%s%s\n", |
| urb, usb_endpoint_num(&ep->desc), |
| is_in ? "in" : "out", |
| ({ char *s; |
| |
| switch (usb_endpoint_type(&ep->desc)) { |
| case USB_ENDPOINT_XFER_CONTROL: |
| s = ""; break; |
| case USB_ENDPOINT_XFER_BULK: |
| s = "-bulk"; break; |
| case USB_ENDPOINT_XFER_INT: |
| s = "-intr"; break; |
| default: |
| s = "-iso"; break; |
| }; |
| s; |
| })); |
| usb_put_urb (urb); |
| |
| /* list contents may have changed */ |
| spin_lock(&hcd_urb_list_lock); |
| goto rescan; |
| } |
| spin_unlock_irq(&hcd_urb_list_lock); |
| |
| /* Wait until the endpoint queue is completely empty */ |
| while (!list_empty (&ep->urb_list)) { |
| spin_lock_irq(&hcd_urb_list_lock); |
| |
| /* The list may have changed while we acquired the spinlock */ |
| urb = NULL; |
| if (!list_empty (&ep->urb_list)) { |
| urb = list_entry (ep->urb_list.prev, struct urb, |
| urb_list); |
| usb_get_urb (urb); |
| } |
| spin_unlock_irq(&hcd_urb_list_lock); |
| |
| if (urb) { |
| usb_kill_urb (urb); |
| usb_put_urb (urb); |
| } |
| } |
| } |
| |
| /** |
| * usb_hcd_alloc_bandwidth - check whether a new bandwidth setting exceeds |
| * the bus bandwidth |
| * @udev: target &usb_device |
| * @new_config: new configuration to install |
| * @cur_alt: the current alternate interface setting |
| * @new_alt: alternate interface setting that is being installed |
| * |
| * To change configurations, pass in the new configuration in new_config, |
| * and pass NULL for cur_alt and new_alt. |
| * |
| * To reset a device's configuration (put the device in the ADDRESSED state), |
| * pass in NULL for new_config, cur_alt, and new_alt. |
| * |
| * To change alternate interface settings, pass in NULL for new_config, |
| * pass in the current alternate interface setting in cur_alt, |
| * and pass in the new alternate interface setting in new_alt. |
| * |
| * Returns an error if the requested bandwidth change exceeds the |
| * bus bandwidth or host controller internal resources. |
| */ |
| int usb_hcd_alloc_bandwidth(struct usb_device *udev, |
| struct usb_host_config *new_config, |
| struct usb_host_interface *cur_alt, |
| struct usb_host_interface *new_alt) |
| { |
| int num_intfs, i, j; |
| struct usb_host_interface *alt = NULL; |
| int ret = 0; |
| struct usb_hcd *hcd; |
| struct usb_host_endpoint *ep; |
| |
| hcd = bus_to_hcd(udev->bus); |
| if (!hcd->driver->check_bandwidth) |
| return 0; |
| |
| /* Configuration is being removed - set configuration 0 */ |
| if (!new_config && !cur_alt) { |
| for (i = 1; i < 16; ++i) { |
| ep = udev->ep_out[i]; |
| if (ep) |
| hcd->driver->drop_endpoint(hcd, udev, ep); |
| ep = udev->ep_in[i]; |
| if (ep) |
| hcd->driver->drop_endpoint(hcd, udev, ep); |
| } |
| hcd->driver->check_bandwidth(hcd, udev); |
| return 0; |
| } |
| /* Check if the HCD says there's enough bandwidth. Enable all endpoints |
| * each interface's alt setting 0 and ask the HCD to check the bandwidth |
| * of the bus. There will always be bandwidth for endpoint 0, so it's |
| * ok to exclude it. |
| */ |
| if (new_config) { |
| num_intfs = new_config->desc.bNumInterfaces; |
| /* Remove endpoints (except endpoint 0, which is always on the |
| * schedule) from the old config from the schedule |
| */ |
| for (i = 1; i < 16; ++i) { |
| ep = udev->ep_out[i]; |
| if (ep) { |
| ret = hcd->driver->drop_endpoint(hcd, udev, ep); |
| if (ret < 0) |
| goto reset; |
| } |
| ep = udev->ep_in[i]; |
| if (ep) { |
| ret = hcd->driver->drop_endpoint(hcd, udev, ep); |
| if (ret < 0) |
| goto reset; |
| } |
| } |
| for (i = 0; i < num_intfs; ++i) { |
| struct usb_host_interface *first_alt; |
| int iface_num; |
| |
| first_alt = &new_config->intf_cache[i]->altsetting[0]; |
| iface_num = first_alt->desc.bInterfaceNumber; |
| /* Set up endpoints for alternate interface setting 0 */ |
| alt = usb_find_alt_setting(new_config, iface_num, 0); |
| if (!alt) |
| /* No alt setting 0? Pick the first setting. */ |
| alt = first_alt; |
| |
| for (j = 0; j < alt->desc.bNumEndpoints; j++) { |
| ret = hcd->driver->add_endpoint(hcd, udev, &alt->endpoint[j]); |
| if (ret < 0) |
| goto reset; |
| } |
| } |
| } |
| if (cur_alt && new_alt) { |
| struct usb_interface *iface = usb_ifnum_to_if(udev, |
| cur_alt->desc.bInterfaceNumber); |
| |
| if (iface->resetting_device) { |
| /* |
| * The USB core just reset the device, so the xHCI host |
| * and the device will think alt setting 0 is installed. |
| * However, the USB core will pass in the alternate |
| * setting installed before the reset as cur_alt. Dig |
| * out the alternate setting 0 structure, or the first |
| * alternate setting if a broken device doesn't have alt |
| * setting 0. |
| */ |
| cur_alt = usb_altnum_to_altsetting(iface, 0); |
| if (!cur_alt) |
| cur_alt = &iface->altsetting[0]; |
| } |
| |
| /* Drop all the endpoints in the current alt setting */ |
| for (i = 0; i < cur_alt->desc.bNumEndpoints; i++) { |
| ret = hcd->driver->drop_endpoint(hcd, udev, |
| &cur_alt->endpoint[i]); |
| if (ret < 0) |
| goto reset; |
| } |
| /* Add all the endpoints in the new alt setting */ |
| for (i = 0; i < new_alt->desc.bNumEndpoints; i++) { |
| ret = hcd->driver->add_endpoint(hcd, udev, |
| &new_alt->endpoint[i]); |
| if (ret < 0) |
| goto reset; |
| } |
| } |
| ret = hcd->driver->check_bandwidth(hcd, udev); |
| reset: |
| if (ret < 0) |
| hcd->driver->reset_bandwidth(hcd, udev); |
| return ret; |
| } |
| |
| /* Disables the endpoint: synchronizes with the hcd to make sure all |
| * endpoint state is gone from hardware. usb_hcd_flush_endpoint() must |
| * have been called previously. Use for set_configuration, set_interface, |
| * driver removal, physical disconnect. |
| * |
| * example: a qh stored in ep->hcpriv, holding state related to endpoint |
| * type, maxpacket size, toggle, halt status, and scheduling. |
| */ |
| void usb_hcd_disable_endpoint(struct usb_device *udev, |
| struct usb_host_endpoint *ep) |
| { |
| struct usb_hcd *hcd; |
| |
| might_sleep(); |
| hcd = bus_to_hcd(udev->bus); |
| if (hcd->driver->endpoint_disable) |
| hcd->driver->endpoint_disable(hcd, ep); |
| } |
| |
| /** |
| * usb_hcd_reset_endpoint - reset host endpoint state |
| * @udev: USB device. |
| * @ep: the endpoint to reset. |
| * |
| * Resets any host endpoint state such as the toggle bit, sequence |
| * number and current window. |
| */ |
| void usb_hcd_reset_endpoint(struct usb_device *udev, |
| struct usb_host_endpoint *ep) |
| { |
| struct usb_hcd *hcd = bus_to_hcd(udev->bus); |
| |
| if (hcd->driver->endpoint_reset) |
| hcd->driver->endpoint_reset(hcd, ep); |
| else { |
| int epnum = usb_endpoint_num(&ep->desc); |
| int is_out = usb_endpoint_dir_out(&ep->desc); |
| int is_control = usb_endpoint_xfer_control(&ep->desc); |
| |
| usb_settoggle(udev, epnum, is_out, 0); |
| if (is_control) |
| usb_settoggle(udev, epnum, !is_out, 0); |
| } |
| } |
| |
| /* Protect against drivers that try to unlink URBs after the device |
| * is gone, by waiting until all unlinks for @udev are finished. |
| * Since we don't currently track URBs by device, simply wait until |
| * nothing is running in the locked region of usb_hcd_unlink_urb(). |
| */ |
| void usb_hcd_synchronize_unlinks(struct usb_device *udev) |
| { |
| spin_lock_irq(&hcd_urb_unlink_lock); |
| spin_unlock_irq(&hcd_urb_unlink_lock); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /* called in any context */ |
| int usb_hcd_get_frame_number (struct usb_device *udev) |
| { |
| struct usb_hcd *hcd = bus_to_hcd(udev->bus); |
| |
| if (!HC_IS_RUNNING (hcd->state)) |
| return -ESHUTDOWN; |
| return hcd->driver->get_frame_number (hcd); |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| #ifdef CONFIG_PM |
| |
| int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg) |
| { |
| struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self); |
| int status; |
| int old_state = hcd->state; |
| |
| dev_dbg(&rhdev->dev, "bus %s%s\n", |
| (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend"); |
| if (!hcd->driver->bus_suspend) { |
| status = -ENOENT; |
| } else { |
| hcd->state = HC_STATE_QUIESCING; |
| status = hcd->driver->bus_suspend(hcd); |
| } |
| if (status == 0) { |
| usb_set_device_state(rhdev, USB_STATE_SUSPENDED); |
| hcd->state = HC_STATE_SUSPENDED; |
| } else { |
| hcd->state = old_state; |
| dev_dbg(&rhdev->dev, "bus %s fail, err %d\n", |
| "suspend", status); |
| } |
| return status; |
| } |
| |
| int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg) |
| { |
| struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self); |
| int status; |
| int old_state = hcd->state; |
| |
| dev_dbg(&rhdev->dev, "usb %s%s\n", |
| (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "resume"); |
| if (!hcd->driver->bus_resume) |
| return -ENOENT; |
| if (hcd->state == HC_STATE_RUNNING) |
| return 0; |
| |
| hcd->state = HC_STATE_RESUMING; |
| status = hcd->driver->bus_resume(hcd); |
| if (status == 0) { |
| /* TRSMRCY = 10 msec */ |
| msleep(10); |
| usb_set_device_state(rhdev, rhdev->actconfig |
| ? USB_STATE_CONFIGURED |
| : USB_STATE_ADDRESS); |
| hcd->state = HC_STATE_RUNNING; |
| } else { |
| hcd->state = old_state; |
| dev_dbg(&rhdev->dev, "bus %s fail, err %d\n", |
| "resume", status); |
| if (status != -ESHUTDOWN) |
| usb_hc_died(hcd); |
| } |
| return status; |
| } |
| |
| /* Workqueue routine for root-hub remote wakeup */ |
| static void hcd_resume_work(struct work_struct *work) |
| { |
| struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work); |
| struct usb_device *udev = hcd->self.root_hub; |
| |
| usb_lock_device(udev); |
| usb_remote_wakeup(udev); |
| usb_unlock_device(udev); |
| } |
| |
| /** |
| * usb_hcd_resume_root_hub - called by HCD to resume its root hub |
| * @hcd: host controller for this root hub |
| * |
| * The USB host controller calls this function when its root hub is |
| * suspended (with the remote wakeup feature enabled) and a remote |
| * wakeup request is received. The routine submits a workqueue request |
| * to resume the root hub (that is, manage its downstream ports again). |
| */ |
| void usb_hcd_resume_root_hub (struct usb_hcd *hcd) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave (&hcd_root_hub_lock, flags); |
| if (hcd->rh_registered) |
| queue_work(ksuspend_usb_wq, &hcd->wakeup_work); |
| spin_unlock_irqrestore (&hcd_root_hub_lock, flags); |
| } |
| EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub); |
| |
| #endif |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| #ifdef CONFIG_USB_OTG |
| |
| /** |
| * usb_bus_start_enum - start immediate enumeration (for OTG) |
| * @bus: the bus (must use hcd framework) |
| * @port_num: 1-based number of port; usually bus->otg_port |
| * Context: in_interrupt() |
| * |
| * Starts enumeration, with an immediate reset followed later by |
| * khubd identifying and possibly configuring the device. |
| * This is needed by OTG controller drivers, where it helps meet |
| * HNP protocol timing requirements for starting a port reset. |
| */ |
| int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num) |
| { |
| struct usb_hcd *hcd; |
| int status = -EOPNOTSUPP; |
| |
| /* NOTE: since HNP can't start by grabbing the bus's address0_sem, |
| * boards with root hubs hooked up to internal devices (instead of |
| * just the OTG port) may need more attention to resetting... |
| */ |
| hcd = container_of (bus, struct usb_hcd, self); |
| if (port_num && hcd->driver->start_port_reset) |
| status = hcd->driver->start_port_reset(hcd, port_num); |
| |
| /* run khubd shortly after (first) root port reset finishes; |
| * it may issue others, until at least 50 msecs have passed. |
| */ |
| if (status == 0) |
| mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(10)); |
| return status; |
| } |
| EXPORT_SYMBOL_GPL(usb_bus_start_enum); |
| |
| #endif |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * usb_hcd_irq - hook IRQs to HCD framework (bus glue) |
| * @irq: the IRQ being raised |
| * @__hcd: pointer to the HCD whose IRQ is being signaled |
| * |
| * If the controller isn't HALTed, calls the driver's irq handler. |
| * Checks whether the controller is now dead. |
| */ |
| irqreturn_t usb_hcd_irq (int irq, void *__hcd) |
| { |
| struct usb_hcd *hcd = __hcd; |
| unsigned long flags; |
| irqreturn_t rc; |
| |
| /* IRQF_DISABLED doesn't work correctly with shared IRQs |
| * when the first handler doesn't use it. So let's just |
| * assume it's never used. |
| */ |
| local_irq_save(flags); |
| |
| if (unlikely(hcd->state == HC_STATE_HALT || |
| !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) { |
| rc = IRQ_NONE; |
| } else if (hcd->driver->irq(hcd) == IRQ_NONE) { |
| rc = IRQ_NONE; |
| } else { |
| set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags); |
| |
| if (unlikely(hcd->state == HC_STATE_HALT)) |
| usb_hc_died(hcd); |
| rc = IRQ_HANDLED; |
| } |
| |
| local_irq_restore(flags); |
| return rc; |
| } |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * usb_hc_died - report abnormal shutdown of a host controller (bus glue) |
| * @hcd: pointer to the HCD representing the controller |
| * |
| * This is called by bus glue to report a USB host controller that died |
| * while operations may still have been pending. It's called automatically |
| * by the PCI glue, so only glue for non-PCI busses should need to call it. |
| */ |
| void usb_hc_died (struct usb_hcd *hcd) |
| { |
| unsigned long flags; |
| |
| dev_err (hcd->self.controller, "HC died; cleaning up\n"); |
| |
| spin_lock_irqsave (&hcd_root_hub_lock, flags); |
| if (hcd->rh_registered) { |
| hcd->poll_rh = 0; |
| |
| /* make khubd clean up old urbs and devices */ |
| usb_set_device_state (hcd->self.root_hub, |
| USB_STATE_NOTATTACHED); |
| usb_kick_khubd (hcd->self.root_hub); |
| } |
| spin_unlock_irqrestore (&hcd_root_hub_lock, flags); |
| } |
| EXPORT_SYMBOL_GPL (usb_hc_died); |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| /** |
| * usb_create_hcd - create and initialize an HCD structure |
| * @driver: HC driver that will use this hcd |
| * @dev: device for this HC, stored in hcd->self.controller |
| * @bus_name: value to store in hcd->self.bus_name |
| * Context: !in_interrupt() |
| * |
| * Allocate a struct usb_hcd, with extra space at the end for the |
| * HC driver's private data. Initialize the generic members of the |
| * hcd structure. |
| * |
| * If memory is unavailable, returns NULL. |
| */ |
| struct usb_hcd *usb_create_hcd (const struct hc_driver *driver, |
| struct device *dev, const char *bus_name) |
| { |
| struct usb_hcd *hcd; |
| |
| hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL); |
| if (!hcd) { |
| dev_dbg (dev, "hcd alloc failed\n"); |
| return NULL; |
| } |
| dev_set_drvdata(dev, hcd); |
| kref_init(&hcd->kref); |
| |
| usb_bus_init(&hcd->self); |
| hcd->self.controller = dev; |
| hcd->self.bus_name = bus_name; |
| hcd->self.uses_dma = (dev->dma_mask != NULL); |
| |
| init_timer(&hcd->rh_timer); |
| hcd->rh_timer.function = rh_timer_func; |
| hcd->rh_timer.data = (unsigned long) hcd; |
| #ifdef CONFIG_PM |
| INIT_WORK(&hcd->wakeup_work, hcd_resume_work); |
| #endif |
| mutex_init(&hcd->bandwidth_mutex); |
| |
| hcd->driver = driver; |
| hcd->product_desc = (driver->product_desc) ? driver->product_desc : |
| "USB Host Controller"; |
| return hcd; |
| } |
| EXPORT_SYMBOL_GPL(usb_create_hcd); |
| |
| static void hcd_release (struct kref *kref) |
| { |
| struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref); |
| |
| kfree(hcd); |
| } |
| |
| struct usb_hcd *usb_get_hcd (struct usb_hcd *hcd) |
| { |
| if (hcd) |
| kref_get (&hcd->kref); |
| return hcd; |
| } |
| EXPORT_SYMBOL_GPL(usb_get_hcd); |
| |
| void usb_put_hcd (struct usb_hcd *hcd) |
| { |
| if (hcd) |
| kref_put (&hcd->kref, hcd_release); |
| } |
| EXPORT_SYMBOL_GPL(usb_put_hcd); |
| |
| /** |
| * usb_add_hcd - finish generic HCD structure initialization and register |
| * @hcd: the usb_hcd structure to initialize |
| * @irqnum: Interrupt line to allocate |
| * @irqflags: Interrupt type flags |
| * |
| * Finish the remaining parts of generic HCD initialization: allocate the |
| * buffers of consistent memory, register the bus, request the IRQ line, |
| * and call the driver's reset() and start() routines. |
| */ |
| int usb_add_hcd(struct usb_hcd *hcd, |
| unsigned int irqnum, unsigned long irqflags) |
| { |
| int retval; |
| struct usb_device *rhdev; |
| |
| dev_info(hcd->self.controller, "%s\n", hcd->product_desc); |
| |
| hcd->authorized_default = hcd->wireless? 0 : 1; |
| set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); |
| |
| /* HC is in reset state, but accessible. Now do the one-time init, |
| * bottom up so that hcds can customize the root hubs before khubd |
| * starts talking to them. (Note, bus id is assigned early too.) |
| */ |
| if ((retval = hcd_buffer_create(hcd)) != 0) { |
| dev_dbg(hcd->self.controller, "pool alloc failed\n"); |
| return retval; |
| } |
| |
| if ((retval = usb_register_bus(&hcd->self)) < 0) |
| goto err_register_bus; |
| |
| if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) { |
| dev_err(hcd->self.controller, "unable to allocate root hub\n"); |
| retval = -ENOMEM; |
| goto err_allocate_root_hub; |
| } |
| |
| switch (hcd->driver->flags & HCD_MASK) { |
| case HCD_USB11: |
| rhdev->speed = USB_SPEED_FULL; |
| break; |
| case HCD_USB2: |
| rhdev->speed = USB_SPEED_HIGH; |
| break; |
| case HCD_USB3: |
| rhdev->speed = USB_SPEED_SUPER; |
| break; |
| default: |
| goto err_allocate_root_hub; |
| } |
| hcd->self.root_hub = rhdev; |
| |
| /* wakeup flag init defaults to "everything works" for root hubs, |
| * but drivers can override it in reset() if needed, along with |
| * recording the overall controller's system wakeup capability. |
| */ |
| device_init_wakeup(&rhdev->dev, 1); |
| |
| /* "reset" is misnamed; its role is now one-time init. the controller |
| * should already have been reset (and boot firmware kicked off etc). |
| */ |
| if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) { |
| dev_err(hcd->self.controller, "can't setup\n"); |
| goto err_hcd_driver_setup; |
| } |
| |
| /* NOTE: root hub and controller capabilities may not be the same */ |
| if (device_can_wakeup(hcd->self.controller) |
| && device_can_wakeup(&hcd->self.root_hub->dev)) |
| dev_dbg(hcd->self.controller, "supports USB remote wakeup\n"); |
| |
| /* enable irqs just before we start the controller */ |
| if (hcd->driver->irq) { |
| |
| /* IRQF_DISABLED doesn't work as advertised when used together |
| * with IRQF_SHARED. As usb_hcd_irq() will always disable |
| * interrupts we can remove it here. |
| */ |
| if (irqflags & IRQF_SHARED) |
| irqflags &= ~IRQF_DISABLED; |
| |
| snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d", |
| hcd->driver->description, hcd->self.busnum); |
| if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags, |
| hcd->irq_descr, hcd)) != 0) { |
| dev_err(hcd->self.controller, |
| "request interrupt %d failed\n", irqnum); |
| goto err_request_irq; |
| } |
| hcd->irq = irqnum; |
| dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum, |
| (hcd->driver->flags & HCD_MEMORY) ? |
| "io mem" : "io base", |
| (unsigned long long)hcd->rsrc_start); |
| } else { |
| hcd->irq = -1; |
| if (hcd->rsrc_start) |
| dev_info(hcd->self.controller, "%s 0x%08llx\n", |
| (hcd->driver->flags & HCD_MEMORY) ? |
| "io mem" : "io base", |
| (unsigned long long)hcd->rsrc_start); |
| } |
| |
| if ((retval = hcd->driver->start(hcd)) < 0) { |
| dev_err(hcd->self.controller, "startup error %d\n", retval); |
| goto err_hcd_driver_start; |
| } |
| |
| /* starting here, usbcore will pay attention to this root hub */ |
| rhdev->bus_mA = min(500u, hcd->power_budget); |
| if ((retval = register_root_hub(hcd)) != 0) |
| goto err_register_root_hub; |
| |
| retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group); |
| if (retval < 0) { |
| printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n", |
| retval); |
| goto error_create_attr_group; |
| } |
| if (hcd->uses_new_polling && hcd->poll_rh) |
| usb_hcd_poll_rh_status(hcd); |
| return retval; |
| |
| error_create_attr_group: |
| mutex_lock(&usb_bus_list_lock); |
| usb_disconnect(&hcd->self.root_hub); |
| mutex_unlock(&usb_bus_list_lock); |
| err_register_root_hub: |
| hcd->driver->stop(hcd); |
| err_hcd_driver_start: |
| if (hcd->irq >= 0) |
| free_irq(irqnum, hcd); |
| err_request_irq: |
| err_hcd_driver_setup: |
| hcd->self.root_hub = NULL; |
| usb_put_dev(rhdev); |
| err_allocate_root_hub: |
| usb_deregister_bus(&hcd->self); |
| err_register_bus: |
| hcd_buffer_destroy(hcd); |
| return retval; |
| } |
| EXPORT_SYMBOL_GPL(usb_add_hcd); |
| |
| /** |
| * usb_remove_hcd - shutdown processing for generic HCDs |
| * @hcd: the usb_hcd structure to remove |
| * Context: !in_interrupt() |
| * |
| * Disconnects the root hub, then reverses the effects of usb_add_hcd(), |
| * invoking the HCD's stop() method. |
| */ |
| void usb_remove_hcd(struct usb_hcd *hcd) |
| { |
| dev_info(hcd->self.controller, "remove, state %x\n", hcd->state); |
| |
| if (HC_IS_RUNNING (hcd->state)) |
| hcd->state = HC_STATE_QUIESCING; |
| |
| dev_dbg(hcd->self.controller, "roothub graceful disconnect\n"); |
| spin_lock_irq (&hcd_root_hub_lock); |
| hcd->rh_registered = 0; |
| spin_unlock_irq (&hcd_root_hub_lock); |
| |
| #ifdef CONFIG_PM |
| cancel_work_sync(&hcd->wakeup_work); |
| #endif |
| |
| sysfs_remove_group(&hcd->self.root_hub->dev.kobj, &usb_bus_attr_group); |
| mutex_lock(&usb_bus_list_lock); |
| usb_disconnect(&hcd->self.root_hub); |
| mutex_unlock(&usb_bus_list_lock); |
| |
| hcd->driver->stop(hcd); |
| hcd->state = HC_STATE_HALT; |
| |
| hcd->poll_rh = 0; |
| del_timer_sync(&hcd->rh_timer); |
| |
| if (hcd->irq >= 0) |
| free_irq(hcd->irq, hcd); |
| usb_deregister_bus(&hcd->self); |
| hcd_buffer_destroy(hcd); |
| } |
| EXPORT_SYMBOL_GPL(usb_remove_hcd); |
| |
| void |
| usb_hcd_platform_shutdown(struct platform_device* dev) |
| { |
| struct usb_hcd *hcd = platform_get_drvdata(dev); |
| |
| if (hcd->driver->shutdown) |
| hcd->driver->shutdown(hcd); |
| } |
| EXPORT_SYMBOL_GPL(usb_hcd_platform_shutdown); |
| |
| /*-------------------------------------------------------------------------*/ |
| |
| #if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE) |
| |
| struct usb_mon_operations *mon_ops; |
| |
| /* |
| * The registration is unlocked. |
| * We do it this way because we do not want to lock in hot paths. |
| * |
| * Notice that the code is minimally error-proof. Because usbmon needs |
| * symbols from usbcore, usbcore gets referenced and cannot be unloaded first. |
| */ |
| |
| int usb_mon_register (struct usb_mon_operations *ops) |
| { |
| |
| if (mon_ops) |
| return -EBUSY; |
| |
| mon_ops = ops; |
| mb(); |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL (usb_mon_register); |
| |
| void usb_mon_deregister (void) |
| { |
| |
| if (mon_ops == NULL) { |
| printk(KERN_ERR "USB: monitor was not registered\n"); |
| return; |
| } |
| mon_ops = NULL; |
| mb(); |
| } |
| EXPORT_SYMBOL_GPL (usb_mon_deregister); |
| |
| #endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */ |