host20_ap.c

GM8120 linux driver.

   	    {if (psDevice_AP->bSpeed==HOST20_Attach_Device_Speed_Full)      
                printf(">>> Full Speed Bulk-IN/Out Test:PASS=(%d) (Address=0x%x) (Size=%d) (TotalSize=%dMB + %dBytes)...\n"
               ,wCounter,(UINT32)(sOTGH_PT_BLK->pbDataPage_Out[0]+wOffset),wRandomSize,wTotalSize_MB,wTotalSize_Byte);
             else 
                printf(">>> High Speed Bulk-IN/Out Test:PASS=(%d) (Address=0x%x) (Size=%d) (TotalSize=%dMB + %dBytes)...\n"
               ,wCounter,(UINT32)(sOTGH_PT_BLK->pbDataPage_Out[0]+wOffset),wRandomSize,wTotalSize_MB,wTotalSize_Byte);
            }


     
     if (wRandomSize>wSizeInterval)
        wRandomSize=wRandomSize-wSizeInterval;
     else
        wRandomSize=wRandomSizeMax;
        
     wOffset++;
     if (wOffset>wOffsetMax)
         wOffset=0;         
    };

  printf(">>> Finish Bulk In/Out Test PASS (%d)... \n",wInputCounter);
	
  OTGH_PT_Bulk_Close();
	
	   printf(">>> Again(1/2->y/n):");  
       scanf("%d",(char *)&bTemp);    	
	   printf("\n");
  }while(bTemp==1);	
	
 free(pbData);
 
 
}

