Skip to content

R
rt-thread

RT-Thread / rt-thread
9 个月 前同步成功

通知 752
Star 8909
Fork 4735
R
rt-thread

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 0fb9c54e 编写于 作者: qiuyiuestc's avatar qiuyiuestc
浏览文件
操作

1.replace API prefix usb* with usbh* in USB host stack to distinct with USB device stack; 

2.adjust some viable and micro name
3.some other small fix
上级 8fd0a7f9
展开全部 隐藏空白更改
内联 并排
Showing with 420 addition and 441 deletion
components/drivers/include/drivers/usb_host.h
浏览文件 @ 0fb9c54e
......@@ -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);
}
......
components/drivers/usb/usbhost/SConscript
浏览文件 @ 0fb9c54e
......@@ -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']
......
components/drivers/usb/usbhost/class/adk.c
浏览文件 @ 0fb9c54e
......@@ -26,7 +26,7 @@
#include <drivers/usb_host.h>
#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.h>
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; i<ifinst->intf_desc->bNumEndpoints; i++)
for(i=0; i<intf->intf_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;
rt_device_register(&adkinst->device, "adkdev", RT_DEVICE_FLAG_RDWR);
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(&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;
}
......
components/drivers/usb/usbhost/class/adk.h
浏览文件 @ 0fb9c54e
......@@ -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
......
components/drivers/usb/usbhost/core/core.c
浏览文件 @ 0fb9c54e
......@@ -25,7 +25,7 @@
#include <rtthread.h>
#include <drivers/usb_host.h>
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; i<USB_MAX_DEVICE; i++)
{
/* to find an idle instance handle */
if(uinst[i].status != UINST_STATUS_IDLE) continue;
if(dev[i].status != DEV_STATUS_IDLE) continue;
/* initialize the usb device instance */
rt_memset(&uinst[i], 0, sizeof(struct uinstance));
rt_memset(&dev[i], 0, sizeof(struct uinstance));
uinst[i].status = UINST_STATUS_BUSY;
uinst[i].index = i + 1;
uinst[i].address = 0;
uinst[i].max_packet_size = 0x8;
dev[i].status = DEV_STATUS_BUSY;
dev[i].index = i + 1;
dev[i].address = 0;
dev[i].max_packet_size = 0x8;
/* unlock scheduler */
rt_exit_critical();
return &uinst[i];
return &dev[i];
}
/* unlock scheduler */
......@@ -71,11 +71,11 @@ uinst_t rt_usb_alloc_instance(void)
* and do device enumunation process.
*
* @param hcd the host controller driver.
* @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_attatch_instance(uinst_t uinst)
rt_err_t rt_usbh_attatch_instance(uinst_t device)
{
int i = 0;
rt_err_t ret = RT_EOK;
......@@ -84,15 +84,15 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst)
uintf_desc_t intf_desc;
ucd_t drv;
RT_ASSERT(uinst != RT_NULL);
RT_ASSERT(device != RT_NULL);
rt_memset(&cfg_desc, 0, sizeof(struct uconfig_descriptor));
dev_desc = &uinst->dev_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; i<uinst->cfg_desc->bNumInterfaces; i++)
for(i=0; i<device->cfg_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; i<uinst->cfg_desc->bNumInterfaces; i++)
for(i=0; i<device->cfg_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;
......
components/drivers/usb/usbhost/core/driver.c
浏览文件 @ 0fb9c54e
......@@ -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;
......
components/drivers/usb/usbhost/core/usbhost.c
浏览文件 @ 0fb9c54e
......@@ -24,7 +24,9 @@
#include <rtthread.h>
#include <drivers/usb_host.h>
#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 <hid.h>
#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);
/* initialize usb host controller */
rt_device_init(uhc);
return 0;
return RT_EOK;
}
INIT_COMPONENT_EXPORT(rt_usb_host_init);
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或