host20_ap.c

GM8120 linux driver.

  UINT8 bTemp;
  UINT32 wTotalSize_Byte,wPrintCounter;
  UINT32 wTotalSize_MB;
  
 do{ 

    if (OTGH_PT_ADVANCE_TEST==0)
       {   
        printf(">>> Free Run 10000000 times:\n");
        wInputCounter=10000000;
        wPrintCounter=1;  
       }
    else
       {
	   printf(">>> Please Input Control Path  counter:");  
       scanf("%d",&wInputCounter);   
       printf("\n");
       
	   printf(">>> Please Input the 'Print Message'  counter:");  
       scanf("%d",&wPrintCounter);         
       printf("\n");       
       
       }//if (AP_Auto_Test==1)
    
    OTGH_PT_Control_Path_Init();
    wOffsetMax=100;//Large than Max Control Packet Size = 64
    wRandomSizeMax=20*1024-200;//Large than wOffsetMax
    wDecrementInterval=101;
    
    
    wRandomSize=wRandomSizeMax;
    wOffset=0;//(0~100)
    wCounter=0;
    wTotalSize_Byte=0;
    wTotalSize_MB=0;
    
  while(wCounter<=wInputCounter)
    {	

	
  //<1>.Control-Setup/Out/In
        pbTemp=(sOTGH_PT_Control.pbDataPage[0]+wOffset);
        for (i=0;i<(wRandomSize);i++)
             *(pbTemp+i)=sOTGH_PT_Control.bDataCounter_OUT++;
 
	
	//<1.2>.Issue command   
            memcpy(bCMD,HOST_AP_CONTROL_VENDOR_OUT,8);
            bCMD[6]=(UINT8)wRandomSize;      //Byte6 = Low byte
            bCMD[7]=(UINT8)(wRandomSize>>8); //Byte7 = High byte
            flib_Host20_Issue_Control_Turbo (1,bCMD,wRandomSize,&(sOTGH_PT_Control.pbDataPage[0]),wOffset);
	
	
	
	
	        wOffset++;
  //<2>.Control-Setup/In/Out	
	//<2.1>.Issue command   
            memcpy(bCMD,HOST_AP_CONTROL_VENDOR_IN,8);
            bCMD[6]=(UINT8)wRandomSize;      //Byte6 = Low byte
            bCMD[7]=(UINT8)(wRandomSize>>8); //Byte7 = High byte
            flib_Host20_Issue_Control_Turbo (1,bCMD,wRandomSize,&(sOTGH_PT_Control.pbDataPage[0]),wOffset);
        
   	//<2.2>.Compare data
        pbTemp=(sOTGH_PT_Control.pbDataPage[0]+wOffset);
        for (i=0;i<(wRandomSize);i++)
             if (*(pbTemp+i)!=sOTGH_PT_Control.bDataCounter_IN++)
   	            {printf("??? Control Path Test Error...(Expect:%d  Actual:%d)\n",sOTGH_PT_Control.bDataCounter_IN-1,*(pbTemp+i));
   	             printf("??? In data address = 0x%x\n",(UINT32)(pbTemp+i));
   	             printf("??? i=%d   \n",i);   	             
   	            OTGH_Error_Handle();
   	             }


  //<3>.Change Variable Size/wOffset
        wCounter++;

        wTotalSize_Byte+=wRandomSize*2+16;
        if (wTotalSize_Byte>1000000)
           {wTotalSize_MB++;
            wTotalSize_Byte=wTotalSize_Byte-1000000;
           }
 
 
   	  if ((wCounter%wPrintCounter)==0)     
       printf(">>> Control Setup-In/Setup-Out Data Compare PASS(Counter=%d)(Size=%d)(wOffset=%d)(TotalSize=%dMB + %dBytes)...\n",wCounter,wRandomSize,wOffset,wTotalSize_MB,wTotalSize_Byte);	
         
        if (wRandomSize > wDecrementInterval)
              wRandomSize= wRandomSize-wDecrementInterval; 
        else  wRandomSize=wRandomSizeMax;

        if (wOffset<wOffsetMax)
            wOffset++;
        else wOffset=0;   


   }// while(wCounter<wInputCounter)
	

       printf(">>> Finish Control Path Test PASS (%d)...\n",wCounter);	

	
	OTGH_PT_Control_Path_Close();
	
	   printf(">>> Again(1/2->y/n):");  
       scanf("%d",(char *)&bTemp);    	
	   printf("\n");
	   
  }while(bTemp==1);		
	
}


