sed.c

ADAM2 sources (modified by Oleg)

 */

char abuffer[4096];

octet *
sed_FormatPacket( destEAddr, ethType )
        register octet *destEAddr;
  {
  octet *xMitBuf;
  bit32u *dp;
  int i;
    
  for(i=0,dp=(bit32u *)abuffer;i<((sizeof abuffer)/4);i++) 
    *dp++=0;

  xMitBuf = (octet *)&abuffer[2];
  Move( destEAddr, xMitBuf, 6 );
  Move( sed_lclEthAddr, xMitBuf + 6, 6 );
  *((short *)(xMitBuf+12)) = wfix(ethType);
  return(xMitBuf+14);
  }

/*
 *  Send a packet out over the ethernet.  The packet is sitting at the
 * beginning of the transmit buffer.  The routine returns when the
 * packet has been successfully sent.
 */
int sed_Send( pkLengthInOctets )
  register int pkLengthInOctets;
  {
  char *cp;

  pkLengthInOctets += 14;             /* account for Ethernet header */
  pkLengthInOctets = (pkLengthInOctets + 1) & (~1);

  if (pkLengthInOctets < E10P_MIN) 
    pkLengthInOctets = E10P_MIN; /* and min. ethernet len */

  cp=&abuffer[2];
  IssueSend((int *)UNCACHED(cp),pkLengthInOctets, FALSE);
  /*Now wait for Tx completion*/
  while (TCRFREEENT == txcompring_size)
    {
    }
  TCRENTINC=1;
  return(0);
  }

/* 
 * Test for the arrival of a packet on the Ethernet interface.  The packet may
 * arrive in either buffer A or buffer B; the location of the packet is
 * returned.  If no packet is returned withing 'timeout' milliseconds,
 * then the routine returns zero.
 * 
 * Note: ignores ethernet errors.  may occasionally return something
 * which was received in error.
 */

octet *sed_IsPacket(void)
  {
  octet *pb;
    
  pb=GetRxPacket();
  if (pb)
    {
    pb+=14;
    }
  return(pb);
  }

/* 
 *  Check to make sure that the packet that you received was the one that
 * you expected to get.
 */
int sed_CheckPacket( recBufLocation, expectedType )
    word *recBufLocation;
    word expectedType;
  {

  if ( recBufLocation[-1] != wfix(expectedType) ) 
    return(0);
   else
    return(1);
  }

char ubuff[2048];

void *GetRxPacket(void)
  {
  bit32u uitmpsts,rlen;
  char *uipbufrtn;

  uipbufrtn=0;
  do
    {
    if (RCRPENDENT)
      {
      uitmpsts=RxCompPtr->status;
      CurrentRcb=(struct rcb_s *)UNCACHED(RxCompPtr->sof_list);
      rlen=CurrentRcb->size&0x0ffff;
      if (((uitmpsts&0xc0000000)==0x80000000)&&(rlen>=60)&&(rlen<=1514))
        { /* Good frame*/
        sys_memcpy(&ubuff[2],CurrentRcb->DatPtr,rlen);
        uipbufrtn=&ubuff[2];
        }
      if (uitmpsts&0x80000000)
        {
        RxFree(CurrentRcb);                         
        }
      RxCompPtr=((struct rxcompring_s *) ((((int)(RxCompPtr+1))&RxCompRingMask)|(RxCompRingBase)));
      RCRENTINC=1;
      }
    }while((RCRPENDENT)&&(uipbufrtn==0));
  return(uipbufrtn);
  }

#ifdef DIAG_SUPPORT
void FillBuffer(volatile int *buffer,int size)
{
  int i;
  char *cp;

  if ((size > 1518) || (size < 64)) 
	return;
  cp = (char *)buffer;
  for(i = 0; i < size; i++)
    *cp++ = (i + 1);
}

int CheckBuffer(volatile int *buffer, int size, int seq)
{
  int i;
  char *cp;

  if ((size > 1518) || (size < 64)) 
  {
    return 1;
  }
  size -= 4;
  cp = (char *)buffer;
  for(i = 0; i < size; i++, cp++)
  {
    if (i == SEQ)
    {
      if ((*cp & 0x0ff) != (seq & 0x0ff))
      {
		/*sys_printf("\n Rx Buffer data miscompare, Expected %x, Found %x\n", (seq&0x0ff), (*cp&0x0ff));*/
        return 1;
       }
    }
    else
    {
      if ((*cp & 0x0ff) != ((i + 1) & 0x0ff)) 
      {
		/*sys_printf("\n Rx Buffer data miscompare, Expected %x, Found %x\n", ((i+1)&0x0ff), (*cp&0x0ff));*/
        return 1;
      }
    }
  }
  rcb_pending--;
  return(0);
}

void SetSeq(volatile int *buffer,int seq)
{
  char *cp;

  if (SEQ >= BUFFER_SIZE) 
	return;
  cp = (char *)buffer;
  cp[SEQ] = (char)seq;
}

