Subversion Repositories openrisc

//==========================================================================

//

//      dev/if_MCF5272_fec.c

//

//      Ethernet device driver for MCF5272's Fast Ethernet Controller (FEC)

//

//==========================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

//

// eCos 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 2 or (at your option) any later version.

//

// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

// -------------------------------------------

//####ECOSGPLCOPYRIGHTEND####

//==========================================================================

// Ethernet device driver for Fast Ethernet MCF5272_fec

#include <pkgconf/io_eth_drivers.h>

#include <cyg/hal/drv_api.h>

#include <cyg/io/eth/netdev.h>

#include <cyg/io/eth/eth_drv.h>

#include <cyg/devs/eth/nbuf.h>

#include <cyg/devs/eth/if_mcf5272.h>

#include <cyg/devs/eth/if_mcf5272_private_data.h>

#include <cyg/infra/cyg_ass.h>

#include <sys/param.h>

#include <net/if.h>

/* Function to retrieve the Ethernet address of the device from the device's

   database. We declare it weak so that other routines can overide it.

   */

externC const void*

db_get_eth_address(void) __attribute__ ((weak));

/*****************************************************************************

     The following  functions  provide  an  interface  directly  to  the

ethernet driver for applications that wish to circumvent the IP stack.

     Applications that wish  to take advantage  of this should  override

these routine with their own.  Leaving these routines as default  routes

all data through the IP stack.

*****************************************************************************/

externC int_t

eth_rx_pkt_filter(u8_t* pkt, uint_t pkt_len) __attribute__ ((weak));

externC void

eth_tx_check(struct eth_drv_sg * sg_list, unsigned int sg_len)

             __attribute__ ((weak));

externC void

eth_send_done(unsigned long tag) __attribute__ ((weak));

externC int_t

eth_send(struct eth_drv_sg * sg_list, unsigned int sg_len, int total_len,

         unsigned long tag);

static MCF5272_fec_priv_data_t MCF5272_fec_priv_data;

/* Interrupt strcture and handles. */

static cyg_interrupt MCF5272_fec_rx_interrupt;

static cyg_interrupt MCF5272_fec_tx_interrupt;

static cyg_handle_t MCF5272_fec_rx_interrupt_handle;

static cyg_handle_t MCF5272_fec_tx_interrupt_handle;

// Interrupt handler

static void MCF5272_fec_int(struct eth_drv_sc *sc);

static int MCF5272_fec_int_vector(struct eth_drv_sc *sc);

// This DSR handles the ethernet [logical] processing

static void MCF5272_fec_deliver(struct eth_drv_sc * sc);

static void MCF5272_fec_stop(struct eth_drv_sc *sc);

static void

MCF5272_fec_send(struct eth_drv_sc *sc, struct eth_drv_sg *sg_list, int sg_len,

            int total_len, unsigned long key);

static void

MCF5272_fec_common_send(struct eth_drv_sc *sc,

                        struct eth_drv_sg *sg_list, int sg_len,

                        int total_len,

                        unsigned long key,

                        tx_key_type_t key_type);

static int

MCF5272_fec_isr(cyg_vector_t vector, cyg_addrword_t data,

                HAL_SavedRegisters *regs);

// One-second call back alarm

static void one_second_alarm_func(cyg_handle_t alarm, cyg_addrword_t data);

// Retrieve statistics

static void MCF5272_get_stats(struct eth_drv_sc *sc, MCF5272_FEC_DIAG* stats);

ETH_DRV_SC(MCF5272_fec_sc,

           &MCF5272_fec_priv_data, // Driver specific data

           "eth0",             // Name for this interface

           MCF5272_fec_start,

           MCF5272_fec_stop,

           MCF5272_fec_control,

           MCF5272_fec_can_send,

           MCF5272_fec_send,

           MCF5272_fec_recv,

           MCF5272_fec_deliver,

           MCF5272_fec_int,

           MCF5272_fec_int_vector);

/* Device name */

static const char ether_device_name[] =  "MCF5272-eth";

NETDEVTAB_ENTRY(MCF5272_fec_netdev,

                ether_device_name,

                MCF5272_fec_init,

                &MCF5272_fec_sc);