//====================================================================
// * Function Name: OTGH_PT_Bulk_Close                          
// * Description: Close the Bulk Path Test
// * Input: none
// * OutPut: none
//====================================================================
void OTGH_PT_Bulk_Close(void)
{
 UINT8 i;	

	flib_Host20_ReleaseStructure(Host20_MEM_TYPE_4K_BUFFER,(UINT32 *)sOTGH_PT_BLK);

  //Release Memory	sOTGH_PT_BLK->pbDataPage_Out
    for (i=0;i<5;i++)
	flib_Host20_ReleaseStructure(Host20_MEM_TYPE_4K_BUFFER,sOTGH_PT_BLK->pbDataPage_Out[i]);

  //Release Memory	sOTGH_PT_BLK->pbDataPage_In
    for (i=0;i<5;i++)
	flib_Host20_ReleaseStructure(Host20_MEM_TYPE_4K_BUFFER,sOTGH_PT_BLK->pbDataPage_In[i]);	

   //<5>.Hang the qHD
       if (psDevice_AP->saCD[0].sInterface[0].sED[0].bED_bmAttributes==OTGH_ED_BULK)    
          {//<5.1>.stop Asynchronous Schedule
            flib_Host20_Asynchronous_Setting(HOST20_Disable);
           if (psHost20_qHD_List_Bulk[0]->bMaxPacketSize> 128)
               {//Support only 2 QHD
                  mwHost20_CurrentAsynchronousAddr_Set(Host20_STRUCTURE_qHD_BASE_ADDRESS);
              }
           else           
           {
           //<5.2>.Hang the qHD for ED0~ED3
            psHost20_qHD_List_Control[1]->bNextQHDPointer=(((UINT32)psHost20_qHD_List_Control[0])>>5);
            }
            
           //<5.2>.Enable Asynchronous Schedule
            flib_Host20_Asynchronous_Setting(HOST20_Enable);
           }      
	
}
//====================================================================
// * Function Name: OTGH_PT_Bulk_Init                          
// * Description: Bulk Test Init
// * Input: none
// * OutPut: none
//====================================================================
void OTGH_PT_Bulk_Init(void)
{

 UINT32 i,j,wMaxPacketSize;

 UINT8 *wTemp;

         wMaxPacketSize=psDevice_AP->saCD[0].sInterface[0].sED[0].bED_wMaxPacketSizeHighByte;
         wMaxPacketSize=(wMaxPacketSize<<8)+(psDevice_AP->saCD[0].sInterface[0].sED[0].bED_wMaxPacketSizeLowByte);


      
   //<5>.Hang the qHD
       if (psDevice_AP->saCD[0].sInterface[0].sED[0].bED_bmAttributes==OTGH_ED_BULK)    
          {//<5.1>.stop Asynchronous Schedule
             flib_Host20_Asynchronous_Setting(HOST20_Disable);
           if (wMaxPacketSize>128)
               {//Support only 2 QHD
                  psHost20_qHD_List_Bulk[0]->bNextQHDPointer=(((UINT32)psHost20_qHD_List_Bulk[1])>>5);
                  psHost20_qHD_List_Bulk[1]->bNextQHDPointer=(((UINT32)psHost20_qHD_List_Bulk[0])>>5);
                  mwHost20_CurrentAsynchronousAddr_Set(((UINT32)psHost20_qHD_List_Bulk[0]));


              }
           else{
               	//<5.2>.Hang the qHD for ED0~ED3
                  psHost20_qHD_List_Control[1]->bNextQHDPointer=(((UINT32)psHost20_qHD_List_Bulk[0])>>5);
                  psHost20_qHD_List_Bulk[0]->bNextQHDPointer=(((UINT32)psHost20_qHD_List_Bulk[1])>>5);
                  psHost20_qHD_List_Bulk[1]->bNextQHDPointer=(((UINT32)psHost20_qHD_List_Control[0])>>5);
                }    
               
               
           //<5.2>.Enable Asynchronous Schedule
           flib_Host20_Asynchronous_Setting(HOST20_Enable);
           
           }      
      
      
      
      
       //Setting Max Packet Size and print message
         wMaxPacketSize=psDevice_AP->saCD[0].sInterface[0].sED[0].bED_wMaxPacketSizeHighByte;
         wMaxPacketSize=(wMaxPacketSize<<8)+(psDevice_AP->saCD[0].sInterface[0].sED[0].bED_wMaxPacketSizeLowByte);
         psHost20_qHD_List_Bulk[0]->bMaxPacketSize=wMaxPacketSize;  
         psHost20_qHD_List_Bulk[1]->bMaxPacketSize=wMaxPacketSize; //Suppose In/Out have the same Max packet Size        
         psHost20_qHD_List_Bulk[0]->bDeviceAddress=psDevice_AP->bAdd;
         psHost20_qHD_List_Bulk[1]->bDeviceAddress=psDevice_AP->bAdd;
      
         
         printf(">>> Bulk In/Out Max Packet Size = %d\n",wMaxPacketSize);
 
        //For Bulk Structure
         sOTGH_PT_BLK=( OTGH_PT_BLK_Struct *)flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);//2=>4kBuffer;
         sOTGH_PT_BLK->wDataRange=4*1024*5; //4K*5  
         
         //For Bulk-Out = 20K bytes          
	     sOTGH_PT_BLK->pbDataPage_Out[0]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);
	     sOTGH_PT_BLK->pbDataPage_Out[1]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);
	     sOTGH_PT_BLK->pbDataPage_Out[2]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);
	     sOTGH_PT_BLK->pbDataPage_Out[3]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);
	     sOTGH_PT_BLK->pbDataPage_Out[4]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);
         
         wTemp=sOTGH_PT_BLK->pbDataPage_Out[0];
         j=0;
         for (i=0;i<(sOTGH_PT_BLK->wDataRange);i++)
             {
              *(wTemp+i)=j++;
              if ((j%233)==0)//Random Number alignment
                 {
                 j=0;//Change Random number	
                 }
                          
             }

         //For Bulk-In  = 20K bytes
         sOTGH_PT_BLK->pbDataPage_In[0]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);
         sOTGH_PT_BLK->pbDataPage_In[1]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);         
         sOTGH_PT_BLK->pbDataPage_In[2]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);         
         sOTGH_PT_BLK->pbDataPage_In[3]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);         
         sOTGH_PT_BLK->pbDataPage_In[4]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);         

         wTemp=sOTGH_PT_BLK->pbDataPage_In[0];
         for (i=0;i<(sOTGH_PT_BLK->wDataRange);i++)
              *(wTemp+i)=0x88;         

	if (((psDevice_AP->saCD[0].sInterface[0].sED[0].bED_EndpointAddress)&BIT7)>0)
       { sOTGH_PT_BLK->bInQHDArrayNum=0;//Array 0
         sOTGH_PT_BLK->bOutQHDArrayNum=1;//Array 0
       }
    else{
         sOTGH_PT_BLK->bInQHDArrayNum=1;//Array 0
         sOTGH_PT_BLK->bOutQHDArrayNum=0;//Array 0
    }


  if (psDevice_AP->bDeviceOnHub==1)
    if (psDevice_AP->bSpeed!=HOST20_Attach_Device_Speed_High)
      {//Init For Device on Hub
       for (i=0;i<2;i++)
            {psHost20_qHD_List_Bulk[i]->bHubAddr=sAttachDevice.bAdd;
             psHost20_qHD_List_Bulk[i]->bPortNumber=psDevice_AP->bOnHubPortNumber+1;
             psHost20_qHD_List_Bulk[i]->bSplitTransactionMask=0xF8;//??
             psHost20_qHD_List_Bulk[i]->bInterruptScheduleMask=0x01;//??
             psHost20_qHD_List_Bulk[i]->bEdSpeed=psDevice_AP->bSpeed;
             psHost20_qHD_List_Bulk[i]->bControlEdFlag=0;//For Bulk      	
      	    }
      }


}

