1 － audio ：表示一个音频设   备。

2 － communication   device ：通讯设备，如电话， moden 等等。

3 － HID ：人机交互设备，如键盘，鼠标等。

6 － image 图象设备，如扫描仪，摄像头等，有时数码相    机也可归到这一类。

7 －打印机类。如单向，双向打印机等。

8 － mass   storage 海量存储类。所有带有一定存储功能的都可以归到这一类。如数码相机大多数都归这一类。

9 － hub 类。

11 － chip   card/smart   card 。

13 －－ Content Security

14 －－ Video  （ Interface ）

15 －－ Personal Healthcare

220 －－ Diagnostic Device

224 －－ Wireless Controller  （ Interface ）

239 －－ Miscellaneous

254 －－ Application Specific  （ Interface ）

255 － vendor   specific. 厂家的自定义类，主要用于一些特殊的设备。如接口转接卡等。

信号线名称

颜色

1

Vbus

红

2

D-

白

3

D+

绿

4

GNU

黑

shell （金属壳）

屏敝层

Connector Color

mirco/mini-A receptacle

White

mirco/min-AB receptacle

Gray

mirco/min-B receptacle

Black

mirco/min-A plug

White

mirco/min-B plug

Black

struct otg_transceiver {

    struct device       *dev;

    const char      *label;

    u8          default_a;

    enum usb_otg_state  state; // 记录 OTG 控制器的状态，在实际的处理中这个比较重要。

    struct usb_bus      *host;

    struct usb_gadget   *gadget;

    /* to pass extra port status to the root hub */

    u16         port_status;

    u16         port_change;

    /* bind/unbind the host controller */

    int (*set_host)(struct otg_transceiver *otg,

                struct usb_bus *host);// 这个接口用来启用或禁用主控制器，是关键的接口

    /* bind/unbind the peripheral controller */

    int (*set_peripheral)(struct otg_transceiver *otg,

                struct usb_gadget *gadget);

    /* effective for B devices, ignored for A-peripheral */

    int (*set_power)(struct otg_transceiver *otg,

                unsigned mA);// 一般用来设置 vbus 上的供电

    /* for non-OTG B devices: set transceiver into suspend mode */

    int (*set_suspend)(struct otg_transceiver *otg,

                int suspend);

// 下面是 OTG 的三大高级功能的接口。

    /* for B devices only:  start session with A-Host */

    int (*start_srp)(struct otg_transceiver *otg);

    /* start or continue HNP role switch */

    int (*start_hnp)(struct otg_transceiver *otg);

    /* b device disconnect during hnp */

    int (*disconnect)(struct otg_transceiver *otg);

    /* b device connect */

    int (*connect)(struct otg_transceiver *otg, struct usb_device *udev);

    /* host suspend the bus during hnp */

    int     (*host_suspend)(struct otg_transceiver *otg);

    /* hand interrupt related to usb otg */

    int (*otg_interrupt)(struct otg_transceiver *otg);// 中断处理接口

};

Operational Register Default Value (after Reset)

USBCMD 00080000h (00080B00h if Asynchronous Schedule Park Capability is a one)

USBSTS 00001000h

USBINTR 00000000h

FRINDEX 00000000h

CTRLDSSEGMENT 00000000h

PERIODICLISTBASE Undefined

ASYNCLISTADDR Undefined

CONFIGFLAG 00000000h

PORTSC 00002000h (w/PPC set to one); 00003000h (w/PPC set to a zero)

Offset

Size

Mnemonic

Power Well

Register Name

00h

1

CAPLENGTH

Capability Register Length

01h

1

Reserved

N/A

02h

2

HCIVERSION

Interface Version Number

04h

4

HCSPARAMS

Structural Parameters

08h

4

HCCPARAMS

Capability Parameters

0Ch

8

HCSP-PORTROUTE

Companion Port Route Description

Offset

Mnemonic

Register Name

Power Well

00h

USBCMD

USB Command

04h

USBSTS

USB Status

08h

USBINTR

USB Interrupt Enable

0ch

FRINDEX

USB Frame Index

10h

CTRLDSSEGMENT

4G Segment Selector

14h

PERIODICLISTBASE

Frame List Base Address

18h

ASYNCLISTADDR

Next Asynchronous List Address

1C-3F

Reserved

40H

CONFIGFLAG

Configured Flag Register

44H

PORTSC(1-N_PORTS)

Port Status/Control

Host Controller Capability Registers

struct ehci_caps {

/* these fields are specified as 8 and 16 bit registers,

* but some hosts can't perform 8 or 16 bit PCI accesses.

*/

u32 hc_capbase;

#define HC_LENGTH(p) (((p)>>00)&0x00ff) /* bits 7:0 */

#define HC_VERSION(p) (((p)>>16)&0xffff) /* bits 31:16 */

u32 hcs_params; /* HCSPARAMS - offset 0x4 */

#define HCS_DEBUG_PORT(p) (((p)>>20)&0xf) /* bits 23:20, debug port? */

#define HCS_INDICATOR(p) ((p)&(1 << 16)) /* true: has port indicators */

#define HCS_N_CC(p) (((p)>>12)&0xf) /* bits 15:12, #companion HCs */

#define HCS_N_PCC(p) (((p)>>8)&0xf) /* bits 11:8, ports per CC */

#define HCS_PORTROUTED(p) ((p)&(1 << 7)) /* true: port routing */

#define HCS_PPC(p) ((p)&(1 << 4)) /* true: port power control */

#define HCS_N_PORTS(p) (((p)>>0)&0xf) /* bits 3:0, ports on HC */

u32 hcc_params; /* HCCPARAMS - offset 0x8 */

#define HCC_EXT_CAPS(p) (((p)>>8)&0xff) /* for pci extended caps */

#define HCC_ISOC_CACHE(p) ((p)&(1 << 7)) /* true: can cache isoc frame */

#define HCC_ISOC_THRES(p) (((p)>>4)&0x7) /* bits 6:4, uframes cached */

#define HCC_CANPARK(p) ((p)&(1 << 2)) /* true: can park on async qh */

#define HCC_PGM_FRAMELISTLEN(p) ((p)&(1 << 1)) /* true: periodic_size changes*/

#define HCC_64BIT_ADDR(p) ((p)&(1)) /* true: can use 64-bit addr */

u8 portroute [8]; /* nibbles for routing - offset 0xC */

} __attribute__ ((packed));

