Logo Search packages:      
Sourcecode: u-boot-linaro version File versions  Download package

bcm570x.c

/*
 * Broadcom BCM570x Ethernet Driver for U-Boot.
 * Support 5701, 5702, 5703, and 5704. Single instance driver.
 * Copyright (C) 2002 James F. Dougherty (jfd@broadcom.com)
 */

#include <common.h>

#ifdef CONFIG_BMW
#include <mpc824x.h>
#endif
#include <net.h>
#include "bcm570x_mm.h"
#include "bcm570x_autoneg.h"
#include <pci.h>
#include <malloc.h>

/*
 * PCI Registers and definitions.
 */
#define PCI_CMD_MASK    0xffff0000  /* mask to save status bits */
#define PCI_ANY_ID (~0)

/*
 * PCI memory base for Ethernet device as well as device Interrupt.
 */
#define BCM570X_MBAR    0x80100000
#define BCM570X_ILINE   1

#define SECOND_USEC     1000000
#define MAX_PACKET_SIZE 1600
#define MAX_UNITS       4

/* Globals to this module */
int initialized = 0;
unsigned int ioBase = 0;
volatile PLM_DEVICE_BLOCK pDevice = NULL; /* 570x softc */
volatile PUM_DEVICE_BLOCK pUmDevice = NULL;

/* Used to pass the full-duplex flag, etc. */
int line_speed[MAX_UNITS] = { 0, 0, 0, 0 };
static int full_duplex[MAX_UNITS] = { 1, 1, 1, 1 };
static int rx_flow_control[MAX_UNITS] = { 0, 0, 0, 0 };
static int tx_flow_control[MAX_UNITS] = { 0, 0, 0, 0 };
static int auto_flow_control[MAX_UNITS] = { 0, 0, 0, 0 };
static int tx_checksum[MAX_UNITS] = { 1, 1, 1, 1 };
static int rx_checksum[MAX_UNITS] = { 1, 1, 1, 1 };
static int auto_speed[MAX_UNITS] = { 1, 1, 1, 1 };

#if JUMBO_FRAMES
/* Jumbo MTU for interfaces. */
static int mtu[MAX_UNITS] = { 0, 0, 0, 0 };
#endif

/* Turn on Wake-on lan for a device unit */
static int enable_wol[MAX_UNITS] = { 0, 0, 0, 0 };

#define TX_DESC_CNT DEFAULT_TX_PACKET_DESC_COUNT
static unsigned int tx_pkt_desc_cnt[MAX_UNITS] =
    { TX_DESC_CNT, TX_DESC_CNT, TX_DESC_CNT, TX_DESC_CNT };

#define RX_DESC_CNT DEFAULT_STD_RCV_DESC_COUNT
static unsigned int rx_std_desc_cnt[MAX_UNITS] =
    { RX_DESC_CNT, RX_DESC_CNT, RX_DESC_CNT, RX_DESC_CNT };

static unsigned int rx_adaptive_coalesce[MAX_UNITS] = { 1, 1, 1, 1 };

#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
#define JBO_DESC_CNT DEFAULT_JUMBO_RCV_DESC_COUNT
static unsigned int rx_jumbo_desc_cnt[MAX_UNITS] =
    { JBO_DESC_CNT, JBO_DESC_CNT, JBO_DESC_CNT, JBO_DESC_CNT };
#endif
#define RX_COAL_TK DEFAULT_RX_COALESCING_TICKS
static unsigned int rx_coalesce_ticks[MAX_UNITS] =
    { RX_COAL_TK, RX_COAL_TK, RX_COAL_TK, RX_COAL_TK };

#define RX_COAL_FM DEFAULT_RX_MAX_COALESCED_FRAMES
static unsigned int rx_max_coalesce_frames[MAX_UNITS] =
    { RX_COAL_FM, RX_COAL_FM, RX_COAL_FM, RX_COAL_FM };

#define TX_COAL_TK DEFAULT_TX_COALESCING_TICKS
static unsigned int tx_coalesce_ticks[MAX_UNITS] =
    { TX_COAL_TK, TX_COAL_TK, TX_COAL_TK, TX_COAL_TK };

#define TX_COAL_FM DEFAULT_TX_MAX_COALESCED_FRAMES
static unsigned int tx_max_coalesce_frames[MAX_UNITS] =
    { TX_COAL_FM, TX_COAL_FM, TX_COAL_FM, TX_COAL_FM };

#define ST_COAL_TK DEFAULT_STATS_COALESCING_TICKS
static unsigned int stats_coalesce_ticks[MAX_UNITS] =
    { ST_COAL_TK, ST_COAL_TK, ST_COAL_TK, ST_COAL_TK };

/*
 * Legitimate values for BCM570x device types
 */
typedef enum {
      BCM5700VIGIL = 0,
      BCM5700A6,
      BCM5700T6,
      BCM5700A9,
      BCM5700T9,
      BCM5700,
      BCM5701A5,
      BCM5701T1,
      BCM5701T8,
      BCM5701A7,
      BCM5701A10,
      BCM5701A12,
      BCM5701,
      BCM5702,
      BCM5703,
      BCM5703A31,
      TC996T,
      TC996ST,
      TC996SSX,
      TC996SX,
      TC996BT,
      TC997T,
      TC997SX,
      TC1000T,
      TC940BR01,
      TC942BR01,
      NC6770,
      NC7760,
      NC7770,
      NC7780
} board_t;

/* Chip-Rev names for each device-type */
static struct {
      char *name;
} chip_rev[] = {
      {
      "BCM5700VIGIL"}, {
      "BCM5700A6"}, {
      "BCM5700T6"}, {
      "BCM5700A9"}, {
      "BCM5700T9"}, {
      "BCM5700"}, {
      "BCM5701A5"}, {
      "BCM5701T1"}, {
      "BCM5701T8"}, {
      "BCM5701A7"}, {
      "BCM5701A10"}, {
      "BCM5701A12"}, {
      "BCM5701"}, {
      "BCM5702"}, {
      "BCM5703"}, {
      "BCM5703A31"}, {
      "TC996T"}, {
      "TC996ST"}, {
      "TC996SSX"}, {
      "TC996SX"}, {
      "TC996BT"}, {
      "TC997T"}, {
      "TC997SX"}, {
      "TC1000T"}, {
      "TC940BR01"}, {
      "TC942BR01"}, {
      "NC6770"}, {
      "NC7760"}, {
      "NC7770"}, {
      "NC7780"}, {
      0}
};