/*******************************************************************************

    db_get_eth_address() - Returns the default Ethernet address.

*/

const void* db_get_eth_address(void)

{

    /*   Just use an obviously invalid address until someone overrides this */

    /* routine to provide their own address.                                */

    static const unsigned char enaddr[] =

    {

        0x00, 0x11, 0x22, 0x33, 0x44, 0x55

    };

    return  (const void*)enaddr;

}

/*******************************************************************************

 MCF5272_fec_init() - Routine that initializes the FEC.

 INPUT:

    tab - Pointer to the network device table.

 */

static bool MCF5272_fec_init(struct cyg_netdevtab_entry *tab)

{

    struct eth_drv_sc *sc = (struct eth_drv_sc *)tab->device_instance;

    const u8_t *enaddr;

    /*   Indicate that the ethernet driver is down.                         */

    PMCF5272_FEC_DATA(sc)->operational = ETH_DEV_DOWN;

    /*   Initialize the entire driver private area to zero.                 */

    memset((char*)sc->driver_private, sizeof(MCF5272_fec_priv_data_t), 0);

    /*   Initialize the buffers structure.  This strucre contains  transmit */

    /* and receive buffer descriptor managment information.                 */

    nbuf_init(PBUF_INFO(sc));

    /*   Start a alarm that  will trigger  every second.   This alarm  will */

    /* periodically update the recevie and transmit statistics.             */

    cyg_clock_to_counter(cyg_real_time_clock(),

                         &(((MCF5272_fec_priv_data_t*)sc->driver_private)->counter_h));

    cyg_alarm_create(((MCF5272_fec_priv_data_t*)sc->driver_private)->counter_h,

                      one_second_alarm_func,

                     (cyg_addrword_t)(MCF5272_fec_priv_data_t*)sc->driver_private,

                      &(((MCF5272_fec_priv_data_t*)sc->driver_private)->alarm_h),

                      &(((MCF5272_fec_priv_data_t*)sc->driver_private)->alarm));

    cyg_alarm_initialize(((MCF5272_fec_priv_data_t*)sc->driver_private)->alarm_h,

                         cyg_current_time()+

                         (1*SEC_IN_NS)/CYGNUM_KERNEL_COUNTERS_RTC_PERIOD,

                         (1*SEC_IN_NS)/CYGNUM_KERNEL_COUNTERS_RTC_PERIOD);

    /*   Initialize environment, setup  receive, transmit and  non-critical */

    /* interrupt handlers.                                                  */

    cyg_drv_interrupt_create(CYGNUM_HAL_VECTOR_ERX,

                             MCF5272_INT_LEVEL, // Priority

                             (cyg_addrword_t)sc, //  Data item passed to interrupt handler

                             (cyg_ISR_t *)MCF5272_fec_isr,

                             (cyg_DSR_t *)eth_drv_dsr,

                             &MCF5272_fec_rx_interrupt_handle,

                             &MCF5272_fec_rx_interrupt);

    cyg_drv_interrupt_create(CYGNUM_HAL_VECTOR_ETX,

                             MCF5272_INT_LEVEL, // Priority

                             (cyg_addrword_t)sc, //  Data item passed to interrupt handler

                             (cyg_ISR_t *)MCF5272_fec_isr,

                             (cyg_DSR_t *)eth_drv_dsr,

                             &MCF5272_fec_tx_interrupt_handle,

                             &MCF5272_fec_tx_interrupt);

    /*   Attach interrupt here in order  to start receiving interrupt  from */

    /* the FEC.                                                             */

    cyg_drv_interrupt_attach(MCF5272_fec_rx_interrupt_handle);

    cyg_drv_interrupt_attach(MCF5272_fec_tx_interrupt_handle);

    put_reg(MCF5272_SIM->gpio.pbcnt, 0x55550000 |

            (get_reg(MCF5272_SIM->gpio.pbcnt) & 0x0000FFFF));

    /*   Reset the FEC - equivalent to a hard reset.                        */

    put_reg(MCF5272_SIM->enet.ecr, MCF5272_FEC_ECR_RESET);

    /*   Wait for the reset sequence to complete.                           */

    while(get_reg(MCF5272_SIM->enet.ecr) & MCF5272_FEC_ECR_RESET);

    /*   Set the Ethernet control register to zero to disable the FEC.      */

    put_reg(MCF5272_SIM->enet.ecr, 0);

    /*   Set the source address for the controller.                         */

    /*   Initialize  physical  address  register  by  copying  our  adapter */

    /* address from the device's permanent storage.                         */

    enaddr = (cyg_uint8*)db_get_eth_address();

    put_reg(MCF5272_SIM->enet.malr,0

                                       | (enaddr[0] <<24)

                                       | (enaddr[1] <<16)

                                       | (enaddr[2] <<8)

                                       | (enaddr[3] <<0));

    put_reg(MCF5272_SIM->enet.maur,0

                                       | (enaddr[4] <<24)

                                       | (enaddr[5] <<16));

    /*   Initialize the hash  table registers  to ignore  hash checking  to */

    /* detect multicast Etherhet addresses.                                 */

    put_reg(MCF5272_SIM->enet.htur, 0);

    put_reg(MCF5272_SIM->enet.htlr, 0);

    /*   Set Receive Buffer Size.   This  is  the  size  for  each  receive */

    /* buffer.                                                              */

    put_reg(MCF5272_SIM->enet.emrbr, (uint16)RX_BUFFER_SIZE);

    /*   Point to the start of the circular Rx buffer descriptor queue.     */

    put_reg(MCF5272_SIM->enet.erdsr, nbuf_get_start(PBUF_INFO(sc), Rx));

    /*   Point to the start of the circular Tx buffer descriptor queue.     */

    put_reg(MCF5272_SIM->enet.etdsr, nbuf_get_start(PBUF_INFO(sc), Tx));

    /*   Set  the  FIFO  transmit  highwater  mark  to  128  bytes.   Frame */

    /* transmission begins when the number of bytes selected by this  field */

    /* are written into the  transmit FIFO,  if an  end of  frame has  been */

    /* written to the FIFIO, or if the FIFO is full before selected  number */

    /* of bytes are written.                                                */

    put_reg(MCF5272_SIM->enet.tfwr, MCF5272_FEC_XWMRK_128);

    /*   Clear any interrupts by setting all bits in the EIR register.      */

    put_reg(MCF5272_SIM->enet.eir, 0xFFFFFFFF);

    /*   Set the tranceiver interface to MII mode.                          */

    put_reg(MCF5272_SIM->enet.rcr, 0 | MCF5272_FEC_RCR_MII_MODE);

                                   // | MCF5272_FEC_RCR_DRT);

    /*   Set the mode is ETH_MODE_SIMPLEX.   We are assuming the device  is */

    /* half-duplex mode.                                                    */

    PMCF5272_FEC_DATA(sc)->duplex = ETH_MODE_SIMPLEX;

    /* The default speed is 10 Mbs. */

    PMCF5272_FEC_DATA(sc)->speed = ETH_SPEED_10MB;

    /*   Write the maximum  frame  length  and  setup  so  we  can  receive */

    /* broadcast packets.                                                   */

    put_reg(MCF5272_SIM->enet.mflr, MCF5272_FEC_MFLR_BRDCAST |

            sizeof(eth_frame_hdr));

    /*   Check for heartbeat count  and enable  full-duplex transmit.   The */

    /* hearbeat check is performed following end of transmission and the HB */

    /* bit in the status  reguster is set if  the collision input does  not */

    /* assert within the heartbeat window.                                  */

    /*   NOTE: We disable full  duplex mode  because we  notice that  we're */

    /* getting Receive CRC erors.                                           */

    put_reg(MCF5272_SIM->enet.tcr, 0 |MCF5272_FEC_TCR_HBC);

                                   //| MCF5272_FEC_TCR_FDEN);

    /*   Set  the  MII  frequency  divider.   The  MII_SPEED  controls  the */

    /* frequency of the MII management  interface  clock  relative  to  the */

    /* system clock.  We set MII  speed  to  7  because  the  system  clock */

    /* frequency is 66 Mhz.                                                 */

    put_reg(MCF5272_SIM->enet.mscr, 7<<1);

    /*   Initialize upper level driver.                                     */

    (sc->funs->eth_drv->init)(sc, (unsigned char *)enaddr);

    /*   Return  true  to  indicate  that  the  driver  initialization  has */

    /* completed successfully.                                              */

    return true;

}

