diff --git a/components/drivers/include/drivers/usb_host.h b/components/drivers/include/drivers/usb_host.h index a5a850d4cf..0e6c21432b 100644 --- a/components/drivers/include/drivers/usb_host.h +++ b/components/drivers/include/drivers/usb_host.h @@ -37,17 +37,17 @@ extern "C" { #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 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 struct uhcd; -struct uifinst; -struct uhubinst; +struct uintf; +struct uhub; struct uclass_driver { @@ -55,8 +55,8 @@ struct uclass_driver int class_code; int subclass_code; - rt_err_t (*run)(void* arg); - rt_err_t (*stop)(void* arg); + rt_err_t (*enable)(void* arg); + rt_err_t (*disable)(void* arg); void* user_data; }; @@ -86,32 +86,31 @@ struct uinstance rt_uint8_t max_packet_size; rt_uint8_t port; - struct uhubinst* parent; - struct uifinst* ifinst[USB_MAX_INTERFACE]; + struct uhub* parent; + struct uintf* intf[USB_MAX_INTERFACE]; }; typedef struct uinstance* uinst_t; -struct uifinst +struct uintf { - uinst_t uinst; + struct uinstance* device; 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; + struct uintf* intf; func_callback callback; void* user_data; }; typedef struct upipe* upipe_t; -struct uhubinst +struct uhub { struct uhub_descriptor hub_desc; rt_uint8_t num_ports; @@ -122,19 +121,19 @@ struct uhubinst upipe_t pipe_in; rt_uint8_t buffer[8]; struct uinstance* self; - struct uhcd *hcd; + struct uhcd *hcd; }; -typedef struct uhubinst* uhubinst_t; +typedef struct uhub* uhub_t; struct uhcd_ops { - int (*ctl_xfer)(uinst_t inst, ureq_t setup, void* buffer, int nbytes, + 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, uifinst_t ifinst, uep_desc_t ep, + 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); @@ -144,6 +143,7 @@ struct uhcd { struct rt_device parent; struct uhcd_ops* ops; + struct uhub* roothub; }; typedef struct uhcd* uhcd_t; @@ -159,7 +159,7 @@ struct uhost_msg uhost_msg_type type; union { - struct uhubinst* uhub; + struct uhub* hub; struct { func_callback function; @@ -170,82 +170,67 @@ struct uhost_msg typedef struct uhost_msg* uhost_msg_t; /* usb host system interface */ -void rt_usb_host_init(void); -void rt_usb_hub_thread(void); +rt_err_t rt_usb_host_init(void); +void rt_usbh_hub_init(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); +struct uinstance* rt_usbh_alloc_instance(void); +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_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); /* 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); +rt_err_t rt_usbh_class_driver_init(void); +rt_err_t rt_usbh_class_driver_register(ucd_t drv); +rt_err_t rt_usbh_class_driver_unregister(ucd_t drv); +rt_err_t rt_usbh_class_driver_enable(ucd_t drv, void* args); +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_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); +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_usb_hid_protocal_kbd(void); -uprotocal_t rt_usb_hid_protocal_mouse(void); +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_usb_adk_set_string(const char *manufacturer, - const char *model, - const char *description, - const char *version, - const char *uri, - const char *serial); +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_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 uhost_msg* msg, rt_size_t size); +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_port_status(uhub_t uhub, rt_uint16_t port, + rt_uint8_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, + rt_uint16_t feature); +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, - uifinst_t ifinst, - uep_desc_t ep, - func_callback callback) +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 (ifinst == RT_NULL) - return -RT_EIO; + if(intf == RT_NULL) return -RT_EIO; - return hcd->ops->alloc_pipe(pipe, ifinst, ep, callback); + return hcd->ops->alloc_pipe(pipe, intf, ep, callback); } rt_inline rt_err_t rt_usb_hcd_free_pipe(uhcd_t hcd, upipe_t pipe) @@ -255,59 +240,40 @@ rt_inline rt_err_t rt_usb_hcd_free_pipe(uhcd_t hcd, upipe_t pipe) 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) +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) + 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_inline int rt_usb_hcd_control_xfer(uhcd_t hcd, - uinst_t uinst, - ureq_t setup, - void *buffer, - int nbytes, - int timeout) +rt_inline int rt_usb_hcd_control_xfer(uhcd_t hcd, struct uinstance* device, ureq_t setup, + void* buffer, int nbytes, int timeout) { - if (uinst->status == UINST_STATUS_IDLE) - return -1; + if(device->status == DEV_STATUS_IDLE) return -1; - return hcd->ops->ctl_xfer(uinst, setup, buffer, nbytes, timeout); + return hcd->ops->ctl_xfer(device, setup, buffer, nbytes, timeout); } -rt_inline int rt_usb_hcd_int_xfer(uhcd_t hcd, - upipe_t pipe, - void *buffer, - int nbytes, - int 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) + 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_hub_control(uhcd_t hcd, - rt_uint16_t port, - rt_uint8_t cmd, - void *args) +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); } diff --git a/components/drivers/usb/usbhost/SConscript b/components/drivers/usb/usbhost/SConscript index 02e09f75df..32962b104e 100644 --- a/components/drivers/usb/usbhost/SConscript +++ b/components/drivers/usb/usbhost/SConscript @@ -9,22 +9,22 @@ core/usbhost.c core/hub.c """) -if GetDepend('RT_USB_CLASS_ADK'): +if GetDepend('RT_USBH_ADK'): src += Glob('class/adk.c') - src += Glob('udev/adkapp.c') + src += Glob('class/adkapp.c') -if GetDepend('RT_USB_CLASS_MASS_STORAGE'): +if GetDepend('RT_USBH_MSTORAGE'): src += Glob('class/mass.c') - src += Glob('udev/udisk.c') + src += Glob('class/udisk.c') -if GetDepend('RT_USB_CLASS_HID'): +if GetDepend('RT_USBH_HID'): src += Glob('class/hid.c') -if GetDepend('RT_USB_HID_MOUSE'): - src += Glob('udev/umouse.c') +if GetDepend('RT_USBH_HID_MOUSE'): + src += Glob('class/umouse.c') -if GetDepend('RT_USB_HID_KEYBOARD'): - src += Glob('udev/ukbd.c') +if GetDepend('RT_USBH_HID_KEYBOARD'): + src += Glob('class/ukbd.c') CPPPATH = [cwd, cwd + '/class', cwd + '/core', \ cwd + '/include', cwd + '../../../include'] diff --git a/components/drivers/usb/usbhost/class/adk.c b/components/drivers/usb/usbhost/class/adk.c index 0b470f6884..fd6619599c 100644 --- a/components/drivers/usb/usbhost/class/adk.c +++ b/components/drivers/usb/usbhost/class/adk.c @@ -26,7 +26,7 @@ #include #include "adk.h" -#ifdef RT_USB_CLASS_ADK +#ifdef RT_USBH_ADK static struct uclass_driver adk_driver; static const char* _adk_manufacturer = RT_NULL; @@ -36,7 +36,7 @@ static const char* _adk_version = RT_NULL; static const char* _adk_uri = RT_NULL; static const char* _adk_serial = RT_NULL; -rt_err_t rt_usb_adk_set_string(const char* manufacturer, const char* model, +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) { @@ -53,29 +53,29 @@ rt_err_t rt_usb_adk_set_string(const char* manufacturer, const char* model, #ifdef RT_USING_MODULE #include -RTM_EXPORT(rt_usb_adk_set_string); +RTM_EXPORT(rt_usbh_adk_set_string); #endif /** * This function will do USB_REQ_GET_PROTOCOL request to set idle period to the usb adk device * - * @param ifinst the interface instance. + * @param intf the interface instance. * @duration the idle period of requesting data. * @report_id the report id * * @return the error code, RT_EOK on successfully. */ -static rt_err_t rt_usb_adk_get_protocol(uifinst_t ifinst, rt_uint16_t *protocol) +static rt_err_t rt_usbh_adk_get_protocol(struct uintf* intf, rt_uint16_t *protocol) { struct ureqest setup; - uinst_t uinst; + uinst_t device; int timeout = 100; /* parameter check */ - RT_ASSERT(ifinst != RT_NULL); - RT_ASSERT(ifinst->uinst != RT_NULL); + RT_ASSERT(intf != RT_NULL); + RT_ASSERT(intf->device != RT_NULL); - uinst = ifinst->uinst; + device = intf->device; setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_VENDOR | USB_REQ_TYPE_DEVICE; @@ -84,7 +84,7 @@ static rt_err_t rt_usb_adk_get_protocol(uifinst_t ifinst, rt_uint16_t *protocol) setup.length = 2; setup.value = 0; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, (void*)protocol, 2, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, (void*)protocol, 2, timeout) == 0) return RT_EOK; else return -RT_FALSE; } @@ -92,24 +92,24 @@ static rt_err_t rt_usb_adk_get_protocol(uifinst_t ifinst, rt_uint16_t *protocol) /** * This function will do USB_REQ_SEND_STRING request to set idle period to the usb adk device * - * @param ifinst the interface instance. + * @param intf the interface instance. * @duration the idle period of requesting data. * @report_id the report id * * @return the error code, RT_EOK on successfully. */ -static rt_err_t rt_usb_adk_send_string(uifinst_t ifinst, rt_uint16_t index, +static rt_err_t rt_usbh_adk_send_string(struct uintf* intf, rt_uint16_t index, const char* str) { struct ureqest setup; - uinst_t uinst; + uinst_t device; int timeout = 100; /* parameter check */ - RT_ASSERT(ifinst != RT_NULL); - RT_ASSERT(ifinst->uinst != RT_NULL); + RT_ASSERT(intf != RT_NULL); + RT_ASSERT(intf->device != RT_NULL); - uinst = ifinst->uinst; + device = intf->device; setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_VENDOR | USB_REQ_TYPE_DEVICE; @@ -118,7 +118,7 @@ static rt_err_t rt_usb_adk_send_string(uifinst_t ifinst, rt_uint16_t index, setup.length = rt_strlen(str) + 1; setup.value = 0; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, (void*)str, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, (void*)str, rt_strlen(str) + 1, timeout) == 0) return RT_EOK; else return -RT_FALSE; } @@ -126,23 +126,23 @@ static rt_err_t rt_usb_adk_send_string(uifinst_t ifinst, rt_uint16_t index, /** * This function will do USB_REQ_START request to set idle period to the usb adk device * - * @param ifinst the interface instance. + * @param intf the interface instance. * @duration the idle period of requesting data. * @report_id the report id * * @return the error code, RT_EOK on successfully. */ -static rt_err_t rt_usb_adk_start(uifinst_t ifinst) +static rt_err_t rt_usbh_adk_start(struct uintf* intf) { struct ureqest setup; - uinst_t uinst; + uinst_t device; int timeout = 100; /* parameter check */ - RT_ASSERT(ifinst != RT_NULL); - RT_ASSERT(ifinst->uinst != RT_NULL); + RT_ASSERT(intf != RT_NULL); + RT_ASSERT(intf->device != RT_NULL); - uinst = ifinst->uinst; + device = intf->device; setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_VENDOR | USB_REQ_TYPE_DEVICE; @@ -151,7 +151,7 @@ static rt_err_t rt_usb_adk_start(uifinst_t ifinst) setup.length = 0; setup.value = 0; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, RT_NULL, 0, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, timeout) == 0) return RT_EOK; else return -RT_FALSE; } @@ -159,25 +159,25 @@ static rt_err_t rt_usb_adk_start(uifinst_t ifinst) /** * This function will read data from usb adk device * - * @param ifinst the interface instance. + * @param intf the interface instance. * * @return the error code, RT_EOK on successfully. */ -static rt_size_t rt_usb_adk_read(rt_device_t device, rt_off_t pos, void* buffer, +static rt_size_t rt_usbh_adk_read(rt_device_t device, rt_off_t pos, void* buffer, rt_size_t size) { - uadkinst_t adkinst; + uadk_t adk; rt_size_t length; - uifinst_t ifinst; + struct uintf* intf; /* check parameter */ RT_ASSERT(device != RT_NULL); RT_ASSERT(buffer != RT_NULL); - ifinst = (uifinst_t)device->user_data; - adkinst = (uadkinst_t)ifinst->user_data; + intf = (struct uintf*)device->user_data; + adk = (uadk_t)intf->user_data; - length = rt_usb_hcd_bulk_xfer(ifinst->uinst->hcd, adkinst->pipe_in, + length = rt_usb_hcd_bulk_xfer(intf->device->hcd, adk->pipe_in, buffer, size, 300); return length; @@ -187,23 +187,23 @@ static rt_size_t rt_usb_adk_read(rt_device_t device, rt_off_t pos, void* buffer, /** * This function will write data to usb adk device * - * @param ifinst the interface instance. + * @param intf the interface instance. * * @return the error code, RT_EOK on successfully. */ -static rt_size_t rt_usb_adk_write (rt_device_t device, rt_off_t pos, const void* buffer, +static rt_size_t rt_usbh_adk_write (rt_device_t device, rt_off_t pos, const void* buffer, rt_size_t size) { - uadkinst_t adkinst; + uadk_t adk; rt_size_t length; - uifinst_t ifinst; + struct uintf* intf; RT_ASSERT(buffer != RT_NULL); - ifinst = (uifinst_t)device->user_data; - adkinst = (uadkinst_t)ifinst->user_data; + intf = (struct uintf*)device->user_data; + adk = (uadk_t)intf->user_data; - length = rt_usb_hcd_bulk_xfer(ifinst->uinst->hcd, adkinst->pipe_out, + length = rt_usb_hcd_bulk_xfer(intf->device->hcd, adk->pipe_out, (void*)buffer, size, 300); return length; @@ -217,30 +217,30 @@ static rt_size_t rt_usb_adk_write (rt_device_t device, rt_off_t pos, const void* * * @return the error code, RT_EOK on successfully. */ -static rt_err_t rt_usb_adk_run(void* arg) +static rt_err_t rt_usbh_adk_enable(void* arg) { int i = 0; - uadkinst_t adkinst; - uifinst_t ifinst = (uifinst_t)arg; + uadk_t adk; + struct uintf* intf = (struct uintf*)arg; udev_desc_t dev_desc; rt_uint16_t protocol; rt_err_t ret; /* parameter check */ - if(ifinst == RT_NULL) + if(intf == RT_NULL) { rt_kprintf("the interface is not available\n"); return -RT_EIO; } - RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usb_adk_run\n")); + RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_adk_run\n")); - dev_desc = &ifinst->uinst->dev_desc; + dev_desc = &intf->device->dev_desc; if(dev_desc->idVendor == USB_ACCESSORY_VENDOR_ID && (dev_desc->idProduct == USB_ACCESSORY_PRODUCT_ID || dev_desc->idProduct == USB_ACCESSORY_ADB_PRODUCT_ID)) { - if(ifinst->intf_desc->bInterfaceSubClass != 0xFF) return -RT_ERROR; + if(intf->intf_desc->bInterfaceSubClass != 0xFF) return -RT_ERROR; RT_DEBUG_LOG(RT_DEBUG_USB, ("found android accessory device\n")); } @@ -248,9 +248,9 @@ static rt_err_t rt_usb_adk_run(void* arg) { RT_DEBUG_LOG(RT_DEBUG_USB, ("switch device\n")); - if((ret = rt_usb_adk_get_protocol(ifinst, &protocol)) != RT_EOK) + if((ret = rt_usbh_adk_get_protocol(intf, &protocol)) != RT_EOK) { - rt_kprintf("rt_usb_adk_get_protocol failed\n"); + rt_kprintf("rt_usbh_adk_get_protocol failed\n"); return ret; } @@ -260,17 +260,17 @@ static rt_err_t rt_usb_adk_run(void* arg) return -RT_ERROR; } - rt_usb_adk_send_string(ifinst, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_MANUFACTURER, _adk_manufacturer); - rt_usb_adk_send_string(ifinst, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_MODEL, _adk_model); - rt_usb_adk_send_string(ifinst, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_DESCRIPTION, _adk_description); - rt_usb_adk_send_string(ifinst, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_VERSION, _adk_version); - rt_usb_adk_send_string(ifinst, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_URI, _adk_uri); - rt_usb_adk_send_string(ifinst, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_SERIAL, _adk_serial); RT_DEBUG_LOG(RT_DEBUG_USB, ("manufacturer %s\n", _adk_manufacturer)); @@ -280,28 +280,28 @@ static rt_err_t rt_usb_adk_run(void* arg) RT_DEBUG_LOG(RT_DEBUG_USB, ("uri %s\n", _adk_uri)); RT_DEBUG_LOG(RT_DEBUG_USB, ("serial %s\n", _adk_serial)); - if((ret = rt_usb_adk_start(ifinst)) != RT_EOK) + if((ret = rt_usbh_adk_start(intf)) != RT_EOK) { - rt_kprintf("rt_usb_adk_start failed\n"); + rt_kprintf("rt_usbh_adk_start failed\n"); return ret; } return RT_EOK; } - adkinst = rt_malloc(sizeof(struct uadkinst)); - RT_ASSERT(adkinst != RT_NULL); + adk = rt_malloc(sizeof(struct uadkinst)); + RT_ASSERT(adk != RT_NULL); /* initilize the data structure */ - rt_memset(adkinst, 0, sizeof(struct uadkinst)); - ifinst->user_data = (void*)adkinst; + rt_memset(adk, 0, sizeof(struct uadkinst)); + intf->user_data = (void*)adk; - for(i=0; iintf_desc->bNumEndpoints; i++) + for(i=0; iintf_desc->bNumEndpoints; i++) { uep_desc_t ep_desc; /* get endpoint descriptor from interface descriptor */ - rt_usb_get_endpoint_descriptor(ifinst->intf_desc, i, &ep_desc); + rt_usbh_get_endpoint_descriptor(intf->intf_desc, i, &ep_desc); if(ep_desc == RT_NULL) { rt_kprintf("rt_usb_get_endpoint_descriptor error\n"); @@ -316,41 +316,41 @@ static rt_err_t rt_usb_adk_run(void* arg) if(ep_desc->bEndpointAddress & USB_DIR_IN) { /* allocate an in pipe for the adk instance */ - ret = rt_usb_hcd_alloc_pipe(ifinst->uinst->hcd, &adkinst->pipe_in, - ifinst, ep_desc, RT_NULL); + ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &adk->pipe_in, + intf, ep_desc, RT_NULL); if(ret != RT_EOK) return ret; } else { /* allocate an output pipe for the adk instance */ - ret = rt_usb_hcd_alloc_pipe(ifinst->uinst->hcd, &adkinst->pipe_out, - ifinst, ep_desc, RT_NULL); + ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &adk->pipe_out, + intf, ep_desc, RT_NULL); if(ret != RT_EOK) return ret; } } /* check pipes infomation */ - if(adkinst->pipe_in == RT_NULL || adkinst->pipe_out == RT_NULL) + if(adk->pipe_in == RT_NULL || adk->pipe_out == RT_NULL) { rt_kprintf("pipe error, unsupported device\n"); return -RT_ERROR; } /* set configuration */ - ret = rt_usb_set_configure(ifinst->uinst, 1); + ret = rt_usbh_set_configure(intf->device, 1); if(ret != RT_EOK) return ret; /* register adk device */ - adkinst->device.type = RT_Device_Class_Char; - adkinst->device.init = RT_NULL; - adkinst->device.open = RT_NULL; - adkinst->device.close = RT_NULL; - adkinst->device.read = rt_usb_adk_read; - adkinst->device.write = rt_usb_adk_write; - adkinst->device.control = RT_NULL; - adkinst->device.user_data = (void*)ifinst; + adk->device.type = RT_Device_Class_Char; + adk->device.init = RT_NULL; + adk->device.open = RT_NULL; + adk->device.close = RT_NULL; + adk->device.read = rt_usbh_adk_read; + adk->device.write = rt_usbh_adk_write; + adk->device.control = RT_NULL; + adk->device.user_data = (void*)intf; - rt_device_register(&adkinst->device, "adkdev", RT_DEVICE_FLAG_RDWR); + rt_device_register(&adk->device, "adkdev", RT_DEVICE_FLAG_RDWR); return RT_EOK; } @@ -363,36 +363,39 @@ static rt_err_t rt_usb_adk_run(void* arg) * * @return the error code, RT_EOK on successfully. */ -static rt_err_t rt_usb_adk_stop(void* arg) +static rt_err_t rt_usbh_adk_disable(void* arg) { - uadkinst_t adkinst; - uifinst_t ifinst = (uifinst_t)arg; + uadk_t adk; + struct uintf* intf = (struct uintf*)arg; - RT_ASSERT(ifinst != RT_NULL); + RT_ASSERT(intf != RT_NULL); - RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usb_adk_stop\n")); + RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_adk_stop\n")); - adkinst = (uadkinst_t)ifinst->user_data; - if(adkinst == RT_NULL) + adk = (uadk_t)intf->user_data; + if(adk == RT_NULL) { - rt_free(ifinst); + rt_free(intf); return RT_EOK; } - if(adkinst->pipe_in != RT_NULL) - rt_usb_hcd_free_pipe(ifinst->uinst->hcd, adkinst->pipe_in); + if(adk->pipe_in != RT_NULL) + rt_usb_hcd_free_pipe(intf->device->hcd, adk->pipe_in); - if(adkinst->pipe_out != RT_NULL) - rt_usb_hcd_free_pipe(ifinst->uinst->hcd, adkinst->pipe_out); + if(adk->pipe_out != RT_NULL) + rt_usb_hcd_free_pipe(intf->device->hcd, adk->pipe_out); /* unregister adk device */ - rt_device_unregister(&adkinst->device); + rt_device_unregister(&adk->device); /* free adk instance */ - if(adkinst != RT_NULL) rt_free(adkinst); + if(adk != RT_NULL) + { + rt_free(adk); + } /* free interface instance */ - rt_free(ifinst); + rt_free(intf); return RT_EOK; } @@ -403,12 +406,12 @@ static rt_err_t rt_usb_adk_stop(void* arg) * * @return the error code, RT_EOK on successfully. */ -ucd_t rt_usb_class_driver_adk(void) +ucd_t rt_usbh_class_driver_adk(void) { adk_driver.class_code = USB_CLASS_ADK; - adk_driver.run = rt_usb_adk_run; - adk_driver.stop = rt_usb_adk_stop; + adk_driver.enable = rt_usbh_adk_enable; + adk_driver.disable = rt_usbh_adk_disable; return &adk_driver; } diff --git a/components/drivers/usb/usbhost/class/adk.h b/components/drivers/usb/usbhost/class/adk.h index 95140ceb7d..f08bea5f59 100644 --- a/components/drivers/usb/usbhost/class/adk.h +++ b/components/drivers/usb/usbhost/class/adk.h @@ -34,7 +34,7 @@ struct uadkinst struct rt_device device; }; -typedef struct uadkinst* uadkinst_t; +typedef struct uadkinst* uadk_t; #define USB_ACCESSORY_VENDOR_ID 0x18D1 #define USB_ACCESSORY_PRODUCT_ID 0x2D00 diff --git a/components/drivers/usb/usbhost/core/core.c b/components/drivers/usb/usbhost/core/core.c index e7da42f7e4..af53370f4b 100644 --- a/components/drivers/usb/usbhost/core/core.c +++ b/components/drivers/usb/usbhost/core/core.c @@ -25,7 +25,7 @@ #include #include -static struct uinstance uinst[USB_MAX_DEVICE]; +static struct uinstance dev[USB_MAX_DEVICE]; /** * This function will allocate an usb device instance from system. @@ -35,7 +35,7 @@ static struct uinstance uinst[USB_MAX_DEVICE]; * * @return the allocate instance on successful, or RT_NULL on failure. */ -uinst_t rt_usb_alloc_instance(void) +uinst_t rt_usbh_alloc_instance(void) { int i; @@ -45,19 +45,19 @@ uinst_t rt_usb_alloc_instance(void) for(i=0; idev_desc; + dev_desc = &device->dev_desc; RT_DEBUG_LOG(RT_DEBUG_USB, ("start enumnation\n")); /* get device descriptor head */ - ret = rt_usb_get_descriptor(uinst, USB_DESC_TYPE_DEVICE, (void*)dev_desc, 8); + ret = rt_usbh_get_descriptor(device, USB_DESC_TYPE_DEVICE, (void*)dev_desc, 8); if(ret != RT_EOK) { rt_kprintf("get device descriptor head failed\n"); @@ -100,7 +100,7 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst) } /* set device address */ - ret = rt_usb_set_address(uinst); + ret = rt_usbh_set_address(device); if(ret != RT_EOK) { rt_kprintf("set device address failed\n"); @@ -108,14 +108,14 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst) } /* set device max packet size */ - uinst->max_packet_size = uinst->dev_desc.bMaxPacketSize0; + device->max_packet_size = device->dev_desc.bMaxPacketSize0; RT_DEBUG_LOG(RT_DEBUG_USB, ("get device descriptor length %d\n", dev_desc->bLength)); /* get full device descriptor again */ - ret = rt_usb_get_descriptor - (uinst, USB_DESC_TYPE_DEVICE, (void*)dev_desc, dev_desc->bLength); + ret = rt_usbh_get_descriptor + (device, USB_DESC_TYPE_DEVICE, (void*)dev_desc, dev_desc->bLength); if(ret != RT_EOK) { rt_kprintf("get full device descriptor failed\n"); @@ -126,8 +126,7 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst) RT_DEBUG_LOG(RT_DEBUG_USB, ("Product ID 0x%x\n", dev_desc->idProduct)); /* get configuration descriptor head */ - ret = rt_usb_get_descriptor(uinst, USB_DESC_TYPE_CONFIGURATION, &cfg_desc, - sizeof(struct uconfig_descriptor)); + ret = rt_usbh_get_descriptor(device, USB_DESC_TYPE_CONFIGURATION, &cfg_desc, 18); if(ret != RT_EOK) { rt_kprintf("get configuration descriptor head failed\n"); @@ -135,12 +134,12 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst) } /* alloc memory for configuration descriptor */ - uinst->cfg_desc = (ucfg_desc_t)rt_malloc(cfg_desc.wTotalLength); - rt_memset(uinst->cfg_desc, 0, cfg_desc.wTotalLength); + device->cfg_desc = (ucfg_desc_t)rt_malloc(cfg_desc.wTotalLength); + rt_memset(device->cfg_desc, 0, cfg_desc.wTotalLength); /* get full configuration descriptor */ - ret = rt_usb_get_descriptor(uinst, USB_DESC_TYPE_CONFIGURATION, - uinst->cfg_desc, cfg_desc.wTotalLength); + ret = rt_usbh_get_descriptor(device, USB_DESC_TYPE_CONFIGURATION, + device->cfg_desc, cfg_desc.wTotalLength); if(ret != RT_EOK) { rt_kprintf("get full configuration descriptor failed\n"); @@ -148,13 +147,13 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst) } /* set configuration */ - ret = rt_usb_set_configure(uinst, 1); + ret = rt_usbh_set_configure(device, 1); if(ret != RT_EOK) return ret; - for(i=0; icfg_desc->bNumInterfaces; i++) + for(i=0; icfg_desc->bNumInterfaces; i++) { /* get interface descriptor through configuration descriptor */ - ret = rt_usb_get_interface_descriptor(uinst->cfg_desc, i, &intf_desc); + ret = rt_usbh_get_interface_descriptor(device->cfg_desc, i, &intf_desc); if(ret != RT_EOK) { rt_kprintf("rt_usb_get_interface_descriptor error\n"); @@ -166,22 +165,22 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst) intf_desc->bInterfaceSubClass)); /* find driver by class code found in interface descriptor */ - drv = rt_usb_class_driver_find(intf_desc->bInterfaceClass, + drv = rt_usbh_class_driver_find(intf_desc->bInterfaceClass, intf_desc->bInterfaceSubClass); if(drv != RT_NULL) { - /* allocate memory for interface uinst */ - uinst->ifinst[i] = - (uifinst_t)rt_malloc(sizeof(struct uifinst)); + /* allocate memory for interface device */ + device->intf[i] = + (struct uintf*)rt_malloc(sizeof(struct uintf)); - uinst->ifinst[i]->drv = drv; - uinst->ifinst[i]->uinst = uinst; - uinst->ifinst[i]->intf_desc = intf_desc; - uinst->ifinst[i]->user_data = RT_NULL; + device->intf[i]->drv = drv; + device->intf[i]->device = device; + device->intf[i]->intf_desc = intf_desc; + device->intf[i]->user_data = RT_NULL; /* open usb class driver */ - ret = rt_usb_class_driver_run(drv, (void*)uinst->ifinst[i]); + ret = rt_usbh_class_driver_enable(drv, (void*)device->intf[i]); if(ret != RT_EOK) { rt_kprintf("interface %d run class driver error\n", i); @@ -201,35 +200,35 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst) * This function will detach an usb device instance from its host controller, * and release all resource. * - * @param uinst the usb device instance. + * @param device the usb device instance. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_detach_instance(uinst_t uinst) +rt_err_t rt_usbh_detach_instance(uinst_t device) { int i = 0; - if(uinst == RT_NULL) + if(device == RT_NULL) { rt_kprintf("no usb instance to detach\n"); return -RT_ERROR; } /* free configration descriptor */ - if(uinst->cfg_desc) rt_free(uinst->cfg_desc); + if(device->cfg_desc) rt_free(device->cfg_desc); - for(i=0; icfg_desc->bNumInterfaces; i++) + for(i=0; icfg_desc->bNumInterfaces; i++) { - if(uinst->ifinst[i] == RT_NULL) continue; - if(uinst->ifinst[i]->drv == RT_NULL) continue; + if(device->intf[i] == RT_NULL) continue; + if(device->intf[i]->drv == RT_NULL) continue; - RT_ASSERT(uinst->ifinst[i]->uinst == uinst); + RT_ASSERT(device->intf[i]->device == device); RT_DEBUG_LOG(RT_DEBUG_USB, ("free interface instance %d\n", i)); - rt_usb_class_driver_stop(uinst->ifinst[i]->drv, (void*)uinst->ifinst[i]); + rt_usbh_class_driver_disable(device->intf[i]->drv, (void*)device->intf[i]); } - rt_memset(uinst, 0, sizeof(struct uinstance)); + rt_memset(device, 0, sizeof(struct uinstance)); return RT_EOK; } @@ -237,20 +236,20 @@ rt_err_t rt_usb_detach_instance(uinst_t uinst) /** * This function will do USB_REQ_GET_DESCRIPTO' request for the usb device instance, * - * @param uinst the usb device instance. + * @param device the usb device instance. * @param type the type of descriptor request. * @param buffer the data buffer to save requested data * @param nbytes the size of buffer * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_get_descriptor(uinst_t uinst, rt_uint8_t type, void* buffer, +rt_err_t rt_usbh_get_descriptor(uinst_t device, rt_uint8_t type, void* buffer, int nbytes) { struct ureqest setup; int timeout = 100; - RT_ASSERT(uinst != RT_NULL); + RT_ASSERT(device != RT_NULL); setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_STANDARD | USB_REQ_TYPE_DEVICE; @@ -259,7 +258,7 @@ rt_err_t rt_usb_get_descriptor(uinst_t uinst, rt_uint8_t type, void* buffer, setup.length = nbytes; setup.value = type << 8; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, buffer, nbytes, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, nbytes, timeout) != nbytes) return -RT_EIO; else return RT_EOK; } @@ -267,16 +266,16 @@ rt_err_t rt_usb_get_descriptor(uinst_t uinst, rt_uint8_t type, void* buffer, /** * This function will set an address to the usb device. * - * @param uinst the usb device instance. + * @param device the usb device instance. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_set_address(uinst_t uinst) +rt_err_t rt_usbh_set_address(uinst_t device) { struct ureqest setup; int timeout = 100; - RT_ASSERT(uinst != RT_NULL); + RT_ASSERT(device != RT_NULL); RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usb_set_address\n")); @@ -285,14 +284,14 @@ rt_err_t rt_usb_set_address(uinst_t uinst) setup.request = USB_REQ_SET_ADDRESS; setup.index = 0; setup.length = 0; - setup.value = uinst->index; + setup.value = device->index; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, RT_NULL, 0, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, timeout) != 0) return -RT_EIO; rt_thread_delay(50); - uinst->address = uinst->index; + device->address = device->index; return RT_EOK; } @@ -300,18 +299,18 @@ rt_err_t rt_usb_set_address(uinst_t uinst) /** * This function will set a configuration to the usb device. * - * @param uinst the usb device instance. + * @param device the usb device instance. * @param config the configuration number. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_set_configure(uinst_t uinst, int config) +rt_err_t rt_usbh_set_configure(uinst_t device, int config) { struct ureqest setup; int timeout = 100; /* check parameter */ - RT_ASSERT(uinst != RT_NULL); + RT_ASSERT(device != RT_NULL); setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | USB_REQ_TYPE_DEVICE; @@ -320,7 +319,7 @@ rt_err_t rt_usb_set_configure(uinst_t uinst, int config) setup.length = 0; setup.value = config; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, RT_NULL, 0, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, timeout) != 0) return -RT_EIO; return RT_EOK; @@ -329,18 +328,18 @@ rt_err_t rt_usb_set_configure(uinst_t uinst, int config) /** * This function will set an interface to the usb device. * - * @param uinst the usb device instance. + * @param device the usb device instance. * @param intf the interface number. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_set_interface(uinst_t uinst, int intf) +rt_err_t rt_usbh_set_interface(uinst_t device, int intf) { struct ureqest setup; int timeout = 100; /* check parameter */ - RT_ASSERT(uinst != RT_NULL); + RT_ASSERT(device != RT_NULL); setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | USB_REQ_TYPE_INTERFACE; @@ -349,7 +348,7 @@ rt_err_t rt_usb_set_interface(uinst_t uinst, int intf) setup.length = 0; setup.value = intf; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, RT_NULL, 0, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, timeout) != 0) return -RT_EIO; return RT_EOK; @@ -358,18 +357,18 @@ rt_err_t rt_usb_set_interface(uinst_t uinst, int intf) /** * This function will clear feature for the endpoint of the usb device. * - * @param uinst the usb device instance. + * @param device the usb device instance. * @param endpoint the endpoint number of the usb device. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_clear_feature(uinst_t uinst, int endpoint, int feature) +rt_err_t rt_usbh_clear_feature(uinst_t device, int endpoint, int feature) { struct ureqest setup; int timeout = 100; /* check parameter */ - RT_ASSERT(uinst != RT_NULL); + RT_ASSERT(device != RT_NULL); setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD | USB_REQ_TYPE_ENDPOINT; @@ -378,7 +377,7 @@ rt_err_t rt_usb_clear_feature(uinst_t uinst, int endpoint, int feature) setup.length = 0; setup.value = feature; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, RT_NULL, 0, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, timeout) != 0) return -RT_EIO; return RT_EOK; @@ -393,7 +392,7 @@ rt_err_t rt_usb_clear_feature(uinst_t uinst, int endpoint, int feature) * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_get_interface_descriptor(ucfg_desc_t cfg_desc, int num, +rt_err_t rt_usbh_get_interface_descriptor(ucfg_desc_t cfg_desc, int num, uintf_desc_t* intf_desc) { rt_uint32_t ptr, depth = 0; @@ -438,7 +437,7 @@ rt_err_t rt_usb_get_interface_descriptor(ucfg_desc_t cfg_desc, int num, * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_get_endpoint_descriptor(uintf_desc_t intf_desc, int num, +rt_err_t rt_usbh_get_endpoint_descriptor(uintf_desc_t intf_desc, int num, uep_desc_t* ep_desc) { int count = 0, depth = 0; diff --git a/components/drivers/usb/usbhost/core/driver.c b/components/drivers/usb/usbhost/core/driver.c index 52457d7cfc..165e343093 100644 --- a/components/drivers/usb/usbhost/core/driver.c +++ b/components/drivers/usb/usbhost/core/driver.c @@ -34,7 +34,7 @@ static rt_list_t _driver_list; * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_class_driver_init(void) +rt_err_t rt_usbh_class_driver_init(void) { rt_list_init(&_driver_list); @@ -49,7 +49,7 @@ rt_err_t rt_usb_class_driver_init(void) * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_class_driver_register(ucd_t drv) +rt_err_t rt_usbh_class_driver_register(ucd_t drv) { if (drv == RT_NULL) return -RT_ERROR; @@ -66,7 +66,7 @@ rt_err_t rt_usb_class_driver_register(ucd_t drv) * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_class_driver_unregister(ucd_t drv) +rt_err_t rt_usbh_class_driver_unregister(ucd_t drv) { RT_ASSERT(drv != RT_NULL); @@ -84,12 +84,12 @@ rt_err_t rt_usb_class_driver_unregister(ucd_t drv) * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_class_driver_run(ucd_t drv, void* args) +rt_err_t rt_usbh_class_driver_enable(ucd_t drv, void* args) { RT_ASSERT(drv != RT_NULL); - if(drv->run != RT_NULL) - drv->run(args); + if(drv->enable != RT_NULL) + drv->enable(args); return RT_EOK; } @@ -102,12 +102,12 @@ rt_err_t rt_usb_class_driver_run(ucd_t drv, void* args) * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_class_driver_stop(ucd_t drv, void* args) +rt_err_t rt_usbh_class_driver_disable(ucd_t drv, void* args) { RT_ASSERT(drv != RT_NULL); - if(drv->stop != RT_NULL) - drv->stop(args); + if(drv->disable != RT_NULL) + drv->disable(args); return RT_EOK; } @@ -121,7 +121,7 @@ rt_err_t rt_usb_class_driver_stop(ucd_t drv, void* args) * * @return the registered usb class driver on successful, or RT_NULL on failure. */ -ucd_t rt_usb_class_driver_find(int class_code, int subclass_code) +ucd_t rt_usbh_class_driver_find(int class_code, int subclass_code) { struct rt_list_node *node; diff --git a/components/drivers/usb/usbhost/core/hub.c b/components/drivers/usb/usbhost/core/hub.c index c907defcf6..a71aa4f89c 100644 --- a/components/drivers/usb/usbhost/core/hub.c +++ b/components/drivers/usb/usbhost/core/hub.c @@ -34,20 +34,20 @@ static struct uclass_driver hub_driver; * This function will do USB_REQ_GET_DESCRIPTOR request for the device instance * to get usb hub descriptor. * - * @param ifinst the interface instance. + * @param intf the interface instance. * @buffer the data buffer to save usb hub descriptor. * @param nbytes the size of buffer * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_hub_get_descriptor(uinst_t uinst, rt_uint8_t *buffer, +rt_err_t rt_usbh_hub_get_descriptor(struct uinstance* device, rt_uint8_t *buffer, rt_size_t nbytes) { struct ureqest setup; int timeout = 100; /* parameter check */ - RT_ASSERT(uinst != RT_NULL); + RT_ASSERT(device != RT_NULL); setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_DEVICE; @@ -56,7 +56,7 @@ rt_err_t rt_usb_hub_get_descriptor(uinst_t uinst, rt_uint8_t *buffer, setup.length = nbytes; setup.value = USB_DESC_TYPE_HUB << 8; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, buffer, nbytes, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, nbytes, timeout) == nbytes) return RT_EOK; else return -RT_FALSE; } @@ -65,19 +65,19 @@ rt_err_t rt_usb_hub_get_descriptor(uinst_t uinst, rt_uint8_t *buffer, * This function will do USB_REQ_GET_STATUS request for the device instance * to get usb hub status. * - * @param ifinst the interface instance. + * @param intf the interface instance. * @buffer the data buffer to save usb hub status. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_hub_get_status(uinst_t uinst, rt_uint8_t* buffer) +rt_err_t rt_usbh_hub_get_status(struct uinstance* device, rt_uint8_t* buffer) { struct ureqest setup; int timeout = 100; int length = 4; /* parameter check */ - RT_ASSERT(uinst != RT_NULL); + RT_ASSERT(device != RT_NULL); setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_TYPE_DEVICE; @@ -86,7 +86,7 @@ rt_err_t rt_usb_hub_get_status(uinst_t uinst, rt_uint8_t* buffer) setup.length = length; setup.value = 0; - if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, buffer, length, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, length, timeout) == length) return RT_EOK; else return -RT_FALSE; } @@ -95,13 +95,13 @@ rt_err_t rt_usb_hub_get_status(uinst_t uinst, rt_uint8_t* buffer) * This function will do USB_REQ_GET_STATUS request for the device instance * to get hub port status. * - * @param ifinst the interface instance. + * @param intf the interface instance. * @port the hub port to get status. * @buffer the data buffer to save usb hub status. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_hub_get_port_status(uhubinst_t uhub, rt_uint16_t port, +rt_err_t rt_usbh_hub_get_port_status(uhub_t hub, rt_uint16_t port, rt_uint8_t* buffer) { struct ureqest setup; @@ -109,12 +109,12 @@ rt_err_t rt_usb_hub_get_port_status(uhubinst_t uhub, rt_uint16_t port, int length = 4; /* parameter check */ - RT_ASSERT(uhub != RT_NULL); + RT_ASSERT(hub != RT_NULL); /* get roothub port status */ - if(uhub->is_roothub) + if(hub->is_roothub) { - rt_usb_hcd_hub_control(uhub->hcd, port, RH_GET_PORT_STATUS, + rt_usb_hcd_hub_control(hub->hcd, port, RH_GET_PORT_STATUS, (void*)buffer); return RT_EOK; } @@ -126,7 +126,7 @@ rt_err_t rt_usb_hub_get_port_status(uhubinst_t uhub, rt_uint16_t port, setup.length = 4; setup.value = 0; - if(rt_usb_hcd_control_xfer(uhub->hcd, uhub->self, &setup, buffer, + if(rt_usb_hcd_control_xfer(hub->hcd, hub->self, &setup, buffer, length, timeout) == timeout) return RT_EOK; else return -RT_FALSE; } @@ -135,25 +135,25 @@ rt_err_t rt_usb_hub_get_port_status(uhubinst_t uhub, rt_uint16_t port, * This function will do USB_REQ_CLEAR_FEATURE request for the device instance * to clear feature of the hub port. * - * @param ifinst the interface instance. + * @param intf the interface instance. * @port the hub port. * @feature feature to be cleared. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_hub_clear_port_feature(uhubinst_t uhub, rt_uint16_t port, +rt_err_t rt_usbh_hub_clear_port_feature(uhub_t hub, rt_uint16_t port, rt_uint16_t feature) { struct ureqest setup; int timeout = 100; /* parameter check */ - RT_ASSERT(uhub != RT_NULL); + RT_ASSERT(hub != RT_NULL); /* clear roothub feature */ - if(uhub->is_roothub) + if(hub->is_roothub) { - rt_usb_hcd_hub_control(uhub->hcd, port, RH_CLEAR_PORT_FEATURE, + rt_usb_hcd_hub_control(hub->hcd, port, RH_CLEAR_PORT_FEATURE, (void*)feature); return RT_EOK; } @@ -165,7 +165,7 @@ rt_err_t rt_usb_hub_clear_port_feature(uhubinst_t uhub, rt_uint16_t port, setup.length = 0; setup.value = feature; - if(rt_usb_hcd_control_xfer(uhub->hcd, uhub->self, &setup, RT_NULL, 0, + if(rt_usb_hcd_control_xfer(hub->hcd, hub->self, &setup, RT_NULL, 0, timeout) == 0) return RT_EOK; else return -RT_FALSE; } @@ -174,25 +174,25 @@ rt_err_t rt_usb_hub_clear_port_feature(uhubinst_t uhub, rt_uint16_t port, * This function will do USB_REQ_SET_FEATURE request for the device instance * to set feature of the hub port. * - * @param ifinst the interface instance. + * @param intf the interface instance. * @port the hub port. * @feature feature to be set. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_hub_set_port_feature(uhubinst_t uhub, rt_uint16_t port, +rt_err_t rt_usbh_hub_set_port_feature(uhub_t hub, rt_uint16_t port, rt_uint16_t feature) { struct ureqest setup; int timeout = 100; /* parameter check */ - RT_ASSERT(uhub != RT_NULL); + RT_ASSERT(hub != RT_NULL); /* clear roothub feature */ - if(uhub->is_roothub) + if(hub->is_roothub) { - rt_usb_hcd_hub_control(uhub->hcd, port, RH_SET_PORT_FEATURE, + rt_usb_hcd_hub_control(hub->hcd, port, RH_SET_PORT_FEATURE, (void*)feature); return RT_EOK; } @@ -204,7 +204,7 @@ rt_err_t rt_usb_hub_set_port_feature(uhubinst_t uhub, rt_uint16_t port, setup.length = 0; setup.value = feature; - if(rt_usb_hcd_control_xfer(uhub->hcd, uhub->self, &setup, RT_NULL, 0, + if(rt_usb_hcd_control_xfer(hub->hcd, hub->self, &setup, RT_NULL, 0, timeout) == 0) return RT_EOK; else return -RT_FALSE; } @@ -212,33 +212,33 @@ rt_err_t rt_usb_hub_set_port_feature(uhubinst_t uhub, rt_uint16_t port, /** * This function will rest hub port, it is invoked when sub device attached to the hub port. * - * @param ifinst the interface instance. + * @param intf the interface instance. * @param port the hub port. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_hub_reset_port(uhubinst_t uhub, rt_uint16_t port) +rt_err_t rt_usbh_hub_reset_port(uhub_t hub, rt_uint16_t port) { rt_err_t ret; rt_uint32_t pstatus; /* parameter check */ - RT_ASSERT(uhub != RT_NULL); + RT_ASSERT(hub != RT_NULL); rt_thread_delay(50); /* reset hub port */ - ret = rt_usb_hub_set_port_feature(uhub, port, PORT_FEAT_RESET); + ret = rt_usbh_hub_set_port_feature(hub, port, PORT_FEAT_RESET); if(ret != RT_EOK) return ret; while(1) { - ret = rt_usb_hub_get_port_status(uhub, port, (rt_uint8_t*)&pstatus); + ret = rt_usbh_hub_get_port_status(hub, port, (rt_uint8_t*)&pstatus); if(!(pstatus & PORT_PRS)) break; } /* clear port reset feature */ - ret = rt_usb_hub_clear_port_feature(uhub, port, PORT_FEAT_C_RESET); + ret = rt_usbh_hub_clear_port_feature(hub, port, PORT_FEAT_C_RESET); if(ret != RT_EOK) return ret; rt_thread_delay(50); @@ -249,12 +249,12 @@ rt_err_t rt_usb_hub_reset_port(uhubinst_t uhub, rt_uint16_t port) /** * This function will do debouce, it is invoked when sub device attached to the hub port. * - * @param uinst the usb instance. + * @param device the usb instance. * @param port the hub port. * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_hub_port_debounce(uhubinst_t uhub, rt_uint16_t port) +rt_err_t rt_usbh_hub_port_debounce(uhub_t hub, rt_uint16_t port) { rt_err_t ret; int i = 0, times = 20; @@ -262,11 +262,11 @@ rt_err_t rt_usb_hub_port_debounce(uhubinst_t uhub, rt_uint16_t port) rt_bool_t connect = RT_TRUE; /* parameter check */ - RT_ASSERT(uhub != RT_NULL); + RT_ASSERT(hub != RT_NULL); for(i=0; inum_ports; i++) + for (i = 0; i < hub->num_ports; i++) { rt_err_t ret; - uinst_t uinst; + struct uinstance* device; rt_uint32_t pstatus = 0; reconnect = RT_FALSE; /* get hub port status */ - ret = rt_usb_hub_get_port_status(uhub, i + 1, (rt_uint8_t*)&pstatus); + ret = rt_usbh_hub_get_port_status(hub, i + 1, (rt_uint8_t*)&pstatus); if(ret != RT_EOK) continue; - RT_DEBUG_LOG(RT_DEBUG_USB, ("port_status 0x%x\n", pstatus)); + RT_DEBUG_LOG(RT_DEBUG_USB, ("port %d status 0x%x\n", i, pstatus)); /* check port status change */ if ((pstatus & PORT_CCSC)) { /* clear port status change feature */ - rt_usb_hub_clear_port_feature(uhub, i + 1, PORT_FEAT_C_CONNECTION); + rt_usbh_hub_clear_port_feature(hub, i + 1, PORT_FEAT_C_CONNECTION); reconnect = RT_TRUE; } if(pstatus & PORT_PESC) { - rt_usb_hub_clear_port_feature(uhub, i + 1, PORT_FEAT_C_ENABLE); + rt_usbh_hub_clear_port_feature(hub, i + 1, PORT_FEAT_C_ENABLE); reconnect = RT_TRUE; } if(reconnect) { - if(uhub->child[i]->status != UINST_STATUS_IDLE) - rt_usb_detach_instance(uhub->child[i]); + if(hub->child[i]->status != DEV_STATUS_IDLE) + rt_usbh_detach_instance(hub->child[i]); - ret = rt_usb_hub_port_debounce(uhub, i + 1); + ret = rt_usbh_hub_port_debounce(hub, i + 1); if(ret != RT_EOK) continue; /* allocate an usb instance for new connected device */ - uinst = rt_usb_alloc_instance(); - if(uinst == RT_NULL) break; + device = rt_usbh_alloc_instance(); + if(device == RT_NULL) break; /* set usb device speed */ - uinst->speed = (pstatus & PORT_LSDA) ? 1 : 0; - uinst->parent = uhub; - uinst->hcd = uhub->hcd; - uhub->child[i] = uinst; + device->speed = (pstatus & PORT_LSDA) ? 1 : 0; + device->parent = hub; + device->hcd = hub->hcd; + hub->child[i] = device; /* reset usb roothub port */ - rt_usb_hub_reset_port(uhub, i + 1); + rt_usbh_hub_reset_port(hub, i + 1); /* attatch the usb instance to the hcd */ - rt_usb_attatch_instance(uinst); + rt_usbh_attatch_instance(device); } } @@ -363,18 +363,18 @@ static rt_err_t rt_usb_hub_port_change(uhubinst_t uhub) * * @return none. */ -static void rt_usb_hub_irq(void* context) +static void rt_usbh_hub_irq(void* context) { upipe_t pipe; - uifinst_t ifinst; - uhubinst_t uhub; + struct uintf* intf; + uhub_t hub; int timeout = 100; RT_ASSERT(context != RT_NULL); pipe = (upipe_t)context; - ifinst = pipe->ifinst; - uhub = (uhubinst_t)ifinst->user_data; + intf = pipe->intf; + hub = (uhub_t)intf->user_data; if(pipe->status != UPIPE_STATUS_OK) { @@ -382,14 +382,14 @@ static void rt_usb_hub_irq(void* context) return; } - rt_usb_hub_port_change(uhub); + rt_usbh_hub_port_change(hub); rt_kprintf("hub int xfer...\n"); /* parameter check */ - RT_ASSERT(pipe->ifinst->uinst->hcd != RT_NULL); + RT_ASSERT(pipe->intf->device->hcd != RT_NULL); - rt_usb_hcd_int_xfer(ifinst->uinst->hcd, pipe, uhub->buffer, + rt_usb_hcd_int_xfer(intf->device->hcd, pipe, hub->buffer, pipe->ep.wMaxPacketSize, timeout); } @@ -401,33 +401,33 @@ static void rt_usb_hub_irq(void* context) * * @return the error code, RT_EOK on successfully. */ -static rt_err_t rt_usb_hub_run(void *arg) +static rt_err_t rt_usbh_hub_enable(void *arg) { int i = 0; rt_err_t ret = RT_EOK; uep_desc_t ep_desc; - uhubinst_t uhub; - uinst_t uinst; - uifinst_t ifinst = (uifinst_t)arg; + uhub_t hub; + struct uinstance* device; + struct uintf* intf = (struct uintf*)arg; int timeout = 300; /* paremeter check */ - RT_ASSERT(ifinst != RT_NULL); + RT_ASSERT(intf != RT_NULL); - RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usb_hub_run\n")); + RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_hub_run\n")); /* get usb device instance */ - uinst = ifinst->uinst; + device = intf->device; /* create a hub instance */ - uhub = rt_malloc(sizeof(struct uhubinst)); - rt_memset(uhub, 0, sizeof(struct uhubinst)); + hub = rt_malloc(sizeof(struct uhub)); + rt_memset(hub, 0, sizeof(struct uhub)); /* make interface instance's user data point to hub instance */ - ifinst->user_data = (void*)uhub; + intf->user_data = (void*)hub; /* get hub descriptor head */ - ret = rt_usb_hub_get_descriptor(uinst, (rt_uint8_t*)&uhub->hub_desc, 8); + ret = rt_usbh_hub_get_descriptor(device, (rt_uint8_t*)&hub->hub_desc, 8); if(ret != RT_EOK) { rt_kprintf("get hub descriptor failed\n"); @@ -435,8 +435,8 @@ static rt_err_t rt_usb_hub_run(void *arg) } /* get full hub descriptor */ - ret = rt_usb_hub_get_descriptor(uinst, (rt_uint8_t*)&uhub->hub_desc, - uhub->hub_desc.length); + ret = rt_usbh_hub_get_descriptor(device, (rt_uint8_t*)&hub->hub_desc, + hub->hub_desc.length); if(ret != RT_EOK) { rt_kprintf("get hub descriptor again failed\n"); @@ -444,23 +444,23 @@ static rt_err_t rt_usb_hub_run(void *arg) } /* get hub ports number */ - uhub->num_ports = uhub->hub_desc.num_ports; - uhub->hcd = uinst->hcd; - uhub->self = uinst; + hub->num_ports = hub->hub_desc.num_ports; + hub->hcd = device->hcd; + hub->self = device; /* reset all hub ports */ - for (i = 0; i < uhub->num_ports; i++) + for (i = 0; i < hub->num_ports; i++) { - rt_usb_hub_set_port_feature(uhub, i + 1, PORT_FEAT_POWER); - rt_thread_delay(uhub->hub_desc.pwron_to_good + rt_usbh_hub_set_port_feature(hub, i + 1, PORT_FEAT_POWER); + rt_thread_delay(hub->hub_desc.pwron_to_good * 2 * RT_TICK_PER_SECOND / 1000 ); } - if(ifinst->intf_desc->bNumEndpoints != 1) + if(intf->intf_desc->bNumEndpoints != 1) return -RT_ERROR; /* get endpoint descriptor from interface descriptor */ - rt_usb_get_endpoint_descriptor(ifinst->intf_desc, 0, &ep_desc); + rt_usbh_get_endpoint_descriptor(intf->intf_desc, 0, &ep_desc); if(ep_desc == RT_NULL) { rt_kprintf("rt_usb_get_endpoint_descriptor error\n"); @@ -474,17 +474,17 @@ static rt_err_t rt_usb_hub_run(void *arg) if(ep_desc->bEndpointAddress & USB_DIR_IN) { /* allocate a pipe according to the endpoint type */ - rt_usb_hcd_alloc_pipe(uinst->hcd, &uhub->pipe_in, ifinst, - ep_desc, rt_usb_hub_irq); + rt_usb_hcd_alloc_pipe(device->hcd, &hub->pipe_in, intf, + ep_desc, rt_usbh_hub_irq); } else return -RT_ERROR; } /* parameter check */ - RT_ASSERT(uinst->hcd != RT_NULL); + RT_ASSERT(device->hcd != RT_NULL); - rt_usb_hcd_int_xfer(uinst->hcd, uhub->pipe_in, uhub->buffer, - uhub->pipe_in->ep.wMaxPacketSize, timeout); + rt_usb_hcd_int_xfer(device->hcd, hub->pipe_in, hub->buffer, + hub->pipe_in->ep.wMaxPacketSize, timeout); return RT_EOK; } @@ -497,32 +497,32 @@ static rt_err_t rt_usb_hub_run(void *arg) * * @return the error code, RT_EOK on successfully. */ -static rt_err_t rt_usb_hub_stop(void* arg) +static rt_err_t rt_usbh_hub_disable(void* arg) { int i; - uhubinst_t uhub; - uinst_t uinst; - uifinst_t ifinst = (uifinst_t)arg; + uhub_t hub; + struct uinstance* device; + struct uintf* intf = (struct uintf*)arg; /* paremeter check */ - RT_ASSERT(ifinst != RT_NULL); + RT_ASSERT(intf != RT_NULL); - RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usb_hub_stop\n")); + RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_hub_stop\n")); - uinst = ifinst->uinst; - uhub = (uhubinst_t)ifinst->user_data; + device = intf->device; + hub = (uhub_t)intf->user_data; - if(uhub->pipe_in != RT_NULL) - rt_usb_hcd_free_pipe(uinst->hcd, uhub->pipe_in); + if(hub->pipe_in != RT_NULL) + rt_usb_hcd_free_pipe(device->hcd, hub->pipe_in); - for(i=0; inum_ports; i++) + for(i=0; inum_ports; i++) { - if(uhub->child[i] != RT_NULL) - rt_usb_detach_instance(uhub->child[i]); + if(hub->child[i] != RT_NULL) + rt_usbh_detach_instance(hub->child[i]); } - if(uhub != RT_NULL) rt_free(uhub); - if(ifinst != RT_NULL) rt_free(ifinst); + if(hub != RT_NULL) rt_free(hub); + if(intf != RT_NULL) rt_free(intf); return RT_EOK; } @@ -533,12 +533,12 @@ static rt_err_t rt_usb_hub_stop(void* arg) * * @return the error code, RT_EOK on successfully. */ -ucd_t rt_usb_class_driver_hub(void) +ucd_t rt_usbh_class_driver_hub(void) { hub_driver.class_code = USB_CLASS_HUB; - hub_driver.run = rt_usb_hub_run; - hub_driver.stop = rt_usb_hub_stop; + hub_driver.enable = rt_usbh_hub_enable; + hub_driver.disable = rt_usbh_hub_disable; return &hub_driver; } @@ -551,7 +551,7 @@ ucd_t rt_usb_class_driver_hub(void) * * @return none. */ -static void rt_usb_hub_thread_entry(void* parameter) +static void rt_usbh_hub_thread_entry(void* parameter) { while(1) { @@ -566,7 +566,7 @@ static void rt_usb_hub_thread_entry(void* parameter) switch (msg.type) { case USB_MSG_CONNECT_CHANGE: - rt_usb_hub_port_change(msg.content.uhub); + rt_usbh_hub_port_change(msg.content.hub); break; case USB_MSG_CALLBACK: /* invoke callback */ @@ -582,16 +582,15 @@ static void rt_usb_hub_thread_entry(void* parameter) * This function will post an message to the usb message queue, * * @param msg the message to be posted - * @param size the size of the message . * * @return the error code, RT_EOK on successfully. */ -rt_err_t rt_usb_post_event(struct uhost_msg* msg, rt_size_t size) +rt_err_t rt_usbh_event_signal(struct uhost_msg* msg) { RT_ASSERT(msg != RT_NULL); /* send message to usb message queue */ - rt_mq_send(usb_mq, (void*)msg, size); + rt_mq_send(usb_mq, (void*)msg, sizeof(struct uhost_msg)); return RT_EOK; } @@ -602,7 +601,7 @@ rt_err_t rt_usb_post_event(struct uhost_msg* msg, rt_size_t size) * @return none. * */ -void rt_usb_hub_thread(void) +void rt_usbh_hub_init(void) { rt_thread_t thread; @@ -610,7 +609,7 @@ void rt_usb_hub_thread(void) usb_mq = rt_mq_create("usbh", 32, 16, RT_IPC_FLAG_FIFO); /* create usb hub thread */ - thread = rt_thread_create("usbh", rt_usb_hub_thread_entry, RT_NULL, + thread = rt_thread_create("usbh", rt_usbh_hub_thread_entry, RT_NULL, USB_THREAD_STACK_SIZE, 8, 20); if(thread != RT_NULL) { diff --git a/components/drivers/usb/usbhost/core/usbhost.c b/components/drivers/usb/usbhost/core/usbhost.c index f40bd71528..dcfdf6a127 100644 --- a/components/drivers/usb/usbhost/core/usbhost.c +++ b/components/drivers/usb/usbhost/core/usbhost.c @@ -24,7 +24,9 @@ #include #include -#if defined(RT_USB_HID_KEYBOARD) || defined(RT_USB_HID_MOUSE) +#define USB_HOST_CONTROLLER_NAME "usbh" + +#if defined(RT_USBH_HID_KEYBOARD) || defined(RT_USBH_HID_MOUSE) #include #endif @@ -34,54 +36,64 @@ * * @return none. */ -int rt_usb_host_init(void) +rt_err_t rt_usb_host_init(void) { ucd_t drv; -#ifdef RT_USB_CLASS_HID + rt_device_t uhc; +#ifdef RT_USBH_HID uprotocal_t protocal; #endif - /* initialize usb hub thread */ - rt_usb_hub_thread(); + uhc = rt_device_find(USB_HOST_CONTROLLER_NAME); + if(uhc == RT_NULL) + { + rt_kprintf("can't find usb host controller %s\n", USB_HOST_CONTROLLER_NAME); + return -RT_ERROR; + } + + /* initialize usb hub */ + rt_usbh_hub_init(); /* initialize class driver */ - rt_usb_class_driver_init(); + rt_usbh_class_driver_init(); -#ifdef RT_USB_CLASS_MASS_STORAGE +#ifdef RT_USBH_MSTORAGE /* register mass storage class driver */ - drv = rt_usb_class_driver_storage(); - rt_usb_class_driver_register(drv); + drv = rt_usbh_class_driver_storage(); + rt_usbh_class_driver_register(drv); #endif -#ifdef RT_USB_CLASS_HID +#ifdef RT_USBH_HID /* register hid class driver */ - drv = rt_usb_class_driver_hid(); - rt_usb_class_driver_register(drv); + drv = rt_usbh_class_driver_hid(); + rt_usbh_class_driver_register(drv); -#ifdef RT_USB_HID_KEYBOARD +#ifdef RT_USBH_HID_KEYBOARD /* register hid keyboard protocal */ - protocal = rt_usb_hid_protocal_kbd(); - rt_usb_hid_protocal_register(protocal); + protocal = rt_usbh_hid_protocal_kbd(); + rt_usbh_hid_protocal_register(protocal); #endif -#ifdef RT_USB_HID_MOUSE +#ifdef RT_USBH_HID_MOUSE /* register hid mouse protocal */ - protocal = rt_usb_hid_protocal_mouse(); - rt_usb_hid_protocal_register(protocal); + protocal = rt_usbh_hid_protocal_mouse(); + rt_usbh_hid_protocal_register(protocal); #endif #endif -#ifdef RT_USB_CLASS_ADK +#ifdef RT_USBH_ADK /* register adk class driver */ - drv = rt_usb_class_driver_adk(); - rt_usb_class_driver_register(drv); + drv = rt_usbh_class_driver_adk(); + rt_usbh_class_driver_register(drv); #endif /* register hub class driver */ - drv = rt_usb_class_driver_hub(); - rt_usb_class_driver_register(drv); + drv = rt_usbh_class_driver_hub(); + rt_usbh_class_driver_register(drv); - return 0; + /* initialize usb host controller */ + rt_device_init(uhc); + + return RT_EOK; } -INIT_COMPONENT_EXPORT(rt_usb_host_init);