1.概述
如下图所示，Linux内核中USB主机体系结构由五部分组成，分别为Application Software、USB Class Driver、USB Core(USB Driver)、USB Host Controller Driver、USB Host Controller。应用程序处于用户空间，通过系统调用访问Class Driver，从而间接的访问USB设备，如主机端的应用程序aplay、arecord可以访问USB音频设备。Class Driver是某一类设备驱动，不同类设备会匹配不同的Class Driver，如USB音频设备会匹配Audio驱动，USB存储设备会匹配Mass Storage驱动，鼠标和键盘会匹配HID驱动。USB Core(USB Driver)是内核设计的一个抽象层，目的是将Class Driver和USB Host Controller Driver分隔开，使两者都依赖一个稳定的中间层；USB Core(USB Driver)向上提供通信接口，向下统一管理USB设备，同时完成USB设备和USB Class Driver的匹配工作。USB Host Controller目前有4种不同的硬件级接口标准，分别为OHCI、UHCI、EHCI、xHCI，OHCI和UHCI实现了USB1.1，EHCI实现了USB2.0，xHCI实现了USB3.2，不同的接口标准都有对应的USB Host Controller Driver，如xHCI对应于xhci-hcd驱动，向下兼容OHCI和EHCI。最底层是USB Host Controller硬件。下面将分别介绍Linux内核中USB主机体系结构USB Class Driver、USB Core(USB Driver)、USB Host Controller Driver四个部分。
2.USB Class Driver
Linux内核使用struct usb_driver数据结构描述USB Class Driver，使用usb_register和usb_deregister注册、注销struct usb_driver。USB Class Driver可以使用module_usb_driver宏定义注册驱动。需要注意的是，USB Class Driver是针对USB接口的，如果一个设备是复合设备，每个接口都有不同的功能，则每个接口都有对应的USB Class Driver。主机枚举设备的时候，会识别每个接口的功能同时匹配对应的struct usb_driver，匹配成功后struct usb_driver的probe函数被调用。
[include/linux/usb.h]
struct usb_driver {const char *name; /* USB Class Driver名称，必须唯一且和模块名称一样 *//* 当USB设备的接口和驱动匹配成功后，该函数被调用 */int (*probe) (struct usb_interface *intf,const struct usb_device_id *id);/* 断开USB设备或者卸载驱动模块时调用 */void (*disconnect) (struct usb_interface *intf);/* usbf接口，用户空间可以通过该函数和驱动通信 */int (*unlocked_ioctl) (struct usb_interface *intf,unsigned int code, void *buf);/* 功耗管理相关函数 */int (*suspend) (struct usb_interface *intf, pm_message_t message);int (*resume) (struct usb_interface *intf);int (*reset_resume)(struct usb_interface *intf);/* Called by usb_reset_device() when the device is about to be* reset. This routine must not return until the driver has no active* URBs for the device, and no more URBs may be submitted until the* post_reset method is called. */int (*pre_reset)(struct usb_interface *intf);/* Called by usb_reset_device() after the device has been reset */int (*post_reset)(struct usb_interface *intf);/* 用于匹配USB Class Driver */const struct usb_device_id *id_table;const struct attribute_group **dev_groups;struct usb_dynids dynids;struct usbdrv_wrap drvwrap;unsigned int no_dynamic_id:1;/* if set to 0, the USB core will not allow autosuspend for* interfaces bound to this driver */unsigned int supports_autosuspend:1;/* if set to 1, the USB core will not allow hubs* to initiate lower power link state transitions when an idle timeout* occurs. Device-initiated USB 3.0 link PM will still be allowed.*/unsigned int disable_hub_initiated_lpm:1;/* if set to 1, the USB core will not kill URBs and disable* endpoints before calling the driver's disconnect method.*/unsigned int soft_unbind:1;......
};
/** use these in module_init()/module_exit()* and don't forget MODULE_DEVICE_TABLE(usb, ...)*/
extern int usb_register_driver(struct usb_driver *, struct module *,const char *);/* use a define to avoid include chaining to get THIS_MODULE & friends */
#define usb_register(driver) \usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)extern void usb_deregister(struct usb_driver *);
/*** module_usb_driver() - Helper macro for registering a USB driver* @__usb_driver: usb_driver struct** Helper macro for USB drivers which do not do anything special in module* init/exit. This eliminates a lot of boilerplate. Each module may only* use this macro once, and calling it replaces module_init() and module_exit()*/
#define module_usb_driver(__usb_driver) \module_driver(__usb_driver, usb_register, usb_deregister)
下面是USB Mass Storage的USB Class Driver定义，使用module_usb_stor_driver宏进行注册。U盘、USB硬盘都使用下面的驱动。
[drivers/usb/storage/usb.c]
#define DRV_NAME "usb-storage"
static struct usb_driver usb_storage_driver = {.name = DRV_NAME,.probe = storage_probe,.disconnect = usb_stor_disconnect,.suspend = usb_stor_suspend,.resume = usb_stor_resume,.reset_resume = usb_stor_reset_resume,.pre_reset = usb_stor_pre_reset,.post_reset = usb_stor_post_reset,.id_table = usb_storage_usb_ids,.supports_autosuspend = 1,.soft_unbind = 1,
};
module_usb_stor_driver(usb_storage_driver, usb_stor_host_template, DRV_NAME);[drivers/usb/storage/usb.h]
#define module_usb_stor_driver(__driver, __sht, __name) \
static int __init __driver##_init(void) \
{ \usb_stor_host_template_init(&(__sht), __name, THIS_MODULE); \return usb_register(&(__driver)); \
} \
module_init(__driver##_init); \
static void __exit __driver##_exit(void) \
{ \usb_deregister(&(__driver)); \
} \
module_exit(__driver##_exit)
3.USB Core(USB Driver)
USB Core(USB Driver)有三个功能，第一是向USB Class Driver提供通信接口，第二是匹配驱动，第三是管理USB Device。
3.1.通信接口
USB Core(USB Driver)层封装了USB Request Block数据结构，即struct urb。USB Class Driver只需要分配并填充struct urb，然后调用通信接口将struct urb提交到USB Core(USB Driver)层即可完成和USB设备的通信。
[include/linux/usb.h]
struct urb {/* private: usb core and host controller only fields in the urb */struct kref kref; /* reference count of the URB */int unlinked; /* unlink error code */void *hcpriv; /* private data for host controller */atomic_t use_count; /* concurrent submissions counter */atomic_t reject; /* submissions will fail *//* public: documented fields in the urb that can be used by drivers */struct list_head urb_list; /* list head for use by the urb's current owner */struct list_head anchor_list; /* the URB may be anchored */struct usb_anchor *anchor;struct usb_device *dev; /* (in) pointer to associated device */struct usb_host_endpoint *ep; /* (internal) pointer to endpoint */unsigned int pipe; /* (in) pipe information */unsigned int stream_id; /* (in) stream ID */int status; /* (return) non-ISO status */unsigned int transfer_flags; /* (in) URB_SHORT_NOT_OK | ...*/void *transfer_buffer; /* (in) associated data buffer */dma_addr_t transfer_dma; /* (in) dma addr for transfer_buffer */struct scatterlist *sg; /* (in) scatter gather buffer list */int num_mapped_sgs; /* (internal) mapped sg entries */int num_sgs; /* (in) number of entries in the sg list */u32 transfer_buffer_length; /* (in) data buffer length */u32 actual_length; /* (return) actual transfer length */unsigned char *setup_packet; /* (in) setup packet (control only) */dma_addr_t setup_dma; /* (in) dma addr for setup_packet */int start_frame; /* (modify) start frame (ISO) */int number_of_packets; /* (in) number of ISO packets */int interval; /* (modify) transfer interval (INT/ISO) */int error_count; /* (return) number of ISO errors */void *context; /* (in) context for completion */usb_complete_t complete; /* (in) completion routine */......
};
主要的通信接口定义如下，包含分配、释放、填充、提交和取消URB。提交URB的接口包含了同步接口和异步接口，异步接口经过封装得到同步接口。内核没有封装ISOC传输类型的同步接口，因此ISOC传输只能使用异步接口。
/* initializes a control urb */
static inline void usb_fill_control_urb(struct urb *urb,struct usb_device *dev, unsigned int pipe,unsigned char *setup_packet, void *transfer_buffer,int buffer_length, usb_complete_t complete_fn, void *context)
{......
}
/* macro to help initialize a bulk urb */
static inline void usb_fill_bulk_urb(struct urb *urb,struct usb_device *dev, unsigned int pipe,void *transfer_buffer, int buffer_length,usb_complete_t complete_fn, void *context)
{......
}
/* macro to help initialize a interrupt urb */
static inline void usb_fill_int_urb(struct urb *urb,struct usb_device *dev, unsigned int pipe,void *transfer_buffer, int buffer_length,usb_complete_t complete_fn, void *context, int interval)
{......
}
extern void usb_init_urb(struct urb *urb);
extern struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags);
extern void usb_free_urb(struct urb *urb);/* issue an asynchronous transfer request for an endpoint */
extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags);
/* abort/cancel a transfer request for an endpoint */
extern int usb_unlink_urb(struct urb *urb);/* Builds a control urb, sends it off and waits for completion */
extern int usb_control_msg(struct usb_device *dev, unsigned int pipe,__u8 request, __u8 requesttype, __u16 value, __u16 index,void *data, __u16 size, int timeout);
/* Builds an interrupt urb, sends it off and waits for completion */
extern int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe,void *data, int len, int *actual_length, int timeout);
/* Builds a bulk urb, sends it off and waits for completion */
extern int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,void *data, int len, int *actual_length, int timeout);
通信的目的由pipe表示，pipe的位定义如下所示，其包含了USB设备地址、传输类型、传输方向、端点编号信息。内核提供了一系列定义pipe和解析pipe的宏定义，驱动可以直接使用。
/** For various legacy reasons, Linux has a small cookie that's paired with* a struct usb_device to identify an endpoint queue. Queue characteristics* are defined by the endpoint's descriptor. This cookie is called a "pipe",* an unsigned int encoded as:** - direction: bit 7 (0 = Host-to-Device [Out],* 1 = Device-to-Host [In] ...* like endpoint bEndpointAddress)* - device address: bits 8-14 ... bit positions known to uhci-hcd* - endpoint: bits 15-18 ... bit positions known to uhci-hcd* - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt,* 10 = control, 11 = bulk)** Given the device address and endpoint descriptor, pipes are redundant.*//* NOTE: these are not the standard USB_ENDPOINT_XFER_* values!! */
/* (yet ... they're the values used by usbfs) */
#define PIPE_ISOCHRONOUS 0
#define PIPE_INTERRUPT 1
#define PIPE_CONTROL 2
#define PIPE_BULK 3#define usb_pipein(pipe) ((pipe) & USB_DIR_IN)
#define usb_pipeout(pipe) (!usb_pipein(pipe))#define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f)
#define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf)#define usb_pipetype(pipe) (((pipe) >> 30) & 3)
#define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
#define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT)
#define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL)
#define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK)static inline unsigned int __create_pipe(struct usb_device *dev,unsigned int endpoint)
{return (dev->devnum << 8) | (endpoint << 15);
}/* Create various pipes... */
#define usb_sndctrlpipe(dev, endpoint) \((PIPE_CONTROL << 30) | __create_pipe(dev, endpoint))
#define usb_rcvctrlpipe(dev, endpoint) \((PIPE_CONTROL << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
#define usb_sndisocpipe(dev, endpoint) \((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev, endpoint))
#define usb_rcvisocpipe(dev, endpoint) \((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
#define usb_sndbulkpipe(dev, endpoint) \((PIPE_BULK << 30) | __create_pipe(dev, endpoint))
#define usb_rcvbulkpipe(dev, endpoint) \((PIPE_BULK << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
#define usb_sndintpipe(dev, endpoint) \((PIPE_INTERRUPT << 30) | __create_pipe(dev, endpoint))
#define usb_rcvintpipe(dev, endpoint) \((PIPE_INTERRUPT << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
创建pipe需要两个参数，一个是struct usb_device和endpoint，endpoint为端点描述符中的bEndpointAddress。当USB Class Driver的probe函数被调用时，内核会传入一个和该驱动匹配成功的接口的数据结构，即struct usb_interface。驱动可以通过interface_to_usbdev函数从struct usb_interface获取struct usb_device，endpoint通过usb_find_xx系列函数中获取(ISOC传输需要驱动自己从struct usb_host_interface数据结构中解析)。
[include/linux/usb.h]
struct usb_interface {/* array of alternate settings for this interface,* stored in no particular order */struct usb_host_interface *altsetting;struct usb_host_interface *cur_altsetting; /* the currently* active alternate setting */unsigned num_altsetting; /* number of alternate settings *//* If there is an interface association descriptor then it will list* the associated interfaces */struct usb_interface_assoc_descriptor *intf_assoc;int minor; /* minor number this interface is bound to */enum usb_interface_condition condition; /* state of binding */unsigned sysfs_files_created:1; /* the sysfs attributes exist */unsigned ep_devs_created:1; /* endpoint "devices" exist */unsigned unregistering:1; /* unregistration is in progress */unsigned needs_remote_wakeup:1; /* driver requires remote wakeup */unsigned needs_altsetting0:1; /* switch to altsetting 0 is pending */unsigned needs_binding:1; /* needs delayed unbind/rebind */unsigned resetting_device:1; /* true: bandwidth alloc after reset */unsigned authorized:1; /* used for interface authorization */struct device dev; /* interface specific device info */struct device *usb_dev;struct work_struct reset_ws; /* for resets in atomic context */......
};
#define to_usb_device(d) container_of(d, struct usb_device, dev)static inline struct usb_device *interface_to_usbdev(struct usb_interface *intf)
{return to_usb_device(intf->dev.parent);
}
int __must_check
usb_find_common_endpoints(struct usb_host_interface *alt,struct usb_endpoint_descriptor **bulk_in,struct usb_endpoint_descriptor **bulk_out,struct usb_endpoint_descriptor **int_in,struct usb_endpoint_descriptor **int_out);int __must_check
usb_find_common_endpoints_reverse(struct usb_host_interface *alt,struct usb_endpoint_descriptor **bulk_in,struct usb_endpoint_descriptor **bulk_out,struct usb_endpoint_descriptor **int_in,struct usb_endpoint_descriptor **int_out);static inline int __must_check
usb_find_bulk_in_endpoint(struct usb_host_interface *alt,struct usb_endpoint_descriptor **bulk_in)
{return usb_find_common_endpoints(alt, bulk_in, NULL, NULL, NULL);
}static inline int __must_check
usb_find_bulk_out_endpoint(struct usb_host_interface *alt,struct usb_endpoint_descriptor **bulk_out)
{return usb_find_common_endpoints(alt, NULL, bulk_out, NULL, NULL);
}static inline int __must_check
usb_find_int_in_endpoint(struct usb_host_interface *alt,struct usb_endpoint_descriptor **int_in)
{return usb_find_common_endpoints(alt, NULL, NULL, int_in, NULL);
}static inline int __must_check
usb_find_int_out_endpoint(struct usb_host_interface *alt,struct usb_endpoint_descriptor **int_out)
{return usb_find_common_endpoints(alt, NULL, NULL, NULL, int_out);
}static inline int __must_check
usb_find_last_bulk_in_endpoint(struct usb_host_interface *alt,struct usb_endpoint_descriptor **bulk_in)
{return usb_find_common_endpoints_reverse(alt, bulk_in, NULL, NULL, NULL);
}static inline int __must_check
usb_find_last_bulk_out_endpoint(struct usb_host_interface *alt,struct usb_endpoint_descriptor **bulk_out)
{return usb_find_common_endpoints_reverse(alt, NULL, bulk_out, NULL, NULL);
}static inline int __must_check
usb_find_last_int_in_endpoint(struct usb_host_interface *alt,struct usb_endpoint_descriptor **int_in)
{return usb_find_common_endpoints_reverse(alt, NULL, NULL, int_in, NULL);
}static inline int __must_check
usb_find_last_int_out_endpoint(struct usb_host_interface *alt,struct usb_endpoint_descriptor **int_out)
{return usb_find_common_endpoints_reverse(alt, NULL, NULL, NULL, int_out);
}
3.2.匹配驱动和设备及接口
USB Class Driver和USB设备接口、USB设备和USB Core(USB Driver)都是通过struct usb_device_id中的信息进行匹配。struct usb_device_id定义了4中匹配方式，第一种是产品信息匹配，通常情况使用VID和PID；第二种是根据设备类信息进行匹配；第三种根据接口的类信息进行匹配，第四种根据厂家自定义的接口进行匹配。具体使用那种匹配方式，由match_flags决定，内核定义了USB_DEVICE_ID_xx开头的宏，用来设置match_flags。USB Class Driver和USB设备接口、USB设备和USB Core(USB Driver)的匹配工作由usb_bus_type中的usb_device_match函数完成，该函数会进一步调用usb_match_id进行匹配。
[include/linux/mod_devicetable.h]
struct usb_device_id {/* which fields to match against? */__u16 match_flags;/* Used for product specific matches; range is inclusive */__u16 idVendor;__u16 idProduct;__u16 bcdDevice_lo;__u16 bcdDevice_hi;/* Used for device class matches */__u8 bDeviceClass;__u8 bDeviceSubClass;__u8 bDeviceProtocol;/* Used for interface class matches */__u8 bInterfaceClass;__u8 bInterfaceSubClass;__u8 bInterfaceProtocol;/* Used for vendor-specific interface matches */__u8 bInterfaceNumber;/* not matched against */kernel_ulong_t driver_info__attribute__((aligned(sizeof(kernel_ulong_t))));
};
/* Some useful macros to use to create struct usb_device_id */
#define USB_DEVICE_ID_MATCH_VENDOR 0x0001
#define USB_DEVICE_ID_MATCH_PRODUCT 0x0002
#define USB_DEVICE_ID_MATCH_DEV_LO 0x0004
#define USB_DEVICE_ID_MATCH_DEV_HI 0x0008
#define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010
#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020
#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040
#define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080
#define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100
#define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200
#define USB_DEVICE_ID_MATCH_INT_NUMBER 0x0400[include/linux/usb.h]
#define USB_DEVICE_ID_MATCH_DEVICE \(USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
#define USB_DEVICE_ID_MATCH_DEV_RANGE \(USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
#define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION \(USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
#define USB_DEVICE_ID_MATCH_DEV_INFO \(USB_DEVICE_ID_MATCH_DEV_CLASS | \USB_DEVICE_ID_MATCH_DEV_SUBCLASS | \USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
#define USB_DEVICE_ID_MATCH_INT_INFO \(USB_DEVICE_ID_MATCH_INT_CLASS | \USB_DEVICE_ID_MATCH_INT_SUBCLASS | \USB_DEVICE_ID_MATCH_INT_PROTOCOL)/*** USB_DEVICE - macro used to describe a specific usb device* @vend: the 16 bit USB Vendor ID* @prod: the 16 bit USB Product ID** This macro is used to create a struct usb_device_id that matches a* specific device.*/
#define USB_DEVICE(vend, prod) \.match_flags = USB_DEVICE_ID_MATCH_DEVICE, \.idVendor = (vend), \.idProduct = (prod)/*** USB_INTERFACE_INFO - macro used to describe a class of usb interfaces* @cl: bInterfaceClass value* @sc: bInterfaceSubClass value* @pr: bInterfaceProtocol value** This macro is used to create a struct usb_device_id that matches a* specific class of interfaces.*/
#define USB_INTERFACE_INFO(cl, sc, pr) \.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \.bInterfaceClass = (cl), \.bInterfaceSubClass = (sc), \.bInterfaceProtocol = (pr)
......const struct usb_device_id *usb_match_id(struct usb_interface *interface,const struct usb_device_id *id);
extern struct bus_type usb_bus_type;[drivers/usb/core/driver.c]
struct bus_type usb_bus_type = {.name = "usb",.match = usb_device_match,.uevent = usb_uevent,.need_parent_lock = true,
};
struct usb_driver定义的USB Class Driver驱动和USB设备的接口匹配，而struct usb_device_driver定义的驱动和USB设备匹配，使用usb_register_device_driver和usb_deregister_device_driver函数注册和注销struct usb_device_driver。内核提供了通用的struct usb_device_driver，即usb_generic_driver，在USB子系统初始化的时候注册到系统中，通常情况下USB Class Driver无需再提供struct usb_device_driver。
[include/linux/usb.h]
struct usb_device_driver {const char *name;/* If set, used for better device/driver matching. */bool (*match) (struct usb_device *udev);/* Called to see if the driver is willing to manage a particular* device. If it is, probe returns zero and uses dev_set_drvdata()* to associate driver-specific data with the device. If unwilling* to manage the device, return a negative errno value. */int (*probe) (struct usb_device *udev);/* Called when the device is no longer accessible, usually* because it has been (or is being) disconnected or the driver's* module is being unloaded.*/void (*disconnect) (struct usb_device *udev);int (*suspend) (struct usb_device *udev, pm_message_t message);int (*resume) (struct usb_device *udev, pm_message_t message);const struct attribute_group **dev_groups;struct usbdrv_wrap drvwrap;/* used with @match() to select better matching driver at probe() time.*/const struct usb_device_id *id_table;unsigned int supports_autosuspend:1;unsigned int generic_subclass:1;
};extern int usb_register_device_driver(struct usb_device_driver *,struct module *);
extern void usb_deregister_device_driver(struct usb_device_driver *);
extern struct usb_device_driver usb_generic_driver;[drivers/usb/core/generic.c]
struct usb_device_driver usb_generic_driver = {.name = "usb",.match = usb_generic_driver_match,.probe = usb_generic_driver_probe,.disconnect = usb_generic_driver_disconnect,
#ifdef CONFIG_PM.suspend = usb_generic_driver_suspend,.resume = usb_generic_driver_resume,
#endif.supports_autosuspend = 1,
};
3.3.管理设备
USB Core(USB Driver)使用struct usb_device数据结构描述USB设备。该数据结构在系统枚举USB设备的时候，由usb_alloc_dev函数分配和usb_new_device初始化。
[include/linux/usb.h]
struct usb_device {/* device number; address on a USB bus */int devnum;/* device ID string for use in messages (e.g., /port/...) */char devpath[16];/* tree topology hex string for use with xHCI */u32 route;/* device state: configured, not attached, etc. */enum usb_device_state state;/* device speed: high/full/low (or error) */enum usb_device_speed speed;/* number of rx lanes in use, USB 3.2 adds dual-lane support */unsigned int rx_lanes;/* number of tx lanes in use, USB 3.2 adds dual-lane support */unsigned int tx_lanes;/* Transaction Translator info; used with low/full speed dev,* highspeed hub */struct usb_tt *tt;int ttport; /* device port on that tt hub *//* one bit for each endpoint, with ([0] = IN, [1] = OUT) endpoints */unsigned int toggle[2];/* our hub, unless we're the root */struct usb_device *parent;struct usb_bus *bus; /* bus we're part of *//* endpoint 0 data (default control pipe) */struct usb_host_endpoint ep0;struct device dev; /* generic device interface *//* USB device descriptor */struct usb_device_descriptor descriptor;struct usb_host_bos *bos;/* all of the device's configs */struct usb_host_config *config;/* the active configuration */struct usb_host_config *actconfig;struct usb_host_endpoint *ep_in[16]; /* array of IN endpoints */struct usb_host_endpoint *ep_out[16]; /* array of OUT endpoints */char **rawdescriptors; /* raw descriptors for each config *//* Current available from the bus */unsigned short bus_mA;u8 portnum; /* parent port number (origin 1) */u8 level; /* number of USB hub ancestors *//* device address, XHCI: assigned by HW, others: same as devnum */u8 devaddr;....../* ask driver core to reprobe using the generic driver */unsigned use_generic_driver:1;......
};[include/linux/usb/hcd.h]
/* Enumeration is only for the hub driver, or HCD virtual root hubs */
/* usb device constructor (usbcore-internal) */
extern struct usb_device *usb_alloc_dev(struct usb_device *parent,struct usb_bus *, unsigned port);
/* perform initial device setup (usbcore-internal) */
extern int usb_new_device(struct usb_device *dev);
/* disconnect a device (usbcore-internal) */
void usb_disconnect(struct usb_device **pdev);
4. USB Host Controller Driver
Linux内核使用struct usb_hcd数据结构描述USB Host Controller Driver，使用struct hc_driver描述USB Host Controller的操作方法，比如通信接口usb_submit_urb最终会调用到urb_enqueue函数，不同接口协议的USB Host Controller需要提供不同的struct hc_driver。使用usb_create_hcd和__usb_create_hcd函数创建struct usb_hcd，使用usb_add_hcd函数添加struct usb_hcd，使用usb_remove_hcd移除struct usb_hcd。
[include/linux/usb/hcd.h]
struct usb_hcd {struct usb_bus self; /* hcd is-a bus */struct kref kref; /* reference counter */const char *product_desc; /* product/vendor string */int speed; /* Speed for this roothub. */char irq_descr[24]; /* driver + bus # */struct timer_list rh_timer; /* drives root-hub polling */struct urb *status_urb; /* the current status urb */
#ifdef CONFIG_PMstruct work_struct wakeup_work; /* for remote wakeup */
#endifstruct work_struct died_work; /* for when the device dies *//* hardware info/state */const struct hc_driver *driver; /* hw-specific hooks *//* OTG and some Host controllers need software interaction with phys;* other external phys should be software-transparent*/struct usb_phy *usb_phy;struct usb_phy_roothub *phy_roothub;....../* bandwidth_mutex should be taken before adding or removing* any new bus bandwidth constraints:* 1. Before adding a configuration for a new device.* 2. Before removing the configuration to put the device into* the addressed state.* 3. Before selecting a different configuration.* 4. Before selecting an alternate interface setting.** bandwidth_mutex should be dropped after a successful control message* to the device, or resetting the bandwidth after a failed attempt.*/struct mutex *address0_mutex;struct mutex *bandwidth_mutex;struct usb_hcd *shared_hcd;struct usb_hcd *primary_hcd;......
};struct hc_driver {const char *description; /* "ehci-hcd" etc */const char *product_desc; /* product/vendor string */size_t hcd_priv_size; /* size of private data *//* irq handler */irqreturn_t (*irq) (struct usb_hcd *hcd);....../* called to init HCD and root hub */int (*reset) (struct usb_hcd *hcd);int (*start) (struct usb_hcd *hcd);/* NOTE: these suspend/resume calls relate to the HC as* a whole, not just the root hub; they're for PCI bus glue.*//* called after suspending the hub, before entering D3 etc */int (*pci_suspend)(struct usb_hcd *hcd, bool do_wakeup);/* called after entering D0 (etc), before resuming the hub */int (*pci_resume)(struct usb_hcd *hcd, bool hibernated);/* cleanly make HCD stop writing memory and doing I/O */void (*stop) (struct usb_hcd *hcd);/* shutdown HCD */void (*shutdown) (struct usb_hcd *hcd);/* return current frame number */int (*get_frame_number) (struct usb_hcd *hcd);/* manage i/o requests, device state */int (*urb_enqueue)(struct usb_hcd *hcd,struct urb *urb, gfp_t mem_flags);int (*urb_dequeue)(struct usb_hcd *hcd,struct urb *urb, int status);/** (optional) these hooks allow an HCD to override the default DMA* mapping and unmapping routines. In general, they shouldn't be* necessary unless the host controller has special DMA requirements,* such as alignment contraints. If these are not specified, the* general usb_hcd_(un)?map_urb_for_dma functions will be used instead* (and it may be a good idea to call these functions in your HCD* implementation)*/int (*map_urb_for_dma)(struct usb_hcd *hcd, struct urb *urb,gfp_t mem_flags);void (*unmap_urb_for_dma)(struct usb_hcd *hcd, struct urb *urb);/* hw synch, freeing endpoint resources that urb_dequeue can't */void (*endpoint_disable)(struct usb_hcd *hcd,struct usb_host_endpoint *ep);/* (optional) reset any endpoint state such as sequence numberand current window */void (*endpoint_reset)(struct usb_hcd *hcd,struct usb_host_endpoint *ep);/* root hub support */int (*hub_status_data) (struct usb_hcd *hcd, char *buf);int (*hub_control) (struct usb_hcd *hcd,u16 typeReq, u16 wValue, u16 wIndex, char *buf, u16 wLength);int (*bus_suspend)(struct usb_hcd *);int (*bus_resume)(struct usb_hcd *);int (*start_port_reset)(struct usb_hcd *, unsigned port_num);unsigned long (*get_resuming_ports)(struct usb_hcd *);/* force handover of high-speed port to full-speed companion */void (*relinquish_port)(struct usb_hcd *, int);/* has a port been handed over to a companion? */int (*port_handed_over)(struct usb_hcd *, int);/* CLEAR_TT_BUFFER completion callback */void (*clear_tt_buffer_complete)(struct usb_hcd *,struct usb_host_endpoint *);/* xHCI specific functions *//* Called by usb_alloc_dev to alloc HC device structures */int (*alloc_dev)(struct usb_hcd *, struct usb_device *);/* Called by usb_disconnect to free HC device structures */void (*free_dev)(struct usb_hcd *, struct usb_device *);/* Change a group of bulk endpoints to support multiple stream IDs */int (*alloc_streams)(struct usb_hcd *hcd, struct usb_device *udev,struct usb_host_endpoint **eps, unsigned int num_eps,unsigned int num_streams, gfp_t mem_flags);/* Reverts a group of bulk endpoints back to not using stream IDs.* Can fail if we run out of memory.*/int (*free_streams)(struct usb_hcd *hcd, struct usb_device *udev,struct usb_host_endpoint **eps, unsigned int num_eps,gfp_t mem_flags);/* Bandwidth computation functions *//* Note that add_endpoint() can only be called once per endpoint before* check_bandwidth() or reset_bandwidth() must be called.* drop_endpoint() can only be called once per endpoint also.* A call to xhci_drop_endpoint() followed by a call to* xhci_add_endpoint() will add the endpoint to the schedule with* possibly new parameters denoted by a different endpoint descriptor* in usb_host_endpoint. A call to xhci_add_endpoint() followed by a* call to xhci_drop_endpoint() is not allowed.*//* Allocate endpoint resources and add them to a new schedule */int (*add_endpoint)(struct usb_hcd *, struct usb_device *,struct usb_host_endpoint *);/* Drop an endpoint from a new schedule */int (*drop_endpoint)(struct usb_hcd *, struct usb_device *,struct usb_host_endpoint *);/* Check that a new hardware configuration, set using* endpoint_enable and endpoint_disable, does not exceed bus* bandwidth. This must be called before any set configuration* or set interface requests are sent to the device.*/int (*check_bandwidth)(struct usb_hcd *, struct usb_device *);/* Reset the device schedule to the last known good schedule,* which was set from a previous successful call to* check_bandwidth(). This reverts any add_endpoint() and* drop_endpoint() calls since that last successful call.* Used for when a check_bandwidth() call fails due to resource* or bandwidth constraints.*/void (*reset_bandwidth)(struct usb_hcd *, struct usb_device *);/* Returns the hardware-chosen device address */int (*address_device)(struct usb_hcd *, struct usb_device *udev);/* prepares the hardware to send commands to the device */int (*enable_device)(struct usb_hcd *, struct usb_device *udev);/* Notifies the HCD after a hub descriptor is fetched.* Will block.*/int (*update_hub_device)(struct usb_hcd *, struct usb_device *hdev,struct usb_tt *tt, gfp_t mem_flags);int (*reset_device)(struct usb_hcd *, struct usb_device *);/* Notifies the HCD after a device is connected and its* address is set*/int (*update_device)(struct usb_hcd *, struct usb_device *);int (*set_usb2_hw_lpm)(struct usb_hcd *, struct usb_device *, int);/* USB 3.0 Link Power Management *//* Returns the USB3 hub-encoded value for the U1/U2 timeout. */int (*enable_usb3_lpm_timeout)(struct usb_hcd *,struct usb_device *, enum usb3_link_state state);/* The xHCI host controller can still fail the command to* disable the LPM timeouts, so this can return an error code.*/int (*disable_usb3_lpm_timeout)(struct usb_hcd *,struct usb_device *, enum usb3_link_state state);int (*find_raw_port_number)(struct usb_hcd *, int);/* Call for power on/off the port if necessary */int (*port_power)(struct usb_hcd *hcd, int portnum, bool enable);......
};struct usb_hcd *__usb_create_hcd(const struct hc_driver *driver,struct device *sysdev, struct device *dev, const char *bus_name,struct usb_hcd *primary_hcd);
/* create and initialize an HCD structure */
extern struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,struct device *dev, const char *bus_name);
/* finish generic HCD structure initialization and register */
extern int usb_add_hcd(struct usb_hcd *hcd,unsigned int irqnum, unsigned long irqflags);
/* shutdown processing for generic HCDs */
extern void usb_remove_hcd(struct usb_hcd *hcd);
xHCI、EHCI、OHCI三种接口协议标准的USB Host Controller Driver的struct hc_driver定义如下。
[drivers/usb/host/xhci.c]
static const struct hc_driver xhci_hc_driver = {.description = "xhci-hcd",.product_desc = "xHCI Host Controller",.hcd_priv_size = sizeof(struct xhci_hcd),/* generic hardware linkage */.irq = xhci_irq,.flags = HCD_MEMORY | HCD_DMA | HCD_USB3 | HCD_SHARED | HCD_BH,/* basic lifecycle operations */.reset = NULL, /* xhci_plat_setup */.start = xhci_run, /* xhci_plat_start */.stop = xhci_stop,.shutdown = xhci_shutdown,/* managing i/o requests and associated device resources */.map_urb_for_dma = xhci_map_urb_for_dma,.urb_enqueue = xhci_urb_enqueue,.urb_dequeue = xhci_urb_dequeue,.alloc_dev = xhci_alloc_dev,.free_dev = xhci_free_dev,.alloc_streams = xhci_alloc_streams,.free_streams = xhci_free_streams,.add_endpoint = xhci_add_endpoint,.drop_endpoint = xhci_drop_endpoint,.endpoint_disable = xhci_endpoint_disable,.endpoint_reset = xhci_endpoint_reset,.check_bandwidth = xhci_check_bandwidth,.reset_bandwidth = xhci_reset_bandwidth,.address_device = xhci_address_device,.enable_device = xhci_enable_device,.update_hub_device = xhci_update_hub_device,.reset_device = xhci_discover_or_reset_device,/* scheduling support */.get_frame_number = xhci_get_frame,/* root hub support */.hub_control = xhci_hub_control,.hub_status_data = xhci_hub_status_data,.bus_suspend = xhci_bus_suspend,.bus_resume = xhci_bus_resume,.get_resuming_ports = xhci_get_resuming_ports,/* call back when device connected and addressed */.update_device = xhci_update_device,.set_usb2_hw_lpm = xhci_set_usb2_hardware_lpm,.enable_usb3_lpm_timeout = xhci_enable_usb3_lpm_timeout,.disable_usb3_lpm_timeout = xhci_disable_usb3_lpm_timeout,.find_raw_port_number = xhci_find_raw_port_number,.clear_tt_buffer_complete = xhci_clear_tt_buffer_complete,
};[drivers/usb/host/ehci-hcd.c]
static const struct hc_driver ehci_hc_driver = {.description = hcd_name,.product_desc = "EHCI Host Controller",.hcd_priv_size = sizeof(struct ehci_hcd),/* generic hardware linkage */.irq = ehci_irq,.flags = HCD_MEMORY | HCD_DMA | HCD_USB2 | HCD_BH,/* basic lifecycle operations */.reset = ehci_setup,.start = ehci_run,.stop = ehci_stop,.shutdown = ehci_shutdown,/* managing i/o requests and associated device resources */.urb_enqueue = ehci_urb_enqueue,.urb_dequeue = ehci_urb_dequeue,.endpoint_disable = ehci_endpoint_disable,.endpoint_reset = ehci_endpoint_reset,.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,/* scheduling support */.get_frame_number = ehci_get_frame,/* root hub support */.hub_status_data = ehci_hub_status_data,.hub_control = ehci_hub_control,.bus_suspend = ehci_bus_suspend,.bus_resume = ehci_bus_resume,.relinquish_port = ehci_relinquish_port,.port_handed_over = ehci_port_handed_over,.get_resuming_ports = ehci_get_resuming_ports,/* device support */.free_dev = ehci_remove_device,
};[drivers/usb/host/ohci-hcd.c]
static const struct hc_driver ohci_hc_driver = {.description = hcd_name,.product_desc = "OHCI Host Controller",.hcd_priv_size = sizeof(struct ohci_hcd),/* generic hardware linkage */.irq = ohci_irq,.flags = HCD_MEMORY | HCD_DMA | HCD_USB11,/* basic lifecycle operations */.reset = ohci_setup,.start = ohci_start,.stop = ohci_stop,.shutdown = ohci_shutdown,/* managing i/o requests and associated device resources */.urb_enqueue = ohci_urb_enqueue,.urb_dequeue = ohci_urb_dequeue,.endpoint_disable = ohci_endpoint_disable,/* scheduling support */.get_frame_number = ohci_get_frame,/* root hub support */.hub_status_data = ohci_hub_status_data,.hub_control = ohci_hub_control,
#ifdef CONFIG_PM.bus_suspend = ohci_bus_suspend,.bus_resume = ohci_bus_resume,
#endif.start_port_reset = ohci_start_port_reset,
};
5. USB子系统
Linux内核主机USB子系统的初始化入口如下所示，注册了usb_bus_type、usbfs_driver、usb_generic_driver，初始化了USB设备的设备号、hub等。
[drivers\usb\core\usb.c]
static int __init usb_init(void)
{......retval = bus_register(&usb_bus_type);if (retval)goto bus_register_failed;retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);if (retval)goto bus_notifier_failed;retval = usb_major_init();if (retval)goto major_init_failed;retval = usb_register(&usbfs_driver);if (retval)goto driver_register_failed;retval = usb_devio_init();if (retval)goto usb_devio_init_failed;retval = usb_hub_init();if (retval)goto hub_init_failed;retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);if (!retval)goto out;......
}
static void __exit usb_exit(void)
{......usb_release_quirk_list();usb_deregister_device_driver(&usb_generic_driver);usb_major_cleanup();usb_deregister(&usbfs_driver);usb_devio_cleanup();usb_hub_cleanup();bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);bus_unregister(&usb_bus_type);usb_acpi_unregister();usb_debugfs_cleanup();idr_destroy(&usb_bus_idr);
}
subsys_initcall(usb_init);
module_exit(usb_exit);
参考资料
- eXtensible Host Controller Interface for Universal Serial Bus
- Linux kernel 5.10
- Linux驱动开发实例
- Linux设备驱动开发详解