/*      This function is called to  "start up"  the interface.   It may  be */

/* called multiple times, even  when the hardware  is already running.   It */

/* will be called whenever something "hardware oriented" changes and should */

/* leave the hardware ready to send/receive packets.                        */

static void

MCF5272_fec_start(struct eth_drv_sc *sc, cyg_uint8 *enaddr, int flags)

{

    /*   Initialize the buffers structure.  This strucre contains  transmit */

    /* and receive buffer descriptor managment information.  We  initialize */

    /* again here becuase we don't  know the internal  state of the  buffer */

    /* descriptor pointer in the FEC if the FEC was disabled after  calling */

    /* MCF5272_fec_stop.                                                    */

    if (PMCF5272_FEC_DATA(sc)->operational != ETH_DEV_UP)

    {

        nbuf_init(PBUF_INFO(sc));

    }

    /*   Unmask the Transmit and Receive  frame  interrupt  to  handle  the */

    /* interrupts.                                                          */

    /*   Unmask the Internal Bus  Errorso we  can detect  any internal  bus */

    /* error when the FEC tries to acess the internal bus.                  */

    put_reg(MCF5272_SIM->enet.eimr,

            get_reg(MCF5272_SIM->enet.eimr) | MCF5272_FEC_INTERRUPT_MASK);

    /*   Enable FEC.                                                        */

    put_reg(MCF5272_SIM->enet.ecr, MCF5272_FEC_ECR_ETHER_EN);

    /*   Indicate that there have been empty receive buffers produced.      */

    put_reg(MCF5272_SIM->enet.rdar, MCF5272_FEC_RDAR_DESTACT);

    /*   Set the flag to indicate that the device is up and running.        */

    PMCF5272_FEC_DATA(sc)->operational = ETH_DEV_UP;

}

