pe_usb.c

GM8120 linux driver.

///////////////////////////////////////////////////////////////////////////////
//
//	File name: usb.c
//	Version: 1.0
//	Date: 2003/8/05
//
//	Author: Andrew
//	Email: [e-mail]
//	Phone: [phone]
//	Company: Faraday Tech. Corp.
//
//	Description: USB Service Rountine & relatived subroutine
//
//	1. vOTGInit(void)
//		1.1 vFOTG200_Dev_Init(void);
//	2. vOTGHandler(void)
//		2.1 vOTG_ep0setup(void);
//			2.1.1 bOTGStandardCommand(void);
//				2.1.1.1 bGet_OTGstatus();
//				2.1.1.2 bClear_OTGfeature();
//				2.1.1.3 bSet_OTGfeature();
//				2.1.1.4 bSet_OTGaddress();
//				2.1.1.5 bGet_OTGdescriptor();
//					2.1.1.5.1 vOTGEP0TxData(void);
//				2.1.1.6 bSet_OTGdescriptor();
//					2.1.1.6.1 vOTGEP0RxData(void);
//				2.1.1.7 vGet_OTGconfiguration();
//				2.1.1.8 bSet_OTGconfiguration();
//					2.1.1.8.1 vOTGClrEPx(void);
//				2.1.1.9 bGet_OTGinterface();
//				2.1.1.10 bSet_OTGinterface();
//					2.1.1.10.1 vOTGClrEPx(void);
//				2.1.1.11 bSynch_OTGframe();
//		2.2 vOTG_ep0tx(void);
//			2.2.1 vOTGEP0TxData(void);
//		2.3 vOTG_ep0rx(void);
//			2.3.1 vOTGEP0RxData(void);
//		2.4 vOTG_ep0end(void);
//		2.5 vOTG_ep0fail(void);
//		2.6 vOTG_rst(void);
//		2.7 vOTG_suspend(void);
//		2.8 vOTG_resm(void);
//		2.9 vOTG_ISO_SeqErr(void);
//		2.10 vOTG_ISO_SeqAbort(void);
//		2.11 vOTG_TX0Byte(void);
//		2.12 vOTG_RX0Byte(void);
///////////////////////////////////////////////////////////////////////////////
#define USB_GLOBALS

#define NoFixPort			0
#define FixPort			1
#define USB_DataPort		FixPort

#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "Pe_usb.h"
#include "FA510.h"
#include "Pe_usb_hs_pos.h"
#include "Pe_usb_fs_pos.h"
#include "FOTG200_peripheral.h"
#include "Pe_my_usbtable.h"
#include "chipset.h"  
#include "flib.h" 
#include "OTGController.h"
#include "cpe.h"

SetupPacket ControlOTGCmd;
INT8U   * pu8OTGDescriptorEX;

INT16U u16OTGTxRxCounter;
BOOLEAN bOTGEP0HaltSt;
CommandType eOTGCxCommand;
Action eOTGCxFinishAction;

INT32U OTG_interrupt_level1;
INT32U OTG_interrupt_level1_Save;
INT32U OTG_interrupt_level1_Mask;

INT8U u8OTGConfigValue;
INT8U u8OTGInterfaceValue;
INT8U u8OTGInterfaceAlternateSetting;

BOOLEAN bOTGBufferEmpty;
BOOLEAN bOTGHighSpeed;
BOOLEAN bOTGChirpFinish;

INT8U u8OTGInterruptCount;
INT32U u32OTGInterrupt_TX_COUNT ;
INT32U u32OTGInterrupt_RX_COUNT ;
INT8U u8OTGInterruptOutCount ;

INT8U* u8CxOUTVendorTest = NULL;
INT8U* u8CxINVendorTest = NULL;

INT8U u8CxOUTVandorDataCount = 0;
INT8U u8CxINVandorDataCount = 0;
	
void vCxOUT_VendorTest(void);
void vCxOUT_VendorRxData(void);
void vCxIN_VendorTest(void);
void vCxIN_VendorTxData(void);


extern CBW tOTGCBW;

extern void OTGH_Error_Handle(void);
void vFOTG200_Dev_Init(void);