/* indexed by board_t, above */
static struct {
      char *name;
} board_info[] = {
      {
      "Broadcom Vigil B5700 1000Base-T"}, {
      "Broadcom BCM5700 1000Base-T"}, {
      "Broadcom BCM5700 1000Base-SX"}, {
      "Broadcom BCM5700 1000Base-SX"}, {
      "Broadcom BCM5700 1000Base-T"}, {
      "Broadcom BCM5700"}, {
      "Broadcom BCM5701 1000Base-T"}, {
      "Broadcom BCM5701 1000Base-T"}, {
      "Broadcom BCM5701 1000Base-T"}, {
      "Broadcom BCM5701 1000Base-SX"}, {
      "Broadcom BCM5701 1000Base-T"}, {
      "Broadcom BCM5701 1000Base-T"}, {
      "Broadcom BCM5701"}, {
      "Broadcom BCM5702 1000Base-T"}, {
      "Broadcom BCM5703 1000Base-T"}, {
      "Broadcom BCM5703 1000Base-SX"}, {
      "3Com 3C996 10/100/1000 Server NIC"}, {
      "3Com 3C996 10/100/1000 Server NIC"}, {
      "3Com 3C996 Gigabit Fiber-SX Server NIC"}, {
      "3Com 3C996 Gigabit Fiber-SX Server NIC"}, {
      "3Com 3C996B Gigabit Server NIC"}, {
      "3Com 3C997 Gigabit Server NIC"}, {
      "3Com 3C997 Gigabit Fiber-SX Server NIC"}, {
      "3Com 3C1000 Gigabit NIC"}, {
      "3Com 3C940 Gigabit LOM (21X21)"}, {
      "3Com 3C942 Gigabit LOM (31X31)"}, {
      "Compaq NC6770 Gigabit Server Adapter"}, {
      "Compaq NC7760 Gigabit Server Adapter"}, {
      "Compaq NC7770 Gigabit Server Adapter"}, {
      "Compaq NC7780 Gigabit Server Adapter"}, {
0},};

/* PCI Devices which use the 570x chipset */
struct pci_device_table {
      unsigned short vendor_id, device_id;      /* Vendor/DeviceID */
      unsigned short subvendor, subdevice;      /* Subsystem ID's or PCI_ANY_ID */
      unsigned int class, class_mask;     /* (class,subclass,prog-if) triplet */
      unsigned long board_id; /* Data private to the driver */
      int io_size, min_latency;
} bcm570xDevices[] = {
      {
      0x14e4, 0x1644, 0x1014, 0x0277, 0, 0, BCM5700VIGIL, 128, 32}, {
      0x14e4, 0x1644, 0x14e4, 0x1644, 0, 0, BCM5700A6, 128, 32}, {
      0x14e4, 0x1644, 0x14e4, 0x2, 0, 0, BCM5700T6, 128, 32}, {
      0x14e4, 0x1644, 0x14e4, 0x3, 0, 0, BCM5700A9, 128, 32}, {
      0x14e4, 0x1644, 0x14e4, 0x4, 0, 0, BCM5700T9, 128, 32}, {
      0x14e4, 0x1644, 0x1028, 0xd1, 0, 0, BCM5700, 128, 32}, {
      0x14e4, 0x1644, 0x1028, 0x0106, 0, 0, BCM5700, 128, 32}, {
      0x14e4, 0x1644, 0x1028, 0x0109, 0, 0, BCM5700, 128, 32}, {
      0x14e4, 0x1644, 0x1028, 0x010a, 0, 0, BCM5700, 128, 32}, {
      0x14e4, 0x1644, 0x10b7, 0x1000, 0, 0, TC996T, 128, 32}, {
      0x14e4, 0x1644, 0x10b7, 0x1001, 0, 0, TC996ST, 128, 32}, {
      0x14e4, 0x1644, 0x10b7, 0x1002, 0, 0, TC996SSX, 128, 32}, {
      0x14e4, 0x1644, 0x10b7, 0x1003, 0, 0, TC997T, 128, 32}, {
      0x14e4, 0x1644, 0x10b7, 0x1005, 0, 0, TC997SX, 128, 32}, {
      0x14e4, 0x1644, 0x10b7, 0x1008, 0, 0, TC942BR01, 128, 32}, {
      0x14e4, 0x1644, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5700, 128, 32}, {
      0x14e4, 0x1645, 0x14e4, 1, 0, 0, BCM5701A5, 128, 32}, {
      0x14e4, 0x1645, 0x14e4, 5, 0, 0, BCM5701T1, 128, 32}, {
      0x14e4, 0x1645, 0x14e4, 6, 0, 0, BCM5701T8, 128, 32}, {
      0x14e4, 0x1645, 0x14e4, 7, 0, 0, BCM5701A7, 128, 32}, {
      0x14e4, 0x1645, 0x14e4, 8, 0, 0, BCM5701A10, 128, 32}, {
      0x14e4, 0x1645, 0x14e4, 0x8008, 0, 0, BCM5701A12, 128, 32}, {
      0x14e4, 0x1645, 0x0e11, 0xc1, 0, 0, NC6770, 128, 32}, {
      0x14e4, 0x1645, 0x0e11, 0x7c, 0, 0, NC7770, 128, 32}, {
      0x14e4, 0x1645, 0x0e11, 0x85, 0, 0, NC7780, 128, 32}, {
      0x14e4, 0x1645, 0x1028, 0x0121, 0, 0, BCM5701, 128, 32}, {
      0x14e4, 0x1645, 0x10b7, 0x1004, 0, 0, TC996SX, 128, 32}, {
      0x14e4, 0x1645, 0x10b7, 0x1006, 0, 0, TC996BT, 128, 32}, {
      0x14e4, 0x1645, 0x10b7, 0x1007, 0, 0, TC1000T, 128, 32}, {
      0x14e4, 0x1645, 0x10b7, 0x1008, 0, 0, TC940BR01, 128, 32}, {
      0x14e4, 0x1645, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5701, 128, 32}, {
      0x14e4, 0x1646, 0x14e4, 0x8009, 0, 0, BCM5702, 128, 32}, {
      0x14e4, 0x1646, 0x0e11, 0xbb, 0, 0, NC7760, 128, 32}, {
      0x14e4, 0x1646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702, 128, 32}, {
      0x14e4, 0x16a6, 0x14e4, 0x8009, 0, 0, BCM5702, 128, 32}, {
      0x14e4, 0x16a6, 0x0e11, 0xbb, 0, 0, NC7760, 128, 32}, {
      0x14e4, 0x16a6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702, 128, 32}, {
      0x14e4, 0x1647, 0x14e4, 0x0009, 0, 0, BCM5703, 128, 32}, {
      0x14e4, 0x1647, 0x14e4, 0x000a, 0, 0, BCM5703A31, 128, 32}, {
      0x14e4, 0x1647, 0x14e4, 0x000b, 0, 0, BCM5703, 128, 32}, {
      0x14e4, 0x1647, 0x14e4, 0x800a, 0, 0, BCM5703, 128, 32}, {
      0x14e4, 0x1647, 0x0e11, 0x9a, 0, 0, NC7770, 128, 32}, {
      0x14e4, 0x1647, 0x0e11, 0x99, 0, 0, NC7780, 128, 32}, {
      0x14e4, 0x1647, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703, 128, 32}, {
      0x14e4, 0x16a7, 0x14e4, 0x0009, 0, 0, BCM5703, 128, 32}, {
      0x14e4, 0x16a7, 0x14e4, 0x000a, 0, 0, BCM5703A31, 128, 32}, {
      0x14e4, 0x16a7, 0x14e4, 0x000b, 0, 0, BCM5703, 128, 32}, {
      0x14e4, 0x16a7, 0x14e4, 0x800a, 0, 0, BCM5703, 128, 32}, {
      0x14e4, 0x16a7, 0x0e11, 0x9a, 0, 0, NC7770, 128, 32}, {
      0x14e4, 0x16a7, 0x0e11, 0x99, 0, 0, NC7780, 128, 32}, {
      0x14e4, 0x16a7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703, 128, 32}
};

#define n570xDevices   (sizeof(bcm570xDevices)/sizeof(bcm570xDevices[0]))

/*
 * Allocate a packet buffer from the bcm570x packet pool.
 */
void *bcm570xPktAlloc (int u, int pksize)
{
      return malloc (pksize);
}

