pe_usb.c

GM8120 linux driver.

	tOTGCSW.u32DataResidue = 0;			
	eUsbOTGMassStorageState = STATE_CSW;

	#if(Bulk_Satus == Bulk_FIFO_SingleDir)
	mUsbIntF2OUTEn();
	#elif(Bulk_Satus == Bulk_FIFO_BiDir)	

	mUsbIntF0OUTEn();

	#endif
	mUsbIntF0INEn();



	
	mUsbIntEP0SetupEn();
	mUsbIntEP0InEn();
	mUsbIntEP0OutEn();
	mUsbIntEP0EndEn();
	
	mUsbDMA2FIFOSel(FOTG200_DMA2FIFO_Non);
//	Do_Delay(100);
#if DCacheEnable	
	fLib_EnableDCache();
#endif
}

///////////////////////////////////////////////////////////////////////////////
//		vOTGDxFWr()
//		Description: Write the buffer content to USB220 Data FIFO
//		input: Buffer pointer, byte number to write, Change Endian type or NOT
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTGDxFWr(INT8U FIFONum, INT8U   * pu8Buffer, INT16U u16Num)
{
	INT32U wTemp;
	INT32U FIFO_Sel;
	
	if (u16Num==0)//Bruce;;03152005
	   return;
	
	
	if(FIFONum<4)
		FIFO_Sel = 1<<FIFONum;
	else
	{
		printf("L%x: Set to Wrong FIFO,FIFO%d not support..", u8LineOTGCount ++,FIFONum);
		return;
	}
	
#if DCacheEnable	
	CPUCleanInvalidateDCacheAll();
	fLib_DisableDCache(); 		
#endif

	mUsbDmaConfig(u16Num,DIRECTION_IN);
	mUsbDMA2FIFOSel(FIFO_Sel);
	mUsbDmaAddr(pu8Buffer);

	mUsbDmaStart();
	while(1)
	{
		wTemp = mUsbIntSrc2Rd();
		if(wTemp & BIT8)
		{
		mUsbFIFOClr((INT32U)FIFONum);

			mUsbIntDmaErrClr();
			printf("L%x: FIFO%d IN transfer DMA error..", u8LineOTGCount ++,FIFONum);
			break;
		}
		if(wTemp & BIT7)
		{
			mUsbIntDmaFinishClr();
			break;
		}
		if((wTemp & 0x00000007)>0)//If (Resume/Suspend/Reset) exit
		{
            mUsbDMARst();
		    mUsbFIFOClr((INT32U)FIFONum);
			mUsbIntDmaFinishClr();
			printf("L%x: FIFO%d IN transfer DMA stop because USB Resume/Suspend/Reset..", u8LineOTGCount ++,FIFONum);
			break;
		}
	}
	mUsbDMA2FIFOSel(FOTG200_DMA2FIFO_Non);
#if DCacheEnable	
	fLib_EnableDCache();
#endif

}


///////////////////////////////////////////////////////////////////////////////
//		vOTGDxFRd()
//		Description: Fill the buffer from USB220 Data FIFO
//		input: Buffer pointer, byte number to write, Change Endian type or NOT
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTGDxFRd(INT8U FIFONum, INT8U * pu8Buffer, INT16U u16Num)
{
	INT32U wTemp;
	INT32U FIFO_Sel;
	
	if (u16Num==0)//Bruce;;03152005
	   return;
	
	
	if(FIFONum<4)
		FIFO_Sel = 1<<FIFONum;
	else
	{
		printf("L%x: Set to Wrong FIFO,FIFO%d not support..", u8LineOTGCount ++,FIFONum);
		return;
	}

#if DCacheEnable	
	CPUCleanInvalidateDCacheAll();
	fLib_DisableDCache(); 		
#endif

	mUsbDmaConfig(u16Num,DIRECTION_OUT);
	mUsbDMA2FIFOSel(FIFO_Sel);
	mUsbDmaAddr(pu8Buffer);

	mUsbDmaStart();
	while(1)
	{
		wTemp = mUsbIntSrc2Rd();
		if(wTemp & BIT8)
		{
		  mUsbFIFOClr((INT32U)FIFONum);
			mUsbIntDmaErrClr();
			printf("L%x: FIFO%d OUT transfer DMA error..", u8LineOTGCount ++,FIFONum);
			break;
		}
		if(wTemp & BIT7)
		{
			mUsbIntDmaFinishClr();
			break;
		}
		if((wTemp & 0x00000007)>0)//If (Resume/Suspend/Reset) exit
		{
      mUsbDMARst();
      mUsbFIFOClr((INT32U)FIFONum);
			mUsbIntDmaFinishClr();
			printf("L%x: FIFO%d OUT transfer DMA stop because USB Resume/Suspend/Reset..", u8LineOTGCount ++,FIFONum);
			break;
		}
	}
	mUsbDMA2FIFOSel(FOTG200_DMA2FIFO_Non);
#if DCacheEnable	
	fLib_EnableDCache();
#endif

}


