add usb_host.h file

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2207 bbd45198-f89e-11dd-88c7-29a3b14d5316

1 files changed, 552 insertions, 0 deletions

diff --git a/components/drivers/include/drivers/usb_host.h b/components/drivers/include/drivers/usb_host.h
new file mode 100644
index 0000000000..316d0059a2
--- /dev/null
+++ b/components/drivers/include/drivers/usb_host.h
@@ -0,0 +1,552 @@
+/*

+ * File      : usb_host.h

+ * This file is part of RT-Thread RTOS

+ * COPYRIGHT (C) 2011, RT-Thread Development Team

+ *

+ * The license and distribution terms for this file may be

+ * found in the file LICENSE in this distribution or at

+ * http://www.rt-thread.org/license/LICENSE

+ *

+ * Change Logs:

+ * Date           Author       Notes

+ * 2011-3-12     Yi Qiu      first version

+ */

+

+#ifndef __RT_USB_HOST_H__

+#define __RT_USB_HOST_H__

+

+#include <rtthread.h>

+

+#define RT_DEBUG_USB					0x01

+

+#define USB_MAX_DEVICE					0x20

+#define USB_MAX_INTERFACE				0x08

+#define USB_HUB_PORT_NUM				0x04

+#define SIZEOF_USB_REQUEST				0x08

+

+#define UINST_STATUS_IDLE				0x00

+#define UINST_STATUS_BUSY				0x01

+#define UINST_STATUS_ERROR				0x02

+

+#define UPIPE_STATUS_OK					0x00

+#define UPIPE_STATUS_STALL				0x01

+#define UPIPE_STATUS_ERROR				0x02

+

+#define USB_CLASS_DEVICE  				0x00

+#define USB_CLASS_AUDIO					0x01

+#define USB_CLASS_CDC  					0x02

+#define USB_CLASS_HID 		 			0x03

+#define USB_CLASS_PHYSICAL				0x05

+#define USB_CLASS_IMAGE					0x06

+#define USB_CLASS_PRINTER 				0x07

+#define USB_CLASS_MASS_STORAGE  		0x08

+#define USB_CLASS_HUB  					0x09

+#define USB_CLASS_CDC_DATA				0x0a

+#define USB_CLASS_SMART_CARD 			0x0b

+#define USB_CLASS_SECURITY				0x0d

+#define USB_CLASS_VIDEO					0x0e

+#define USB_CLASS_HEALTHCARE 			0x0f

+#define USB_CLASS_DIAG_DEVICE			0xdc

+#define USB_CLASS_WIRELESS				0xe0

+#define USB_CLASS_MISC 					0xef

+#define USB_CLASS_APP_SPECIFIC  		0xfe

+#define USB_CLASS_VEND_SPECIFIC 		0xff

+

+#define USB_DESC_TYPE_DEVICE			0x01

+#define USB_DESC_TYPE_CONFIGURATION		0x02

+#define USB_DESC_TYPE_STRING			0x03

+#define USB_DESC_TYPE_INTERFACE			0x04

+#define USB_DESC_TYPE_ENDPOINT			0x05

+#define USB_DESC_TYPE_DEVICEQUALIFIER	0x06

+#define USB_DESC_TYPE_OTHERSPEED		0x07

+#define USB_DESC_TYPE_HID 				0x21

+#define USB_DESC_TYPE_REPORT 			0x22

+#define USB_DESC_TYPE_PHYSICAL  		0x23

+#define USB_DESC_TYPE_HUB  				0x29

+

+#define USB_REQ_TYPE_STANDARD			0x00

+#define USB_REQ_TYPE_CLASS				0x20

+#define USB_REQ_TYPE_VENDOR  			0x40

+#define USB_REQ_TYPE_TYPE_MASK			0x60

+

+#define USB_REQ_TYPE_DIR_OUT			0x00

+#define USB_REQ_TYPE_DIR_IN				0x80

+

+#define USB_REQ_TYPE_DEVICE  			0x00

+#define USB_REQ_TYPE_INTERFACE  		0x01

+#define USB_REQ_TYPE_ENDPOINT			0x02

