usbvideo_drv.c

MTK平台绝密核心代码之 USB驱动

	/* record interface name and interface descriptor length */
	g_USBVideo.vc_if_info->interface_name_ptr = (kal_char *)ifname;
	g_USBVideo.vc_if_info->ifdscr_size = 0; /* Will be modified after the following attribute parts*/

	/* related endpoint info and class specific command handler*/
	g_USBVideo.vc_if_info->ep_info[0] = (Usb_Ep_Info*)g_USBVideo.vc_ep_intr_info;
	g_USBVideo.vc_if_info->if_class_specific_hdlr = USBVideo_Ep0_VC_Command;

	/* standard interface descriptor */
	p_desc = get_ctrl_buffer(sizeof(Usb_If_Dscr));
	((Usb_If_Dscr*)p_desc)->bLength = USB_IFDSC_LENGTH;
	((Usb_If_Dscr*)p_desc)->bDescriptorType = USB_INTERFACE;
	((Usb_If_Dscr*)p_desc)->bInterfaceNumber = if_id;
	((Usb_If_Dscr*)p_desc)->bAlternateSetting = 0;
	((Usb_If_Dscr*)p_desc)->bNumEndpoints = USBVIDEO_VC_EP_NUMBER;
	((Usb_If_Dscr*)p_desc)->bInterfaceClass = USBVIDEO_CC_VIDEO;
	((Usb_If_Dscr*)p_desc)->bInterfaceSubClass = USBVIDEO_SC_VIDEOCONTROL;
	((Usb_If_Dscr*)p_desc)->bInterfaceProtocol = USBVIDEO_PC_PROTOCOL_UNDEFINED;
	((Usb_If_Dscr*)p_desc)->iInterface = USB_Get_String_Number((void *)g_USBVideo.custom_param->vc_interface_string); 
	kal_mem_cpy(&g_USBVideo.vc_if_info->ifdscr.classif[if_desc_index ], p_desc, USB_IFDSC_LENGTH);
	if_desc_index += USB_IFDSC_LENGTH;
	free_ctrl_buffer(p_desc);
	
	/* class-specific VC interface descriptor */
	p_desc = get_ctrl_buffer(sizeof(USBVideo_Class_VC_If_Dscr));
	((USBVideo_Class_VC_If_Dscr*)p_desc)->bLength = USBVIDEO_VC_INTERFACE_LENGTH;
	((USBVideo_Class_VC_If_Dscr*)p_desc)->bDescriptorType = USBVIDEO_CS_INTERFACE;
	((USBVideo_Class_VC_If_Dscr*)p_desc)->bDescriptorSubType = USBVIDEO_VC_HEADER;
	//((USBVideo_Class_VC_If_Dscr*)p_desc)->bcdUSB[0] = 0x10; /* video spec rev is 1.1 */
	//((USBVideo_Class_VC_If_Dscr*)p_desc)->bcdUSB[1] = 0x01; 
	((USBVideo_Class_VC_If_Dscr*)p_desc)->bcdUSB[0] = 0x00; /* video spec rev is 1.0 */
	((USBVideo_Class_VC_If_Dscr*)p_desc)->bcdUSB[1] = 0x01; 
	total_size = sizeof(USBVideo_Class_VC_If_Dscr)+sizeof(USBVideo_CT_Dscr)+sizeof(USBVideo_OT_Dscr)+sizeof(USBVideo_PU_Dscr);
	((USBVideo_Class_VC_If_Dscr*)p_desc)->wTotalLength[0] = total_size&0xff;
	((USBVideo_Class_VC_If_Dscr*)p_desc)->wTotalLength[1] = (total_size>>8)&0xff;
	((USBVideo_Class_VC_If_Dscr*)p_desc)->dwClockFrequency[0] = USBVIDEO_CLOCK_FREQUENCY&0xff;
	((USBVideo_Class_VC_If_Dscr*)p_desc)->dwClockFrequency[1] = (USBVIDEO_CLOCK_FREQUENCY>>8)&0xff;
	((USBVideo_Class_VC_If_Dscr*)p_desc)->dwClockFrequency[2] = (USBVIDEO_CLOCK_FREQUENCY>>16)&0xff;
	((USBVideo_Class_VC_If_Dscr*)p_desc)->dwClockFrequency[3] = (USBVIDEO_CLOCK_FREQUENCY>>24)&0xff;
	((USBVideo_Class_VC_If_Dscr*)p_desc)->bInCollection = 1; /* number of VS interface*/
	((USBVideo_Class_VC_If_Dscr*)p_desc)->baInterfaceNr = if_id + 1; /* VS interface number */
	kal_mem_cpy(&g_USBVideo.vc_if_info->ifdscr.classif[if_desc_index ], p_desc, USBVIDEO_VC_INTERFACE_LENGTH);
	if_desc_index += USBVIDEO_VC_INTERFACE_LENGTH;
	free_ctrl_buffer(p_desc);
	
	/* input (camera) terminal descriptor */
	p_desc = get_ctrl_buffer(sizeof(USBVideo_CT_Dscr));
	((USBVideo_CT_Dscr*)p_desc)->bLength = USBVIDEO_VC_CT_LENGTH;
	((USBVideo_CT_Dscr*)p_desc)->bDescriptorType = USBVIDEO_CS_INTERFACE;
	((USBVideo_CT_Dscr*)p_desc)->bDescriptorSubType = USBVIDEO_VC_INPUT_TERMINAL;
	((USBVideo_CT_Dscr*)p_desc)->bTerminalID = USBVIDEO_CT_ID;
	((USBVideo_CT_Dscr*)p_desc)->wTerminalType[0] = USBVIDEO_ITT_CAMERA&0xff;
	((USBVideo_CT_Dscr*)p_desc)->wTerminalType[1] = (USBVIDEO_ITT_CAMERA>>8)&0xff;
	((USBVideo_CT_Dscr*)p_desc)->bAssocTerminal = 0x0; /* no association*/
	((USBVideo_CT_Dscr*)p_desc)->iTerminal = USB_Get_String_Number((void *)g_USBVideo.custom_param->vc_camera_string); 
	((USBVideo_CT_Dscr*)p_desc)->wObjectiveFocalLengthMin[0] = 0;
	((USBVideo_CT_Dscr*)p_desc)->wObjectiveFocalLengthMin[1] = 0;
	((USBVideo_CT_Dscr*)p_desc)->wObjectiveFocalLengthMax[0] = 0;
	((USBVideo_CT_Dscr*)p_desc)->wObjectiveFocalLengthMax[1] = 0;
	((USBVideo_CT_Dscr*)p_desc)->wOcularFocalLength[0] = 0;
	((USBVideo_CT_Dscr*)p_desc)->wOcularFocalLength[1] = 0;
	((USBVideo_CT_Dscr*)p_desc)->bControlSize = 0x2;
	attr_info = g_USBVideo.camera_param->usbvideo_get_attr_info(&attr_size);/*  look for Usbvideo_attr.c */
	if(attr_info == NULL)
		EXT_ASSERT(0, attr_size, 0, 0);
	map_size = sizeof(g_USBVideo_CT_Attr_Map)/sizeof(USBVideo_Attr_Map);
	for(attr_index = 0; attr_index < attr_size; attr_index++)
	{
		if(attr_info[attr_index].b_feature == KAL_TRUE)
		{
			for(map_index = 0; map_index < map_size; map_index++)
			{
				if(g_USBVideo_CT_Attr_Map[map_index].attr_type==attr_info[attr_index].type)
				{
					/* descriptor attr */
					ct_attr |= (1<<g_USBVideo_CT_Attr_Map[map_index].shift);/* add into descriptor*/
					/* supported list */
					g_USBVideo.vc_ct_support |= (1<<attr_info[attr_index].type);
					/* support set attribute list*/
					if(attr_info[attr_index].b_set == KAL_TRUE)
						g_USBVideo.vc_ct_set |= (1<<attr_info[attr_index].type);
				}	
			}
			
			/* check attr in this descriptor */
			if(attr_info[attr_index].type == USBVIDEO_ATTRIBUTE_FOCAL_MIN)
			{
				attr_value.type = USBVIDEO_ATTRIBUTE_FOCAL_MIN;
				attr_value.req_type = USBVIDEO_REQUEST_GET_CUR;
				g_USBVideo.camera_param->usbvideo_get_attr_value(&attr_value);
				((USBVideo_CT_Dscr*)p_desc)->wObjectiveFocalLengthMin[0] = attr_value.value&0xff;
				((USBVideo_CT_Dscr*)p_desc)->wObjectiveFocalLengthMin[1] = (attr_value.value>>8)&0xff;
			}
			else if(attr_info[attr_index].type == USBVIDEO_ATTRIBUTE_FOCAL_MAX)
			{
				attr_value.type = USBVIDEO_ATTRIBUTE_FOCAL_MAX;
				attr_value.req_type = USBVIDEO_REQUEST_GET_CUR;
				g_USBVideo.camera_param->usbvideo_get_attr_value(&attr_value);
				((USBVideo_CT_Dscr*)p_desc)->wObjectiveFocalLengthMax[0] = attr_value.value&0xff;
				((USBVideo_CT_Dscr*)p_desc)->wObjectiveFocalLengthMax[1] = (attr_value.value>>8)&0xff;	
			}
			else if(attr_info[attr_index].type == USBVIDEO_ATTRIBUTE_FOCAL_LENGTH)
			{
				attr_value.type = USBVIDEO_ATTRIBUTE_FOCAL_LENGTH;
				attr_value.req_type = USBVIDEO_REQUEST_GET_CUR;
				g_USBVideo.camera_param->usbvideo_get_attr_value(&attr_value);
				((USBVideo_CT_Dscr*)p_desc)->wOcularFocalLength[0] = attr_value.value&0xff;
				((USBVideo_CT_Dscr*)p_desc)->wOcularFocalLength[1] = (attr_value.value>>8)&0xff;	
			}
		}		
	}
	((USBVideo_CT_Dscr*)p_desc)->bmControls[0] = ct_attr&0xff;
	((USBVideo_CT_Dscr*)p_desc)->bmControls[1] = (ct_attr>>8)&0xff;
	kal_mem_cpy(&g_USBVideo.vc_if_info->ifdscr.classif[if_desc_index ], p_desc, USBVIDEO_VC_CT_LENGTH);
	if_desc_index += USBVIDEO_VC_CT_LENGTH;
	free_ctrl_buffer(p_desc);

	/* output terminal descriptor */
	p_desc = get_ctrl_buffer(sizeof(USBVideo_OT_Dscr));
	((USBVideo_OT_Dscr*)p_desc)->bLength = USBVIDEO_VC_OT_LENGTH;
	((USBVideo_OT_Dscr*)p_desc)->bDescriptorType = USBVIDEO_CS_INTERFACE;
	((USBVideo_OT_Dscr*)p_desc)->bDescriptorSubType = USBVIDEO_VC_OUTPUT_TERMINAL;
	((USBVideo_OT_Dscr*)p_desc)->bTerminalID = USBVIDEO_OT_ID;
	((USBVideo_OT_Dscr*)p_desc)->wTerminalType[0] = USBVIDEO_TT_STREAMING&0xff;
	((USBVideo_OT_Dscr*)p_desc)->wTerminalType[1] = (USBVIDEO_TT_STREAMING>>8)&0xff;
	((USBVideo_OT_Dscr*)p_desc)->bAssocTerminal = 0x0; /* no association*/
	((USBVideo_OT_Dscr*)p_desc)->bSourceID = USBVIDEO_PU_ID;
	((USBVideo_OT_Dscr*)p_desc)->iTerminal = USB_Get_String_Number((void *)g_USBVideo.custom_param->vc_output_string); 
	kal_mem_cpy(&g_USBVideo.vc_if_info->ifdscr.classif[if_desc_index ], p_desc, USBVIDEO_VC_OT_LENGTH);
	if_desc_index += USBVIDEO_VC_OT_LENGTH;
	free_ctrl_buffer(p_desc);
	
	/* processing unit descriptor */
	p_desc = get_ctrl_buffer(sizeof(USBVideo_PU_Dscr));
	((USBVideo_PU_Dscr*)p_desc)->bLength = USBVIDEO_VC_PU_LENGTH;
	((USBVideo_PU_Dscr*)p_desc)->bDescriptorType = USBVIDEO_CS_INTERFACE;
	((USBVideo_PU_Dscr*)p_desc)->bDescriptorSubType = USBVIDEO_VC_PROCESSING_UNIT;
	((USBVideo_PU_Dscr*)p_desc)->bUintID = USBVIDEO_PU_ID;
	((USBVideo_PU_Dscr*)p_desc)->bSourceID = USBVIDEO_CT_ID;
	((USBVideo_PU_Dscr*)p_desc)->wMaxMultiplier[0] = 0;
	((USBVideo_PU_Dscr*)p_desc)->wMaxMultiplier[1] = 0;
        ((USBVideo_PU_Dscr*)p_desc)->bControlSize = 0x2;
	map_size = sizeof(g_USBVideo_PU_Attr_Map)/sizeof(USBVideo_Attr_Map);
	for(attr_index = 0; attr_index < attr_size; attr_index++)
	{
		if(attr_info[attr_index].b_feature == KAL_TRUE)
		{
			for(map_index = 0; map_index < map_size; map_index++)
			{
				if(g_USBVideo_PU_Attr_Map[map_index].attr_type==attr_info[attr_index].type)
				{
					/* descriptor attr */
					pu_attr |= (1<<g_USBVideo_PU_Attr_Map[map_index].shift);
					/* supported list */
					g_USBVideo.vc_pu_support |= (1<<(attr_info[attr_index].type&(~0x80)));
					/* support set attribute list*/
					if(attr_info[attr_index].b_set == KAL_TRUE)
						g_USBVideo.vc_pu_set |= (1<<(attr_info[attr_index].type&(~0x80)));
				}	
			}
			
			/* get attr in this descriptor*/
			if(attr_info[attr_index].type == USBVIDEO_ATTRIBUTE_MAX_MULTIPLIER)
			{
				attr_value.type = USBVIDEO_ATTRIBUTE_MAX_MULTIPLIER;
				attr_value.req_type = USBVIDEO_REQUEST_GET_CUR;
				g_USBVideo.camera_param->usbvideo_get_attr_value(&attr_value);	
				((USBVideo_PU_Dscr*)p_desc)->wMaxMultiplier[0] = attr_value.value&0xff;
				((USBVideo_PU_Dscr*)p_desc)->wMaxMultiplier[1] = (attr_value.value>>8)&0xff;
			}
		}		
	}
	((USBVideo_PU_Dscr*)p_desc)->bmControls[0] = pu_attr&0xff;
	((USBVideo_PU_Dscr*)p_desc)->bmControls[1] = (pu_attr>>8)&0xff;
	((USBVideo_PU_Dscr*)p_desc)->iProcessing = USB_Get_String_Number((void *)g_USBVideo.custom_param->vc_processing_unit_string); 
	//((USBVideo_PU_Dscr*)p_desc)->bmVideoStandards	= 0;  /* for 1.1 revision */
	
	kal_mem_cpy(&g_USBVideo.vc_if_info->ifdscr.classif[if_desc_index ], p_desc, USBVIDEO_VC_PU_LENGTH);
	if_desc_index += USBVIDEO_VC_PU_LENGTH;
	free_ctrl_buffer(p_desc);

	/* endpoint handler*/
	USB_Register_Drv_Info(USB_DRV_HDLR_EP_IN, ep_id, USBVideo_IntrIn_Hdlr);
	g_USBVideo.vc_ep_intr_info->ep_reset = USBVideo_IntrIn_Reset;

	/* standard interrupt endpoint descriptor */
	p_desc = get_ctrl_buffer(sizeof(Usb_Ep_Dscr));
	((Usb_Ep_Dscr*)p_desc)->bLength = USB_EPDSC_LENGTH;
	((Usb_Ep_Dscr*)p_desc)->bDescriptorType = USB_ENDPOINT;
	((Usb_Ep_Dscr*)p_desc)->bEndpointAddress = (USB_EP_DIR_IN | ep_id);	/*InPipe*/
	((Usb_Ep_Dscr*)p_desc)->bmAttributes = USB_EP_INTR;
	((Usb_Ep_Dscr*)p_desc)->wMaxPacketSize[0] = USB_EP_INTR_MAXP&0xff; 		/*HW-dependent*/
	((Usb_Ep_Dscr*)p_desc)->wMaxPacketSize[1] = (USB_EP_INTR_MAXP>>8)&0xff;
	((Usb_Ep_Dscr*)p_desc)->bInterval = 1;
	g_USBVideo.vc_ep_intr_info->ep_status.epin_status.byEP = ep_id;
	g_USBVideo.vc_ep_intr_info->ep_status.epin_status.nBytesLeft = USB_EP_NODATA;
	kal_mem_cpy(&g_USBVideo.vc_ep_intr_info->epdesc.classep[ep_desc_index], p_desc, USB_EPDSC_LENGTH);
	ep_desc_index +=USB_EPDSC_LENGTH;
	free_ctrl_buffer(p_desc);

	/* class-specific interrupt endpoint descriptor */
	p_desc = get_ctrl_buffer(sizeof(USBVideo_Intr_Ep_Dscr));
	((USBVideo_Intr_Ep_Dscr*)p_desc)->bLength = USBVIDEO_VC_INTR_LENGTH;
	((USBVideo_Intr_Ep_Dscr*)p_desc)->bDescriptorType = USBVIDEO_CS_ENDPOINT;
	((USBVideo_Intr_Ep_Dscr*)p_desc)->bDescriptorSubType = USB_EP_INTR;	
	((USBVideo_Intr_Ep_Dscr*)p_desc)->wMaxTransferSize[0] = USB_EP_INTR_MAXP&0xff;
	((USBVideo_Intr_Ep_Dscr*)p_desc)->wMaxTransferSize[1] = (USB_EP_INTR_MAXP>>8)&0xff;
	kal_mem_cpy(&g_USBVideo.vc_ep_intr_info->epdesc.classep[ep_desc_index], p_desc, USBVIDEO_VC_INTR_LENGTH);
	ep_desc_index+=USBVIDEO_VC_INTR_LENGTH;
	free_ctrl_buffer(p_desc);

	/* construct interface size */
	g_USBVideo.vc_if_info->ifdscr_size = if_desc_index;
	g_USBVideo.vc_ep_intr_info->epdscr_size = ep_desc_index;
}


