usbimage_drv.c

mtk 6225平台的usb程序！ 对想了解mtk平台usb的朋友会有帮助！

		
		if (g_USBImage.cancel_block.Cancellation_Code != PTP_CANCEL_TRANSACTION)
			ASSERT(0);

		cancel_transaction_ID = (kal_uint16)g_USBImage.cancel_block.TransactionID[1];
		cancel_transaction_ID <<= 16;
		cancel_transaction_ID |= (kal_uint16)g_USBImage.cancel_block.TransactionID[0];
		
		if (cancel_transaction_ID != g_USBImage.current_transactionID)
		{
			EXT_ASSERT(0, g_USBImage.current_transactionID, cancel_transaction_ID, 0);
		}
		else
		{
			g_USBImage.host_cancel_flag = KAL_TRUE;
			USB_Image_Cmd_Reset();
			USB_Image_BulkIn_Reset();
			USB_Image_BulkOut_Reset();	
		}
		gUsbDevice.ep0_state = USB_EP0_RX_STATUS;
   		USB_Update_EP0_State(USB_EP0_DRV_STATE_READ_END, KAL_FALSE, KAL_TRUE);
	}
	else
		EXT_ASSERT(0, nCount , 0, 0);	
}


/* parse image class specific commands */
static void USB_Image_Ep0_Command(Usb_Ep0_Status *pep0state, Usb_Command *pcmd)
{
	kal_uint8  bError = KAL_FALSE;

	switch (pcmd->bRequest)
	{
		case  USB_IMAGE_RESET:
			if( (pcmd->bmRequestType != USB_CMD_CLASSIFOUT) ||(pcmd->wValue != 0) ||(pcmd->wIndex != 0) )
			{
				bError = KAL_TRUE;
#ifndef  __PRODUCTION_RELEASE__			
				EXT_ASSERT(0, (kal_uint32)pcmd->bmRequestType, (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
#endif
			}
			else
			{
				USB_Image_Cmd_Reset();
				USB_Image_BulkIn_Reset();
				USB_Image_BulkOut_Reset();
				USB_Image_IntrIn_Reset();
			}
			break;
		case  USB_IMAGE_CANCEL:
			if( (pcmd->bmRequestType != USB_CMD_CLASSIFOUT) ||(pcmd->wValue != 0) ||(pcmd->wIndex != 0)||(pcmd->wLength != 6))
			{
				bError = KAL_TRUE;
#ifndef  __PRODUCTION_RELEASE__				
				EXT_ASSERT(0, (kal_uint32)pcmd->bmRequestType, (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
#endif
			}
			else
			{
				gUsbDevice.ep0_state = USB_EP0_RX;
			}
			break;
		case  USB_IMAGE_GET_DEVICE_STATUS:
			if( (pcmd->bmRequestType != USB_CMD_CLASSIFIN) ||(pcmd->wValue != 0) ||(pcmd->wIndex != 0) )
			{
				bError = KAL_TRUE;
#ifndef  __PRODUCTION_RELEASE__				
				EXT_ASSERT(0, (kal_uint32)pcmd->bmRequestType, (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
#endif
			}
			else
			{
				if(g_USBImage.host_cancel_flag == KAL_TRUE)
				{
					g_USBImage.device_status.wLength = 4;
					g_USBImage.device_status.Code = PTP_DEVICE_BUSY;
					USB_Generate_EP0Data(pep0state, pcmd, &g_USBImage.device_status, 4);
				}
//				else if(g_USBImage.device_cancel_flag == KAL_TRUE)
//				{
//					g_USBImage.device_status.wLength = 10;
//					g_USBImage.device_status.Code = PTP_TRANSACTION_CANCELLED;
//					g_USBImage.device_status.Num_para = 1;
//					g_USBImage.device_status.Para_size = 2;
//					g_USBImage.device_status.endpoint = (g_USBImage.txpipe->byEP |USB_EP_DIR_IN);
//					USB_Generate_EP0Data(pep0state, pcmd, &g_USBImage.device_status, 10);
//				}
				else
				{
					g_USBImage.device_status.wLength = 4;
					g_USBImage.device_status.Code = PTP_OK;
					USB_Generate_EP0Data(pep0state, pcmd, &g_USBImage.device_status, 4);
				}
			}
			break;
		default:
			bError = KAL_TRUE;
#ifndef  __PRODUCTION_RELEASE__			
			EXT_ASSERT(0, pcmd->bRequest, 0, 0);
#endif
			break;
	}

	if (gUsbDevice.ep0_state == USB_EP0_IDLE)
	{
		gUsbDevice.ep0_state = USB_EP0_RX_STATUS;
		USB_Update_EP0_State(USB_EP0_DRV_STATE_READ_END, bError, KAL_TRUE);
	}
	else
		USB_Update_EP0_State(USB_EP0_DRV_STATE_READ_END, bError, KAL_FALSE);
}

/************************************************************
	endpoint reset  functions
*************************************************************/
/* Bulk In endpoint reset function */
static void USB_Image_BulkIn_Reset(void)
{
	return;
}

/* Bulk Out endpoint reset function */
static void USB_Image_BulkOut_Reset(void)
{
	return;
}

/* Interrupt endpoint reset function */
static void USB_Image_IntrIn_Reset(void)
{
	g_USBImage.intr_done = KAL_TRUE;
}
/************************************************************
	Interrupt EP IN handle functions
*************************************************************/

/* Interrupt endpoint done handler */
static void USB_Image_IntrIn_Hdlr(void)
{
	/* To do is to set interrupt done flag */
	g_USBImage.intr_done = KAL_TRUE;
}

/************************************************************
	Bulk EP OUT handle functions
*************************************************************/
/* EP Bulk Out interrupt handler, called by EP interrupt */
static void USB_Image_BulkOut_Hdr(void)
{
	kal_uint32	nCount;
	ilm_struct 	*usb_ilm;

	/* check data length */
	nCount = USB_EP_Out_Pkt_Len(g_USBImage.rxpipe->byEP);
	
	if(g_USBImage.state == PTP_CMD_RX)
	{
		/* read the data out */
		USB_EPFIFORead(g_USBImage.rxpipe->byEP, nCount, &g_USBImage.image_cmd);
		g_USBImage.current_transactionID = g_USBImage.image_cmd.TransactionID;

		if((g_USBImage.image_cmd.Code == PTP_SEND_OBJECT_INFO)||(g_USBImage.image_cmd.Code == PTP_SEND_OBJECT))
		{	
			/* no message send to PTP state machine */
			g_USBImage.state = PTP_DATA_RX;
			g_USBImage.current_rx_bytes = 0;
			if(g_USBImage.image_cmd.Code == PTP_SEND_OBJECT_INFO)
			{
				if((g_USBImage.image_cmd.Parameter1 != 0x00000000)||(g_USBImage.image_cmd.Parameter2 != 0x00000000))
				{
#ifndef  __PRODUCTION_RELEASE__			
					EXT_ASSERT(0, g_USBImage.image_cmd.Parameter1, g_USBImage.image_cmd.Parameter2, 0);
#endif
					/* cancel transaction interrupt */
					g_USBImage.image_event.ContainerLength = USB_IMAGE_CONTAINER_LENGTH;
					g_USBImage.image_event.Code = PTP_CANCEL_TRANSACTION;
					g_USBImage.image_event.TransactionID = g_USBImage.current_transactionID;
					USB_Image_Send_Intr(&g_USBImage.image_event, USB_IMAGE_CONTAINER_LENGTH);

					/* Send Response */
					g_USBImage.state = PTP_CMD_RX;
					g_USBImage.image_response.ContainerLength = USB_IMAGE_CONTAINER_LENGTH;
					g_USBImage.image_response.Code = PTP_PARAMETER_NOT_SUPPORTED;
					g_USBImage.image_response.TransactionID = g_USBImage.current_transactionID;
					USB_Image_ReturnTx(&g_USBImage.image_response, USB_IMAGE_CONTAINER_LENGTH);
				}
			}
		}
		else
		{
			DRV_BuildPrimitive(usb_ilm, MOD_DRV_HISR, MOD_USB, 
							MSG_ID_USB_PTPIMAGE_DATA_RX_DONE_CONF, NULL);
			msg_send_ext_queue(usb_ilm);
		}
		
		/* Clear OutPktRdy here, because no two cmds coming  */
		USB_EP_Bulk_Out_Ready(g_USBImage.rxpipe->byEP);
	}
	else if(g_USBImage.state == PTP_DATA_RX)
	{
		if(g_USBImage.current_rx_bytes == 0)			/* begin to receive data packet */
		{
			PTP_CONTAINER		*data;			
			if(g_USBImage.image_cmd.Code == PTP_SEND_OBJECT)
			{
				if(g_USBImage.dps_rx_buffer_index == 1)  
				{
					/* read the data out */
					USB_EPFIFORead(g_USBImage.rxpipe->byEP, nCount, g_USBImage.dps_request_rx_data);
					data = (PTP_CONTAINER*)g_USBImage.dps_request_rx_data;
					g_USBImage.total_rx_bytes = data->ContainerLength;
				}
				else
				{
					/* read the data out */
					USB_EPFIFORead(g_USBImage.rxpipe->byEP, nCount, g_USBImage.dps_response_rx_data);
					data = (PTP_CONTAINER*)g_USBImage.dps_response_rx_data;
					g_USBImage.total_rx_bytes = data->ContainerLength;
				}
			}
			else 	/* send object info */
			{
				/* read the data out */
				USB_EPFIFORead(g_USBImage.rxpipe->byEP, nCount, g_USBImage.image_buffer);
				data = (PTP_CONTAINER*)g_USBImage.image_buffer;
				g_USBImage.total_rx_bytes = data->ContainerLength;
			}
		}
		else
		{
			if(g_USBImage.image_cmd.Code == PTP_SEND_OBJECT)
			{
				if(g_USBImage.dps_rx_buffer_index == 1)  
				{
					USB_EPFIFORead(g_USBImage.rxpipe->byEP, nCount, 
						g_USBImage.dps_request_rx_data + g_USBImage.current_rx_bytes);	
				}
				else
				{
					USB_EPFIFORead(g_USBImage.rxpipe->byEP, nCount, 
						g_USBImage.dps_response_rx_data + g_USBImage.current_rx_bytes);	
				}
			}
			else
			{
				USB_EPFIFORead(g_USBImage.rxpipe->byEP, nCount, 
					(kal_uint8 *)g_USBImage.image_buffer + g_USBImage.current_rx_bytes);
			}
		}
			
		g_USBImage.current_rx_bytes += nCount;

		if(g_USBImage.current_rx_bytes > g_USBImage.total_rx_bytes)
		{
			EXT_ASSERT(0, g_USBImage.current_rx_bytes, g_USBImage.total_rx_bytes, 0);
		}
		else if(g_USBImage.current_rx_bytes == g_USBImage.total_rx_bytes)
		{
			g_USBImage.state = PTP_RESPONSE;
			DRV_BuildPrimitive(usb_ilm, MOD_DRV_HISR, MOD_USB, 
							MSG_ID_USB_PTPIMAGE_DATA_RX_DONE_CONF, NULL);
			msg_send_ext_queue(usb_ilm);
		}
		else
		{
			/* Clear OutPktRdy */
			USB_EP_Bulk_Out_Ready(g_USBImage.rxpipe->byEP);
		}
	}
	else
		ASSERT(0);
}

/************************************************************
	Send message functions used by the whole image class driver 
*************************************************************/
void USB_Image_Send_Msg(USBIMAGE_MSG_TYPE msg_type, kal_uint32 param1, kal_uint32 param2)
{
	usb_image_xml_struct		*xml_receive_ind;
	usb_image_start_struct		*dps_xml_ind;
	ilm_struct 				*usb_ilm;
	module_type 				dest_mod;
	
#if (defined(__PICTBRIDGE_USB_TEST__) )
	dest_mod = MOD_CUSTOM1;
#else
	dest_mod = MOD_MMI;
#endif
	/* mmi must view this message as reset message! */
	if(msg_type == USB_IMAGE_MSG_MMI_DISCOVERY_IND)
	{
		dps_xml_ind = (usb_image_start_struct*)construct_local_para(
							sizeof(usb_image_start_struct), TD_CTRL);

		dps_xml_ind->dps_request_address = g_USBImage.dps_request_tx_data + USB_IMAGE_CONTAINER_LENGTH;
		dps_xml_ind->dps_response_address = g_USBImage.dps_response_tx_data + USB_IMAGE_CONTAINER_LENGTH;

		/* send a message to mmi, let it know the addresses can be placed xml packet  */
		DRV_BuildPrimitive(usb_ilm, MOD_USB, dest_mod, 
							MSG_ID_USB_MMI_DPS_DISCOVERY_IND, dps_xml_ind);
		msg_send_ext_queue(usb_ilm);
	}
	else if(msg_type == USB_IMAGE_MSG_MMI_HREQUEST_IND)
	{
		xml_receive_ind = (usb_image_xml_struct*)construct_local_para(
							sizeof(usb_image_xml_struct), TD_CTRL);

		xml_receive_ind->xml_address = g_USBImage.dps_request_rx_data 
										+ USB_IMAGE_CONTAINER_LENGTH;
		xml_receive_ind->xml_packet_size = g_USBImage.received_xml_size;
	
		/* send a message to mmi, let it know a request xml packet arrive */
		DRV_BuildPrimitive(usb_ilm, MOD_USB, dest_mod, 
							MSG_ID_USB_MMI_DPS_HREQUEST_IND, xml_receive_ind);
		msg_send_ext_queue(usb_ilm);
	}
	else if (msg_type == USB_IMAGE_MSG_MMI_HRESPONSE_IND)
	{
		xml_receive_ind = (usb_image_xml_struct*)construct_local_para(
							sizeof(usb_image_xml_struct), TD_CTRL);

		xml_receive_ind->xml_address = g_USBImage.dps_response_rx_data 
										+ USB_IMAGE_CONTAINER_LENGTH;
		xml_receive_ind->xml_packet_size = g_USBImage.received_xml_size;
			
		/* send a message to mmi, let it know a response xml packet arrive */
		DRV_BuildPrimitive(usb_ilm, MOD_USB, dest_mod, 
							MSG_ID_USB_MMI_DPS_HRESPONSE_IND, xml_receive_ind);
		msg_send_ext_queue(usb_ilm);
	}
	else if (msg_type == USB_IMAGE_MSG_MMI_DREQUEST_CONF)
	{
		DRV_BuildPrimitive(usb_ilm, MOD_USB, dest_mod, 
							MSG_ID_USB_MMI_DPS_DREQUEST_CONF, NULL);
		msg_send_ext_queue(usb_ilm);
	}
	else if (msg_type == USB_IMAGE_MSG_MMI_DRESPONSE_CONF)
	{
		DRV_BuildPrimitive(usb_ilm, MOD_USB, dest_mod, 
							MSG_ID_USB_MMI_DPS_DRESPONSE_CONF, NULL);
		msg_send_ext_queue(usb_ilm);
	}
}