+#define USB_REQ_TYPE_OTHER				0x03

+#define USB_REQ_TYPE_RECIPIENT_MASK		0x1f

+

+#define USB_FEATURE_ENDPOINT_HALT		0x00

+#define USB_FEATURE_DEV_REMOTE_WAKEUP	0x01

+#define USB_FEATURE_TEST_MODE			0x02

+

+#define USB_REQ_GET_STATUS				0x00

+#define USB_REQ_CLEAR_FEATURE			0x01

+#define USB_REQ_SET_FEATURE				0x03

+#define USB_REQ_SET_ADDRESS				0x05

+#define USB_REQ_GET_DESCRIPTOR			0x06

+#define USB_REQ_SET_DESCRIPTOR			0x07

+#define USB_REQ_GET_CONFIGURATION		0x08

+#define USB_REQ_SET_CONFIGURATION		0x09

+#define USB_REQ_GET_INTERFACE			0x0A

+#define USB_REQ_SET_INTERFACE			0x0B

+#define USB_REQ_SYNCH_FRAME				0x0C

+#define USB_REQ_SET_ENCRYPTION			0x0D

+#define USB_REQ_GET_ENCRYPTION			0x0E

+#define USB_REQ_RPIPE_ABORT				0x0E

+#define USB_REQ_SET_HANDSHAKE			0x0F

+#define USB_REQ_RPIPE_RESET				0x0F

+#define USB_REQ_GET_HANDSHAKE			0x10

+#define USB_REQ_SET_CONNECTION			0x11

+#define USB_REQ_SET_SECURITY_DATA		0x12

+#define USB_REQ_GET_SECURITY_DATA		0x13

+#define USB_REQ_SET_WUSB_DATA			0x14

+#define USB_REQ_LOOPBACK_DATA_WRITE		0x15

+#define USB_REQ_LOOPBACK_DATA_READ		0x16

+#define USB_REQ_SET_INTERFACE_DS		0x17

+

+#define USB_PID_OUT  					0x01

+#define USB_PID_ACK  					0x02

+#define USB_PID_DATA0					0x03

+#define USB_PID_SOF  					0x05

+#define USB_PID_IN						0x09

+#define USB_PID_NACK 					0x0A

+#define USB_PID_DATA1					0x0B

+#define USB_PID_PRE  					0x0C

+#define USB_PID_SETUP					0x0D

+#define USB_PID_STALL					0x0E

+

+#define USB_EP_DESC_OUT					0x00

+#define USB_EP_DESC_IN					0x80

+#define USB_EP_DESC_NUM_MASK			0x0f

+

+#define USB_EP_ATTR_CONTROL				0x00

+#define USB_EP_ATTR_ISOC				0x01

+#define USB_EP_ATTR_BULK				0x02

+#define USB_EP_ATTR_INT					0x03

+#define USB_EP_ATTR_TYPE_MASK			0x03

+

+#define USB_EPNO_MASK 					0x7f

+#define USB_DIR_OUT 					0x00

+#define USB_DIR_IN 						0x80

+#define USB_DIR_MASK  					0x80

+

+#define RH_GET_PORT_STATUS				0

+#define RH_SET_PORT_STATUS				1

+#define RH_CLEAR_PORT_FEATURE			2

+#define RH_SET_PORT_FEATURE				3

+

+/*

+ * Port feature numbers

+ */

+#define PORT_FEAT_CONNECTION			0

+#define PORT_FEAT_ENABLE				1

+#define PORT_FEAT_SUSPEND				2

+#define PORT_FEAT_OVER_CURRENT			3

+#define PORT_FEAT_RESET					4

+#define PORT_FEAT_POWER					8

+#define PORT_FEAT_LOWSPEED				9

+#define PORT_FEAT_HIGHSPEED				10

+#define PORT_FEAT_C_CONNECTION			16

+#define PORT_FEAT_C_ENABLE				17

+#define PORT_FEAT_C_SUSPEND				18

+#define PORT_FEAT_C_OVER_CURRENT		19

+#define PORT_FEAT_C_RESET				20

+

