⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 otg_dev.c

📁 s3c6400 ADS下官方测试程序
💻 C
📖 第 1 页 / 共 5 页
字号:
				OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, oOtgDev.m_uControlEPMaxPktSize);
				if (oOtgDev.m_eSpeed == USB_HIGH)
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(0<<0));	//ep0 enable, clear nak, next ep0, 64byte
				else
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
				OTGDEV_WrPktEp0((u8 *)aDescStr1+(oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize), oOtgDev.m_uControlEPMaxPktSize);
				oOtgDev.m_uEp0State = EP0_STATE_GD_STR_I1;
				oOtgDev.m_uEp0SubState++;
			}
			else
			{
				OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, sizeof(aDescStr1)-(oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize));
				if (oOtgDev.m_eSpeed == USB_HIGH)
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(0<<0));	//ep0 enable, clear nak, next ep0, 64byte
				else
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
				OTGDEV_WrPktEp0((u8 *)aDescStr1+(oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize), sizeof(aDescStr1)-(oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize));
				oOtgDev.m_uEp0State = EP0_STATE_INIT;
				oOtgDev.m_uEp0SubState = 0;
			}
			break;

		case EP0_STATE_GD_STR_I2:
			DbgUsb("[GDS2_%d]", oOtgDev.m_uEp0SubState);
			if ((oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize+oOtgDev.m_uControlEPMaxPktSize)<sizeof(aDescStr2))
			{
				OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, oOtgDev.m_uControlEPMaxPktSize);
				if (oOtgDev.m_eSpeed == USB_HIGH)
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(0<<0));	//ep0 enable, clear nak, next ep0, 64byte
				else
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
				OTGDEV_WrPktEp0((u8 *)aDescStr2+(oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize), oOtgDev.m_uControlEPMaxPktSize);
				oOtgDev.m_uEp0State = EP0_STATE_GD_STR_I2;
				oOtgDev.m_uEp0SubState++;
			}
			else
			{
				OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, sizeof(aDescStr2)-(oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize));
				if (oOtgDev.m_eSpeed == USB_HIGH)
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(0<<0));	//ep0 enable, clear nak, next ep0, 64byte
				else
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
				DbgUsb("[E]");
				OTGDEV_WrPktEp0((u8 *)aDescStr2+(oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize), sizeof(aDescStr2)-(oOtgDev.m_uEp0SubState*oOtgDev.m_uControlEPMaxPktSize));
				oOtgDev.m_uEp0State = EP0_STATE_INIT;
				oOtgDev.m_uEp0SubState = 0;
			}
			break;

		case EP0_STATE_CONFIGURATION_GET:
			OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 1);
			Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
			Outp32(EP0_FIFO, g_usConfig);
			oOtgDev.m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_STATE_INTERFACE_GET:
			OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 1);
			Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
			OTGDEV_WrPktEp0((u8 *)&oInterfaceGet+0, 1);
			oOtgDev.m_uEp0State = EP0_STATE_INIT;
			break;


		case EP0_STATE_GET_STATUS0:
			OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 1);
			Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
			OTGDEV_WrPktEp0((u8 *)&oStatusGet+0, 1);
			oOtgDev.m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_STATE_GET_STATUS1:
			OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 1);
			Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
			OTGDEV_WrPktEp0((u8 *)&oStatusGet+1, 1);
			oOtgDev.m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_STATE_GET_STATUS2:
			OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 1);
			Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
			OTGDEV_WrPktEp0((u8 *)&oStatusGet+2, 1);
			oOtgDev.m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_STATE_GET_STATUS3:
			OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 1);
			Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
			OTGDEV_WrPktEp0((u8 *)&oStatusGet+3, 1);
			oOtgDev.m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_STATE_GET_STATUS4:
			OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 1);
			Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
			OTGDEV_WrPktEp0((u8 *)&oStatusGet+4, 1);
			oOtgDev.m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_STATE_TEST_MODE:					
			switch(oOtgDev.m_oDeviceRequest.wIndex_H)
			{	
				u32 uTemp;
				
				case TEST_J:
					//Set Test J
					OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 0);
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
					Disp ("Test_J\n");
					uTemp = Inp32(DCTL);
					uTemp = uTemp & ~(TEST_CONTROL_FIELD) | (TEST_J_MODE);						
					Outp32(DCTL,uTemp);
					oOtgDev.m_uEp0State = EP0_STATE_INIT;
					break;

				case TEST_K:
					//Set Test K
					OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 0);
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
					Disp ("Test_K\n");
					uTemp = Inp32(DCTL);
					uTemp = uTemp & ~(TEST_CONTROL_FIELD) | (TEST_K_MODE);						
					Outp32(DCTL,uTemp);
					oOtgDev.m_uEp0State = EP0_STATE_INIT;
					break;

				case TEST_SE0_NAK:
					//Set Test SE0_NAK
					OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 0);
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
					Disp ("Test_SE0_NAK\n");
					uTemp = Inp32(DCTL);
					uTemp = uTemp & ~(TEST_CONTROL_FIELD) | (TEST_SE0_NAK_MODE);						
					Outp32(DCTL,uTemp);
					oOtgDev.m_uEp0State = EP0_STATE_INIT;
					break;

				case TEST_PACKET:
					//Set Test Packet
					OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 0);
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
					OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, TEST_PKT_SIZE);
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(0<<0));	//ep0 enable, clear nak, next ep0, 64byte
					OTGDEV_WrPktEp0(TestPkt, TEST_PKT_SIZE);
					Disp ("Test_Packet\n");
					uTemp = Inp32(DCTL);
					uTemp = uTemp & ~(TEST_CONTROL_FIELD) | (TEST_PACKET_MODE);						
					Outp32(DCTL,uTemp);
					oOtgDev.m_uEp0State = EP0_STATE_INIT;
					break;	
					
				case TEST_FORCE_ENABLE:
					//Set Test Force Enable
					OTGDEV_SetInEpXferSize(EP_TYPE_CONTROL, 1, 0);
					Outp32(DIEPCTL0, (1u<<31)|(1<<26)|(CONTROL_EP<<11)|(3<<0));	//ep0 enable, clear nak, next ep0, 8byte
					Disp ("Test_Force_Enable\n");
					uTemp = Inp32(DCTL);
					uTemp = uTemp & ~(TEST_CONTROL_FIELD) | (TEST_FORCE_ENABLE_MODE);						
					Outp32(DCTL,uTemp);
					oOtgDev.m_uEp0State = EP0_STATE_INIT;
					break;	
			}

		default:
			break;
	}
}