/*      A routine to halt the FEC.                                          */

static void

MCF5272_fec_stop(struct eth_drv_sc *sc)

{

    /*   Stop the packet transmission gracefully.                           */

    /*   Set the Graceful Transmit Stop bit.                                */

    put_reg(MCF5272_SIM->enet.tcr, get_reg(MCF5272_SIM->enet.tcr)

                                   | MCF5272_FEC_TCR_GTS);

    /*   Wait for the current transmission to complete.                     */

    while( !(get_reg(MCF5272_SIM->enet.eir) & MCF5272_FEC_EIR_GRA));

    /*   Clear the GRA event.                                               */

    put_reg(MCF5272_SIM->enet.eir, MCF5272_FEC_EIR_GRA);

    /*   Disable all FEC interrupts by clearing the IMR register.           */

    put_reg(MCF5272_SIM->enet.eimr,  0);

    /*   Clear the GTS bit so frames can be tranmitted when restarted       */

    put_reg(MCF5272_SIM->enet.tcr, get_reg(MCF5272_SIM->enet.tcr) &

                                   ~MCF5272_FEC_TCR_GTS);

    /*   Set the Ethernet control register to zero to disable the FEC.      */

    put_reg(MCF5272_SIM->enet.ecr, 0);

    /*   Deliver any pending frames and acknowledge any transmitted frames.   */

    MCF5272_fec_deliver(sc);

    /*   Set the flag to indicate that the device is down.                  */

    PMCF5272_FEC_DATA(sc)->operational = ETH_DEV_DOWN;

}

/*      This routine is called to perform special "control" opertions.       */

static int

MCF5272_fec_control(struct eth_drv_sc *sc, unsigned long key,

                    void *data, int data_length)