//====================================================================
// * Function Name: OTGH_PT_Bulk                          
// * Description: 
//   <1>.Increment Size Test
//   <2>.Increment Start Address Test
//   <3>.Random Pattern test
//
//   The Bulk path test function call
//   <1>.Issue the Loop1-CBW
//   <2>.Issue the Loop1-OutData
//   <3>.Issue the Loop1-CSW
//   <4>.Issue the Loop2-CBW
//   <5>.Issue the Loop2-InData & Compare
//   <6>.Issue the Loop2-CSW
//   <7>.Compare data 
// * Input: none
// * OutPut: none
//====================================================================
void OTGH_PT_Bulk(void)
{
   UINT32 wTag,i;
   UINT32  wInputCounter,wCounter,wOffset,wRandomSize,wRandomSizeMax,wOffsetMax,wSizeInterval,wDumyControlInterval;
   UINT8  bTemp; 
   UINT8 *pbData;
   UINT8 bCMD[8];
   UINT32 wTotalSize_Byte,wPrintCounter;
   UINT32 wTotalSize_MB;  
   UINT8 *pbData2;
  
   pbData=malloc(250);
  
   do { 
	  printf(">>> Please Input the Bulk-In/Out  counter:");  
      scanf("%d",&wInputCounter);         
      printf("\n");
	  printf(">>> Please Input the 'Print Message'  counter:");  
      scanf("%d",&wPrintCounter);         
      printf("\n");       

      OTGH_PT_Bulk_Init(); 

      //Cofiguration Setting
      wOffset=0; //From 0 to 100 bytes
      wOffsetMax=550;//Large than Max PacketSize 512
      wRandomSizeMax=20*1024-600;  //16*1024; //john  //20*1024-600;//600 large than wOffsetMax  
      wSizeInterval=101;
      wDumyControlInterval=8;

      //Init Value
      wCounter=0;   
      wTag=0x88888888;   
      wRandomSize=wRandomSizeMax;
      wTotalSize_Byte=0;
      wTotalSize_MB=0;
   
      while(wCounter<wInputCounter)
	  {
         pbData2=sOTGH_PT_BLK->pbDataPage_In[0]+wOffset;
         for (i=0;i<wRandomSize;i++)
            *(pbData2+i)=0x88;          
         
         //<1>.Issue the Loop1-CBW
         OTGH_PT_Bulk_SendCBW(wRandomSize, wOffset, wTag++,OTGH_Dir_Out);
     
         //<2>.Issue the Loop1-OutData
	     flib_Host20_Issue_Bulk (sOTGH_PT_BLK->bOutQHDArrayNum,wRandomSize,&(sOTGH_PT_BLK->pbDataPage_Out[0]),wOffset,OTGH_Dir_Out);

         //<3>.Issue the Loop1-CSW
         OTGH_PT_Bulk_ReceiveCSW();

         //Here should be insert the dumy control transfer 
         if ((psHost20_qHD_List_Bulk[0]->bMaxPacketSize)<=128)
            if (wCounter%wDumyControlInterval==0)  
			{
         	   memcpy(bCMD,OTGH_GETDESCRIPTOR_DEVICE,8);
               flib_Host20_Issue_Control (1,bCMD,0x12,pbData);    
			}


         //<4>.Issue the Loop2-CBW
         OTGH_PT_Bulk_SendCBW(wRandomSize, wOffset, wTag++,OTGH_Dir_IN);     
     
         //<5>.Issue the Loop2-InData & Compare
	     flib_Host20_Issue_Bulk (sOTGH_PT_BLK->bInQHDArrayNum, wRandomSize,&(sOTGH_PT_BLK->pbDataPage_In[0]),wOffset,OTGH_Dir_IN);

         //<6>.Issue the Loop2-CSW
         OTGH_PT_Bulk_ReceiveCSW();

         //Here should be insert the dumy control transfer 
         if ((psHost20_qHD_List_Bulk[0]->bMaxPacketSize)<=128)
            if (wCounter%wDumyControlInterval==0)  
			{
       	       memcpy(bCMD,OTGH_GETDESCRIPTOR_DEVICE,8);
               flib_Host20_Issue_Control (1,bCMD,0x12,pbData);    
			}

            //<7>.Compare data 
            for (i=0;i<wRandomSize;i++)
              { if (*(sOTGH_PT_BLK->pbDataPage_In[0]+i+wOffset)!=*(sOTGH_PT_BLK->pbDataPage_Out[0]+i+wOffset))
                   {
                   	printf(">>> Error:BULK-IN/Out Fail (Expected data:%d/Received Data:%d (i=%d)\n",*(sOTGH_PT_BLK->pbDataPage_Out[0]+i+wOffset),*(sOTGH_PT_BLK->pbDataPage_In[0]+i+wOffset),i);	
	                printf(">>> Expected Address:0x%x  /Received Address:0x%x / Counter=%d\n",(UINT32)(sOTGH_PT_BLK->pbDataPage_Out[0]+i+wOffset),(UINT32)(sOTGH_PT_BLK->pbDataPage_In[0]+i+wOffset),wCounter);
	                OTGH_Error_Handle();
                   	}
              }
    //<8>.Print message
	      wCounter++;    
	      wTotalSize_Byte+=(wRandomSize*2)+88;
          if (wTotalSize_Byte>1000000)
             {wTotalSize_MB++;
              wTotalSize_Byte=wTotalSize_Byte-1000000;
             } 
	      
         if ((wCounter%wPrintCounter)==0)