///////////////////////////////////////////////////////////////////////////////
//		vOTGCxFWr()
//		Description: Write the buffer content to USB220 Cx FIFO
//		input: Buffer pointer, byte number to write, Change Endian type or NOT
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTGCxFWr( INT8U *pu8Buffer, INT16U u16Num)
{
	INT32U wTemp;
	
	if (u16Num==0)//Bruce;;03152005
	   return;

	
	
#if DCacheEnable	
	CPUCleanInvalidateDCacheAll();
	fLib_DisableDCache(); 		
#endif

	mUsbDmaConfig(u16Num,DIRECTION_IN);
	mUsbDMA2FIFOSel(FOTG200_DMA2CxFIFO);
	mUsbDmaAddr(pu8Buffer);

	mUsbDmaStart();
	while(1)
	{
		wTemp = mUsbIntSrc2Rd();
		if(wTemp & BIT8)
		{
      mUsbCxFClr();

			mUsbIntDmaErrClr();
			printf("L%x: Cx IN DMA error..", u8LineOTGCount ++);
			break;
		}
		if(wTemp & BIT7)
		{
			mUsbIntDmaFinishClr();
			break;
		}
		if((wTemp & 0x00000007)>0)//If (Resume/Suspend/Reset) exit
		{
		  mUsbDMARst();
		  mUsbCxFClr();
			mUsbIntDmaFinishClr();
			printf("L%x: Cx IN DMA stop because USB Resume/Suspend/Reset..", u8LineOTGCount ++);
			break;
		}
	}
	mUsbDMA2FIFOSel(FOTG200_DMA2FIFO_Non);
#if DCacheEnable	
	fLib_EnableDCache();
#endif
				
}


///////////////////////////////////////////////////////////////////////////////
//		vOTGCxFRd()
//		Description: Fill the buffer from USB220 Cx FIFO
//		input: Buffer pointer, byte number to write, Change Endian type or NOT
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTGCxFRd(INT8U *pu8Buffer, INT16U u16Num)
{
	INT32U wTemp;

	if (u16Num==0)//Bruce;;03152005
	   return;



#if DCacheEnable	
	CPUCleanInvalidateDCacheAll();
	fLib_DisableDCache(); 		
#endif

	mUsbDmaConfig(u16Num,DIRECTION_OUT);
	mUsbDMA2FIFOSel(FOTG200_DMA2CxFIFO);
	mUsbDmaAddr(pu8Buffer);

	mUsbDmaStart();
	while(1)
	{
		wTemp = mUsbIntSrc2Rd();
		if(wTemp & BIT8)
		{
		  mUsbCxFClr();
			mUsbIntDmaErrClr();
			printf("L%x: Cx OUT DMA error..", u8LineOTGCount ++);
			break;
		}
		if(wTemp & BIT7)
		{
			mUsbIntDmaFinishClr();
			break;
		}
		if((wTemp & 0x00000007)>0)//If (Resume/Suspend/Reset) exit
		{
      mUsbDMARst();
      mUsbCxFClr();
			mUsbIntDmaFinishClr();
			printf("L%x: Cx OUT DMA stop because USB Resume/Suspend/Reset..", u8LineOTGCount ++);
			break;
		}
	}
	mUsbDMA2FIFOSel(FOTG200_DMA2FIFO_Non);
#if DCacheEnable	
	fLib_EnableDCache();
#endif
}