+/*

+	The HcRhPortStatus[1:NDP] register is used to control and report port events on a per-port

+	basis. NumberDownstreamPorts represents the number of HcRhPortStatus registers that are

+	implemented in hardware.  The lower word is used to reflect the port status, whereas the upper

+	word reflects the status change bits.  Some status bits are implemented with special write behavior

+	(see below).  If a transaction (token through handshake) is in progress when a write to change

+	port status occurs, the resulting port status change must be postponed until the transaction

+	completes.  Reserved bits should always be written '0'.

+*/

+#define PORT_CCS    					0x00000001UL	/* R:CurrentConnectStatus - W:ClearPortEnable	*/

+#define PORT_PES        				0x00000002UL	/* R:PortEnableStatus - W:SetPortEnable 			*/

+#define PORT_PSS       					0x00000004UL	/* R:PortSuspendStatus - W:SetPortSuspend		*/

+#define PORT_POCI   					0x00000008UL	/* R:PortOverCurrentIndicator - W:ClearSuspendStatus	*/

+#define PORT_PRS         				0x00000010UL	/* R:PortResetStatus - W: SetPortReset			*/

+#define PORT_PPS         				0x00000100UL	/* R:PortPowerStatus - W: SetPortPower			*/

+#define PORT_LSDA     					0x00000200UL	/* R:LowSpeedDeviceAttached - W:ClearPortPower	*/

+#define PORT_CCSC						0x00010000UL

+#define PORT_PESC						0x00020000UL

+#define PORT_PSSC						0x00040000UL

+#define PORT_POCIC						0x00080000UL

+#define PORT_PRSC						0x00100000UL

+

+/*

+ *Hub Status & Hub Change bit masks

+ */

+#define HUB_STATUS_LOCAL_POWER			0x0001

+#define HUB_STATUS_OVERCURRENT			0x0002

+

+#define HUB_CHANGE_LOCAL_POWER			0x0001

+#define HUB_CHANGE_OVERCURRENT			0x0002

+

+#define USB_EP_ATTR(attr) 				(attr & USB_EP_ATTR_TYPE_MASK)

+#define USB_EP_DESC_NUM(addr)			(addr & USB_EP_DESC_NUM_MASK)

+

+#define uswap_32(x) \

+	((((x) & 0xff000000) >> 24) | \

+	 (((x) & 0x00ff0000) >>  8) | \

+	 (((x) & 0x0000ff00) <<  8) | \

+	 (((x) & 0x000000ff) << 24))

+

+typedef void (*func_callback)(void *context);

+

+struct uhcd;

+struct uifinst;

+struct uhubinst;

+

+enum umsg_type

+{

+	USB_MSG_CONNECT_CHANGE,

+	USB_MSG_CALLBACK,

+};

+typedef enum umsg_type umsg_type;

+

+struct usb_descriptor

+{

+	rt_uint8_t bLength;

+	rt_uint8_t type;

+};

+typedef struct usb_descriptor* udesc_t;

+

+struct udevice_descriptor 

+{

+	rt_uint8_t bLength;

+	rt_uint8_t type;

+	rt_uint16_t bcdUSB;

+	rt_uint8_t bDeviceClass;

+	rt_uint8_t bDeviceSubClass;

+	rt_uint8_t bDeviceProtocol;

+	rt_uint8_t bMaxPacketSize0;

+	rt_uint16_t idVendor;

+	rt_uint16_t idProduct;

+	rt_uint16_t bcdDevice;

+	rt_uint8_t iManufacturer;

+	rt_uint8_t iProduct;

+	rt_uint8_t iSerialNumber;

+	rt_uint8_t bNumConfigurations;

+};

+typedef struct udevice_descriptor* udev_desc_t;

+

+struct uconfig_descriptor 

+{

+	rt_uint8_t bLength;

+	rt_uint8_t type;

+	rt_uint16_t wTotalLength;

+	rt_uint8_t bNumInterfaces;

+	rt_uint8_t bConfigurationValue;

+	rt_uint8_t iConfiguration;

+	rt_uint8_t bmAttributes;

+	rt_uint8_t MaxPower;

+};