Host Controller Operational Registers

struct ehci_regs {

/* USBCMD: offset 0x00 */

u32 command;

/* 23:16 is r/w intr rate, in microframes; default "8" == 1/msec */

#define CMD_PARK (1<<11) /* enable "park" on async qh */

#define CMD_PARK_CNT(c) (((c)>>8)&3) /* how many transfers to park for */

#define CMD_LRESET (1<<7) /* partial reset (no ports, etc) */

#define CMD_IAAD (1<<6) /* "doorbell" interrupt async advance */

#define CMD_ASE (1<<5) /* async schedule enable */

#define CMD_PSE (1<<4) /* periodic schedule enable */

/* 3:2 is periodic frame list size */

#define CMD_RESET (1<<1) /* reset HC not bus */

#define CMD_RUN (1<<0) /* start/stop HC */

/* USBSTS: offset 0x04 */

u32 status;

#define STS_ASS (1<<15) /* Async Schedule Status */

#define STS_PSS (1<<14) /* Periodic Schedule Status */

#define STS_RECL (1<<13) /* Reclamation */

#define STS_HALT (1<<12) /* Not running (any reason) */

/* some bits reserved */

/* these STS_* flags are also intr_enable bits (USBINTR) */

#define STS_IAA (1<<5) /* Interrupted on async advance */

#define STS_FATAL (1<<4) /* such as some PCI access errors */

#define STS_FLR (1<<3) /* frame list rolled over */

#define STS_PCD (1<<2) /* port change detect */

#define STS_ERR (1<<1) /* "error" completion (overflow, ...) */

#define STS_INT (1<<0) /* "normal" completion (short, ...) */

/* USBINTR: offset 0x08 */

u32 intr_enable;

/* FRINDEX: offset 0x0C */

u32 frame_index; /* current microframe number */

/* CTRLDSSEGMENT: offset 0x10 */

u32 segment; /* address bits 63:32 if needed */

/* PERIODICLISTBASE: offset 0x14 */

u32 frame_list; /* points to periodic list */

/* ASYNCLISTADDR: offset 0x18 */

u32 async_next; /* address of next async queue head */

u32 reserved [9];

/* CONFIGFLAG: offset 0x40 */

u32 configured_flag;

#define FLAG_CF (1<<0) /* true: we'll support "high speed" */

/* PORTSC: offset 0x44 */

u32 port_status [0]; /* up to N_PORTS */

/* 31:23 reserved */

#define PORT_WKOC_E (1<<22) /* wake on overcurrent (enable) */

#define PORT_WKDISC_E (1<<21) /* wake on disconnect (enable) */

#define PORT_WKCONN_E (1<<20) /* wake on connect (enable) */

/* 19:16 for port testing */

#define PORT_LED_OFF (0<<14)

#define PORT_LED_AMBER (1<<14)

#define PORT_LED_GREEN (2<<14)

#define PORT_LED_MASK (3<<14)

#define PORT_OWNER (1<<13) /* true: companion hc owns this port */

#define PORT_POWER (1<<12) /* true: has power (see PPC) */

#define PORT_USB11(x) (((x)&(3<<10)) == (1<<10)) /* USB 1.1 device */

/* 11:10 for detecting lowspeed devices (reset vs release ownership) */

/* 9 reserved */

#define PORT_RESET (1<<8) /* reset port */

#define PORT_SUSPEND (1<<7) /* suspend port */

#define PORT_RESUME (1<<6) /* resume it */

#define PORT_OCC (1<<5) /* over current change */

#define PORT_OC (1<<4) /* over current active */

#define PORT_PEC (1<<3) /* port enable change */

#define PORT_PE (1<<2) /* port enable */

#define PORT_CSC (1<<1) /* connect status change */

#define PORT_CONNECT (1<<0) /* device connected */

#define PORT_RWC_BITS (PORT_CSC | PORT_PEC | PORT_OCC)

} __attribute__ ((packed));