/*
 * Free a packet previously allocated from the bcm570x packet
 * buffer pool.
 */
void bcm570xPktFree (int u, void *p)
{
      free (p);
}

int bcm570xReplenishRxBuffers (PUM_DEVICE_BLOCK pUmDevice)
{
      PLM_PACKET pPacket;
      PUM_PACKET pUmPacket;
      void *skb;
      int queue_rx = 0;
      int ret = 0;

      while ((pUmPacket = (PUM_PACKET)
            QQ_PopHead (&pUmDevice->rx_out_of_buf_q.Container)) != 0) {

            pPacket = (PLM_PACKET) pUmPacket;

            /* reuse an old skb */
            if (pUmPacket->skbuff) {
                  QQ_PushTail (&pDevice->RxPacketFreeQ.Container,
                             pPacket);
                  queue_rx = 1;
                  continue;
            }
            if ((skb = bcm570xPktAlloc (pUmDevice->index,
                                  pPacket->u.Rx.RxBufferSize + 2)) ==
                0) {
                  QQ_PushHead (&pUmDevice->rx_out_of_buf_q.Container,
                             pPacket);
                  printf ("NOTICE: Out of RX memory.\n");
                  ret = 1;
                  break;
            }

            pUmPacket->skbuff = skb;
            QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket);
            queue_rx = 1;
      }

      if (queue_rx) {
            LM_QueueRxPackets (pDevice);
      }

      return ret;
}

/*
 * Probe, Map, and Init 570x device.
 */
int eth_init (bd_t * bis)
{
      int i, rv, devFound = FALSE;
      pci_dev_t devbusfn;
      unsigned short status;

      /* Find PCI device, if it exists, configure ...  */
      for (i = 0; i < n570xDevices; i++) {
            devbusfn = pci_find_device (bcm570xDevices[i].vendor_id,
                                  bcm570xDevices[i].device_id, 0);
            if (devbusfn == -1) {
                  continue;   /* No device of that vendor/device ID */
            } else {

                  /* Set ILINE */
                  pci_write_config_byte (devbusfn,
                                     PCI_INTERRUPT_LINE,
                                     BCM570X_ILINE);

                  /*
                   * 0x10 - 0x14 define one 64-bit MBAR.
                   * 0x14 is the higher-order address bits of the BAR.
                   */
                  pci_write_config_dword (devbusfn,
                                    PCI_BASE_ADDRESS_1, 0);

                  ioBase = BCM570X_MBAR;

                  pci_write_config_dword (devbusfn,
                                    PCI_BASE_ADDRESS_0, ioBase);

                  /*
                   * Enable PCI memory, IO, and Master -- don't
                   * reset any status bits in doing so.
                   */
                  pci_read_config_word (devbusfn, PCI_COMMAND, &status);

                  status |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;

                  pci_write_config_word (devbusfn, PCI_COMMAND, status);

                  printf
                      ("\n%s: bus %d, device %d, function %d: MBAR=0x%x\n",
                       board_info[bcm570xDevices[i].board_id].name,
                       PCI_BUS (devbusfn), PCI_DEV (devbusfn),
                       PCI_FUNC (devbusfn), ioBase);

                  /* Allocate once, but always clear on init */
                  if (!pDevice) {
                        pDevice = malloc (sizeof (UM_DEVICE_BLOCK));
                        pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
                        memset (pDevice, 0x0, sizeof (UM_DEVICE_BLOCK));
                  }

                  /* Configure pci dev structure */
                  pUmDevice->pdev = devbusfn;
                  pUmDevice->index = 0;
                  pUmDevice->tx_pkt = 0;
                  pUmDevice->rx_pkt = 0;
                  devFound = TRUE;
                  break;
            }
      }

      if (!devFound) {
            printf
                ("eth_init: FAILURE: no BCM570x Ethernet devices found.\n");
            return -1;
      }

      /* Setup defaults for chip */
      pDevice->TaskToOffload = LM_TASK_OFFLOAD_NONE;

      if (pDevice->ChipRevId == T3_CHIP_ID_5700_B0) {
            pDevice->TaskToOffload = LM_TASK_OFFLOAD_NONE;
      } else {

            if (rx_checksum[i]) {
                  pDevice->TaskToOffload |=
                      LM_TASK_OFFLOAD_RX_TCP_CHECKSUM |
                      LM_TASK_OFFLOAD_RX_UDP_CHECKSUM;
            }

            if (tx_checksum[i]) {
                  pDevice->TaskToOffload |=
                      LM_TASK_OFFLOAD_TX_TCP_CHECKSUM |
                      LM_TASK_OFFLOAD_TX_UDP_CHECKSUM;
                  pDevice->NoTxPseudoHdrChksum = TRUE;
            }
      }

      /* Set Device PCI Memory base address */
      pDevice->pMappedMemBase = (PLM_UINT8) ioBase;

      /* Pull down adapter info */
      if ((rv = LM_GetAdapterInfo (pDevice)) != LM_STATUS_SUCCESS) {
            printf ("bcm570xEnd: LM_GetAdapterInfo failed: rv=%d!\n", rv);
            return -2;
      }

      /* Lock not needed */
      pUmDevice->do_global_lock = 0;

      if (T3_ASIC_REV (pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5700) {
            /* The 5700 chip works best without interleaved register */
            /* accesses on certain machines. */
            pUmDevice->do_global_lock = 1;
      }

      /* Setup timer delays */
      if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) {
            pDevice->UseTaggedStatus = TRUE;
            pUmDevice->timer_interval = CONFIG_SYS_HZ;
      } else {
            pUmDevice->timer_interval = CONFIG_SYS_HZ / 50;
      }

      /* Grab name .... */
      pUmDevice->name =
          (char *)malloc (strlen (board_info[bcm570xDevices[i].board_id].name)
                      + 1);
      strcpy (pUmDevice->name, board_info[bcm570xDevices[i].board_id].name);

      eth_getenv_enetaddr("ethaddr", pDevice->NodeAddress);
      LM_SetMacAddress (pDevice);
      /* Init queues  .. */
      QQ_InitQueue (&pUmDevice->rx_out_of_buf_q.Container,
                  MAX_RX_PACKET_DESC_COUNT);
      pUmDevice->rx_last_cnt = pUmDevice->tx_last_cnt = 0;

      /* delay for 4 seconds */
      pUmDevice->delayed_link_ind = (4 * CONFIG_SYS_HZ) / pUmDevice->timer_interval;

      pUmDevice->adaptive_expiry = CONFIG_SYS_HZ / pUmDevice->timer_interval;

      /* Sometimes we get spurious ints. after reset when link is down. */
      /* This field tells the isr to service the int. even if there is */
      /* no status block update. */
      pUmDevice->adapter_just_inited =
          (3 * CONFIG_SYS_HZ) / pUmDevice->timer_interval;

      /* Initialize 570x */
      if (LM_InitializeAdapter (pDevice) != LM_STATUS_SUCCESS) {
            printf ("ERROR: Adapter initialization failed.\n");
            return ERROR;
      }

      /* Enable chip ISR */
      LM_EnableInterrupt (pDevice);

      /* Clear MC table */
      LM_MulticastClear (pDevice);

      /* Enable Multicast */
      LM_SetReceiveMask (pDevice,
                     pDevice->ReceiveMask | LM_ACCEPT_ALL_MULTICAST);

      pUmDevice->opened = 1;
      pUmDevice->tx_full = 0;
      pUmDevice->tx_pkt = 0;
      pUmDevice->rx_pkt = 0;
      printf ("eth%d: %s @0x%lx,",
            pDevice->index, pUmDevice->name, (unsigned long)ioBase);
      printf ("node addr ");
      for (i = 0; i < 6; i++) {
            printf ("%2.2x", pDevice->NodeAddress[i]);
      }
      printf ("\n");

      printf ("eth%d: ", pDevice->index);
      printf ("%s with ", chip_rev[bcm570xDevices[i].board_id].name);

      if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5400_PHY_ID)
            printf ("Broadcom BCM5400 Copper ");
      else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5401_PHY_ID)
            printf ("Broadcom BCM5401 Copper ");
      else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5411_PHY_ID)
            printf ("Broadcom BCM5411 Copper ");
      else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5701_PHY_ID)
            printf ("Broadcom BCM5701 Integrated Copper ");
      else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5703_PHY_ID)
            printf ("Broadcom BCM5703 Integrated Copper ");
      else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM8002_PHY_ID)
            printf ("Broadcom BCM8002 SerDes ");
      else if (pDevice->EnableTbi)
            printf ("Agilent HDMP-1636 SerDes ");
      else
            printf ("Unknown ");
      printf ("transceiver found\n");

      printf ("eth%d: %s, MTU: %d,",
            pDevice->index, pDevice->BusSpeedStr, 1500);

      if ((pDevice->ChipRevId != T3_CHIP_ID_5700_B0) && rx_checksum[i])
            printf ("Rx Checksum ON\n");
      else
            printf ("Rx Checksum OFF\n");
      initialized++;

      return 0;
}

