Merge pull request #1108 from uestczyh222/master

 [Components][Drivers][USB HOST]Fix core stack and msc driver

1 files changed, 78 insertions, 81 deletions

diff --git a/components/drivers/include/drivers/usb_host.h b/components/drivers/include/drivers/usb_host.h
index 0e6c21432b..92adaa3d47 100644
--- a/components/drivers/include/drivers/usb_host.h
+++ b/components/drivers/include/drivers/usb_host.h
@@ -37,17 +37,21 @@ extern "C" {
 #define USB_HUB_PORT_NUM                0x04
 #define SIZEOF_USB_REQUEST              0x08
 
-#define DEV_STATUS_IDLE               0x00
-#define DEV_STATUS_BUSY               0x01
-#define DEV_STATUS_ERROR              0x02
+#define DEV_STATUS_IDLE                 0x00
+#define DEV_STATUS_BUSY                 0x01
+#define DEV_STATUS_ERROR                0x02
 
 #define UPIPE_STATUS_OK                 0x00
 #define UPIPE_STATUS_STALL              0x01
 #define UPIPE_STATUS_ERROR              0x02
 
+#define USBH_PID_SETUP                  0x00
+#define USBH_PID_DATA                   0x01
+
 struct uhcd;
-struct uintf;
+struct uhintf;
 struct uhub;
+struct upipe;
 
 struct uclass_driver
 {
@@ -74,10 +78,16 @@ typedef struct uprotocal* uprotocal_t;
 
 struct uinstance
 {
+    struct rt_device parent;
+
     struct udevice_descriptor dev_desc;
     ucfg_desc_t cfg_desc;
     struct uhcd *hcd;
 
+    struct upipe * pipe_ep0_out;
+    struct upipe * pipe_ep0_in;
+    rt_list_t pipe;
+
     rt_uint8_t status;
     rt_uint8_t type;
     rt_uint8_t index;
@@ -86,12 +96,12 @@ struct uinstance
     rt_uint8_t max_packet_size;    
     rt_uint8_t port;
 
-    struct uhub* parent;
-    struct uintf* intf[USB_MAX_INTERFACE];        
+    struct uhub* parent_hub;
+    struct uhintf* intf[USB_MAX_INTERFACE];        
 };
 typedef struct uinstance* uinst_t;
 
-struct uintf
+struct uhintf
 {
     struct uinstance* device;
     uintf_desc_t intf_desc;
@@ -102,9 +112,11 @@ struct uintf
 
 struct upipe
 {
+    rt_list_t list;
+    rt_uint8_t pipe_index;
     rt_uint32_t status;
     struct uendpoint_descriptor ep;
-    struct uintf* intf;
+    uinst_t inst;
     func_callback callback;
     void* user_data;
 };
@@ -118,7 +130,7 @@ struct uhub
     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;
@@ -127,23 +139,18 @@ typedef struct uhub* uhub_t;
 
 struct uhcd_ops
 {
-    int (*ctl_xfer)(struct uinstance* 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, struct uintf* intf, 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);    
+    rt_err_t    (*reset_port)   (rt_uint8_t port);
+    int         (*pipe_xfer)    (upipe_t pipe, rt_uint8_t token, void* buffer, int nbytes, int timeout);
+    rt_err_t    (*open_pipe)    (upipe_t pipe);
+    rt_err_t    (*close_pipe)   (upipe_t pipe);  
 };
-
+typedef struct uhcd_ops* uhcd_ops_t;
 struct uhcd
 {
     struct rt_device parent;
-    struct uhcd_ops* ops;
-    struct uhub* roothub; 
+    uhcd_ops_t ops;
+    rt_uint8_t num_ports;
+    uhub_t roothub; 
 };
 typedef struct uhcd* uhcd_t;
 
@@ -171,22 +178,19 @@ typedef struct uhost_msg* uhost_msg_t;
 
 /* usb host system interface */
 rt_err_t rt_usb_host_init(void);
-void rt_usbh_hub_init(void);
+void rt_usbh_hub_init(struct uhcd *hcd);
 
 /* usb host core interface */
-struct uinstance* rt_usbh_alloc_instance(void);
+struct uinstance* rt_usbh_alloc_instance(uhcd_t uhcd);
 rt_err_t rt_usbh_attatch_instance(struct uinstance* device);
 rt_err_t rt_usbh_detach_instance(struct uinstance* device);
-rt_err_t rt_usbh_get_descriptor(struct uinstance* device, rt_uint8_t type, void* buffer, 
-    int nbytes);
+rt_err_t rt_usbh_get_descriptor(struct uinstance* device, rt_uint8_t type, void* buffer, int nbytes);
 rt_err_t rt_usbh_set_configure(struct uinstance* device, int config);
 rt_err_t rt_usbh_set_address(struct uinstance* device);
 rt_err_t rt_usbh_set_interface(struct uinstance* device, int intf);
 rt_err_t rt_usbh_clear_feature(struct uinstance* device, int endpoint, int feature);
-rt_err_t rt_usbh_get_interface_descriptor(ucfg_desc_t cfg_desc, int num, 
-    uintf_desc_t* intf_desc);
-rt_err_t rt_usbh_get_endpoint_descriptor(uintf_desc_t intf_desc, int num, 
-    uep_desc_t* ep_desc);
+rt_err_t rt_usbh_get_interface_descriptor(ucfg_desc_t cfg_desc, int num, uintf_desc_t* intf_desc);
+rt_err_t rt_usbh_get_endpoint_descriptor(uintf_desc_t intf_desc, int num, uep_desc_t* ep_desc);
 
 /* usb class driver interface */
 rt_err_t rt_usbh_class_driver_init(void);
@@ -197,26 +201,17 @@ rt_err_t rt_usbh_class_driver_disable(ucd_t drv, void* args);
 ucd_t rt_usbh_class_driver_find(int class_code, int subclass_code);
 
 /* usb class driver implement */
-ucd_t rt_usbh_class_driver_hid(void);
 ucd_t rt_usbh_class_driver_hub(void);
 ucd_t rt_usbh_class_driver_storage(void);
-ucd_t rt_usbh_class_driver_adk(void);
 
-/* usb hid protocal implement */
-uprotocal_t rt_usbh_hid_protocal_kbd(void);
-uprotocal_t rt_usbh_hid_protocal_mouse(void);
 
-/* usb adk class driver interface */
-rt_err_t rt_usbh_adk_set_string(const char* manufacturer, const char* model,
-    const char* description, const char* version, const char* uri, 
-    const char* serial);
 
 /* usb hub interface */
 rt_err_t rt_usbh_hub_get_descriptor(struct uinstance* device, rt_uint8_t *buffer, 
     rt_size_t size);
-rt_err_t rt_usbh_hub_get_status(struct uinstance* device, rt_uint8_t* buffer);
+rt_err_t rt_usbh_hub_get_status(struct uinstance* device, rt_uint32_t* buffer);
 rt_err_t rt_usbh_hub_get_port_status(uhub_t uhub, rt_uint16_t port, 
-    rt_uint8_t* buffer);
+    rt_uint32_t* buffer);
 rt_err_t rt_usbh_hub_clear_port_feature(uhub_t uhub, rt_uint16_t port, 
     rt_uint16_t feature);
 rt_err_t rt_usbh_hub_set_port_feature(uhub_t uhub, rt_uint16_t port, 
@@ -224,58 +219,59 @@ rt_err_t rt_usbh_hub_set_port_feature(uhub_t uhub, rt_uint16_t port,
 rt_err_t rt_usbh_hub_reset_port(uhub_t uhub, rt_uint16_t port);
 rt_err_t rt_usbh_event_signal(struct uhost_msg* msg);
 
-/* usb host controller driver interface */
-rt_inline rt_err_t rt_usb_hcd_alloc_pipe(uhcd_t hcd, upipe_t* pipe, 
-    struct uintf* intf, uep_desc_t ep, func_callback callback)
-{
-    if(intf == RT_NULL) return -RT_EIO;
 
-    return hcd->ops->alloc_pipe(pipe, intf, ep, callback);
-}
+void rt_usbh_root_hub_connect_handler(struct uhcd *hcd, rt_uint8_t port, rt_bool_t isHS);
+void rt_usbh_root_hub_disconnect_handler(struct uhcd *hcd, rt_uint8_t port);
 
-rt_inline rt_err_t rt_usb_hcd_free_pipe(uhcd_t hcd, upipe_t pipe)
+/* usb host controller driver interface */
+rt_inline rt_err_t rt_usb_instance_add_pipe(uinst_t inst, upipe_t pipe)
 {
+    RT_ASSERT(inst != RT_NULL);
     RT_ASSERT(pipe != RT_NULL);
-    
-    return hcd->ops->free_pipe(pipe);
+    rt_list_insert_before(&inst->pipe, &pipe->list);
+    return RT_EOK;
 }
-
-rt_inline int rt_usb_hcd_bulk_xfer(uhcd_t hcd, upipe_t pipe, void* buffer, 
-    int nbytes, int timeout)
+rt_inline upipe_t rt_usb_instance_find_pipe(uinst_t inst,rt_uint8_t ep_address)
 {
-    if(pipe == RT_NULL) return -1;
-    if(pipe->intf == RT_NULL) return -1;
-    if(pipe->intf->device == RT_NULL) return -1;    
-    if(pipe->intf->device->status == DEV_STATUS_IDLE) 
-        return -1;
-
-    return hcd->ops->bulk_xfer(pipe, buffer, nbytes, timeout);
+    rt_list_t * l;
+    for(l = inst->pipe.next;l != &inst->pipe;l = l->next)
+    {
+        if(rt_list_entry(l,struct upipe,list)->ep.bEndpointAddress == ep_address)
+        {
+            return rt_list_entry(l,struct upipe,list);
+        }
+    }
+    return RT_NULL;
 }
-
-rt_inline int rt_usb_hcd_control_xfer(uhcd_t hcd, struct uinstance* device, ureq_t setup, 
-    void* buffer, int nbytes, int timeout)
+rt_inline rt_err_t rt_usb_hcd_alloc_pipe(uhcd_t hcd, upipe_t* pipe, uinst_t inst, uep_desc_t ep)
 {
-    if(device->status == DEV_STATUS_IDLE) return -1;
-
-    return hcd->ops->ctl_xfer(device, setup, buffer, nbytes, timeout);
+    *pipe = (upipe_t)rt_malloc(sizeof(struct upipe));
+    if(*pipe == RT_NULL)
+    {
+        return RT_ERROR;
+    }
+    rt_memset(*pipe,0,sizeof(struct upipe));
+    (*pipe)->inst = inst;
+    rt_memcpy(&(*pipe)->ep,ep,sizeof(struct uendpoint_descriptor));
+    return hcd->ops->open_pipe(*pipe);
+}
+rt_inline void rt_usb_pipe_add_callback(upipe_t pipe, func_callback callback)
+{
+    pipe->callback = callback;
 }
 
-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->intf == RT_NULL) return -1;
-    if(pipe->intf->device == RT_NULL) return -1;    
-    if(pipe->intf->device->status == DEV_STATUS_IDLE) 
-        return -1;
-
-    return hcd->ops->int_xfer(pipe, buffer, nbytes, timeout);
+rt_inline rt_err_t rt_usb_hcd_free_pipe(uhcd_t hcd, upipe_t pipe)
+{
+    RT_ASSERT(pipe != RT_NULL);
+    hcd->ops->close_pipe(pipe);
+    rt_free(pipe);
+    return RT_EOK;
 }
 
-rt_inline rt_err_t rt_usb_hcd_hub_control(uhcd_t hcd, rt_uint16_t port, 
-    rt_uint8_t cmd, void *args)
-{    
-    return hcd->ops->hub_ctrl(port, cmd, args);
+int rt_usb_hcd_pipe_xfer(uhcd_t hcd, upipe_t pipe, void* buffer, int nbytes, int timeout);
+rt_inline int rt_usb_hcd_setup_xfer(uhcd_t hcd, upipe_t pipe, ureq_t setup, int timeout)
+{
+    return hcd->ops->pipe_xfer(pipe, USBH_PID_SETUP, (void *)setup, 8, timeout);
 }
 
 #ifdef __cplusplus
@@ -284,3 +280,4 @@ rt_inline rt_err_t rt_usb_hcd_hub_control(uhcd_t hcd, rt_uint16_t port,
 
 #endif
 
+