struct ehci_hcd { /* one per controller */

/* glue to PCI and HCD framework */

struct ehci_caps __iomem *caps;

struct ehci_regs __iomem *regs;

struct ehci_dbg_port __iomem *debug;

__u32 hcs_params; /* cached register copy */

spinlock_t lock;

/* async schedule support */

struct ehci_qh *async;

struct ehci_qh *reclaim;

unsigned scanning : 1;

/* periodic schedule support */

#define DEFAULT_I_TDPS 1024 /* some HCs can do less */

unsigned periodic_size;

__hc32 *periodic; /* hw periodic table */

dma_addr_t periodic_dma;

unsigned i_thresh; /* uframes HC might cache */

union ehci_shadow *pshadow; /* mirror hw periodic table */

int next_uframe; /* scan periodic, start here */

unsigned periodic_sched; /* periodic activity count */

/* list of itds completed while clock_frame was still active */

struct list_head cached_itd_list;

unsigned clock_frame;

/* per root hub port */

unsigned long reset_done [EHCI_MAX_ROOT_PORTS];

/* bit vectors (one bit per port) */

unsigned long bus_suspended; /* which ports were

already suspended at the start of a bus suspend */

unsigned long companion_ports; /* which ports are

dedicated to the companion controller */

unsigned long owned_ports; /* which ports are

owned by the companion during a bus suspend */

unsigned long port_c_suspend; /* which ports have

the change-suspend feature turned on */

unsigned long suspended_ports; /* which ports are

suspended */

/* per-HC memory pools (could be per-bus, but ...) */

struct dma_pool *qh_pool; /* qh per active urb */

struct dma_pool *qtd_pool; /* one or more per qh */

struct dma_pool *itd_pool; /* itd per iso urb */

struct dma_pool *sitd_pool; /* sitd per split iso urb */

struct timer_list iaa_watchdog;

struct timer_list watchdog;

unsigned long actions;

unsigned stamp;

unsigned long next_statechange;

u32 command;

/* SILICON QUIRKS */

unsigned no_selective_suspend:1;

unsigned has_fsl_port_bug:1; /* FreeScale */

unsigned big_endian_mmio:1;

unsigned big_endian_desc:1;

unsigned has_amcc_usb23:1;

/* required for usb32 quirk */

#define OHCI_CTRL_HCFS (3 << 6)

#define OHCI_USB_OPER (2 << 6)

#define OHCI_USB_SUSPEND (3 << 6)

#define OHCI_HCCTRL_OFFSET 0x4

#define OHCI_HCCTRL_LEN 0x4

__hc32 *ohci_hcctrl_reg;

u8 sbrn; /* packed release number */

/* irq statistics */

#ifdef EHCI_STATS

struct ehci_stats stats;

# define COUNT(x) do { (x)++; } while (0)

#else

# define COUNT(x) do {} while (0)

#endif

/* debug files */

#ifdef DEBUG

struct dentry *debug_dir;

struct dentry *debug_async;

struct dentry *debug_periodic;

struct dentry *debug_registers;

#endif

#ifdef CONFIG_USB_OTG

/*

* OTG controllers and transceivers need software interaction;

* other external transceivers should be software-transparent

*/

struct otg_transceiver *transceiver;

#endif

};

struct ehci_caps __iomem *caps;

struct ehci_regs __iomem *regs;

struct ehci_dbg_port __iomem *debug;

__u32 hcs_params; /* cached register copy */

__hc32 *periodic;

硬件相关，这些结构体的成员都要指向寄存器的地址。

struct ehci_qh *async;

struct ehci_qh *reclaim;

unsigned scanning : 1;

unsigned periodic_size;

__hc32 *periodic;

dma_addr_t periodic_dma;

unsigned i_thresh;

union ehci_shadow *pshadow;

int next_uframe;

unsigned periodic_sched;

管理EHCI的等时调度和异性调度。

struct otg_transceiver *transceiver;

如果系统中有OTG，此成员负责OTG的操作和管理。

struct dma_pool *qh_pool; /

struct dma_pool *qtd_pool;

struct dma_pool *itd_pool;

struct dma_pool *sitd_pool;

struct timer_list iaa_watchdog;

struct timer_list watchdog;

unsigned long actions;

unsigned stamp;

unsigned long next_statechange;

struct list_head cached_itd_list;

unsigned clock_frame;

EHCI控制过程中所需要用到的操作系统的资源的管理。

struct usb_hcd {

......

/* The HC driver's private data is stored at the end of

* this structure.

*/

unsigned long hcd_priv[0]

__attribute__ ((aligned(sizeof(unsigned long))));

};

struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,

struct device *dev, const char *bus_name)

{

......

hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);

......

}

unsigned long hcd_priv[0] __attribute__ ((aligned(sizeof(unsigned long)))); 这样的语句是GNUＣ语言特有的用法，定义一个指向本结构体末尾的指针。

usb_create_hcd在给hcd分配内存是会多分配 driver->hcd_priv_size 大小的内存，按HCD的定义，这段多分配的内存正是unsigned long hcd_priv[0]指向的地址。这段多分配的地址正是用来存放ehci_hcd 对象的，在hc_driver中，我们一定要把ehci_hcd的长度赋给hcd_priv_size，如下：

hcd_priv_size = sizeof(struct ehci_hcd),

这样usb_create_hcd 才能正确的创建usb_hcd对象，ehci_hcd才有容身之地。

至于两者这、之间的转化，可以用下面这些函数为工具：

static inline struct ehci_hcd *hcd_to_ehci (struct usb_hcd *hcd)

{

return (struct ehci_hcd *) (hcd->hcd_priv);

}

static inline struct usb_hcd *ehci_to_hcd (struct ehci_hcd *ehci)

{

return container_of ((void *) ehci, struct usb_hcd, hcd_priv);

}

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);

int flags;

#define HCD_MEMORY 0x0001 /* HC regs use memory (else I/O) */

#define HCD_LOCAL_MEM 0x0002 /* HC needs local memory */

#define HCD_USB11 0x0010 /* USB 1.1 */

#define HCD_USB2 0x0020 /* USB 2.0 */

/* 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, pm_message_t message);

/* called after entering D0 (etc), before resuming the hub */

int (*pci_resume) (struct usb_hcd *hcd);

/* 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);

/* hw synch, freeing endpoint resources that urb_dequeue can't */

void (*endpoint_disable)(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);

int (*disconnect)(struct usb_hcd *);

int (*connect)(struct usb_hcd *, struct usb_device*);

/* 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);

};

static const struct hc_driver ehci_omap_hc_driver = {

.description = hcd_name,

.product_desc = "OMAP-EHCI Host Controller",

.hcd_priv_size = sizeof(struct ehci_hcd),

/*

* generic hardware linkage

*/

.irq = ehci_irq,

.flags = HCD_MEMORY | HCD_USB2,

/*

* basic lifecycle operations

*/

.reset = ehci_init,

.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,

/*

* 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,

.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,

};

hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);

if (!hcd->regs) {

dev_err(&pdev->dev, "EHCI ioremap failed/n");

ret = -ENOMEM;

goto err_ioremap;

}

/* we know this is the memory we want, no need to ioremap again */