//====================================================================ok
// * Function Name: OTGH_PT_ISO_IN                          
// * Description: The ISO-In path test function call
//   <1>.Input the Test counter
//   <2>.Issue the ISO-IN command
//   <3>.Compare data the receiving data
// * Input: none
// * OutPut: none
//====================================================================
UINT32 wDebug;
void OTGH_PT_ISO_IN(void)
{
	UINT32 wInputCounter,wCounter,j,wMaxPacketSize,wSize,wOffset,i,wTotalSize_Byte,wTotalSize_MByte;
    UINT8 *pbData;
    UINT32 wOffsetIncrement,wOffsetMax,wSizeIncrement,wSizeMax,wPrintCounter;
    UINT8 bMult,bTemp;

  flib_Host20_Asynchronous_Setting(HOST20_Disable);


	
   //<1>.Input the Test counter
   if (OTGH_PT_ADVANCE_TEST==0)
      {
      printf(">>> Free Run 1000 times:\n");
      wInputCounter=1000;	//10000000
      wPrintCounter=1;
      }else
	   {
	   printf(">>> Please Input the ISO-IN (1020 Bytes) counter:");  
       scanf("%d",&wInputCounter);   
       printf("\n");     
       
	   printf(">>> Please Input the 'Print Message'  counter:");  
       scanf("%d",&wPrintCounter);         
       printf("\n");       
       }



   //<2>.Allocate buffer for In Data => Support 24K*100=2400K=2.4M
         for(i=0;i<OTGH_PT_ISO_DATABUFFER_NUM;i++)
	         sOTGH_PT_ISO.aDataBufferArray[i]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);          
    
    


    
   flib_Host20_ISO_Init();


   wMaxPacketSize=psDevice_AP->saCD[0].sInterface[0].sED[0].bED_wMaxPacketSizeHighByte;
   wMaxPacketSize=((wMaxPacketSize<<8)+psDevice_AP->saCD[0].sInterface[0].sED[0].bED_wMaxPacketSizeLowByte);
   bTemp=wMaxPacketSize>>11;
   switch(bTemp)
         {
         case 0:
               bMult=1;
         break;
         case 1:
               bMult=2;
         break;
         case 2:
               bMult=3;         
         break;
         default:
               printf("??? MaxPacketSize Parse Error...\n");
               while(1);
         //break;	
         	
         	
         }
   

   wMaxPacketSize=wMaxPacketSize&0x7FF;

   wCounter=0;



   if (psDevice_AP->bSpeed==0)
            {
             //wSizeIncrement=wMaxPacketSize*3;//*8; //(3=Mult / 8uframes )	
             //wSizeMax=500*wMaxPacketSize;//For Full Speed
             wSizeIncrement=wMaxPacketSize*8;//*8; //(3=Mult / 8uframes )	
             wSizeMax=8*wMaxPacketSize;//For Full Speed
             
            }                   //(Max=500 iTD / 1iTD Min=64bytes => 500*64 = 32K)
         else                    
         	{
         	//wSizeIncrement=wMaxPacketSize*bMult*100;//*8; //(3=Mult / 8uframes )
         	wSizeIncrement=wMaxPacketSize*8;	
         	//wSizeMax=256*1024;//For High Speed
         	                  //(Total iTD=1024 => use 500 iTD => 1 iTD = 64*1*8=512 bytes)=>500*512 = 250K
            wSizeMax=wMaxPacketSize*8;//For High Speed

         	}                  
   wSize=wSizeIncrement;

   
   wOffset=0; 
   wOffsetIncrement=101;
   wOffsetMax=4096-1;
   wTotalSize_Byte=0;
   wTotalSize_MByte=0;
  while(wCounter<wInputCounter)
    {
      wCounter++;
      
	//<3>.Issue the ISO-IN command
	
	     if ((psDevice_AP->bDeviceOnHub==1)
	         &(sAttachDevice.bSpeed==HOST20_Attach_Device_Speed_High)
	         &(psDevice_AP->bSpeed==HOST20_Attach_Device_Speed_Full))//Full-Device + High-Hub	
	         flib_Host20_Issue_ISO_siTD (1,1,wMaxPacketSize,wSize
	                          ,&(sOTGH_PT_ISO.aDataBufferArray[0]),wOffset,OTGH_Dir_IN,bMult);
         else	
	         flib_Host20_Issue_ISO (1,1,wMaxPacketSize,wSize
	                          ,&(sOTGH_PT_ISO.aDataBufferArray[0]),wOffset,OTGH_Dir_IN,bMult);
	
	                             
	//<4>.Compare data the receiving data
          pbData=sOTGH_PT_ISO.aDataBufferArray[0]+wOffset;	
//          wOffsetTemp=wOffset;
	      for (j=0;j<wSize;j++)
	          {
	          if (sOTGH_PT_ISO.bDataCounter!=*(pbData+j))
	             {printf(">>> Error:ISO-IN Fail (Expected data:0x%x/Received Data:0x%x\n"
	                    ,(UINT32)(sOTGH_PT_ISO.bDataCounter),(UINT32)*(pbData+j));
	              printf("    Received Data Address:0x%x / Size = 0x%d\n"
	                    ,(UINT32)(pbData+j),(UINT32)wSize);
	                    	
	              OTGH_Error_Handle();
	             }
	          sOTGH_PT_ISO.bDataCounter++;	
	          if (sOTGH_PT_ISO.bDataCounter>=sOTGH_PT_ISO.bDataMax)
	             sOTGH_PT_ISO.bDataCounter=0;
	             
	             
	          }
  
  //printf(">>> Current sOTGH_PT_ISO.bDataCounter=0x%x\n",(UINT32)sOTGH_PT_ISO.bDataCounter);
  
  wTotalSize_Byte=wTotalSize_Byte+wSize;
  if (wTotalSize_Byte>(1024*1024))
     {
     wTotalSize_MByte++;
     wTotalSize_Byte=wTotalSize_Byte-(1024*1024);
     }
 
  
  
  
  if ((wCounter%wPrintCounter)==0)
     {
       if (psDevice_AP->bSpeed==HOST20_Attach_Device_Speed_Full)
          printf(">>> Full Speed ISO IN Test:(Current Size=%d / Current Offset = %d) Total Size=%dMB + %dBytes PASS...=====> Counter=%d \n"
              ,wSize,wOffset,wTotalSize_MByte,wTotalSize_Byte,wCounter);
       else
          printf(">>> High Speed ISO IN Test:(Current Size=%d / Current Offset = %d) Total Size=%dMB + %dBytes PASS...=====> Counter=%d \n"
              ,wSize,wOffset,wTotalSize_MByte,wTotalSize_Byte,wCounter);
       
     
     }



  wOffset=wOffset + wOffsetIncrement;
  if (wOffset>=wOffsetMax)
     wOffset=0;


  
  wSize=wSize+wSizeIncrement;
  if (wSize>wSizeMax)
        wSize=wSizeIncrement;


  //if (wSize>wSizeIncrement)
  //    wSize=wSize-wSizeIncrement;
  //else wSize=wSizeMax;
  

  
    };

  printf(">>> ISO IN Test:PASS (%d) \n",wInputCounter);
	
  //<5>.Free the allocated Buffer
        for(i=0;i<OTGH_PT_ISO_DATABUFFER_NUM;i++)
             flib_Host20_ReleaseStructure(Host20_MEM_TYPE_4K_BUFFER,sOTGH_PT_ISO.aDataBufferArray[i]);

        flib_Host20_Periodic_Setting(HOST20_Disable);

	
 flib_Host20_Asynchronous_Setting(HOST20_Enable);	
	
	
}
//====================================================================ok
// * Function Name: OTGH_PT_ISO_Out                          
// * Description: The ISO-Out path test function call
//   <1>.Input the Test counter
//   <2>.Prepare sending data
//   <3>.Issue the ISO-Out command
// * Input: none
// * OutPut: none
//====================================================================
void OTGH_PT_ISO_Out(void)
{
    UINT32 wInputCounter,wCounter,j,wMaxPacketSize,wSize,wOffset,i,wOffsetIncrement,wOffsetMax;
    UINT8 *pbData;
    UINT8 bDataCounter;
    UINT32 wSizeMax,wSizeIncrement,wPrintCounter,wTotalSize_Byte,wTotalSize_MByte;
    UINT8 bMult,bTemp;
    
	//<1>.Input the Test counter
   if (OTGH_PT_ADVANCE_TEST==0)
      {
      printf(">>> Free Run 1000 times:\n");
      wInputCounter=1000;	//10000000
      wPrintCounter=1;
      }else
	   {
	     printf(">>> Please Input the ISO_Out counter:");  
         scanf("%d",&wInputCounter);  
         printf("\n");

	   printf(">>> Please Input the 'Print Message'  counter:");  
       scanf("%d",&wPrintCounter);         
       printf("\n");       
      } 
   
   //<2>.Allocate buffer for In Data => Support 24K*100=2400K=2.4M
         for(i=0;i<OTGH_PT_ISO_DATABUFFER_NUM;i++)
	         sOTGH_PT_ISO.aDataBufferArray[i]=flib_Host20_GetStructure(Host20_MEM_TYPE_4K_BUFFER);          
   
  
   
   flib_Host20_ISO_Init();

   wMaxPacketSize=psDevice_AP->saCD[0].sInterface[0].sED[0].bED_wMaxPacketSizeHighByte;
   wMaxPacketSize=((wMaxPacketSize<<8)+psDevice_AP->saCD[0].sInterface[0].sED[0].bED_wMaxPacketSizeLowByte);
   bTemp=wMaxPacketSize>>11;
   switch(bTemp)
         {
         case 0:
               bMult=1;
         break;
         case 1:
               bMult=2;
         break;
         case 2:
               bMult=3;         
         break;
         default:
               printf("??? MaxPacketSize Parse Error...\n");
               while(1);
         break;	
         	
         	
         }
    wMaxPacketSize=wMaxPacketSize&0x7FF;   
 
       
   wCounter=0;
   wTotalSize_Byte=0;
   wTotalSize_MByte=0;   
  if (psDevice_AP->bSpeed==0)//For Full Speed
            {
             wSizeIncrement=wMaxPacketSize*8;//3;//*8; //(3=Mult / 8uframes )	
             //wSizeMax=500*wMaxPacketSize;//For Full Speed
             wSizeMax=8*wMaxPacketSize;
            }                   //(Max=512 iTD / 1iTD Min=512 => 512*512 = 256K)
         else                    
         	{
         	//wSizeIncrement=wMaxPacketSize*bMult*10;//*8; //(3=Mult / 8uframes )	
         	//wSizeMax=256*1024;//For High Speed
         	                  //(Total iTD=1024 => use 500 iTD => 1 iTD = 64*1*8=512 bytes)=>500*512 = 250K
         	wSizeIncrement=wMaxPacketSize*8;
         	wSizeMax=8*wMaxPacketSize;
         	}                  
   wSize=wSizeIncrement;

   wOffset=0; 
   wOffsetIncrement=101;
   wOffsetMax=4096-1;   
  
  while(wCounter<wInputCounter)
    {
      wCounter++;
      //wSizeMax=128*1024;
      //wSize=99840;
      //wOffset=3030;
      
	//<2>.Prepare sending data
	
	       pbData=sOTGH_PT_ISO.aDataBufferArray[0]+wOffset;
	       bDataCounter=sOTGH_PT_ISO.bDataCounter;
	       
	      for (j=0;j<wSize;j++)
	          {
	           *pbData++=bDataCounter++;
	           if (bDataCounter>=sOTGH_PT_ISO.bDataMax)
	               bDataCounter=0;
	          }	
	       sOTGH_PT_ISO.bDataCounter=bDataCounter;   
	//<3>.Issue the ISO-Out command
	     flib_Host20_Issue_ISO (1,1,wMaxPacketSize,wSize
	                          ,&(sOTGH_PT_ISO.aDataBufferArray[0]),wOffset,OTGH_Dir_Out,bMult);


  wTotalSize_Byte=wTotalSize_Byte+wSize;
  if (wTotalSize_Byte>(1024*1024))
     {
     wTotalSize_MByte++;
     wTotalSize_Byte=wTotalSize_Byte-(1024*1024);
     }



  if ((wCounter%wPrintCounter)==0)
     {
       if (psDevice_AP->bSpeed==HOST20_Attach_Device_Speed_Full)
           printf(">>> Full Speed ISO-Out data : (Size =%d / wOffset =%d)Total Size=%dMB + %dBytes =========> Counter=%d \n"
           ,wSize,wOffset,wTotalSize_MByte,wTotalSize_Byte,wCounter);
     
       else
           printf(">>> High Speed ISO-Out data : (Size =%d / wOffset =%d)Total Size=%dMB + %dBytes =========> Counter=%d \n"
           ,wSize,wOffset,wTotalSize_MByte,wTotalSize_Byte,wCounter);
       
     }
    
   wOffset=wOffset + wOffsetIncrement;
  if (wOffset>=wOffsetMax)
     wOffset=0;
  
  wSize=wSize+wSizeIncrement;
  if (wSize>wSizeMax)
     wSize=wSizeIncrement;     
    
 //printf(">>> Wait for device compare data 500ms\n");    
  //flib_Host20_TimerEnable(500);//Wait for Device Compare Data    
    
    
    };	//while(wCounter<wInputCounter)

   printf(">>> ISO-Out data finish : %d \n" ,wCounter ); //<5>.Free the allocated Buffer
        for(i=0;i<OTGH_PT_ISO_DATABUFFER_NUM;i++)