+typedef struct uconfig_descriptor* ucfg_desc_t;

+

+struct uinterface_descriptor 

+{

+	rt_uint8_t bLength;

+	rt_uint8_t type;

+	rt_uint8_t bInterfaceNumber;

+	rt_uint8_t bAlternateSetting;

+	rt_uint8_t bNumEndpoints;

+	rt_uint8_t bInterfaceClass;

+	rt_uint8_t bInterfaceSubClass;

+	rt_uint8_t bInterfaceProtocol;

+	rt_uint8_t iInterface;

+};

+typedef struct uinterface_descriptor* uintf_desc_t;

+

+struct uendpoint_descriptor 

+{

+	rt_uint8_t bLength;

+	rt_uint8_t type;

+	rt_uint8_t bEndpointAddress;

+	rt_uint8_t bmAttributes;

+	rt_uint16_t wMaxPacketSize;

+	rt_uint8_t bInterval;

+};

+typedef struct uendpoint_descriptor* uep_desc_t;

+

+struct ustring_descriptor 

+{

+	rt_uint8_t bLength;

+	rt_uint8_t type;

+	rt_uint8_t* String;

+};

+typedef struct ustring_descriptor* ustr_desc_t;

+

+struct uhub_descriptor 

+{

+	rt_uint8_t length;

+	rt_uint8_t type;

+	rt_uint8_t num_ports;

+	rt_uint16_t characteristics;	

+	rt_uint8_t pwron_to_good;		/* power on to power good */

+	rt_uint8_t current;	

+	rt_uint8_t removable[8];

+	rt_uint8_t pwr_ctl[8];

+};

+typedef struct uhub_descriptor* uhub_desc_t;

+

+struct ureqest

+{

+	rt_uint8_t request_type;

+	rt_uint8_t request;

+	rt_uint16_t value;

+	rt_uint16_t index;	

+	rt_uint16_t length;

+};

+typedef struct ureqest* ureq_t;

+

+struct uclass_driver

+{

+	rt_list_t list;

+	int class_code;

+	int subclass_code;

+	

+	rt_err_t (*run)(void* arg);

+	rt_err_t (*stop)(void* arg);

+

+	void* user_data;

+};

+typedef struct uclass_driver* ucd_t;

+

+struct uprotocal

+{

+	rt_list_t list;

+	int pro_id;

+	

+	rt_err_t (*init)(void* arg);

+	rt_err_t (*callback)(void* arg);	

+};

+typedef struct uprotocal* uprotocal_t;

+

+struct uinstance

+{

+	struct udevice_descriptor dev_desc;

+	ucfg_desc_t cfg_desc;

+	struct uhcd *hcd;

+

+	rt_uint8_t status;

+	rt_uint8_t type;

+	rt_uint8_t index;

+	rt_uint8_t address;	

+	rt_uint8_t speed;

+	rt_uint8_t max_packet_size;	

+	rt_uint8_t port;

+

+	struct uhubinst* parent;

+	struct uifinst* ifinst[USB_MAX_INTERFACE];		

+};

+typedef struct uinstance* uinst_t;

+

+struct uifinst

+{

+	uinst_t uinst;

+	uintf_desc_t intf_desc;

+

+	ucd_t drv;

+	void *user_data;

+};

+typedef struct uifinst* uifinst_t;

+

+struct upipe

+{

+	rt_uint32_t status;

+	struct uendpoint_descriptor ep;

+	uifinst_t ifinst;

+	func_callback callback;

+	void* user_data;

+};

+typedef struct upipe* upipe_t;

+

+struct umsg

+{

+	umsg_type type; 

+	union

+	{

+		struct uhubinst* uhub;

+		struct 

+		{

+			func_callback function;

+			void *context;

+		}cb;

+	}content;

+};

+typedef struct umsg* umsg_t;

+

+struct uhubinst

