Subversion Repositories openrisc

/* ethernet.c -- Simulation of Ethernet MAC

   Copyright (C) 2001 by Erez Volk, erez@opencores.org

                         Ivan Guzvinec, ivang@opencores.org

   Copyright (C) 2008, 2001 Embecosm Limited

   Copyright (C) 2010 ORSoC

   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

   Contributor Julius Baxter <julius@orsoc.se>

   This file is part of Or1ksim, the 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 program is commented throughout in a fashion suitable for processing

   with Doxygen. */

/* Autoconf and/or portability configuration */

#include "config.h"

#include "port.h"

/* System includes */

#include <stdlib.h>

#include <stdio.h>

#include <sys/socket.h>

#include <sys/ioctl.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <fcntl.h>

#include <sys/poll.h>

#include <unistd.h>

#include <errno.h>

#include <linux/if.h>

#include <linux/if_tun.h>

/* Package includes */

#include "arch.h"

#include "config.h"

#include "abstract.h"

#include "eth.h"

#include "dma.h"

#include "sim-config.h"

#include "fields.h"

#include "crc32.h"

#include "vapi.h"

#include "pic.h"

#include "sched.h"

#include "toplevel-support.h"

#include "sim-cmd.h"

/* Control debug messages */

#define ETH_DEBUG 0

#ifndef ETH_DEBUG

# define ETH_DEBUG  1

#endif

/*! Period (clock cycles) for rescheduling Rx and Tx controllers. */

#define  RTX_RESCHED_PERIOD  10000

/*! MAC address that is always accepted. */