//////////
// Function Name : OTGDEV_HandleEvent_BulkIn
// Function Desctiption : This function handles bulk in transfer in CPU mode.
// Input : NONE
// Output : NONE
// Version :
void OTGDEV_HandleEvent_BulkIn(void)
{
	u8* BulkInBuf;
	u32 uRemainCnt;

	DbgUsb("CPU_MODE Bulk In Function\n");
	
	BulkInBuf = (u8*)oOtgDev.m_pUpPt;
	
	uRemainCnt = oOtgDev.m_uUploadSize- ((u32)oOtgDev.m_pUpPt - oOtgDev.m_uUploadAddr);

	if (uRemainCnt > oOtgDev.m_uBulkInEPMaxPktSize)
	{
		OTGDEV_SetInEpXferSize(EP_TYPE_BULK, 1, oOtgDev.m_uBulkInEPMaxPktSize);
		Outp32(bulkIn_DIEPCTL, 1u<<31|1<<26|2<<18|1<<15|oOtgDev.m_uBulkInEPMaxPktSize<<0);		//ep3 enable, clear nak, bulk, usb active, next ep3, max pkt 64
		OTGDEV_WrPktBulkInEp(BulkInBuf, oOtgDev.m_uBulkInEPMaxPktSize);

		oOtgDev.m_pUpPt += oOtgDev.m_uBulkInEPMaxPktSize;
	}	
	else if(uRemainCnt > 0)
	{		
		OTGDEV_SetInEpXferSize(EP_TYPE_BULK, 1, uRemainCnt);
		Outp32(bulkIn_DIEPCTL, 1u<<31|1<<26|2<<18|1<<15|oOtgDev.m_uBulkInEPMaxPktSize<<0);		//ep3 enable, clear nak, bulk, usb active, next ep3, max pkt 64
		OTGDEV_WrPktBulkInEp(BulkInBuf, uRemainCnt);

		oOtgDev.m_pUpPt += uRemainCnt;
	}
	else	//uRemainCnt = 0
	{
		Outp32(bulkIn_DIEPCTL, (DEPCTL_SNAK|DEPCTL_BULK_TYPE));
	}
}

