ethernetif.c File Reference

---

Detailed Description

Ethernet Interface Skeleton.

Definition in file ethernetif.c.

#include "lwip/opt.h"
#include "lwip/def.h"
#include "lwip/mem.h"
#include "lwip/pbuf.h"
#include "lwip/sys.h"
#include <lwip/stats.h>
#include <lwip/snmp.h>
#include "netif/etharp.h"
#include "netif/ppp_oe.h"
#include "conf_eth.h"
#include "macb.h"

Go to the source code of this file.

Data Structures
struct	ethernetif
	Helper struct to hold private data used to operate your ethernet interface. More...
Defines
#define	IFNAME0   'e'
#define	IFNAME1   'n'
#define	netifGUARD_BLOCK_NBTICKS   ( 250 )
Functions
err_t	ethernetif_init (struct netif *netif)
	Should be called at the beginning of the program to set up the network interface.
static void	ethernetif_input (void *pvParameters)
	This function should be called when a packet is ready to be read from the interface.
static void	low_level_init (struct netif *netif)
	In this function, the hardware should be initialized.
static struct pbuf *	low_level_input (struct netif *netif)
	Should allocate a pbuf and transfer the bytes of the incoming packet from the interface into the pbuf.
static err_t	low_level_output (struct netif *netif, struct pbuf *p)
	This function should do the actual transmission of the packet.

---

Define Documentation

#define IFNAME0   'e'

Definition at line 62 of file ethernetif.c.

Referenced by ethernetif_init().

#define IFNAME1   'n'

Definition at line 63 of file ethernetif.c.

Referenced by ethernetif_init().

#define netifGUARD_BLOCK_NBTICKS   ( 250 )

Definition at line 65 of file ethernetif.c.

Referenced by low_level_input(), and low_level_output().

---

Function Documentation

err_t ethernetif_init

(

struct netif *

netif

)

Should be called at the beginning of the program to set up the network interface.

It calls the function low_level_init() to do the actual setup of the hardware.

This function should be passed as a parameter to netif_add().

Parameters:

netif

the lwip network interface structure for this ethernetif

Returns:

ERR_OK if the loopif is initialized ERR_MEM if private data couldn't be allocated any other err_t on error

Definition at line 334 of file ethernetif.c.

References IFNAME0, IFNAME1, low_level_init(), and low_level_output().

Referenced by prvEthernetConfigureInterface().

{
  /* struct ethernetif *ethernetif; */

  LWIP_ASSERT("netif != NULL", (netif != NULL));
    
  /*ethernetif = (struct ethernetif *)mem_malloc(sizeof(struct ethernetif));
  if (ethernetif == NULL)
  {
    LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
    return ERR_MEM;
  }*/

#if LWIP_NETIF_HOSTNAME
  /* Initialize interface hostname */
  netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */

  /*
   * Initialize the snmp variables and counters inside the struct netif.
   * The last argument should be replaced with your link speed, in units
   * of bits per second.
   */
#if LWIP_SNMP
  NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 100000000);
#endif /* LWIP_SNMP */

  netif->state = NULL; /* ethernetif;
  ethernetif->ethaddr = (struct eth_addr *)&(netif->hwaddr[0]); */
  netif->name[0] = IFNAME0;
  netif->name[1] = IFNAME1;
  /* We directly use etharp_output() here to save a function call.
   * You can instead declare your own function an call etharp_output()
   * from it if you have to do some checks before sending (e.g. if link
   * is available...) */
  netif->output = etharp_output;
  netif->linkoutput = low_level_output;

  /* initialize the hardware */
  low_level_init(netif);

/* DONE BY THE LWIP TASK.
  // Initializes the ARP table and queue.
  etharp_init();

  // You must call etharp_tmr at a ARP_TMR_INTERVAL (5 seconds) regular interval
  // after this initialization.
  sys_timeout(ARP_TMR_INTERVAL, (sys_timeout_handler)arp_timer, NULL);
*/
  return ERR_OK;
}

static void ethernetif_input

(

void *

pvParameters

)