+{

+	struct uhub_descriptor hub_desc;

+	rt_uint8_t num_ports;

+	rt_uint32_t port_status[USB_HUB_PORT_NUM];

+	struct uinstance* child[USB_HUB_PORT_NUM];		

+

+	rt_bool_t is_roothub;

+	upipe_t pipe_in;

+	rt_uint8_t buffer[8];	

+	struct uinstance* self;

+	struct uhcd *hcd;	

+};	

+typedef struct uhubinst* uhubinst_t;

+

+struct uhcd_ops

+{

+	int (*ctl_xfer)(uinst_t inst, ureq_t setup, void* buffer, int nbytes, 

+		int timeout);

+	int (*bulk_xfer)(upipe_t pipe, void* buffer, int nbytes, int timeout);

+	int (*int_xfer)(upipe_t pipe, void* buffer, int nbytes, int timeout);

+	int (*iso_xfer)(upipe_t pipe, void* buffer, int nbytes, int timeout);

+	

+	rt_err_t (*alloc_pipe)(struct upipe** pipe, uifinst_t ifinst, uep_desc_t ep, 

+		func_callback callback);

+	rt_err_t (*free_pipe)(upipe_t pipe);	

+	rt_err_t (*hub_ctrl)(rt_uint16_t port, rt_uint8_t cmd, void *args);	

+};

+

+struct uhcd

+{

+	struct rt_device parent;

+	struct uhcd_ops* ops;

+};

+typedef struct uhcd* uhcd_t;

+

+/* usb host system interface */

+void rt_usb_host_init(void);

+void rt_usb_hub_thread(void);

+

+/* usb host core interface */

+uinst_t rt_usb_alloc_instance(void);

+rt_err_t rt_usb_attatch_instance(uinst_t uinst);

+rt_err_t rt_usb_detach_instance(uinst_t uinst);

+rt_err_t rt_usb_get_descriptor(uinst_t uinst, rt_uint8_t type, void* buffer, 

+	int nbytes);

+rt_err_t rt_usb_set_configure(uinst_t uinst, int config);

+rt_err_t rt_usb_set_address(uinst_t uinst);

+rt_err_t rt_usb_set_interface(uinst_t uinst, int intf);

+rt_err_t rt_usb_clear_feature(uinst_t uinst, int endpoint, int feature);

+rt_err_t rt_usb_get_interface_descriptor(ucfg_desc_t cfg_desc, int num, 

+	uintf_desc_t* intf_desc);

+rt_err_t rt_usb_get_endpoint_descriptor(uintf_desc_t intf_desc, int num, 

+	uep_desc_t* ep_desc);

+

+/* usb class driver interface */

+rt_err_t rt_usb_class_driver_init(void);

+rt_err_t rt_usb_class_driver_register(ucd_t drv);

+rt_err_t rt_usb_class_driver_unregister(ucd_t drv);

+rt_err_t rt_usb_class_driver_run(ucd_t drv, void* args);

+rt_err_t rt_usb_class_driver_stop(ucd_t drv, void* args);

+ucd_t rt_usb_class_driver_find(int class_code, int subclass_code);

+

+/* usb class driver implement */

+ucd_t rt_usb_class_driver_hid(void);

+ucd_t rt_usb_class_driver_hub(void);

+ucd_t rt_usb_class_driver_storage(void);

+ucd_t rt_usb_class_driver_adk(void);

+

+/* usb hid protocal implement */

+uprotocal_t rt_usb_hid_protocal_kbd(void);

+uprotocal_t rt_usb_hid_protocal_mouse(void);

+

+/* usb hub interface */

+rt_err_t rt_usb_hub_get_descriptor(uinst_t uinst, rt_uint8_t *buffer, 

+	rt_size_t size);

+rt_err_t rt_usb_hub_get_status(uinst_t uinst, rt_uint8_t* buffer);

+rt_err_t rt_usb_hub_get_port_status(uhubinst_t uhub, rt_uint16_t port, 

+	rt_uint8_t* buffer);

+rt_err_t rt_usb_hub_clear_port_feature(uhubinst_t uhub, rt_uint16_t port, 

+	rt_uint16_t feature);

+rt_err_t rt_usb_hub_set_port_feature(uhubinst_t uhub, rt_uint16_t port, 

+	rt_uint16_t feature);