//////////
// Function Name : OTGDEV_HandleEvent_BulkOut
// Function Desctiption : This function handles bulk out transfer.
// Input : NONE
// Output : NONE
// Version :
void OTGDEV_HandleEvent_BulkOut(u32 fifoCntByte)
{
	u8 TempBuf[16];
	u32 uCheck;

	if (oOtgDev.m_uDownloadFileSize==0)
	{
		if (fifoCntByte == 10)
		{		
			OTGDEV_RdPktBulkOutEp((u8 *)TempBuf, 10);
			uCheck = *((u8 *)(TempBuf+8)) + (*((u8 *)(TempBuf+9))<<8);

			if (uCheck==0x1)
			{
				oOtgDev.m_uUploadAddr =
					*((u8 *)(TempBuf+0))+
					(*((u8 *)(TempBuf+1))<<8)+
					(*((u8 *)(TempBuf+2))<<16)+
					(*((u8 *)(TempBuf+3))<<24);

				oOtgDev.m_uUploadSize =
					*((u8 *)(TempBuf+4))+
					(*((u8 *)(TempBuf+5))<<8)+
					(*((u8 *)(TempBuf+6))<<16)+
					(*((u8 *)(TempBuf+7))<<24);
				oOtgDev.m_pUpPt=(u8 *)oOtgDev.m_uUploadAddr;
				DbgUsb("UploadAddress : 0x%x, UploadSize: %d\n", oOtgDev.m_uUploadAddr, oOtgDev.m_uUploadSize);
 	
				if (oOtgDev.m_eOpMode == USB_DMA)
				{
					if (oOtgDev.m_uUploadSize>0)
					{
						u32 uPktCnt, uRemainder;
						
						DbgUsb("Dma Start for IN PKT \n");

						Outp32(GAHBCFG, MODE_DMA|BURST_INCR4|GBL_INT_UNMASK);
						Outp32(GINTMSK, INT_RESUME|INT_OUT_EP|INT_IN_EP|INT_ENUMDONE|INT_RESET|INT_SUSPEND); //gint unmask

						Outp32(bulkIn_DIEPDMA, (u32)oOtgDev.m_pUpPt);

						uPktCnt = (u32)(oOtgDev.m_uUploadSize/oOtgDev.m_uBulkInEPMaxPktSize);
						uRemainder = (u32)(oOtgDev.m_uUploadSize%oOtgDev.m_uBulkInEPMaxPktSize);
						if(uRemainder != 0)
						{
							uPktCnt += 1;
						}
						if (uPktCnt > 1023)
						{
							OTGDEV_SetInEpXferSize(EP_TYPE_BULK, 1023, (oOtgDev.m_uBulkInEPMaxPktSize*1023));							
						}
						else
						{
							OTGDEV_SetInEpXferSize(EP_TYPE_BULK, uPktCnt, oOtgDev.m_uUploadSize);
						}
					
						Outp32(bulkIn_DIEPCTL, 1u<<31|1<<26|2<<18|1<<15|BULK_IN_EP<<11|oOtgDev.m_uBulkInEPMaxPktSize<<0);		//ep1 enable, clear nak, bulk, usb active, next ep1, max pkt						
					}		
				}
				else
				{
					if (oOtgDev.m_uUploadSize > oOtgDev.m_uBulkInEPMaxPktSize)
					{
						OTGDEV_SetInEpXferSize(EP_TYPE_BULK, 1, oOtgDev.m_uBulkInEPMaxPktSize);
					}
					else
					{
						OTGDEV_SetInEpXferSize(EP_TYPE_BULK, 1, oOtgDev.m_uUploadSize);
					}
					Outp32(bulkIn_DIEPCTL, 1u<<31|1<<26|2<<18|1<<15|oOtgDev.m_uBulkInEPMaxPktSize<<0);		//ep1 enable, clear nak, bulk, usb active, max pkt 64
				}  
			}
			oOtgDev.m_uDownloadFileSize=0;
			return;
		}
		else
		{
			OTGDEV_RdPktBulkOutEp((u8 *)TempBuf, 8);
			DbgUsb("downloadFileSize==0, 1'st BYTE_READ_CNT_REG : %x\n", fifoCntByte);
			
			if(download_run==true)
			{
				oOtgDev.m_uDownloadAddress=
					*((u8 *)(TempBuf+0))+
					(*((u8 *)(TempBuf+1))<<8)+
					(*((u8 *)(TempBuf+2))<<16)+
					(*((u8 *)(TempBuf+3))<<24);
			}
			else
			{
				oOtgDev.m_uDownloadAddress=tempDownloadAddress;
			}

			oOtgDev.m_uDownloadFileSize=
				*((u8 *)(TempBuf+4))+
				(*((u8 *)(TempBuf+5))<<8)+
				(*((u8 *)(TempBuf+6))<<16)+
				(*((u8 *)(TempBuf+7))<<24);

			oOtgDev.m_pDownPt=(u8 *)oOtgDev.m_uDownloadAddress;
			DbgUsb("downloadAddress : 0x%x, downloadFileSize: %d\n", oOtgDev.m_uDownloadAddress, oOtgDev.m_uDownloadFileSize);

			OTGDEV_RdPktBulkOutEp((u8 *)oOtgDev.m_pDownPt, fifoCntByte-8); // The first 8-bytes are deleted.
			oOtgDev.m_pDownPt += fifoCntByte-8;
			
			if (oOtgDev.m_eOpMode == USB_CPU)
			{
				OTGDEV_SetOutEpXferSize(EP_TYPE_BULK, 1, oOtgDev.m_uBulkOutEPMaxPktSize);
				Outp32(bulkOut_DOEPCTL, 1u<<31|1<<26|2<<18|1<<15|oOtgDev.m_uBulkOutEPMaxPktSize<<0);		//ep3 enable, clear nak, bulk, usb active, next ep3, max pkt 64
			}
			else
			{
				if (oOtgDev.m_uDownloadFileSize>oOtgDev.m_uBulkOutEPMaxPktSize)
				{
					u32 uPktCnt, uRemainder;
					
					DbgUsb("downloadFileSize!=0, Dma Start for 2nd OUT PKT \n");
					Outp32(GINTMSK, INT_RESUME|INT_OUT_EP|INT_IN_EP|INT_ENUMDONE|INT_RESET|INT_SUSPEND); //gint unmask
					Outp32(GAHBCFG, MODE_DMA|BURST_INCR4|GBL_INT_UNMASK);
					Outp32(bulkOut_DOEPDMA, (u32)oOtgDev.m_pDownPt);
					uPktCnt = (u32)(oOtgDev.m_uDownloadFileSize-oOtgDev.m_uBulkOutEPMaxPktSize)/oOtgDev.m_uBulkOutEPMaxPktSize;
					uRemainder = (u32)((oOtgDev.m_uDownloadFileSize-oOtgDev.m_uBulkOutEPMaxPktSize)%oOtgDev.m_uBulkOutEPMaxPktSize);
					if(uRemainder != 0)
					{
						uPktCnt += 1;
					}
					if (uPktCnt > 1023)
					{
						OTGDEV_SetOutEpXferSize(EP_TYPE_BULK, 1023, (oOtgDev.m_uBulkOutEPMaxPktSize*1023));
					}
					else
					{
						OTGDEV_SetOutEpXferSize(EP_TYPE_BULK, uPktCnt, (oOtgDev.m_uDownloadFileSize-oOtgDev.m_uBulkOutEPMaxPktSize));
					}
					Outp32(bulkOut_DOEPCTL, 1u<<31|1<<26|2<<18|1<<15|oOtgDev.m_uBulkOutEPMaxPktSize<<0);		//ep3 enable, clear nak, bulk, usb active, next ep3, max pkt 64
				}		
			}
		}
	}

	else
	{
		if (oOtgDev.m_eOpMode == USB_CPU)
		{
			DbgUsb("downloadFileSize!=0, 2nd BYTE_READ_CNT_REG : %x\n", fifoCntByte);
			OTGDEV_RdPktBulkOutEp((u8 *)oOtgDev.m_pDownPt, fifoCntByte);
			oOtgDev.m_pDownPt += fifoCntByte;
			
			OTGDEV_SetOutEpXferSize(EP_TY

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -