Mirrors_Framework/rt-thread
1
0
Fork 0
mirror of https://github.com/RT-Thread/rt-thread.git synced 2026-06-14 13:13:57 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #981 from enkiller/modify_usb_stack_

Browse Source 
[usb]update usb stack
This commit is contained in:
Bernard Xiong
2017-11-13 14:25:51 +08:00
committed by GitHub
parent f0bc0f8fd4 cc54e0a74e
commit d3e72e7498
21 changed files with 2744 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/drivers/include/drivers/usb_common.h
+20 -15
View File
@@ -313,12 +313,12 @@ typedef struct uiad_descriptor* uiad_desc_t;
struct uendpoint_descriptor
{
rt_uint8_t bLength;
rt_uint8_t type;
rt_uint8_t bEndpointAddress;
rt_uint8_t bmAttributes;
rt_uint8_t bLength;
rt_uint8_t type;
rt_uint8_t bEndpointAddress;
rt_uint8_t bmAttributes;
rt_uint16_t wMaxPacketSize;
rt_uint8_t bInterval;
rt_uint8_t bInterval;
};
typedef struct uendpoint_descriptor* uep_desc_t;
@@ -358,33 +358,38 @@ struct usb_qualifier_descriptor
rt_uint8_t bRESERVED;
} __attribute__ ((packed));
#ifndef HID_SUB_DESCRIPTOR_MAX
#define HID_SUB_DESCRIPTOR_MAX 1
#endif
struct uhid_descriptor
{
rt_uint8_t bLength;
rt_uint8_t type;
rt_uint8_t bLength;
rt_uint8_t type;
rt_uint16_t bcdHID;
rt_uint8_t bCountryCode;
rt_uint8_t bNumDescriptors;
rt_uint8_t bCountryCode;
rt_uint8_t bNumDescriptors;
struct hid_descriptor_list
{
rt_uint8_t type;
rt_uint16_t wLength;
}Descriptor[1];
}Descriptor[HID_SUB_DESCRIPTOR_MAX];
};
typedef struct uhid_descriptor* uhid_desc_t;
struct urequest
{
rt_uint8_t request_type;
rt_uint8_t request;
rt_uint16_t value;
rt_uint16_t index;
rt_uint16_t length;
rt_uint8_t request_type;
rt_uint8_t bRequest;
rt_uint16_t wValue;
rt_uint16_t wIndex;
rt_uint16_t wLength;
};
typedef struct urequest* ureq_t;
#ifndef MIN
#define MIN(a, b) (a < b ? a : b)
#endif
#ifndef MAX
#define MAX(a, b) (a > b ? a : b)
#endif
components/drivers/include/drivers/usb_device.h
+11 -11
View File
@@ -28,13 +28,13 @@
#define __USB_DEVICE_H__
#include <rtthread.h>
#include "usb_common.h"
#include "drivers/usb_common.h"
/* Vendor ID */
#ifdef USB_VENDOR_ID
#define _VENDOR_ID USB_VENDOR_ID
#define _VENDOR_ID USB_VENDOR_ID
#else
#define _VENDOR_ID 0x0EFF
#define _VENDOR_ID 0x0EFF
#endif
/* Product ID */
#ifdef USB_PRODUCT_ID
@@ -76,7 +76,7 @@ typedef enum
/* request to read full count */
UIO_REQUEST_READ_FULL,
/* request to read any count */
UIO_REQUEST_READ_MOST,
UIO_REQUEST_READ_BEST,
/* request to write full count */
UIO_REQUEST_WRITE,
}UIO_REQUEST_TYPE;
@@ -99,11 +99,11 @@ struct udcd_ops
struct ep_id
{
rt_uint8_t addr;
rt_uint8_t type;
rt_uint8_t dir;
rt_uint8_t maxpacket;
rt_uint8_t status;
rt_uint8_t addr;
rt_uint8_t type;
rt_uint8_t dir;
rt_uint16_t maxpacket;
rt_uint8_t status;
};
typedef rt_err_t (*udep_handler_t)(struct ufunction* func, rt_size_t size);
@@ -238,7 +238,7 @@ struct udev_msg
udcd_t dcd;
union
{
struct ep_msg ep_msg;
struct ep_msg ep_msg;
struct urequest setup;
} content;
};
@@ -295,7 +295,7 @@ rt_err_t rt_usbd_ep0_clear_stall(udevice_t device);
rt_err_t rt_usbd_ep0_setup_handler(udcd_t dcd, struct urequest* setup);
rt_err_t rt_usbd_ep0_in_handler(udcd_t dcd);
rt_err_t rt_usbd_ep0_out_handler(udcd_t dcd, rt_size_t size);
rt_err_t rt_usbd_ep_in_handler(udcd_t dcd, rt_uint8_t address);
rt_err_t rt_usbd_ep_in_handler(udcd_t dcd, rt_uint8_t address, rt_size_t size);
rt_err_t rt_usbd_ep_out_handler(udcd_t dcd, rt_uint8_t address, rt_size_t size);
rt_err_t rt_usbd_reset_handler(udcd_t dcd);
rt_err_t rt_usbd_connect_handler(udcd_t dcd);
components/drivers/usb/SConscript
+3 -4
View File
@@ -2,13 +2,12 @@
import os
from building import *
cwd = GetCurrentDir()
objs = []
list = os.listdir(cwd)
cwd = GetCurrentDir()
objs = []
list = os.listdir(cwd)
for d in list:
path = os.path.join(cwd, d)
if os.path.isfile(os.path.join(path, 'SConscript')):
objs = objs + SConscript(os.path.join(d, 'SConscript'))
Return('objs')
components/drivers/usb/usbdevice/SConscript
+4 -1
View File
@@ -9,12 +9,15 @@ core/usbdevice.c
if GetDepend('RT_USB_DEVICE_CDC'):
src += Glob('class/cdc_vcom.c')
if GetDepend('RT_USB_DEVICE_HID'):
src += Glob('class/hid.c')
if GetDepend('RT_USB_DEVICE_MSTORAGE'):
src += Glob('class/mstorage.c')
CPPPATH = [cwd]
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_USB_DEVICE'], CPPPATH = CPPPATH)
group = DefineGroup('rt_usbd', src, depend = ['RT_USING_USB_DEVICE'], CPPPATH = CPPPATH)
Return('group')
components/drivers/usb/usbdevice/class/cdc_vcom.c
+103 -43
View File
@@ -22,24 +22,31 @@
* 2012-10-02 Yi Qiu first version
* 2012-12-12 heyuanjie87 change endpoints and function handler
* 2013-06-25 heyuanjie87 remove SOF mechinism
* 2013-07-20 Yi Qiu do more test
* 2013-07-20 Yi Qiu do more test
* 2016-02-01 Urey Fix some error
*/
#include <rthw.h>
#include <rtthread.h>
#include <rtservice.h>
#include <rtdevice.h>
#include <rthw.h>
#include <drivers/serial.h>
#include "drivers/usb_device.h"
#include "cdc.h"
#ifdef RT_USB_DEVICE_CDC
#define TX_TIMEOUT 100
#define TX_TIMEOUT 1000
#define CDC_RX_BUFSIZE 2048
#define CDC_MAX_PACKET_SIZE 64
#define VCOM_DEVICE "vcom"
#define VCOM_TASK_STK_SIZE 2048
//#define VCOM_TX_USE_DMA
ALIGN(RT_ALIGN_SIZE)
static rt_uint8_t vcom_thread_stack[512];
static rt_uint8_t vcom_thread_stack[VCOM_TASK_STK_SIZE];
static struct rt_thread vcom_thread;
#define VCOM_MQ_MSG_SZ 16
#define VCOM_MQ_MAX_MSG 4
@@ -52,7 +59,7 @@ static struct ucdc_line_coding line_coding;
struct vcom
{
struct rt_serial_device serial;
struct rt_serial_device serial;
uep_t ep_out;
uep_t ep_in;
uep_t ep_cmd;
@@ -61,7 +68,6 @@ struct vcom
struct rt_completion wait;
rt_uint8_t rx_rbp[CDC_RX_BUFSIZE];
struct rt_ringbuffer rx_ringbuffer;
struct serial_ringbuffer vcom_int_rx;
};
struct vcom_tx_msg
@@ -227,7 +233,7 @@ static rt_err_t _ep_in_handler(ufunction_t func, rt_size_t size)
RT_ASSERT(func != RT_NULL);
RT_DEBUG_LOG(RT_DEBUG_USB, ("_ep_in_handler %d\n", size));
rt_kprintf("%s size = %d\n",__func__,size);
data = (struct vcom*)func->user_data;
if ((size != 0) && (size % CDC_MAX_PACKET_SIZE == 0))
{
@@ -276,11 +282,11 @@ static rt_err_t _ep_out_handler(ufunction_t func, rt_size_t size)
rt_hw_interrupt_enable(level);
/* notify receive data */
rt_hw_serial_isr(&data->serial);
rt_hw_serial_isr(&data->serial,RT_SERIAL_EVENT_RX_IND);
data->ep_out->request.buffer = data->ep_out->buffer;
data->ep_out->request.size = EP_MAXPACKET(data->ep_out);
data->ep_out->request.req_type = UIO_REQUEST_READ_MOST;
data->ep_out->request.req_type = UIO_REQUEST_READ_BEST;
rt_usbd_io_request(func->device, data->ep_out, &data->ep_out->request);
return RT_EOK;
@@ -325,7 +331,7 @@ static rt_err_t _cdc_get_line_coding(udevice_t device, ureq_t setup)
data.bCharFormat = 0;
data.bDataBits = 8;
data.bParityType = 0;
size = setup->length > 7 ? 7 : setup->length;
size = setup->wLength > 7 ? 7 : setup->wLength;
rt_usbd_ep0_write(device, (void*)&data, size);
@@ -380,7 +386,7 @@ static rt_err_t _interface_handler(ufunction_t func, ureq_t setup)
data = (struct vcom*)func->user_data;
switch(setup->request)
switch(setup->bRequest)
{
case CDC_SEND_ENCAPSULATED_COMMAND:
break;
@@ -435,7 +441,7 @@ static rt_err_t _function_enable(ufunction_t func)
data->ep_out->request.buffer = data->ep_out->buffer;
data->ep_out->request.size = EP_MAXPACKET(data->ep_out);
data->ep_out->request.req_type = UIO_REQUEST_READ_MOST;
data->ep_out->request.req_type = UIO_REQUEST_READ_BEST;
rt_usbd_io_request(func->device, data->ep_out, &data->ep_out->request);
return RT_EOK;
@@ -630,69 +636,111 @@ static int _vcom_getc(struct rt_serial_device *serial)
return result;
}
static rt_size_t _vcom_tx(struct rt_serial_device *serial,
const char *buf, rt_size_t size)
#ifdef VCOM_TX_USE_DMA
static rt_size_t _vcom_tx(struct rt_serial_device *serial, const char *buf, rt_size_t size,int direction)
{
struct vcom_tx_msg msg;
static struct vcom_tx_msg msg;
RT_ASSERT(serial != RT_NULL);
RT_ASSERT(buf != RT_NULL);
msg.buf = buf;
msg.serial = serial;
msg.size = size;
rt_kprintf("%s\n",__func__);
if (rt_mq_send(&vcom_tx_thread_mq, (void*)&msg,
sizeof(struct vcom_tx_msg)) != RT_EOK)
msg.buf = buf;
msg.serial = serial;
msg.size = size;
if (rt_mq_send(&vcom_tx_thread_mq, (void*)&msg, sizeof(struct vcom_tx_msg)) != RT_EOK)
{
rt_kprintf("vcom send msg fail\n");
return 0;
}
return size;
}
#else
static int _vcom_putc(struct rt_serial_device *serial, char c)
{
static struct vcom_tx_msg msg;
RT_ASSERT(serial != RT_NULL);
msg.buf = (void *)((rt_uint32_t)c);
msg.serial = serial;
msg.size = 1;
if (rt_mq_send(&vcom_tx_thread_mq, (void*)&msg, sizeof(struct vcom_tx_msg)) != RT_EOK)
{
// rt_kprintf("vcom send msg fail\n");
return -1;
}
return 1;
}
#endif
static const struct rt_uart_ops usb_vcom_ops =
{
_vcom_configure,
_vcom_control,
#ifndef VCOM_TX_USE_DMA
_vcom_putc,
_vcom_getc,
RT_NULL
#else
RT_NULL,
_vcom_getc,
RT_NULL,
//_vcom_tx,
_vcom_tx
#endif
};
/* Vcom Tx Thread */
static void vcom_tx_thread_entry(void* parameter)
{
struct vcom_tx_msg msg;
rt_uint8_t ch;
while (1)
{
if (rt_mq_recv(&vcom_tx_thread_mq, (void*)&msg,
sizeof(struct vcom_tx_msg), RT_WAITING_FOREVER) == RT_EOK)
if (rt_mq_recv(&vcom_tx_thread_mq, (void*)&msg, sizeof(struct vcom_tx_msg), RT_WAITING_FOREVER) == RT_EOK)
{
struct ufunction *func;
struct vcom *data;
func = (struct ufunction*)msg.serial->parent.user_data;
data = (struct vcom*)func->user_data;
if (!data->connected)
{
/* drop msg */
#ifndef VCOM_TX_USE_DMA
rt_hw_serial_isr(&data->serial,RT_SERIAL_EVENT_TX_DONE);
#else
rt_hw_serial_isr(&data->serial,RT_SERIAL_EVENT_TX_DMADONE);
#endif
continue;
}
rt_completion_init(&data->wait);
#ifndef VCOM_TX_USE_DMA
ch = (rt_uint8_t)((rt_uint32_t)msg.buf);
data->ep_in->request.buffer = (rt_uint8_t*)&ch;
#else
data->ep_in->request.buffer = (rt_uint8_t*)msg.buf;
#endif
data->ep_in->request.size = msg.size;
data->ep_in->request.req_type = UIO_REQUEST_WRITE;
data->ep_in->request.buffer = (void*)msg.buf;
data->ep_in->request.size = msg.size;
data->ep_in->request.req_type = UIO_REQUEST_WRITE;
rt_usbd_io_request(func->device, data->ep_in, &data->ep_in->request);
if (rt_completion_wait(&data->wait, TX_TIMEOUT) != RT_EOK)
{
rt_kprintf("vcom tx timeout\n");
}
}
#ifndef VCOM_TX_USE_DMA
rt_hw_serial_isr(&data->serial,RT_SERIAL_EVENT_TX_DONE);
#else
rt_hw_serial_isr(&data->serial,RT_SERIAL_EVENT_TX_DMADONE);
#endif
}
}
}
@@ -706,29 +754,41 @@ static void rt_usb_vcom_init(struct ufunction *func)
/* initialize ring buffer */
rt_ringbuffer_init(&data->rx_ringbuffer, data->rx_rbp, CDC_RX_BUFSIZE);
config.baud_rate = BAUD_RATE_115200;
config.bit_order = BIT_ORDER_LSB;
config.data_bits = DATA_BITS_8;
config.parity = PARITY_NONE;
config.stop_bits = STOP_BITS_1;
config.invert = NRZ_NORMAL;
config.baud_rate = BAUD_RATE_115200;
config.data_bits = DATA_BITS_8;
config.stop_bits = STOP_BITS_1;
config.parity = PARITY_NONE;
config.bit_order = BIT_ORDER_LSB;
config.invert = NRZ_NORMAL;
config.bufsz = CDC_RX_BUFSIZE;
data->serial.ops = &usb_vcom_ops;
data->serial.int_rx = &data->vcom_int_rx;
data->serial.config = config;
data->serial.ops = &usb_vcom_ops;
data->serial.serial_rx = RT_NULL;
data->serial.config = config;
/* register vcom device */
rt_hw_serial_register(&data->serial, VCOM_DEVICE,
#ifndef VCOM_TX_USE_DMA
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX,
#else
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_DMA_TX,
#endif
func);
/* create an vcom message queue */
rt_mq_init(&vcom_tx_thread_mq, "vcomq", vcom_tx_thread_mq_pool, VCOM_MQ_MSG_SZ,
sizeof(vcom_tx_thread_mq_pool), RT_IPC_FLAG_FIFO);
rt_mq_init(&vcom_tx_thread_mq,
"vcomq",
vcom_tx_thread_mq_pool,
VCOM_MQ_MSG_SZ,
sizeof(vcom_tx_thread_mq_pool),
RT_IPC_FLAG_FIFO);
/* init usb device thread */
rt_thread_init(&vcom_thread, "vcom", vcom_tx_thread_entry, RT_NULL,
vcom_thread_stack, 512, 8, 20);
rt_thread_init(&vcom_thread, "vcom",
vcom_tx_thread_entry, RT_NULL,
vcom_thread_stack, VCOM_TASK_STK_SIZE,
8, 20);
result = rt_thread_startup(&vcom_thread);
RT_ASSERT(result == RT_EOK);
}
components/drivers/usb/usbdevice/class/hid.c
+552
View File
File diff suppressed because it is too large Load Diff
components/drivers/usb/usbdevice/class/hid.h
+55
View File
@@ -0,0 +1,55 @@
/*
* File : hid.h
* COPYRIGHT (C) 2008 - 2016, RT-Thread Development Team
*
* Change Logs:
* Date Author Notes
* 2017Äê3ÔÂ13ÈÕ Urey the first version
*/
#ifndef _USBDEVICE_CLASS_HID_H_
#define _USBDEVICE_CLASS_HID_H_
#ifdef __cplusplus
extern "C" {
#endif
#define HID_DESCRIPTOR_TYPE 0x21
#define HID_DESCRIPTOR_SIZE 0x09
#define HID_OFF_HID_DESC 0x12
#define USB_HID_SUBCLASS_BOOT 0x01
#define USB_HID_SUBCLASS_NOBOOT 0x00
#define USB_HID_PROTOCOL_NONE 0x00
#define USB_HID_PROTOCOL_KEYBOARD 0x01
#define USB_HID_PROTOCOL_MOUSE 0x02
#define USB_HID_REQ_GET_REPORT 0x01
#define USB_HID_REQ_GET_IDLE 0x02
#define USB_HID_REQ_GET_PROTOCOL 0x03
#define USB_HID_REQ_SET_REPORT 0x09
#define USB_HID_REQ_SET_IDLE 0x0a
#define USB_HID_REQ_SET_PROTOCOL 0x0b
#define MAX_REPORT_SIZE 8
#define HID_RX_BUFSIZE 64
struct uhid_comm_descriptor
{
#ifdef RT_USB_DEVICE_COMPOSITE
struct uiad_descriptor iad_desc;
#endif
struct uinterface_descriptor intf_desc;
struct uhid_descriptor hid_desc;
struct uendpoint_descriptor ep_in_desc;
struct uendpoint_descriptor ep_out_desc;
};
typedef struct uhid_comm_descriptor* uhid_comm_desc_t;
#ifdef __cplusplus
}
#endif
#endif /* _USBDEVICE_CLASS_HID_H_ */
components/drivers/usb/usbdevice/class/mstorage.c
+3 -1
View File
@@ -27,7 +27,7 @@
#include <rtthread.h>
#include <rtservice.h>
#include <rtdevice.h>
#include "drivers/usb_device.h"
#include "mstorage.h"
#ifdef RT_USB_DEVICE_MSTORAGE
@@ -112,6 +112,8 @@ static struct usb_qualifier_descriptor dev_qualifier =
0,
};
const static struct umass_descriptor _mass_desc =
{
USB_DESC_LENGTH_INTERFACE, //bLength;
components/drivers/usb/usbdevice/core/core.c
+119 -123
View File
File diff suppressed because it is too large Load Diff
components/drivers/usb/usbdevice/core/usbdevice.c
+32 -13
View File
@@ -89,27 +89,47 @@ rt_err_t rt_usb_device_init(void)
cfg = rt_usbd_config_new();
#ifdef RT_USB_DEVICE_MSTORAGE
/* create a mass storage function object */
func = rt_usbd_function_mstorage_create(udevice);
{
extern ufunction_t rt_usbd_function_mstorage_create(udevice_t device);
/* create a mass storage function object */
func = rt_usbd_function_mstorage_create(udevice);
/* add the function to the configuration */
rt_usbd_config_add_function(cfg, func);
/* add the function to the configuration */
rt_usbd_config_add_function(cfg, func);
}
#endif
#ifdef RT_USB_DEVICE_CDC
/* create a cdc function object */
func = rt_usbd_function_cdc_create(udevice);
{
extern ufunction_t rt_usbd_function_cdc_create(udevice_t device);
/* create a cdc function object */
func = rt_usbd_function_cdc_create(udevice);
/* add the function to the configuration */
rt_usbd_config_add_function(cfg, func);
/* add the function to the configuration */
rt_usbd_config_add_function(cfg, func);
}
#endif
#ifdef RT_USB_DEVICE_HID
{
extern ufunction_t rt_usbd_function_hid_create(udevice_t device);
/* create a cdc function object */
func = rt_usbd_function_hid_create(udevice);
/* add the function to the configuration */
rt_usbd_config_add_function(cfg, func);
}
#endif
#ifdef RT_USB_DEVICE_RNDIS
/* create a rndis function object */
func = rt_usbd_function_rndis_create(udevice);
{
extern ufunction_t rt_usbd_function_rndis_create(udevice_t device);
/* create a rndis function object */
func = rt_usbd_function_rndis_create(udevice);
/* add the function to the configuration */
rt_usbd_config_add_function(cfg, func);
/* add the function to the configuration */
rt_usbd_config_add_function(cfg, func);
}
#endif
/* set device descriptor to the device */
@@ -131,5 +151,4 @@ rt_err_t rt_usb_device_init(void)
return RT_EOK;
}
#endif
components/drivers/usb/usbhost/SConscript
+1 -1
View File
@@ -29,6 +29,6 @@ if GetDepend('RT_USBH_HID_KEYBOARD'):
CPPPATH = [cwd, cwd + '/class', cwd + '/core', \
cwd + '/include', cwd + '../../../include']
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_USB_HOST'], CPPPATH = CPPPATH)
group = DefineGroup('rt_usbh', src, depend = ['RT_USING_USBH'], CPPPATH = CPPPATH)
Return('group')
components/drivers/usb/usbhost/class/hid.c
+397
View File
@@ -0,0 +1,397 @@
/*
* File : hid.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2011-12-12 Yi Qiu first version
*/
#include <rtthread.h>
#include <drivers/usb_host.h>
#include "hid.h"
#ifdef RT_USBH_HID
static struct uclass_driver hid_driver;
static rt_list_t _protocal_list;
/**
* This function will do USB_REQ_SET_IDLE request to set idle period to the usb hid device
*
* @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.
*/
rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id)
{
struct urequest setup;
struct uinstance* device;
int timeout = 100;
/* parameter check */
RT_ASSERT(intf != RT_NULL);
RT_ASSERT(intf->device != RT_NULL);
device = intf->device;
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_INTERFACE;
setup.request = USB_REQ_SET_IDLE;
setup.index = 0;
setup.length = 0;
setup.value = (duration << 8 )| report_id;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0,
timeout) == 0) return RT_EOK;
else return -RT_FALSE;
}
/**
* This function will do USB_REQ_GET_REPORT request to get report from the usb hid device
*
* @param intf the interface instance.
* @buffer the data buffer to save usb report descriptor.
* @param nbytes the size of buffer
*
* @return the error code, RT_EOK on successfully.
*/
rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type,
rt_uint8_t id, rt_uint8_t *buffer, rt_size_t size)
{
struct urequest setup;
struct uinstance* device;
int timeout = 100;
/* parameter check */
RT_ASSERT(intf != RT_NULL);
RT_ASSERT(intf->device != RT_NULL);
device = intf->device;
setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_INTERFACE;
setup.request = USB_REQ_GET_REPORT;
setup.index = intf->intf_desc->bInterfaceNumber;
setup.length = size;
setup.value = (type << 8 ) + id;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size,
timeout) == size) return RT_EOK;
else return -RT_FALSE;
}
/**
* This function will do USB_REQ_SET_REPORT request to set report to the usb hid device
*
* @param intf the interface instance.
* @buffer the data buffer to save usb report descriptor.
* @param nbytes the size of buffer
*
* @return the error code, RT_EOK on successfully.
*/
rt_err_t rt_usbh_hid_set_report(struct uintf* intf, rt_uint8_t *buffer, rt_size_t size)
{
struct urequest setup;
struct uinstance* device;
int timeout = 100;
/* parameter check */
RT_ASSERT(intf != RT_NULL);
RT_ASSERT(intf->device != RT_NULL);
device = intf->device;
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_INTERFACE;
setup.request = USB_REQ_SET_REPORT;
setup.index = intf->intf_desc->bInterfaceNumber;
setup.length = size;
setup.value = 0x02 << 8;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size,
timeout) == size) return RT_EOK;
else return -RT_FALSE;
}
/**
* This function will do USB_REQ_SET_PROTOCOL request to set protocal to the usb hid device.
*
* @param intf the interface instance.
* @param protocol the protocol id.
*
* @return the error code, RT_EOK on successfully.
*/
rt_err_t rt_usbh_hid_set_protocal(struct uintf* intf, int protocol)
{
struct urequest setup;
struct uinstance* device;
int timeout = 100;
/* parameter check */
RT_ASSERT(intf != RT_NULL);
RT_ASSERT(intf->device != RT_NULL);
device = intf->device;
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_INTERFACE;
setup.request = USB_REQ_SET_PROTOCOL;
setup.index = 0;
setup.length = 0;
setup.value = protocol;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0,
timeout) == 0) return RT_EOK;
else return -RT_FALSE;
}
/**
* This function will do USB_REQ_GET_DESCRIPTOR request for the device instance
* to set feature of the hub port.
*
* @param intf the interface instance.
* @buffer the data buffer to save usb report descriptor.
* @param nbytes the size of buffer
*
* @return the error code, RT_EOK on successfully.
*/
rt_err_t rt_usbh_hid_get_report_descriptor(struct uintf* intf,
rt_uint8_t *buffer, rt_size_t size)
{
struct urequest setup;
struct uinstance* device;
int timeout = 100;
/* parameter check */
RT_ASSERT(intf != RT_NULL);
RT_ASSERT(intf->device != RT_NULL);
device = intf->device;
setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_STANDARD|
USB_REQ_TYPE_INTERFACE;
setup.request = USB_REQ_GET_DESCRIPTOR;
setup.index = 0;
setup.length = size;
setup.value = USB_DESC_TYPE_REPORT << 8;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, size,
timeout) == size) return RT_EOK;
else return -RT_FALSE;
}
/**
* This function will register specified hid protocal to protocal list
*
* @param protocal the specified protocal.
*
* @return the error code, RT_EOK on successfully.
*/
rt_err_t rt_usbh_hid_protocal_register(uprotocal_t protocal)
{
RT_ASSERT(protocal != RT_NULL);
if (protocal == RT_NULL) return -RT_ERROR;
/* insert class driver into driver list */
rt_list_insert_after(&_protocal_list, &(protocal->list));
return RT_EOK;
}
/**
* This function is the callback function of hid's int endpoint, it is invoked when data comes.
*
* @param context the context of the callback function.
*
* @return none.
*/
static void rt_usbh_hid_callback(void* context)
{
upipe_t pipe;
struct uhid* hid;
int timeout = 300;
/* parameter check */
RT_ASSERT(context != RT_NULL);
pipe = (upipe_t)context;
hid = (struct uhid*)pipe->intf->user_data;
/* invoke protocal callback function */
hid->protocal->callback((void*)hid);
/* parameter check */
RT_ASSERT(pipe->intf->device->hcd != RT_NULL);
rt_usb_hcd_int_xfer(pipe->intf->device->hcd, pipe, hid->buffer,
pipe->ep.wMaxPacketSize, timeout);
}
/**
* This function will find specified hid protocal from protocal list
*
* @param pro_id the protocal id.
*
* @return the found protocal or RT_NULL if there is no this protocal.
*/
static uprotocal_t rt_usbh_hid_protocal_find(int pro_id)
{
struct rt_list_node *node;
/* try to find protocal object */
for (node = _protocal_list.next; node != &_protocal_list; node = node->next)
{
uprotocal_t protocal =
(uprotocal_t)rt_list_entry(node, struct uprotocal, list);
if (protocal->pro_id == pro_id) return protocal;
}
/* not found */
return RT_NULL;
}
/**
* This function will run hid class driver when usb device is detected and identified
* as a hid class device, it will continue the enumulate process.
*
* @param arg the argument.
*
* @return the error code, RT_EOK on successfully.
*/
static rt_err_t rt_usbh_hid_enable(void* arg)
{
int i = 0, pro_id;
uprotocal_t protocal;
struct uhid* hid;
struct uintf* intf = (struct uintf*)arg;
int timeout = 100;
upipe_t pipe;
/* parameter check */
if(intf == RT_NULL)
{
rt_kprintf("the interface is not available\n");
return -RT_EIO;
}
pro_id = intf->intf_desc->bInterfaceProtocol;
RT_DEBUG_LOG(RT_DEBUG_USB,
("HID device enable, protocal id %d\n", pro_id));
protocal = rt_usbh_hid_protocal_find(pro_id);
if(protocal == RT_NULL)
{
rt_kprintf("can't find hid protocal %d\n", pro_id);
intf->user_data = RT_NULL;
return -RT_ERROR;
}
hid = rt_malloc(sizeof(struct uhid));
RT_ASSERT(hid != RT_NULL);
/* initilize the data structure */
rt_memset(hid, 0, sizeof(struct uhid));
intf->user_data = (void*)hid;
hid->protocal = protocal;
for(i=0; i<intf->intf_desc->bNumEndpoints; i++)
{
rt_err_t ret;
uep_desc_t ep_desc;
/* get endpoint descriptor */
rt_usbh_get_endpoint_descriptor(intf->intf_desc, i, &ep_desc);
if(ep_desc == RT_NULL)
{
rt_kprintf("rt_usbh_get_endpoint_descriptor error\n");
return -RT_ERROR;
}
if(USB_EP_ATTR(ep_desc->bmAttributes) != USB_EP_ATTR_INT)
continue;
if(!(ep_desc->bEndpointAddress & USB_DIR_IN)) continue;
ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &hid->pipe_in,
intf, ep_desc, rt_usbh_hid_callback);
if(ret != RT_EOK) return ret;
}
/* initialize hid protocal */
hid->protocal->init((void*)intf);
pipe = hid->pipe_in;
/* parameter check */
RT_ASSERT(pipe->intf->device->hcd != RT_NULL);
rt_usb_hcd_int_xfer(pipe->intf->device->hcd, hid->pipe_in,
hid->buffer, hid->pipe_in->ep.wMaxPacketSize, timeout);
return RT_EOK;
}
/**
* This function will be invoked when usb device plug out is detected and it would clean
* and release all hub class related resources.
*
* @param arg the argument.
*
* @return the error code, RT_EOK on successfully.
*/
static rt_err_t rt_usbh_hid_disable(void* arg)
{
struct uhid* hid;
struct uintf* intf = (struct uintf*)arg;
RT_ASSERT(intf != RT_NULL);
RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_hid_disable\n"));
hid = (struct uhid*)intf->user_data;
if(hid != RT_NULL)
{
if(hid->pipe_in != RT_NULL)
{
/* free the HID in pipe */
rt_usb_hcd_free_pipe(intf->device->hcd, hid->pipe_in);
}
/* free the hid instance */
rt_free(hid);
}
/* free the instance */
rt_free(intf);
return RT_EOK;
}
/**
* This function will register hid class driver to the usb class driver manager.
* and it should be invoked in the usb system initialization.
*
* @return the error code, RT_EOK on successfully.
*/
ucd_t rt_usbh_class_driver_hid(void)
{
rt_list_init(&_protocal_list);
hid_driver.class_code = USB_CLASS_HID;
hid_driver.enable = rt_usbh_hid_enable;
hid_driver.disable = rt_usbh_hid_disable;
return &hid_driver;
}
#endif
components/drivers/usb/usbhost/class/hid.h
+45
View File
@@ -0,0 +1,45 @@
/*
* File : hid.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2011-12-12 Yi Qiu first version
*/
#ifndef __HID_H__
#define __HID_H__
#include <rtthread.h>
struct uhid
{
upipe_t pipe_in;
rt_uint8_t buffer[8];
uprotocal_t protocal;
};
typedef struct uhid uhid_t;
#define USB_REQ_GET_REPORT 0x01
#define USB_REQ_GET_IDLE 0x02
#define USB_REQ_GET_PROTOCOL 0x03
#define USB_REQ_SET_REPORT 0x09
#define USB_REQ_SET_IDLE 0x0a
#define USB_REQ_SET_PROTOCOL 0x0b
#define USB_HID_KEYBOARD 1
#define USB_HID_MOUSE 2
rt_err_t rt_usbh_hid_set_idle(struct uintf* intf, int duration, int report_id);
rt_err_t rt_usbh_hid_get_report(struct uintf* intf, rt_uint8_t type, rt_uint8_t id, rt_uint8_t *buffer, rt_size_t size);
rt_err_t rt_usbh_hid_set_report(struct uintf* intf, rt_uint8_t *buffer, rt_size_t size);
rt_err_t rt_usbh_hid_set_protocal(struct uintf* intf, int protocol);
rt_err_t rt_usbh_hid_get_report_descriptor(struct uintf* intf, rt_uint8_t *buffer, rt_size_t size);
rt_err_t rt_usbh_hid_protocal_register(uprotocal_t protocal);
#endif
components/drivers/usb/usbhost/class/mass.c
+648
View File
File diff suppressed because it is too large Load Diff
components/drivers/usb/usbhost/class/mass.h
+54
View File
@@ -0,0 +1,54 @@
/*
* File : mass.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2011-12-12 Yi Qiu first version
*/
#ifndef __MASS_H__
#define __MASS_H__
#include <rtthread.h>
#include "dfs_fs.h"
#define MAX_PARTITION_COUNT 4
#define SECTOR_SIZE 512
struct ustor_data
{
struct dfs_partition part;
struct uintf* intf;
int udisk_id;
const char path;
};
struct ustor
{
upipe_t pipe_in;
upipe_t pipe_out;
rt_uint32_t capicity[2];
struct rt_device dev[MAX_PARTITION_COUNT];
rt_uint8_t dev_cnt;
};
typedef struct ustor* ustor_t;
rt_err_t rt_usbh_storage_get_max_lun(struct uintf* intf, rt_uint8_t* max_lun);
rt_err_t rt_usbh_storage_reset(struct uintf* intf);
rt_err_t rt_usbh_storage_read10(struct uintf* intf, rt_uint8_t *buffer,
rt_uint32_t sector, rt_size_t count, int timeout);
rt_err_t rt_usbh_storage_write10(struct uintf* intf, rt_uint8_t *buffer,
rt_uint32_t sector, rt_size_t count, int timeout);
rt_err_t rt_usbh_storage_request_sense(struct uintf* intf, rt_uint8_t* buffer);
rt_err_t rt_usbh_storage_test_unit_ready(struct uintf* intf);
rt_err_t rt_usbh_storage_inquiry(struct uintf* intf, rt_uint8_t* buffer);
rt_err_t rt_usbh_storage_get_capacity(struct uintf* intf, rt_uint8_t* buffer);
#endif
components/drivers/usb/usbhost/class/udisk.c
+419
View File
@@ -0,0 +1,419 @@
/*
* File : udisk.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2011-12-12 Yi Qiu first version
*/
#include <rtthread.h>
#include <dfs_fs.h>
#include <drivers/usb_host.h>
#include "mass.h"
#ifdef RT_USBH_MSTORAGE
#define UDISK_MAX_COUNT 8
static rt_uint8_t _udisk_idset = 0;
static int udisk_get_id(void)
{
int i;
for(i=0; i< UDISK_MAX_COUNT; i++)
{
if((_udisk_idset & (1 << i)) != 0) continue;
else break;
}
/* it should not happen */
if(i == UDISK_MAX_COUNT) RT_ASSERT(0);
_udisk_idset |= (1 << i);
return i;
}
static void udisk_free_id(int id)
{
RT_ASSERT(id < UDISK_MAX_COUNT)
_udisk_idset &= ~(1 << id);
}
/**
* This function will initialize the udisk device
*
* @param dev the pointer of device driver structure
*
* @return RT_EOK
*/
static rt_err_t rt_udisk_init(rt_device_t dev)
{
return RT_EOK;
}
/**
* This function will read some data from a device.
*
* @param dev the pointer of device driver structure
* @param pos the position of reading
* @param buffer the data buffer to save read data
* @param size the size of buffer
*
* @return the actually read size on successful, otherwise negative returned.
*/
static rt_size_t rt_udisk_read(rt_device_t dev, rt_off_t pos, void* buffer,
rt_size_t size)
{
rt_err_t ret;
struct uintf* intf;
struct ustor_data* data;
int timeout = 500;
/* check parameter */
RT_ASSERT(dev != RT_NULL);
RT_ASSERT(buffer != RT_NULL);
if(size > 4096) timeout = 800;
data = (struct ustor_data*)dev->user_data;
intf = data->intf;
ret = rt_usbh_storage_read10(intf, (rt_uint8_t*)buffer, pos, size, timeout);
if (ret != RT_EOK)
{
rt_kprintf("usb mass_storage read failed\n");
return 0;
}
return size;
}
/**
* This function will write some data to a device.
*
* @param dev the pointer of device driver structure
* @param pos the position of written
* @param buffer the data buffer to be written to device
* @param size the size of buffer
*
* @return the actually written size on successful, otherwise negative returned.
*/
static rt_size_t rt_udisk_write (rt_device_t dev, rt_off_t pos, const void* buffer,
rt_size_t size)
{
rt_err_t ret;
struct uintf* intf;
struct ustor_data* data;
int timeout = 500;
/* check parameter */
RT_ASSERT(dev != RT_NULL);
RT_ASSERT(buffer != RT_NULL);
if(size * SECTOR_SIZE > 4096) timeout = 800;
data = (struct ustor_data*)dev->user_data;
intf = data->intf;
ret = rt_usbh_storage_write10(intf, (rt_uint8_t*)buffer, pos, size, timeout);
if (ret != RT_EOK)
{
rt_kprintf("usb mass_storage write %d sector failed\n", size);
return 0;
}
return size;
}
/**
* This function will execute SCSI_INQUIRY_CMD command to get inquiry data.
*
* @param intf the interface instance.
* @param buffer the data buffer to save inquiry data
*
* @return the error code, RT_EOK on successfully.
*/
static rt_err_t rt_udisk_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{
ustor_t stor;
struct ustor_data* data;
/* check parameter */
RT_ASSERT(dev != RT_NULL);
data = (struct ustor_data*)dev->user_data;
stor = (ustor_t)data->intf->user_data;
if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME)
{
struct rt_device_blk_geometry *geometry;
geometry = (struct rt_device_blk_geometry *)args;
if (geometry == RT_NULL) return -RT_ERROR;
geometry->bytes_per_sector = SECTOR_SIZE;
geometry->block_size = stor->capicity[1];
geometry->sector_count = stor->capicity[0];
}
return RT_EOK;
}
/**
* This function will run udisk driver when usb disk is detected.
*
* @param intf the usb interface instance.
*
* @return the error code, RT_EOK on successfully.
*/
rt_err_t rt_udisk_run(struct uintf* intf)
{
int i = 0;
rt_err_t ret;
char dname[4];
char sname[8];
rt_uint8_t max_lun, *sector, sense[18], inquiry[36];
struct dfs_partition part[MAX_PARTITION_COUNT];
ustor_t stor;
/* check parameter */
RT_ASSERT(intf != RT_NULL);
/* set interface */
// ret = rt_usbh_set_interface(intf->device, intf->intf_desc->bInterfaceNumber);
// if(ret != RT_EOK)
// rt_usbh_clear_feature(intf->device, 0, USB_FEATURE_ENDPOINT_HALT);
/* reset mass storage class device */
ret = rt_usbh_storage_reset(intf);
if(ret != RT_EOK) return ret;
stor = (ustor_t)intf->user_data;
/* get max logic unit number */
ret = rt_usbh_storage_get_max_lun(intf, &max_lun);
if(ret != RT_EOK)
rt_usbh_clear_feature(intf->device, 0, USB_FEATURE_ENDPOINT_HALT);
/* reset pipe in endpoint */
ret = rt_usbh_clear_feature(intf->device,
stor->pipe_in->ep.bEndpointAddress, USB_FEATURE_ENDPOINT_HALT);
if(ret != RT_EOK) return ret;
/* reset pipe out endpoint */
ret = rt_usbh_clear_feature(intf->device,
stor->pipe_out->ep.bEndpointAddress, USB_FEATURE_ENDPOINT_HALT);
if(ret != RT_EOK) return ret;
while((ret = rt_usbh_storage_inquiry(intf, inquiry)) != RT_EOK)
{
if(ret == -RT_EIO) return ret;
rt_thread_delay(5);
if(i++ < 10) continue;
rt_kprintf("rt_usbh_storage_inquiry error\n");
return -RT_ERROR;
}
i = 0;
/* wait device ready */
while((ret = rt_usbh_storage_test_unit_ready(intf)) != RT_EOK)
{
if(ret == -RT_EIO) return ret;
ret = rt_usbh_storage_request_sense(intf, sense);
if(ret == -RT_EIO) return ret;
rt_thread_delay(10);
if(i++ < 10) continue;
rt_kprintf("rt_usbh_storage_test_unit_ready error\n");
return -RT_ERROR;
}
i = 0;
rt_memset(stor->capicity, 0, sizeof(stor->capicity));
/* get storage capacity */
while((ret = rt_usbh_storage_get_capacity(intf,
(rt_uint8_t*)stor->capicity)) != RT_EOK)
{
if(ret == -RT_EIO) return ret;
rt_thread_delay(50);
if(i++ < 10) continue;
stor->capicity[0] = 2880;
stor->capicity[1] = 0x200;
rt_kprintf("rt_usbh_storage_get_capacity error\n");
break;
}
stor->capicity[0] = uswap_32(stor->capicity[0]);
stor->capicity[1] = uswap_32(stor->capicity[1]);
stor->capicity[0] += 1;
RT_DEBUG_LOG(RT_DEBUG_USB, ("capicity %d, block size %d\n",
stor->capicity[0], stor->capicity[1]));
/* get the first sector to read partition table */
sector = (rt_uint8_t*) rt_malloc (SECTOR_SIZE);
if (sector == RT_NULL)
{
rt_kprintf("allocate partition sector buffer failed\n");
return -RT_ERROR;
}
rt_memset(sector, 0, SECTOR_SIZE);
RT_DEBUG_LOG(RT_DEBUG_USB, ("read partition table\n"));
/* get the partition table */
ret = rt_usbh_storage_read10(intf, sector, 0, 1, 500);
if(ret != RT_EOK)
{
rt_kprintf("read parition table error\n");
rt_free(sector);
return -RT_ERROR;
}
RT_DEBUG_LOG(RT_DEBUG_USB, ("finished reading partition\n"));
for(i=0; i<MAX_PARTITION_COUNT; i++)
{
/* get the first partition */
ret = dfs_filesystem_get_partition(&part[i], sector, i);
if (ret == RT_EOK)
{
struct ustor_data* data = rt_malloc(sizeof(struct ustor_data));
rt_memset(data, 0, sizeof(struct ustor_data));
data->intf = intf;
data->udisk_id = udisk_get_id();
data->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO);
rt_snprintf(dname, 6, "ud%d-%d", data->udisk_id, i);
rt_snprintf(sname, 8, "sem_ud%d", i);
/* register sdcard device */
stor->dev[i].type = RT_Device_Class_Block;
stor->dev[i].init = rt_udisk_init;
stor->dev[i].read = rt_udisk_read;
stor->dev[i].write = rt_udisk_write;
stor->dev[i].control = rt_udisk_control;
stor->dev[i].user_data = (void*)data;
rt_device_register(&stor->dev[i], dname, RT_DEVICE_FLAG_RDWR |
RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
stor->dev_cnt++;
if (dfs_mount(stor->dev[i].parent.name, UDISK_MOUNTPOINT, "elm",
0, 0) == 0)
{
RT_DEBUG_LOG(RT_DEBUG_USB, ("udisk part %d mount successfully\n", i));
}
else
{
RT_DEBUG_LOG(RT_DEBUG_USB, ("udisk part %d mount failed\n", i));
}
}
else
{
if(i == 0)
{
struct ustor_data* data = rt_malloc(sizeof(struct ustor_data));
rt_memset(data, 0, sizeof(struct ustor_data));
data->udisk_id = udisk_get_id();
/* there is no partition table */
data->part.offset = 0;
data->part.size = 0;
data->intf = intf;
data->part.lock = rt_sem_create("sem_ud", 1, RT_IPC_FLAG_FIFO);
rt_snprintf(dname, 7, "udisk%d", data->udisk_id);
/* register sdcard device */
stor->dev[0].type = RT_Device_Class_Block;
stor->dev[0].init = rt_udisk_init;
stor->dev[0].read = rt_udisk_read;
stor->dev[0].write = rt_udisk_write;
stor->dev[0].control = rt_udisk_control;
stor->dev[0].user_data = (void*)data;
rt_device_register(&stor->dev[0], dname,
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE
| RT_DEVICE_FLAG_STANDALONE);
stor->dev_cnt++;
if (dfs_mount(stor->dev[0].parent.name, UDISK_MOUNTPOINT,
"elm", 0, 0) == 0)
{
rt_kprintf("Mount FAT on Udisk successful.\n");
}
else
{
rt_kprintf("Mount FAT on Udisk failed.\n");
}
}
break;
}
}
rt_free(sector);
return RT_EOK;
}
/**
* This function will be invoked when usb disk plug out is detected and it would clean
* and release all udisk related resources.
*
* @param intf the usb interface instance.
*
* @return the error code, RT_EOK on successfully.
*/
rt_err_t rt_udisk_stop(struct uintf* intf)
{
int i;
ustor_t stor;
struct ustor_data* data;
/* check parameter */
RT_ASSERT(intf != RT_NULL);
RT_ASSERT(intf->device != RT_NULL);
stor = (ustor_t)intf->user_data;
RT_ASSERT(stor != RT_NULL);
for(i=0; i<stor->dev_cnt; i++)
{
rt_device_t dev = &stor->dev[i];
data = (struct ustor_data*)dev->user_data;
/* unmount filesystem */
dfs_unmount(UDISK_MOUNTPOINT);
/* delete semaphore */
rt_sem_delete(data->part.lock);
udisk_free_id(data->udisk_id);
rt_free(data);
/* unregister device */
rt_device_unregister(&stor->dev[i]);
}
return RT_EOK;
}
#endif
components/drivers/usb/usbhost/class/ukbd.c
+72
View File
@@ -0,0 +1,72 @@
/*
* File : ukbd.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2012-01-03 Yi Qiu first version
*/
#include <rtthread.h>
#include <drivers/usb_host.h>
#include "hid.h"
#if defined(RT_USBH_HID) && defined(RT_USBH_HID_KEYBOARD)
static struct uprotocal kbd_protocal;
static rt_err_t rt_usbh_hid_kbd_callback(void* arg)
{
int int1, int2;
struct uhid* hid;
hid = (struct uhid*)arg;
int1 = *(rt_uint32_t*)hid->buffer;
int2 = *(rt_uint32_t*)(&hid->buffer[4]);
if(int1 != 0 || int2 != 0)
{
RT_DEBUG_LOG(RT_DEBUG_USB, ("key down 0x%x, 0x%x\n", int1, int2));
}
return RT_EOK;
}
static rt_err_t rt_usbh_hid_kbd_init(void* arg)
{
struct uintf* intf = (struct uintf*)arg;
RT_ASSERT(intf != RT_NULL);
rt_usbh_hid_set_protocal(intf, 0);
rt_usbh_hid_set_idle(intf, 10, 0);
//RT_DEBUG_LOG(RT_DEBUG_USB, ("start usb keyboard\n"));
return RT_EOK;
}
/**
* This function will define the hid keyboard protocal, it will be register to the protocal list.
*
* @return the keyboard protocal structure.
*/
uprotocal_t rt_usbh_hid_protocal_kbd(void)
{
kbd_protocal.pro_id = USB_HID_KEYBOARD;
kbd_protocal.init = rt_usbh_hid_kbd_init;
kbd_protocal.callback = rt_usbh_hid_kbd_callback;
return &kbd_protocal;
}
#endif
components/drivers/usb/usbhost/class/umouse.c
+157
View File
@@ -0,0 +1,157 @@
/*
* File : umouse.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2012-01-03 Yi Qiu first version
*/
#include <rtthread.h>
#include <drivers/usb_host.h>
#include "hid.h"
#ifdef RT_USING_RTGUI
#include <rtgui/event.h>
#include <rtgui/rtgui_server.h>
#include "drv_lcd.h"
#endif
#if defined(RT_USBH_HID) && defined(RT_USBH_HID_MOUSE)
static struct uprotocal mouse_protocal;
#ifdef RT_USING_RTGUI
#define LKEY_PRESS 0x01
#define RKEY_PRESS 0x02
#define MKEY_PRESS 0x04
#define MOUSE_SCALING 0x02
static rt_bool_t lkey_down=RT_FALSE;
//static rt_bool_t rkey_down=RT_FALSE;
//static rt_bool_t mkey_down=RT_FALSE;
static struct rtgui_event_mouse emouse;
#endif
static rt_err_t rt_usbh_hid_mouse_callback(void* arg)
{
struct uhid* hid;
#ifdef RT_USING_RTGUI
rt_uint16_t xoffset=0;
rt_uint16_t yoffset=0;
#endif
hid = (struct uhid*)arg;
RT_DEBUG_LOG(RT_DEBUG_USB, ("hid 0x%x 0x%x\n",
*(rt_uint32_t*)hid->buffer,
*(rt_uint32_t*)(&hid->buffer[4])));
#ifdef RT_USING_RTGUI
if(hid->buffer[1]!=0)
{
if(hid->buffer[1]>127)
{
xoffset=(256-hid->buffer[1])*MOUSE_SCALING;
if(emouse.x>xoffset)
{
emouse.x-=xoffset;
}else
{
emouse.x=0;
}
}else
{
xoffset=(hid->buffer[1])*MOUSE_SCALING;
if((emouse.x+xoffset)<480)
{
emouse.x+=xoffset;
}else
{
emouse.x=480;
}
}
}
if(hid->buffer[2]!=0)
{
if(hid->buffer[2]>127)
{
yoffset=(256-hid->buffer[2])*MOUSE_SCALING;
if(emouse.y>yoffset)
{
emouse.y-=yoffset;
}else
{
emouse.y=0;
}
}else
{
yoffset=hid->buffer[2]*MOUSE_SCALING;
if(emouse.y+yoffset<272)
{
emouse.y+=yoffset;
}else
{
emouse.y=272;
}
}
}
if(xoffset!=0||yoffset!=0)
{
cursor_set_position(emouse.x,emouse.y);
}
if(hid->buffer[0]&LKEY_PRESS)
{
if(lkey_down==RT_FALSE){
// rt_kprintf("mouse left key press down\n");
emouse.button = (RTGUI_MOUSE_BUTTON_LEFT | RTGUI_MOUSE_BUTTON_DOWN);
rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse));
lkey_down=RT_TRUE;
}
}else if(lkey_down==RT_TRUE)
{
// rt_kprintf("mouse left key press up\n");
emouse.button = (RTGUI_MOUSE_BUTTON_LEFT | RTGUI_MOUSE_BUTTON_UP);
rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse));
lkey_down=RT_FALSE;
}
#endif
return RT_EOK;
}
static rt_err_t rt_usbh_hid_mouse_init(void* arg)
{
struct uintf* intf = (struct uintf*)arg;
RT_ASSERT(intf != RT_NULL);
rt_usbh_hid_set_protocal(intf, 0);
rt_usbh_hid_set_idle(intf, 10, 0);
RT_DEBUG_LOG(RT_DEBUG_USB, ("start usb mouse\n"));
#ifdef RT_USING_RTGUI
RTGUI_EVENT_MOUSE_BUTTON_INIT(&emouse);
emouse.wid = RT_NULL;
cursor_display(RT_TRUE);
#endif
return RT_EOK;
}
/**
* This function will define the hid mouse protocal, it will be register to the protocal list.
*
* @return the keyboard protocal structure.
*/
uprotocal_t rt_usbh_hid_protocal_mouse(void)
{
mouse_protocal.pro_id = USB_HID_MOUSE;
mouse_protocal.init = rt_usbh_hid_mouse_init;
mouse_protocal.callback = rt_usbh_hid_mouse_callback;
return &mouse_protocal;
}
#endif
components/drivers/usb/usbhost/core/core.c
+22 -22
View File
@@ -234,10 +234,10 @@ rt_err_t rt_usbh_detach_instance(uinst_t device)
}
/**
* This function will do USB_REQ_GET_DESCRIPTO' request for the usb device instance,
* This function will do USB_REQ_GET_DESCRIPTO' bRequest for the usb device instance,
*
* @param device the usb device instance.
* @param type the type of descriptor request.
* @param type the type of descriptor bRequest.
* @param buffer the data buffer to save requested data
* @param nbytes the size of buffer
*
@@ -253,10 +253,10 @@ rt_err_t rt_usbh_get_descriptor(uinst_t device, rt_uint8_t type, void* buffer,
setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_STANDARD |
USB_REQ_TYPE_DEVICE;
setup.request = USB_REQ_GET_DESCRIPTOR;
setup.index = 0;
setup.length = nbytes;
setup.value = type << 8;
setup.bRequest = USB_REQ_GET_DESCRIPTOR;
setup.wIndex = 0;
setup.wLength = nbytes;
setup.wValue = type << 8;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, nbytes,
timeout) != nbytes) return -RT_EIO;
@@ -281,10 +281,10 @@ rt_err_t rt_usbh_set_address(uinst_t device)
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD |
USB_REQ_TYPE_DEVICE;
setup.request = USB_REQ_SET_ADDRESS;
setup.index = 0;
setup.length = 0;
setup.value = device->index;
setup.bRequest = USB_REQ_SET_ADDRESS;
setup.wIndex = 0;
setup.wLength = 0;
setup.wValue = device->index;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0,
timeout) != 0) return -RT_EIO;
@@ -314,10 +314,10 @@ rt_err_t rt_usbh_set_configure(uinst_t device, int config)
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD |
USB_REQ_TYPE_DEVICE;
setup.request = USB_REQ_SET_CONFIGURATION;
setup.index = 0;
setup.length = 0;
setup.value = config;
setup.bRequest = USB_REQ_SET_CONFIGURATION;
setup.wIndex = 0;
setup.wLength = 0;
setup.wValue = config;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0,
timeout) != 0) return -RT_EIO;
@@ -343,10 +343,10 @@ rt_err_t rt_usbh_set_interface(uinst_t device, int intf)
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD |
USB_REQ_TYPE_INTERFACE;
setup.request = USB_REQ_SET_INTERFACE;
setup.index = 0;
setup.length = 0;
setup.value = intf;
setup.bRequest = USB_REQ_SET_INTERFACE;
setup.wIndex = 0;
setup.wLength = 0;
setup.wValue = intf;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0,
timeout) != 0) return -RT_EIO;
@@ -372,10 +372,10 @@ rt_err_t rt_usbh_clear_feature(uinst_t device, int endpoint, int feature)
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_STANDARD |
USB_REQ_TYPE_ENDPOINT;
setup.request = USB_REQ_CLEAR_FEATURE;
setup.index = endpoint;
setup.length = 0;
setup.value = feature;
setup.bRequest = USB_REQ_CLEAR_FEATURE;
setup.wIndex = endpoint;
setup.wLength = 0;
setup.wValue = feature;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0,
timeout) != 0) return -RT_EIO;
components/drivers/usb/usbhost/core/driver.c
+1 -1
View File
@@ -24,7 +24,7 @@
#include <rtthread.h>
#include <rtservice.h>
#include <rtdevice.h>
#include <drivers/usb_host.h>
static rt_list_t _driver_list;
components/drivers/usb/usbhost/core/hub.c
+26 -26
View File
@@ -31,7 +31,7 @@ static struct rt_messagequeue *usb_mq;
static struct uclass_driver hub_driver;
/**
* This function will do USB_REQ_GET_DESCRIPTOR request for the device instance
* This function will do USB_REQ_GET_DESCRIPTOR bRequest for the device instance
* to get usb hub descriptor.
*
* @param intf the interface instance.
@@ -51,10 +51,10 @@ rt_err_t rt_usbh_hub_get_descriptor(struct uinstance* device, rt_uint8_t *buffer
setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_DEVICE;
setup.request = USB_REQ_GET_DESCRIPTOR;
setup.index = 0;
setup.length = nbytes;
setup.value = USB_DESC_TYPE_HUB << 8;
setup.bRequest = USB_REQ_GET_DESCRIPTOR;
setup.wIndex = 0;
setup.wLength = nbytes;
setup.wValue = USB_DESC_TYPE_HUB << 8;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, nbytes,
timeout) == nbytes) return RT_EOK;
@@ -62,7 +62,7 @@ rt_err_t rt_usbh_hub_get_descriptor(struct uinstance* device, rt_uint8_t *buffer
}
/**
* This function will do USB_REQ_GET_STATUS request for the device instance
* This function will do USB_REQ_GET_STATUS bRequest for the device instance
* to get usb hub status.
*
* @param intf the interface instance.
@@ -81,10 +81,10 @@ rt_err_t rt_usbh_hub_get_status(struct uinstance* device, rt_uint8_t* buffer)
setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_DEVICE;
setup.request = USB_REQ_GET_STATUS;
setup.index = 0;
setup.length = length;
setup.value = 0;
setup.bRequest = USB_REQ_GET_STATUS;
setup.wIndex = 0;
setup.wLength = length;
setup.wValue = 0;
if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, buffer, length,
timeout) == length) return RT_EOK;
@@ -92,7 +92,7 @@ rt_err_t rt_usbh_hub_get_status(struct uinstance* device, rt_uint8_t* buffer)
}
/**
* This function will do USB_REQ_GET_STATUS request for the device instance
* This function will do USB_REQ_GET_STATUS bRequest for the device instance
* to get hub port status.
*
* @param intf the interface instance.
@@ -121,10 +121,10 @@ rt_err_t rt_usbh_hub_get_port_status(uhub_t hub, rt_uint16_t port,
setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_OTHER;
setup.request = USB_REQ_GET_STATUS;
setup.index = port;
setup.length = 4;
setup.value = 0;
setup.bRequest = USB_REQ_GET_STATUS;
setup.wIndex = port;
setup.wLength = 4;
setup.wValue = 0;
if(rt_usb_hcd_control_xfer(hub->hcd, hub->self, &setup, buffer,
length, timeout) == timeout) return RT_EOK;
@@ -132,7 +132,7 @@ rt_err_t rt_usbh_hub_get_port_status(uhub_t hub, rt_uint16_t port,
}
/**
* This function will do USB_REQ_CLEAR_FEATURE request for the device instance
* This function will do USB_REQ_CLEAR_FEATURE bRequest for the device instance
* to clear feature of the hub port.
*
* @param intf the interface instance.
@@ -160,10 +160,10 @@ rt_err_t rt_usbh_hub_clear_port_feature(uhub_t hub, rt_uint16_t port,
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_OTHER;
setup.request = USB_REQ_CLEAR_FEATURE;
setup.index = port;
setup.length = 0;
setup.value = feature;
setup.bRequest = USB_REQ_CLEAR_FEATURE;
setup.wIndex = port;
setup.wLength = 0;
setup.wValue = feature;
if(rt_usb_hcd_control_xfer(hub->hcd, hub->self, &setup, RT_NULL, 0,
timeout) == 0) return RT_EOK;
@@ -171,7 +171,7 @@ rt_err_t rt_usbh_hub_clear_port_feature(uhub_t hub, rt_uint16_t port,
}
/**
* This function will do USB_REQ_SET_FEATURE request for the device instance
* This function will do USB_REQ_SET_FEATURE bRequest for the device instance
* to set feature of the hub port.
*
* @param intf the interface instance.
@@ -199,10 +199,10 @@ rt_err_t rt_usbh_hub_set_port_feature(uhub_t hub, rt_uint16_t port,
setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_CLASS |
USB_REQ_TYPE_OTHER;
setup.request = USB_REQ_SET_FEATURE;
setup.index = port;
setup.length = 0;
setup.value = feature;
setup.bRequest = USB_REQ_SET_FEATURE;
setup.wIndex = port;
setup.wLength = 0;
setup.wValue = feature;
if(rt_usb_hcd_control_xfer(hub->hcd, hub->self, &setup, RT_NULL, 0,
timeout) == 0) return RT_EOK;
@@ -561,7 +561,7 @@ static void rt_usbh_hub_thread_entry(void* parameter)
if(rt_mq_recv(usb_mq, &msg, sizeof(struct uhost_msg), RT_WAITING_FOREVER)
!= RT_EOK ) continue;
RT_DEBUG_LOG(RT_DEBUG_USB, ("msg type %d\n", msg.type));
//RT_DEBUG_LOG(RT_DEBUG_USB, ("msg type %d\n", msg.type));
switch (msg.type)
{