/* Ethernet Interrupt service routine */
void eth_isr (void)
{
      LM_UINT32 oldtag, newtag;
      int i;

      pUmDevice->interrupt = 1;

      if (pDevice->UseTaggedStatus) {
            if ((pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) ||
                pUmDevice->adapter_just_inited) {
                  MB_REG_WR (pDevice, Mailbox.Interrupt[0].Low, 1);
                  oldtag = pDevice->pStatusBlkVirt->StatusTag;

                  for (i = 0;; i++) {
                        pDevice->pStatusBlkVirt->Status &=
                            ~STATUS_BLOCK_UPDATED;
                        LM_ServiceInterrupts (pDevice);
                        newtag = pDevice->pStatusBlkVirt->StatusTag;
                        if ((newtag == oldtag) || (i > 50)) {
                              MB_REG_WR (pDevice,
                                       Mailbox.Interrupt[0].Low,
                                       newtag << 24);
                              if (pDevice->UndiFix) {
                                    REG_WR (pDevice, Grc.LocalCtrl,
                                          pDevice->
                                          GrcLocalCtrl | 0x2);
                              }
                              break;
                        }
                        oldtag = newtag;
                  }
            }
      } else {
            while (pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) {
                  unsigned int dummy;

                  pDevice->pMemView->Mailbox.Interrupt[0].Low = 1;
                  pDevice->pStatusBlkVirt->Status &=
                      ~STATUS_BLOCK_UPDATED;
                  LM_ServiceInterrupts (pDevice);
                  pDevice->pMemView->Mailbox.Interrupt[0].Low = 0;
                  dummy = pDevice->pMemView->Mailbox.Interrupt[0].Low;
            }
      }

      /* Allocate new RX buffers */
      if (QQ_GetEntryCnt (&pUmDevice->rx_out_of_buf_q.Container)) {
            bcm570xReplenishRxBuffers (pUmDevice);
      }

      /* Queue packets */
      if (QQ_GetEntryCnt (&pDevice->RxPacketFreeQ.Container)) {
            LM_QueueRxPackets (pDevice);
      }

      if (pUmDevice->tx_queued) {
            pUmDevice->tx_queued = 0;
      }

      if (pUmDevice->tx_full) {
            if (pDevice->LinkStatus != LM_STATUS_LINK_DOWN) {
                  printf
                      ("NOTICE: tx was previously blocked, restarting MUX\n");
                  pUmDevice->tx_full = 0;
            }
      }

      pUmDevice->interrupt = 0;

}

int eth_send (volatile void *packet, int length)
{
      int status = 0;
#if ET_DEBUG
      unsigned char *ptr = (unsigned char *)packet;
#endif
      PLM_PACKET pPacket;
      PUM_PACKET pUmPacket;

      /* Link down, return */
      while (pDevice->LinkStatus == LM_STATUS_LINK_DOWN) {
#if 0
            printf ("eth%d: link down - check cable or link partner.\n",
                  pUmDevice->index);
#endif
            eth_isr ();

            /* Wait to see link for one-half a second before sending ... */
            udelay (1500000);

      }

      /* Clear sent flag */
      pUmDevice->tx_pkt = 0;

      /* Previously blocked */
      if (pUmDevice->tx_full) {
            printf ("eth%d: tx blocked.\n", pUmDevice->index);
            return 0;
      }

      pPacket = (PLM_PACKET)
          QQ_PopHead (&pDevice->TxPacketFreeQ.Container);

      if (pPacket == 0) {
            pUmDevice->tx_full = 1;
            printf ("bcm570xEndSend: TX full!\n");
            return 0;
      }

      if (pDevice->SendBdLeft.counter == 0) {
            pUmDevice->tx_full = 1;
            printf ("bcm570xEndSend: no more TX descriptors!\n");
            QQ_PushHead (&pDevice->TxPacketFreeQ.Container, pPacket);
            return 0;
      }

      if (length <= 0) {
            printf ("eth: bad packet size: %d\n", length);
            goto out;
      }

      /* Get packet buffers and fragment list */
      pUmPacket = (PUM_PACKET) pPacket;
      /* Single DMA Descriptor transmit.
       * Fragments may be provided, but one DMA descriptor max is
       * used to send the packet.
       */
      if (MM_CoalesceTxBuffer (pDevice, pPacket) != LM_STATUS_SUCCESS) {
            if (pUmPacket->skbuff == NULL) {
                  /* Packet was discarded */
                  printf ("TX: failed (1)\n");
                  status = 1;
            } else {
                  printf ("TX: failed (2)\n");
                  status = 2;
            }
            QQ_PushHead (&pDevice->TxPacketFreeQ.Container, pPacket);
            return status;
      }

      /* Copy packet to DMA buffer */
      memset (pUmPacket->skbuff, 0x0, MAX_PACKET_SIZE);
      memcpy ((void *)pUmPacket->skbuff, (void *)packet, length);
      pPacket->PacketSize = length;
      pPacket->Flags |= SND_BD_FLAG_END | SND_BD_FLAG_COAL_NOW;
      pPacket->u.Tx.FragCount = 1;
      /* We've already provided a frame ready for transmission */
      pPacket->Flags &= ~SND_BD_FLAG_TCP_UDP_CKSUM;

      if (LM_SendPacket (pDevice, pPacket) == LM_STATUS_FAILURE) {
            /*
             *  A lower level send failure will push the packet descriptor back
             *  in the free queue, so just deal with the VxWorks clusters.
             */
            if (pUmPacket->skbuff == NULL) {
                  printf ("TX failed (1)!\n");
                  /* Packet was discarded */
                  status = 3;
            } else {
                  /* A resource problem ... */
                  printf ("TX failed (2)!\n");
                  status = 4;
            }

            if (QQ_GetEntryCnt (&pDevice->TxPacketFreeQ.Container) == 0) {
                  printf ("TX: emptyQ!\n");
                  pUmDevice->tx_full = 1;
            }
      }

      while (pUmDevice->tx_pkt == 0) {
            /* Service TX */
            eth_isr ();
      }
#if ET_DEBUG
      printf ("eth_send: 0x%x, %d bytes\n"
            "[%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x] ...\n",
            (int)pPacket, length,
            ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5],
            ptr[6], ptr[7], ptr[8], ptr[9], ptr[10], ptr[11], ptr[12],
            ptr[13], ptr[14], ptr[15]);
