USB
USB 驱动主要实现设备驱动的底层细节，并为上层提供一套标准的 API 接口以供使用。USB模块主要特性如下：
- Complies with USB 2.0 Specification
- Supports High-Speed (HS, 480-Mbps), Full-Speed (FS, 12-Mbps), and Low-Speed (LS, 1.5-Mbps) in Host mode
- Supports High-Speed (HS, 480 Mbps), Full-Speed (FS, 12 Mbps) in Device mode
- Supports the UTMI+ Level 3 interface. The 8-bit bidirectional data buses are used
- Supports bi-directional endpoint0 for Control transfer
- Supports up to 8 User-Configurable Endpoints for Bulk, Isochronous and Interrupt bi-directional transfers (Endpoint1, Endpoint2, Endpoint3, Endpoint4)
- Supports up to (4KB+64Bytes) FIFO for EPs (Including EP0)
- Supports High-Bandwidth Isochronous & Interrupt transfers
- Automated splitting/combining of packets for Bulk transfers
- Supports point-to-point and point-to-multipoint transfer in both Host and Peripheral mode
- Includes automatic ping capabilities
- Soft connect/disconnect function
- Performs all transaction scheduling in hardware
- Power Optimization and Power Management capabilities
- Includes interface to an external Normal DMA controller for every Eps
模块配置
R128 仅有一个 USB，HAL 驱动支持两个及以上 USB 外设，故部分配置为空。
Kernel Setup --->
Drivers Setup --->
SoC HAL Drivers --->
USB devices --->
[*] enable USB driver
[*] USB HOST --->
[*] Support usb host ehci0 # USB0 配置
[*] Support usb host ohci0
[ ] Support usb host ehci1 # USB1 配置
[ ] Support usb host ohci1
[*] Mass Storage support
[*] USB CD support
[ ] Carplay host support
[ ] UVC support
[ ] HID support
[*] USB DEVICE --->
[ ] enable dma for udc driver
[*] Support usb gadget driver
usb gadget driver (adb gadget driver) --->
(X) adb gadget driver
( ) mtp gadget driver
( ) uac gadget driver
( ) ncm gadget driver
( ) msc gadget driver
[*] USB MANAGER
源码结构
.
├── Kconfig
├── Makefile
├── common # 公共操作
│ ├── Makefile
│ ├── list_head_ext.c
│ ├── list_head_ext.h
│ ├── usb_init.c
│ ├── usb_init.h
│ ├── usb_phy.c
│ └── usb_phy.h
├── core # USB 核心驱动
│ ├── Makefile
│ ├── urb.c
│ ├── urb.h
│ ├── usb_core_base.c
│ ├── usb_core_base.h
│ ├── usb_core_config.c
│ ├── usb_core_config.h
│ ├── usb_core_init.c
│ ├── usb_core_init.h
│ ├── usb_core_interface.c
│ ├── usb_core_interface.h
│ ├── usb_driver_init.c
│ ├── usb_driver_init.h
│ ├── usb_gen_hcd.c
│ ├── usb_gen_hcd.h
│ ├── usb_gen_hcd_rh.c
│ ├── usb_gen_hcd_rh.h
│ ├── usb_gen_hub.c
│ ├── usb_gen_hub.h
│ ├── usb_gen_hub_base.c
│ ├── usb_gen_hub_base.h
│ ├── usb_msg.c
│ ├── usb_msg.h
│ ├── usb_msg_base.c
│ ├── usb_msg_base.h
│ ├── usb_virt_bus.c
│ └── usb_virt_bus.h
├── gadget # gadget 相关实现
│ ├── Makefile
│ ├── function
│ │ ├── adb.c
│ │ ├── msc
│ │ │ ├── msc.c
│ │ │ ├── scsi.c
│ │ │ ├── scsi.h
│ │ │ ├── usb_slave_msc.c
│ │ │ └── usb_slave_msc.h
│ │ ├── mtp.c
│ │ └── uac.c
│ ├── gadget.c
│ ├── gadget.h
│ └── gadget_hal.c
├── hid # hid 相关实现
│ ├── Class
│ │ ├── Hid.c
│ │ ├── HidProtocol.c
│ │ ├── HidProtocol.h
│ │ ├── HidTransport.c
│ │ ├── HidTransport.h
│ │ └── Makefile
│ ├── Client
│ │ ├── KeyBoard
│ │ │ ├── KeyBoard.c
│ │ │ ├── KeyBoard.h
│ │ │ └── Makefile
│ │ ├── Makefile
│ │ ├── Mouse
│ │ │ ├── Makefile
│ │ │ ├── UsbMouse.c
│ │ │ ├── UsbMouse.h
│ │ │ ├── UsbMouse_DriftControl.c
│ │ │ └── UsbMouse_DriftControl.h
│ │ └── misc_lib.c
│ ├── Include
│ │ ├── Hid.h
│ │ ├── HidFunDrv.h
│ │ ├── HidSpec.h
│ │ ├── Hid_i.h
│ │ └── misc_lib.h
│ └── Makefile
├── host # Host 驱动
│ ├── Makefile
│ ├── ehci-hcd.c
│ ├── ehci-hub.c
│ ├── ehci-mem.c
│ ├── ehci-q.c
│ ├── ehci-sched.c
│ ├── ehci-sunxi.c
│ ├── ehci-timer.c
│ ├── ehci.h
│ ├── hci_hal.c
│ ├── ohci-hcd.c
│ ├── ohci-hub.c
│ ├── ohci-mem.c
│ ├── ohci-q.c
│ ├── ohci-sunxi.c
│ ├── ohci.h
│ ├── sunxi-hci.c
│ └── sunxi-hci.h
├── include
│ ├── audio.h
│ ├── bitops.h
│ ├── ch11.h
│ ├── ch9.h
│ ├── ehci_def.h
│ ├── endian.h
│ ├── error.h
│ ├── hcd.h
│ ├── mod_devicetable.h
│ ├── mod_usbhost.h
│ ├── storage.h
│ ├── usb.h
│ ├── usb_list.h
│ ├── usb_melis.h
│ ├── usb_os_platform.h
│ └── usb_rtos.h
├── manager # usb 管理类
│ ├── Makefile
│ ├── sunxi_usb_board.h
│ ├── usb_hw_scan.c
│ ├── usb_hw_scan.h
│ ├── usb_manager.c
│ ├── usb_manager_common.h
│ ├── usb_msg_center.c
│ └── usb_msg_center.h
├── platform # 芯片平台寄存器定义
│ ├── sun20iw2
│ │ ├── Makefile
│ │ ├── usb_sun20iw2.c
│ │ └── usb_sun20iw2.h
. . .
. . .
. . .
├── storage # 存储器相关实现
│ ├── Class
│ │ ├── Makefile
│ │ ├── mscProtocol.c
│ │ ├── mscProtocol.h
│ │ ├── mscTransport.c
│ │ ├── mscTransport.h
│ │ ├── mscTransport_i.c
│ │ ├── msc_common.h
│ │ └── usb_msc.c
│ ├── Disk
│ │ ├── BlkDev.c
│ │ ├── BlkDev.h
│ │ ├── CD.c
│ │ ├── CD.h
│ │ ├── Disk.c
│ │ ├── LunMgr.c
│ │ ├── LunMgr_i.h
│ │ ├── Makefile
│ │ └── Scsi2.c
│ ├── Kconfig
│ ├── Makefile
│ ├── Misc
│ │ ├── Makefile
│ │ ├── usbh_buff_manager.c
│ │ ├── usbh_disk_info.c
│ │ └── usbh_disk_remove_time.c
│ └── include
│ ├── LunMgr.h
│ ├── Scsi2.h
│ ├── usb_msc.h
│ ├── usb_msc_i.h
│ ├── usbh_buff_manager.h
│ ├── usbh_disk_info.h
│ └── usbh_disk_remove_time.h
├── udc # UDC 实现
│ ├── Makefile
│ ├── udc.c
│ ├── udc.h
│ ├── udc_hal.c
│ ├── udc_platform.h
│ ├── usb_dma.c
│ └── usb_dma.h
└── uvc # UVC 实现
├── Class
│ ├── Makefile
│ ├── uvc.c
│ ├── uvc_driver.c
│ ├── uvc_driver.h
│ ├── uvc_v4l2.c
│ ├── uvc_video.c
│ └── uvc_video.h
├── Include
│ ├── UVC.h
│ ├── assessibility.h
│ ├── uvcvideo.h
│ ├── video.h
│ └── videodev2.h
├── Makefile
├── Misc
│ ├── Makefile
│ └── assessibility.c
├── Webcam
│ ├── Makefile
│ ├── usbWebcam.c
│ ├── usbWebcam.h
│ ├── usbWebcam_proc.c
│ └── usbWebcam_proc.h
└── drv_webcam
├── Makefile
├── dev_cfg
│ ├── webcam_dev.c
│ └── webcam_dev_i.h
├── drv_webcam.c
├── drv_webcam.h
├── drv_webcam_i.h
├── fb.h
└── webcam_core
├── dev_webcam.c
├── dev_webcam_i.h
├── webcam_linklist_manager.c
└── webcam_linklist_manager.h
模块接口说明
头文件
#include <sunxi_hal_usb.h>
#include <usb_os_platform.h>
UDC 回调事件结构体
typedef enum {
UDC_EVENT_RX_STANDARD_REQUEST = 1,
UDC_EVENT_RX_CLASS_REQUEST = 2,
UDC_EVENT_RX_DATA = 3,
UDC_EVENT_TX_COMPLETE = 4,
} udc_callback_event_t;
### UDC 错误返回枚举
typedef enum {
UDC_ERRNO_SUCCESS = 0,
UDC_ERRNO_CMD_NOT_SUPPORTED = -1,
UDC_ERRNO_CMD_INVALID = -2,
UDC_ERRNO_BUF_NULL = -3,
UDC_ERRNO_BUF_FULL = -4,
UDC_ERRNO_EP_INVALID = -5,
UDC_ERRNO_RX_NOT_READY = -6,
UDC_ERRNO_TX_BUSY = -7,
} udc_errno_t;
USB 驱动初始化
函数原型
void sunxi_usb_init(void);
参数：
- 无
返回值：
- 无
USB HOST 初始化
函数原型
int hal_usb_core_init(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB HOST 去初始化
函数原型
int hal_usb_core_exit(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB HOST 加载所有主机驱动（除了0）
函数原型
int hal_usb_hci_init(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB HOST 去加载所有主机驱动（除了0）
函数原型
int hal_usb_hci_deinit(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB HOST 加载指定主机驱动
函数原型
int hal_usb_hcd_init(int hci_num);
参数：
- hci_num：指定主机驱动
返回值：
- 0：成功
- 负数：失败
USB HOST 去加载指定主机驱动
函数原型
int hal_usb_hcd_deinit(int hci_num);
参数：
- hci_num：指定主机驱动
返回值：
- 0：成功
- 负数：失败
USB HOST PHY 区域显示
函数原型
void hal_hci_phy_range_show(int hci_num);
参数：
- hci_num：指定主机驱动
返回值：
- 无
USB HOST PHY 配置区域
函数原型
void hal_hci_phy_range_set(int hci_num, int val);
参数：
- hci_num：指定主机驱动
- val：配置的值
返回值：
- 无
USB HOST 显示驱动能力
函数原型
void hal_hci_driverlevel_show(int hci_num);
参数：
- hci_num：指定主机驱动
返回值：
- 无
USB HOST 配置驱动能力
函数原型
void hal_hci_driverlevel_adjust(int hci_num, int driverlevel);
参数：
- hci_num：指定主机驱动
- driverlevel：配置的驱动能力
返回值：
- 无
USB HOST 眼图测试
函数原型
void hal_hci_ed_test(int hci_num, const char *buf, unsigned int count);
参数：
- hci_num：指定主机驱动
- buf：传输的数据
- count：数据长度
返回值：
- 无
USB UDC 初始化
函数原型
int32_t hal_udc_init(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB UDC 去初始化
函数原型
int32_t hal_udc_deinit(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB UDC EP 读操作
函数原型
int32_t hal_udc_ep_read(uint8_t ep_addr, void *buf, uint32_t len);
参数：
- ep_addr：ep地址
- buf：读取的数据指针
- len：读取长度
返回值：
- 0：成功
- 负数：失败
USB UDC EP 写操作
函数原型
int32_t hal_udc_ep_write(uint8_t ep_addr, void *buf , uint32_t len);
参数：
- ep_addr：ep地址
- buf：读取的数据指针
- len：读取长度
返回值：
- 0：成功
- 负数：失败
USB UDC 初始化设备描述符
函数原型
void hal_udc_device_desc_init(void *device_desc);
参数：
- device_desc：设备描述符数据
返回值：
- 无
USB UDC 配置描述符初始化
函数原型
void hal_udc_config_desc_init(void *config_desc, uint32_t len);
参数：
- config_desc：配置描述符指针
- len：长度
返回值：
- 无
USB UDC 字符串描述符初始化
函数原型
void hal_udc_string_desc_init(const void *string_desc);
参数：
- string_desc：配置字符串描述符的指针
返回值：
- 无
USB UDC 注册回调函数
函数原型
void hal_udc_register_callback(udc_callback_t user_callback);
参数：
- user_callback：回调函数
返回值：
- 无
USB UDC 禁用 EP
函数原型
void hal_udc_ep_disable(uint8_t ep_addr);
参数：
- ep_addr：地址
返回值：
- 无
USB UDC 启用 EP
函数原型
void hal_udc_ep_enable(uint8_t ep_addr, uint16_t maxpacket, uint32_t ts_type);
参数：
- ep_addr：地址
- maxpacket：最大包大小
- ts_type：模式
返回值：
- 无
USB UDC 设置 EP 发送/接收 buffer
函数原型
void hal_udc_ep_set_buf(uint8_t ep_addr, void *buf, uint32_t len);
参数：
- ep_addr：地址
- buf：buf的指针
- len：buf的长度
返回值：
- 无
USB UDC 显示驱动能力
函数原型
void hal_udc_driverlevel_show(void);
参数：
- 无
返回值：
- 无
USB UDC 调整驱动能力
函数原型
void hal_udc_driverlevel_adjust(int driverlevel);
参数：
- driverlevel：驱动能力
返回值：
- 无
USB UDC 显示范围
函数原型
void hal_udc_phy_range_show(int usbc_num);
参数：
- usbc_num：usb控制器号
返回值：
- 无
USB UDC 配置范围
函数原型
void hal_udc_phy_range_set(int usbc_num, int val);
参数：
- usbc_num：usb控制器号
- val：值
返回值：
- 无
USB UDC 眼图测试
函数原型
void hal_udc_ed_test(const char *buf, size_t count);
参数：
- buf：测试使用的buf
- count：数量
返回值：
- 无
USB Manager 初始化
函数原型
int hal_usb_manager_init(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB Manager 去初始化
函数原型
int hal_usb_manager_deinit(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB Gadget 初始化
函数原型
int hal_gadget_init(void);
参数：
- 无
返回值：
- 0：成功
- 负数：失败
USB Gadget 去初始化
函数原型
void hal_gadget_exit(void);
参数：
- 无
返回值：
- 无
USB Gadget 启用功能
函数原型
int usb_gadget_function_enable(const char *name);
参数：
- name：功能名
返回值：
- 0：成功
- 负数：失败
USB Gadget 禁用功能
函数原型
int usb_gadget_function_disable(const char *name);
参数：
- name：功能名
返回值：
- 0：成功
- 负数：失败
USB Gadget 读取
函数原型
int usb_gadget_function_read(int ep_idx, char *buf, int size);
参数：
- ep_idx：端点号
- buf：buf指针
- size：buf的大小
返回值：
- 0：成功
- 负数：失败
USB Gadget 限时读取
函数原型
int usb_gadget_function_read_timeout(int ep_idx, char *buf, int size, int ms);
参数：
- ep_idx：端点号
- buf：buf指针
- size：buf的大小
- ms：超时时间
返回值：
- 0：成功
- 负数：失败
USB Gadget 写数据
函数原型
int usb_gadget_function_write(int ep_idx, char *buf, int size);
参数：
- ep_idx：端点号
- buf：buf指针
- size：buf的大小
返回值：
- 0：成功
- 负数：失败
USB Gadget 写字符串
函数原型
int usb_gadget_function_string_set(char *name, char *str, unsigned int idx);
参数：
- name：名称
- str：字符串指针
- idx：端点号
返回值：
- 0：成功
- 负数：失败
模块使用范例
测试用例公共头文件
usb_test.h
#ifndef USB_TEST_H
#define USB_TEST_H
#include <sunxi_hal_usb.h>
#include <usb_os_platform.h>
#ifdef __cplusplus
extern "C" {
#endif
int usb_test_cmd_hci(int argc, const char **argv);
int usb_test_cmd_udc(int argc, const char **argv);
int usb_test_cmd_phy_range(int argc, const char **argv);
int usb_test_cmd_ed_test(int argc, const char **argv);
int usb_test_cmd_debug(int argc, const char **argv);
int usb_test_cmd_uvc(int argc, const char **argv);
int usb_test_is_otg(int port);
int usb_test_get_port(const char *buf, int *port);
void usb_test_show_help(void);
unsigned char usb_core_is_enabled(void);
unsigned char sunxi_ehci_status_get(void);
#ifdef __cplusplus
}
#endif
#endif // USB_TEST_H
HCI 测试实现实现
#include "usb_test.h"
int usb_test_cmd_hci(int argc, const char **argv)
{
int c;
int hci_num = 0;
unsigned int port = 0;
if (argc == 4) {
// insmod/rmmod indicate host driver
if (usb_test_get_port(argv[3], &port))
return 0;
} else if (argc == 3) {
// insmod/rmmod all host driver
port = 0xffff;
} else
return -1;
while ((c = getopt(argc, (char *const *)argv, "ir")) != -1) {
switch (c) {
case 'i':
#ifdef CONFIG_HAL_TEST_UDC
/*otg mode rmmod device driver before insmod hci*/
if (usb_test_is_otg(port)) {
printf("[usb0] rmmod device driver!\n");
hal_gadget_exit();
}
#endif
if (!usb_core_is_enabled())
hal_usb_core_init();
if (port == 0xffff)
for (hci_num = 0; hci_num < USB_MAX_CONTROLLER_COUNT; hci_num++)
hal_usb_hcd_init(hci_num);
else
hal_usb_hcd_init(port);
break;
case 'r':
if (port == 0xffff)
for (hci_num = 0; hci_num < USB_MAX_CONTROLLER_COUNT; hci_num++)
hal_usb_hcd_deinit(hci_num);
else
hal_usb_hcd_deinit(port);
if (usb_core_is_enabled() && !sunxi_ehci_status_get())
hal_usb_core_exit();
break;
default:
printf("ERR: insmod/rmmod error!\n");
usb_test_show_help();
break;
}
}
return 0;
}
int usb_test_cmd_debug(int argc, const char **argv)
{
int enable = 0;
if (argc != 3)
return -1;
enable = atoi(argv[2]);
if (enable == 1 || enable == 0) {
hal_usb_hcd_debug_set(enable);
printf("USB debug %s!\n", hal_usb_hcd_debug_get() ? "open" : "close");
return 0;
}
return -1;
}
MSG 测试用例实现
#include <inttypes.h>
#include "usb.h"
#include "ch9.h"
#include "storage.h"
#include "usb_os_platform.h"
struct usb_msg_dev {
uint8_t max_lun;
uint8_t cbw[32];
};
static struct usb_device_descriptor demo_device_desc = {
.bLength = USB_DT_DEVICE_SIZE,
.bDescriptorType = USB_DT_DEVICE,
.bcdUSB = 0x0200,
.bDeviceClass = 0,
.bDeviceSubClass = 0,
.bDeviceProtocol = 0,
.bMaxPacketSize0 = 64,
.idVendor = 0x18d1,
.idProduct = 0x0001,
.bcdDevice = 0x0001,
.iManufacturer = 0x01,
.iProduct = 0x02,
.iSerialNumber = 0x03,
.bNumConfigurations = 1
};
static struct usb_config_descriptor demo_config_desc = {
.bLength = USB_DT_CONFIG_SIZE,
.bDescriptorType = USB_DT_CONFIG,
.wTotalLength = 32, /* FIXME */
.bNumInterfaces = 1,
.bConfigurationValue = 1,
.iConfiguration = 0,
.bmAttributes = 0x80,
.bMaxPower = 0x64 /* 200mA */
};
static struct usb_interface_descriptor demo_intf_desc = {
.bLength = USB_DT_INTERFACE_SIZE,
.bDescriptorType = USB_DT_INTERFACE,
.bInterfaceNumber = 0x0,
.bAlternateSetting = 0x0,
.bNumEndpoints = 2,
.bInterfaceClass = 0x08, /* Mass Storage class */
.bInterfaceSubClass = 0x06, /* SCSI Transparent Subclass */
.bInterfaceProtocol = 0x50, /* Bulk-Only Protocol */
.iInterface = 0
};
static struct usb_endpoint_descriptor demo_ep_bulk_out = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = 0x1 | USB_DIR_OUT,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = 0x0200, /* 512 Bytes */
.bInterval = 0
};
static struct usb_endpoint_descriptor demo_ep_bulk_in = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = 0x1 | USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = 0x0200, /* 512 Bytes */
.bInterval = 0
};
/*
* String descriptors
*/
static const uint16_t g_str_lang_id[] = {
0x0304, 0x0409
};
static const uint16_t g_str_manufacturer[] = {
0x030e, 'G', 'o', 'o', 'g', 'l', 'e'
};
static const uint16_t g_str_product[] = {
0x0308, 'M', 's', 'g'
};
static const uint16_t g_str_serialnumber[] = {
0x0314, '2', '0', '0', '8', '0', '4', '1', '1'
};
struct usb_msg_dev g_msg_dev = {
.max_lun = 0,
};
static void *g_config_desc = NULL;
void usb_msg_desc_init(void)
{
uint32_t config_desc_len;
void *buf;
config_desc_len = demo_config_desc.bLength + demo_intf_desc.bLength
+ demo_ep_bulk_out.bLength + demo_ep_bulk_in.bLength;
g_config_desc = malloc(config_desc_len);
/* compose configuation, interface and endpoint descriptors */
buf = g_config_desc;
memcpy(buf, &demo_config_desc, demo_config_desc.bLength);
buf += demo_config_desc.bLength;
memcpy(buf, &demo_intf_desc, demo_intf_desc.bLength);
buf += demo_intf_desc.bLength;
memcpy(buf, &demo_ep_bulk_out, demo_ep_bulk_out.bLength);
buf += demo_ep_bulk_out.bLength;
memcpy(buf, &demo_ep_bulk_in, demo_ep_bulk_in.bLength);
hal_udc_device_desc_init(&demo_device_desc);
hal_udc_config_desc_init(g_config_desc, config_desc_len);
/* FIXME: string descriptors must be initialized in the following order now */
hal_udc_string_desc_init(g_str_lang_id);
hal_udc_string_desc_init(g_str_manufacturer);
hal_udc_string_desc_init(g_str_product);
hal_udc_string_desc_init(g_str_serialnumber);
}
static void usb_msg_ep_init(void)
{
hal_log_info("usb demo ep init...\n");
/* init bulk-in ep */
hal_udc_ep_enable(demo_ep_bulk_in.bEndpointAddress,
demo_ep_bulk_in.wMaxPacketSize,
demo_ep_bulk_in.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
/* initialise bulk-out ep buf in order to get the first CBW */
hal_udc_ep_set_buf(demo_ep_bulk_out.bEndpointAddress,
g_msg_dev.cbw,
sizeof(g_msg_dev.cbw));
/* init bulk-out ep */
hal_udc_ep_enable(demo_ep_bulk_out.bEndpointAddress,
demo_ep_bulk_out.wMaxPacketSize,
demo_ep_bulk_out.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
}
static udc_errno_t usb_msg_class_request_handler(struct usb_ctrlrequest *crq)
{
udc_errno_t ret = UDC_ERRNO_SUCCESS;
switch(crq->bRequest) {
case US_BULK_RESET_REQUEST:
/* TODO */
break;
case US_BULK_GET_MAX_LUN:
hal_log_info("get MAX_LUN\r\n");
if (crq->bRequestType !=
(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE)) {
ret = UDC_ERRNO_CMD_INVALID;
break;
}
/* FIXME: a fake response for demo */
hal_udc_ep_write(0, &g_msg_dev.max_lun, sizeof(g_msg_dev.max_lun));
break;
default:
ret = UDC_ERRNO_CMD_INVALID;
break;
}
return ret;
}
static udc_errno_t usb_msg_standard_request_handler(struct usb_ctrlrequest *crq)
{
udc_errno_t ret = UDC_ERRNO_SUCCESS;
switch (crq->bRequest) {
case USB_REQ_SET_CONFIGURATION:
/* FIXME: usb msg driver should be independent of demo code */
usb_msg_ep_init();
break;
default:
ret = UDC_ERRNO_CMD_INVALID;
break;
}
return ret;
}
static udc_errno_t usb_msg_scsi_cmd_handler(struct bulk_cb_wrap *cbw)
{
udc_errno_t ret = UDC_ERRNO_SUCCESS;
uint8_t opcode = cbw->CDB[0];
uint8_t fake_rsp[36] = {0x00, 0x80, 0x02, 0x02, 0x1F, 0x00, 0x00,
0x00, 0x54, 0x69, 0x6e, 0x61, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20};
hal_log_info("scsi cmd opcode: 0x%x\n", opcode);
switch (opcode) {
case 0x12: /* INQUIRY */
/* FIXME: a fake response for demo */
hal_udc_ep_write(demo_ep_bulk_in.bEndpointAddress, fake_rsp, sizeof(fake_rsp));
break;
default:
ret = UDC_ERRNO_CMD_INVALID;
break;
}
return ret;
}
udc_errno_t usb_msg_callback(uint8_t ep_addr, udc_callback_event_t event, void *data, uint32_t len)
{
uint8_t ep_idx;
uint8_t is_in;
udc_errno_t ret = UDC_ERRNO_SUCCESS;
struct usb_ctrlrequest *crq;
struct bulk_cb_wrap *cbw;
hal_log_info("usb_msg_callback event: %"PRIu32", len: %"PRIu32"\n", event, len);
ep_idx = ep_addr & 0x7f;
is_in = ep_addr & USB_DIR_IN;
if (ep_idx == 0) { /* handle ep0 */
crq = (struct usb_ctrlrequest *)data;
switch (event) {
case UDC_EVENT_RX_STANDARD_REQUEST:
ret = usb_msg_standard_request_handler(crq);
break;
case UDC_EVENT_RX_CLASS_REQUEST:
ret = usb_msg_class_request_handler(crq);
break;
default:
ret = UDC_ERRNO_CMD_NOT_SUPPORTED;
break;
}
} else { /* handle ep1~4 */
if (is_in) {
/* TODO: maybe useless? */
} else {
cbw = (struct bulk_cb_wrap *)data;
switch (event) {
case UDC_EVENT_RX_DATA:
usb_msg_scsi_cmd_handler(cbw);
break;
default:
ret = UDC_ERRNO_CMD_NOT_SUPPORTED;
break;
}
}
}
return ret;
}
PHY 驱动测试实现
#include "usb_test.h"
static void __usb_ed_test(int port, const char *buf)
{
if (usb_test_is_otg(port)) { /*otg mode*/
#ifdef CONFIG_HAL_TEST_UDC
hal_udc_ed_test(buf, strlen(buf));
#else
printf("ERR: udc config not find!\n");
#endif
} else {
#ifdef CONFIG_HAL_TEST_HCI
hal_hci_ed_test(port, buf, strlen(buf));
#else
printf("ERR: hci config not find!\n");
#endif
}
}
static void __phy_range_set(int port, int val)
{
if (usb_test_is_otg(port)) { /*otg mode*/
#ifdef CONFIG_HAL_TEST_UDC
hal_udc_phy_range_set(port, val);
#else
printf("ERR: udc config not find!\n");
#endif
} else {
#ifdef CONFIG_HAL_TEST_HCI
hal_hci_phy_range_set(port, val);
#else
printf("ERR: hci config not find!\n");
#endif
}
}
static void __phy_range_show(int port)
{
if (usb_test_is_otg(port)) { /*otg mode*/
#ifdef CONFIG_HAL_TEST_UDC
hal_udc_phy_range_show(port);
#else
printf("ERR: udc config not find!\n");
#endif
} else {
#ifdef CONFIG_HAL_TEST_HCI
hal_hci_phy_range_show(port);
#else
printf("ERR: hci config not find!\n");
#endif
}
}
int usb_test_cmd_ed_test(int argc, const char **argv)
{
int port = 0;
if (argc != 4)
return -1;
if (usb_test_get_port(argv[2], &port))
return 0;
__usb_ed_test(port, argv[3]);
return 0;
}
int usb_test_cmd_phy_range(int argc, const char **argv)
{
int c;
int val;
int port;
if ((argc != 4) && (argc != 5))
return -1;
if (usb_test_get_port(argv[3], &port))
return 0;
if (usb_test_is_otg(port)) {
printf("\nOTG%d phy range\n", port);
} else
printf("\nEHCI%d phy range\n", port);
while ((c = getopt(argc, (char *const *)argv, "sg")) != -1) {
switch (c) {
case 's':
if(argc == 5)
val = strtol(argv[4], NULL, 16);
else
return -1;
__phy_range_set(port, val);
break;
case 'g':
__phy_range_show(port);
break;
default:
printf("ERR: phy_range cmd error!\n");
usb_test_show_help();
break;
}
}
return 0;
}
USB UDC 测试用例实现
#include "usb_test.h"
int usb_test_cmd_udc(int argc, const char **argv)
{
int c;
if ((argc != 3) && (argc != 4))
return -1;
while ((c = getopt(argc, (char *const *)argv, "ir")) != -1) {
switch (c) {
case 'i':
#ifdef CONFIG_HAL_TEST_HCI
// rmmod host driver before insmod otg
if (usb_test_is_otg(0) == 0) /*hci mode*/
hal_usb_hcd_deinit(0);
#endif
printf("[usb0] insmod device driver!\n");
hal_gadget_init();
break;
case 'r':
printf("[usb0] rmmod device driver!\n");
hal_gadget_exit();
break;
default:
printf("err: insmod/rmmod error!\n");
usb_test_show_help();
break;
}
}
return 0;
}
### USB UVC 测试用例实现
#include <sys/ioctl.h>
#include <fcntl.h>
#include "usb_test.h"
#include "uvcvideo.h"
static int save_frame_to_file(void *str, void *start, int length)
{
FILE *fp = NULL;
fp = fopen(str, "wb+"); //save more frames
if (!fp) {
printf(" Open %s error\n", (char *)str);
return -1;
}
if (fwrite(start, length, 1, fp)) {
fclose(fp);
return 0;
} else {
printf(" Write file fail (%s)\n", strerror(errno));
fclose(fp);
return -1;
}
return 0;
}
int usb_test_cmd_uvc(int argc, const char **argv)
{
int fd;
struct v4l2_capability cap; /* Query device capabilities */
struct v4l2_streamparm parms; /* set streaming parameters */
struct v4l2_format fmt; /* try a format */
struct v4l2_requestbuffers req; /* Initiate Memory Mapping or User Pointer I/O */
struct v4l2_buffer buf; /* Query the status of a buffer */
enum v4l2_buf_type type;
int n_buffers;
char source_data_path[64];
int np;
/* 1.open /dev/videoX node */
fd = open("/dev/video", O_RDWR);
/* 2.Query device capabilities */
memset(&cap, 0, sizeof(cap));
if (ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
printf(" Query device capabilities fail!!!\n");
} else {
printf(" Querey device capabilities succeed\n");
printf(" cap.driver=%s\n", cap.driver);
printf(" cap.card=%s\n", cap.card);
printf(" cap.bus_info=%s\n", cap.bus_info);
printf(" cap.version=0x%08x\n", cap.version);
printf(" cap.capabilities=0x%08x\n", cap.capabilities);
}
/* 7.set streaming parameters */
memset(&parms, 0, sizeof(struct v4l2_streamparm));
parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
parms.parm.capture.timeperframe.numerator = 1;
parms.parm.capture.timeperframe.denominator = 30;
if (ioctl(fd, VIDIOC_S_PARM, &parms) < 0) {
printf(" Setting streaming parameters failed, numerator:%d denominator:%d\n",
parms.parm.capture.timeperframe.numerator,
parms.parm.capture.timeperframe.denominator);
close(fd);
return -1;
}
/* 9.set the data format */
memset(&fmt, 0, sizeof(struct v4l2_format));
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = 1280;
fmt.fmt.pix.height = 720;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
printf(" setting the data format failed!\n");
close(fd);
return -1;
}
/* 10.Initiate Memory Mapping or User Pointer I/O */
memset(&req, 0, sizeof(struct v4l2_requestbuffers));
req.count = 3;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
printf(" VIDIOC_REQBUFS failed\n");
close(fd);
return -1;
}
/* 11.Exchange a buffer with the driver */
for (n_buffers = 0; n_buffers < req.count; n_buffers++) {
memset(&buf, 0, sizeof(struct v4l2_buffer));
buf.index = n_buffers;
if (ioctl(fd, VIDIOC_QBUF, &buf) == -1) {
printf(" VIDIOC_QBUF error\n");
close(fd);
return -1;
}
}
/* streamon */
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (ioctl(fd, VIDIOC_STREAMON, &type) == -1) {
printf(" VIDIOC_STREAMON error! %s\n", strerror(errno));
} else
printf(" stream on succeed\n");
np = 0;
while (np < 5) {
printf(" camera capture num is [%d]\n", np);
/* wait uvc frame */
memset(&buf, 0, sizeof(struct v4l2_buffer));
if (ioctl(fd, VIDIOC_DQBUF, &buf) == -1) {
printf(" VIDIOC_DQBUF error\n");
goto EXIT;
} else
printf("*****DQBUF[%d] FINISH*****\n", buf.index);
sprintf(source_data_path, "/data/source_frame_%d.jpg", np);
save_frame_to_file(source_data_path, (void *)buf.mem_buf, buf.length);
if (ioctl(fd, VIDIOC_QBUF, &buf) == -1) {
printf(" VIDIOC_QBUF error\n");
goto EXIT;
} else
printf("************QBUF[%d] FINISH**************\n\n", buf.index);
np++;
}
printf("\n\n Capture thread finish\n");
EXIT:
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ioctl(fd, VIDIOC_STREAMOFF, &type);
memset(&req, 0, sizeof(struct v4l2_requestbuffers));
req.count = 0;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
ioctl(fd, VIDIOC_REQBUFS, &req);
close(fd);
return 0;
}
USB 测试用例
#include "usb_test.h"
void usb_test_show_help(void)
{
printf("\nUsage:\n"\
"\tusb hci {-i|-r} [<port>]\n"\
"\tusb udc {-i|-r} [<port>]\n"\
"\tusb phy_range {-s|-g} {<port>} [<phyrange>]\n"\
"\tusb ed_test {<port>} {<type>}\n"\
"\tusb debug {<status>}\n"\
"\tusb uvc_test\n"\
"\n\t- - - - - - - - - - - - - - - - - - - - -\n"\
"Meaning:\n"\
"\t-i:insmod, -r:rmmod, -s:set, -g:get\n"\
"\n"\
"\tport : [0-%d],port number\n"\
"\tphyrange : [0x0-0x1f],phy range\n"\
"\tstatus : [0-disable,1-enable],hci debug status\n"\
"\ttype : [test_j_state/test_k_state/test_se0_nak/test_pack]--hci & otg\n"\
"\t [test_not_operating/test_force_enable/test_mask]--hci only\n"\
"\n\t==>> More information refer to spec <<==\n",
USB_MAX_CONTROLLER_COUNT - 1);
}
int usb_test_is_otg(int port)
{
#if defined(CONFIG_HAL_TEST_HCI)
if (port == 0 && !(sunxi_ehci_status_get() & 0x1)) /*otg mode*/
#else
if (port == 0)
#endif
return 1;
else
return 0;
}
int usb_test_get_port(const char *buf, int *port)
{
*port = atoi(buf);
if (*port > USB_MAX_CONTROLLER_COUNT - 1) {
printf("ERR: port(%d) choose error! Port range [0-%d]\n", *port,
USB_MAX_CONTROLLER_COUNT - 1);
return -1;
}
return 0;
}
static int usb_test_command_hci(int argc, const char **argv)
{
#if defined(CONFIG_HAL_TEST_HCI)
return usb_test_cmd_hci(argc, argv);
#else
printf("ERR: Can't find command config!\n");
return -1;
#endif
}
static int usb_test_command_udc(int argc, const char **argv)
{
#if defined(CONFIG_HAL_TEST_UDC)
return usb_test_cmd_udc(argc, argv);
#else
printf("ERR: Can't find command config!\n");
return -1;
#endif
}
static int usb_test_command_phy_range(int argc, const char **argv)
{
return usb_test_cmd_phy_range(argc, argv);
}
static int usb_test_command_ed_test(int argc, const char **argv)
{
return usb_test_cmd_ed_test(argc, argv);
}
static int usb_test_command_debug(int argc, const char **argv)
{
#if defined(CONFIG_HAL_TEST_HCI)
return usb_test_cmd_debug(argc, argv);
#else
printf("ERR: Can't find command config!\n");
return -1;
#endif
}
static int usb_test_command_uvc(int argc, const char **argv)
{
#if defined(CONFIG_HAL_TEST_UVC)
// return usb_test_cmd_uvc(argc, argv);
usb_test_cmd_uvc(argc, argv);/* -1 has other meaning in this case*/
return 0;
#else
printf("ERR: Can't find command config!\n");
return -1;
#endif
}
static int usb_test_command(int argc, const char **argv)
{
int ret = -1;
if (argc < 2) {
printf("ERR: command error\n");
usb_test_show_help();
return -1;
}
if (!strcmp(argv[1], "hci"))
ret = usb_test_command_hci(argc, argv);
else if (!strcmp(argv[1], "udc"))
ret = usb_test_command_udc(argc, argv);
else if (!strcmp(argv[1], "phy_range"))
ret = usb_test_command_phy_range(argc, argv);
else if (!strcmp(argv[1], "ed_test"))
ret = usb_test_command_ed_test(argc, argv);
else if (!strcmp(argv[1], "debug"))
ret = usb_test_command_debug(argc, argv);
else if (!strcmp(argv[1], "uvc_test"))
ret = usb_test_command_uvc(argc, argv);
if (ret == 0)
return 0;
usb_test_show_help();
return -1;
}
FINSH_FUNCTION_EXPORT_CMD(usb_test_command, usb, usb tests)