while ( gCTxFDPtr[1] != CTxPtr )
    {
     pTxFDptr = (sFrameDescriptor *) gCTxFDPtr[1];

     // Check CPU ownership, if Owner is DMA then break
     pFrameDataPtr = (U32 *)&pTxFDptr->Status1;
     if ( (*pFrameDataPtr & TXfOwnership_DMA) )
       break ;

     Status = (pTxFDptr->Status2 >> 16) & 0xffff;

     if (Status & TXFD_TXCP)
     {
       gsMacTxStatus[1].TXCP++ ;
       gsMacTxStatus[1].TxBytes += pTxFDptr->Status2 & 0xFFFF; //CMN
       
#if 1
       if (EXTERNAL_LOOPBACK_PORT == 1)
       {
           TxPktSeq = *((volatile U32 *) (pTxFDptr->FrameDataPtr + 16));
           if (TxPktSeq != TxPktSeqWanted)
           {           
               TxPktSeqErr++;
               TxPktSeqWanted = TxPktSeq+1;
           }
           else
               TxPktSeqWanted++;
       }
#endif       
       
     }
     
     else
     //  {
        //CMN
        gTxErrPacketCnt[1]++;
       
        // Save Error status
        if (Status & TXFD_TXABT) gsMacTxStatus[1].TXABT++ ;
        if (Status & TXFD_DEF)   gsMacTxStatus[1].DEF++ ;
        if (Status & TXFD_PAU)   gsMacTxStatus[1].PAU++ ;
        if (Status & TXFD_EXDEF) gsMacTxStatus[1].EXDEF++ ;
        if (Status & TXFD_NCS)   gsMacTxStatus[1].NCS++ ;
        if (Status & TXFD_SQE)   gsMacTxStatus[1].SQE++ ;
        if (Status & TXFD_LC)    gsMacTxStatus[1].LC++ ;
        if (Status & TXFD_TXHA)  gsMacTxStatus[1].TXHA++ ;
     //  }

     // Clear Framedata pointer already used.
     pTxFDptr->Status2 &= (U32)0x0000FFFF; //CMN

     gCTxFDPtr[1] = (U32)pTxFDptr->NextFrameDescriptor ;
    }

    MacTxDoneFlagForLoopBackCheck[1] = 1 ;
   }
   
}


// Interrupt Service Routine for MAC0 Rx
void MAC0_Rx_isr(void)
{
 sFrameDescriptor *pRxFDptr ;
 U32 RxStatus, FrameLength ;
 U32 CRxPtr;
 U8 *pFrameData ;
 U32 RdValue;

 RdValue=MISTA_0;
 
 if (RdValue & 0x04)
     gsMacRxStatus[0].RXOV++;
     
 if (RdValue & 0x02)
     gsMacRxStatus[0].CRCE++;     
     
 if (RdValue & 0x400)
     gsMacRxStatus[0].RDU++;           
 
 
//#ifdef RxInt_Msg 
// UART_printf("MAC0_Rx_isr(%x), ",RdValue) ;
//#endif 
 
 if (RdValue & MISTA_RxBErr)
   {
#ifdef RxInt_Msg 
 UART_printf("RxBErr(%x), ",RdValue) ;
#endif 
    FIFOTHD_0|=SWR;
    LanInitialize(0);
    MacRxDoneFlagForLoopBackCheck[0] = 1 ;
    gsMacRxStatus[0].RxBErr++ ;  
   }
 else
   { 
    // Get current frame descriptor
    CRxPtr = CRXDSA_0 ;

    do
    {
     // Get Rx Frame Descriptor
     pRxFDptr = (sFrameDescriptor *)gCRxFDPtr[0];

     if ((pRxFDptr->Status1|RXfOwnership_CPU)==RXfOwnership_CPU) // ownership=CPU
       {
        RxStatus = (pRxFDptr->Status1 >> 16) & 0xffff;
#ifdef RxInt_Msg        
 UART_printf("Rx_Status=%x,",RxStatus) ;
#endif 

#if 1
        pFrameData = (U8 *)pRxFDptr->FrameDataPtr ;
        if (EXTERNAL_LOOPBACK_PORT == 0)
        {
            RxPktSeq = *((volatile U32 *) (pFrameData + 16));
            if (RxPktSeq != RxPktSeqWanted)
            {               
               *((volatile unsigned int *) 0xFFF03210) = 0x43;
               RxPktSeqErr++;
               RxPktSeqWanted = RxPktSeq+1;
            }
            else
               RxPktSeqWanted++;
        }
#endif
        // If Rx frame is good, then process received frame
        if(RxStatus & RXFD_RXGD)
        {
         FrameLength = pRxFDptr->Status1 & 0xffff ;
         pFrameData = (U8 *)pRxFDptr->FrameDataPtr ;
         gsMacRxStatus[0].RXGD++ ;
         gsMacRxStatus[0].RxBytes += FrameLength; //CMN
       
         pRxFDptr->FrameDataPtr = (U32)RxFrameBuffer0;
         RxFrameBuffer0 += (U32)(sizeof(sMACFrame)) ;
         if ( RxFrameBuffer0 >= (U32)RxFBALimitAddr0)
           RxFrameBuffer0 = (U32)RxFBABaseAddr0 ;
         
         // Send to another port
         if (EXTERNAL_LOOPBACK_PORT == 1)
             SendPacket(1,pFrameData,FrameLength);
        }
        else        
         gRxErrPacketCnt[0]++; 

         // Save Error status
         if (RxStatus & RXFD_RP)   gsMacRxStatus[0].RP++ ;
         if (RxStatus & RXFD_ALIE) gsMacRxStatus[0].ALIE++ ;
         if (RxStatus & RXFD_PTLE) gsMacRxStatus[0].PTLE++ ;         
       }
     else
       break;

     // Change ownership to DMA for next use
     pRxFDptr->Status1 |= RXfOwnership_DMA;

     // Get Next Frame Descriptor pointer to process
     gCRxFDPtr[0] = (U32)(pRxFDptr->NextFrameDescriptor) ;
    } while ((CRxPtr = CRXDSA_0) != gCRxFDPtr[0]);
#ifdef RxInt_Msg        
    UART_printf("\n") ;
#endif 

    MacRxDoneFlagForLoopBackCheck[0] = 1 ; // only used for loopback test

    RSDR_0 = 0;
   }  

 MISTA_0=RdValue&0x0000ffff; //CMN
}