#endif
      pUmDevice->tx_pkt = 0;
      QQ_PushHead (&pDevice->TxPacketFreeQ.Container, pPacket);

      /* Done with send */
      out:
      return status;
}

/* Ethernet receive */
int eth_rx (void)
{
      PLM_PACKET pPacket = NULL;
      PUM_PACKET pUmPacket = NULL;
      void *skb;
      int size = 0;

      while (TRUE) {

            bcm570x_service_isr:
            /* Pull down packet if it is there */
            eth_isr ();

            /* Indicate RX packets called */
            if (pUmDevice->rx_pkt) {
                  /* printf("eth_rx: got a packet...\n"); */
                  pUmDevice->rx_pkt = 0;
            } else {
                  /* printf("eth_rx: waiting for packet...\n"); */
                  goto bcm570x_service_isr;
            }

            pPacket = (PLM_PACKET)
                QQ_PopHead (&pDevice->RxPacketReceivedQ.Container);

            if (pPacket == 0) {
                  printf ("eth_rx: empty packet!\n");
                  goto bcm570x_service_isr;
            }

            pUmPacket = (PUM_PACKET) pPacket;
#if ET_DEBUG
            printf ("eth_rx: packet @0x%x\n", (int)pPacket);
#endif
            /* If the packet generated an error, reuse buffer */
            if ((pPacket->PacketStatus != LM_STATUS_SUCCESS) ||
                ((size = pPacket->PacketSize) > pDevice->RxMtu)) {

                  /* reuse skb */
                  QQ_PushTail (&pDevice->RxPacketFreeQ.Container,
                             pPacket);
                  printf ("eth_rx: error in packet dma!\n");
                  goto bcm570x_service_isr;
            }

            /* Set size and address */
            skb = pUmPacket->skbuff;
            size = pPacket->PacketSize;

            /* Pass the packet up to the protocol
             * layers.
             */
            NetReceive (skb, size);

            /* Free packet buffer */
            bcm570xPktFree (pUmDevice->index, skb);
            pUmPacket->skbuff = NULL;

            /* Reuse SKB */
            QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket);

            return 0;   /* Got a packet, bail ... */
      }
      return size;
}

/* Shut down device */
void eth_halt (void)
{
      int i;
      if (initialized)
            if (pDevice && pUmDevice && pUmDevice->opened) {
                  printf ("\neth%d:%s,", pUmDevice->index,
                        pUmDevice->name);
                  printf ("HALT,");
                  /* stop device */
                  LM_Halt (pDevice);
                  printf ("POWER DOWN,");
                  LM_SetPowerState (pDevice, LM_POWER_STATE_D3);

                  /* Free the memory allocated by the device in tigon3 */
                  for (i = 0; i < pUmDevice->mem_list_num; i++) {
                        if (pUmDevice->mem_list[i]) {
                              /* sanity check */
                              if (pUmDevice->dma_list[i]) { /* cache-safe memory */
                                    free (pUmDevice->mem_list[i]);
                              } else {
                                    free (pUmDevice->mem_list[i]);      /* normal memory   */
                              }
                        }
                  }
                  pUmDevice->opened = 0;
                  free (pDevice);
                  pDevice = NULL;
                  pUmDevice = NULL;
                  initialized = 0;
                  printf ("done - offline.\n");
            }
}

/*
 *
 * Middle Module: Interface between the HW driver (tigon3 modules) and
 * the native (SENS) driver.  These routines implement the system
 * interface for tigon3 on VxWorks.
 */

/* Middle module dependency - size of a packet descriptor */
int MM_Packet_Desc_Size = sizeof (UM_PACKET);

LM_STATUS
MM_ReadConfig32 (PLM_DEVICE_BLOCK pDevice,
             LM_UINT32 Offset, LM_UINT32 * pValue32)
{
      UM_DEVICE_BLOCK *pUmDevice;
      pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
      pci_read_config_dword (pUmDevice->pdev, Offset, (u32 *) pValue32);
      return LM_STATUS_SUCCESS;
}

LM_STATUS
MM_WriteConfig32 (PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset, LM_UINT32 Value32)
{
      UM_DEVICE_BLOCK *pUmDevice;
      pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
      pci_write_config_dword (pUmDevice->pdev, Offset, Value32);
      return LM_STATUS_SUCCESS;
}

LM_STATUS
MM_ReadConfig16 (PLM_DEVICE_BLOCK pDevice,
             LM_UINT32 Offset, LM_UINT16 * pValue16)
{
      UM_DEVICE_BLOCK *pUmDevice;
      pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
      pci_read_config_word (pUmDevice->pdev, Offset, (u16 *) pValue16);
      return LM_STATUS_SUCCESS;
}

LM_STATUS
MM_WriteConfig16 (PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset, LM_UINT16 Value16)
{
      UM_DEVICE_BLOCK *pUmDevice;
      pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
      pci_write_config_word (pUmDevice->pdev, Offset, Value16);
      return LM_STATUS_SUCCESS;
}

LM_STATUS
MM_AllocateSharedMemory (PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize,
                   PLM_VOID * pMemoryBlockVirt,
                   PLM_PHYSICAL_ADDRESS pMemoryBlockPhy, LM_BOOL Cached)
{
      PLM_VOID pvirt;
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      dma_addr_t mapping;

      pvirt = malloc (BlockSize);
      mapping = (dma_addr_t) (pvirt);
      if (!pvirt)
            return LM_STATUS_FAILURE;

      pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt;
      pUmDevice->dma_list[pUmDevice->mem_list_num] = mapping;
      pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = BlockSize;
      memset (pvirt, 0, BlockSize);

      *pMemoryBlockVirt = (PLM_VOID) pvirt;
      MM_SetAddr (pMemoryBlockPhy, (dma_addr_t) mapping);

      return LM_STATUS_SUCCESS;
}

LM_STATUS
MM_AllocateMemory (PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize,
               PLM_VOID * pMemoryBlockVirt)
{
      PLM_VOID pvirt;
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;

      pvirt = malloc (BlockSize);

      if (!pvirt)
            return LM_STATUS_FAILURE;

      pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt;
      pUmDevice->dma_list[pUmDevice->mem_list_num] = 0;
      pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = BlockSize;
      memset (pvirt, 0, BlockSize);
      *pMemoryBlockVirt = pvirt;

      return LM_STATUS_SUCCESS;
}

LM_STATUS MM_MapMemBase (PLM_DEVICE_BLOCK pDevice)
{
      printf ("BCM570x PCI Memory base address @0x%x\n",
            (unsigned int)pDevice->pMappedMemBase);
      return LM_STATUS_SUCCESS;
}