/* video control interface reset  function, enable interrupt endpoint */
void USBVideo_VC_If_Reset(void)
{
	g_USBVideo.intrpipe = &g_USBVideo.vc_ep_intr_info->ep_status.epin_status;
	
	/*Non-DMA*/
	USB_InEPEn(g_USBVideo.vc_ep_intr_info->ep_status.epin_status.byEP, KAL_FALSE);
}

/* video streaming interface create function, prepare descriptor */
void USBVideo_VS_If_Create(void *ifname)
{
	kal_uint8 ep_in_id;
	kal_uint8 if_id;
	kal_uint8 iad_id;
	kal_uint8 video_size_num;
	kal_uint8 still_size_num;
	kal_uint8 compression_num;
	//kal_uint8 incall_jpeg_size_num;
	kal_uint32 index;
	kal_uint32 total_length;
	const USBVideo_Video_Size_Info *p_video_size_param;
	const USBVideo_Still_Size_Info *p_still_size_param;
	const USBVideo_Compression_Info *p_compression_param;
	kal_uint8* p_desc;
	kal_uint32 if_desc_index = 0;
	kal_uint32 max_frame_size;

	p_video_size_param = g_USBVideo.camera_param->usbvideo_get_video_size_info(&video_size_num);
	p_still_size_param = g_USBVideo.camera_param->usbvideo_get_still_size_info(&still_size_num);
	p_compression_param = g_USBVideo.camera_param->usbvideo_get_compression_info(&compression_num);

	g_USBVideo.video_control.p_video_size_info = p_video_size_param;
	g_USBVideo.video_control.video_size_num = video_size_num;
	g_USBVideo.video_control.p_still_size_info = p_still_size_param;
	g_USBVideo.video_control.still_size_num = still_size_num;

	/* check the sequence index, following design should have this assumption  */
	for(index = 0; index < video_size_num; index++)
	{
		if((kal_uint32)p_video_size_param[index].type != (index + 1))
			EXT_ASSERT(0, index, (kal_uint32)p_video_size_param[index].type, 0);
	}
	for(index = 0; index < still_size_num; index++)
	{
		if((kal_uint32)p_still_size_param[index].type != (index + 1))
			EXT_ASSERT(0, index, (kal_uint32)p_still_size_param[index].type, 0);
	}
	for(index = 0; index < compression_num; index++)
	{
		if((kal_uint32)p_compression_param[index].type != (index + 1))
			EXT_ASSERT(0, index, (kal_uint32)p_compression_param[index].type, 0);
	}

#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif

	/* get resource number and register to gUsbDevice */
	g_USBVideo.vs_if_info = USB_Get_Interface_Number(&if_id);
	g_USBVideo.vs_interface_id = if_id;
	g_USBVideo.vs_ep_in_info = USB_Get_BulkIn_Ep(&ep_in_id);
	
	/* record interface name and interface descriptor length */
	g_USBVideo.vs_if_info->interface_name_ptr = (kal_char *)ifname;
	g_USBVideo.vs_if_info->ifdscr_size = 0; /* Will be modified after the following attribute parts*/

	/* related endpoint info and class specific command handler*/
	g_USBVideo.vs_if_info->ep_info[0] = g_USBVideo.vs_ep_in_info;
	g_USBVideo.vs_if_info->if_class_specific_hdlr = USBVideo_Ep0_VS_Command;

	/* standard interface descriptor */
	p_desc = get_ctrl_buffer(sizeof(Usb_If_Dscr));
	((Usb_If_Dscr*)p_desc)->bLength = USB_IFDSC_LENGTH;
	((Usb_If_Dscr*)p_desc)->bDescriptorType = USB_INTERFACE;
	((Usb_If_Dscr*)p_desc)->bInterfaceNumber = if_id;
	((Usb_If_Dscr*)p_desc)->bAlternateSetting = 0;
	((Usb_If_Dscr*)p_desc)->bNumEndpoints = USBVIDEO_VS_EP_NUMBER;