// Interrupt Service Routine for MAC1 Rx
void MAC1_Rx_isr(void)
{
 sFrameDescriptor *pRxFDptr ;
 U32 RxStatus, FrameLength ;
 U32 CRxPtr;
 U8 *pFrameData ;
 U32 RdValue;

 RdValue=MISTA_1;

 if (RdValue & 0x04)
     gsMacRxStatus[1].RXOV++;
     
 if (RdValue & 0x02)
     gsMacRxStatus[1].CRCE++;     
     
 if (RdValue & 0x400)
     gsMacRxStatus[1].RDU++;     
     
 
 //MISTA_1=RdValue&0x0000ffff;
 
#ifdef RxInt_Msg 
//if ((RdValue&0x0000ffff)!=0x211)
 UART_printf("MAC1_Rx_isr(%x), ",RdValue) ;
#endif 
 
 if (RdValue & MISTA_RxBErr)
   {
#ifdef RxInt_Msg 
 UART_printf("RxBErr(%x), ",RdValue) ;
#endif 
    FIFOTHD_1|=SWR;
    LanInitialize(1);
    MacRxDoneFlagForLoopBackCheck[1] = 1 ;
    gsMacRxStatus[1].RxBErr++ ; //CMN [2002/11/01]

   }
 else
   { 
    // Get current frame descriptor
    CRxPtr = CRXDSA_1 ;

    do
    {
     // Get Rx Frame Descriptor
     pRxFDptr = (sFrameDescriptor *)gCRxFDPtr[1];

     if ((pRxFDptr->Status1|RXfOwnership_CPU)==RXfOwnership_CPU) // ownership=CPU
       {
        RxStatus = (pRxFDptr->Status1 >> 16) & 0xffff;
#ifdef RxInt_Msg        
 UART_printf("Rx_Status=%x,",RxStatus) ;
#endif 

#if 1
        pFrameData = (U8 *)pRxFDptr->FrameDataPtr ;
        if (EXTERNAL_LOOPBACK_PORT == 1)
        {
            RxPktSeq = *((volatile U32 *) (pFrameData + 16));
            if (RxPktSeq != RxPktSeqWanted)
            {               
               RxPktSeqErr++;
               RxPktSeqWanted = RxPktSeq+1;
            }
            else
               RxPktSeqWanted++;
        }
#endif
        // If Rx frame is good, then process received frame
        if(RxStatus & RXFD_RXGD)
        {
         FrameLength = pRxFDptr->Status1 & 0xffff ;    
         pFrameData = (U8 *)pRxFDptr->FrameDataPtr ;
         gsMacRxStatus[1].RXGD++ ;
         gsMacRxStatus[1].RxBytes += FrameLength; //CMN

         pRxFDptr->FrameDataPtr = (U32)RxFrameBuffer1;
         RxFrameBuffer1 += (U32)(sizeof(sMACFrame)) ;
         if ( RxFrameBuffer1 >= (U32)RxFBALimitAddr1)
           RxFrameBuffer1 = (U32)RxFBABaseAddr1 ;
         
         // Send to another port
         if (EXTERNAL_LOOPBACK_PORT == 0)
         {
             /*
             *(pFrameData+0)=0x03; //marked by CMN
             *(pFrameData+5)=0x66; //marked by CMN
             */
             SendPacket(0,pFrameData,FrameLength);
         }
        }
        else
         // If Rx frame has error, then process error frame
         gRxErrPacketCnt[1]++ ; 

         // Save Error status
         if (RxStatus & RXFD_RP)   gsMacRxStatus[1].RP++ ;
         if (RxStatus & RXFD_ALIE) gsMacRxStatus[1].ALIE++ ;
         if (RxStatus & RXFD_PTLE) gsMacRxStatus[1].PTLE++ ;
        
       }
     else
       break;

     // Change ownership to DMA for next use
     pRxFDptr->Status1 |= RXfOwnership_DMA;

     // Get Next Frame Descriptor pointer to process
     gCRxFDPtr[1] = (U32)(pRxFDptr->NextFrameDescriptor) ;      
     
    } while ((CRxPtr = CRXDSA_1) != gCRxFDPtr[1]);
#ifdef RxInt_Msg        
 UART_printf("\n") ;
#endif 

    MacRxDoneFlagForLoopBackCheck[1] = 1 ; // only used for loopback test

    RSDR_1 = 0;
   }
   
 MISTA_1=RdValue&0x0000ffff; //CMN
}