{

    switch (key)

    {

    case ETH_DRV_SET_MAC_ADDRESS:

        {

            /*   Set the hardware address of the Ethernet controller.       */

            struct ifreq* p_ifreq = data;

            /*   If the length of the strcutre is not equal to the size  of */

            /* ifreq, then exit with an error.                              */

            if (data_length != sizeof(*p_ifreq))

            {

                return 0;

            }

            /*   Set the lower 4-byte address.                              */

            put_reg(MCF5272_SIM->enet.malr,0

                                               | (p_ifreq->ifr_ifru.ifru_hwaddr.sa_data[0] <<24)

                                               | (p_ifreq->ifr_ifru.ifru_hwaddr.sa_data[1] <<16)

                                               | (p_ifreq->ifr_ifru.ifru_hwaddr.sa_data[2] <<8)

                                               | (p_ifreq->ifr_ifru.ifru_hwaddr.sa_data[3] <<0));

            /*   Set the upper 2-byte address.                              */

            put_reg(MCF5272_SIM->enet.maur,

                                               | (p_ifreq->ifr_ifru.ifru_hwaddr.sa_data[4] <<24)

                                               | (p_ifreq->ifr_ifru.ifru_hwaddr.sa_data[5] <<16));

            /*   Return 1 to indicate  that  programming  of  the  new  MAC */

            /* address is successful.                                       */

            return 1;

        }

        break;

    #ifdef CYGPKG_NET

    case ETH_DRV_GET_IF_STATS:

    case ETH_DRV_GET_IF_STATS_UD:

        #if 0

        {

            struct ether_drv_stats* pstats = (struct ether_drv_stats*)

                                                data;

            MCF5272_FEC_DIAG diag;

            /* Retrieve the driver defined diagnostic structure. */

            MCF5272_get_stats(sc, &diag);

            strcpy(pstats->description, ether_device_name);

            pstats->duplex = ETH_MODE_UNKNWON;

            pstats->operational = (unsigned char )PMCF5272_FEC_DATA(sc)->operational;

            pstats->speed = 0;

            /*   Translate the device specific  diagnostic  values  to  the */

            /* generic ether_drv_stats values.                              */

            /* Get the receive bytes count. */

            pstats->rx_count = diag.rx_bytes_cnt;

            /* Get the number of successful packet received. */

            pstats->rx_good = diag.rx_pk_cnt;

            /* Get the receive CRC error count. */

            pstats->rx_crc_errors = diag.rx_crc_err_cnt;

            /* Get the receive overrun error count. */

            pstats->rx_overrun_errors = diag.rx_overrun_err_cnt;

            /* Get the received short frame error count. */

            pstats->rx_short_frames = diag.rx_short_frm_err_cnt;

            /* Get the received long frame error count. */

            pstats->rx_too_long_frames = diag.rx_long_frm_err_cnt;

            /* Get the number of transmitted bytes. */

            pstats->tx_count = diag.tx_bytes_cnt;

            /* Get the number of defered packets. */

            pstats->tx_deferred = diag.tx_def_cnt;

            /* The number of successfully transmitted packets. */

            pstats->tx_good = diag.tx_pk_cnt;

            /* Get the transmit late collision count. */

            pstats->tx_late_collisions = diag.tx_late_col_cnt;

            /* Get the transmit underrun count. */

            pstats->tx_underrun = diag.tx_underrun_cnt;

            /* Get the transmit late collision count. */

            pstats->tx_total_collisions = diag.tx_late_col_cnt;

            return 1;

        }

        #else

        {

            /*   Copy the ethernet name device over.                        */

            strcpy(((struct mcf5272_ether_drv_stats*)data)->description,

                   ether_device_name);

            /* Get the stats. */

            MCF5272_get_stats(sc,

                              &((struct mcf5272_ether_drv_stats*)data)->stats);

            /* Copy the mode over. */

            ((struct mcf5272_ether_drv_stats*)data)->duplex =

                PMCF5272_FEC_DATA(sc)->duplex;

            /* The ethernet driver is operational. */

            ((struct mcf5272_ether_drv_stats*)data)->operational =

                PMCF5272_FEC_DATA(sc)->operational;

            /*   Copy the speed over.                                       */

            ((struct mcf5272_ether_drv_stats*)data)->speed =

                PMCF5272_FEC_DATA(sc)->speed;

            return 1;

        }

        #endif

        break;

    #endif /* CYGPKG_NET */

    default:

        return 1;

        break;

    }

}

/*      This routine is  called to see  if it is  possible to send  another */

/* packet.  It will  return  non-zero  if  a  transmit  is  possible,  zero */

/* otherwise.                                                               */

static int

MCF5272_fec_can_send(struct eth_drv_sc *sc)

