Subversion Repositories openrisc_2011-10-31

/* eth.c. Test of Or1ksim Ethernet
 
   Copyright (C) 1999-2006 OpenCores
   Copyright (C) 2010 Embecosm Limited
 
   Contributors various OpenCores participants
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of OpenRISC 1000 Architectural Simulator.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 3 of the License, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   more details.
 
   You should have received a copy of the GNU General Public License along
   with this program.  If not, see <http:  www.gnu.org/licenses/>.  */
 
/* ----------------------------------------------------------------------------
   This code is commented throughout for use with Doxygen.
   --------------------------------------------------------------------------*/
 
#include "spr-defs.h"
#include "support.h"
#include "board.h"
 
typedef long off_t;
 
#include "fields.h"
#include "eth.h"
 
typedef volatile unsigned long *REGISTER;
 
REGISTER
    eth_moder = (unsigned long *)(ETH_BASE + ETH_MODER),
	eth_int_source = (unsigned long *)(ETH_BASE + ETH_INT_SOURCE),
	eth_int_mask = (unsigned long *)(ETH_BASE + ETH_INT_MASK),
	eth_ipgt = (unsigned long *)(ETH_BASE + ETH_IPGT),
	eth_ipgr1 = (unsigned long *)(ETH_BASE + ETH_IPGR1),
	eth_ipgr2 = (unsigned long *)(ETH_BASE + ETH_IPGR2),
	eth_packetlen = (unsigned long *)(ETH_BASE + ETH_PACKETLEN),
	eth_collconf = (unsigned long *)(ETH_BASE + ETH_COLLCONF),
	eth_tx_bd_num = (unsigned long *)(ETH_BASE + ETH_TX_BD_NUM),
	eth_controlmoder = (unsigned long *)(ETH_BASE + ETH_CTRLMODER),
	eth_miimoder = (unsigned long *)(ETH_BASE + ETH_MIIMODER),
	eth_miicommand = (unsigned long *)(ETH_BASE + ETH_MIICOMMAND),
	eth_miiaddress = (unsigned long *)(ETH_BASE + ETH_MIIADDRESS),
	eth_miitx_data = (unsigned long *)(ETH_BASE + ETH_MIITX_DATA),
	eth_miirx_data = (unsigned long *)(ETH_BASE + ETH_MIIRX_DATA),
	eth_miistatus = (unsigned long *)(ETH_BASE + ETH_MIISTATUS),
	eth_mac_addr0 = (unsigned long *)(ETH_BASE + ETH_MAC_ADDR0),
	eth_mac_addr1 = (unsigned long *)(ETH_BASE + ETH_MAC_ADDR1),
	eth_bd_base = (unsigned long *)(ETH_BASE + ETH_BD_BASE);
 
volatile unsigned int_happend;
unsigned char r_packet[2000];
unsigned char s_packet[1003];
unsigned tx_bindex;
unsigned rx_bindex;
 
void interrupt_handler()
{
    unsigned i,len;
 
    printf ("Int\n");
    switch (*eth_int_source & 0x7f) {
    case 0x2 : 
	printf ("Transmit Error.\n");
	*eth_int_source = 0x2;
	 break;
    case 0x8 : 
	printf ("Receive Error\n");
	*eth_int_source = 0x8;
	break;
    case 0x4 : 
        printf ("Receive Frame\n");
	*eth_int_source = 0x4;
 
        CLEAR_FLAG(*eth_moder, ETH_MODER, RXEN);
 
        len = GET_FIELD(eth_bd_base[(*eth_tx_bd_num << 1) + 2], ETH_RX_BD, LENGTH);
        for (i=0; i<len; i++)
          if (r_packet[i] != (unsigned char)i)
          {
              printf("Failed at byte %d. expect %d, received %d\n", i, i, r_packet[i]);
              exit(1);
          }
        break;
    case 0x10: 
	printf ("Busy\n");
	*eth_int_source = 0x10;
	break;
    case 0x1 : 
        printf ("Transmit Frame.\n");
        *eth_int_source = 0x1;
	CLEAR_FLAG(*eth_moder, ETH_MODER, TXEN);
 
        break;
    default:
        printf ("Invalid int @ %0x\n", (unsigned int)*eth_int_source & 0x7f);
      	*eth_int_source = 0x7f;
	exit (1);
    }
 
    mtspr(SPR_PICSR, 0);
    int_happend = 1;
}
 
static void set_mac( void )
{
	*eth_mac_addr0 = 0x04030201LU;
	*eth_mac_addr1 = 0x00000605LU;
}
 