// Send ethernet frame function
int SendPacket(int num, U8 *Data,int Size)
{
 sFrameDescriptor *psTxFD;
 int              FrameLength ;
 U32              *pTXFDStatus1;

 if (num==0)
   {      
    // Get Tx frame descriptor & data pointer
    psTxFD = (sFrameDescriptor *)gWTxFDPtr[0] ;

    pTXFDStatus1 = (U32 *)&psTxFD->Status1;
    FrameLength = Size ;

    // Check DMA ownership
    if ( (*pTXFDStatus1 & TXfOwnership_DMA) ) return 0 ;

    //CMN
    if (psTxFD->Status2 & 0xFFFF0000)  
    {
        CheckTxFDStatus(0, psTxFD);   //The descriptor hasn't been processed yet.
        DoChk++;
    }
    
    psTxFD->FrameDataPtr = (U32)Data;

#if 1
    if (EXTERNAL_LOOPBACK_PORT == 0)
        *((volatile U32 *) (Data + 16)) = PktSeq++;
#endif

    // Set TX Frame flag & Length Field
    psTxFD->Status1 |= (PaddingMode | CRCMode | MACTxIntEn);
    psTxFD->Status2 = (U32)(FrameLength & 0xffff);

    // Cheange ownership to DMA
    psTxFD->Status1 |= TXfOwnership_DMA;

    // Enable MAC Tx control register
    MacTxGo(0);
    
    // Change the Tx frame descriptor for next use
    gWTxFDPtr[0] = (U32)(psTxFD->NextFrameDescriptor);
   }
 else if (num==1)
   {
    // Get Tx frame descriptor & data pointer
    psTxFD = (sFrameDescriptor *)gWTxFDPtr[1] ;

    pTXFDStatus1 = (U32 *)&psTxFD->Status1;
    FrameLength = Size ;

    // Check DMA ownership
    if ( (*pTXFDStatus1 & TXfOwnership_DMA) ) return 0 ;

    //CMN
    if (psTxFD->Status2 & 0xFFFF0000)  
    {
        CheckTxFDStatus(1, psTxFD);   //The descriptor hasn't been processed yet.
        DoChk++;
    }


    psTxFD->FrameDataPtr = (U32)Data;

#if 1
    if (EXTERNAL_LOOPBACK_PORT == 1)
        *((volatile U32 *) (Data + 16)) = PktSeq++;
#endif
    // Set TX Frame flag & Length Field
    psTxFD->Status1 |= (PaddingMode | CRCMode | MACTxIntEn);  
    psTxFD->Status2 = (U32)(FrameLength & 0xffff);

    // Cheange ownership to DMA
    psTxFD->Status1 |= TXfOwnership_DMA;

    // Enable MAC Tx control register
    MacTxGo(1);

    // Change the Tx frame descriptor for next use
    gWTxFDPtr[1] = (U32)(psTxFD->NextFrameDescriptor);
   }
 return 1 ;
}


// Main function for MAC Block test
int MacTest(void)
{	
 volatile unsigned int loop=0;  
 volatile U32 btime, total_time;
 
 TimerInitialize(TIMER_CHANNEL);

 LanInitialize(0);
 LanInitialize(1);
 
 btime = cur_ticks;
 
 while(1) 
 {
   if ((cur_ticks - btime) >= 100)
   {
       total_time = cur_ticks - btime;
       btime = cur_ticks;
       ShowTxRxStatusWithTime();       
   }
 }

 return 1;
}


int main()
{
  unsigned int oldvect, temp;
  
  UART_Initialize(115200);
  UART_printf("\n\nW90N740 DIAG Program 1.0 - MAC\n\n");

  /* clear CPSR I bit */
  __asm
  {
      MRS    temp, CPSR
      AND    temp, temp, 0x7F
      MSR    CPSR_c, temp
  }

  /* replace IRQ exception entry */
  oldvect = *(volatile unsigned int *)0x38;
  *(volatile unsigned int *)0x38 = (unsigned int) IRQ_IntHandler;
 
  /*
  AIC_SCR_EMCTX0 = 0x41;
  AIC_SCR_EMCRX0 = 0x41;
  AIC_SCR_EMCTX1 = 0x41;
  AIC_SCR_EMCRX1 = 0x41;
  */
    
  memset((U8 *)0x80400000,0,1024*1024) ; // clear buffer
  MacTest();
  return 0;
}