//============================================================================= 
//		OTGP_HNP_Enable()
//		Description:
//			
//		input: none
//		output: none
//=============================================================================
int Debug_Check_R138(void)
{
  UINT32 u32Temp;
  
  u32Temp = mUsbIntSrc1MaskRd();
  
    if ((u32Temp&0x3C)!=0x3C)
       {
       printf("??? Check 0x138 error = 0x%x\n",u32Temp);
       while(1)
       ;
//       return (0);	
       }
    else{
    return (1);

    
    }

}



//============================================================================= 
//		OTGP_HNP_Enable()
//		Description:
//			
//		input: none
//		output: none
//=============================================================================
void OTGP_HNP_Enable(void)
{
    //<1>.Set b_Bus_Request
          mdwOTGC_Control_B_BUS_REQ_Set();
 
	//<2>.Set the HNP enable
	      mdwOTGC_Control_B_HNP_EN_Set();


}


///////////////////////////////////////////////////////////////////////////////
//		vOTGIsr2()
//		Description:
//			1. Record FOTG200 Device group interrupt register.
//			2. Disable Usb interrupt.
//			3. Expect "Usb interrupt will be renabled after all events had been
//			   serviced in main()".
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTGIsr2(void)
{
	OTG_interrupt_level1_Save = mUsbIntGroupRegRd();
	OTG_interrupt_level1_Mask = mUsbIntGroupMaskRd();
	 
	OTG_interrupt_level1 = OTG_interrupt_level1_Save & ~OTG_interrupt_level1_Mask;

	if (OTG_interrupt_level1 != 0)
	{		

	//bruce;;04182005;;	fLib_DisableInt(IRQ_FOTG200);
	}
}

///////////////////////////////////////////////////////////////////////////////
//		vFOTG200_Dev_Init()
//		Description:
//			1. Reset all interrupt and clear all fifo data of FOTG200 Device
//			2. Turn on the "Global Interrupt Enable" bit of FOTG200 Device
//			3. Turn on the "Chip Enable" bit of FOTG200 Device
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vFOTG200_Dev_Init(void)
{
	// suspend counter
	mUsbIdleCnt(7);

	// Clear interrupt
	mUsbIntBusRstClr();
	mUsbIntSuspClr();
	mUsbIntResmClr();
	
	// Disable all fifo interrupt
	mUsbIntFIFO0_3OUTDis();
	mUsbIntFIFO0_3INDis();
	//if ((mUsbIntSrc1MaskRd()&0xF00FF)!=0xF00FF)//Bruce;;07192005
	//    {printf("??? 0x138 Set Fail...\n");//Bruce;;07192005
	//     while(1);//Bruce;;07192005
	//    }//Bruce;;07192005
	    
	// Soft Reset
	mUsbSoftRstSet(); 			// All circuit change to which state after Soft Reset?
	mUsbSoftRstClr();
	
	// Clear all fifo
	mUsbClrAllFIFOSet();			// will be cleared after one cycle.
	
	// Enable usb200 global interrupt
	mUsbGlobIntEnSet();
	mUsbChipEnSet();
}

///////////////////////////////////////////////////////////////////////////////
//		vOTGInit()
//		Description:
//			1. Configure the FIFO and EPx map.
//			2. Initiate FOTG200 Device.
//			3. Set the usb interrupt source as edge-trigger.
//			4. Enable Usb interrupt.
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTGInit(void)
{
	// init variables
	u16OTGTxRxCounter = 0;
	eOTGCxCommand = CMD_VOID;
	u8OTGConfigValue = 0;
	u8OTGInterfaceValue = 0;
	u8OTGInterfaceAlternateSetting = 0;
	bOTGEP0HaltSt = FALSE;
	
	eOTGCxFinishAction = ACT_IDLE;
	OTG_interrupt_level1 = 0;

	// Initiate FUSB220
	vFOTG200_Dev_Init();

	// Initiate Interrupt
//	    fLib_CloseInt(IRQ_FOTG200);
//  	fLib_SetIntTrig(IRQ_FOTG200,LEVEL,L_ACTIVE);
//   	fLib_ConnectInt(IRQ_FOTG200, vOTGIsr2);
//   	fLib_EnableInt(IRQ_FOTG200);	
}