///////////////////////////////////////////////////////////////////////////////
//		vUsbCxLoopBackTest()
//		Description: Do Cx Data loop back test
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vUsbCxLoopBackTest(void)
{
	INT8U u8TxTmp[64],u8RxTmp[64];
	INT32U u32i;

	// set for Cx loop back test enable
	bFOTGPeri_Port(0x02) = BIT1;

	// write data
	for(u32i = 0; u32i<64; u32i++)
		u8TxTmp[u32i] = u32i;
	vOTGCxFWr(u8TxTmp,64);

	// check Cx Done bit
	mUsbEP0DoneSet();
	while(!(bFOTGPeri_Port(0x0B) | BIT0));

	// set for Cx loop back test clear
	bFOTGPeri_Port(0x02) = BIT2;
	bFOTGPeri_Port(0x0B) &= ~BIT0;

	// read data 
	memset(u8RxTmp,0,64);
	vOTGCxFRd(u8RxTmp,64);

	//compare data
	for(u32i = 0; u32i<64; u32i++)
	{
		if(u8TxTmp[u32i] != u8RxTmp[u32i])
		{
			printf("CxTest%d:***Cx loop test error, Tx=0x%x, Rx=0x%x\n",
				(INT16U)u32i,u8TxTmp[u32i],u8RxTmp[u32i]);
		}
		else
		{
			printf("CxTest%d:Cx loop test ok, Tx=0x%x, Rx=0x%x\n",
				(INT16U)u32i,u8TxTmp[u32i],u8RxTmp[u32i]);
		}
	}
}


///////////////////////////////////////////////////////////////////////////////
//		vUsbPamLoopBackTest()
//		Description: Do PAM (Only FIFO0 or FIFO2) loop back test .
//					FIFO0 => FIFO0 & FIFO1 ping pong, packet size = 512, transfer type = Bulk
//					FIFO2 => FIFO2 & FIFO3 ping pong, packet size = 512, transfer type = Bulk
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vUsbPamLoopBackTest(INT32U u32StartFIFONum)
{
	INT8U *u8TxTmp,*u8RxTmp;
	INT32U u32i;
	BOOLEAN bTestPass = TRUE;
	
	u8TxTmp =(INT8U *) malloc(1024);
	u8RxTmp =(INT8U *) malloc(1024);

	mUsbIntEP0InEn();
	mUsbEPMap(EP1, ((INT8U)u32StartFIFONum));
	mUsbEPMxPtSz(EP1, DIRECTION_IN, 0x200 );
	mUsbFIFOMap(u32StartFIFONum, 0x11);
	mUsbFIFOConfig(u32StartFIFONum, 0x26);
	mUsbFIFOConfig(u32StartFIFONum+1, 0x06);

	// write data
	for(u32i = 0; u32i<1024; u32i++)
		u8TxTmp[u32i] = (INT8U)u32i;
	vOTGDxFWr(u32StartFIFONum,u8TxTmp,1024);
	mUsbFIFODone(u32StartFIFONum);

	
	mUsbIntEP0OutEn();
	mUsbEPMap(EP1, (((INT8U)u32StartFIFONum) << 4));
	mUsbEPMxPtSz(EP1, DIRECTION_OUT, 0x200 );
	mUsbFIFOMap(u32StartFIFONum, 0x01);
	mUsbFIFOConfig(u32StartFIFONum, 0x26);
	mUsbFIFOConfig(u32StartFIFONum+1, 0x06);

	// read data 
	memset(u8RxTmp,0,1024);
	vOTGDxFRd(u32StartFIFONum,u8RxTmp,1024 );
	
	//compare data
	for(u32i = 0; u32i<1024; u32i++)
	{
		if(u8TxTmp[u32i] != u8RxTmp[u32i])
		{
			bTestPass = FALSE;
			printf("PAMTest%d:***PAM loop test error, Tx=0x%x, Rx=0x%x\n",
				(INT16U)u32i,u8TxTmp[u32i],u8RxTmp[u32i]);
		}
		else
		{
//			printf("PAMTest%d:PAM loop test ok, Tx=0x%x, Rx=0x%x\n",
//				(INT16U)u32i,u8TxTmp[u32i],u8RxTmp[u32i]);
		}
	}
	
	if(bTestPass)
	{
		printf("PAMTest:PAM FIFO%d loop test Pass\n",u32StartFIFONum);
	}		
	printf("Please re-plug device into host.\n");
}