static const unsigned char mac_broadcast[ETHER_ADDR_LEN] =

  { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

/* -------------------------------------------------------------------------- */

/*!Structure describing the Ethernet device                                   */

/* -------------------------------------------------------------------------- */

struct eth_device

{

  /* Basic stuff about the device */

  int                enabled;           /* Is peripheral enabled */

  oraddr_t           baseaddr;          /* Base address in memory */

  unsigned long int  base_vapi_id;      /* Start of VAPI ID block */

  /* DMA controller this MAC is connected to, and associated channels */

  unsigned dma;

  unsigned tx_channel;

  unsigned rx_channel;

  /* Details of the hardware */

  unsigned char      mac_address[ETHER_ADDR_LEN];  /* Ext HW address */

  unsigned long int  phy_addr;          /* Int HW address */

  unsigned long int  mac_int;           /* interrupt line number */

  int                dummy_crc;         /* Flag indicating if we add CRC */

  int                int_line_stat;     /* interrupt line status */

  /* External interface deatils */

  int rtx_type;                         /* Type of external i/f: FILE or TAP */

  /* RX and TX file names and handles for FILE type connection. */

  char  *rxfile;                        /* Rx filename */

  char  *txfile;                        /* Tx filename */

  int    txfd;                          /* Rx file handle */

  int    rxfd;                          /* Tx file handle */

  /* Info for TAP type connections */

  char *tap_dev;                        /* The TAP device */

  int   rtx_fd;                         /* TAP device handle */

  /* Indices into the buffer descriptors. */

  unsigned long int  tx_bd_index;

  unsigned long int  rx_bd_index;

  /* Visible registers */

  struct

  {

    unsigned long int  moder;

    unsigned long int  int_source;

    unsigned long int  int_mask;

    unsigned long int  ipgt;

    unsigned long int  ipgr1;

    unsigned long int  ipgr2;

    unsigned long int  packetlen;

    unsigned long int  collconf;

    unsigned long int  tx_bd_num;

    unsigned long int  controlmoder;

    unsigned long int  miimoder;

    unsigned long int  miicommand;

    unsigned long int  miiaddress;

    unsigned long int  miitx_data;

    unsigned long int  miirx_data;

    unsigned long int  miistatus;

    unsigned long int  hash0;

    unsigned long int  hash1;

    /* Buffer descriptors */

    unsigned long int  bd_ram[ETH_BD_SPACE / 4];

  } regs;

};

/* -------------------------------------------------------------------------- */

/*!Write an Ethernet packet to a FILE interface.

   This writes a single Ethernet packet to a FILE interface. The format is to

   write the length, then the data.

   @param[in] eth     Pointer to the relevant Ethernet data structure.

   @param[in] buf     Where to get the data.

   @param[in] length  Length of data to write.

   @return  The length if successful, a negative value otherwise.             */

/* -------------------------------------------------------------------------- */

static ssize_t

eth_write_file_packet (struct eth_device *eth,

                       unsigned char     *buf,

                       unsigned long int  length)

{

  ssize_t  nwritten;

  /* Write length to file. */

  nwritten = write (eth->txfd, &(length), sizeof (length));

  if (nwritten != sizeof (length))

    {

      fprintf (stderr, "ERROR: Failed to write Ethernet packet length: %s.\n",

               strerror (errno));

      return  -1;

    }

  /* write data to file */

  nwritten = write (eth->txfd, buf, length);

  if (nwritten != length)

    {

      fprintf (stderr, "ERROR: Failed to write Ethernet packet data: %s.\n",

               strerror (errno));

      return  -1;

    }

  return  nwritten;

}       /* eth_write_file_packet () */

/* -------------------------------------------------------------------------- */

/*!Write an Ethernet packet to a TAP interface.

   This writes a single Ethernet packet to a TAP interface.

   @param[in] eth     Pointer to the relevant Ethernet data structure.

   @param[in] buf     Where to get the data.

   @param[in] length  Length of data to write.

   @return  The length if successful, a negative value otherwise.             */

/* -------------------------------------------------------------------------- */

static ssize_t

eth_write_tap_packet (struct eth_device *eth,

                      unsigned char     *buf,

                      unsigned long int  length)

{

  ssize_t  nwritten;

#if ETH_DEBUG

  int  j;

  printf ("Writing TAP\n");

  printf ("  packet %d bytes:", (int) length);

  for (j = 0; j < length; j++)

    {

      if (0 == (j % 16))

        {

          printf ("\n");

        }

      else if (0 == (j % 8))

        {

          printf (" ");

        }

      printf ("%.2x ", buf[j]);

    }

  printf("\nend packet:\n");

#endif    

  /* Write the data to the TAP */

  nwritten = write (eth->rtx_fd, buf, length);

  if (nwritten != length)

    {

      fprintf (stderr, "ERROR: Failed to write Ethernet packet data: %s.\n",

               strerror (errno));

      return  -1;

    }

  return  nwritten;

}       /* eth_write_tap_packet () */

/* -------------------------------------------------------------------------- */

/*!Write an Ethernet packet.

   This writes a single Ethernet packet to the outside world from the supplied

   buffer. It deals with the different types of external interface.

   @param[in] eth     Pointer to the relevant Ethernet data structure.

   @param[in] buf     Where to get the data.

   @param[in] length  Length of data to write.

   @return  The length if successful, zero if no packet was available,

            a negative value otherwise.                                       */

/* -------------------------------------------------------------------------- */

static ssize_t

eth_write_packet (struct eth_device *eth,

                  unsigned char     *buf,

                  ssize_t            length)

{

  /* Send packet according to interface type. */

  switch (eth->rtx_type)

    {

    case ETH_RTX_FILE: return  eth_write_file_packet (eth, buf, length);

    case ETH_RTX_TAP:  return  eth_write_tap_packet (eth, buf, length);

    default:

      fprintf (stderr, "Unknown Ethernet write interface: ignored.\n");

      return  (ssize_t) -1;

    }

}       /* eth_write_packet () */

/* -------------------------------------------------------------------------- */

/*!Flush a Tx buffer descriptor to the outside world.

   We know the buffer descriptor is full, so write it to the appropriate

   outside interface.

   @param[in] eth  The Ethernet data structure.                               */

/* -------------------------------------------------------------------------- */

static void

eth_flush_bd (struct eth_device *eth)

{

  /* First word of BD is flags and length, second is pointer to buffer */

  unsigned long int  bd_info = eth->regs.bd_ram[eth->tx_bd_index];

  unsigned long int  bd_addr = eth->regs.bd_ram[eth->tx_bd_index + 1];

  unsigned char      buf[ETH_MAXPL];

  long int           packet_length;

  long int           bytes_sent;

  /* Get the packet length */

  packet_length = GET_FIELD (bd_info, ETH_TX_BD, LENGTH);

  /* Clear error status bits and retry count. */

  CLEAR_FLAG (bd_info, ETH_TX_BD, DEFER);

  CLEAR_FLAG (bd_info, ETH_TX_BD, COLLISION);

  CLEAR_FLAG (bd_info, ETH_TX_BD, RETRANSMIT);

  CLEAR_FLAG (bd_info, ETH_TX_BD, UNDERRUN);

  CLEAR_FLAG (bd_info, ETH_TX_BD, NO_CARRIER);

  SET_FIELD (bd_info, ETH_TX_BD, RETRY, 0);

  /* Copy data from buffer descriptor address into our local buf. */

  for (bytes_sent = 0; bytes_sent < packet_length; bytes_sent +=4)

    {

      unsigned long int  read_word =

        eval_direct32 (bytes_sent + bd_addr, 0, 0);

      buf[bytes_sent]     = (unsigned char) (read_word >> 24);

      buf[bytes_sent + 1] = (unsigned char) (read_word >> 16);

      buf[bytes_sent + 2] = (unsigned char) (read_word >> 8);

      buf[bytes_sent + 3] = (unsigned char) (read_word);

    }

  /* Send packet according to interface type and set BD status. If we didn't

     write the whole packet, then we retry. */

  if (eth_write_packet (eth, buf, packet_length) == packet_length)

    {

      CLEAR_FLAG (bd_info, ETH_TX_BD, READY);

      SET_FLAG (eth->regs.int_source, ETH_INT_SOURCE, TXB);

    }

  else

    {

      /* Does this retry mechanism really work? */

      CLEAR_FLAG (bd_info, ETH_TX_BD, READY);

      CLEAR_FLAG (bd_info, ETH_TX_BD, COLLISION);

      SET_FLAG (eth->regs.int_source, ETH_INT_SOURCE, TXE);

#if ETH_DEBUG

      printf ("Transmit retry request.\n");

#endif

    }

  /* Update the flags in the buffer descriptor */

  eth->regs.bd_ram[eth->tx_bd_index] = bd_info;

  /* Generate interrupt to indicate transfer complete, under the

     following criteria all being met:

     - either INT_MASK flag for Tx (OK or error) is set

     - the bugger descriptor has its IRQ flag set

     - there is no interrupt in progress.

     @todo We ought to warn if we get here and fail to set an IRQ. */

  if ((TEST_FLAG (eth->regs.int_mask, ETH_INT_MASK, TXE_M) ||

       TEST_FLAG (eth->regs.int_mask, ETH_INT_MASK, TXB_M)) &&

      TEST_FLAG (bd_info, ETH_TX_BD, IRQ))

    {

      if (eth->int_line_stat)

        {

          fprintf (stderr, "Warning: Interrupt active during Tx.\n");

        }

      else

        {

#if ETH_DEBUG

          printf ("TRANSMIT interrupt\n");

#endif

          report_interrupt (eth->mac_int);

          eth->int_line_stat = 1;

        }

    }

  /* Advance to next BD, wrapping around if appropriate. */

  if (TEST_FLAG (bd_info, ETH_TX_BD, WRAP) ||

      eth->tx_bd_index >= ((eth->regs.tx_bd_num - 1) * 2))

    {

      eth->tx_bd_index = 0;

    }

  else

    {

      eth->tx_bd_index += 2;

    }

}       /* eth_flush_bd () */

/* -------------------------------------------------------------------------- */

/*!Tx clock function.

   Responsible for starting and completing any TX actions.

   The original version had 4 states, which allowed modeling the transfer of

   data one byte per cycle.  For now we use only the one state for

   efficiency. When we find something in a buffer descriptor, we transmit

   it.

   We reschedule every cycle. There is no point in trying to do anything if

   there is an interrupt still being processed by the core.

   @todo We should eventually reinstate the one byte per cycle transfer.

   @param[in] dat  The Ethernet data structure, passed as a void pointer.    */

/* -------------------------------------------------------------------------- */

static void

eth_controller_tx_clock (void *dat)

{

  struct eth_device *eth = dat;

  /* Only do anything if there is not an interrupt outstanding. */

  if (!eth->int_line_stat)

    {

      /* First word of BD is flags. If we have a buffer ready, get it and

         transmit it. */

      if (TEST_FLAG (eth->regs.bd_ram[eth->tx_bd_index], ETH_TX_BD, READY))

        {

          eth_flush_bd (eth);

        }

    }

  /* Wake up again after 1 ticks (was 10, changed by Julius). */

  SCHED_ADD (eth_controller_tx_clock, dat, RTX_RESCHED_PERIOD);

}       /* eth_controller_tx_clock () */

/* -------------------------------------------------------------------------- */

/*!Read an Ethernet packet from a FILE interface.

   This reads a single Ethernet packet from the outside world via a FILE

   interface.

   The format is 4 bytes of packet length, followed by the packet data.

   @param[in]  eth  Pointer to the relevant Ethernet data structure

   @param[out] buf  Where to put the data

   @return  The length if successful, zero if no packet was available

            (i.e. EOF), a negative value otherwise.                           */

/* -------------------------------------------------------------------------- */

static ssize_t

eth_read_file_packet (struct eth_device *eth,

                      unsigned char     *buf)

{

  ssize_t  packet_length;

  ssize_t  nread;

  /* Read packet length. We may be at EOF. */

  nread = read (eth->rxfd, &(packet_length), sizeof (packet_length));

  if (0 == nread)

    {

      return  0;                 /* No more packets */

    }

  else if (nread < sizeof (packet_length))

    {

      fprintf (stderr, "ERROR: Failed to read length from file.\n");

      return  -1;

    }

  /* Packet must be big enough to hold a header */

  if (packet_length < ETHER_HDR_LEN)

    {

      fprintf (stderr, "Warning: Ethernet packet length %zd too small.\n",

               packet_length);

      return  -1;

    }

  /* Read the packet proper. */

  nread = read (eth->rxfd, buf, packet_length);

  if (nread != packet_length)

    {

      fprintf (stderr, "ERROR: Failed to read packet from file.\n");

      return  -1;

    }

  return  packet_length;

}       /* eth_read_file_packet () */

/* -------------------------------------------------------------------------- */

/*!Read an Ethernet packet from a FILE interface.

   This reads a single Ethernet packet from the outside world via a TAP

   interface.

   A complete packet is always read, so its length (minus CRC) is the amount

   read.

   @param[in]  eth  Pointer to the relevant Ethernet data structure

   @param[out] buf  Where to put the data

   @return  The length if successful, zero if no packet was available,

            a negative value otherwise.                                       */

/* -------------------------------------------------------------------------- */

static ssize_t

eth_read_tap_packet (struct eth_device *eth,

                     unsigned char     *buf)

{

  struct pollfd  fds[1];

  int            n;

  ssize_t        packet_length;

  /* Poll to see if there is data to read */

  fds[0].fd     = eth->rtx_fd;

  fds[0].events = POLLIN;

  n = poll (fds, 1, 0);

  if (n < 0)

    {

      fprintf (stderr, "Warning: Poll for TAP receive failed %s: ignored.\n",

               strerror (errno));

      return  -1;

    }

  else if ((n > 0) && ((fds[0].revents & POLLIN) == POLLIN))

    {

      /* Data to be read from TAP */

      packet_length = read (eth->rtx_fd, buf, ETH_MAXPL);

#if ETH_DEBUG

      printf ("%d bytes read from TAP.\n", (int) packet_length);

#endif

      if (packet_length < 0)

        {

          fprintf (stderr, "Warning: Read of RXTATE_RECV failed: %s.\n",

                   strerror (errno));

          SET_FLAG (eth->regs.int_source, ETH_INT_SOURCE, RXE);

          /* Signal interrupt if enabled, and no interrupt currently in

             progress. */

          if (TEST_FLAG (eth->regs.int_mask, ETH_INT_MASK, RXE_M) &&

              !eth->int_line_stat)

            {

#if ETH_DEBUG

              printf ("Ethernet failed receive interrupt\n");

#endif

              report_interrupt (eth->mac_int);

              eth->int_line_stat = 1;

            }

        }

      return  packet_length;

    }

  else

    {

      return  0;                 /* No packet */

    }

}       /* eth_read_tap_packet () */

/* -------------------------------------------------------------------------- */

/*!Read an Ethernet packet.

   This reads a single Ethernet packet from the outside world into the

   supplied buffer. It deals with the different types of external interface.

   @param[in]  eth  Pointer to the relevant Ethernet data structure

   @param[out] buf  Where to put the data

   @return  The length if successful, zero if no packet was available,

            a negative value otherwise.                                       */

/* -------------------------------------------------------------------------- */

static ssize_t

eth_read_packet (struct eth_device *eth,

                 unsigned char     *buf)

{

  switch (eth->rtx_type)

    {

    case ETH_RTX_FILE: return  eth_read_file_packet (eth, buf);

    case ETH_RTX_TAP:  return  eth_read_tap_packet (eth, buf);

    default:

      fprintf (stderr, "Unknown Ethernet read interface: ignored.\n");

      return  (ssize_t) -1;

    }

}       /* eth_read_packet () */

/* -------------------------------------------------------------------------- */

/*!Fill a buffer descriptor

   A buffer descriptor is empty. Attempt to fill it from the outside world.

   @param[in] eth  The Ethernet data structure, passed as a void pointer.    */

/* -------------------------------------------------------------------------- */

static void

eth_fill_bd (struct eth_device *eth)

{

  /* First word of BD is flags and length, second is pointer to buffer */

  unsigned long int  bd_info = eth->regs.bd_ram[eth->rx_bd_index];

  unsigned long int  bd_addr = eth->regs.bd_ram[eth->rx_bd_index + 1];

  long int           packet_length;

  long int           bytes_read;

  unsigned char      buf[ETH_MAXPL];

  /* Clear various status bits */

  CLEAR_FLAG (bd_info, ETH_RX_BD, MISS);

  CLEAR_FLAG (bd_info, ETH_RX_BD, INVALID);

  CLEAR_FLAG (bd_info, ETH_RX_BD, DRIBBLE);

  CLEAR_FLAG (bd_info, ETH_RX_BD, UVERRUN);

  CLEAR_FLAG (bd_info, ETH_RX_BD, COLLISION);

  CLEAR_FLAG (bd_info, ETH_RX_BD, TOOBIG);

  CLEAR_FLAG (bd_info, ETH_RX_BD, TOOSHORT);

  /* Loopback is permitted. We believe that Linux never uses it, so we'll

     note the attempt and ignore.

     @todo We should support this. */

  if (TEST_FLAG (eth->regs.moder, ETH_MODER, LOOPBCK))

    {

      PRINTF ("Ethernet loopback requested.\n");

      fprintf (stderr, "ERROR: Loopback not supported. Ignored.\n");

    }

  packet_length = eth_read_packet (eth, buf);

  if (packet_length <= 0)

    {

      /* Empty packet or error. No more to do here. */

      return;

    }

/* Got a packet successfully. If not promiscuous mode, check the destination

   address is meant for us. */

  if (!TEST_FLAG (eth->regs.moder, ETH_MODER, PRO))

    {

      if (TEST_FLAG (eth->regs.moder, ETH_MODER, IAM))

        {

          /* There is little documentation of how IAM is supposed to work. It

             seems that some mapping function (not defined) maps the address

             down to a number in the range 0-63. If that bit is set in

             HASH0/HASH1 registers, the packet is accepted. */

          fprintf (stderr, "Warning: Individual Address Mode ignored.\n");

        }

      /* Check for HW address match. */

      if ((0 != bcmp (eth->mac_address, buf, ETHER_ADDR_LEN)) &&

          (0 != bcmp (mac_broadcast,    buf, ETHER_ADDR_LEN)))

        {

#if ETH_DEBUG           

          printf ("packet for %.2x:%.2x:%.2x:%.2x:%.2x:%.2x ignored.\n",

                  buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);

#endif

          /* Not for us. No more to do here. */

          return;

        }

    }

  /* Transfer the buffer into the BD. */

#if ETH_DEBUG

  printf ("writing to Rx BD%d: %d bytes @ 0x%.8x\n",

          (int) eth->rx_bd_index / 2,  (int) packet_length,

          (unsigned int)bd_addr);

#endif

  for (bytes_read = 0; bytes_read < packet_length; bytes_read +=4)

    {

      unsigned long int  send_word =

        ((unsigned long) buf[bytes_read]     << 24) |

        ((unsigned long) buf[bytes_read + 1] << 16) |

        ((unsigned long) buf[bytes_read + 2] <<  8) |

        ((unsigned long) buf[bytes_read + 3]      );

      set_direct32 (bd_addr + bytes_read, send_word, 0, 0);

    }

#if ETH_DEBUG

  printf("BD filled with 0x%08lx bytes.\n", bytes_read);

#endif

  /* Write result to BD.

     The OpenRISC MAC hardware passes on the CRC (which it should not). The

     Linux drivers have been written to expect a value (which they ignore). So

     for consistency, we pretend the length is 4 bytes longer.

     This is now controlled by a configuration parameter, dummy_crc. For

     backwards compatibility, it defaults to TRUE. */

  SET_FIELD (bd_info, ETH_RX_BD, LENGTH,

             packet_length + (eth->dummy_crc ? 4 : 0));

  CLEAR_FLAG (bd_info, ETH_RX_BD, READY);

  SET_FLAG (eth->regs.int_source, ETH_INT_SOURCE, RXB);

  eth->regs.bd_ram[eth->rx_bd_index] = bd_info;

  /* Advance to next BD. The Rx BDs start after the Tx BDs. */

  if (TEST_FLAG (bd_info, ETH_RX_BD, WRAP) ||

      (eth->rx_bd_index >= ETH_BD_COUNT))

    {

      eth->rx_bd_index = eth->regs.tx_bd_num * 2;

    }

  else

    {

      eth->rx_bd_index += 2;

    }

  /* Raise an interrupt if necessary. */

  if (TEST_FLAG (eth->regs.int_mask, ETH_INT_MASK, RXB_M) &&