omap->ehci->caps = hcd->regs;

omap->ehci_base = hcd->regs;

res = platform_get_resource(pdev, IORESOURCE_MEM, 1);

omap->uhh_base = ioremap(res->start, resource_size(res));

if (!omap->uhh_base) {

dev_err(&pdev->dev, "UHH ioremap failed/n");

ret = -ENOMEM;

goto err_uhh_ioremap;

}

struct ehci_itd {

/* first part defined by EHCI spec */

__hc32 hw_next; /* see EHCI 3.3.1 */

__hc32 hw_transaction [8]; /* see EHCI 3.3.2 */

#define EHCI_ISOC_ACTIVE (1<<31) /* activate transfer this slot */

#define EHCI_ISOC_BUF_ERR (1<<30) /* Data buffer error */

#define EHCI_ISOC_BABBLE (1<<29) /* babble detected */

#define EHCI_ISOC_XACTERR (1<<28) /* XactErr - transaction error */

#define EHCI_ITD_LENGTH(tok) (((tok)>>16) & 0x0fff)

#define EHCI_ITD_IOC (1 << 15) /* interrupt on complete */

#define ITD_ACTIVE(ehci) cpu_to_hc32(ehci, EHCI_ISOC_ACTIVE)

__hc32 hw_bufp [7]; /* see EHCI 3.3.3 */

__hc32 hw_bufp_hi [7]; /* Appendix B */

/* the rest is HCD-private */

dma_addr_t itd_dma; /* for this itd */

union ehci_shadow itd_next; /* ptr to periodic q entry */

struct urb *urb;

struct ehci_iso_stream *stream; /* endpoint's queue */

struct list_head itd_list; /* list of stream's itds */

/* any/all hw_transactions here may be used by that urb */

unsigned frame; /* where scheduled */

unsigned pg;

unsigned index[8]; /* in urb->iso_frame_desc */

} __attribute__ ((aligned (32)));

__hc32 hw_next;

指向下一个调度数据结构的指针。

__hc32 hw_transaction [8];

#define EHCI_ISOC_ACTIVE (1<<31) /* activate transfer this slot */

#define EHCI_ISOC_BUF_ERR (1<<30) /* Data buffer error */

#define EHCI_ISOC_BABBLE (1<<29) /* babble detected */

#define EHCI_ISOC_XACTERR (1<<28) /* XactErr - transaction error */

#define EHCI_ITD_LENGTH(tok) (((tok)>>16) & 0x0fff)

#define EHCI_ITD_IOC (1 << 15) /* interrupt on complete */

#define ITD_ACTIVE(ehci) cpu_to_hc32(ehci, EHCI_ISOC_ACTIVE)

传输状态和控制字段

设置成1，EHCI会自动传输本itd数据（对此数据进行调度），完成后EHCI置此位为0,此数据以后不参与调度。

有传输错误是置1（overrun/underrun）.

检测到 babble时EHCI会将此字段置1。

不能收到有效数据是EHCI置此位为1（超时，CRC错，PID错等）

传输数据长度，OUT传输时表示软件想要传送的数据长度，由软件写入，IN传输表示软件希望接收的数据长度，传输完成EHCI会写入实际的传输长度。

传输完成

使能ITD的宏。

Page Select (PG).Transaction X Offset这两个字段linux中没有使用。

__hc32 hw_bufp [7];

hw_bufp [0]的0-6位是设备地址，8-11位是端点号，12-31是buf指针。

__hc32 hw_bufp_hi [7];

64位时会用到此位，扩展指针位数

struct ehci_sitd {

/* first part defined by EHCI spec */

__hc32 hw_next;

/* uses bit field macros above - see EHCI 0.95 Table 3-8 */

__hc32 hw_fullspeed_ep; /* EHCI table 3-9 */

__hc32 hw_uframe; /* EHCI table 3-10 */

__hc32 hw_results; /* EHCI table 3-11 */

#define SITD_IOC (1 << 31) /* interrupt on completion */

#define SITD_PAGE (1 << 30) /* buffer 0/1 */

#define SITD_LENGTH(x) (0x3ff & ((x)>>16))

#define SITD_STS_ACTIVE (1 << 7) /* HC may execute this */

#define SITD_STS_ERR (1 << 6) /* error from TT */

#define SITD_STS_DBE (1 << 5) /* data buffer error (in HC) */

#define SITD_STS_BABBLE (1 << 4) /* device was babbling */

#define SITD_STS_XACT (1 << 3) /* illegal IN response */

#define SITD_STS_MMF (1 << 2) /* incomplete split transaction */

#define SITD_STS_STS (1 << 1) /* split transaction state */

#define SITD_ACTIVE(ehci) cpu_to_hc32(ehci, SITD_STS_ACTIVE)

__hc32 hw_buf [2]; /* EHCI table 3-12 */

__hc32 hw_backpointer; /* EHCI table 3-13 */

__hc32 hw_buf_hi [2]; /* Appendix B */

/* the rest is HCD-private */

dma_addr_t sitd_dma;

union ehci_shadow sitd_next; /* ptr to periodic q entry */

struct urb *urb;

struct ehci_iso_stream *stream; /* endpoint's queue */

struct list_head sitd_list; /* list of stream's sitds */

unsigned frame;

unsigned index;

} __attribute__ ((aligned (32)));

__hc32 hw_next;

指向下一sitd结构的指针，第1-2位表示传输类型（itd/sitd/qt）,5-31位表示指针。

__hc32 hw_fullspeed_ep;

31位位表示方向，24－30表示端口数，16-22表示hub地址，8-11位表端点号，0-6位表设备地址。

__hc32 hw_uframe;

__hc32 hw_results;

#define SITD_IOC (1 << 31) /* interrupt on completion */

