1972 lines
62 KiB
C
1972 lines
62 KiB
C
#include "sys_config.h"
|
|
#include "typesdef.h"
|
|
#include "list.h"
|
|
#include "errno.h"
|
|
#include "dev.h"
|
|
#include "devid.h"
|
|
#include "osal/string.h"
|
|
#include "osal/irq.h"
|
|
#include "osal/semaphore.h"
|
|
#include "osal/mutex.h"
|
|
#include "osal/task.h"
|
|
#include "osal/work.h"
|
|
#include "osal/event.h"
|
|
|
|
#include "hal/usb_device.h"
|
|
#include "hal/gpio.h"
|
|
|
|
#include "dev/usb/hgusb20_v1_dev_api.h"
|
|
#include "dev/usb/uvc_host.h"
|
|
|
|
#define HOST_EP0_BUF p_dev->usb_ep0_rxbuf
|
|
|
|
uint8_t uvc_dat[UVC_HOST_NUM][2048+12] __attribute__((aligned(4)));
|
|
uint8_t usbmic_dat[1024] __attribute__((aligned(4)));
|
|
uint8 uvc_set_addr = 2;
|
|
uint8 hub_set_addr = 11;
|
|
uint8 hub_insert = 0;
|
|
uint8 uvc_head_res = 0;
|
|
|
|
|
|
void delay_us(uint32 n);
|
|
void hgusb20_host_reset_phy(struct hgusb20_dev * p_dev);
|
|
|
|
|
|
void delay_ms(uint32 n)
|
|
{
|
|
//uint32 sys_clk = sys_get_apbclk();//ll_cc_sys_clk_get();
|
|
|
|
if (n) {
|
|
delay_us(n*1000);
|
|
}
|
|
}
|
|
|
|
|
|
//获取描述符
|
|
bool usb_host_get_descriptor(struct hgusb20_dev *p_dev, uint8 desc_type, uint8 desc_index, uint8 *p_buf, uint16 len)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0x80;
|
|
p_dev->usb_ctrl.cmd.request = 0x06; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = ((uint16)desc_type << 8) | desc_index;
|
|
p_dev->usb_ctrl.cmd.index = 0;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
return usb_host_ep0_request(p_dev, p_buf);
|
|
}
|
|
|
|
//接收完剩余数据，发送空包
|
|
bool usb_host_get_descriptor_end_do(struct hgusb20_dev *p_dev)
|
|
{
|
|
while (p_dev->ep0_ptr.rx_len >= p_dev->usb_host.ep0_pkt) { //收完剩余数据
|
|
hgusb20_host_ep0_rx(p_dev, p_dev->usb_ep0_rxbuf, 0);
|
|
}
|
|
if (!p_dev->usb_host.stall) {
|
|
hgusb20_host_ep0_tx(p_dev, NULL, 0); //数据包接收完毕，发送一个空包
|
|
}
|
|
if (p_dev->usb_ctrl.error) {
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//第一次尝试获取设备描述符
|
|
bool usb_host_get_device_descriptor_1_do(struct hgusb20_dev *p_dev)
|
|
{
|
|
p_dev->usb_ctrl.error = 0;
|
|
if (usb_host_get_descriptor(p_dev, DEVICE_DESCRIPTOR, 0, p_dev->usb_ep0_rxbuf, 64)) {
|
|
p_dev->usb_host.ep0_pkt = p_dev->usb_ep0_rxbuf[7]; //Max Pkt
|
|
if (p_dev->usb_host.ep0_pkt != 8 && p_dev->usb_host.ep0_pkt != 16 &&
|
|
p_dev->usb_host.ep0_pkt != 32 && p_dev->usb_host.ep0_pkt != 64) {
|
|
p_dev->usb_ctrl.error = 1;
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//跳过N个ep0的值
|
|
void usb_host_ep0buf_skip_do(struct hgusb20_dev *p_dev, uint8 offset)
|
|
{
|
|
p_dev->ep0_ptr.offset += offset;
|
|
while (p_dev->ep0_ptr.offset >= p_dev->ep0_ptr.rx_len && p_dev->ep0_ptr.rx_len >= p_dev->usb_host.ep0_pkt) {
|
|
p_dev->ep0_ptr.offset -= p_dev->ep0_ptr.rx_len;
|
|
hgusb20_host_ep0_rx(p_dev, p_dev->usb_ep0_rxbuf, 0);
|
|
if (p_dev->ep0_ptr.rx_len == 0) {
|
|
_os_printf("ep0 buf skip err\n");
|
|
//usb_sw->usb_ctrl.error = 1;
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//从EP0_BUF中获取USB的相关信息
|
|
void usb_host_get_info(struct hgusb20_dev *p_dev)
|
|
{
|
|
uint16 vid = get_unaligned_le16(&HOST_EP0_BUF[p_dev->ep0_ptr.offset]); //获取描述符中的相关信息
|
|
uint16 pid = get_unaligned_le16(&HOST_EP0_BUF[p_dev->ep0_ptr.offset + 2]);
|
|
uint16 ver = get_unaligned_le16(&HOST_EP0_BUF[p_dev->ep0_ptr.offset + 4]);
|
|
|
|
//警告消除
|
|
(void)vid;
|
|
(void)pid;
|
|
(void)ver;
|
|
}
|
|
|
|
|
|
//第二次获取设备描述符中的VID PID等产品信息
|
|
bool usb_host_get_device_descriptor_2_do(struct hgusb20_dev *p_dev)
|
|
{
|
|
if (usb_host_get_descriptor(p_dev, DEVICE_DESCRIPTOR, 0, p_dev->usb_ep0_rxbuf, 0x12)) {
|
|
//获取USB的相关信息
|
|
//usb_host_ep0buf_skip_do(p_dev, 8);
|
|
p_dev->ep0_ptr.offset += 8;
|
|
usb_host_get_info(p_dev);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//第一次尝试获取配置描述符
|
|
bool usb_host_get_configuration_descriptor_1(struct hgusb20_dev *p_dev, uint8 cfg_index)
|
|
{
|
|
return usb_host_get_descriptor(p_dev, CONFIGURATION_DESCRIPTOR, cfg_index, p_dev->usb_ep0_rxbuf, 9); //第一次，尝试获取配置描述符
|
|
}
|
|
|
|
//第二次获取配置描述符的Bulk端点信息等
|
|
bool usb_host_get_configuration_descriptor_3(struct hgusb20_dev *p_dev, uint8 cfg_index, uint16 desc_len, uint8* buf)
|
|
{
|
|
if (desc_len < 18) {
|
|
_os_printf("desc_len err\n");
|
|
return FALSE;
|
|
}
|
|
return usb_host_get_descriptor(p_dev, CONFIGURATION_DESCRIPTOR, cfg_index, buf, desc_len);
|
|
}
|
|
|
|
|
|
//设置配置
|
|
bool usb_host_set_configuration(struct hgusb20_dev *p_dev, uint8 cfg_value)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0x00;
|
|
p_dev->usb_ctrl.cmd.request = 0x09; //Set Configuration
|
|
p_dev->usb_ctrl.cmd.value = cfg_value;
|
|
p_dev->usb_ctrl.cmd.index = 0;
|
|
p_dev->usb_ctrl.cmd.length = 0;
|
|
return usb_host_ep0_request(p_dev, NULL);
|
|
}
|
|
|
|
|
|
//设置接口
|
|
bool usb_host_set_interface(struct hgusb20_dev *p_dev, uint8 index, uint8 value)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0x01;
|
|
p_dev->usb_ctrl.cmd.request = 0x0b; //Set Interface
|
|
p_dev->usb_ctrl.cmd.value = value;
|
|
p_dev->usb_ctrl.cmd.index = index;
|
|
p_dev->usb_ctrl.cmd.length = 0;
|
|
return usb_host_ep0_request(p_dev, NULL);
|
|
}
|
|
|
|
//获取描述符
|
|
bool usb_host_uvc_get_info(struct hgusb20_dev *p_dev, uint16 uid, uint16 cs, uint32 len, uint8 *pinf)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa1;
|
|
p_dev->usb_ctrl.cmd.request = UVC_GET_INFO; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = cs;
|
|
p_dev->usb_ctrl.cmd.index = uid;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
|
|
return usb_host_ep0_request(p_dev, pinf);
|
|
}
|
|
|
|
bool usb_host_get_cur(struct hgusb20_dev *p_dev, uint16 uid, uint16 cs, uint32 len, uint8 *pinf)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa1;
|
|
p_dev->usb_ctrl.cmd.request = UVC_GET_CUR; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = cs;
|
|
p_dev->usb_ctrl.cmd.index = uid;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
|
|
return usb_host_ep0_request(p_dev, pinf);
|
|
}
|
|
|
|
bool usb_host_get_min(struct hgusb20_dev *p_dev, uint16 uid, uint16 cs, uint32 len, uint8 *pinf)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa1;
|
|
p_dev->usb_ctrl.cmd.request = UVC_GET_MIN; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = cs;
|
|
p_dev->usb_ctrl.cmd.index = uid;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
return usb_host_ep0_request(p_dev, pinf);
|
|
}
|
|
|
|
bool usb_host_get_max(struct hgusb20_dev *p_dev, uint16 uid, uint16 cs, uint32 len, uint8 *pinf)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa1;
|
|
p_dev->usb_ctrl.cmd.request = UVC_GET_MAX; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = cs;
|
|
p_dev->usb_ctrl.cmd.index = uid;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
return usb_host_ep0_request(p_dev, pinf);
|
|
}
|
|
|
|
bool usb_host_get_res(struct hgusb20_dev *p_dev, uint16 uid, uint16 cs, uint32 len, uint8 *pinf)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa1;
|
|
p_dev->usb_ctrl.cmd.request = UVC_GET_RES; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = cs;
|
|
p_dev->usb_ctrl.cmd.index = uid;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
return usb_host_ep0_request(p_dev, pinf);
|
|
}
|
|
|
|
bool usb_host_get_def(struct hgusb20_dev *p_dev, uint16 uid, uint16 cs, uint32 len, uint8 *pinf)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa1;
|
|
p_dev->usb_ctrl.cmd.request = UVC_GET_DEF; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = cs;
|
|
p_dev->usb_ctrl.cmd.index = uid;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
return usb_host_ep0_request(p_dev, pinf);
|
|
}
|
|
|
|
//获取描述符
|
|
bool usb_host_set_cur(struct hgusb20_dev *p_dev, uint16 uid, uint16 cs, uint32 len, uint8 *pinf)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0x21;
|
|
p_dev->usb_ctrl.cmd.request = UVC_SET_CUR; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = cs;
|
|
p_dev->usb_ctrl.cmd.index = uid;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
|
|
return usb_host_ep0_request(p_dev, pinf);
|
|
}
|
|
|
|
void usb_host_set_address(struct hgusb20_dev *p_dev, uint8 addr)
|
|
{
|
|
os_sleep_ms(10);
|
|
p_dev->usb_ctrl.cmd.rtype = 0x00;
|
|
p_dev->usb_ctrl.cmd.request = 0x05; //Set Address
|
|
p_dev->usb_ctrl.cmd.value = addr;
|
|
p_dev->usb_ctrl.cmd.index = 0;
|
|
p_dev->usb_ctrl.cmd.length = 0;
|
|
usb_host_ep0_request(p_dev, NULL);
|
|
}
|
|
|
|
bool uvc_clear_ep_feature(struct hgusb20_dev *p_dev, uint16 ep_addr)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0x02;
|
|
p_dev->usb_ctrl.cmd.request = 0x01; //Set Configuration
|
|
p_dev->usb_ctrl.cmd.value = 0;
|
|
p_dev->usb_ctrl.cmd.index = ep_addr;
|
|
p_dev->usb_ctrl.cmd.length = 0;
|
|
return usb_host_ep0_request(p_dev, NULL);
|
|
}
|
|
|
|
|
|
|
|
struct VIDEO_COMMIT commit;
|
|
UVC_SLEST uvc_select;
|
|
UVC_PROCESS uvc_proc;
|
|
UVC_PROCESS_INFO uvc_proc_info;
|
|
UVC_DES uvc_des;
|
|
UAC_DES uac_des;
|
|
EP_DES videostream;
|
|
volatile UVCDEV uvc;
|
|
UACDEV uac;
|
|
MICDEV usb_mic;
|
|
SPKDEV usb_spk;
|
|
volatile uint8 uvc_cur_indx = 0;
|
|
uint8 *uvc_cfg_des;//[2014] = {0};
|
|
|
|
|
|
void analysis_uvc_desc(uint8 *desc,uint32 desclen)
|
|
{
|
|
#define EP_CNT 16
|
|
EP_DES eptmp[EP_CNT]; //缓存6点节点信息
|
|
uint8 epnum = 0;
|
|
uint8_t uvc_dat_ep = 0;
|
|
uint32_t itk=0;
|
|
uint8 *temp_desc;
|
|
uint8 is_cv = 0;
|
|
uint8 is_vs = 0;
|
|
static uint8 cun = 0;
|
|
cun ++;
|
|
_os_printf("_____analysis_uvc_desc cun _____%d\r\n",cun);
|
|
uint32 desc_total_len = desclen;
|
|
uint32 des_len = 0;
|
|
uint32 des_type = 0;
|
|
uint8 uvc_or_uac = 0;
|
|
uint8 au_cs = 0;
|
|
temp_desc = desc;
|
|
memset((uint8 *)&uvc_des,0,sizeof(UVC_DES));
|
|
memset((uint8 *)&videostream,0,sizeof(EP_DES));
|
|
memset((uint8 *)&eptmp,0,EP_CNT*sizeof(EP_DES));
|
|
memset((uint8 *)&uac_des,0,sizeof(UAC_DES));
|
|
uvc_des.control_endpoint = 0xff;
|
|
while(desc_total_len)
|
|
{
|
|
des_len = temp_desc[0];
|
|
des_type = temp_desc[1];
|
|
|
|
if(des_type == STRAME_O_CONTORL) {
|
|
if(temp_desc[5] == 0x0e)
|
|
uvc_or_uac = 1;
|
|
else if(temp_desc[5] == 0x01)
|
|
uvc_or_uac = 2;
|
|
}
|
|
|
|
if(uvc_or_uac == 1) {
|
|
uvc_des.DesLen = temp_desc[0];
|
|
uvc_des.DescriptorType = temp_desc[1];
|
|
uvc_des.vs_head.bDescriptorType = temp_desc[5];
|
|
uvc_des.vs_head.bDescriptorSubtype = temp_desc[6];
|
|
|
|
if(uvc_des.DescriptorType == ENDPOINT_DESC){
|
|
eptmp[epnum].ep = temp_desc[2];
|
|
eptmp[epnum].eptpye = temp_desc[3];
|
|
eptmp[epnum].len = temp_desc[4]|(temp_desc[5]<<8);
|
|
epnum++;
|
|
}
|
|
|
|
if(uvc_des.DescriptorType == STRAME_O_CONTORL){
|
|
is_cv=temp_desc[6];
|
|
if(is_cv == 1)
|
|
uvc_des.control_intfs = temp_desc[2];
|
|
if((uvc_des.vs_head.bDescriptorType == 0x0e) && (uvc_des.vs_head.bDescriptorSubtype == 0x02)){
|
|
is_vs = 1;
|
|
}else{
|
|
is_vs = 0;
|
|
}
|
|
}
|
|
|
|
if(is_cv == 1){//cv
|
|
if(uvc_des.DescriptorType == INTERFACE_Type){
|
|
uvc_des.Subtype = temp_desc[2];
|
|
if(uvc_des.Subtype == UVC_PROCESSING_UNIT)
|
|
{
|
|
memcpy(&uvc_des.vc_process, temp_desc, 8);
|
|
uvc_des.vc_process.wMaxMultiplier = temp_desc[6]<<8|temp_desc[5];
|
|
for(uint8 i=0; i<uvc_des.vc_process.bControlSize; i++)
|
|
uvc_des.vc_process.bmControls = (uvc_des.vc_process.bmControls|(temp_desc[8+i]<<(i*8)));
|
|
}
|
|
//_os_printf("CV_subtype :%d\n",uvc_des.Subtype);
|
|
}
|
|
if(uvc_des.DescriptorType == ENDPOINT_DESC && temp_desc[3]==0x03){
|
|
uvc_des.control_endpoint= temp_desc[2]&0x7f;
|
|
_os_printf("control_endpoint :%d \n",uvc_des.control_endpoint);
|
|
}
|
|
}
|
|
if(is_cv == 2){//SV
|
|
if(uvc_des.DescriptorType == INTERFACE_Type){
|
|
uvc_des.Subtype = temp_desc[2];
|
|
if(uvc_des.Subtype ==VS_INPUT_HEADER ){
|
|
memcpy(&uvc_des.vs_head, temp_desc, sizeof(VS_HEAD));
|
|
if(is_vs){
|
|
uvc_dat_ep = temp_desc[6];
|
|
}
|
|
}
|
|
else if((uvc_des.Subtype ==VS_FORMAT_UNCOMPRESSED) || (uvc_des.Subtype ==VS_FORMAT_MJPEG)||(uvc_des.Subtype ==VS_FORMAT_FRAME_BASED)){
|
|
memcpy(&uvc_des.vs_format[uvc_des.vs_format_num++], temp_desc, sizeof(VS_FORMAT));
|
|
}/*
|
|
else if(uvc_des.Subtype ==VS_FRAME_UNCOMPRESSED || uvc_des.Subtype ==VS_FRAME_MJPEG ){
|
|
my_memcpy(&uvc_des.vs_frame[uvc_des.vs_frame_num], temp_desc, sizeof(VS_FRAME));
|
|
uvc_des.vs_frame[uvc_des.vs_frame_num].wWidth = temp_desc[6]<<8|temp_desc[5];
|
|
uvc_des.vs_frame[uvc_des.vs_frame_num].wHeight= temp_desc[8]<<8|temp_desc[7];
|
|
uvc_des.vs_frame_num++;
|
|
}*/
|
|
else if( (uvc_des.Subtype ==VS_FRAME_MJPEG)||(uvc_des.Subtype ==VS_FRAME_FRAME_BASED) ){
|
|
memcpy(&uvc_des.vs_frame[uvc_des.vs_frame_num], temp_desc, sizeof(VS_FRAME));
|
|
uvc_des.vs_frame[uvc_des.vs_frame_num].wWidth = temp_desc[6]<<8|temp_desc[5];
|
|
uvc_des.vs_frame[uvc_des.vs_frame_num].wHeight= temp_desc[8]<<8|temp_desc[7];
|
|
uvc_des.vs_frame_num++;
|
|
_os_printf("^^^^^^^^");
|
|
}
|
|
}
|
|
if(uvc_des.DescriptorType == STRAME_O_CONTORL && temp_desc[0]==sizeof(SINTF_DESC)){
|
|
memcpy(&uvc_des.intfs[uvc_des.intfs_count++],temp_desc,temp_desc[0]);
|
|
if(uvc_des.intfs_count>= __INTFS_STACK__)uvc_des.intfs_count =0;
|
|
}
|
|
if(uvc_des.DescriptorType == ENDPOINT_DESC && temp_desc[0]==(sizeof(SEP_DESC)-1)){
|
|
memcpy(&uvc_des.edpt[uvc_des.edpt_count++],temp_desc,temp_desc[0]);
|
|
if(uvc_des.edpt_count>= __INTFS_STACK__)uvc_des.edpt_count =0;
|
|
}
|
|
}
|
|
}
|
|
if(uvc_or_uac == 2) {
|
|
uac_des.DesLen = temp_desc[0];
|
|
uac_des.DescriptorType = temp_desc[1];
|
|
|
|
if(uac_des.DescriptorType == STRAME_O_CONTORL){
|
|
au_cs=temp_desc[6];
|
|
if(au_cs == 1)
|
|
uac_des.control_interface = temp_desc[2];
|
|
}
|
|
|
|
if(au_cs == 1) {
|
|
if(uac_des.DescriptorType == INTERFACE_Type) {
|
|
uac_des.Subtype = temp_desc[2];
|
|
if(uac_des.Subtype == AC_INPUT_DES) {
|
|
memcpy(&uac_des.ac_input[uac_des.ac_input_num], temp_desc, uac_des.DesLen);
|
|
uac_des.ac_input_num++;
|
|
}
|
|
if(uac_des.Subtype == AC_FEATURE_DES) {
|
|
if(uac_des.DesLen >= sizeof(AC_FEATURE))
|
|
memcpy(&uac_des.ac_feature[uac_des.ac_feature_num], temp_desc, sizeof(AC_FEATURE));
|
|
else
|
|
memcpy(&uac_des.ac_feature[uac_des.ac_feature_num], temp_desc, uac_des.DesLen);
|
|
uac_des.ac_feature_num++;
|
|
}
|
|
|
|
if(uac_des.Subtype == AC_OUTPUT_DES) {
|
|
memcpy(&uac_des.ac_output[uac_des.ac_output_num], temp_desc, uac_des.DesLen);
|
|
uac_des.ac_output_num++;
|
|
}
|
|
}
|
|
}
|
|
else if(au_cs == 2) {
|
|
if(uac_des.DescriptorType == INTERFACE_Type) {
|
|
uac_des.Subtype = temp_desc[2];
|
|
if(uac_des.Subtype == AS_General_Des) {
|
|
memcpy(&uac_des.as_general[uac_des.as_general_num], temp_desc, 5);
|
|
uac_des.as_general[uac_des.as_general_num].wFormatTag = (temp_desc[6]<<8)|(temp_desc[5]);
|
|
uac_des.as_general_num++;
|
|
}
|
|
if(uac_des.Subtype == AS_Format_Des) {
|
|
memcpy(&uac_des.as_format[uac_des.as_format_num], temp_desc, 8);
|
|
if(temp_desc[7] <= 4) {
|
|
for(uint8 i=0; i<temp_desc[7]; i++)
|
|
uac_des.as_format[uac_des.as_format_num].tSamFreq[i] = (temp_desc[10]<<16)|(temp_desc[9]<<8)|(temp_desc[8]);
|
|
}
|
|
else {
|
|
uac_des.as_format[uac_des.as_format_num].bSamFreqType = 4;
|
|
for(uint8 i=0; i<4; i++)
|
|
uac_des.as_format[uac_des.as_format_num].tSamFreq[i] = (temp_desc[10]<<16)|(temp_desc[9]<<8)|(temp_desc[8]);
|
|
}
|
|
uac_des.as_format_num++;
|
|
}
|
|
}
|
|
else if(uac_des.DescriptorType == STRAME_O_CONTORL){
|
|
memcpy(&uac_des.as_interface[uac_des.as_interface_num],temp_desc,uac_des.DesLen);
|
|
uac_des.as_interface_num++;
|
|
}
|
|
else if(uac_des.DescriptorType == ENDPOINT_DESC){
|
|
memcpy(&uac_des.as_endpoint[uac_des.as_endpoint_num],temp_desc,uac_des.DesLen);
|
|
uac_des.as_endpoint_num++;
|
|
}
|
|
}
|
|
|
|
}
|
|
temp_desc += des_len;
|
|
desc_total_len -= des_len;
|
|
}
|
|
|
|
if(uvc_dat_ep){
|
|
for(itk = 0;itk < EP_CNT;itk++){
|
|
if(uvc_dat_ep == eptmp[itk].ep){
|
|
_os_printf("select ep:%x\r\n",eptmp[itk].ep);
|
|
_os_printf("ep tpye:%d\r\n",eptmp[itk].eptpye);
|
|
_os_printf("ep len:%d\r\n",eptmp[itk].len);
|
|
memcpy((uint8 *)&videostream,(uint8 *)&eptmp[itk],sizeof(EP_DES));
|
|
break;
|
|
}
|
|
}
|
|
}else{
|
|
os_printf("video stream ep error...\r\n");
|
|
}
|
|
}
|
|
|
|
void printf_uvc_vsdesc(UVC_DES *ud)
|
|
{
|
|
uint32 i;
|
|
_os_printf("=======VS_HEADER============\r\n");
|
|
_os_printf("bLength: %d\r\n",ud->vs_head.bLength );
|
|
_os_printf("bDescriptorType: %d\r\n",ud->vs_head.bDescriptorType );
|
|
_os_printf("bDescriptorSubtype: %d\r\n",ud->vs_head.bDescriptorSubtype );
|
|
_os_printf(" bNumFormats: %d\r\n",ud->vs_head.bNumFormats );
|
|
_os_printf(" \r\n__________________________\r\n");
|
|
_os_printf("=======VS_FORMAT============\r\n");
|
|
for(i = 0;i< ud->vs_format_num;i++){
|
|
_os_printf(" bLength: %d\r\n",ud->vs_format[i].bLength );
|
|
_os_printf(" bDescriptorType: %d\r\n",ud->vs_format[i].bDescriptorType );
|
|
_os_printf(" bDescriptorSubtype: %d\r\n",ud->vs_format[i].bDescriptorSubtype );
|
|
_os_printf(" bFrameIndex: %d\r\n",ud->vs_format[i].bFrameIndex );
|
|
_os_printf(" bNumFrameDescriptors: %d\r\n",ud->vs_format[i].bNumFrameDescriptors );
|
|
_os_printf(" \r\n__________________________\r\n");
|
|
}
|
|
_os_printf("=======VS_FRAME============\r\n");
|
|
for(i = 0;i< ud->vs_frame_num;i++){
|
|
_os_printf(" bLength: %d\r\n",ud->vs_frame[i].bLength );
|
|
_os_printf(" bDescriptorType: %d\r\n",ud->vs_frame[i].bDescriptorType );
|
|
_os_printf(" bDescriptorSubtype: %d\r\n",ud->vs_frame[i].bDescriptorSubtype );
|
|
_os_printf(" bFrameIndex: %d\r\n",ud->vs_frame[i].bFrameIndex );
|
|
_os_printf(" bmCapabilities: %d\r\n",ud->vs_frame[i].bmCapabilities );
|
|
_os_printf(" wWidth: %d\r\n",ud->vs_frame[i].wWidth );
|
|
_os_printf(" wHeight: %d\r\n",ud->vs_frame[i].wHeight );
|
|
_os_printf(" \r\n__________________________\r\n");
|
|
}
|
|
}
|
|
|
|
void get_uvc_process_support(UVC_DES *ud, UVC_PROCESS *uvc_p)
|
|
{
|
|
uvc_p->ctl_intfs = ud->control_intfs;
|
|
uvc_p->process_unitID = ud->vc_process.bUnitID;
|
|
uvc_p->process_ctl = ud->vc_process.bmControls;
|
|
}
|
|
void set_uvc_process_ctlval(UVC_PROCESS_INFO *uvc_p_info)
|
|
{
|
|
uvc_p_info->brightness.ctl_val = 0x02;
|
|
uvc_p_info->contrast.ctl_val = 0x03;
|
|
uvc_p_info->hue.ctl_val = 0x06;
|
|
uvc_p_info->saturation.ctl_val = 0x07;
|
|
uvc_p_info->sharpness.ctl_val = 0x08;
|
|
uvc_p_info->gamma.ctl_val = 0x09;
|
|
uvc_p_info->white_bal_temp.ctl_val = 0x0A;
|
|
uvc_p_info->white_bal_comp.ctl_val = 0x0C;
|
|
uvc_p_info->backlight_comp.ctl_val = 0x02;
|
|
uvc_p_info->gain.ctl_val = 0x04;
|
|
uvc_p_info->power_line_fre.ctl_val = 0x05;
|
|
uvc_p_info->hue_auto.ctl_val = 0x10;
|
|
uvc_p_info->white_bal_temp_auto.ctl_val = 0x0B;
|
|
uvc_p_info->white_bal_comp_auto.ctl_val = 0x0D;
|
|
uvc_p_info->digital_mult.ctl_val = 0x0E;
|
|
uvc_p_info->digital_mult_limit.ctl_val = 0x0F;
|
|
uvc_p_info->ana_video_stan.ctl_val = 0x11;
|
|
uvc_p_info->ana_lock_sta.ctl_val = 0x12;
|
|
uvc_p_info->contrast_auto.ctl_val = 0x13;
|
|
}
|
|
void get_uvc_process_info(struct hgusb20_dev *p_dev, UVC_PROCESS *uvc_p, UVC_PROCESS_INFO *uvc_p_info)
|
|
{
|
|
uint16 uid = (uvc_p->process_unitID<<8)|uvc_p->ctl_intfs;
|
|
uint16 cs = 0;
|
|
UVC_PROC_REQ *ptr = NULL;
|
|
ptr = &(uvc_p_info->brightness);
|
|
for(uint8 i=0; i<16; i++)
|
|
{
|
|
if(uvc_p->process_ctl & BIT(i)){
|
|
cs = (ptr->ctl_val<<8)|0x00;
|
|
usb_host_uvc_get_info(p_dev, uid, cs, 1, (uint8*)&(ptr->info));
|
|
os_sleep_ms(2);
|
|
usb_host_get_min(p_dev, uid, cs, 2, (uint8*)&(ptr->min));
|
|
os_sleep_ms(2);
|
|
usb_host_get_max(p_dev, uid, cs, 2, (uint8*)&(ptr->max));
|
|
os_sleep_ms(2);
|
|
usb_host_get_res(p_dev, uid, cs, 2, (uint8*)&(ptr->res));
|
|
os_sleep_ms(2);
|
|
usb_host_get_def(p_dev, uid, cs, 2, (uint8*)&(ptr->cur));
|
|
os_printf("p_dev->usb_ctrl.error:%d\n",p_dev->usb_ctrl.error);
|
|
}
|
|
ptr++;
|
|
}
|
|
}
|
|
int set_uvc_process_cur(struct hgusb20_dev *p_dev, UVC_PROCESS *uvc_p, UVC_PROCESS_INFO *uvc_p_info, UVC_PROCESS_ENUM proc, int16 cur)
|
|
{
|
|
if(!(uvc_p->process_ctl&BIT(proc))) {
|
|
_os_printf("request %d is not support!\n", proc);
|
|
return 0;
|
|
}
|
|
UVC_PROC_REQ *ptr = NULL;
|
|
ptr = (&(uvc_p_info->brightness)+proc);
|
|
if(cur >= ptr->max) {
|
|
cur = ptr->max;
|
|
_os_printf("uvc process %d max val:%d\n", proc, ptr->max);
|
|
}
|
|
if(cur <= ptr->min) {
|
|
cur = ptr->min;
|
|
_os_printf("uvc process %d min val:%d\n", proc, ptr->min);
|
|
}
|
|
uint16 uid = (uvc_p->process_unitID<<8)|uvc_p->ctl_intfs;
|
|
uint16 cs = (ptr->ctl_val<<8)|0x00;
|
|
irq_disable(USB20DMA_IRQn);
|
|
if(!usb_host_set_cur(p_dev, uid, cs, 2, (uint8*)&cur)) {
|
|
irq_enable(USB20DMA_IRQn);
|
|
_os_printf("uvc process %d err\n", proc);
|
|
return 0;
|
|
}
|
|
irq_enable(USB20DMA_IRQn);
|
|
return 1;
|
|
}
|
|
|
|
void select_uvc_intfs(UVC_DES *ud,UVCDEV *uvc)
|
|
{ uint32 i;
|
|
uint32 temp = 0;
|
|
uint32 intfs_indx=0;
|
|
uint32 edpt_indx=0;
|
|
for(i =0;i<ud->intfs_count;i++)
|
|
{
|
|
if(ud->intfs[i].alt_tring > temp && ud->intfs[i].iclass == UVC_CLASS)
|
|
intfs_indx = i;
|
|
temp = ud->intfs[i].alt_tring;
|
|
}
|
|
temp =0;
|
|
for(i =0;i<ud->edpt_count;i++)
|
|
{
|
|
//_os_printf("temp%d plaload%d\n",temp,ud->edpt[i].pay_load);
|
|
if(ud->edpt[i].pay_load > temp)
|
|
edpt_indx = i;
|
|
temp = ud->edpt[i].pay_load;
|
|
}
|
|
// ud->intfs_count
|
|
// ud->edpt_count
|
|
_os_printf("intfs indx :%d edpt_indx %d \r\n",intfs_indx,edpt_indx);
|
|
uvc->epstrm = ud->edpt[edpt_indx].ep_addr;
|
|
uvc->strm_pload= ud->edpt[edpt_indx].pay_load;
|
|
uvc->strm_interval = ud->edpt[edpt_indx].interval;
|
|
|
|
uvc->ctyp = ud->intfs[intfs_indx].iclass;
|
|
uvc->strm_intfs=ud->intfs[intfs_indx].num;
|
|
uvc->strm_altset=ud->intfs[intfs_indx].alt_tring;
|
|
}
|
|
|
|
|
|
int uvc_resolution2indx(uint32 width,uint32 height)
|
|
{
|
|
uint32 i = 0;
|
|
for(i = 0;i < uvc_des.vs_frame_num;i++)
|
|
{
|
|
if(uvc_des.vs_frame[i].wWidth == width && uvc_des.vs_frame[i].wHeight == height)
|
|
return uvc_des.vs_frame[i].bFrameIndex;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
volatile uint8_t uvc_format = 1; //1:jpg 2:264
|
|
static uint8 select_uvc_format(UVC_DES *ud,UVC_SLEST *us,uint8 index)
|
|
{
|
|
uint8 j;
|
|
uint32 i;
|
|
uint8 format_type;
|
|
//slect vs format
|
|
memset((uint8 *)us,0,sizeof(UVC_SLEST));
|
|
for(j = 0;j < 2;j++){
|
|
if(j == 0){
|
|
if(IS_UVC_JPEG){
|
|
format_type = VS_FORMAT_MJPEG;
|
|
}
|
|
else{
|
|
format_type = VS_FORMAT_UNCOMPRESSED;
|
|
}
|
|
}else{
|
|
format_type = VS_FORMAT_FRAME_BASED;
|
|
}
|
|
|
|
for(i=0;i<ud->vs_format_num;i++){
|
|
if(ud->vs_format[i].bDescriptorSubtype == format_type){
|
|
us->vs_format = ud->vs_format[i];
|
|
if(format_type == VS_FORMAT_MJPEG){
|
|
uvc_format = 1;
|
|
}else if(format_type == VS_FORMAT_FRAME_BASED){
|
|
uvc_format = 2;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(us->vs_format.bFrameIndex == 0){
|
|
_os_printf("can't suppost UVCFORMAT\r\n");
|
|
return FALSE;
|
|
}
|
|
|
|
for(i=0;i<ud->vs_frame_num;i++){
|
|
if(ud->vs_frame[i].bFrameIndex == index)
|
|
us->vs_frame = ud->vs_frame[i];
|
|
}
|
|
_os_printf("FORMAT INDX %d\r\n",us->vs_format.bFrameIndex);
|
|
_os_printf("FRAME INDX %d\r\n",us->vs_frame.bFrameIndex);
|
|
return 1;
|
|
}
|
|
|
|
void select_resolution(uint8 *p,UVC_SLEST *su)
|
|
{
|
|
p[2] = su->vs_format.bFrameIndex;
|
|
p[3] = su->vs_frame.bFrameIndex;
|
|
commit.bmhint = (p[1] << 8) + p[0];
|
|
commit.bFormatIndex = p[2];
|
|
commit.bFrameIndex = p[3];
|
|
commit.dwFrameInterval = (p[7] << 24) +(p[6] << 16) +(p[5] << 8) +(p[4] << 0) ;
|
|
commit.wKeyFrameRate = (p[9] << 8) + p[8];
|
|
commit.wPFrameRate = (p[11] << 8) + p[10];
|
|
commit.wCompQuality = (p[13] << 8) + p[12];
|
|
commit.wCompWindowSize = (p[15] << 8) + p[14];
|
|
commit.wDelay = (p[17] << 8) + p[16];
|
|
commit.dwMaxVideoFrameSize=(p[21] << 24) +(p[20] << 16) +(p[19] << 8) +(p[18] << 0);
|
|
commit.dwMaxPayloadTSize = (p[25] << 24) +(p[24] << 16) +(p[23] << 8) +(p[22] << 0);
|
|
|
|
// _os_printf(".bmhint:%x\r\n", commit.bmhint);
|
|
// _os_printf(".bFormatIndex:%x\r\n", commit.bFormatIndex);
|
|
// _os_printf(".bFrameIndex:%x\r\n", commit.bFrameIndex);
|
|
// _os_printf(".dwFrameInterval:%x\r\n",commit.dwFrameInterval);
|
|
// _os_printf(".wKeyFrameRate:%x\r\n", commit.wKeyFrameRate);
|
|
// _os_printf(".wPFrameRate:%x\r\n", commit.wPFrameRate);
|
|
// _os_printf(".wCompQuality:%x\r\n", commit.wCompQuality);
|
|
// _os_printf(".wCompWindowSize:%x\r\n",commit.wCompWindowSize);
|
|
// _os_printf(".wDelay:%x\r\n", commit.wDelay);
|
|
// _os_printf(".dwMaxVideoFrameSize:%x\r\n",commit.dwMaxVideoFrameSize);
|
|
// _os_printf(".dwMaxPayloadTSize:%x\r\n",commit.dwMaxPayloadTSize);
|
|
}
|
|
|
|
void cnvr(uint8 *p)
|
|
{
|
|
commit.bmhint = (p[1] << 8) + p[0];
|
|
commit.bFormatIndex = p[2];
|
|
commit.bFrameIndex = p[3];
|
|
commit.dwFrameInterval = (p[7] << 24) +(p[6] << 16) +(p[5] << 8) +(p[4] << 0) ;
|
|
commit.wKeyFrameRate = (p[9] << 8) + p[8];
|
|
commit.wPFrameRate = (p[11] << 8) + p[10];
|
|
commit.wCompQuality = (p[13] << 8) + p[12];
|
|
commit.wCompWindowSize = (p[15] << 8) + p[14];
|
|
commit.wDelay = (p[17] << 8) + p[16];
|
|
commit.dwMaxVideoFrameSize=(p[21] << 24) +(p[20] << 16) +(p[19] << 8) +(p[18] << 0) ;
|
|
commit.dwMaxPayloadTSize = (p[25] << 24) +(p[24] << 16) +(p[23] << 8) +(p[22] << 0) ;
|
|
}
|
|
|
|
|
|
|
|
|
|
int8 select_cur(struct hgusb20_dev *p_dev,uint8 index)
|
|
{
|
|
uint8 pcommit[26];
|
|
os_sleep_ms(5); //50
|
|
if(!select_uvc_format(&uvc_des,&uvc_select,index))
|
|
{
|
|
return 0xFF;//error
|
|
}
|
|
|
|
uvc_cur_indx = index;
|
|
if(uvc.strm_altset > 0){
|
|
if(!usb_host_set_interface(p_dev,uvc.strm_intfs ,0)){
|
|
_os_printf("select interface error\r\n");
|
|
return 0xFF;
|
|
}
|
|
}
|
|
|
|
|
|
if (!usb_host_get_cur(p_dev,1,0x0100,0x1a,pcommit)) { //uvc_probe_control
|
|
_os_printf("select cur error\r\n");
|
|
return 0xFF;
|
|
}
|
|
select_resolution(pcommit,&uvc_select);
|
|
if (!usb_host_set_cur(p_dev,1,0x0100,0x1a,pcommit)) { //uvc_probe_control
|
|
return 0xFF;
|
|
}
|
|
if (!usb_host_get_cur(p_dev,1,0x0100,0x1a,pcommit)) { //uvc_probe_control
|
|
return 0xFF;
|
|
}
|
|
cnvr(pcommit);
|
|
_os_printf("select cur finish\r\n");
|
|
// for(itk = 0;itk < 26;itk++){
|
|
// _os_printf("%x ",pcommit[itk]);
|
|
// }
|
|
// _os_printf("\r\n");
|
|
|
|
if (!usb_host_set_cur(p_dev,1,0x0100,0x1a,pcommit)) { //uvc_probe_control
|
|
return 0xFF;
|
|
}
|
|
if (!usb_host_get_cur(p_dev,1,0x0100,0x1a,pcommit)) { //uvc_probe_control
|
|
return 0xFF;
|
|
}
|
|
cnvr(pcommit);
|
|
_os_printf("select cur finish2\r\n");
|
|
// for(itk = 0;itk < 26;itk++){
|
|
// _os_printf("%x ",pcommit[itk]);
|
|
// }
|
|
// _os_printf("\r\n");
|
|
if(commit.wCompWindowSize == 0x1e){
|
|
pcommit[4] = 0x15;
|
|
pcommit[5] = 0x16;
|
|
pcommit[6] = 0x05;
|
|
pcommit[7] = 0;
|
|
}
|
|
|
|
if (!usb_host_set_cur(p_dev,1,0x0200,0x1a,pcommit)) {
|
|
return 0xFF;
|
|
}
|
|
|
|
//uvc on
|
|
_os_printf("strm_altset:%d\r\n",uvc.strm_altset);
|
|
os_sleep_ms(5);//250
|
|
if((videostream.eptpye&0X03) == USB_ENDPOINT_XFER_ISOC){
|
|
if(uvc.strm_altset > 0){
|
|
//usb_host_set_interface(p_dev,uvc.strm_intfs ,uvc.strm_altset);
|
|
}
|
|
}
|
|
//_os_printf("---p_dev->usb_ctrl.error:%d\r\n",p_dev->usb_ctrl.error);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
uint8 uvc_dpi = 0;
|
|
bool enum_set_resolution(struct hgusb20_dev *p_dev,uint8 resolution)
|
|
{
|
|
int indx = 0;
|
|
_os_printf("resolution:%d\r\n",resolution);
|
|
if(resolution == 1)//VGA
|
|
{
|
|
indx=uvc_resolution2indx(640,480);
|
|
uvc_dpi = 1;
|
|
}
|
|
if(resolution == 2){//720P
|
|
indx=uvc_resolution2indx(1280,720);
|
|
_os_printf("uvc can set resolution :1280*720\r\n");
|
|
uvc_dpi = 2;
|
|
if(indx == -1){
|
|
indx=uvc_resolution2indx(640,480);
|
|
uvc_dpi = 1;
|
|
_os_printf("uvc can not set resolution :720p\r\n");
|
|
}
|
|
}
|
|
return select_cur(p_dev,indx);
|
|
}
|
|
extern int enum_deal;
|
|
extern int uvc_default_dpi();
|
|
extern void usb_host_enum_finish_init(uint32_t uvc_format);
|
|
void uvc_stream_open(struct hgusb20_dev *p_dev,uint8 enable){
|
|
uint8 ret;
|
|
int dpi = UVC_720P;
|
|
uac_stop();
|
|
if(enable){
|
|
|
|
dpi = uvc_default_dpi();
|
|
ret = enum_set_resolution(p_dev,dpi);
|
|
if(ret != 0){
|
|
os_printf("enum set resolution failed\n");
|
|
|
|
}
|
|
os_printf("%s %d\n",__FUNCTION__,__LINE__);
|
|
if(uvc.strm_altset > 0){
|
|
uvc_room_init_mjpeg(p_dev);
|
|
usb_host_set_interface(p_dev,uvc.strm_intfs ,uvc.strm_altset);
|
|
usb_host_enum_finish_init(uvc_format);
|
|
hgusb20_ep_rx_kick(p_dev, UVC_EP, (uint32)(uvc_dat[0]+uvc_head_res), 0x400);
|
|
}else{
|
|
uvc_room_init_mjpeg(p_dev);
|
|
if((videostream.eptpye&0X03) == USB_ENDPOINT_XFER_BULK){
|
|
hgusb20_host_rx_ep_init(p_dev, UVC_EP, uvc.epstrm, USB_ENDPOINT_XFER_BULK, 1024);
|
|
uvc_head_res = BULK_HEAD;
|
|
}else{
|
|
hgusb20_host_rx_ep_init(p_dev, UVC_EP, uvc.epstrm, USB_ENDPOINT_XFER_ISOC, 1024);
|
|
uvc_head_res = ISO_HEAD;
|
|
}
|
|
os_printf("%s %d\n",__FUNCTION__,__LINE__);
|
|
usb_host_enum_finish_init(uvc_format);
|
|
os_printf("%s %d\n",__FUNCTION__,__LINE__);
|
|
hgusb20_ep_rx_kick(p_dev, UVC_EP, (uint32)(uvc_dat[0]+uvc_head_res), 0x400);
|
|
enum_deal = 1;
|
|
os_printf("%s %d\n",__FUNCTION__,__LINE__);
|
|
}
|
|
}else{
|
|
if(uvc.strm_altset > 0){
|
|
hgusb20_ep_rx_abort(p_dev, UVC_EP);
|
|
usb_host_set_interface(p_dev,uvc.strm_intfs ,0);
|
|
}else{
|
|
hgusb20_ep_rx_abort(p_dev, UVC_EP);
|
|
uvc_clear_ep_feature(p_dev, uvc.epstrm);
|
|
memset(uvc_dat[0], 0, sizeof(uvc_dat[0]));
|
|
}
|
|
}
|
|
uac_start(p_dev, usbmic_dat);
|
|
}
|
|
|
|
|
|
void uvc_ep_init(struct hgusb20_dev *p_dev)
|
|
{
|
|
if((videostream.eptpye&0X03) == USB_ENDPOINT_XFER_BULK){
|
|
hgusb20_host_rx_ep_init(p_dev, UVC_EP, uvc.epstrm, USB_ENDPOINT_XFER_BULK, 1024);
|
|
uvc_head_res = BULK_HEAD;
|
|
}else{
|
|
hgusb20_host_rx_ep_init(p_dev, UVC_EP, uvc.epstrm, USB_ENDPOINT_XFER_ISOC, 1024);
|
|
uvc_head_res = ISO_HEAD;
|
|
}
|
|
|
|
}
|
|
|
|
int uvc_ep_bulk_or_isoc()
|
|
{
|
|
if((videostream.eptpye&0X03) == USB_ENDPOINT_XFER_BULK){
|
|
return USB_ENDPOINT_XFER_BULK;
|
|
}
|
|
else{
|
|
return USB_ENDPOINT_XFER_ISOC;
|
|
}
|
|
return RET_ERR;
|
|
}
|
|
|
|
//usb host枚举成功后会执行的一个函数,默认为空,使用弱引用,返回是一个分辨率的值
|
|
__attribute__((weak)) void usb_host_enum_finish_init(uint32_t uvc_format)
|
|
{
|
|
}
|
|
|
|
__attribute__((weak)) int uvc_default_dpi()
|
|
{
|
|
return UVC_720P;
|
|
}
|
|
|
|
void split_uac_intfs(UAC_DES *ud,UACDEV *uac)
|
|
{
|
|
int8 temp = -1;
|
|
uint8 intfs_indx = 0;
|
|
uint8 edps_indx = 0;
|
|
uint8 altset_indx = 0;
|
|
os_memset((uint8 *)uac, 0, sizeof(UACDEV));
|
|
|
|
for(uint8 i=0; i<ud->ac_input_num; i++)
|
|
{
|
|
temp = -1;
|
|
|
|
if((ud->ac_input[i].wTerminalType==USB_streaming) && ((ud->ac_output[i].wTerminalType&0x03ff)>0x0300))
|
|
{
|
|
uac->spk_type = ud->ac_output[i].wTerminalType;
|
|
altset_indx = 0;
|
|
uac->spk_feaunitID = ud->ac_feature[i].bUnitID;
|
|
os_memcpy(uac->spk_feaunit_ctl, ud->ac_feature[i].bmaControls, 2);
|
|
for(uint8 j=intfs_indx; j<ud->as_interface_num; j++)
|
|
{
|
|
if((ud->as_interface[j].bAlternateSetting <= temp) || (ud->as_interface[j].bInterfaceClass != UAC_CLASS))
|
|
break;
|
|
uac->spk_strm_intfs = ud->as_interface[j].bInterfaceNumber;
|
|
temp = ud->as_interface[j].bAlternateSetting;
|
|
uac->spk_strm_altset[altset_indx] = ud->as_interface[j].bAlternateSetting;
|
|
if(ud->as_interface[j].bNumEndpoints > 0)
|
|
{
|
|
uac->spk_fmttag[altset_indx] = ud->as_general[edps_indx].wFormatTag;
|
|
uac->spk_fmttype[altset_indx] = ud->as_format[edps_indx].bFormatType;
|
|
uac->spk_nrchl[altset_indx] = ud->as_format[edps_indx].bNrChannels;
|
|
uac->spk_fmsize[altset_indx] = ud->as_format[edps_indx].bSubframeSize;
|
|
uac->spk_bitres[altset_indx] = ud->as_format[edps_indx].bBitResolution;
|
|
uac->spk_samfretype[altset_indx] = ud->as_format[edps_indx].bSamFreqType;
|
|
for(uint8 k=0; k<uac->spk_samfretype[altset_indx]; k++)
|
|
{
|
|
uac->spk_samfre[altset_indx][k] = ud->as_format[edps_indx].tSamFreq[k];
|
|
}
|
|
uac->spk_epstrm[altset_indx] = ud->as_endpoint[edps_indx].bEndpointAddress;
|
|
uac->spk_strm_pload[altset_indx] = ud->as_endpoint[edps_indx].wMaxPacketSize;
|
|
uac->spk_eptype[altset_indx] = ud->as_endpoint[edps_indx].bmAttributes;
|
|
edps_indx++;
|
|
}
|
|
altset_indx++;
|
|
intfs_indx++;
|
|
}
|
|
}
|
|
else if(((ud->ac_input[i].wTerminalType&0x02ff)>0x0200) && (ud->ac_output[i].wTerminalType==USB_streaming))
|
|
{
|
|
uac->mic_type = ud->ac_input[i].wTerminalType;
|
|
altset_indx = 0;
|
|
uac->mic_feaunitID = ud->ac_feature[i].bUnitID;
|
|
os_memcpy(uac->mic_feaunit_ctl, ud->ac_feature[i].bmaControls, 2);
|
|
for(uint8 j=intfs_indx; j<ud->as_interface_num; j++)
|
|
{
|
|
if((ud->as_interface[j].bAlternateSetting <= temp) || (ud->as_interface[j].bInterfaceClass != UAC_CLASS))
|
|
break;
|
|
uac->mic_strm_intfs = ud->as_interface[j].bInterfaceNumber;
|
|
temp = ud->as_interface[j].bAlternateSetting;
|
|
uac->mic_strm_altset[altset_indx] = ud->as_interface[j].bAlternateSetting;
|
|
if(ud->as_interface[j].bNumEndpoints > 0)
|
|
{
|
|
uac->mic_fmttag[altset_indx] = ud->as_general[edps_indx].wFormatTag;
|
|
uac->mic_fmttype[altset_indx] = ud->as_format[edps_indx].bFormatType;
|
|
uac->mic_nrchl[altset_indx] = ud->as_format[edps_indx].bNrChannels;
|
|
uac->mic_fmsize[altset_indx] = ud->as_format[edps_indx].bSubframeSize;
|
|
uac->mic_bitres[altset_indx] = ud->as_format[edps_indx].bBitResolution;
|
|
uac->mic_samfretype[altset_indx] = ud->as_format[edps_indx].bSamFreqType;
|
|
for(uint8 k=0; k<uac->mic_samfretype[altset_indx]; k++)
|
|
{
|
|
uac->mic_samfre[altset_indx][k] = ud->as_format[edps_indx].tSamFreq[k];
|
|
}
|
|
uac->mic_epstrm[altset_indx] = ud->as_endpoint[edps_indx].bEndpointAddress;
|
|
uac->mic_strm_pload[altset_indx] = ud->as_endpoint[edps_indx].wMaxPacketSize;
|
|
uac->mic_eptype[altset_indx] = ud->as_endpoint[edps_indx].bmAttributes;
|
|
edps_indx++;
|
|
}
|
|
altset_indx++;
|
|
intfs_indx++;
|
|
}
|
|
}
|
|
}
|
|
uac->ctl_intfs = ud->control_interface;
|
|
}
|
|
|
|
void select_mic_intfs(UACDEV *uac, MICDEV *mic)
|
|
{
|
|
memset((uint8 *)mic, 0, sizeof(MICDEV));
|
|
for(uint8 i=0; i<4; i++)
|
|
{
|
|
/*PCM 单通道 16bit*/
|
|
if((uac->mic_fmttag[i]==0x0001) && (uac->mic_fmttype[i]==1) &&
|
|
(uac->mic_nrchl[i]==1) && (uac->mic_bitres[i]==16))
|
|
{
|
|
mic->strm_intfs = uac->mic_strm_intfs;
|
|
mic->strm_altset = i;
|
|
mic->epstrm = uac->mic_epstrm[i];
|
|
mic->eptype = uac->mic_eptype[i];
|
|
mic->strm_pload = uac->mic_strm_pload[i];
|
|
}
|
|
}
|
|
}
|
|
void set_usbmic_intfs(struct hgusb20_dev *p_dev, MICDEV *mic, uint8 altset)
|
|
{
|
|
usb_host_set_interface(p_dev, mic->strm_intfs, altset);
|
|
}
|
|
void usbmic_ep_init(struct hgusb20_dev *p_dev, MICDEV *mic)
|
|
{
|
|
hgusb20_host_rx_ep_init(p_dev, UAC_EP, mic->epstrm, 1, 1024);
|
|
if(p_dev->usb_ctrl.bus_high_speed)
|
|
hgusb20_host_set_interval(p_dev, UAC_EP, 0, 4);
|
|
else
|
|
hgusb20_host_set_interval(p_dev, UAC_EP, 0, 1);
|
|
hgusb20_ep_rx_kick(p_dev, UAC_EP, (uint32)usbmic_dat, 1024);
|
|
}
|
|
void usbmic_stream_enable(struct hgusb20_dev *p_dev, MICDEV *mic, uint8 enable)
|
|
{
|
|
int ret = 0;
|
|
if(enable) {
|
|
ret = usb_host_set_interface(p_dev, mic->strm_intfs, mic->strm_altset);
|
|
} else {
|
|
ret = usb_host_set_interface(p_dev, mic->strm_intfs, 0);
|
|
}
|
|
if(!ret) {
|
|
os_printf("usbmic SetInterface err\n");
|
|
}
|
|
}
|
|
|
|
void select_spk_intfs(UACDEV *uac, SPKDEV *spk)
|
|
{
|
|
memset((uint8 *)spk, 0, sizeof(SPKDEV));
|
|
for(uint8 i=0; i<4; i++)
|
|
{
|
|
/*PCM 单通道 16bit*/
|
|
if((uac->spk_fmttag[i]==0x0001) && (uac->spk_fmttype[i]==1) &&
|
|
(uac->spk_nrchl[i]==1) && (uac->spk_bitres[i]==16))
|
|
{
|
|
spk->strm_intfs = uac->spk_strm_intfs;
|
|
spk->strm_altset = i;
|
|
spk->epstrm = uac->spk_epstrm[i];
|
|
spk->eptype = uac->spk_eptype[i];
|
|
spk->strm_pload = uac->spk_strm_pload[i];
|
|
}
|
|
}
|
|
}
|
|
void set_usbspk_intfs(struct hgusb20_dev *p_dev, SPKDEV *spk, uint8 altset)
|
|
{
|
|
usb_host_set_interface(p_dev, spk->strm_intfs, altset);
|
|
}
|
|
void usbspk_ep_init(struct hgusb20_dev *p_dev, SPKDEV *spk)
|
|
{
|
|
hgusb20_host_tx_ep_init(p_dev, UAC_EP, spk->epstrm, 1, 1024);
|
|
if(p_dev->usb_ctrl.bus_high_speed)
|
|
hgusb20_host_set_interval(p_dev, UAC_EP, 1, 4);
|
|
else
|
|
hgusb20_host_set_interval(p_dev, UAC_EP, 1, 1);
|
|
extern void usbspk_tx(struct hgusb20_dev *p_dev, uint8_t ep, uint32_t len);
|
|
usbspk_tx(p_dev,UAC_EP,16);
|
|
}
|
|
void usbspk_stream_enable(struct hgusb20_dev *p_dev, SPKDEV *spk, uint8 enable)
|
|
{
|
|
int ret = 0;
|
|
if(enable) {
|
|
ret = usb_host_set_interface(p_dev, spk->strm_intfs, spk->strm_altset);
|
|
} else {
|
|
ret = usb_host_set_interface(p_dev, spk->strm_intfs, 0);
|
|
}
|
|
if(!ret) {
|
|
os_printf("usbspk SetInterface err\n");
|
|
}
|
|
}
|
|
void get_uac_vol(struct hgusb20_dev *p_dev, UACDEV *uac, uint8 audio_dev)
|
|
{
|
|
int8 channel = -1;
|
|
uint8 *feaunit_ctl = NULL;
|
|
uint8 feaunitID = 0;
|
|
int16 *min_vol = NULL, *max_vol = NULL;
|
|
|
|
if(audio_dev == 0)
|
|
{
|
|
feaunit_ctl = uac->spk_feaunit_ctl;
|
|
feaunitID = uac->spk_feaunitID;
|
|
min_vol = &uac->spk_min_vol;
|
|
max_vol = &uac->spk_max_vol;
|
|
}
|
|
else if(audio_dev == 1)
|
|
{
|
|
feaunit_ctl = uac->mic_feaunit_ctl;
|
|
feaunitID = uac->mic_feaunitID;
|
|
min_vol = &uac->mic_min_vol;
|
|
max_vol = &uac->mic_max_vol;
|
|
}
|
|
|
|
for(uint8 i=0; i<2; i++) {
|
|
if(feaunit_ctl[i] & 0x02) {
|
|
channel = i;
|
|
break;
|
|
}
|
|
}
|
|
if(channel == -1) {
|
|
_os_printf("UAC DEV:%d no channel to get the volume\n", audio_dev);
|
|
return;
|
|
}
|
|
uint16 uid = (feaunitID<<8)|uac->ctl_intfs;
|
|
uint16 cs = (0x02<<8)|channel;
|
|
uac_stop();
|
|
if(!usb_host_get_min(p_dev, uid, cs, 2, (uint8*)min_vol)) {
|
|
_os_printf("get uac dev:%d min vol err\n", audio_dev);
|
|
}
|
|
else {
|
|
_os_printf("uac dev:%d min vol:%d\n", audio_dev, *min_vol);
|
|
}
|
|
if(!usb_host_get_max(p_dev, uid, cs, 2, (uint8*)max_vol)) {
|
|
_os_printf("get uac dev:%d max vol err\n", audio_dev);
|
|
}
|
|
else {
|
|
_os_printf("uac dev:%d max vol:%d\n", audio_dev, *max_vol);
|
|
}
|
|
uac_start(p_dev, usbmic_dat);
|
|
}
|
|
int set_uac_mute(struct hgusb20_dev *p_dev, UACDEV *uac, uint8 audio_dev, uint8 enable)
|
|
{
|
|
int8 channel = -1;
|
|
uint8 *feaunit_ctl = NULL;
|
|
uint8 feaunitID = 0;
|
|
if(audio_dev == 0)
|
|
{
|
|
feaunit_ctl = uac->spk_feaunit_ctl;
|
|
feaunitID = uac->spk_feaunitID;
|
|
}
|
|
else if(audio_dev == 1)
|
|
{
|
|
feaunit_ctl = uac->mic_feaunit_ctl;
|
|
feaunitID = uac->mic_feaunitID;
|
|
}
|
|
for(uint8 i=0; i<2; i++) {
|
|
if(feaunit_ctl[i] & 0x01) {
|
|
channel = i;
|
|
break;
|
|
}
|
|
}
|
|
if(channel == -1) {
|
|
_os_printf("UAC DEV:%d no channel to set mute\n", audio_dev);
|
|
return 0;
|
|
}
|
|
uint16 uid = (feaunitID<<8)|uac->ctl_intfs;
|
|
uint16 cs = (0x01<<8)|channel;
|
|
uac_stop();
|
|
if(!usb_host_set_cur(p_dev, uid, cs, 1, &enable)) {
|
|
_os_printf("set uac dev:%d mute err\n", audio_dev);
|
|
}
|
|
uac_start(p_dev, usbmic_dat);
|
|
return 1;
|
|
}
|
|
|
|
int set_uac_volume(struct hgusb20_dev *p_dev, UACDEV *uac, uint8 audio_dev, int16 volume)
|
|
{
|
|
int8 channel = -1;
|
|
uint8 *feaunit_ctl = NULL;
|
|
uint8 feaunitID = 0;
|
|
int16 min_vol = 0x00, max_vol = 0x00;
|
|
|
|
if(audio_dev == 0)
|
|
{
|
|
feaunit_ctl = uac->spk_feaunit_ctl;
|
|
feaunitID = uac->spk_feaunitID;
|
|
min_vol = uac->spk_min_vol;
|
|
max_vol = uac->spk_max_vol;
|
|
}
|
|
else if(audio_dev == 1)
|
|
{
|
|
feaunit_ctl = uac->mic_feaunit_ctl;
|
|
feaunitID = uac->mic_feaunitID;
|
|
min_vol = uac->mic_min_vol;
|
|
max_vol = uac->mic_max_vol;
|
|
}
|
|
|
|
for(uint8 i=0; i<2; i++) {
|
|
if(feaunit_ctl[i] & 0x02) {
|
|
channel = i;
|
|
break;
|
|
}
|
|
}
|
|
if(channel == -1) {
|
|
_os_printf("UAC DEV:%d no channel to set the volume\n", audio_dev);
|
|
return 0;
|
|
}
|
|
|
|
if(volume <= min_vol){
|
|
volume = min_vol;
|
|
_os_printf("UAC DEV:%d MIN VOLUME:%x\n",audio_dev, min_vol);
|
|
}
|
|
if(volume>=max_vol) {
|
|
volume = max_vol;
|
|
_os_printf("UAC DEV:%d MAX VOLUME:%x\n",audio_dev, max_vol);
|
|
}
|
|
|
|
uint16 uid = (feaunitID<<8)|uac->ctl_intfs;
|
|
uint16 cs = (0x02<<8)|channel;
|
|
uac_stop();
|
|
if(!usb_host_set_cur(p_dev, uid, cs, 2, (uint8*)&volume)) {
|
|
_os_printf("set uac dev:%d vol err\n", audio_dev);
|
|
}
|
|
uac_start(p_dev, usbmic_dat);
|
|
return 1;
|
|
|
|
}
|
|
|
|
void uac_stream_open(struct hgusb20_dev *p_dev, uint8_t enable)
|
|
{
|
|
uac_stop();
|
|
if((uac.spk_type == Speaker) && (uac.mic_type == Microphone)) {
|
|
usbspk_stream_enable(p_dev, (SPKDEV*)&usb_spk, enable);
|
|
os_sleep_ms(10);
|
|
usbmic_stream_enable(p_dev, (MICDEV*)&usb_mic, enable);
|
|
}
|
|
if(enable)
|
|
uac_start(p_dev, usbmic_dat);
|
|
}
|
|
extern uint8 uac_open;
|
|
extern uint8_t uvc_open;
|
|
extern uint8_t uac_run;
|
|
extern void usbmic_enum_finish(void);
|
|
extern void usbspk_enum_finish(void);
|
|
uint8 usb_host_ep0_enum_uvc(struct hgusb20_dev *p_dev)
|
|
{
|
|
//uint8 ret;
|
|
uint8 addr = 0;
|
|
uint16 desc_len;
|
|
//int dpi = UVC_720P;
|
|
addr = uvc_set_addr;
|
|
uac_open = 0;
|
|
uac_run = 0;
|
|
irq_disable(USB20MC_IRQn);
|
|
usb_host_set_address(p_dev, addr); //设置设备地址
|
|
hgusb20_set_address(p_dev, addr);
|
|
os_sleep_ms(5);
|
|
|
|
if (!usb_host_get_device_descriptor_2_do(p_dev)) { //第二次获取失败，一般是设地址错误
|
|
_os_printf("SetAddr Err\r\n");
|
|
goto __enum_err;
|
|
}
|
|
|
|
if (!usb_host_get_configuration_descriptor_1(p_dev, 0)) {
|
|
goto __enum_err;
|
|
}
|
|
desc_len = (HOST_EP0_BUF[3] << 8)+ HOST_EP0_BUF[2];
|
|
if(desc_len == 0){
|
|
_os_printf("< configuration dec len er>\n");
|
|
goto __enum_err;
|
|
}
|
|
uvc_cfg_des = malloc(2014);
|
|
if (!usb_host_get_configuration_descriptor_3(p_dev, 0, desc_len, uvc_cfg_des)) {
|
|
_os_printf("GetCfg Err\r\n");
|
|
goto __enum_err;
|
|
}
|
|
_os_printf("desc_len:%d\r\n",desc_len);
|
|
analysis_uvc_desc(uvc_cfg_des,desc_len);
|
|
free(uvc_cfg_des);
|
|
//printf_uvc_vsdesc(&uvc_des);
|
|
|
|
select_uvc_intfs(&uvc_des,(UVCDEV *)&uvc);
|
|
split_uac_intfs(&uac_des,(UACDEV *)&uac);
|
|
usb_host_set_configuration(p_dev, 1); //设置配置
|
|
|
|
os_sleep_ms(5);
|
|
if (uvc.ctyp == UVC_CLASS) {
|
|
_os_printf("strm_intfs:%x, epstrm:%x, strm_pload: %x, strm_altset:%x \r\n",uvc.strm_intfs ,uvc.epstrm,uvc.strm_pload, uvc.strm_altset);
|
|
get_uvc_process_support(&uvc_des, &uvc_proc);
|
|
set_uvc_process_ctlval(&uvc_proc_info);
|
|
get_uvc_process_info(p_dev, &uvc_proc, &uvc_proc_info);
|
|
// dpi = uvc_default_dpi();
|
|
// ret = enum_set_resolution(p_dev,dpi);
|
|
// if(ret != 0){
|
|
// goto __enum_err;
|
|
// }
|
|
usb_host_enum_finish_init(uvc_format);
|
|
uvc_room_init_mjpeg();
|
|
|
|
_os_printf(" uvc.epstrm %x,uvc.strm_pload %x,uvc.strm_interval %x\r\n",uvc.epstrm&0x7f,uvc.strm_pload,uvc.strm_interval);
|
|
uvc_ep_init(p_dev);
|
|
|
|
if(uvc.strm_altset > 0)
|
|
{
|
|
usb_host_set_interface(p_dev,uvc.strm_intfs ,0);
|
|
}
|
|
|
|
os_sleep_ms(10);
|
|
//if(uvc_host_init(uvc_addr_get(), uvc.epstrm,-1,uvc.strm_pload,uvc.strm_interval))
|
|
//#if EN_UVC_TAKE_PHOTO
|
|
// uvc_actech_as_control();
|
|
//#endif
|
|
// uvc_actech_as_usensor();
|
|
}
|
|
if((uac.spk_type == Speaker) && (uac.mic_type == Microphone))
|
|
{
|
|
select_mic_intfs((UACDEV*)&uac, (MICDEV*)&usb_mic);
|
|
select_spk_intfs((UACDEV*)&uac, (SPKDEV*)&usb_spk);
|
|
usbspk_stream_enable(p_dev, (SPKDEV*)&usb_spk, 0);
|
|
os_sleep_ms(5);
|
|
usbmic_stream_enable(p_dev, (MICDEV*)&usb_mic, 0);
|
|
os_sleep_ms(5);
|
|
get_uac_vol(p_dev, (UACDEV*)&uac, 0);
|
|
get_uac_vol(p_dev, (UACDEV*)&uac, 1);
|
|
set_uac_mute(p_dev, (UACDEV*)&uac, 0, 0);
|
|
set_uac_volume(p_dev, (UACDEV*)&uac, 0, 0);
|
|
usbspk_stream_enable(p_dev, (SPKDEV*)&usb_spk, 1);
|
|
usbmic_stream_enable(p_dev, (MICDEV*)&usb_mic, 1);
|
|
}
|
|
if (p_dev->usb_ctrl.error) {
|
|
_os_printf("Enum ERR\r\n");
|
|
goto __enum_err;
|
|
}
|
|
irq_enable(USB20MC_IRQn);
|
|
if((uac.spk_type == Speaker) && (uac.mic_type == Microphone)) {
|
|
uac_open = 1;
|
|
uac_run = 1;
|
|
usbmic_room_init();
|
|
usbspk_room_init(16);
|
|
usbmic_enum_finish();
|
|
usbspk_enum_finish();
|
|
usbmic_ep_init(p_dev, (MICDEV*)&usb_mic);
|
|
usbspk_ep_init(p_dev, (SPKDEV*)&usb_spk);
|
|
}
|
|
os_sleep_ms(20);
|
|
if(uvc_open){
|
|
uvc_stream_open(p_dev,1);
|
|
}
|
|
_os_printf("Enum OK\r\n");
|
|
return TRUE;
|
|
|
|
__enum_err:
|
|
irq_enable(USB20MC_IRQn);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
uint8 *hub_des;//[2014] = {0};
|
|
HUB_manage hub_manage;
|
|
|
|
|
|
uint8 get_int_enpoint(uint8 *desc)
|
|
{
|
|
uint8 *temp = desc;
|
|
uint32 temp_len =desc[0];
|
|
while(temp_len){
|
|
temp_len =temp[0];
|
|
if(temp[0] == 0x7 && temp[1] == 0x5&&temp[3] == 0x3)
|
|
return (temp[2]&0x7f);
|
|
else{
|
|
temp+=temp_len;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
uint8 get_hub_port_num(uint8 *desc)
|
|
{
|
|
|
|
uint8 *temp=desc;
|
|
//uint32 len = desc[0];
|
|
if(temp[0] == 0x9 && temp[1] == 0x29)
|
|
return temp[2];
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
bool usb_hub_get_status(struct hgusb20_dev *p_dev,uint8 *pinf)
|
|
{
|
|
bool ret;
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa0;
|
|
p_dev->usb_ctrl.cmd.request = 0; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = 0;
|
|
p_dev->usb_ctrl.cmd.index = 0;
|
|
p_dev->usb_ctrl.cmd.length = 4;
|
|
ret = usb_host_ep0_request(p_dev, pinf);
|
|
return ret;
|
|
}
|
|
|
|
bool usb_hub_set_port_feature(struct hgusb20_dev *p_dev,uint8 port,uint8 feature)
|
|
{
|
|
bool ret;
|
|
p_dev->usb_ctrl.cmd.rtype = 0x23;
|
|
p_dev->usb_ctrl.cmd.request = 0x03; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = feature;
|
|
p_dev->usb_ctrl.cmd.index = port;
|
|
p_dev->usb_ctrl.cmd.length = 0;
|
|
p_dev->usb_ctrl.error = 0;
|
|
ret = usb_host_ep0_request(p_dev, NULL);
|
|
return ret;
|
|
}
|
|
|
|
bool usb_host_hub_get_descriptor(struct hgusb20_dev *p_dev, uint16 len)
|
|
{
|
|
bool ret;
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa0;
|
|
p_dev->usb_ctrl.cmd.request = 0x06; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = 0;
|
|
p_dev->usb_ctrl.cmd.index = 0;
|
|
p_dev->usb_ctrl.cmd.length = len;
|
|
|
|
|
|
ret = usb_host_ep0_request(p_dev, p_dev->usb_ep0_rxbuf);
|
|
return ret;
|
|
|
|
}
|
|
|
|
bool usb_host_get_hub_descriptor(struct hgusb20_dev *p_dev,uint8* buf)
|
|
{
|
|
bool ret;
|
|
ret = usb_host_hub_get_descriptor(p_dev, 64); //第一次，尝试获取设备描述符
|
|
//p_dev->usb_host.ep0_pkt = p_dev->usb_ep0buf[7]; //Max Pkt
|
|
memcpy(buf,p_dev->usb_ep0_rxbuf,64);
|
|
return ret;
|
|
}
|
|
|
|
|
|
void usb_host_hub_init_do(struct hgusb20_dev *p_dev)
|
|
{
|
|
hgusb20_host_rx_ep_init(p_dev, HUB_EP, hub_manage.int_endpoint, USB_ENDPOINT_XFER_BULK, 4);
|
|
hgusb20_set_address(p_dev, hub_set_addr);
|
|
hgusb20_ep_rx_kick(p_dev, HUB_EP, (uint32)uvc_dat[0], 0x4);
|
|
}
|
|
|
|
bool usb_hub_get_port_status(struct hgusb20_dev *p_dev,uint8 *desc,uint8 port)
|
|
{
|
|
bool ret;
|
|
p_dev->usb_ctrl.cmd.rtype = 0xa3;
|
|
p_dev->usb_ctrl.cmd.request = 0; //Get Descriptor
|
|
p_dev->usb_ctrl.cmd.value = 0;
|
|
p_dev->usb_ctrl.cmd.index = port;
|
|
p_dev->usb_ctrl.cmd.length = 4;
|
|
p_dev->usb_ctrl.error = 0;
|
|
p_dev->usb_host.ep0_pkt = 255;
|
|
ret = usb_host_ep0_request(p_dev, desc);
|
|
return ret;
|
|
}
|
|
|
|
|
|
void hub_ep_init(struct hgusb20_dev *p_dev)
|
|
{
|
|
usb_host_hub_init_do(p_dev); //ep init
|
|
//hub_isr_init(p_dev);
|
|
irq_enable(USB20MC_IRQn);
|
|
irq_enable(USB20DMA_IRQn);
|
|
}
|
|
|
|
|
|
|
|
uint8 usb_host_ep0_enum_hub(struct hgusb20_dev *p_dev)
|
|
{
|
|
uint8 ret;
|
|
int i;
|
|
uint8 addr = 0;
|
|
uint16 desc_len;
|
|
|
|
uint8 rst = hgusb20_host_reset(p_dev);
|
|
if (rst) {
|
|
return rst;
|
|
}
|
|
rst = hgusb20_host_reset(p_dev);
|
|
if (rst) {
|
|
return rst;
|
|
}
|
|
|
|
if (!usb_host_get_device_descriptor_2_do(p_dev)) {
|
|
_os_printf("GetDesc Err\r\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if (hgusb20_host_reset(p_dev)) {
|
|
return FALSE;
|
|
}
|
|
if (p_dev->usb_ctrl.bus_high_speed) {
|
|
_os_printf("high_speed device plug in\r\n");
|
|
} else {
|
|
_os_printf("full_speed device plug in\r\n");
|
|
}
|
|
addr = hub_set_addr;
|
|
//hub_set_addr++;
|
|
//uvc_set_addr = 4;
|
|
//addr = uvc_set_addr;
|
|
usb_host_set_address(p_dev, hub_set_addr); //设置设备地址
|
|
hgusb20_set_address(p_dev, addr);
|
|
os_sleep_ms(10);
|
|
|
|
if (!usb_host_get_device_descriptor_2_do(p_dev)) { //第二次获取失败，一般是设地址错误
|
|
_os_printf("SetAddr Err\r\n");
|
|
return FALSE;
|
|
}
|
|
//usb_host_get_device_end(usb_sw); //获取设备描述符后留接口
|
|
if (!usb_host_get_configuration_descriptor_1(p_dev, 0)) {
|
|
return FALSE;
|
|
}
|
|
desc_len = (HOST_EP0_BUF[3] << 8)+ HOST_EP0_BUF[2];
|
|
if(desc_len == 0){
|
|
_os_printf("< configuration dec len er>\n");
|
|
return FALSE;
|
|
}
|
|
hub_des = malloc(2014);
|
|
if (!usb_host_get_configuration_descriptor_3(p_dev, 0, desc_len, hub_des)) {
|
|
_os_printf("GetCfg Err\r\n");
|
|
free(hub_des);
|
|
return FALSE;
|
|
}
|
|
_os_printf("desc_len:%d\r\n",desc_len);
|
|
hub_manage.int_endpoint = get_int_enpoint(hub_des);
|
|
usb_host_set_configuration(p_dev, 1); //设置配置
|
|
|
|
os_sleep_ms(10);
|
|
ret = usb_host_get_hub_descriptor(p_dev,hub_des);
|
|
if(ret != 1){
|
|
_os_printf("hub_descriptor err\r\n");
|
|
free(hub_des);
|
|
return ret;
|
|
}
|
|
os_sleep_ms(100);
|
|
hub_manage.port_num = get_hub_port_num(hub_des);
|
|
p_dev->usb_ctrl.error = 0;
|
|
ret = usb_hub_get_status(p_dev,hub_des);
|
|
if(ret != 1){
|
|
_os_printf("get status err\r\n");
|
|
free(hub_des);
|
|
return ret;
|
|
}
|
|
_os_printf("hub_des:%d port_num:%d int_endpoint:%d\r\n",hub_des[0],hub_manage.port_num,hub_manage.int_endpoint);
|
|
if(hub_des[0]==0)
|
|
{
|
|
for(i=1;i<hub_manage.port_num+1;i++){
|
|
ret=usb_hub_set_port_feature(p_dev,i,0x08);
|
|
if(ret != 1){
|
|
free(hub_des);
|
|
return ret;
|
|
}
|
|
// _os_printf("set port feature :%d \n",i);
|
|
}
|
|
}
|
|
|
|
for(i=1;i<hub_manage.port_num+1;i++){
|
|
ret = usb_hub_get_port_status(p_dev,hub_des,i);
|
|
if(ret == FALSE){
|
|
free(hub_des);
|
|
return FALSE;
|
|
}
|
|
|
|
//_os_printf("%x %x %x %x\n",desc[0],desc[1],desc[2],desc[3]);
|
|
//_os_printf("\n");
|
|
}
|
|
free(hub_des);
|
|
_os_printf("hub_enum_finish\r\n");
|
|
|
|
_os_printf("uvc_dat[0]:%x\r\n",uvc_dat[0][0]);
|
|
hub_ep_init(p_dev);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
bool usb_host_enum1(struct hgusb20_dev *p_dev)
|
|
{
|
|
uint8 try_cnt = 3;
|
|
uint8 res;
|
|
do {
|
|
|
|
if (!hgusb20_is_device_online(p_dev)) {
|
|
_os_printf("host not online Err\r\n");
|
|
break;
|
|
}
|
|
|
|
res = hgusb20_host_reset(p_dev);
|
|
if (res) {
|
|
return res;
|
|
}
|
|
res = hgusb20_host_reset(p_dev);
|
|
if (res) {
|
|
return res;
|
|
}
|
|
if (!usb_host_get_device_descriptor_1_do(p_dev)) {
|
|
_os_printf("GetDesc Err\r\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if (hgusb20_host_reset(p_dev)) {
|
|
return FALSE;
|
|
}
|
|
if (p_dev->usb_ctrl.bus_high_speed) {
|
|
_os_printf("high_speed device plug in\r\n");
|
|
} else {
|
|
_os_printf("full_speed device plug in\r\n");
|
|
}
|
|
|
|
//usb_host_init(usb_sw);
|
|
res = usb_host_ep0_enum_uvc(p_dev);
|
|
if (res == 0) {
|
|
//hgusb20_reset_phy(p_dev);
|
|
continue;
|
|
} else if (res == 2) {
|
|
break;
|
|
}
|
|
return TRUE;
|
|
} while (--try_cnt);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
uint8 hub_ep0_clear_port_feature(struct hgusb20_dev *p_dev, uint8 port,uint8 feature)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0x23;
|
|
p_dev->usb_ctrl.cmd.request = 0x01; //Set Configuration
|
|
p_dev->usb_ctrl.cmd.value = feature;
|
|
p_dev->usb_ctrl.cmd.index = port;
|
|
p_dev->usb_ctrl.cmd.length = 0;
|
|
p_dev->usb_host.ep0_pkt = 255;
|
|
usb_host_ep0_request(p_dev, NULL);
|
|
os_sleep_ms(10);
|
|
return FALSE;
|
|
}
|
|
|
|
uint8 hub_ep0_set_port_feature(struct hgusb20_dev *p_dev, uint8 port,uint8 feature)
|
|
{
|
|
p_dev->usb_ctrl.cmd.rtype = 0x23;
|
|
p_dev->usb_ctrl.cmd.request = 0x03; //Set Configuration
|
|
p_dev->usb_ctrl.cmd.value = feature;
|
|
p_dev->usb_ctrl.cmd.index = port;
|
|
p_dev->usb_ctrl.cmd.length = 0;
|
|
p_dev->usb_host.ep0_pkt = 255;
|
|
usb_host_ep0_request(p_dev, NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
uint8 hub_wait_port_connect(struct hgusb20_dev *p_dev,uint8 port)
|
|
{
|
|
uint8 buff[10];
|
|
uint8 ret;
|
|
do{
|
|
ret = usb_hub_get_port_status(p_dev,buff,port);
|
|
if(ret == FALSE){
|
|
return FALSE;
|
|
}
|
|
os_sleep_ms(1);
|
|
}while(!(buff[0] & HUB_STATU_CONNECT) );
|
|
return TRUE;
|
|
}
|
|
|
|
uint8 hub_wait_port_restend(struct hgusb20_dev *p_dev,uint8 port)
|
|
{
|
|
uint8 buff[10];
|
|
uint8 ret;
|
|
ret = usb_hub_get_port_status(p_dev,buff,port);
|
|
if(ret == FALSE){
|
|
return FALSE;
|
|
}
|
|
do{
|
|
ret = usb_hub_get_port_status(p_dev,buff,port);
|
|
if(ret == FALSE){
|
|
return FALSE;
|
|
}
|
|
os_sleep_ms(1);
|
|
}while((buff[3]&HUB_STATU_RESTEND) != 0);
|
|
return TRUE;
|
|
}
|
|
|
|
uint8 clean_hub_port(struct hgusb20_dev *p_dev,uint8 port)
|
|
{
|
|
|
|
uint8 ret = 0;
|
|
|
|
// u_addr_set(5);
|
|
// if(ret != 0)return ret;
|
|
ret =hub_ep0_clear_port_feature(p_dev,port,PORT_CONNECT);
|
|
|
|
if(ret != 0)return ret;
|
|
|
|
ret = hub_ep0_set_port_feature(p_dev,port,PORT_REST);
|
|
if(ret != 0)return ret;
|
|
|
|
ret = hub_wait_port_connect(p_dev,port);
|
|
if(ret == FALSE) return FALSE;
|
|
|
|
ret = hub_ep0_clear_port_feature(p_dev,port,CLEAR_PORT_REST);
|
|
if(ret != 0)return ret;
|
|
|
|
ret = hub_wait_port_restend(p_dev,port);
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int usb_hub_isr_handl(struct hgusb20_dev *p_dev)
|
|
{
|
|
uint8 hub_port = 0 ;
|
|
uint8 ret;
|
|
|
|
uint32 rx_len;
|
|
rx_len = hgusb20_ep_get_sie_rx_len(p_dev, HUB_EP);
|
|
_os_printf("uvc_dat[0]:%x %d\r\n",uvc_dat[0][0],rx_len);
|
|
if( rx_len > 0 ){
|
|
for(hub_port = 1;hub_port<8;hub_port++ )
|
|
{
|
|
if(uvc_dat[0][0]&BIT(hub_port))
|
|
break;
|
|
}
|
|
|
|
_os_printf("hub port %d connect \n",hub_port);
|
|
hub_manage.connect_port =hub_port;
|
|
ret = clean_hub_port(p_dev,hub_manage.connect_port);
|
|
_os_printf("hub ret %d \n",ret);
|
|
if(ret == FALSE)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
else{
|
|
return 1;
|
|
}
|
|
if(ret!=0){
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
extern volatile uint8 hub_interrupt;
|
|
|
|
|
|
|
|
uint8 hub_enum_error = 0;
|
|
void usb_hub_device_insert(struct hgusb20_dev *p_dev)
|
|
{
|
|
uint8 ret;
|
|
while(1){
|
|
|
|
os_sema_down(&p_dev->usb_os_msg->hub_sema, osWaitForever);
|
|
if (usb_hub_isr_handl(p_dev) == 0) {
|
|
hgusb20_set_address(p_dev, 0);
|
|
if (!usb_host_get_device_descriptor_1_do(p_dev)) {
|
|
_os_printf("GetDesc hub Err\r\n");
|
|
hub_enum_error = 1;
|
|
os_sema_up(&p_dev->usb_os_msg->hub_finish_sema);
|
|
continue;
|
|
}
|
|
_os_printf("enum uvc\r\n");
|
|
ret = usb_host_ep0_enum_uvc(p_dev);
|
|
}else{
|
|
hub_enum_error = 1;
|
|
os_sema_up(&p_dev->usb_os_msg->hub_finish_sema);
|
|
continue;
|
|
}
|
|
//hgusb20_ep_rx_kick(p_dev, HUB_EP, (uint32)uvc_dat, 0x4);
|
|
//_os_printf("up finish sema \n");
|
|
hub_enum_error = 0;
|
|
os_sema_up(&p_dev->usb_os_msg->hub_finish_sema);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8 usb_host_ep0_enum_hub_dev(struct hgusb20_dev *p_dev)
|
|
{
|
|
uint8 ret = TRUE;
|
|
#if 0
|
|
while(hub_interrupt == 0)
|
|
os_sleep_ms(1);
|
|
hub_interrupt = 0;
|
|
if (usb_hub_isr_handl(p_dev) == 0) {
|
|
hgusb20_set_address(p_dev, 0);
|
|
if (!usb_host_get_device_descriptor_1_do(p_dev)) {
|
|
_os_printf("GetDesc hub Err\r\n");
|
|
return FALSE;
|
|
}
|
|
ret = usb_host_ep0_enum_uvc(p_dev);
|
|
}
|
|
#endif
|
|
//_os_printf("wait hub device insert\r\n");
|
|
os_sema_down(&p_dev->usb_os_msg->hub_finish_sema, osWaitForever);
|
|
//_os_printf("finish down \n");
|
|
if(hub_enum_error){
|
|
ret = FALSE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool usb_host_enum2(struct hgusb20_dev *p_dev)
|
|
{
|
|
uint8 try_cnt = 3;
|
|
uint8 res;
|
|
|
|
do {
|
|
if (!hgusb20_is_device_online(p_dev)) {
|
|
break;
|
|
}
|
|
|
|
//usb_host_init(usb_sw);
|
|
// res = usb_host_ep0_enum_uvc(usb_sw);
|
|
res = usb_host_ep0_enum_hub(p_dev);
|
|
if (res == 0) {
|
|
continue;
|
|
} else if (res == 2) {
|
|
break;
|
|
}else if(res == 1){
|
|
res = usb_host_ep0_enum_hub_dev(p_dev);
|
|
}
|
|
|
|
if (res == 0) {
|
|
continue;
|
|
} else if (res == 2) {
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
} while (--try_cnt);
|
|
|
|
//usb_host_set_fail();
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
bool usb_uvc_host_enum(struct hgusb20_dev *p_dev)
|
|
{
|
|
SDEV_DESC dev_desc;
|
|
bool res = 0;
|
|
res = hgusb20_host_reset(p_dev);
|
|
if (res) {
|
|
return res;
|
|
}
|
|
hgusb20_set_address(p_dev, 0);
|
|
if (!usb_host_get_device_descriptor_2_do(p_dev)) {
|
|
_os_printf("SetAddr Err\r\n");
|
|
return 0;
|
|
}
|
|
|
|
memcpy(&dev_desc,p_dev->usb_ep0_rxbuf,sizeof(SDEV_DESC));
|
|
|
|
switch(dev_desc.device_class){
|
|
case USB_DEV_HUB_CLASS:
|
|
res = usb_host_enum2(p_dev);
|
|
break;
|
|
case USB_DEV_UVC_CLASS:
|
|
res = usb_host_enum1(p_dev);
|
|
break;
|
|
default:
|
|
_os_printf("--USB can't suppost this device-- \n");
|
|
break;
|
|
}
|
|
|
|
if(res == 0){
|
|
hgusb20_host_reset_phy(p_dev);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
int32 usb_host_uvc_ioctl(struct usb_device *p_usb_d, uint32 cmd, uint32 param1, uint32 param2)
|
|
{
|
|
uint16 *msg_buf;
|
|
struct hgusb20_dev *p_dev = (struct hgusb20_dev *)p_usb_d;
|
|
enum usb_host_io_cmd io_cmd = (enum usb_dev_io_cmd)cmd;
|
|
int32 ret = RET_OK;
|
|
|
|
switch (io_cmd) {
|
|
case USB_HOST_IO_CMD_RESET:
|
|
hgusb20_host_init(p_dev);
|
|
break;
|
|
|
|
case USB_HOST_IO_CMD_SET_CUR:
|
|
msg_buf = (uint16*)param1;
|
|
ret = usb_host_set_cur(p_dev,msg_buf[1], msg_buf[0], msg_buf[2], (uint8 *)&msg_buf[3]);
|
|
break;
|
|
|
|
case USB_HOST_IO_CMD_GET_CUR:
|
|
msg_buf = (uint16*)param1;
|
|
ret = usb_host_get_cur(p_dev,msg_buf[1], msg_buf[0], msg_buf[2], (uint8 *)&msg_buf[3]);
|
|
break;
|
|
|
|
case USB_HOST_IO_CMD_SET_IDX:
|
|
ret = enum_set_resolution(p_dev, param1);
|
|
break;
|
|
|
|
default:
|
|
ret = -ENOTSUPP;
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
extern int usb_dma_irq_times;
|
|
uint32 usb_host_bus_irq(uint32 irq, uint32 param1, uint32 param2, uint32 param3)
|
|
{
|
|
struct hgusb20_dev *p_dev = (struct hgusb20_dev *)param1;
|
|
uint32 ret_val = 1;
|
|
uint32 ep = param2 & 0xF;
|
|
uint32 len = len;
|
|
usb_dma_irq_times++;
|
|
switch (irq) {
|
|
case USB_CONNECT:
|
|
_os_printf("usb connect: \r\n");
|
|
os_sema_up(&p_dev->usb_os_msg->ep0_sema);
|
|
break;
|
|
case USB_DISCONNECT:
|
|
uac_open = 0;
|
|
hgusb20_host_reset_phy(p_dev);
|
|
_os_printf("usb disconnect................\r\n");
|
|
break;
|
|
case USB_DEV_CTL_IRQ:
|
|
ret_val = 0;
|
|
break;
|
|
case USB_BABBLE:
|
|
_os_printf("usb babble................\r\n");
|
|
break;
|
|
case USB_DEV_SUSPEND_IRQ:
|
|
break;
|
|
case USB_DEV_RESUME_IRQ:
|
|
break;
|
|
// case USB_DEV_SOF_IRQ:
|
|
// break;
|
|
case USB_EP_RX_IRQ:
|
|
|
|
|
|
// _os_printf("usb rx: %d\r\n", ep);
|
|
if(UVC_EP == ep) {
|
|
usb_dma_irq(p_dev, uvc_dat[0], (uint8_t)uvc_head_res, (uint8_t)videostream.eptpye);
|
|
}
|
|
if (UAC_EP == ep) {
|
|
usbmic_dma_irq(p_dev, usbmic_dat);
|
|
}
|
|
if (HUB_EP == ep) {
|
|
os_sema_up(&p_dev->usb_os_msg->hub_sema);
|
|
// _os_printf("hub_ep...isr...HUB:%d ISO:%d %x\r\n",HUB_EP,ISO_EP,param3);
|
|
}
|
|
break;
|
|
case USB_EP_TX_IRQ:
|
|
if (UAC_EP == ep) {
|
|
usbspk_dma_irq(p_dev);
|
|
}
|
|
// os_mutex_unlock(&p_dev->tx_lock);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return ret_val;
|
|
}
|
|
|
|
|
|
|
|
volatile uint8 hub_interrupt = 0;
|
|
|