void vCxOUT_VendorTest(void)
{
	u8CxOUTVendorTest = (INT8U*)malloc(ControlOTGCmd.Length);
	memset(u8CxOUTVendorTest, 0, ControlOTGCmd.Length);

	u16OTGTxRxCounter = ControlOTGCmd.Length;
	pu8OTGDescriptorEX = u8CxOUTVendorTest;
	eOTGCxCommand = CMD_CxOUT_Vendor;
}
void vCxOUT_VendorRxData(void)
{
	INT8U u8temp;
	INT16U u16i;//,j;
	BOOLEAN bCxOUT_CmpOK = TRUE;

	if(u16OTGTxRxCounter < EP0MAXPACKETSIZE)
		u8temp = (INT8U)u16OTGTxRxCounter;
	else
		u8temp = EP0MAXPACKETSIZE;

	u16OTGTxRxCounter -= (INT16U)u8temp;
	vOTGCxFRd(pu8OTGDescriptorEX , u8temp);	
	pu8OTGDescriptorEX = pu8OTGDescriptorEX + u8temp;

	// end of the data stage
	if (u16OTGTxRxCounter == 0)
	{
		for(u16i = 0; u16i< ControlOTGCmd.Length; u16i++)
		{
			if(u8CxOUTVendorTest[u16i] != u8CxOUTVandorDataCount)
			{
#if 1			
				printf("L%02x:Vandor CxData Receive error(0x%x/0x%x)-receive=0x%02x,expect=0x%02x\n",
						u8LineOTGCount++,u16i,ControlOTGCmd.Length, u8CxOUTVendorTest[u16i], u8CxOUTVandorDataCount);
#endif
				bCxOUT_CmpOK = FALSE;
			}
			u8CxOUTVandorDataCount++;			
		}
		if(!bCxOUT_CmpOK)
		{
			mUsbEP0StallSet();
			printf("L%02x:Cx OUT Vendor test error.\n",u8LineOTGCount++);
		}
		eOTGCxCommand = CMD_VOID;
		eOTGCxFinishAction = ACT_DONE;
		free(u8CxOUTVendorTest);		
	}

}

void vCxIN_VendorTest(void)
{
	INT16U u16i;
	u8CxINVendorTest = (INT8U*)malloc(ControlOTGCmd.Length);
	for(u16i = 0; u16i< ControlOTGCmd.Length; u16i++)
	{
		u8CxINVendorTest[u16i] = u8CxINVandorDataCount;//0xbb;//
		u8CxINVandorDataCount++;			
	}

	u16OTGTxRxCounter = ControlOTGCmd.Length;
	pu8OTGDescriptorEX = u8CxINVendorTest;
	eOTGCxCommand = CMD_CxIN_Vendor;
}

void vCxIN_VendorTxData(void)
{
	INT8U u8temp;

	if(u16OTGTxRxCounter < EP0MAXPACKETSIZE)
		u8temp = (INT8U)u16OTGTxRxCounter;
	else
		u8temp = EP0MAXPACKETSIZE;

	u16OTGTxRxCounter -= (INT16U)u8temp;
	vOTGCxFWr(pu8OTGDescriptorEX , u8temp);	
	pu8OTGDescriptorEX = pu8OTGDescriptorEX + u8temp;

	// end of the data stage
	if (u16OTGTxRxCounter == 0)
	{
#if 1	
		eOTGCxFinishAction = ACT_DONE;
#else
		mUsbEP0DoneSet();
		eOTGCxFinishAction = ACT_IDLE;
#endif
		eOTGCxCommand = CMD_VOID;
		free(u8CxINVendorTest);		
	}

}



//==================== For OTG Control ============================