#define SITD_PAGE (1 << 30) /* buffer 0/1 */

#define SITD_LENGTH(x) (0x3ff & ((x)>>16))

#define SITD_STS_ACTIVE (1 << 7) /* HC may execute this */

#define SITD_STS_ERR (1 << 6) /* error from TT */

#define SITD_STS_DBE (1 << 5) /* data buffer error (in HC) */

#define SITD_STS_BABBLE (1 << 4) /* device was babbling */

#define SITD_STS_XACT (1 << 3) /* illegal IN response */

#define SITD_STS_MMF (1 << 2) /* incomplete split transaction */

#define SITD_STS_STS (1 << 1) /* split transaction state */

__hc32 hw_buf [2];

12－31位表示buf地址，

__hc32 hw_backpointer;

__hc32 hw_buf_hi [2];

一般置0或指向一个sitd数据。

struct ehci_qtd {

/* first part defined by EHCI spec */

__hc32 hw_next; /* see EHCI 3.5.1 */

__hc32 hw_alt_next; /* see EHCI 3.5.2 */

__hc32 hw_token; /* see EHCI 3.5.3 */

#define QTD_TOGGLE (1 << 31) /* data toggle */

#define QTD_LENGTH(tok) (((tok)>>16) & 0x7fff)

#define QTD_IOC (1 << 15) /* interrupt on complete */

#define QTD_CERR(tok) (((tok)>>10) & 0x3)

#define QTD_PID(tok) (((tok)>>8) & 0x3)

#define QTD_STS_ACTIVE (1 << 7) /* HC may execute this */

#define QTD_STS_HALT (1 << 6) /* halted on error */

#define QTD_STS_DBE (1 << 5) /* data buffer error (in HC) */

#define QTD_STS_BABBLE (1 << 4) /* device was babbling (qtd halted) */

#define QTD_STS_XACT (1 << 3) /* device gave illegal response */

#define QTD_STS_MMF (1 << 2) /* incomplete split transaction */

#define QTD_STS_STS (1 << 1) /* split transaction state */

#define QTD_STS_PING (1 << 0) /* issue PING? */

#define ACTIVE_BIT(ehci) cpu_to_hc32(ehci, QTD_STS_ACTIVE)

#define HALT_BIT(ehci) cpu_to_hc32(ehci, QTD_STS_HALT)

#define STATUS_BIT(ehci) cpu_to_hc32(ehci, QTD_STS_STS)

__hc32 hw_buf [5]; /* see EHCI 3.5.4 */

__hc32 hw_buf_hi [5]; /* Appendix B */

/* the rest is HCD-private */

dma_addr_t qtd_dma; /* qtd address */

struct list_head qtd_list; /* sw qtd list */

struct urb *urb; /* qtd's urb */

size_t length; /* length of buffer */

} __attribute__ ((aligned (32)));

hw_next

指向下一传输单元

hw_alt_next

也是指向一个传输单元，当处理当前传输时遇到一个短包此字段会有用。

hw_token

#define QTD_TOGGLE (1 << 31) /* data toggle */

#define QTD_LENGTH(tok) (((tok)>>16) & 0x7fff)

#define QTD_IOC (1 << 15) /* interrupt on complete */

#define QTD_CERR(tok) (((tok)>>10) & 0x3)

#define QTD_PID(tok) (((tok)>>8) & 0x3)

#define QTD_STS_ACTIVE (1 << 7) /* HC may execute this */

#define QTD_STS_HALT (1 << 6) /* halted on error */

#define QTD_STS_DBE (1 << 5) /* data buffer error (in HC) */

#define QTD_STS_BABBLE (1 << 4) /* device was babbling (qtd halted) */

#define QTD_STS_XACT (1 << 3) /* device gave illegal response */

#define QTD_STS_MMF (1 << 2) /* incomplete split transaction */

#define QTD_STS_STS (1 << 1) /* split transaction state */

#define QTD_STS_PING (1 << 0) /* issue PING? */

hw_buf [5]

buf指针

hw_buf_hi [5];

兼容64位的指针

hw_next

队列头水平指向的指针

hw_info1

端点的特性

hw_current

当前指针

hw_qtd_next

下一传输块指针

hw_alt_next

hw_buf

buf指针

hw_buf_hi

兼容64位的指针

struct ehci_fstn {

__hc32 hw_next; /* any periodic q entry */

__hc32 hw_prev; /* qh or EHCI_LIST_END */

/* the rest is HCD-private */

dma_addr_t fstn_dma;

union ehci_shadow fstn_next; /* ptr to periodic q entry */

} __attribute__ ((aligned (32)));

dma_addr_t

一个符合DMA访问要求的地址

urb ＊

指向URB的指针

ehci_iso_stream ＊

管理所有的sitd和itd传输单元中的信息

list_head＊

链表指针

typedef struct urb //USB Request Block，包含了建立任何 USB传输所需的所有信息，并贯穿于USB协议栈对数据处理的整个过程