LM_STATUS MM_InitializeUmPackets (PLM_DEVICE_BLOCK pDevice)
{
      int i;
      void *skb;
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      PUM_PACKET pUmPacket = NULL;
      PLM_PACKET pPacket = NULL;

      for (i = 0; i < pDevice->RxPacketDescCnt; i++) {
            pPacket = QQ_PopHead (&pDevice->RxPacketFreeQ.Container);
            pUmPacket = (PUM_PACKET) pPacket;

            if (pPacket == 0) {
                  printf ("MM_InitializeUmPackets: Bad RxPacketFreeQ\n");
            }

            skb = bcm570xPktAlloc (pUmDevice->index,
                               pPacket->u.Rx.RxBufferSize + 2);

            if (skb == 0) {
                  pUmPacket->skbuff = 0;
                  QQ_PushTail (&pUmDevice->rx_out_of_buf_q.Container,
                             pPacket);
                  printf ("MM_InitializeUmPackets: out of buffer.\n");
                  continue;
            }

            pUmPacket->skbuff = skb;
            QQ_PushTail (&pDevice->RxPacketFreeQ.Container, pPacket);
      }

      pUmDevice->rx_low_buf_thresh = pDevice->RxPacketDescCnt / 8;

      return LM_STATUS_SUCCESS;
}

LM_STATUS MM_GetConfig (PLM_DEVICE_BLOCK pDevice)
{
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      int index = pDevice->index;

      if (auto_speed[index] == 0)
            pDevice->DisableAutoNeg = TRUE;
      else
            pDevice->DisableAutoNeg = FALSE;

      if (line_speed[index] == 0) {
            pDevice->RequestedMediaType = LM_REQUESTED_MEDIA_TYPE_AUTO;
            pDevice->DisableAutoNeg = FALSE;
      } else {
            if (line_speed[index] == 1000) {
                  if (pDevice->EnableTbi) {
                        pDevice->RequestedMediaType =
                            LM_REQUESTED_MEDIA_TYPE_FIBER_1000MBPS_FULL_DUPLEX;
                  } else if (full_duplex[index]) {
                        pDevice->RequestedMediaType =
                            LM_REQUESTED_MEDIA_TYPE_UTP_1000MBPS_FULL_DUPLEX;
                  } else {
                        pDevice->RequestedMediaType =
                            LM_REQUESTED_MEDIA_TYPE_UTP_1000MBPS;
                  }
                  if (!pDevice->EnableTbi)
                        pDevice->DisableAutoNeg = FALSE;
            } else if (line_speed[index] == 100) {
                  if (full_duplex[index]) {
                        pDevice->RequestedMediaType =
                            LM_REQUESTED_MEDIA_TYPE_UTP_100MBPS_FULL_DUPLEX;
                  } else {
                        pDevice->RequestedMediaType =
                            LM_REQUESTED_MEDIA_TYPE_UTP_100MBPS;
                  }
            } else if (line_speed[index] == 10) {
                  if (full_duplex[index]) {
                        pDevice->RequestedMediaType =
                            LM_REQUESTED_MEDIA_TYPE_UTP_10MBPS_FULL_DUPLEX;
                  } else {
                        pDevice->RequestedMediaType =
                            LM_REQUESTED_MEDIA_TYPE_UTP_10MBPS;
                  }
            } else {
                  pDevice->RequestedMediaType =
                      LM_REQUESTED_MEDIA_TYPE_AUTO;
                  pDevice->DisableAutoNeg = FALSE;
            }

      }
      pDevice->FlowControlCap = 0;
      if (rx_flow_control[index] != 0) {
            pDevice->FlowControlCap |= LM_FLOW_CONTROL_RECEIVE_PAUSE;
      }
      if (tx_flow_control[index] != 0) {
            pDevice->FlowControlCap |= LM_FLOW_CONTROL_TRANSMIT_PAUSE;
      }
      if ((auto_flow_control[index] != 0) &&
          (pDevice->DisableAutoNeg == FALSE)) {

            pDevice->FlowControlCap |= LM_FLOW_CONTROL_AUTO_PAUSE;
            if ((tx_flow_control[index] == 0) &&
                (rx_flow_control[index] == 0)) {
                  pDevice->FlowControlCap |=
                      LM_FLOW_CONTROL_TRANSMIT_PAUSE |
                      LM_FLOW_CONTROL_RECEIVE_PAUSE;
            }
      }

      /* Default MTU for now */
      pUmDevice->mtu = 1500;

#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
      if (pUmDevice->mtu > 1500) {
            pDevice->RxMtu = pUmDevice->mtu;
            pDevice->RxJumboDescCnt = DEFAULT_JUMBO_RCV_DESC_COUNT;
      } else {
            pDevice->RxJumboDescCnt = 0;
      }
      pDevice->RxJumboDescCnt = rx_jumbo_desc_cnt[index];
#else
      pDevice->RxMtu = pUmDevice->mtu;
#endif

      if (T3_ASIC_REV (pDevice->ChipRevId) == T3_ASIC_REV_5701) {
            pDevice->UseTaggedStatus = TRUE;
            pUmDevice->timer_interval = CONFIG_SYS_HZ;
      } else {
            pUmDevice->timer_interval = CONFIG_SYS_HZ / 50;
      }

      pDevice->TxPacketDescCnt = tx_pkt_desc_cnt[index];
      pDevice->RxStdDescCnt = rx_std_desc_cnt[index];
      /* Note:  adaptive coalescence really isn't adaptive in this driver */
      pUmDevice->rx_adaptive_coalesce = rx_adaptive_coalesce[index];
      if (!pUmDevice->rx_adaptive_coalesce) {
            pDevice->RxCoalescingTicks = rx_coalesce_ticks[index];
            if (pDevice->RxCoalescingTicks > MAX_RX_COALESCING_TICKS)
                  pDevice->RxCoalescingTicks = MAX_RX_COALESCING_TICKS;
            pUmDevice->rx_curr_coalesce_ticks = pDevice->RxCoalescingTicks;

            pDevice->RxMaxCoalescedFrames = rx_max_coalesce_frames[index];
            if (pDevice->RxMaxCoalescedFrames > MAX_RX_MAX_COALESCED_FRAMES)
                  pDevice->RxMaxCoalescedFrames =
                      MAX_RX_MAX_COALESCED_FRAMES;
            pUmDevice->rx_curr_coalesce_frames =
                pDevice->RxMaxCoalescedFrames;
            pDevice->StatsCoalescingTicks = stats_coalesce_ticks[index];
            if (pDevice->StatsCoalescingTicks > MAX_STATS_COALESCING_TICKS)
                  pDevice->StatsCoalescingTicks =
                      MAX_STATS_COALESCING_TICKS;
      } else {
            pUmDevice->rx_curr_coalesce_frames =
                DEFAULT_RX_MAX_COALESCED_FRAMES;
            pUmDevice->rx_curr_coalesce_ticks = DEFAULT_RX_COALESCING_TICKS;
      }
      pDevice->TxCoalescingTicks = tx_coalesce_ticks[index];
      if (pDevice->TxCoalescingTicks > MAX_TX_COALESCING_TICKS)
            pDevice->TxCoalescingTicks = MAX_TX_COALESCING_TICKS;
      pDevice->TxMaxCoalescedFrames = tx_max_coalesce_frames[index];
      if (pDevice->TxMaxCoalescedFrames > MAX_TX_MAX_COALESCED_FRAMES)
            pDevice->TxMaxCoalescedFrames = MAX_TX_MAX_COALESCED_FRAMES;

      if (enable_wol[index]) {
            pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_MAGIC_PACKET;
            pDevice->WakeUpMode = LM_WAKE_UP_MODE_MAGIC_PACKET;
      }
      pDevice->NicSendBd = TRUE;

      /* Don't update status blocks during interrupt */
      pDevice->RxCoalescingTicksDuringInt = 0;
      pDevice->TxCoalescingTicksDuringInt = 0;

      return LM_STATUS_SUCCESS;

}

