STM32FUSBHOSTlib数据结构

typedef struct USB_OTG_handle

{

USB_OTG_CORE_CFGS cfg;

USB_OTG_CORE_REGS regs;

#ifdef USE_DEVICE_MODE

DCD_DEV dev;

#endif

#ifdef USE_HOST_MODE

HCD_DEV host;

#endif

#ifdef USE_OTG_MODE

OTG_DEV otg;

#endif

}

USB_OTG_CORE_HANDLE , *PUSB_OTG_CORE_HANDLE;

typedef struct USB_OTG_core_cfg

{

uint8_t host_channels;

uint8_t dev_endpoints;

uint8_t speed;

uint8_t dma_enable;

uint16_t mps;

uint16_t TotalFifoSize;

uint8_t phy_itface;

uint8_t Sof_output;

uint8_t low_power;

uint8_t coreID;

}

USB_OTG_CORE_CFGS, *PUSB_OTG_CORE_CFGS;

typedef struct USB_OTG_core_regs //000h

{

USB_OTG_GREGS *GREGS;

USB_OTG_DREGS *DREGS;

USB_OTG_HREGS *HREGS;

USB_OTG_INEPREGS *INEP_REGS[USB_OTG_MAX_TX_FIFOS]; USB_OTG_OUTEPREGS *OUTEP_REGS[USB_OTG_MAX_TX_FIFOS]; USB_OTG_HC_REGS *HC_REGS[USB_OTG_MAX_TX_FIFOS];

__IO uint32_t *HPRT0;

__IO uint32_t *DFIFO[USB_OTG_MAX_TX_FIFOS];

__IO uint32_t *PCGCCTL;

}

USB_OTG_CORE_REGS , *PUSB_OTG_CORE_REGS;

typedef struct _HCD

{

uint8_t Rx_Buffer [MAX_DATA_LENGTH];

__IO uint32_t ConnSts;

__IO uint32_t ErrCnt[USB_OTG_MAX_TX_FIFOS];

__IO uint32_t XferCnt[USB_OTG_MAX_TX_FIFOS];

__IO HC_STATUS HC_Status[USB_OTG_MAX_TX_FIFOS];

__IO URB_STATE URB_State[USB_OTG_MAX_TX_FIFOS];

USB_OTG_HC hc [USB_OTG_MAX_TX_FIFOS];

uint16_t channel [USB_OTG_MAX_TX_FIFOS];

USB_OTG_hPort_TypeDef *port_cb;

}

HCD_DEV , *USB_OTG_USBH_PDEV;

typedef struct USB_OTG_hPort

{

void (*Disconnect) (void *phost);

void (*Connect) (void *phost);

uint8_t ConnStatus;

uint8_t DisconnStatus;

uint8_t ConnHandled;

uint8_t DisconnHandled;

} USB_OTG_hPort_TypeDef;

typedef struct _Host_TypeDef

{

HOST_State gState; /* Host State Machine Value */

HOST_State gStateBkp; /* backup of previous State machine value */ ENUM_State EnumState; /* Enumeration state Machine */

CMD_State RequestState;

USBH_Ctrl_TypeDef Control;

USBH_Device_TypeDef device_prop;

USBH_Class_cb_TypeDef *class_cb;

USBH_Usr_cb_TypeDef *usr_cb;

} USBH_HOST, *pUSBH_HOST;

HOST_IDLE =0,

HOST_ISSUE_CORE_RESET,

HOST_DEV_ATTACHED,

HOST_DEV_DISCONNECTED,

HOST_ISSUE_RESET,

HOST_DETECT_DEVICE_SPEED,

HOST_ENUMERATION,

HOST_CLASS_REQUEST,

HOST_CLASS,

HOST_CTRL_XFER,

HOST_USR_INPUT,

HOST_SUSPENDED,

HOST_ERROR_STATE

}HOST_State;

typedef enum {

ENUM_IDLE = 0,

ENUM_GET_FULL_DEV_DESC,

ENUM_SET_ADDR,

ENUM_GET_CFG_DESC,

ENUM_GET_FULL_CFG_DESC,

ENUM_GET_MFC_STRING_DESC, ENUM_GET_PRODUCT_STRING_DESC, ENUM_GET_SERIALNUM_STRING_DESC, ENUM_SET_CONFIGURATION,

ENUM_DEV_CONFIGURED

} ENUM_State;

typedef struct _Ctrl

{

uint8_t hc_num_in; uint8_t hc_num_out; uint8_t ep0size;

uint8_t *buff;

uint16_t length;

uint8_t errorcount; uint16_t timer;

CTRL_STATUS status;

USB_Setup_TypeDef setup; CTRL_State state;

} USBH_Ctrl_TypeDef;

CMD_IDLE =0,

CMD_SEND,

CMD_WAIT

} CMD_State;

typedef enum {

CTRL_START = 0,

CTRL_XFRC,

CTRL_HALTED,

CTRL_NAK,

CTRL_STALL,

CTRL_XACTERR,

CTRL_BBLERR,

CTRL_DATA TGLERR,

CTRL_FAIL

}CTRL_STATUS;

typedef union _USB_Setup

{ uint8_t d8[8];

struct _SetupPkt_Struc

{

uint8_t bmRequestType;

uint8_t bRequest;

uint16_t_uint8_t wValue;

uint16_t_uint8_t wIndex;

uint16_t_uint8_t wLength;

} b;

} USB_Setup_TypeDef;