{

       spinlock_t lock;         & nbsp;    // lock for the URB

       void *hcpriv;                // private data for host controller与主机控制器相关数据，对USB内核层是透明

       struct list_head urb_list;       // list pointer to all active urbs双向指针，用于将此URB连接到处于活动的URB双向链表中

       struct urb *next;             // pointer to next URB 指向下一个URB的指针

       struct usb_device *dev;       // pointer to associated USB device 接受此URB的USB设备指针

       unsigned int pipe;// pipe information表示设备的某个端点和客户端驱动程序之间的管道

       int status;          ;           ;  // returned status 返回状态

       unsigned int transfer_flags;       // USB_DISABLE_SPD | USB_ISO_ASAP | etc.

USB_DISABLE_SPD   //拒绝短数据包，即比最大传输包长度小的数据包

USB_ISO_ASAP     //用于实时传输，告诉主机控制器立即进行此请求的数据传输。如果没有置位，则需要给start_frame赋值，用来通知主机控制器该在哪个帧上开始此请求的数据传输

USB_ASYNC_UNLINK  //告诉USBD采用异步方式取消请求

USB_QUEUE_BULK    //表示批量请求可以排队，一般一个设备的批量请求端点只有一个URB

USB_NO_FSBR       //表示全速传输站用的带宽不要回收

USB_ZERO_PACKET //表示批量传输的数据长度等于端点的包最大长度时，主机控制器在发送完数据后，再发送一个零长度的包表示数据结束

USB_TIMEOUT_KILLED //本位只被HCD设置，表示发生了超时。客户驱动可以给URB的处理设置一个超时时间，如果处理超时，则要求USBD结束对此URB的处理，URB的返回信息中会反映该此状态。

       void *transfer_buffer ;           ;  // associated data buffer传输数据缓存区指针，接收或发送设备的数据，它必须是物理连续的，不可换页的内存块，用kmalloc（，GFP_KERNEL）分配 

       int actual_length;      // actual data buffer length 实际数据长度

       int bandwidth;                  //此请求每次占用一帧的带宽，只适用实时/中断传输 

       int start_frame;    //此请求所开始传输的帧号，只适用实时/中断传输。中断传输时，表示返回启动此请求的第一次中断传输的帧号。实时传输时，指明处理第一个实时请求数据报包的帧号，如果设置了USB_ISO_ASAP，此变量表示返回启动第一次实时传输的帧号。

       int number_of_packets;  // number of packets in this request (iso)此请求所包含的数据包数，只适合实时传输

       int interval; // polling interval (irq only) 中断传输的周期，1〈= interval〈=255

       int error_count;   // number of errors in this transfer (iso only)发生传输错误次数的累加值，只适用实时传输

       int timeout;       // timeout (in jiffies)      

       void *context;               // context for completion routine回调函数中的参数

       usb_complete_t complete;       // pointer to completion routine 指向回调函数的指针。当数据传输完成后，主机控制器驱动会回调该函数。

       iso_packet_descriptor_t iso_frame_desc[0]; 要进行实时传输的结构数组，每个结构表示一次数据传输

}

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)

初始化控制URB结构，pipe是端点通道，setup_packet指向setup_packet数据，transfer_buffer指向transfer数据，

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)

初始化块传输的URB

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)

初始化中断传输的URB

usb_control_msg(struct usb_device *dev, unsigned int pipe,

__u8 request, __u8 requesttype, __u16 value, __u16 index,

void *data, __u16 size, int timeout);

usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe,

void *data, int len, int *actual_length, int timeout);

usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,

void *data, int len, int *actual_length,

int timeout);

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);

extern struct urb *usb_get_urb(struct urb *urb);

extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags);

extern int usb_unlink_urb(struct urb *urb);

extern void usb_kill_urb(struct urb *urb);

extern void usb_poison_urb(struct urb *urb);

extern void usb_unpoison_urb(struct urb *urb);

extern void usb_kill_anchored_urbs(struct usb_anchor *anchor);

usb_poison_anchored_urbs(struct usb_anchor *anchor);

extern void usb_unpoison_anchored_urbs(struct usb_anchor *anchor);

extern void usb_unlink_anchored_urbs(struct usb_anchor *anchor);

extern void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor);

extern void usb_unanchor_urb(struct urb *urb);

extern int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor,

unsigned int timeout);

extern struct urb *usb_get_from_anchor(struct usb_anchor *anchor);

extern void usb_scuttle_anchored_urbs(struct usb_anchor *anchor);

extern int usb_anchor_empty(struct usb_anchor *anchor);

#define PIPE_ISOCHRONOUS 0

#define PIPE_INTERRUPT 1

#define PIPE_CONTROL 2

#define PIPE_BULK 3

#define usb_pipein(pipe)

#define usb_pipeout(pipe)

#define usb_pipedevice(pipe)

#define usb_pipeendpoint(pipe)

#define usb_pipetype(pipe)

#define usb_pipeisoc(pipe)

#define usb_pipeint(pipe)

#define usb_pipecontrol(pipe)

#define usb_pipebulk(pipe)

#define usb_gettoggle(dev, ep, out)

#define usb_dotoggle(dev, ep, out)

#define usb_settoggle(dev, ep, out, bit)

#define usb_sndctrlpipe(dev,endpoint)

#define usb_rcvctrlpipe(dev,endpoint)

#define usb_sndisocpipe(dev,endpoint)

#define usb_rcvisocpipe(dev,endpoint)

#define usb_sndbulkpipe(dev,endpoint)

#define usb_rcvbulkpipe(dev,endpoint)

#define usb_sndintpipe(dev,endpoint)

#define usb_rcvintpipe(dev,endpoint)

static int ehci_urb_enqueue (

struct usb_hcd *hcd,

struct urb *urb,

gfp_t mem_flags

) {

struct ehci_hcd *ehci = hcd_to_ehci (hcd);

struct list_head qtd_list;

INIT_LIST_HEAD (&qtd_list);

switch (usb_pipetype (urb->pipe)) {

case PIPE_CONTROL:

/* qh_completions() code doesn't handle all the fault cases

* in multi-TD control transfers. Even 1KB is rare anyway.

*/

if (urb->transfer_buffer_length > (16 * 1024))

return -EMSGSIZE;

/* FALLTHROUGH */

/* case PIPE_BULK: */

default:

if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))

return -ENOMEM;

return submit_async(ehci, urb, &qtd_list, mem_flags);

case PIPE_INTERRUPT:

if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))

return -ENOMEM;

return intr_submit(ehci, urb, &qtd_list, mem_flags);

case PIPE_ISOCHRONOUS:

if (urb->dev->speed == USB_SPEED_HIGH)