LM_STATUS MM_StartTxDma (PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
{
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      printf ("Start TX DMA: dev=%d packet @0x%x\n",
            (int)pUmDevice->index, (unsigned int)pPacket);

      return LM_STATUS_SUCCESS;
}

LM_STATUS MM_CompleteTxDma (PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
{
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      printf ("Complete TX DMA: dev=%d packet @0x%x\n",
            (int)pUmDevice->index, (unsigned int)pPacket);
      return LM_STATUS_SUCCESS;
}

LM_STATUS MM_IndicateStatus (PLM_DEVICE_BLOCK pDevice, LM_STATUS Status)
{
      char buf[128];
      char lcd[4];
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      LM_FLOW_CONTROL flow_control;

      pUmDevice->delayed_link_ind = 0;
      memset (lcd, 0x0, 4);

      if (Status == LM_STATUS_LINK_DOWN) {
            sprintf (buf, "eth%d: %s: NIC Link is down\n",
                   pUmDevice->index, pUmDevice->name);
            lcd[0] = 'L';
            lcd[1] = 'N';
            lcd[2] = 'K';
            lcd[3] = '?';
      } else if (Status == LM_STATUS_LINK_ACTIVE) {
            sprintf (buf, "eth%d:%s: ", pUmDevice->index, pUmDevice->name);

            if (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS) {
                  strcat (buf, "1000 Mbps ");
                  lcd[0] = '1';
                  lcd[1] = 'G';
                  lcd[2] = 'B';
            } else if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS) {
                  strcat (buf, "100 Mbps ");
                  lcd[0] = '1';
                  lcd[1] = '0';
                  lcd[2] = '0';
            } else if (pDevice->LineSpeed == LM_LINE_SPEED_10MBPS) {
                  strcat (buf, "10 Mbps ");
                  lcd[0] = '1';
                  lcd[1] = '0';
                  lcd[2] = ' ';
            }
            if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL) {
                  strcat (buf, "full duplex");
                  lcd[3] = 'F';
            } else {
                  strcat (buf, "half duplex");
                  lcd[3] = 'H';
            }
            strcat (buf, " link up");

            flow_control = pDevice->FlowControl &
                (LM_FLOW_CONTROL_RECEIVE_PAUSE |
                 LM_FLOW_CONTROL_TRANSMIT_PAUSE);

            if (flow_control) {
                  if (flow_control & LM_FLOW_CONTROL_RECEIVE_PAUSE) {
                        strcat (buf, ", receive ");
                        if (flow_control &
                            LM_FLOW_CONTROL_TRANSMIT_PAUSE)
                              strcat (buf, " & transmit ");
                  } else {
                        strcat (buf, ", transmit ");
                  }
                  strcat (buf, "flow control ON");
            } else {
                  strcat (buf, ", flow control OFF");
            }
            strcat (buf, "\n");
            printf ("%s", buf);
      }
#if 0
      sysLedDsply (lcd[0], lcd[1], lcd[2], lcd[3]);
#endif
      return LM_STATUS_SUCCESS;
}