[static]

This function should be called when a packet is ready to be read from the interface.

It uses the function low_level_input() that should handle the actual reception of bytes from the network interface. Then the type of the received packet is determined and the appropriate input function is called.

Parameters:

netif

the lwip network interface structure for this ethernetif

Definition at line 280 of file ethernetif.c.

References low_level_input().

Referenced by low_level_init().

{
  struct netif      *netif = (struct netif *)pvParameters;
  struct pbuf       *p;


  for( ;; )
  {
    do
    {
      /* move received packet into a new pbuf */
      p = low_level_input( netif );
      if( p == NULL )
      {
        /* No packet could be read.  Wait a for an interrupt to tell us
        there is more data available. */
        vMACBWaitForInput(100);
      }
    }while( p == NULL );

    if( ERR_OK != ethernet_input( p, netif ) )
    {
      pbuf_free(p);
      p = NULL;
    }
  }
}

static void low_level_init

(

struct netif *

netif

)

[static]

In this function, the hardware should be initialized.

Called from ethernetif_init().

Parameters:

netif

the already initialized lwip network interface structure for this ethernetif

Definition at line 89 of file ethernetif.c.

References ETHERNET_CONF_ETHADDR0, ETHERNET_CONF_ETHADDR1, ETHERNET_CONF_ETHADDR2, ETHERNET_CONF_ETHADDR3, ETHERNET_CONF_ETHADDR4, ETHERNET_CONF_ETHADDR5, ethernetif_input(), netifINTERFACE_TASK_PRIORITY, netifINTERFACE_TASK_STACK_SIZE, and sys_thread_new().

Referenced by ethernetif_init().

{
  unsigned portBASE_TYPE uxPriority;


  /* set MAC hardware address length */
  netif->hwaddr_len = ETHARP_HWADDR_LEN;

  /* set MAC hardware address */
  netif->hwaddr[0] = ETHERNET_CONF_ETHADDR0;
  netif->hwaddr[1] = ETHERNET_CONF_ETHADDR1;
  netif->hwaddr[2] = ETHERNET_CONF_ETHADDR2;
  netif->hwaddr[3] = ETHERNET_CONF_ETHADDR3;
  netif->hwaddr[4] = ETHERNET_CONF_ETHADDR4;
  netif->hwaddr[5] = ETHERNET_CONF_ETHADDR5;

  /* maximum transfer unit */
  netif->mtu = 1500;
  
  /* device capabilities */
  /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
  netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
 
  /* Do whatever else is needed to initialize interface. */  
  /* Initialise the MACB. */
  // NOTE: This routine contains code that polls status bits. If the Ethernet
  // cable is not plugged in then this can take a considerable time.  To prevent
  // this from starving lower priority tasks of processing time we lower our
  // priority prior to the call, then raise it back again once the initialization
  // is complete.
  // Read the priority of the current task.
  uxPriority = uxTaskPriorityGet( NULL );
  // Set the priority of the current task to the lowest possible.
  vTaskPrioritySet( NULL, tskIDLE_PRIORITY );
  // Init the MACB interface.
  while( xMACBInit(&AVR32_MACB) == FALSE )
  {
    __asm__ __volatile__ ( "nop" );
  }
  // Restore the priority of the current task.
  vTaskPrioritySet( NULL, uxPriority );

  /* Create the task that handles the MACB input packets. */
  sys_thread_new( "ETHINT", ethernetif_input, netif, netifINTERFACE_TASK_STACK_SIZE,
                  netifINTERFACE_TASK_PRIORITY );
}

static struct pbuf* low_level_input

(

struct netif *

netif

)

[static, read]

Should allocate a pbuf and transfer the bytes of the incoming packet from the interface into the pbuf.

Parameters:

netif

the lwip network interface structure for this ethernetif

Returns:

a pbuf filled with the received packet (including MAC header) NULL on memory error

Definition at line 205 of file ethernetif.c.

References netifGUARD_BLOCK_NBTICKS.

Referenced by ethernetif_input().