return itd_submit (ehci, urb, mem_flags);

else

return sitd_submit (ehci, urb, mem_flags);

}

}

static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)

{

__hc32 dma = QH_NEXT(ehci, qh->qh_dma);

struct ehci_qh *head;

/* (re)start the async schedule? */

head = ehci->async;

timer_action_done (ehci, TIMER_ASYNC_OFF);

if (!head->qh_next.qh) {

u32 cmd = ehci_readl(ehci, &ehci->regs->command);

if (!(cmd & CMD_ASE)) {

/* in case a clear of CMD_ASE didn't take yet */

(void)handshake(ehci, &ehci->regs->status,

STS_ASS, 0, 150);

cmd |= CMD_ASE | CMD_RUN;

ehci_writel(ehci, cmd, &ehci->regs->command);

ehci_to_hcd(ehci)->state = HC_STATE_RUNNING;

/* posted write need not be known to HC yet ... */

}

}

/* clear halt and/or toggle; and maybe recover from silicon quirk */

if (qh->qh_state == QH_STATE_IDLE)

qh_refresh (ehci, qh);

/* splice right after start */

qh->qh_next = head->qh_next;

qh->hw_next = head->hw_next;

wmb ();

head->qh_next.qh = qh;

head->hw_next = dma;

qh->qh_state = QH_STATE_LINKED;

/* qtd completions reported later by interrupt */

}

usb/host/ehci_hcd.c

/* start HC running; it's halted, ehci_init() has been run (once) */

static int ehci_run (struct usb_hcd *hcd)

{

struct ehci_hcd *ehci = hcd_to_ehci (hcd);

......

if ((retval = ehci_reset(ehci)) != 0) {

ehci_mem_cleanup(ehci);

return retval;

}

ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);

ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);

1－audio：表示一个音频设 备。

2－communication device：通讯设备，如电话，moden等等。

3－HID：人机交互设备，如键盘，鼠标等。

6－image图象设备，如扫描仪，摄像头等，有时数码相 机也可归到这一类。

7－打印机类。如单向，双向打印机等。

8－mass storage海量存储类。所有带有一定存储功能的都可以归到这一类。如数码相机大多数都归这一类。

9－hub类。

11－chip card/smart card。

13 －－Content Security

14－－Video （Interface）

15－－Personal Healthcare

220－－Diagnostic Device

224－－Wireless Controller （Interface）

239－－Miscellaneous

254－－Application Specific （Interface）

255－vendor specific.厂家的自定义类，主要用于一些特殊的设备。如接口转接卡等。

struct usb_device {           ;  //代表一个USB设备 

      enum {

               USB_SPEED_UNKNOWN = 0,               /* enumerating */

               USB_SPEED_LOW, USB_SPEED_FULL,              /* usb 1.1 */

               USB_SPEED_HIGH                       /* usb 2.0 */

       } speed;                         //设备速度，低速/全速/高速

       struct usb_device *tt;             /* usb1.1 device on usb2.0 bus */，事务处理解释器

       int ttport;          ;      /* device/hub port on that tt */设备所连接的具有事务处理解释器功能的集线器端口

       atomic_t refcnt;          ;   /* Reference count */引用计数

       struct semaphore serialize; //用于同步

       unsigned int toggle[2] ;           ;    /* one bit for each endpoint ([0] = IN, [1] = OUT) */用于同步切换的位图，每个端点占用1位，[0]表示输入，[1]输出

       unsigned int halted[2];        /* endpoint halts; one bit per endpoint # & direction;  [0] = IN, [1] = OUT */表示端点是否处于停止状态的位图

       int epmaxpacketin[16] ;           ;/* INput endpoint specific maximums */输入端点的最大包长

       int epmaxpacketout[16] ;           ;    /* OUTput endpoint specific maximums */输出端点的最大包长

       struct usb_device *parent;   //表示设备所连的上游集线器指针

       struct usb_bus *bus;        /* Bus we're part of */设备所属的USB总线系统

       struct usb_device_descriptor descriptor;/* Descriptor */ 设备描述符

       struct usb_config_descriptor *config; /* All of the configs */指向设备的配置描述符和其所包含的接口描述符，端点描述符的指针

       struct usb_config_descriptor *actconfig;/* the active configuration */当前的配置描述符指针

       char **rawdescriptors;   ;           ;/* Raw descriptors for each config */

       int have_langid;            /* whether string_langid is valid yet *// 是否有string_langid

       int string_langid;        /* language ID for strings */和字符描述符相关的语言ID

      void *hcpriv;   ;           ;    /* Host Controller private data */设备在HCD层占用的资源指针，对USB内核层是透明的

    /* usbdevfs inode list */ 设备在usbdevfs中的inode列表

       struct list_head inodes;

       struct list_head filelist;

       /*

        * Child devices - these can be either new devices

        * (if this is a hub device), or different instances

        * of this same device.

        *

        * Each instance needs its own set of data structures.

        */只对当前设备是集线器的情况有效

      int maxchild;           /* Number of ports if hub */ hub的下游端口数

       struct usb_device *children[USB_MAXCHILDREN]; hub所连设备指针

};

struct usb_bus { //USB总线系统

       int busnum;          ;           ;  /* Bus number (in order of reg) */当前总线系统的序列号，Linux支持多总线系统并为它们编号

#ifdef DEVNUM_ROUND_ROBIN

       int devnum_next;     /* Next open device number in round-robin allocation */

#endif /* DEVNUM_ROUND_ROBIN */给连接到子系统上的设备分配设备号的数据结构

       struct usb_devmap devmap;       /* Device map */给连接到子系统上的设备分配设备号的数据结构

       struct usb_operations *op;      /* Operations (specific to the HC) */HCD为USB内核提供的一系统函数集指针

       struct usb_device *root_hub;    /* Root hub */指向根Hub的指针