static void transmit_one_packet( void )
{
	unsigned i;
 
	/* Initialize packet */
	for ( i = 0; i < sizeof(s_packet); ++ i )
		s_packet[i] = (unsigned char)i;
 
	/* Set Ethernet BD */
	SET_FIELD(eth_bd_base[tx_bindex], ETH_TX_BD, LENGTH, sizeof(s_packet));
	eth_bd_base[tx_bindex + 1] = (unsigned long)s_packet;
 
	/* Start Ethernet */
	SET_FLAG(eth_bd_base[tx_bindex], ETH_TX_BD, READY);
	SET_FLAG(*eth_moder, ETH_MODER, TXEN);
 
	/* Now wait till sent */
	while ( TEST_FLAG( eth_bd_base[tx_bindex], ETH_TX_BD, READY ) );
	CLEAR_FLAG(*eth_moder, ETH_MODER, TXEN);
	*eth_int_source = 0x7f;
}
 
static void transmit_one_packet_int( void )
{
	unsigned i;	
 
	int_happend = 0;
	/* Initialize packet */
	printf("Init\n");
	for ( i = 0; i < sizeof(s_packet); ++ i )
		s_packet[i] = (unsigned char)i;
 
	/* Set Ethernet BD */
	printf("Set BD\n");
	SET_FIELD(eth_bd_base[tx_bindex], ETH_TX_BD, LENGTH, sizeof(s_packet));
	eth_bd_base[tx_bindex + 1] = (unsigned long)s_packet;
 
	/* Start Ethernet */
	printf("Set Flags\n");
	SET_FLAG(eth_bd_base[tx_bindex], ETH_TX_BD, IRQ);
	SET_FLAG(eth_bd_base[tx_bindex], ETH_TX_BD, READY);
	SET_FLAG(*eth_moder, ETH_MODER, TXEN);	
}
 
 
static void receive_one_packet(void)
{
  unsigned int i;
  unsigned int len;  
 
  eth_bd_base[rx_bindex + 1] = (unsigned long)r_packet;
 
  SET_FLAG(eth_bd_base[rx_bindex], ETH_RX_BD, READY);
  SET_FLAG(*eth_moder, ETH_MODER, RXEN);
 
  while ( TEST_FLAG( eth_bd_base[rx_bindex], ETH_RX_BD, READY ) );  
  CLEAR_FLAG(*eth_moder, ETH_MODER, RXEN);
  *eth_int_source = 0x7f;
 
  len = GET_FIELD(eth_bd_base[rx_bindex], ETH_RX_BD, LENGTH);
  for (i=0; i<len; i++)
      if (r_packet[i] != (unsigned char)i)
      {
          printf("Failed at byte %d. expect %d, received %d\n", i, i, r_packet[i]);
          exit(1);
      }
}
 
static void receive_one_packet_int(void)
{
  int_happend = 0;
  printf("Set BD\n");
  eth_bd_base[rx_bindex + 1] = (unsigned long)r_packet;
 
  printf("SetFlags\n");
  SET_FLAG(eth_bd_base[rx_bindex], ETH_RX_BD, IRQ);
  SET_FLAG(eth_bd_base[rx_bindex], ETH_RX_BD, READY);
  SET_FLAG(*eth_moder, ETH_MODER, RXEN);
}
 
int main()
{
	printf( "Starting Ethernet test\n" );
 
	tx_bindex = 0;
	rx_bindex = *eth_tx_bd_num << 1;
 
	set_mac();
 
	/*-------------------*/
	/* non iterrupt test */
	transmit_one_packet();
	tx_bindex += 2;	
	receive_one_packet();
	rx_bindex += 2;
	transmit_one_packet();
	tx_bindex += 2;
	receive_one_packet();
	rx_bindex += 2;
 
 
	/*-------------------*/
	/* interrupt test    */
	excpt_int = (unsigned long)interrupt_handler;
	/* Enable interrup	ts */
	printf("enable ints\n");
	mtspr (SPR_SR, mfspr(SPR_SR) | SPR_SR_IEE);
	mtspr (SPR_PICMR, mfspr(SPR_PICMR) | (0x00000001L << ETH_IRQ));
 
	printf("set mask flags TX\n");
	SET_FLAG(*eth_int_mask, ETH_INT_MASK, TXB_M);
	transmit_one_packet_int();
	tx_bindex += 2;
	/* printf("waiting for int\n"); */
	while (!int_happend);
	CLEAR_FLAG(*eth_int_mask, ETH_INT_MASK, TXB_M);
 
	printf("seting mask flag RX\n");
	SET_FLAG(*eth_int_mask, ETH_INT_MASK, RXB_M);
	receive_one_packet_int();
	rx_bindex += 2;
	/* printf("waiting for int\n"); */
	while (!int_happend);
	CLEAR_FLAG(*eth_int_mask, ETH_INT_MASK, RXB_M);
 
 
	printf( "Ending Ethernet test\n" );
 
	report (0xdeaddead);
	exit(0);
}