[b44] Add driver for Broadcom bcm44xx cards
authorPantelis Koukousoulas <pktoss@gmail.com>
Fri, 21 Nov 2008 21:19:37 +0000 (23:19 +0200)
committerMichael Brown <mcb30@etherboot.org>
Fri, 21 Nov 2008 23:22:50 +0000 (23:22 +0000)
This driver is based on Stefan Hajnoczi's summer work, which
is in turn based on version 1.01 of the linux b44 driver.
I just assembled the pieces and fixed/added a few pieces
here and there to make it work for my hardware.

The most major limitation is that this driver won't work
on systems with >1GB RAM due to the card not having enough
address bits for that and gPXE not working around this
limitation.

Still, other than that the driver works well enough for
at least 2 users :) and the above limitation can always
be fixed when somebody wants it bad enough :)

Signed-off-by: Pantelis Koukousoulas <pktoss@gmail.com>
src/drivers/net/b44.c [new file with mode: 0644]
src/drivers/net/b44.h [new file with mode: 0644]
src/include/gpxe/errfile.h

diff --git a/src/drivers/net/b44.c b/src/drivers/net/b44.c
new file mode 100644 (file)
index 0000000..4c9c8e6
--- /dev/null
@@ -0,0 +1,949 @@
+/*
+ * Copyright (c) 2008 Stefan Hajnoczi <stefanha@gmail.com>
+ * Copyright (c) 2008 Pantelis Koukousoulas <pktoss@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * This driver is a port of the b44 linux driver version 1.01
+ *
+ * Copyright (c) 2002 David S. Miller <davem@redhat.com>
+ * Copyright (c) Pekka Pietikainen <pp@ee.oulu.fi>
+ * Copyright (C) 2006 Broadcom Corporation.
+ *
+ * Some ssb bits copied from version 2.0 of the b44 driver
+ * Copyright (c) Michael Buesch
+ *
+ * Copyright (c) a lot of people too. Please respect their work.
+ */
+
+#include <errno.h>
+#include <assert.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <byteswap.h>
+#include <gpxe/io.h>
+#include <mii.h>
+#include <gpxe/iobuf.h>
+#include <gpxe/malloc.h>
+#include <gpxe/pci.h>
+#include <gpxe/netdevice.h>
+#include <gpxe/ethernet.h>
+#include <gpxe/if_ether.h>
+#include <gpxe/memmap.h>
+#include "b44.h"
+
+
+static inline int ring_next(int index)
+{
+       /* B44_RING_SIZE is a power of 2 :) */
+       return (index + 1) & (B44_RING_SIZE - 1);
+}
+
+
+/* Memory-mapped I/O wrappers */
+
+static inline u32 br32(const struct b44_private *bp, u32 reg)
+{
+       return readl(bp->regs + reg);
+}
+
+
+static inline void bw32(const struct b44_private *bp, u32 reg, u32 val)
+{
+       writel(val, bp->regs + reg);
+}
+
+
+static inline void bflush(const struct b44_private *bp, u32 reg, u32 timeout)
+{
+       readl(bp->regs + reg);
+       udelay(timeout);
+}
+
+
+#define VIRT_TO_B44(addr)      ( virt_to_bus(addr) + SB_PCI_DMA )
+
+
+/**
+ * Return non-zero if the installed RAM is within
+ * the limit given and zero if it is outside.
+ * Hopefully will be removed soon.
+ */
+int phys_ram_within_limit(u64 limit)
+{
+       struct memory_map memmap;
+       struct memory_region *highest = NULL;
+       get_memmap(&memmap);
+
+       highest = &memmap.regions[memmap.count - 1];
+
+       return (highest->end < limit);
+}
+
+
+/**
+ * Ring cells waiting to be processed are between 'tx_cur' and 'pending'
+ * indexes in the ring.
+ */
+static u32 pending_tx_index(struct b44_private *bp)
+{
+       u32 pending = br32(bp, B44_DMATX_STAT);
+       pending &= DMATX_STAT_CDMASK;
+
+       pending /= sizeof(struct dma_desc);
+       return pending & (B44_RING_SIZE - 1);
+}
+
+
+/**
+ * Ring cells waiting to be processed are between 'rx_cur' and 'pending'
+ * indexes in the ring.
+ */
+static u32 pending_rx_index(struct b44_private *bp)
+{
+       u32 pending = br32(bp, B44_DMARX_STAT);
+       pending &= DMARX_STAT_CDMASK;
+
+       pending /= sizeof(struct dma_desc);
+       return pending & (B44_RING_SIZE - 1);
+}
+
+
+/**
+ * Wait until the given bit is set/cleared.
+ */
+static int b44_wait_bit(struct b44_private *bp, unsigned long reg, u32 bit,
+                                   unsigned long timeout, const int clear)
+{
+       unsigned long i;
+
+       for (i = 0; i < timeout; i++) {
+               u32 val = br32(bp, reg);
+
+               if (clear && !(val & bit))
+                       break;
+
+               if (!clear && (val & bit))
+                       break;
+
+               udelay(10);
+       }
+       if (i == timeout) {
+               return -ENODEV;
+       }
+       return 0;
+}
+
+
+/*
+ * Sonics Silicon Backplane support. SSB is a mini-bus interconnecting
+ * so-called IP Cores. One of those cores implements the Fast Ethernet
+ * functionality and another one the PCI engine.
+ *
+ * You need to switch to the core you want to talk to before actually
+ * sending commands.
+ *
+ * See: http://bcm-v4.sipsolutions.net/Backplane for (reverse-engineered)
+ * specs.
+ */
+
+static inline u32 ssb_get_core_rev(struct b44_private *bp)
+{
+       return (br32(bp, B44_SBIDHIGH) & SBIDHIGH_RC_MASK);
+}
+
+
+static inline int ssb_is_core_up(struct b44_private *bp)
+{
+       return ((br32(bp, B44_SBTMSLOW) & (SSB_CORE_DOWN | SBTMSLOW_CLOCK))
+                                                       == SBTMSLOW_CLOCK);
+}
+
+
+static u32 ssb_pci_setup(struct b44_private *bp, u32 cores)
+{
+       u32 bar_orig, pci_rev, val;
+
+       pci_read_config_dword(bp->pci, SSB_BAR0_WIN, &bar_orig);
+       pci_write_config_dword(bp->pci, SSB_BAR0_WIN,
+                              BCM4400_PCI_CORE_ADDR);
+       pci_rev = ssb_get_core_rev(bp);
+
+       val = br32(bp, B44_SBINTVEC);
+       val |= cores;
+       bw32(bp, B44_SBINTVEC, val);
+
+       val = br32(bp, SSB_PCI_TRANS_2);
+       val |= SSB_PCI_PREF | SSB_PCI_BURST;
+       bw32(bp, SSB_PCI_TRANS_2, val);
+
+       pci_write_config_dword(bp->pci, SSB_BAR0_WIN, bar_orig);
+
+       return pci_rev;
+}
+
+
+static void ssb_core_disable(struct b44_private *bp)
+{
+       if (br32(bp, B44_SBTMSLOW) & SBTMSLOW_RESET)
+               return;
+
+       bw32(bp, B44_SBTMSLOW, (SBTMSLOW_REJECT | SBTMSLOW_CLOCK));
+       b44_wait_bit(bp, B44_SBTMSLOW, SBTMSLOW_REJECT, 100000, 0);
+       b44_wait_bit(bp, B44_SBTMSHIGH, SBTMSHIGH_BUSY, 100000, 1);
+
+       bw32(bp, B44_SBTMSLOW, (SBTMSLOW_FGC | SBTMSLOW_CLOCK |
+                                               SSB_CORE_DOWN));
+       bflush(bp, B44_SBTMSLOW, 1);
+
+       bw32(bp, B44_SBTMSLOW, SSB_CORE_DOWN);
+       bflush(bp, B44_SBTMSLOW, 1);
+}
+
+
+static void ssb_core_reset(struct b44_private *bp)
+{
+       u32 val;
+       const u32 mask = (SBTMSLOW_CLOCK | SBTMSLOW_FGC | SBTMSLOW_RESET);
+
+       ssb_core_disable(bp);
+
+       bw32(bp, B44_SBTMSLOW, mask);
+       bflush(bp, B44_SBTMSLOW, 1);
+
+       /* Clear SERR if set, this is a hw bug workaround.  */
+       if (br32(bp, B44_SBTMSHIGH) & SBTMSHIGH_SERR)
+               bw32(bp, B44_SBTMSHIGH, 0);
+
+       val = br32(bp, B44_SBIMSTATE);
+       if (val & (SBIMSTATE_BAD)) {
+               bw32(bp, B44_SBIMSTATE, val & ~SBIMSTATE_BAD);
+       }
+
+       bw32(bp, B44_SBTMSLOW, (SBTMSLOW_CLOCK | SBTMSLOW_FGC));
+       bflush(bp, B44_SBTMSLOW, 1);
+
+       bw32(bp, B44_SBTMSLOW, (SBTMSLOW_CLOCK));
+       bflush(bp, B44_SBTMSLOW, 1);
+}
+
+
+/*
+ * Driver helper functions
+ */
+
+/*
+ * Chip reset provides power to the b44 MAC & PCI cores, which
+ * is necessary for MAC register access. We only do a partial
+ * reset in case of transmit/receive errors (ISTAT_ERRORS) to
+ * avoid the chip being hung for an unnecessary long time in
+ * this case.
+ *
+ * Called-by: b44_close, b44_halt, b44_inithw(b44_open), b44_probe
+ */
+static void b44_chip_reset(struct b44_private *bp, int reset_kind)
+{
+       if (ssb_is_core_up(bp)) {
+               bw32(bp, B44_RCV_LAZY, 0);
+
+               bw32(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE);
+
+               b44_wait_bit(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE, 200, 1);
+
+               bw32(bp, B44_DMATX_CTRL, 0);
+
+               bp->tx_dirty = bp->tx_cur = 0;
+
+               if (br32(bp, B44_DMARX_STAT) & DMARX_STAT_EMASK)
+                       b44_wait_bit(bp, B44_DMARX_STAT, DMARX_STAT_SIDLE,
+                                                                 100, 0);
+
+               bw32(bp, B44_DMARX_CTRL, 0);
+
+               bp->rx_cur = 0;
+       } else {
+               ssb_pci_setup(bp, SBINTVEC_ENET0);
+       }
+
+       ssb_core_reset(bp);
+
+       /* Don't enable PHY if we are only doing a partial reset. */
+       if (reset_kind == B44_CHIP_RESET_PARTIAL)
+               return;
+
+       /* Make PHY accessible. */
+       bw32(bp, B44_MDIO_CTRL,
+            (MDIO_CTRL_PREAMBLE | (0x0d & MDIO_CTRL_MAXF_MASK)));
+       bflush(bp, B44_MDIO_CTRL, 1);
+
+       /* Enable internal or external PHY */
+       if (!(br32(bp, B44_DEVCTRL) & DEVCTRL_IPP)) {
+               bw32(bp, B44_ENET_CTRL, ENET_CTRL_EPSEL);
+               bflush(bp, B44_ENET_CTRL, 1);
+       } else {
+               u32 val = br32(bp, B44_DEVCTRL);
+               if (val & DEVCTRL_EPR) {
+                       bw32(bp, B44_DEVCTRL, (val & ~DEVCTRL_EPR));
+                       bflush(bp, B44_DEVCTRL, 100);
+               }
+       }
+}
+
+
+/**
+ * called by b44_poll in the error path
+ */
+static void b44_halt(struct b44_private *bp)
+{
+       /* disable ints */
+       bw32(bp, B44_IMASK, 0);
+       bflush(bp, B44_IMASK, 1);
+
+       DBG("b44: powering down PHY\n");
+       bw32(bp, B44_MAC_CTRL, MAC_CTRL_PHY_PDOWN);
+
+       /*
+        * Now reset the chip, but without enabling
+        * the MAC&PHY part of it.
+        * This has to be done _after_ we shut down the PHY
+        */
+       b44_chip_reset(bp, B44_CHIP_RESET_PARTIAL);
+}
+
+
+
+/*
+ * Called at device open time to get the chip ready for
+ * packet processing.
+ *
+ * Called-by: b44_open
+ */
+static void b44_init_hw(struct b44_private *bp, int reset_kind)
+{
+       u32 val;
+#define CTRL_MASK (DMARX_CTRL_ENABLE | (RX_PKT_OFFSET << DMARX_CTRL_ROSHIFT))
+
+       b44_chip_reset(bp, B44_CHIP_RESET_FULL);
+       if (reset_kind == B44_FULL_RESET) {
+               b44_phy_reset(bp);
+       }
+
+       /* Enable CRC32, set proper LED modes and power on PHY */
+       bw32(bp, B44_MAC_CTRL, MAC_CTRL_CRC32_ENAB | MAC_CTRL_PHY_LEDCTRL);
+       bw32(bp, B44_RCV_LAZY, (1 << RCV_LAZY_FC_SHIFT));
+
+       /* This sets the MAC address too.  */
+       b44_set_rx_mode(bp->netdev);
+
+       /* MTU + eth header + possible VLAN tag + struct rx_header */
+       bw32(bp, B44_RXMAXLEN, B44_MAX_MTU + ETH_HLEN + 8 + RX_HEADER_LEN);
+       bw32(bp, B44_TXMAXLEN, B44_MAX_MTU + ETH_HLEN + 8 + RX_HEADER_LEN);
+
+       bw32(bp, B44_TX_HIWMARK, TX_HIWMARK_DEFLT);
+       if (reset_kind == B44_PARTIAL_RESET) {
+               bw32(bp, B44_DMARX_CTRL, CTRL_MASK);
+       } else {
+               bw32(bp, B44_DMATX_CTRL, DMATX_CTRL_ENABLE);
+               bw32(bp, B44_DMATX_ADDR, VIRT_TO_B44(bp->tx));
+
+               bw32(bp, B44_DMARX_CTRL, CTRL_MASK);
+               bw32(bp, B44_DMARX_ADDR, VIRT_TO_B44(bp->rx));
+               bw32(bp, B44_DMARX_PTR, B44_RX_RING_LEN_BYTES);
+
+               bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
+       }
+
+       val = br32(bp, B44_ENET_CTRL);
+       bw32(bp, B44_ENET_CTRL, (val | ENET_CTRL_ENABLE));
+#undef CTRL_MASK
+}
+
+
+/***  Management of ring descriptors  ***/
+
+
+static void b44_populate_rx_descriptor(struct b44_private *bp, u32 idx)
+{
+       struct rx_header *rh;
+       u32 ctrl, addr;
+
+       rh = bp->rx_iobuf[idx]->data;
+       rh->len = 0;
+       rh->flags = 0;
+       ctrl = DESC_CTRL_LEN & (RX_PKT_BUF_SZ - RX_PKT_OFFSET);
+       if (idx == B44_RING_LAST) {
+               ctrl |= DESC_CTRL_EOT;
+       }
+       addr = VIRT_TO_B44(bp->rx_iobuf[idx]->data);
+
+       bp->rx[idx].ctrl = cpu_to_le32(ctrl);
+       bp->rx[idx].addr = cpu_to_le32(addr);
+       bw32(bp, B44_DMARX_PTR, idx * sizeof(struct dma_desc));
+}
+
+
+/*
+ * Refill RX ring descriptors with buffers. This is needed
+ * because during rx we are passing ownership of descriptor
+ * buffers to the network stack.
+ */
+static void b44_rx_refill(struct b44_private *bp, u32 pending)
+{
+       u32 i;
+
+       // skip pending
+       for (i = pending + 1; i != bp->rx_cur; i = ring_next(i)) {
+               if (bp->rx_iobuf[i] != NULL)
+                       continue;
+
+               bp->rx_iobuf[i] = alloc_iob(RX_PKT_BUF_SZ);
+               if (!bp->rx_iobuf[i]) {
+                       DBG("Refill rx ring failed!!\n");
+                       break;
+               }
+
+               b44_populate_rx_descriptor(bp, i);
+       }
+}
+
+
+static void b44_free_rx_ring(struct b44_private *bp)
+{
+       u32 i;
+
+       if (bp->rx) {
+               for (i = 0; i < B44_RING_SIZE; i++) {
+                       free_iob(bp->rx_iobuf[i]);
+                       bp->rx_iobuf[i] = NULL;
+               }
+               free_dma(bp->rx, B44_RX_RING_LEN_BYTES);
+               bp->rx = NULL;
+       }
+}
+
+
+static int b44_init_rx_ring(struct b44_private *bp)
+{
+       b44_free_rx_ring(bp);
+
+       bp->rx = malloc_dma(B44_RX_RING_LEN_BYTES, B44_DMA_ALIGNMENT);
+       if (!bp->rx)
+               return -ENOMEM;
+
+       memset(bp->rx_iobuf, 0, sizeof(bp->rx_iobuf));
+
+       bp->rx_iobuf[0] = alloc_iob(RX_PKT_BUF_SZ);
+       b44_populate_rx_descriptor(bp, 0);
+       b44_rx_refill(bp, 0);
+
+       DBG("Init RX rings: rx=0x%08lx\n", VIRT_TO_B44(bp->rx));
+       return 0;
+}
+
+
+static void b44_free_tx_ring(struct b44_private *bp)
+{
+       if (bp->tx) {
+               free_dma(bp->tx, B44_TX_RING_LEN_BYTES);
+               bp->tx = NULL;
+       }
+}
+
+
+static int b44_init_tx_ring(struct b44_private *bp)
+{
+       b44_free_tx_ring(bp);
+
+       bp->tx = malloc_dma(B44_TX_RING_LEN_BYTES, B44_DMA_ALIGNMENT);
+       if (!bp->tx)
+               return -ENOMEM;
+
+       memset(bp->tx, 0, B44_TX_RING_LEN_BYTES);
+       memset(bp->tx_iobuf, 0, sizeof(bp->tx_iobuf));
+
+       DBG("Init TX rings: tx=0x%08lx\n", VIRT_TO_B44(bp->tx));
+       return 0;
+}
+
+
+/*** Interaction with the PHY ***/
+
+
+static int b44_phy_read(struct b44_private *bp, int reg, u32 * val)
+{
+       int err;
+
+       u32 arg1 = (MDIO_OP_READ << MDIO_DATA_OP_SHIFT);
+       u32 arg2 = (bp->phy_addr << MDIO_DATA_PMD_SHIFT);
+       u32 arg3 = (reg << MDIO_DATA_RA_SHIFT);
+       u32 arg4 = (MDIO_TA_VALID << MDIO_DATA_TA_SHIFT);
+       u32 argv = arg1 | arg2 | arg3 | arg4;
+
+       bw32(bp, B44_EMAC_ISTAT, EMAC_INT_MII);
+       bw32(bp, B44_MDIO_DATA, (MDIO_DATA_SB_START | argv));
+       err = b44_wait_bit(bp, B44_EMAC_ISTAT, EMAC_INT_MII, 100, 0);
+       *val = br32(bp, B44_MDIO_DATA) & MDIO_DATA_DATA;
+
+       return err;
+}
+
+
+static int b44_phy_write(struct b44_private *bp, int reg, u32 val)
+{
+       u32 arg1 = (MDIO_OP_WRITE << MDIO_DATA_OP_SHIFT);
+       u32 arg2 = (bp->phy_addr << MDIO_DATA_PMD_SHIFT);
+       u32 arg3 = (reg << MDIO_DATA_RA_SHIFT);
+       u32 arg4 = (MDIO_TA_VALID << MDIO_DATA_TA_SHIFT);
+       u32 arg5 = (val & MDIO_DATA_DATA);
+       u32 argv = arg1 | arg2 | arg3 | arg4 | arg5;
+
+
+       bw32(bp, B44_EMAC_ISTAT, EMAC_INT_MII);
+       bw32(bp, B44_MDIO_DATA, (MDIO_DATA_SB_START | argv));
+       return b44_wait_bit(bp, B44_EMAC_ISTAT, EMAC_INT_MII, 100, 0);
+}
+
+
+static int b44_phy_reset(struct b44_private *bp)
+{
+       u32 val;
+       int err;
+
+       err = b44_phy_write(bp, MII_BMCR, BMCR_RESET);
+       if (err)
+               return err;
+
+       udelay(100);
+       err = b44_phy_read(bp, MII_BMCR, &val);
+       if (!err) {
+               if (val & BMCR_RESET) {
+                       return -ENODEV;
+               }
+       }
+
+       return 0;
+}
+
+
+/*
+ * The BCM44xx CAM (Content Addressable Memory) stores the MAC
+ * and PHY address.
+ */
+static void b44_cam_write(struct b44_private *bp, unsigned char *data,
+                                                           int index)
+{
+       u32 val;
+
+       val  = ((u32) data[2]) << 24;
+       val |= ((u32) data[3]) << 16;
+       val |= ((u32) data[4]) << 8;
+       val |= ((u32) data[5]) << 0;
+       bw32(bp, B44_CAM_DATA_LO, val);
+
+
+       val = (CAM_DATA_HI_VALID |
+              (((u32) data[0]) << 8) | (((u32) data[1]) << 0));
+
+       bw32(bp, B44_CAM_DATA_HI, val);
+
+       val = CAM_CTRL_WRITE | (index << CAM_CTRL_INDEX_SHIFT);
+       bw32(bp, B44_CAM_CTRL, val);
+
+       b44_wait_bit(bp, B44_CAM_CTRL, CAM_CTRL_BUSY, 100, 1);
+}
+
+
+static void b44_set_mac_addr(struct b44_private *bp)
+{
+       u32 val;
+       bw32(bp, B44_CAM_CTRL, 0);
+       b44_cam_write(bp, bp->netdev->ll_addr, 0);
+       val = br32(bp, B44_CAM_CTRL);
+       bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE);
+}
+
+
+/* Read 128-bytes of EEPROM. */
+static void b44_read_eeprom(struct b44_private *bp, u8 * data)
+{
+       long i;
+       u16 *ptr = (u16 *) data;
+
+       for (i = 0; i < 128; i += 2)
+               ptr[i / 2] = cpu_to_le16(readw(bp->regs + 4096 + i));
+}
+
+
+static void b44_load_mac_and_phy_addr(struct b44_private *bp)
+{
+       u8 eeprom[128];
+
+       /* Load MAC address, note byteswapping */
+       b44_read_eeprom(bp, &eeprom[0]);
+       bp->netdev->ll_addr[0] = eeprom[79];
+       bp->netdev->ll_addr[1] = eeprom[78];
+       bp->netdev->ll_addr[2] = eeprom[81];
+       bp->netdev->ll_addr[3] = eeprom[80];
+       bp->netdev->ll_addr[4] = eeprom[83];
+       bp->netdev->ll_addr[5] = eeprom[82];
+
+       /* Load PHY address */
+       bp->phy_addr = eeprom[90] & 0x1f;
+}
+
+
+static void b44_set_rx_mode(struct net_device *netdev)
+{
+       struct b44_private *bp = netdev_priv(netdev);
+       unsigned char zero[6] = { 0, 0, 0, 0, 0, 0 };
+       u32 val;
+       int i;
+
+       val = br32(bp, B44_RXCONFIG);
+       val &= ~RXCONFIG_PROMISC;
+       val |= RXCONFIG_ALLMULTI;
+
+       b44_set_mac_addr(bp);
+
+       for (i = 1; i < 64; i++)
+               b44_cam_write(bp, zero, i);
+
+       bw32(bp, B44_RXCONFIG, val);
+       val = br32(bp, B44_CAM_CTRL);
+       bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE);
+}
+
+
+/*** Implementation of gPXE driver callbacks ***/
+
+/**
+ * Probe device
+ *
+ * @v pci      PCI device
+ * @v id       Matching entry in ID table
+ * @ret rc     Return status code
+ */
+static int b44_probe(struct pci_device *pci, const struct pci_device_id *id)
+{
+       struct net_device *netdev;
+       struct b44_private *bp;
+       int rc;
+
+       /*
+        * Bail out if more than 1GB of physical RAM is installed.
+        * This limitation will be removed later when dma mapping
+        * is merged into mainline.
+        */
+       if (!phys_ram_within_limit(B44_30BIT_DMA_MASK)) {
+               DBG("Sorry, this version of the driver does not\n"
+                   "support systems with more than 1GB of RAM.\n");
+               return -ENOMEM;
+       }
+
+       /* Set up netdev */
+       netdev = alloc_etherdev(sizeof(*bp));
+       if (!netdev)
+               return -ENOMEM;
+
+       netdev_init(netdev, &b44_operations);
+       pci_set_drvdata(pci, netdev);
+       netdev->dev = &pci->dev;
+
+       /* Set up private data */
+       bp = netdev_priv(netdev);
+       memset(bp, 0, sizeof(*bp));
+       bp->netdev = netdev;
+       bp->pci = pci;
+
+       /* Map device registers */
+       bp->regs = ioremap(pci->membase, B44_REGS_SIZE);
+       if (!bp->regs) {
+               netdev_put(netdev);
+               return -ENOMEM;
+       }
+
+       /* Enable PCI bus mastering */
+       adjust_pci_device(pci);
+
+       b44_load_mac_and_phy_addr(bp);
+
+       /* Link management currently not implemented */
+       netdev_link_up(netdev);
+
+       rc = register_netdev(netdev);
+       if (rc != 0) {
+               iounmap(bp->regs);
+               netdev_put(netdev);
+               return rc;
+       }
+
+       b44_chip_reset(bp, B44_CHIP_RESET_FULL);
+
+       DBG("b44 %s (%04x:%04x) regs=%p MAC=%s\n", id->name, id->vendor,
+           id->device, bp->regs, eth_ntoa(netdev->ll_addr));
+
+       return 0;
+}
+
+
+/**
+ * Remove device
+ *
+ * @v pci      PCI device
+ */
+static void b44_remove(struct pci_device *pci)
+{
+       struct net_device *netdev = pci_get_drvdata(pci);
+       struct b44_private *bp = netdev_priv(netdev);
+
+       ssb_core_disable(bp);
+       unregister_netdev(netdev);
+       iounmap(bp->regs);
+       netdev_nullify(netdev);
+       netdev_put(netdev);
+}
+
+
+/** Enable or disable interrupts
+ *
+ * @v netdev   Network device
+ * @v enable   Interrupts should be enabled
+ */
+static void b44_irq(struct net_device *netdev, int enable)
+{
+       struct b44_private *bp = netdev_priv(netdev);
+
+       /* Interrupt mask specifies which events generate interrupts */
+       bw32(bp, B44_IMASK, enable ? IMASK_DEF : IMASK_DISABLE);
+}
+
+
+/** Open network device
+ *
+ * @v netdev   Network device
+ * @ret rc     Return status code
+ */
+static int b44_open(struct net_device *netdev)
+{
+       struct b44_private *bp = netdev_priv(netdev);
+       int rc;
+
+       rc = b44_init_tx_ring(bp);
+       if (rc != 0)
+               return rc;
+
+       rc = b44_init_rx_ring(bp);
+       if (rc != 0)
+               return rc;
+
+       b44_init_hw(bp, B44_FULL_RESET);
+
+       /* Disable interrupts */
+       b44_irq(netdev, 0);
+
+       return 0;
+}
+
+
+/** Close network device
+ *
+ * @v netdev   Network device
+ */
+static void b44_close(struct net_device *netdev)
+{
+       struct b44_private *bp = netdev_priv(netdev);
+
+       b44_chip_reset(bp, B44_FULL_RESET);
+       b44_free_tx_ring(bp);
+       b44_free_rx_ring(bp);
+}
+
+
+/** Transmit packet
+ *
+ * @v netdev   Network device
+ * @v iobuf    I/O buffer
+ * @ret rc     Return status code
+ */
+static int b44_transmit(struct net_device *netdev, struct io_buffer *iobuf)
+{
+       struct b44_private *bp = netdev_priv(netdev);
+       u32 cur = bp->tx_cur;
+       u32 ctrl;
+
+       /* Check for TX ring overflow */
+       if (bp->tx[cur].ctrl) {
+               DBG("tx overflow\n");
+               return -ENOBUFS;
+       }
+
+       /* Will call netdev_tx_complete() on the iobuf later */
+       bp->tx_iobuf[cur] = iobuf;
+
+       /* Set up TX descriptor */
+       ctrl = (iob_len(iobuf) & DESC_CTRL_LEN) |
+           DESC_CTRL_IOC | DESC_CTRL_SOF | DESC_CTRL_EOF;
+
+       if (cur == B44_RING_LAST)
+               ctrl |= DESC_CTRL_EOT;
+
+       bp->tx[cur].ctrl = cpu_to_le32(ctrl);
+       bp->tx[cur].addr = cpu_to_le32(VIRT_TO_B44(iobuf->data));
+
+       /* Update next available descriptor index */
+       cur = ring_next(cur);
+       bp->tx_cur = cur;
+       wmb();
+
+       /* Tell card that a new TX descriptor is ready */
+       bw32(bp, B44_DMATX_PTR, cur * sizeof(struct dma_desc));
+       return 0;
+}
+
+
+/** Recycles sent TX descriptors and notifies network stack
+ *
+ * @v bp Driver state
+ */
+static void b44_tx_complete(struct b44_private *bp)
+{
+       u32 cur, i;
+
+       cur = pending_tx_index(bp);
+
+       for (i = bp->tx_dirty; i != cur; i = ring_next(i)) {
+               /* Free finished frame */
+               netdev_tx_complete(bp->netdev, bp->tx_iobuf[i]);
+               bp->tx_iobuf[i] = NULL;
+
+               /* Clear TX descriptor */
+               bp->tx[i].ctrl = 0;
+               bp->tx[i].addr = 0;
+       }
+       bp->tx_dirty = cur;
+}
+
+
+static void b44_process_rx_packets(struct b44_private *bp)
+{
+       struct io_buffer *iob;  /* received data */
+       struct rx_header *rh;
+       u32 pending, i;
+       u16 len;
+
+       pending = pending_rx_index(bp);
+
+       for (i = bp->rx_cur; i != pending; i = ring_next(i)) {
+               iob = bp->rx_iobuf[i];
+               if (iob == NULL)
+                       break;
+
+               rh = iob->data;
+               len = le16_to_cpu(rh->len);
+
+               /*
+                * Guard against incompletely written RX descriptors.
+                * Without this, things can get really slow!
+                */
+               if (len == 0)
+                       break;
+
+               /* Discard CRC that is generated by the card */
+               len -= 4;
+
+               /* Check for invalid packets and errors */
+               if (len > RX_PKT_BUF_SZ - RX_PKT_OFFSET ||
+                   (rh->flags & cpu_to_le16(RX_FLAG_ERRORS))) {
+                       DBG("rx error len=%d flags=%04x\n", len,
+                                        cpu_to_le16(rh->flags));
+                       rh->len = 0;
+                       rh->flags = 0;
+                       netdev_rx_err(bp->netdev, iob, -EINVAL);
+                       continue;
+               }
+
+               /* Clear RX descriptor */
+               rh->len = 0;
+               rh->flags = 0;
+               bp->rx_iobuf[i] = NULL;
+
+               /* Hand off the IO buffer to the network stack */
+               iob_reserve(iob, RX_PKT_OFFSET);
+               iob_put(iob, len);
+               netdev_rx(bp->netdev, iob);
+       }
+       bp->rx_cur = i;
+       b44_rx_refill(bp, pending_rx_index(bp));
+}
+
+
+/** Poll for completed and received packets
+ *
+ * @v netdev   Network device
+ */
+static void b44_poll(struct net_device *netdev)
+{
+       struct b44_private *bp = netdev_priv(netdev);
+       u32 istat;
+
+       /* Interrupt status */
+       istat = br32(bp, B44_ISTAT);
+       istat &= IMASK_DEF;     /* only the events we care about */
+
+       if (!istat)
+               return;
+       if (istat & ISTAT_TX)
+               b44_tx_complete(bp);
+       if (istat & ISTAT_RX)
+               b44_process_rx_packets(bp);
+       if (istat & ISTAT_ERRORS) {
+               DBG("b44 error istat=0x%08x\n", istat);
+
+               /* Reset B44 core partially to avoid long waits */
+               b44_irq(bp->netdev, 0);
+               b44_halt(bp);
+               b44_init_tx_ring(bp);
+               b44_init_rx_ring(bp);
+               b44_init_hw(bp, B44_FULL_RESET_SKIP_PHY);
+       }
+
+       /* Acknowledge interrupt */
+       bw32(bp, B44_ISTAT, 0);
+       bflush(bp, B44_ISTAT, 1);
+}
+
+
+static struct net_device_operations b44_operations = {
+       .open = b44_open,
+       .close = b44_close,
+       .transmit = b44_transmit,
+       .poll = b44_poll,
+       .irq = b44_irq,
+};
+
+
+static struct pci_device_id b44_nics[] = {
+       PCI_ROM(0x14e4, 0x4401, "BCM4401", "BCM4401"),
+       PCI_ROM(0x14e4, 0x170c, "BCM4401-B0", "BCM4401-B0"),
+       PCI_ROM(0x14e4, 0x4402, "BCM4401-B1", "BCM4401-B1"),
+};
+
+
+struct pci_driver b44_driver __pci_driver = {
+       .ids = b44_nics,
+       .id_count = sizeof b44_nics / sizeof b44_nics[0],
+       .probe = b44_probe,
+       .remove = b44_remove,
+};
diff --git a/src/drivers/net/b44.h b/src/drivers/net/b44.h
new file mode 100644 (file)
index 0000000..fb36757
--- /dev/null
@@ -0,0 +1,467 @@
+/*
+ * Copyright (c) 2008 Stefan Hajnoczi <stefanha@gmail.com>
+ * Copyright (c) 2008 Pantelis Koukousoulas <pktoss@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * This driver is a port of the b44 linux driver version 1.01
+ *
+ * Copyright (c) 2002 David S. Miller <davem@redhat.com>
+ * Copyright (c) Pekka Pietikainen <pp@ee.oulu.fi>
+ * Copyright (C) 2006 Broadcom Corporation.
+ *
+ * Some ssb bits copied from version 2.0 of the b44 driver
+ * Copyright (c) Michael Buesch
+ *
+ * Copyright (c) a lot of people too. Please respect their work.
+ */
+#ifndef _B44_H
+#define _B44_H
+
+/* BCM44xx Register layout */
+#define        B44_DEVCTRL             0x0000UL /* Device Control */
+#define  DEVCTRL_MPM           0x00000040 /* MP PME Enable (B0 only) */
+#define  DEVCTRL_PFE           0x00000080 /* Pattern Filtering Enable */
+#define  DEVCTRL_IPP           0x00000400 /* Internal EPHY Present */
+#define  DEVCTRL_EPR           0x00008000 /* EPHY Reset */
+#define  DEVCTRL_PME           0x00001000 /* PHY Mode Enable */
+#define  DEVCTRL_PMCE          0x00002000 /* PHY Mode Clocks Enable */
+#define  DEVCTRL_PADDR         0x0007c000 /* PHY Address */
+#define  DEVCTRL_PADDR_SHIFT   18
+#define B44_BIST_STAT          0x000CUL /* Built-In Self-Test Status */
+#define B44_WKUP_LEN           0x0010UL /* Wakeup Length */
+#define  WKUP_LEN_P0_MASK      0x0000007f /* Pattern 0 */
+#define  WKUP_LEN_D0           0x00000080
+#define  WKUP_LEN_P1_MASK      0x00007f00 /* Pattern 1 */
+#define  WKUP_LEN_P1_SHIFT     8
+#define  WKUP_LEN_D1           0x00008000
+#define  WKUP_LEN_P2_MASK      0x007f0000 /* Pattern 2 */
+#define  WKUP_LEN_P2_SHIFT     16
+#define  WKUP_LEN_D2           0x00000000
+#define  WKUP_LEN_P3_MASK      0x7f000000 /* Pattern 3 */
+#define  WKUP_LEN_P3_SHIFT     24
+#define  WKUP_LEN_D3           0x80000000
+#define  WKUP_LEN_DISABLE      0x80808080
+#define  WKUP_LEN_ENABLE_TWO   0x80800000
+#define  WKUP_LEN_ENABLE_THREE 0x80000000
+#define B44_ISTAT              0x0020UL /* Interrupt Status */
+#define  ISTAT_LS              0x00000020 /* Link Change (B0 only) */
+#define  ISTAT_PME             0x00000040 /* Power Management Event */
+#define  ISTAT_TO              0x00000080 /* General Purpose Timeout */
+#define  ISTAT_DSCE            0x00000400 /* Descriptor Error */
+#define  ISTAT_DATAE           0x00000800 /* Data Error */
+#define  ISTAT_DPE             0x00001000 /* Descr. Protocol Error */
+#define  ISTAT_RDU             0x00002000 /* Receive Descr. Underflow */
+#define  ISTAT_RFO             0x00004000 /* Receive FIFO Overflow */
+#define  ISTAT_TFU             0x00008000 /* Transmit FIFO Underflow */
+#define  ISTAT_RX              0x00010000 /* RX Interrupt */
+#define  ISTAT_TX              0x01000000 /* TX Interrupt */
+#define  ISTAT_EMAC            0x04000000 /* EMAC Interrupt */
+#define  ISTAT_MII_WRITE       0x08000000 /* MII Write Interrupt */
+#define  ISTAT_MII_READ                0x10000000 /* MII Read Interrupt */
+#define  ISTAT_ERRORS           (ISTAT_DSCE|ISTAT_DATAE|ISTAT_DPE|\
+                                 ISTAT_RDU|ISTAT_RFO|ISTAT_TFU)
+#define B44_IMASK              0x0024UL /* Interrupt Mask */
+#define  IMASK_DEF             (ISTAT_ERRORS | ISTAT_RX | ISTAT_TX)
+#define  IMASK_DISABLE          0
+#define B44_GPTIMER            0x0028UL /* General Purpose Timer */
+#define B44_ADDR_LO            0x0088UL /* ENET Address Lo (B0 only) */
+#define B44_ADDR_HI            0x008CUL /* ENET Address Hi (B0 only) */
+#define B44_FILT_ADDR          0x0090UL /* ENET Filter Address */
+#define B44_FILT_DATA          0x0094UL /* ENET Filter Data */
+#define B44_TXBURST            0x00A0UL /* TX Max Burst Length */
+#define B44_RXBURST            0x00A4UL /* RX Max Burst Length */
+#define B44_MAC_CTRL           0x00A8UL /* MAC Control */
+#define  MAC_CTRL_CRC32_ENAB   0x00000001 /* CRC32 Generation Enable */
+#define  MAC_CTRL_PHY_PDOWN    0x00000004 /* Onchip EPHY Powerdown */
+#define  MAC_CTRL_PHY_EDET     0x00000008 /* Onchip EPHY Energy Detected*/
+#define  MAC_CTRL_PHY_LEDCTRL  0x000000e0 /* Onchip EPHY LED Control */
+#define  MAC_CTRL_PHY_LEDCTRL_SHIFT 5
+#define B44_MAC_FLOW           0x00ACUL /* MAC Flow Control */
+#define  MAC_FLOW_RX_HI_WATER  0x000000ff /* Receive FIFO HI Water Mark */
+#define  MAC_FLOW_PAUSE_ENAB   0x00008000 /* Enbl Pause Frm Generation */
+#define B44_RCV_LAZY           0x0100UL /* Lazy Interrupt Control */
+#define  RCV_LAZY_TO_MASK      0x00ffffff /* Timeout */
+#define  RCV_LAZY_FC_MASK      0xff000000 /* Frame Count */
+#define  RCV_LAZY_FC_SHIFT     24
+#define B44_DMATX_CTRL         0x0200UL /* DMA TX Control */
+#define  DMATX_CTRL_ENABLE     0x00000001 /* Enable */
+#define  DMATX_CTRL_SUSPEND    0x00000002 /* Suepend Request */
+#define  DMATX_CTRL_LPBACK     0x00000004 /* Loopback Enable */
+#define  DMATX_CTRL_FAIRPRIOR  0x00000008 /* Fair Priority */
+#define  DMATX_CTRL_FLUSH      0x00000010 /* Flush Request */
+#define B44_DMATX_ADDR         0x0204UL /* DMA TX Descriptor Ring Addr */
+#define B44_DMATX_PTR          0x0208UL /* DMA TX Last Posted Desc. */
+#define B44_DMATX_STAT         0x020CUL /* DMA TX Cur Actve Desc. + Sts */
+#define  DMATX_STAT_CDMASK     0x00000fff /* Current Descriptor Mask */
+#define  DMATX_STAT_SMASK      0x0000f000 /* State Mask */
+#define  DMATX_STAT_SDISABLED  0x00000000 /* State Disabled */
+#define  DMATX_STAT_SACTIVE    0x00001000 /* State Active */
+#define  DMATX_STAT_SIDLE      0x00002000 /* State Idle Wait */
+#define  DMATX_STAT_SSTOPPED   0x00003000 /* State Stopped */
+#define  DMATX_STAT_SSUSP      0x00004000 /* State Suspend Pending */
+#define  DMATX_STAT_EMASK      0x000f0000 /* Error Mask */
+#define  DMATX_STAT_ENONE      0x00000000 /* Error None */
+#define  DMATX_STAT_EDPE       0x00010000 /* Error Desc. Protocol Error */
+#define  DMATX_STAT_EDFU       0x00020000 /* Error Data FIFO Underrun */
+#define  DMATX_STAT_EBEBR      0x00030000 /* Bus Error on Buffer Read */
+#define  DMATX_STAT_EBEDA      0x00040000 /* Bus Error on Desc. Access */
+#define  DMATX_STAT_FLUSHED    0x00100000 /* Flushed */
+#define B44_DMARX_CTRL         0x0210UL /* DMA RX Control */
+#define  DMARX_CTRL_ENABLE     0x00000001 /* Enable */
+#define  DMARX_CTRL_ROMASK     0x000000fe /* Receive Offset Mask */
+#define  DMARX_CTRL_ROSHIFT    1          /* Receive Offset Shift */
+#define B44_DMARX_ADDR         0x0214UL /* DMA RX Descriptor Ring Addr */
+#define B44_DMARX_PTR          0x0218UL /* DMA RX Last Posted Desc */
+#define B44_DMARX_STAT         0x021CUL /* Cur Active Desc. + Status */
+#define  DMARX_STAT_CDMASK     0x00000fff /* Current Descriptor Mask */
+#define  DMARX_STAT_SMASK      0x0000f000 /* State Mask */
+#define  DMARX_STAT_SDISABLED  0x00000000 /* State Disbaled */
+#define  DMARX_STAT_SACTIVE    0x00001000 /* State Active */
+#define  DMARX_STAT_SIDLE      0x00002000 /* State Idle Wait */
+#define  DMARX_STAT_SSTOPPED   0x00003000 /* State Stopped */
+#define  DMARX_STAT_EMASK      0x000f0000 /* Error Mask */
+#define  DMARX_STAT_ENONE      0x00000000 /* Error None */
+#define  DMARX_STAT_EDPE       0x00010000 /* Error Desc. Protocol Error */
+#define  DMARX_STAT_EDFO       0x00020000 /* Error Data FIFO Overflow */
+#define  DMARX_STAT_EBEBW      0x00030000 /* Error on Buffer Write */
+#define  DMARX_STAT_EBEDA      0x00040000 /* Bus Error on Desc. Access */
+#define B44_DMAFIFO_AD         0x0220UL /* DMA FIFO Diag Address */
+#define  DMAFIFO_AD_OMASK      0x0000ffff /* Offset Mask */
+#define  DMAFIFO_AD_SMASK      0x000f0000 /* Select Mask */
+#define  DMAFIFO_AD_SXDD       0x00000000 /* Select Transmit DMA Data */
+#define  DMAFIFO_AD_SXDP       0x00010000 /* Sel Transmit DMA Pointers */
+#define  DMAFIFO_AD_SRDD       0x00040000 /* Select Receive DMA Data */
+#define  DMAFIFO_AD_SRDP       0x00050000 /* Sel Receive DMA Pointers */
+#define  DMAFIFO_AD_SXFD       0x00080000 /* Select Transmit FIFO Data */
+#define  DMAFIFO_AD_SXFP       0x00090000 /* Sel Transmit FIFO Pointers */
+#define  DMAFIFO_AD_SRFD       0x000c0000 /* Select Receive FIFO Data */
+#define  DMAFIFO_AD_SRFP       0x000c0000 /* Sel Receive FIFO Pointers */
+#define B44_DMAFIFO_LO         0x0224UL /* DMA FIFO Diag Low Data */
+#define B44_DMAFIFO_HI         0x0228UL /* DMA FIFO Diag High Data */
+#define B44_RXCONFIG           0x0400UL /* EMAC RX Config */
+#define  RXCONFIG_DBCAST       0x00000001 /* Disable Broadcast */
+#define  RXCONFIG_ALLMULTI     0x00000002 /* Accept All Multicast */
+#define  RXCONFIG_NORX_WHILE_TX        0x00000004 /* Rcv Disble While TX */
+#define  RXCONFIG_PROMISC      0x00000008 /* Promiscuous Enable */
+#define  RXCONFIG_LPBACK       0x00000010 /* Loopback Enable */
+#define  RXCONFIG_FLOW         0x00000020 /* Flow Control Enable */
+#define  RXCONFIG_FLOW_ACCEPT  0x00000040 /* Accept UFC Frame */
+#define  RXCONFIG_RFILT                0x00000080 /* Reject Filter */
+#define B44_RXMAXLEN           0x0404UL /* EMAC RX Max Packet Length */
+#define B44_TXMAXLEN           0x0408UL /* EMAC TX Max Packet Length */
+#define B44_MDIO_CTRL          0x0410UL /* EMAC MDIO Control */
+#define  MDIO_CTRL_MAXF_MASK   0x0000007f /* MDC Frequency */
+#define  MDIO_CTRL_PREAMBLE    0x00000080 /* MII Preamble Enable */
+#define B44_MDIO_DATA          0x0414UL /* EMAC MDIO Data */
+#define  MDIO_DATA_DATA                0x0000ffff /* R/W Data */
+#define  MDIO_DATA_TA_MASK     0x00030000 /* Turnaround Value */
+#define  MDIO_DATA_TA_SHIFT    16
+#define  MDIO_TA_VALID         2
+#define  MDIO_DATA_RA_MASK     0x007c0000 /* Register Address */
+#define  MDIO_DATA_RA_SHIFT    18
+#define  MDIO_DATA_PMD_MASK    0x0f800000 /* Physical Media Device */
+#define  MDIO_DATA_PMD_SHIFT   23
+#define  MDIO_DATA_OP_MASK     0x30000000 /* Opcode */
+#define  MDIO_DATA_OP_SHIFT    28
+#define  MDIO_OP_WRITE         1
+#define  MDIO_OP_READ          2
+#define  MDIO_DATA_SB_MASK     0xc0000000 /* Start Bits */
+#define  MDIO_DATA_SB_SHIFT    30
+#define  MDIO_DATA_SB_START    0x40000000 /* Start Of Frame */
+#define B44_EMAC_IMASK         0x0418UL /* EMAC Interrupt Mask */
+#define B44_EMAC_ISTAT         0x041CUL /* EMAC Interrupt Status */
+#define  EMAC_INT_MII          0x00000001 /* MII MDIO Interrupt */
+#define  EMAC_INT_MIB          0x00000002 /* MIB Interrupt */
+#define  EMAC_INT_FLOW         0x00000003 /* Flow Control Interrupt */
+#define B44_CAM_DATA_LO                0x0420UL /* EMAC CAM Data Low */
+#define B44_CAM_DATA_HI                0x0424UL /* EMAC CAM Data High */
+#define  CAM_DATA_HI_VALID     0x00010000 /* Valid Bit */
+#define B44_CAM_CTRL           0x0428UL /* EMAC CAM Control */
+#define  CAM_CTRL_ENABLE       0x00000001 /* CAM Enable */
+#define  CAM_CTRL_MSEL         0x00000002 /* Mask Select */
+#define  CAM_CTRL_READ         0x00000004 /* Read */
+#define  CAM_CTRL_WRITE                0x00000008 /* Read */
+#define  CAM_CTRL_INDEX_MASK   0x003f0000 /* Index Mask */
+#define  CAM_CTRL_INDEX_SHIFT  16
+#define  CAM_CTRL_BUSY         0x80000000 /* CAM Busy */
+#define B44_ENET_CTRL          0x042CUL /* EMAC ENET Control */
+#define  ENET_CTRL_ENABLE      0x00000001 /* EMAC Enable */
+#define  ENET_CTRL_DISABLE     0x00000002 /* EMAC Disable */
+#define  ENET_CTRL_SRST                0x00000004 /* EMAC Soft Reset */
+#define  ENET_CTRL_EPSEL       0x00000008 /* External PHY Select */
+#define B44_TX_CTRL            0x0430UL /* EMAC TX Control */
+#define  TX_CTRL_DUPLEX                0x00000001 /* Full Duplex */
+#define  TX_CTRL_FMODE         0x00000002 /* Flow Mode */
+#define  TX_CTRL_SBENAB                0x00000004 /* Single Backoff Enable */
+#define  TX_CTRL_SMALL_SLOT    0x00000008 /* Small Slottime */
+#define B44_TX_HIWMARK         0x0434UL /* EMAC TX High Watermark */
+#define  TX_HIWMARK_DEFLT      56  /* Default used in all drivers */
+#define B44_MIB_CTRL           0x0438UL /* EMAC MIB Control */
+#define  MIB_CTRL_CLR_ON_READ  0x00000001 /* Autoclear on Read */
+#define B44_TX_GOOD_O          0x0500UL /* MIB TX Good Octets */
+#define B44_TX_GOOD_P          0x0504UL /* MIB TX Good Packets */
+#define B44_TX_O               0x0508UL /* MIB TX Octets */
+#define B44_TX_P               0x050CUL /* MIB TX Packets */
+#define B44_TX_BCAST           0x0510UL /* MIB TX Broadcast Packets */
+#define B44_TX_MCAST           0x0514UL /* MIB TX Multicast Packets */
+#define B44_TX_64              0x0518UL /* MIB TX <= 64 byte Packets */
+#define B44_TX_65_127          0x051CUL /* MIB TX 65 to 127 byte Pkts */
+#define B44_TX_128_255         0x0520UL /* MIB TX 128 to 255 byte Pkts */
+#define B44_TX_256_511         0x0524UL /* MIB TX 256 to 511 byte Pkts */
+#define B44_TX_512_1023                0x0528UL /* MIB TX 512 to 1023 byte Pkts */
+#define B44_TX_1024_MAX                0x052CUL /* MIB TX 1024 to max byte Pkts */
+#define B44_TX_JABBER          0x0530UL /* MIB TX Jabber Packets */
+#define B44_TX_OSIZE           0x0534UL /* MIB TX Oversize Packets */
+#define B44_TX_FRAG            0x0538UL /* MIB TX Fragment Packets */
+#define B44_TX_URUNS           0x053CUL /* MIB TX Underruns */
+#define B44_TX_TCOLS           0x0540UL /* MIB TX Total Collisions */
+#define B44_TX_SCOLS           0x0544UL /* MIB TX Single Collisions */
+#define B44_TX_MCOLS           0x0548UL /* MIB TX Multiple Collisions */
+#define B44_TX_ECOLS           0x054CUL /* MIB TX Excessive Collisions */
+#define B44_TX_LCOLS           0x0550UL /* MIB TX Late Collisions */
+#define B44_TX_DEFERED         0x0554UL /* MIB TX Defered Packets */
+#define B44_TX_CLOST           0x0558UL /* MIB TX Carrier Lost */
+#define B44_TX_PAUSE           0x055CUL /* MIB TX Pause Packets */
+#define B44_RX_GOOD_O          0x0580UL /* MIB RX Good Octets */
+#define B44_RX_GOOD_P          0x0584UL /* MIB RX Good Packets */
+#define B44_RX_O               0x0588UL /* MIB RX Octets */
+#define B44_RX_P               0x058CUL /* MIB RX Packets */
+#define B44_RX_BCAST           0x0590UL /* MIB RX Broadcast Packets */
+#define B44_RX_MCAST           0x0594UL /* MIB RX Multicast Packets */
+#define B44_RX_64              0x0598UL /* MIB RX <= 64 byte Packets */
+#define B44_RX_65_127          0x059CUL /* MIB RX 65 to 127 byte Pkts */
+#define B44_RX_128_255         0x05A0UL /* MIB RX 128 to 255 byte Pkts */
+#define B44_RX_256_511         0x05A4UL /* MIB RX 256 to 511 byte Pkts */
+#define B44_RX_512_1023                0x05A8UL /* MIB RX 512 to 1023 byte Pkts */
+#define B44_RX_1024_MAX                0x05ACUL /* MIB RX 1024 to max byte Pkts */
+#define B44_RX_JABBER          0x05B0UL /* MIB RX Jabber Packets */
+#define B44_RX_OSIZE           0x05B4UL /* MIB RX Oversize Packets */
+#define B44_RX_FRAG            0x05B8UL /* MIB RX Fragment Packets */
+#define B44_RX_MISS            0x05BCUL /* MIB RX Missed Packets */
+#define B44_RX_CRCA            0x05C0UL /* MIB RX CRC Align Errors */
+#define B44_RX_USIZE           0x05C4UL /* MIB RX Undersize Packets */
+#define B44_RX_CRC             0x05C8UL /* MIB RX CRC Errors */
+#define B44_RX_ALIGN           0x05CCUL /* MIB RX Align Errors */
+#define B44_RX_SYM             0x05D0UL /* MIB RX Symbol Errors */
+#define B44_RX_PAUSE           0x05D4UL /* MIB RX Pause Packets */
+#define B44_RX_NPAUSE          0x05D8UL /* MIB RX Non-Pause Packets */
+
+/* Sonics Silicon backplane register definitions */
+#define B44_SBIMSTATE          0x0F90UL /* SB Initiator Agent State */
+#define  SBIMSTATE_PC          0x0000000f /* Pipe Count */
+#define  SBIMSTATE_AP_MASK     0x00000030 /* Arbitration Priority */
+#define  SBIMSTATE_AP_BOTH     0x00000000 /* both timeslices and token */
+#define  SBIMSTATE_AP_TS       0x00000010 /* Use timeslices only */
+#define  SBIMSTATE_AP_TK       0x00000020 /* Use token only */
+#define  SBIMSTATE_AP_RSV      0x00000030 /* Reserved */
+#define  SBIMSTATE_IBE         0x00020000 /* In Band Error */
+#define  SBIMSTATE_TO          0x00040000 /* Timeout */
+#define  SBIMSTATE_BAD      ( SBIMSTATE_IBE | SBIMSTATE_TO )
+#define B44_SBINTVEC           0x0F94UL /* SB Interrupt Mask */
+#define  SBINTVEC_PCI          0x00000001 /* Enable interrupts for PCI */
+#define  SBINTVEC_ENET0                0x00000002 /* Enable ints for enet 0 */
+#define  SBINTVEC_ILINE20      0x00000004 /* Enable ints for iline20 */
+#define  SBINTVEC_CODEC                0x00000008 /* Enable ints for v90 codec */
+#define  SBINTVEC_USB          0x00000010 /* Enable intts for usb */
+#define  SBINTVEC_EXTIF                0x00000020 /* Enable ints for ext i/f */
+#define  SBINTVEC_ENET1                0x00000040 /* Enable ints for enet 1 */
+#define B44_SBTMSLOW           0x0F98UL /* SB Target State Low */
+#define  SBTMSLOW_RESET                0x00000001 /* Reset */
+#define  SBTMSLOW_REJECT       0x00000002 /* Reject */
+#define  SBTMSLOW_CLOCK                0x00010000 /* Clock Enable */
+#define  SBTMSLOW_FGC          0x00020000 /* Force Gated Clocks On */
+#define  SBTMSLOW_PE           0x40000000 /* Power Management Enable */
+#define  SBTMSLOW_BE           0x80000000 /* BIST Enable */
+#define B44_SBTMSHIGH          0x0F9CUL /* SB Target State High */
+#define  SBTMSHIGH_SERR                0x00000001 /* S-error */
+#define  SBTMSHIGH_INT         0x00000002 /* Interrupt */
+#define  SBTMSHIGH_BUSY                0x00000004 /* Busy */
+#define  SBTMSHIGH_GCR         0x20000000 /* Gated Clock Request */
+#define  SBTMSHIGH_BISTF       0x40000000 /* BIST Failed */
+#define  SBTMSHIGH_BISTD       0x80000000 /* BIST Done */
+#define B44_SBIDHIGH           0x0FFCUL /* SB Identification High */
+#define  SBIDHIGH_RC_MASK      0x0000000f /* Revision Code */
+#define  SBIDHIGH_CC_MASK      0x0000fff0 /* Core Code */
+#define  SBIDHIGH_CC_SHIFT     4
+#define  SBIDHIGH_VC_MASK      0xffff0000 /* Vendor Code */
+#define  SBIDHIGH_VC_SHIFT     16
+
+/* SSB PCI config space registers.  */
+#define SSB_PMCSR              0x44
+#define  SSB_PE                        0x100
+#define        SSB_BAR0_WIN            0x80
+#define        SSB_BAR1_WIN            0x84
+#define        SSB_SPROM_CONTROL       0x88
+#define        SSB_BAR1_CONTROL        0x8c
+
+/* SSB core and host control registers.  */
+#define SSB_CONTROL            0x0000UL
+#define SSB_ARBCONTROL         0x0010UL
+#define SSB_ISTAT              0x0020UL
+#define SSB_IMASK              0x0024UL
+#define SSB_MBOX               0x0028UL
+#define SSB_BCAST_ADDR         0x0050UL
+#define SSB_BCAST_DATA         0x0054UL
+#define SSB_PCI_TRANS_0                0x0100UL
+#define SSB_PCI_TRANS_1                0x0104UL
+#define SSB_PCI_TRANS_2                0x0108UL
+#define SSB_SPROM              0x0800UL
+
+#define SSB_PCI_MEM            0x00000000
+#define SSB_PCI_IO             0x00000001
+#define SSB_PCI_CFG0           0x00000002
+#define SSB_PCI_CFG1           0x00000003
+#define SSB_PCI_PREF           0x00000004
+#define SSB_PCI_BURST          0x00000008
+#define SSB_PCI_MASK0          0xfc000000
+#define SSB_PCI_MASK1          0xfc000000
+#define SSB_PCI_MASK2          0xc0000000
+
+/* 4400 PHY registers */
+#define B44_MII_AUXCTRL                24      /* Auxiliary Control */
+#define  MII_AUXCTRL_DUPLEX    0x0001  /* Full Duplex */
+#define  MII_AUXCTRL_SPEED     0x0002  /* 1=100Mbps, 0=10Mbps */
+#define  MII_AUXCTRL_FORCED    0x0004  /* Forced 10/100 */
+#define B44_MII_ALEDCTRL       26      /* Activity LED */
+#define  MII_ALEDCTRL_ALLMSK   0x7fff
+#define B44_MII_TLEDCTRL       27      /* Traffic Meter LED */
+#define  MII_TLEDCTRL_ENABLE   0x0040
+
+/* RX/TX descriptor */
+struct dma_desc {
+       u32 ctrl; /* length of data and flags */
+       u32 addr; /* address of data */
+};
+
+/* There are only 12 bits in the DMA engine for descriptor offsetting
+ * so the table must be aligned on a boundary of this.
+ */
+#define B44_DMA_ALIGNMENT      4096
+
+/* The DMA engine can only address the first gigabyte of address space
+ */
+#define B44_30BIT_DMA_MASK     0x3fffffff
+
+#define DESC_CTRL_LEN          0x00001fff
+#define DESC_CTRL_CMASK                0x0ff00000 /* Core specific bits */
+#define DESC_CTRL_EOT          0x10000000 /* End of Table */
+#define DESC_CTRL_IOC          0x20000000 /* Interrupt On Completion */
+#define DESC_CTRL_EOF          0x40000000 /* End of Frame */
+#define DESC_CTRL_SOF          0x80000000 /* Start of Frame */
+
+struct rx_header {
+       u16 len;
+       u16 flags;
+       u16 pad[12];
+};
+#define RX_HEADER_LEN  28
+
+#define RX_FLAG_OFIFO  0x00000001 /* FIFO Overflow */
+#define RX_FLAG_CRCERR 0x00000002 /* CRC Error */
+#define RX_FLAG_SERR   0x00000004 /* Receive Symbol Error */
+#define RX_FLAG_ODD    0x00000008 /* Frame has odd number of nibbles */
+#define RX_FLAG_LARGE  0x00000010 /* Frame is > RX MAX Length */
+#define RX_FLAG_MCAST  0x00000020 /* Dest is Multicast Address */
+#define RX_FLAG_BCAST  0x00000040 /* Dest is Broadcast Address */
+#define RX_FLAG_MISS   0x00000080 /* Received due to promisc mode */
+#define RX_FLAG_LAST   0x00000800 /* Last buffer in frame */
+#define RX_FLAG_ERRORS (RX_FLAG_ODD | RX_FLAG_SERR |\
+                         RX_FLAG_CRCERR | RX_FLAG_OFIFO)
+
+/* Client Mode PCI memory access space (1 GB) */
+#define SB_PCI_DMA              0x40000000
+
+ /* Address of PCI core on BCM4400 cards */
+#define BCM4400_PCI_CORE_ADDR   0x18002000
+
+/* Hardware minimum and maximum for a single frame's data payload */
+#define B44_MIN_MTU            60
+#define B44_MAX_MTU            1500
+
+#define B44_RING_SIZE           8
+#define B44_RING_LAST           ( B44_RING_SIZE - 1 )
+
+#define B44_RX_RING_LEN_BYTES  ( sizeof bp->rx[0] * B44_RING_SIZE )
+#define B44_TX_RING_LEN_BYTES  ( sizeof bp->tx[0] * B44_RING_SIZE )
+
+#define RX_PKT_OFFSET          30
+#define RX_PKT_BUF_SZ          (1536 + RX_PKT_OFFSET + 64)
+
+#define B44_FULL_RESET         1
+#define B44_FULL_RESET_SKIP_PHY        2
+#define B44_PARTIAL_RESET      3
+#define B44_CHIP_RESET_FULL     4
+#define B44_CHIP_RESET_PARTIAL  5
+
+#define SSB_CORE_DOWN           ( SBTMSLOW_RESET | SBTMSLOW_REJECT )
+
+#define B44_REGS_SIZE           8192
+
+/** Driver private state */
+struct b44_private {
+       struct net_device *netdev;
+       struct pci_device *pci;
+       u8 *regs; /* memory-mapped registers */
+       u8 phy_addr;
+
+       struct dma_desc *tx;
+       struct io_buffer *tx_iobuf[B44_RING_SIZE];
+       u32 tx_cur; /* next available descriptor */
+       u32 tx_dirty; /* oldest pending descriptor */
+
+       struct dma_desc *rx;
+       struct io_buffer *rx_iobuf[B44_RING_SIZE];
+       u32 rx_cur; /* next descriptor to read */
+};
+
+
+static void ssb_core_reset ( struct b44_private *bp );
+static void ssb_core_disable ( struct b44_private *bp );
+static u32 ssb_pci_setup ( struct b44_private *bp, u32 cores );
+
+static void b44_chip_reset ( struct b44_private *bp, int reset_kind );
+static void b44_init_hw ( struct b44_private *bp, int reset_kind );
+static void b44_cam_write ( struct b44_private *bp, u8 *data, int index );
+static void b44_set_mac_addr ( struct b44_private *bp );
+static void b44_set_rx_mode ( struct net_device *netdev );
+static void b44_halt(struct b44_private *);
+
+static int b44_phy_reset ( struct b44_private *bp );
+static int b44_phy_write ( struct b44_private *bp, int reg, u32 val );
+static int b44_phy_read ( struct b44_private *bp, int reg, u32 *val );
+
+static int b44_init_tx_ring ( struct b44_private *bp );
+static void b44_free_tx_ring ( struct b44_private *bp );
+static int b44_init_rx_ring ( struct b44_private *bp );
+static void b44_free_rx_ring ( struct b44_private *bp );
+static void b44_rx_refill ( struct b44_private *bp, u32 pending );
+static void b44_populate_rx_descriptor (struct b44_private *bp, u32 index);
+
+static int b44_probe ( struct pci_device *pci,
+                       const struct pci_device_id *id );
+static void b44_remove ( struct pci_device *pci );
+
+static int b44_open ( struct net_device *netdev );
+static void b44_close ( struct net_device *netdev );
+static void b44_irq ( struct net_device *netdev, int enable );
+static void b44_poll ( struct net_device *netdev );
+static void b44_process_rx_packets ( struct b44_private *bp );
+static int b44_transmit ( struct net_device *netdev,
+                          struct io_buffer *iobuf );
+
+static struct net_device_operations b44_operations;
+
+#endif /* _B44_H */
index c851c7d..a3d6d37 100644 (file)
 #define ERRFILE_mtnic               ( ERRFILE_DRIVER | 0x004a0000 )
 #define ERRFILE_phantom                     ( ERRFILE_DRIVER | 0x004b0000 )
 #define ERRFILE_ne2k_isa            ( ERRFILE_DRIVER | 0x004c0000 )
+#define ERRFILE_b44                 ( ERRFILE_DRIVER | 0x004d0000 )
 
 #define ERRFILE_scsi                ( ERRFILE_DRIVER | 0x00700000 )
 #define ERRFILE_arbel               ( ERRFILE_DRIVER | 0x00710000 )