{

    const int buffer_window = 5; /* Specifies the minimum empty buffer descrpitors */

    if ((NUM_TXBDS - PBUF_INFO(sc)->num_busy_bd) > buffer_window)

    {

        return 1;

    }

    else

    {

        PMCF5272_FEC_DATA(sc)->diag_counters.tx_full_cnt++;

        return 0;

    }

}

/*      This routine is called  by eCos  to send  a frame  to the  ethernet */

/* controller.                                                              */

static void

MCF5272_fec_send(struct eth_drv_sc *sc,

                 struct eth_drv_sg *sg_list,

                 int sg_len,

                 int total_len,

                 unsigned long key)

{

    /*   Call eth_tx_check() routine for any packet transmitted by eCos.    */

    eth_tx_check(sg_list, sg_len);

    /*   If   we   do   have   enough    buffer    to    send    we    call */

    /* MCF5272_fec_common_send routine to send  the packet.  Otherwise,  we */

    /* throw away the packet and call eCos's tx_done rutine to notify  that */

    /* the packet has been sent.                                            */

    if (NUM_TXBDS - PBUF_INFO(sc)->num_busy_bd > sg_len)

    {

        MCF5272_fec_common_send(sc, sg_list, sg_len, total_len, key, TX_KEY_ECOS);

    }

    else

    {

        CYG_ASSERT(false, "ETH: Send buffer full");

        /*   Inform the upper layer of a completion of the packet.          */

        (sc->funs->eth_drv->tx_done)(sc,

                                     key,

                                     0);

    }

}

/*      This routine is called to send a frame to the ethernet  controller. */

/* This is a generic send routine.                                          */

/*

  INPUT:

    sc - Ethernet driver sc.

    sg_glist - scatter gather list.

    sg_len - The number of scattter gather entries in the list.

    total_len - The total length of the frame.

*/

static void

MCF5272_fec_common_send(struct eth_drv_sc *sc,

                        struct eth_drv_sg *sg_list,

                        int sg_len,

                        int total_len,

                        unsigned long key,

                        tx_key_type_t key_type)

{

    int i = 0;

    NBUF *pBD = NULL;

    NBUF *first_bd;

    buf_info_t* p_buf = PBUF_INFO(sc);

    CYG_ASSERT(sg_len > 0,  "ETH: sg_len cannot be zero");

    /* Update the number of used transmitted buffer desciptors. */

    p_buf->num_busy_bd += sg_len;

    /*   Keep  track  of  the  maximum  number  of  busy  transmit   buffer */

    /* descriptors.                                                         */

    if (p_buf->num_busy_bd > p_buf->max_num_busy_bd)

    {

        p_buf->max_num_busy_bd = p_buf->num_busy_bd;

    }

    /*   Enqueue the key, the index to first and last buffer desriptor, the */

    /* number of  buffer descriptors,  the packet  length and  the type  of */

    /* packet to the transmit queue.                                        */

    nbuf_enq_tx_key(p_buf, (p_buf->iTxbd + sg_len - 1) % NUM_TXBDS,

                    key,

                    p_buf->iTxbd,

                    sg_len,

                    total_len,

                    key_type);

    /*   Get the pointer to the first buffer descriptor of the packet.   We */

    /* don't set the R bit for the first packet until we have allocated and */

    /* initialized all the buffer descriptors.                              */

    first_bd = pBD = nbuf_tx_allocate(p_buf);

    do

    {

        CYG_ASSERT(pBD != NULL, "ETH: nbuf_tx_allocate() returned NULL");

        /*   Copy the address of the buffer and the length to the allocated */

        /* buffer descriptor.  Note that  buf_index indexes  to the  buffer */

        /* descriptor it returns.                                           */

        pBD->data = (uint8*)sg_list[i].buf;

        pBD->length = sg_list[i].len;

        if (i == sg_len - 1)

        {

            /*   Set the the L,  TC and R bit  to indicate that the  buffer */

            /* descriptor  is  the  last  buffer  descriptor,  the  CRC  is */

            /* appended by the FEC and  the buffer descriptor is ready  for */

            /* transmission.                                                */

            pBD->status |= TX_BD_L | TX_BD_TC | TX_BD_R;

            /*   When we have  reached the  last buffer  scatther list,  we */

            /* break from the loop.                                         */

            break;