typedef enum {

CTRL_IDLE =0,

CTRL_SETUP,

CTRL_SETUP_WAIT,

CTRL_DATA_IN,

CTRL_DATA_IN_WAIT,

CTRL_DATA_OUT,

CTRL_DATA_OUT_WAIT,

CTRL_STATUS_IN,

CTRL_STATUS_IN_WAIT,

CTRL_STATUS_OUT,

CTRL_STATUS_OUT_WAIT,

CTRL_ERROR

}CTRL_State;

{ uint8_t address;

uint8_t speed;

USBH_DevDesc_TypeDef Dev_Desc;

USBH_CfgDesc_TypeDef Cfg_Desc;

USBH_InterfaceDesc_TypeDef Itf_Desc[USBH_MAX_NUM_INTERFACES]; USBH_EpDesc_TypeDef

Ep_Desc[USBH_MAX_NUM_INTERFACES][USBH_MAX_NUM_ENDPOINTS];

USBH_HIDDesc_TypeDef HID_Desc;

}USBH_Device_TypeDef;

typedef struct _USBH_Class_cb

{ USBH_Status (*Init)\

(USB_OTG_CORE_HANDLE *pdev , void *phost);

void (*DeInit)\

(USB_OTG_CORE_HANDLE *pdev , void *phost);

USBH_Status (*Requests)\

(USB_OTG_CORE_HANDLE *pdev , void *phost);

USBH_Status (*Machine)\

(USB_OTG_CORE_HANDLE *pdev , void *phost);

} USBH_Class_cb_TypeDef;

typedef struct _USBH_USR_PROP

{ void (*Init)(void); /* HostLibInitialized */

void (*DeInit)(void); /* HostLibInitialized */

void (*DeviceAttached)(void); /* DeviceAttached */

void (*ResetDevice)(void);

void (*DeviceDisconnected)(void);

void (*OverCurrentDetected)(void);

void (*DeviceSpeedDetected)(uint8_t DeviceSpeed); /* DeviceSpeed */ void (*DeviceDescAvailable)(void *); /* DeviceDescriptor is available */

void (*DeviceAddressAssigned)(void); /* Address is assigned to USB Device */ void (*ConfigurationDescAvailable)(USBH_CfgDesc_TypeDef *,

USBH_InterfaceDesc_TypeDef *, USBH_EpDesc_TypeDef *);

/* Configuration Descriptor available */

void (*ManufacturerString)(void *); /* ManufacturerString*/

void (*ProductString)(void *); /* ProductString*/

void (*SerialNumString)(void *); /* SerialNubString*/

void (*EnumerationDone)(void); /* Enumeration finished */

USBH_USR_Status (*UserInput)(void);

int (*USBH_USR_MSC_Application) (void);

void (*USBH_USR_DeviceNotSupported)(void); /* Device is not supported*/

void (*UnrecoveredError)(void);

}USBH_Usr_cb_TypeDef;

{

uint8_t buff[64];

uint8_t hc_num_in; uint8_t hc_num_out; HID_State state;

uint8_t HIDIntOutEp; uint8_t HIDIntInEp; HID_CtlState ctl_state; uint16_t length;

uint8_t ep_addr; uint16_t poll;

__IO uint16_t timer;

HID_cb_TypeDef *cb; }

HID_Machine_TypeDef;

typedef enum

{

HID_REQ_IDLE = 0,

HID_REQ_GET_REPORT_DESC,

HID_REQ_GET_HID_DESC,

HID_REQ_SET_IDLE,

HID_REQ_SET_PROTOCOL,

HID_REQ_SET_REPORT,

}HID_CtlState;

typedef enum

{

HID_IDLE= 0,

HID_SEND_DATA,

HID_BUSY,

HID_GET_DA TA,

HID_POLL,

HID_ERROR,

}HID_State;

typedef struct HID_cb

{

void (*Init) (void);

void (*Decode) (uint8_t *data);

} HID_cb_TypeDef;

DO : 00 47 47 4b 80

DO : 1b 63 13 47 c5 dc ec 2f

DO : db 68 bc c4 ac ff 23 38

DO : ab 32 88 09 a0 ac 79 69

DO : 6d 3a 43 09 31 f6 eb 87 d9 db ef 15 9a 92 3d 7b 80 32 b4 33 e2 1a 2d 2f

typedef struct _MSC_Process

{

uint8_t hc_num_in;

uint8_t hc_num_out;

uint8_t MSBulkOutEp;

uint8_t MSBulkInEp;

uint16_t MSBulkInEpSize;

uint16_t MSBulkOutEpSize;

uint8_t buff[USBH_MSC_MPS_SIZE];

uint8_t maxLun;

}

MSC_Machine_TypeDef;

typedef struct _BOTXfer

{

uint8_t MSCState;

uint8_t MSCStateBkp;

uint8_t MSCStateCurrent;

uint8_t CmdStateMachine;

uint8_t BOTState;

uint8_t BOTStateBkp;

uint8_t* pRxTxBuff;

uint16_t DataLength;

uint8_t BOTXferErrorCount;

uint8_t BOTXferStatus;

} USBH_BOTXfer_TypeDef;

typedef enum { HC_IDLE = 0,

HC_XFRC,

HC_HALTED,

HC_NAK,

HC_NYET,

HC_STALL,

HC_XACTERR, HC_BBLERR,

HC_DATATGLERR, }HC_STATUS;

typedef enum { URB_IDLE = 0, URB_DONE, URB_NOTREADY, URB_ERROR, URB_STALL

}URB_STATE;