///////////////////////////////////////////////////////////////////////////////
//		vOTGHandler()
//		Description:
//			1. Service all Usb events
//			2. ReEnable Usb interrupt.
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTGHandler(void)
{
   INT32U *u32pData; 
   INT32U OTG_Interrupt_level2;
   INT32U OTG_Interrupt_Mask;
   INT32U OTG_Interrupt_Origan;

   if (bOTGDMARunning) {    	
      u32pData=(INT32U *)(CPE_FOTG200_BASE+0x138);
      if ((*u32pData!=0xb003f)&(*u32pData!=0xb003c)) {
	     printf("??? Interrupt Error During bOTGDMARunning 0x138=0x%x\n",*u32pData);	
    	 OTGH_Error_Handle();	
	  }	
   }

	if (OTG_interrupt_level1 & BIT2)				//Group Source 2
	{
		OTG_Interrupt_Origan = mUsbIntSrc2Rd();
		OTG_Interrupt_Mask = mUsbIntSrc2MaskRd();
		OTG_Interrupt_level2 = OTG_Interrupt_Origan & ~OTG_Interrupt_Mask;

		if (OTG_Interrupt_level2 & BIT0)
			vOTG_rst();
		if (OTG_Interrupt_level2 & BIT1)
			vOTG_suspend();
		if (OTG_Interrupt_level2 & BIT2)
			vOTG_resm();
		if (OTG_Interrupt_level2 & BIT3)
		{
			mUsbIntIsoSeqErrClr();
			vOTG_ISO_SeqErr();
		}
		if (OTG_Interrupt_level2 & BIT4)
		{
			mUsbIntIsoSeqAbortClr();
			vOTG_ISO_SeqAbort();
		}
		if (OTG_Interrupt_level2 & BIT5)
		{
			mUsbIntTX0ByteClr();
			vOTG_TX0Byte();
		}	
		if (OTG_Interrupt_level2 & BIT6)
		{
			mUsbIntRX0ByteClr();		
			vOTG_RX0Byte();		
		}
		if (OTG_Interrupt_level2 & BIT7)
		{
			mUsbIntDmaFinishClr();
#if (OTG_AP_Satus	 == Bulk_AP)
			if(bOTGDMARunning)
				vOTGCheckDMA();
			else
				printf("L%02x:DMA finish Interrupt error.",u8LineOTGCount++);
#endif
		}	
		if (OTG_Interrupt_level2 & BIT8)
		{
			printf("L%02x:DMA error.",u8LineOTGCount++);
			mUsbIntDmaErrClr();
#if (OTG_AP_Satus == Bulk_AP)
			if(bOTGDMARunning)
			{
				vOTGCheckDMA();
				printf("L%02x:DMA error.",u8LineOTGCount++);			
			}
			else
				printf("L%02x:DMA error Interrupt error.",u8LineOTGCount++);
#endif
		}
		
	}
	
	if (OTG_interrupt_level1 & BIT0)				//Group Source 0
	{
		OTG_Interrupt_Origan = mUsbIntSrc0Rd();
		OTG_Interrupt_Mask = mUsbIntSrc0MaskRd();
		OTG_Interrupt_level2 = OTG_Interrupt_Origan & ~OTG_Interrupt_Mask;

//		printf("L%x: IntSrc0 = 0x%02x\n", u8LineOTGCount ++,OTG_Interrupt_level2);

		if (OTG_Interrupt_level2 & BIT5)
			vOTG_ep0abort();
		if (OTG_Interrupt_level2 & BIT2)
			vOTG_ep0rx();
		if (OTG_Interrupt_level2 & BIT0)
			vOTG_ep0setup();
		else if (OTG_Interrupt_level2 & BIT3)
			vOTG_ep0end();
		if (OTG_Interrupt_level2 & BIT1)
			vOTG_ep0tx();
		if (OTG_Interrupt_level2 & BIT4)
			vOTG_ep0fail();

		if (eOTGCxFinishAction == ACT_STALL)
		{
			if(u8OTGMessageLevel & (MESS_ERROR | MESS_WARNING | MESS_INFO))
				printf("L%x: Unsuported EP0 command...Return Cx Stall...\n", u8LineOTGCount ++);
			mUsbEP0StallSet();
		}
		else if (eOTGCxFinishAction == ACT_DONE)
			mUsbEP0DoneSet();

		// Clear Action
		eOTGCxFinishAction = ACT_IDLE;

		#if 0
		// YPING Debug
		if(u16OTGTxRxCounter !=0)
		{
			

		}
		#endif	
	}


	if (OTG_interrupt_level1 & BIT1)				//Group Source 1
	{
		OTG_Interrupt_Origan = mUsbIntSrc1Rd();
		OTG_Interrupt_Mask = mUsbIntSrc1MaskRd();//0x138
		OTG_Interrupt_level2 = OTG_Interrupt_Origan & ~OTG_Interrupt_Mask;

#if (OTG_AP_Satus	 == Bulk_AP)
	#if(Bulk_Satus == Bulk_FIFO_SingleDir)
		// YPING : use FIFO2 for ep2( bulk out)
		if (OTG_Interrupt_level2 & BIT5)			// short packet
			vUsb_Bulk_Out(mUsbFIFOOutByteCount(FIFO2));	 
		else if (OTG_Interrupt_level2 & BIT4)		// full packet
			vUsb_Bulk_Out(mUsbFIFOOutByteCount(FIFO2));
		
		// YPING : use FIFO0 for ep1( bulk in)
		if (OTG_Interrupt_level2 & BIT16)
			vUsb_Bulk_In();
		
	#elif(Bulk_Satus == Bulk_FIFO_BiDir)
	
 if(bOTGDMARunning)	
    {

    	u32pData=(INT32U *)(CPE_FOTG200_BASE+0x138);
    	printf("??? Interrupt Error During bOTGDMARunning 0x138=0x%x\n",*u32pData);	
    	
    	OTGH_Error_Handle();	
    	
    }
		// YPING : use FIFO0 for ep2( bulk out)
		if (OTG_Interrupt_level2 & BIT1)			// short packet
  		    vUsb_Bulk_Out(mUsbFIFOOutByteCount(FIFO0));	 
	
		else if (OTG_Interrupt_level2 & BIT0)		// full packet
			vUsb_Bulk_Out(mUsbFIFOOutByteCount(FIFO0));
		
		// YPING : use FIFO0 for ep1( bulk in)
		if (OTG_Interrupt_level2 & BIT16)
			vUsb_Bulk_In();
			
		// YPING : FIFO3 for ep4( Interrupt out)
		if (OTG_Interrupt_level2 & BIT7)			// short packet
			vOTG_Interrupt_Out();
		else if (OTG_Interrupt_level2 & BIT6)		// full packet
			vOTG_Interrupt_Out();
		
		// YPING : use FIFO2 for ep3( Interrupt In)
		if (OTG_Interrupt_level2 & BIT18)
			vOTG_Interrupt_In();		
	#endif
#endif


#if (OTG_AP_Satus	 == Interrupt_AP)
		if(bOTGHighSpeed)
		{
		// YPING : High speed use FIFO2 for ep2( Interrupt out)
			if (OTG_Interrupt_level2 & BIT5)			// short packet
				vOTG_Interrupt_Out();
			else if (OTG_Interrupt_level2 & BIT4)		// full packet
				vOTG_Interrupt_Out();
		}
		else
		{
		// YPING : Full speed use FIFO1 for ep2( Interrupt out)
			if (OTG_Interrupt_level2 & BIT3)			// short packet
				vOTG_Interrupt_Out();
			else if (OTG_Interrupt_level2 & BIT2)		// full packet
				vOTG_Interrupt_Out();
		}
		
		// YPING : use FIFO0 for ep1( Interrupt In)
		if (OTG_Interrupt_level2 & BIT16)
			vOTG_Interrupt_In();		
#endif


#if (OTG_AP_Satus == IsochronousIN_AP)
		if (OTG_Interrupt_level2 & BIT16)
			vOTG_ISO_In();
#endif

#if (OTG_AP_Satus == IsochronousOUT_AP)
		if (OTG_Interrupt_level2 & BIT1)			// short packet
			vOTG_ISO_Out();
		else if (OTG_Interrupt_level2 & BIT0)		// full packet
			vOTG_ISO_Out();
#endif

	}

	// Clear usb interrupt flags
	OTG_interrupt_level1 = 0;
	
   //	fLib_EnableInt(IRQ_FOTG200);
}

///////////////////////////////////////////////////////////////////////////////
//		vOTG_ep0setup()
//		Description:
//			1. Read 8-byte setup packet.
//			2. Decode command as Standard, Class, Vendor or NOT support command
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTG_ep0setup(void)
{
	INT8U c;
	INT32U *u32UsbCmd;