{
  struct pbuf             *p = NULL;
  struct pbuf             *q;
  u16_t                   len;
  static xSemaphoreHandle xRxSemaphore = NULL;


  /* Parameter not used. */
  ( void ) netif;

  if( xRxSemaphore == NULL )
  {
    vSemaphoreCreateBinary( xRxSemaphore );
  }

  /* Access to the MACB is guarded using a semaphore. */
  if( xSemaphoreTake( xRxSemaphore, netifGUARD_BLOCK_NBTICKS ) )
  {
    /* Obtain the size of the packet. */
    len = ulMACBInputLength();

    if( len )
    {
#if ETH_PAD_SIZE
      len += ETH_PAD_SIZE;    /* allow room for Ethernet padding */
#endif

      /* We allocate a pbuf chain of pbufs from the pool. */
      p = pbuf_alloc( PBUF_RAW, len, PBUF_POOL );

      if( p != NULL )
      {
#if ETH_PAD_SIZE
        pbuf_header( p, -ETH_PAD_SIZE );    /* drop the padding word */
#endif

        /* Let the driver know we are going to read a new packet. */
        vMACBRead( NULL, 0, len );

        /* We iterate over the pbuf chain until we have read the entire
        packet into the pbuf. */
        for( q = p; q != NULL; q = q->next )
        {
          /* Read enough bytes to fill this pbuf in the chain. The
          available data in the pbuf is given by the q->len variable. */
          vMACBRead( q->payload, q->len, len );
        }

#if ETH_PAD_SIZE
        pbuf_header( p, ETH_PAD_SIZE );     /* reclaim the padding word */
#endif
        LINK_STATS_INC(link.recv);
      }
      else
      {
        LINK_STATS_INC(link.memerr);
        LINK_STATS_INC(link.drop);
      }
    }
    xSemaphoreGive( xRxSemaphore );
  }

  return p;
}

static err_t low_level_output	(	struct netif *	netif,
		struct pbuf *	p
	)			[static]

This function should do the actual transmission of the packet.

The packet is contained in the pbuf that is passed to the function. This pbuf might be chained.

Parameters:

	netif	the lwip network interface structure for this ethernetif
	p	the MAC packet to send (e.g. IP packet including MAC addresses and type)

Returns:

ERR_OK if the packet could be sent an err_t value if the packet couldn't be sent

Note:

Returning ERR_MEM here if a DMA queue of your MAC is full can lead to strange results. You might consider waiting for space in the DMA queue to become available since the stack doesn't retry to send a packet dropped because of memory failure (except for the TCP timers).

Definition at line 153 of file ethernetif.c.

References netifGUARD_BLOCK_NBTICKS.

Referenced by ethernetif_init().

{
  struct pbuf             *q;
  static xSemaphoreHandle xTxSemaphore = NULL;
  err_t                   xReturn = ERR_OK;


  ( void )netif; // Unused param, avoid a compiler warning.

  if( xTxSemaphore == NULL )
  {
    vSemaphoreCreateBinary( xTxSemaphore );
  }

#if ETH_PAD_SIZE
  pbuf_header( p, -ETH_PAD_SIZE );    /* drop the padding word */
#endif

  /* Access to the MACB is guarded using a semaphore. */
  if( xSemaphoreTake( xTxSemaphore, netifGUARD_BLOCK_NBTICKS ) )
  {
    for( q = p; q != NULL; q = q->next )
    {
      /* Send the data from the pbuf to the interface, one pbuf at a
      time. The size of the data in each pbuf is kept in the ->len
      variable.  if q->next == NULL then this is the last pbuf in the
      chain. */
      if( !lMACBSend(&AVR32_MACB, q->payload, q->len, ( q->next == NULL ) ) )
      {
        xReturn = ~ERR_OK;
      }
    }
    xSemaphoreGive( xTxSemaphore );
  }

#if ETH_PAD_SIZE
  pbuf_header( p, ETH_PAD_SIZE );     /* reclaim the padding word */
#endif

  LINK_STATS_INC(link.xmit);  // Traces

  return ERR_OK;
}