LM_STATUS MM_FreeRxBuffer (PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
{

      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      PUM_PACKET pUmPacket;
      void *skb;

      pUmPacket = (PUM_PACKET) pPacket;

      if ((skb = pUmPacket->skbuff))
            bcm570xPktFree (pUmDevice->index, skb);

      pUmPacket->skbuff = 0;

      return LM_STATUS_SUCCESS;
}

unsigned long MM_AnGetCurrentTime_us (PAN_STATE_INFO pAnInfo)
{
      return get_timer (0);
}

/*
 *   Transform an MBUF chain into a single MBUF.
 *   This routine will fail if the amount of data in the
 *   chain overflows a transmit buffer.  In that case,
 *   the incoming MBUF chain will be freed.  This routine can
 *   also fail by not being able to allocate a new MBUF (including
 *   cluster and mbuf headers).  In that case the failure is
 *   non-fatal.  The incoming cluster chain is not freed, giving
 *   the caller the choice of whether to try a retransmit later.
 */
LM_STATUS MM_CoalesceTxBuffer (PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
{
      PUM_PACKET pUmPacket = (PUM_PACKET) pPacket;
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      void *skbnew;
      int len = 0;

      if (len == 0)
            return (LM_STATUS_SUCCESS);

      if (len > MAX_PACKET_SIZE) {
            printf ("eth%d: xmit frame discarded, too big!, size = %d\n",
                  pUmDevice->index, len);
            return (LM_STATUS_FAILURE);
      }

      skbnew = bcm570xPktAlloc (pUmDevice->index, MAX_PACKET_SIZE);

      if (skbnew == NULL) {
            pUmDevice->tx_full = 1;
            printf ("eth%d: out of transmit buffers", pUmDevice->index);
            return (LM_STATUS_FAILURE);
      }

      /* New packet values */
      pUmPacket->skbuff = skbnew;
      pUmPacket->lm_packet.u.Tx.FragCount = 1;

      return (LM_STATUS_SUCCESS);
}

LM_STATUS MM_IndicateRxPackets (PLM_DEVICE_BLOCK pDevice)
{
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      pUmDevice->rx_pkt = 1;
      return LM_STATUS_SUCCESS;
}

LM_STATUS MM_IndicateTxPackets (PLM_DEVICE_BLOCK pDevice)
{
      PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
      PLM_PACKET pPacket;
      PUM_PACKET pUmPacket;
      void *skb;
      while (TRUE) {

            pPacket = (PLM_PACKET)
                QQ_PopHead (&pDevice->TxPacketXmittedQ.Container);

            if (pPacket == 0)
                  break;

            pUmPacket = (PUM_PACKET) pPacket;
            skb = (void *)pUmPacket->skbuff;

            /*
             * Free MBLK if we transmitted a fragmented packet or a
             * non-fragmented packet straight from the VxWorks
             * buffer pool. If packet was copied to a local transmit
             * buffer, then there's no MBUF to free, just free
             * the transmit buffer back to the cluster pool.
             */

            if (skb)
                  bcm570xPktFree (pUmDevice->index, skb);

            pUmPacket->skbuff = 0;
            QQ_PushTail (&pDevice->TxPacketFreeQ.Container, pPacket);
            pUmDevice->tx_pkt = 1;
      }
      if (pUmDevice->tx_full) {
            if (QQ_GetEntryCnt (&pDevice->TxPacketFreeQ.Container) >=
                (QQ_GetSize (&pDevice->TxPacketFreeQ.Container) >> 1))
                  pUmDevice->tx_full = 0;
      }
      return LM_STATUS_SUCCESS;
}

/*
 *  Scan an MBUF chain until we reach fragment number "frag"
 *  Return its length and physical address.
 */
void MM_MapTxDma
    (PLM_DEVICE_BLOCK pDevice,
     struct _LM_PACKET *pPacket,
     T3_64BIT_HOST_ADDR * paddr, LM_UINT32 * len, int frag) {
      PUM_PACKET pUmPacket = (PUM_PACKET) pPacket;
      *len = pPacket->PacketSize;
      MM_SetT3Addr (paddr, (dma_addr_t) pUmPacket->skbuff);
}

/*
 *  Convert an mbuf address, a CPU local virtual address,
 *  to a physical address as seen from a PCI device.  Store the
 *  result at paddr.
 */
void MM_MapRxDma (PLM_DEVICE_BLOCK pDevice,
              struct _LM_PACKET *pPacket, T3_64BIT_HOST_ADDR * paddr)
{
      PUM_PACKET pUmPacket = (PUM_PACKET) pPacket;
      MM_SetT3Addr (paddr, (dma_addr_t) pUmPacket->skbuff);
}

void MM_SetAddr (LM_PHYSICAL_ADDRESS * paddr, dma_addr_t addr)
{
#if (BITS_PER_LONG == 64)
      paddr->High = ((unsigned long)addr) >> 32;
      paddr->Low = ((unsigned long)addr) & 0xffffffff;
#else
      paddr->High = 0;
      paddr->Low = (unsigned long)addr;
#endif
}

void MM_SetT3Addr (T3_64BIT_HOST_ADDR * paddr, dma_addr_t addr)
{
      unsigned long baddr = (unsigned long)addr;
#if (BITS_PER_LONG == 64)
      set_64bit_addr (paddr, baddr & 0xffffffff, baddr >> 32);
#else
      set_64bit_addr (paddr, baddr, 0);
#endif
}

/*
 * This combination of `inline' and `extern' has almost the effect of a
 * macro.  The way to use it is to put a function definition in a header
 * file with these keywords, and put another copy of the definition
 * (lacking `inline' and `extern') in a library file.  The definition in
 * the header file will cause most calls to the function to be inlined.
 * If any uses of the function remain, they will refer to the single copy
 * in the library.
 */
void atomic_set (atomic_t * entry, int val)
{
      entry->counter = val;
}

int atomic_read (atomic_t * entry)
{
      return entry->counter;
}

void atomic_inc (atomic_t * entry)
{
      if (entry)
            entry->counter++;
}

void atomic_dec (atomic_t * entry)
{
      if (entry)
            entry->counter--;
}

void atomic_sub (int a, atomic_t * entry)
{
      if (entry)
            entry->counter -= a;
}

void atomic_add (int a, atomic_t * entry)
{
      if (entry)
            entry->counter += a;
}

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
void QQ_InitQueue (PQQ_CONTAINER pQueue, unsigned int QueueSize)
{
      pQueue->Head = 0;
      pQueue->Tail = 0;
      pQueue->Size = QueueSize + 1;
      atomic_set (&pQueue->EntryCnt, 0);
}                       /* QQ_InitQueue */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
char QQ_Full (PQQ_CONTAINER pQueue)
{
      unsigned int NewHead;

      NewHead = (pQueue->Head + 1) % pQueue->Size;

      return (NewHead == pQueue->Tail);
}                       /* QQ_Full */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
char QQ_Empty (PQQ_CONTAINER pQueue)
{
      return (pQueue->Head == pQueue->Tail);
}                       /* QQ_Empty */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
unsigned int QQ_GetSize (PQQ_CONTAINER pQueue)
{
      return pQueue->Size;
}                       /* QQ_GetSize */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
unsigned int QQ_GetEntryCnt (PQQ_CONTAINER pQueue)
{
      return atomic_read (&pQueue->EntryCnt);
}                       /* QQ_GetEntryCnt */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/*    TRUE entry was added successfully.                                      */
/*    FALSE queue is full.                                                    */
/******************************************************************************/
char QQ_PushHead (PQQ_CONTAINER pQueue, PQQ_ENTRY pEntry)
{
      unsigned int Head;

      Head = (pQueue->Head + 1) % pQueue->Size;

#if !defined(QQ_NO_OVERFLOW_CHECK)
      if (Head == pQueue->Tail) {
            return 0;
      }                 /* if */
#endif                        /* QQ_NO_OVERFLOW_CHECK */

      pQueue->Array[pQueue->Head] = pEntry;
      wmb ();
      pQueue->Head = Head;
      atomic_inc (&pQueue->EntryCnt);

      return -1;
}                       /* QQ_PushHead */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/*    TRUE entry was added successfully.                                      */
/*    FALSE queue is full.                                                    */
/******************************************************************************/
char QQ_PushTail (PQQ_CONTAINER pQueue, PQQ_ENTRY pEntry)
{
      unsigned int Tail;

      Tail = pQueue->Tail;
      if (Tail == 0) {
            Tail = pQueue->Size;
      }                 /* if */
      Tail--;

#if !defined(QQ_NO_OVERFLOW_CHECK)
      if (Tail == pQueue->Head) {
            return 0;
      }                 /* if */
#endif                        /* QQ_NO_OVERFLOW_CHECK */

      pQueue->Array[Tail] = pEntry;
      wmb ();
      pQueue->Tail = Tail;
      atomic_inc (&pQueue->EntryCnt);

      return -1;
}                       /* QQ_PushTail */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
PQQ_ENTRY QQ_PopHead (PQQ_CONTAINER pQueue)
{
      unsigned int Head;
      PQQ_ENTRY Entry;

      Head = pQueue->Head;

#if !defined(QQ_NO_UNDERFLOW_CHECK)
      if (Head == pQueue->Tail) {
            return (PQQ_ENTRY) 0;
      }                 /* if */
#endif                        /* QQ_NO_UNDERFLOW_CHECK */

      if (Head == 0) {
            Head = pQueue->Size;
      }                 /* if */
      Head--;

      Entry = pQueue->Array[Head];
      membar ();

      pQueue->Head = Head;
      atomic_dec (&pQueue->EntryCnt);

      return Entry;
}                       /* QQ_PopHead */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
PQQ_ENTRY QQ_PopTail (PQQ_CONTAINER pQueue)
{
      unsigned int Tail;
      PQQ_ENTRY Entry;

      Tail = pQueue->Tail;

#if !defined(QQ_NO_UNDERFLOW_CHECK)
      if (Tail == pQueue->Head) {
            return (PQQ_ENTRY) 0;
      }                 /* if */
#endif                        /* QQ_NO_UNDERFLOW_CHECK */

      Entry = pQueue->Array[Tail];
      membar ();
      pQueue->Tail = (Tail + 1) % pQueue->Size;
      atomic_dec (&pQueue->EntryCnt);

      return Entry;
}                       /* QQ_PopTail */

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
PQQ_ENTRY QQ_GetHead (PQQ_CONTAINER pQueue, unsigned int Idx)
{
      if (Idx >= atomic_read (&pQueue->EntryCnt)) {
            return (PQQ_ENTRY) 0;
      }

      if (pQueue->Head > Idx) {
            Idx = pQueue->Head - Idx;
      } else {
            Idx = pQueue->Size - (Idx - pQueue->Head);
      }
      Idx--;

      return pQueue->Array[Idx];
}

/******************************************************************************/
/* Description:                                                               */
/*                                                                            */
/* Return:                                                                    */
/******************************************************************************/
PQQ_ENTRY QQ_GetTail (PQQ_CONTAINER pQueue, unsigned int Idx)
{
      if (Idx >= atomic_read (&pQueue->EntryCnt)) {
            return (PQQ_ENTRY) 0;
      }

      Idx += pQueue->Tail;
      if (Idx >= pQueue->Size) {
            Idx = Idx - pQueue->Size;
      }

      return pQueue->Array[Idx];
}

Generated by  Doxygen 1.6.0   Back to index