int test_emac(int loopback)
{
  volatile unsigned *mem_ptr; 
  int data_val, i, j, m, RxNeed, ExpTxErrors, try, sts; 

  if (sed_Init(loopback) == 1)
	return 1;

  /* Now put some data in Tx buffer */
  for(i = 0;i < TX_BUF_COUNT; i++)
  {
    if (i >= FLIP_TBUF_INDEX)
      mem_ptr = sys_malloc(1518+16);
    else
      mem_ptr  = sys_malloc(1518+16);
    if (!mem_ptr) {
      sys_printf("Error: sys_malloc\n");
	  return 1;
	}
    mem_ptr=(volatile unsigned *)((i&0xf)+((bit32u)mem_ptr));
    FillBuffer((int *)mem_ptr,1518);
    tx_buf[i] = mem_ptr;
  }

  tx_buf_index = 0;
  tx_frame_seq = rx_fram_seq = 0;
  ExpTxErrors = 0;

  if ((loopback == EXTERNAL_LOOP) || (loopback == WIRE_LOOP))
    clockwait(3*av_cpufreq);
  t_clear();
  if (MACCONTROL&NO_LOOP)
  {
    while(MACSTATUS & 1) 
    {
      if (t_get() > (4*av_cpufreq)) 
      {
		sys_printf("\n Timed out waiting for Link\n");
        return 1;
      }
    }
  }

  /* Now send frame */
  for(j = 0; j < loops; j++)
  {
    for(i = MIN_FRAME_SIZE;i <= MAX_FRAME_SIZE; i += steps)
    {
      for(m = 0; m < TX_BURST_COUNT; m++)
      {
        mem_ptr = tx_buf[tx_buf_index++];
        if (tx_buf_index >= TX_BUF_COUNT) tx_buf_index = 0;
        SetSeq((int *)mem_ptr, tx_frame_seq++);
        IssueSend((int *)mem_ptr, i, FALSE);
        if (((tx_frame_seq & 0xff) == 0) && (( j> 2) || (loops == 1)))
        {
          IssueSend((int *)mem_ptr, i, TRUE);
          ExpTxErrors++;
        }
      }
      for(m = 0; m < TX_BURST_COUNT; m++)
      {
        try = TEST_TIMEOUT;
        while (TCRFREEENT == txcompring_size)
        {
          data_val++;
          if (!try) 
          {
			/*sys_printf("\n Timed out waiting for Tx Completion Ring\n");*/
            return 1;
          }
          try--;
        }
        RxNeed = 1;
        while (RxNeed)
        {
          try = TEST_TIMEOUT;
          while (RCRFREEENT == rxcompring_size)
          {
            data_val++;
            if (!try) 
            {
			  /*sys_printf("\n Timed out waiting for Rx Completion Ring %x %x\n", RCRFREEENT, rxcompring_size);*/
              return 1;
            }
            try--;
          }
      	  CurrentRcb = (struct rcb_s *)UNCACHED(RxCompPtr->sof_list);
          if ((RxCompPtr->status & 0xc0000000) == 0x80000000)
          {
            RxNeed--;
            sts = CheckBuffer(CurrentRcb->DatPtr, i, rx_fram_seq++);
            if (sts) 
            {
              MACCONTROL = CAF | FULL_DUPLEX | SPEED_100 | PEFCE;
              return(sts);
            }
            if ((CurrentRcb->size & 0x0ffff) != (i+4)) 
			{
			  /*sys_printf("\n Rx buffer Length error, i=%d, size=%x\n", (i+4), (CurrentRcb->size & 0xffff));*/
              return 1;
			}
            *(CurrentRcb->DatPtr) = 0;
            RxFree(CurrentRcb);
          }
          RxCompPtr = ((struct rxcompring_s *) ((((int)(RxCompPtr + 1))&RxCompRingMask) | (RxCompRingBase)));
          RCRENTINC = 1;
        }
        tcb_pending--;
        TCRENTINC = 1;
      }
      while(ExpTxErrors) 
      {
        try = TEST_TIMEOUT;
        while (TCRFREEENT == txcompring_size)
        {
          data_val++;
          if (!try) 
          {
			/*sys_printf("\n Timed out waiting for Tx Completion Ring\n");*/
            return 1;
          }
          try--;
        }
        ExpTxErrors--;
        tcb_pending--;
        TCRENTINC = 1;
      }
    }
  }
  sed_shutdown();
  return 0;
}

#if 0
"emac(id=eth0:InternalLoopback, base=0xA8610000, reset_bit=17, loopback=internal)",
"emac(id=eth1:InternalLoopback, base=0xA8612800, reset_bit=21, loopback=internal)",
"emac(id=eth0:ExternalLoopback, base=0xA8610000, reset_bit=17, loopback=external, mii_phy=1, critical=no)",
"emac(id=eth1:ExternalLoopback, base=0xA8612800, reset_bit=21, loopback=external, mii_phy=1, critical=no)",
"emac(id=eth0:WireLoopback    , base=0xA8610000, reset_bit=17, loopback=wire    , mii_phy=1, critical=no)",
"emac(id=eth1:WireLoopback    , base=0xA8612800, reset_bit=21, loopback=wire    , mii_phy=1, critical=no)",
#endif
int demac(void)
{
    char *cp;

	rtim = t_get();
	av_cpufreq = (cp = sys_getenv("cpufrequency")) ? atoul(cp) : 125000000;
  	ticdiv = av_cpufreq / 2000;

	loops = 1/*10*/;
	steps = 7/*1*/;	
	
	emacbase = EMACA_BASE;
	
	sys_printf("Testing 'eth0' InternalLoop ");
	if (test_emac(INTERNAL_LOOP) == 1)
	{
		sys_printf("Failed\n");
		return 1;
	}
	else
		sys_printf("Passed\n");
	
	sys_printf("Testing 'eth0' ExternalLoop ");
	if (test_emac(EXTERNAL_LOOP) == 1)
	{
		sys_printf("Failed\n");
		return 1;
	}
	else
		sys_printf("Passed\n");

#if 0
    sys_printf("Testing 'eth0' WireLoop ");
	if (test_emac(WIRE_LOOP) == 1)
	{
		sys_printf("Failed\n");
		return 1;
	}
	else
		sys_printf("Passed\n");
#endif
	return 0;
}
#endif /*DIAG_SUPPORT*/

#include "emacphy.c"