+rt_err_t rt_usb_hub_reset_port(uhubinst_t uhub, rt_uint16_t port);

+rt_err_t rt_usb_post_event(struct umsg* msg, rt_size_t size);

+

+/* usb host controller driver interface */

+rt_inline rt_err_t rt_usb_hcd_alloc_pipe(uhcd_t hcd, upipe_t* pipe, 

+	uifinst_t ifinst, uep_desc_t ep, func_callback callback)

+{

+	if(ifinst == RT_NULL) return -RT_EIO;

+

+	/* parameter check */

+	RT_ASSERT(hcd != RT_NULL);

+	RT_ASSERT(hcd->ops != RT_NULL);	

+	RT_ASSERT(hcd->ops->alloc_pipe!= RT_NULL);

+

+	return hcd->ops->alloc_pipe(pipe, ifinst, ep, callback);

+}

+

+rt_inline rt_err_t rt_usb_hcd_free_pipe(uhcd_t hcd, upipe_t pipe)

+{

+	RT_ASSERT(pipe != RT_NULL);

+	

+	/* parameter check */

+	RT_ASSERT(hcd != RT_NULL);

+	RT_ASSERT(hcd->ops != RT_NULL);	

+	RT_ASSERT(hcd->ops->free_pipe!= RT_NULL);

+

+	return hcd->ops->free_pipe(pipe);

+}

+

+rt_inline int rt_usb_hcd_bulk_xfer(uhcd_t hcd, upipe_t pipe, void* buffer, 

+	int nbytes, int timeout)

+{

+	if(pipe == RT_NULL) return -1;

+	if(pipe->ifinst == RT_NULL) return -1;

+	if(pipe->ifinst->uinst == RT_NULL) return -1;	

+	if(pipe->ifinst->uinst->status == UINST_STATUS_IDLE) 

+		return -1;

+

+	/* parameter check */

+	RT_ASSERT(hcd != RT_NULL);

+	RT_ASSERT(hcd->ops != RT_NULL);	

+	RT_ASSERT(hcd->ops->bulk_xfer!= RT_NULL);

+

+	return hcd->ops->bulk_xfer(pipe, buffer, nbytes, timeout);

+}

+

+rt_inline int rt_usb_hcd_control_xfer(uhcd_t hcd, uinst_t uinst, ureq_t setup, 

+	void* buffer, int nbytes, int timeout)

+{

+	if(uinst->status == UINST_STATUS_IDLE) return -1;

+

+	/* parameter check */

+	RT_ASSERT(hcd != RT_NULL);

+	RT_ASSERT(hcd->ops != RT_NULL);	

+	RT_ASSERT(hcd->ops->ctl_xfer!= RT_NULL);		

+

+	return hcd->ops->ctl_xfer(uinst, setup, buffer, nbytes, timeout);

+}

+

+rt_inline int rt_usb_hcd_int_xfer(uhcd_t hcd, upipe_t pipe, void* buffer, 

+	int nbytes, int timeout)

+{	

+	if(pipe == RT_NULL) return -1;

+	if(pipe->ifinst == RT_NULL) return -1;

+	if(pipe->ifinst->uinst == RT_NULL) return -1;	

+	if(pipe->ifinst->uinst->status == UINST_STATUS_IDLE) 

+		return -1;

+

+	RT_ASSERT(hcd != RT_NULL);

+	RT_ASSERT(hcd->ops != RT_NULL);	

+	RT_ASSERT(hcd->ops->int_xfer!= RT_NULL);

+

+	return hcd->ops->int_xfer(pipe, buffer, nbytes, timeout);

+}

+

+rt_inline rt_err_t rt_usb_hcd_hub_control(uhcd_t hcd, rt_uint16_t port, 

+	rt_uint8_t cmd, void *args)

+{	

+	RT_ASSERT(hcd != RT_NULL);

+	RT_ASSERT(hcd->ops != RT_NULL);

+	RT_ASSERT(hcd->ops->hub_ctrl != RT_NULL);

+

+	return hcd->ops->hub_ctrl(port, cmd, args);

+}

+

+#endif

+