       struct list_head bus_list;       双向链表指针，USB内核用一个双向链表来维护系统中所有USB总线系统

       void *hcpriv; /* Host Controller private data */与主机控制器相关数据，对USB内核层是透明

       int bandwidth_allocated;       /* on this Host Controller; applies to Int. and Isoc. pipes; measured in microseconds/frame; range is 0..900, where 900 = 90% of a 1-millisecond frame */当前子系统的带宽使用情况，单位是微秒/帧，取值范围[0,900]

       int bandwidth_int_reqs;        ; /* number of Interrupt requesters */子系统中当前的中断传输的数量

       int bandwidth_isoc_reqs;       /* number of Isoc. requesters */子系统中当前的实时传输的数量

       /* usbdevfs inode list */ 在usbdevfs中的inode列表       struct list_head inodes;

       atomic_t refcnt;

};

struct usb_driver { //客户端驱动程序为USB内核提供的调用接口

       const char *name;    //客户端驱动程序的字符串名称，用于避免重复安装和卸载

       void *(*probe)(//给USB内核提供的函数，用于判断驱动程序是否能对设备的某个接口进行驱动，如能则分配资源

           struct usb_device *dev,     ;           ;/* the device */

           unsigned intf,   ;           ;    /* what interface */

           const struct usb_device_id *id   /* from id_table */

           );

       void (*disconnect)(struct usb_device *, void *);//给USB内核提供的函数，用于释放设备的某个接口所占用的资源

       struct list_head driver_list;//对应的双向指针，USB内核通过一个双向指针链表维护USB子系统中所用的客户端驱动程序

       struct file_operations *fops;

       int minor; 驱动的次版本号

       struct semaphore serialize;

       /* ioctl -- userspace apps can talk to drivers through usbdevfs */

       int (*ioctl)(struct usb_device *dev, unsigned int code, void *buf);

       /* support for "new-style" USB hotplugging

        * binding policy can be driven from user mode too

        */

       const struct usb_device_id *id_table;

       /* suspend before the bus suspends;

        * disconnect or resume when the bus resumes */

       // void (*suspend)(struct usb_device *dev);

       // void (*resume)(struct usb_device *dev);

};

f4146900 2833361214 S Bo:1:004:2 -115 31 = 55534243 29010000 00000000 00000600 00000000 00000000 00000000 000000

f4146900 2833361268 C Bo:1:004:2 0 31 >

f4146900 2833361302 S Bi:1:004:1 -115 13 <

f4146900 2833361391 C Bi:1:004:1 0 13 = 55534253 29010000 00000000 00

f4146900 2835361212 S Bo:1:004:2 -115 31 = 55534243 2a010000 00000000 00000600 00000000 00000000 00000000 000000

f4146900 2835361274 C Bo:1:004:2 0 31 >

f4146900 2835361298 S Bi:1:004:1 -115 13 <

f4146900 2835361397 C Bi:1:004:1 0 13 = 55534253 2a010000 00000000 00

f5d38d00 2835764165 C Ii:1:001:1 0:2048 2 = 4000

f5d38d00 2835764175 S Ii:1:001:1 -115:2048 4 <

f46a0280 2835764187 S Ci:1:001:0 s a3 00 0000 0006 0004 4 <

f46a0280 2835764191 C Ci:1:001:0 0 4 = 00010100

f46a0280 2835764194 S Co:1:001:0 s 23 01 0010 0006 0000 0

f46a0280 2835764198 C Co:1:001:0 0 0

f46a0280 2835767349 S Ci:1:001:0 s a3 00 0000 0006 0004 4 <

f46a0280 2835767355 C Ci:1:001:0 0 4 = 00010000

f46a0300 2835794170 S Ci:1:001:0 s a3 00 0000 0006 0004 4 <

f46a0300 2835794223 C Ci:1:001:0 0 4 = 00010000

f46a0b80 2835819162 S Ci:1:001:0 s a3 00 0000 0006 0004 4 <

f46a0b80 2835819207 C Ci:1:001:0 0 4 = 00010000

f46a0280 2835847167 S Ci:1:001:0 s a3 00 0000 0006 0004 4 <

f46a0280 2835851345 C Ci:1:001:0 0 4 = 00010000

f46a0280 2835878175 S Ci:1:001:0 s a3 00 0000 0006 0004 4 <

f46a0280 2835878214 C Ci:1:001:0 0 4 = 00010000

f5d38d00 2836628334 C Ii:1:001:1 0:2048 2 = 4000

f5d38d00 2836628344 S Ii:1:001:1 -115:2048 4 <

f46a0980 2836628356 S Ci:1:001:0 s a3 00 0000 0006 0004 4 <

f46a0980 2836628360 C Ci:1:001:0 0 4 = 01050100

f46a0980 2836628363 S Co:1:001:0 s 23 01 0010 0006 0000 0

f46a0980 2836628367 C Co:1:001:0 0 0

f46a0980 2836628370 S Ci:1:001:0 s a3 00 0000 0006 0004 4 <

f46a0980 2836628372 C Ci:1:001:0 0 4 = 01050000

f4146900

urb内存地址

f4146900

时间戳

S

事件类型(S-submission, C-Callback, E-submission error)

B

端点类型I(中断),C(控制),B(Bulk)和Z(ISOC)

o

数据方向(i或者o)

:1

bus总线号

:004

该bus总线分配到的设备地址[luther.gliethttp]

:2

端点号,对于in端点,为异或^0x80,即去掉第8位1值的数据,比如0x81,那么这里数据为0x81 ^ 0x80 = 1;[luther.gliethttp]

31

数据的长度

=55534243 29010000 00000000 00000600 00000000 00000000 00000000 000000

数据

< --

< -- 表示有数据要上传,后面有需要接收的数据,后面会有IN动作, 

> --

> -- 表示数据部分已经成功下发