linux-mips
[Top] [All Lists]

[PATCH 10/12] drivers: PMC MSP71xx ethernet driver

To: netdev@vger.kernel.org
Subject: [PATCH 10/12] drivers: PMC MSP71xx ethernet driver
From: Marc St-Jean <stjeanma@pmc-sierra.com>
Date: Thu, 26 Apr 2007 18:48:03 -0600
Cc: akpm@linux-foundation.org, jgarzik@pobox.com, linux-mips@linux-mips.org
Original-recipient: rfc822;linux-mips@linux-mips.org
Sender: linux-mips-bounce@linux-mips.org
[PATCH 10/12] drivers: PMC MSP71xx ethernet driver

Patch to add an ethernet driver for the PMC-Sierra MSP71xx devices.

Patches 1 through 9 were posted to linux-mips@linux-mips.org as well
as other sub-system lists/maintainers as appropriate. This patch has
some dependencies on the first few patches in the set. If you would
like to receive these or the entire set, please email me.

Thanks,
Marc

Signed-off-by: Marc St-Jean <Marc_St-Jean@pmc-sierra.com>
---
Changes since last posting:
-Major cleanup in style, etc.
-Converted to platfrom driver model.
-Added iomapping support.
-Added dma sync support.
-Added NAPI support.
-Added skb buffer recycling.

 arch/mips/pmc-sierra/msp71xx/msp_eth.c |  122 +
 drivers/net/Kconfig                    |   20 
 drivers/net/Makefile                   |    1 
 drivers/net/pmcmspeth.c                | 3178 +++++++++++++++++++++++++++++++++
 drivers/net/pmcmspeth.h                |  624 ++++++
 5 files changed, 3945 insertions(+)

diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 76f98f3..53a7246 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -201,6 +201,26 @@ config MACB
 
 source "drivers/net/arm/Kconfig"
 
+config MSPETH
+       bool "Ethernet for PMC-Sierra MSP"
+       depends on NET_ETHERNET && PMC_MSP
+       ---help---
+       This adds support for the the MACs found on the PMC-Sierra MSP devices.
+
+config MSPETH_NAPI
+       bool "NAPI support"
+       depends on MSPETH
+       help
+         NAPI(New API) is a technique to improve network performance on Linux.
+
+config MSPETH_SKB_RECYCLE
+       bool "Socket Buffer recycling support"
+       depends on MSPETH
+       help
+         Reuse the socket buffers used during the transmission of packets for 
the receive
+         operation. This improves performance by reducing kmalloc/kfree 
operations.
+
+
 config MACE
        tristate "MACE (Power Mac ethernet) support"
        depends on NET_ETHERNET && PPC_PMAC && PPC32
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index c26ba39..cc90aa0 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -68,6 +68,7 @@ obj-$(CONFIG_SKFP) += skfp/
 obj-$(CONFIG_VIA_RHINE) += via-rhine.o
 obj-$(CONFIG_VIA_VELOCITY) += via-velocity.o
 obj-$(CONFIG_ADAPTEC_STARFIRE) += starfire.o
+obj-$(CONFIG_MSPETH) += pmcmspeth.o
 obj-$(CONFIG_RIONET) += rionet.o
 
 #
diff --git a/drivers/net/pmcmspeth.c b/drivers/net/pmcmspeth.c
new file mode 100644
index 0000000..788fa23
--- /dev/null
+++ b/drivers/net/pmcmspeth.c
@@ -0,0 +1,3178 @@
+/*
+ * PMC-Sierra MSP EVM ethernet driver for linux
+ *
+ * Copyright 2005-2007 PMC-Sierra, Inc
+ *
+ * Originally based on mspeth.c driver which contains substantially the
+ * same hardware.
+ * Based on skelton.c by Donald Becker.
+ *
+ * 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 (at your
+ * option) any later version.
+ *
+ * THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ * WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ * NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ * USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * 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.
+ */
+
+#include <linux/version.h>
+#include <linux/etherdevice.h>
+#include <linux/proc_fs.h>
+#include <linux/mii.h>
+#include <linux/module.h>
+
+#include <asm/bootinfo.h>
+#include <asm/dma.h>
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+#include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
+#include <net/xfrm.h>
+#include <asm/cpu-features.h>
+#include <msp_regs.h>
+#include <msp_regops.h>
+#include <msp_prom.h>
+#include <msp_int.h>
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+#include <asm/r4kcache.h>
+#include <asm/brecis/prom.h>
+#include <asm/brecis/brecisint.h>
+#include <asm/brecis/brecisint.h>
+#include <asm/brecis/BrecisSysRegs.h>
+#include <brecis/msp.h>
+#endif /* LINUX_VERSION_CODE */
+
+#include "pmcmspeth.h"
+
+/**************************************************************************
+ * The name of the card. Is used for messages and in the requests for
+ * io regions, irqs and dma channels, versions, etc. Also, various other
+ * identifying character constants.
+ */
+static const char cardname[] = "pmcmspeth";
+
+/**************************************************************************
+ * List of PHYs. Each MAC will have a certain number (maybe zero)
+ * PHYs hanging off the MDIO interface.
+ */
+static struct mspeth_phy *root_phy_dev = NULL;
+
+/* Debugging flags */
+static unsigned int mspeth_debug = MSPETH_DEBUG;
+
+/**************************************************************************
+ * Function prototypes
+ */
+
+/* Functions that get called by upper layers */
+static int mspeth_open(struct net_device *dev);
+static int mspeth_send_packet(struct sk_buff *skb,
+                               struct net_device *dev);
+static void mspeth_tx_timeout(struct net_device *dev);
+static void mspeth_hard_restart_bh(unsigned long dev_addr);
+static int mspeth_close(struct net_device *dev);
+static struct net_device_stats *mspeth_get_stats(struct net_device *dev);
+static void mspeth_set_multicast_list(struct net_device *dev);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+static irqreturn_t mspeth_interrupt(int irq, void *dev_id);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+static void mspeth_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+#endif
+
+#ifdef CONFIG_MSPETH_NAPI
+static int mspeth_poll(struct net_device *dev, int *budget);
+inline static void mspeth_txdone(unsigned long dev_addr);
+#else
+static void mspeth_rx(unsigned long dev_addr);
+static void mspeth_txdone(unsigned long dev_addr);
+#endif /* CONFIG_MSPETH_NAPI */
+
+/* Private utility functions */
+static void mspeth_soft_restart(struct net_device *dev);
+static void mspeth_hard_restart(struct net_device *dev);
+static void mspeth_mac_reset(struct net_device *dev);
+static void mspeth_mac_init(struct net_device *dev);
+static void mspeth_phy_init(struct net_device *dev);
+static void mspeth_phy_reset(struct net_device *dev);
+static int mspeth_proc_info(char *buf, char **buf_loc, off_t off,
+                               int len, int *eof, void *data);
+static void mspeth_set_arc_entry(struct net_device *dev,
+                               int index, unsigned char *addr);
+static void mspeth_check_tx_stat(struct net_device *dev, int status);
+static int mspeth_phyprobe(struct net_device *dev);
+static void mspeth_init_phyaddr(struct net_device *dev);
+static void mspeth_init_cmdline(struct net_device *dev);
+static void mspeth_fatal_error_interrupt(struct net_device *dev,
+                                               int status);
+
+/*
+ * Define the utility functions used by the the various other actual
+ * routines here. These should all be inline or macros.
+ */
+
+/************************************************************************
+ * flush_memqueue - Ensure all queued memory transactions are
+ *                     complete.
+ */
+#define flush_memqueue()       blocking_read_reg32(MEM_CFG1_REG)
+
+#if defined(CONFIG_DMA_NONCOHERENT) && \
+    (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+/************************************************************************
+ * writeback_buffer - force the cache to write contents of cached buffer
+ * to memory and invalidate the buffer. Must start on cache line boundary,
+ * must "own" to next higher cache line boundary from end of buffer
+ *
+ * stjeanma, 2006-06-12:
+ * Use L1_CACHE_ALIGN to cache align the buffer rounding down to
+ * the next cache line. It is the resposibility of the caller to ensure
+ * that any partial cache line before the pointer isn't conflicting with
+ * other memory shared with the controller.
+ */
+inline static void
+writeback_buffer(void *buf_addr, unsigned int length)
+{
+       unsigned long end = (unsigned long)buf_addr + length;
+       buf_addr = (void *)((unsigned long)buf_addr &
+                       ~(L1_CACHE_BYTES - 1));
+
+       while ((unsigned long)buf_addr + UNROLL_INCR < end) {
+               CACHE_UNROLL(buf_addr, Hit_Writeback_Inv_D);
+               buf_addr += UNROLL_INCR;
+       }
+
+       while ((unsigned long)buf_addr < end) {
+               flush_dcache_line((unsigned long)buf_addr);
+               buf_addr += L1_CACHE_BYTES;
+       }
+}
+
+/************************************************************************
+ * invalidate_buffer - Invalidate buffer cache
+ *     - must start on cache line boundary
+ *     - must "own" to next higher cache line boundary from end of buffer
+ *
+ * stjeanma, 2006-06-12:
+ * Use L1_CACHE_ALIGN to cache align the buffer rounding down to
+ * the next cache line. It is the resposibility of the caller to ensure
+ * that any partial cache line before the pointer isn't conflicting with
+ * other memory shared with the controller.
+ */
+inline static void
+invalidate_buffer(void *buf_addr, unsigned int length)
+{
+       unsigned long end = (unsigned long)buf_addr + length;
+       buf_addr = (void *)((unsigned long)buf_addr & ~(L1_CACHE_BYTES - 1));
+
+       while ((unsigned long)buf_addr + UNROLL_INCR < end) {
+               CACHE_UNROLL(buf_addr, Hit_Invalidate_D);
+               buf_addr += UNROLL_INCR;
+       }
+
+       while ((unsigned long)buf_addr < end) {
+               invalidate_dcache_line((unsigned long)buf_addr );
+               buf_addr += L1_CACHE_BYTES;
+       }
+}
+#else
+#define writeback_buffer(a, l) do {} while (0)
+#define invalidate_buffer(a, l) do {} while (0)
+#endif /* CONFIG_DMA_NONCOHERENT && LINUX_VERSION_CODE */
+
+/************************************************************************
+ * Read/Write a MSP eth register.
+ */
+inline static u32
+msp_read(struct mspeth_priv *lp, unsigned int offset)
+{
+       return __raw_readl(lp->mapaddr + offset);
+}
+
+inline static void
+msp_write(struct mspeth_priv *lp, unsigned int offset, u32 val)
+{
+       __raw_writel(val, lp->mapaddr + offset);
+}
+
+/************************************************************************
+ * Read/Write a MDIO register.
+ */
+static u32
+mspphy_read(struct mspeth_phy *phyptr, int phy_reg)
+{
+       unsigned long flags;
+       u32 data;
+
+       if (phyptr == NULL) {
+               printk(KERN_WARNING "MSPETH(mspphy_read): "
+                       "Cannot read from a NULL PHY!\n");
+               return 0x0;
+       }
+
+       /* protect access with spin lock */
+       spin_lock_irqsave(&(phyptr->lock), flags);
+
+       while (__raw_readl(phyptr->memaddr + MSPPHY_MII_CTRL) &
+               MD_CA_BUSY_BIT) {;}
+       __raw_writel(MD_CA_BUSY_BIT | phyptr->phyaddr << 5 | phy_reg,
+                       phyptr->memaddr + MSPPHY_MII_CTRL);
+       while (__raw_readl(phyptr->memaddr + MSPPHY_MII_CTRL) &
+               MD_CA_BUSY_BIT) {;}
+       data = __raw_readl(phyptr->memaddr + MSPPHY_MII_DATA);
+
+       /* unlock */
+       spin_unlock_irqrestore(&(phyptr->lock), flags);
+
+       return data & 0xffff;
+}
+
+static void
+mspphy_write(struct mspeth_phy *phyptr, int phy_reg, u32 data)
+{
+       unsigned long flags;
+
+       if (phyptr == NULL) {
+               printk(KERN_WARNING "MSPETH(mspphy_write): "
+                       "Cannot write to a NULL PHY!\n");
+               return;
+       }
+
+       /* protect access with spin lock */
+       spin_lock_irqsave(&(phyptr->lock), flags);
+
+       while (__raw_readl(phyptr->memaddr + MSPPHY_MII_CTRL) &
+               MD_CA_BUSY_BIT) {;}
+       __raw_writel(data, phyptr->memaddr + MSPPHY_MII_DATA);
+       __raw_writel(MD_CA_BUSY_BIT | MD_CA_Wr |
+                       phyptr->phyaddr << 5 | phy_reg,
+                       phyptr->memaddr + MSPPHY_MII_CTRL);
+       while (__raw_readl(phyptr->memaddr + MSPPHY_MII_CTRL) &
+               MD_CA_BUSY_BIT) {;}
+
+       /* unlock */
+       spin_unlock_irqrestore(&(phyptr->lock), flags);
+}
+
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+/* initialise the recycle bin for skb */
+static void
+init_skbuff_bin(void)
+{
+       spin_lock_init(&skb_bin.lock);
+       skb_bin.recycle_max = RX_BUF_NUM * 4; /* max size of bin */
+       skb_bin.recycle_count = 0;
+       skb_bin.recycle_queue = NULL;
+       skb_bin.user_count = 0;
+}
+
+/* free the skb's in recycle bin */
+static void
+free_skbuff_bin(void)
+{
+       spin_lock_bh(&skb_bin.lock);
+
+       /* check any skb's are present in the recycle bin */
+       if (skb_bin.recycle_count > 0) {
+               struct sk_buff *skb;
+               while (skb_bin.recycle_queue != NULL ) {
+                       skb = skb_bin.recycle_queue->next;
+                       dev_kfree_skb_any(skb_bin.recycle_queue);
+                       skb_bin.recycle_queue = skb;
+               }
+       }
+
+       /* reset fields */
+       skb_bin.recycle_queue = NULL;
+       skb_bin.recycle_count = 0;
+       
+       spin_unlock_bh(&skb_bin.lock);
+}
+
+inline static void
+mspeth_skb_headerinit(struct sk_buff *skb)
+{
+       /* these are essential before init */
+       dst_release(skb->dst);
+#ifdef CONFIG_XFRM
+       secpath_put(skb->sp);
+#endif
+#ifdef CONFIG_NETFILTER
+       nf_conntrack_put(skb->nfct);
+#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
+       nf_conntrack_put_reasm(skb->nfct_reasm);
+#endif
+#ifdef CONFIG_BRIDGE_NETFILTER
+       nf_bridge_put(skb->nf_bridge);
+#endif
+#endif /* CONFIG_NETFILTER */
+
+       /* now initialise the skb . . . */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+       /* clear the members till skb->truesize */
+       memset(skb, 0, offsetof(struct sk_buff, truesize));
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+       skb->prev = NULL;
+       skb->list = NULL;
+       skb->sk = NULL;
+       skb->stamp.tv_sec = 0;
+#ifdef CONFIG_BRECIS
+       skb->stamp.tv_usec = 0;
+#endif /* CONFIG_BRECIS */
+       skb->dev = NULL;
+       skb->real_dev = NULL;
+       skb->dst = NULL;
+       memset(skb->cb, 0, sizeof(skb->cb));
+       skb->pkt_type = PACKET_HOST;
+       skb->priority = 0;
+       skb->security = 0;
+
+#ifdef CONFIG_NETFILTER
+       skb->nfmark = skb->nfcache = 0;
+       skb->nfct = NULL;
+#ifdef CONFIG_NETFILTER_DEBUG
+       skb->nf_debug = 0;
+#endif
+#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
+       skb->nf_bridge = NULL;
+#endif
+#endif /* CONFIG_NETFILTER */
+#ifdef CONFIG_NET_SCHED
+       skb->tc_index = 0;
+#endif
+#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
+       skb->nfct_reasm = NULL;
+#endif
+#endif /* LINUX_VERSION_CODE */
+}
+#endif /* CONFIG_MSPETH_SKB_RECYCLE */
+
+/**************************************************************************
+ * Allocate and align a max length socket buffer for this device
+ */
+inline static struct sk_buff *
+mspeth_alloc_skb(struct net_device *dev)
+{
+       struct sk_buff *skb = NULL;
+       
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+       /* try to get an skb from the recycle bin */
+       spin_lock_bh(&skb_bin.lock);
+
+       /* check if the bin si empty */
+       if (skb_bin.recycle_queue) {
+               /* grab an skb from the bin */
+               skb = skb_bin.recycle_queue;
+               skb_bin.recycle_queue = skb->next;
+               
+               /* we have taken one, so reduce the count */
+               skb_bin.recycle_count--;
+               skb_bin.recycle_hits++;
+               spin_unlock_bh(&skb_bin.lock);
+
+               skb->next = NULL; /* must be set to NULL */
+               skb->truesize = (skb->end - skb->head) +
+                               sizeof(struct sk_buff);
+               atomic_set(&skb->users, 1);
+               
+               /* reset the payload pointers */
+               skb->data = skb->head;
+               skb->tail = skb->head;
+
+               /* reset shared info fields */
+               atomic_set(&(skb_shinfo(skb)->dataref), 1);
+               skb_shinfo(skb)->nr_frags = 0;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+               skb_shinfo(skb)->gso_size = 0;
+               skb_shinfo(skb)->gso_segs = 0;
+#endif
+               skb_shinfo(skb)->frag_list = NULL;
+               
+               /* compliance with __dev_alloc_skb */
+               skb_reserve(skb, NET_SKB_PAD);
+       } else {
+               /* no skb in bin */
+               spin_unlock_bh(&skb_bin.lock);
+       }
+#endif /* CONFIG_MSPETH_SKB_RECYCLE */
+
+       if (skb == NULL) {
+               /*
+                * We need a bit more than an ethernet frame for the
+                * aligment stuff so preallocate two more.
+                */
+               skb = dev_alloc_skb(MSP_END_BUFSIZE + 2);
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+               skb_bin.recycle_misses++;
+#endif
+               if (skb == NULL) {
+                       printk(KERN_WARNING "MSPETH(alloc_skb) %s: "
+                               "cannot allocate skb!\n", dev->name);
+                       return NULL;
+               }
+       }
+
+       /*
+        * Align and fill out fields specific to our device. Notice that
+        * our device is smart about FCS etc ......
+        */
+       skb_reserve(skb, 2);
+       skb->dev = dev;
+       skb->ip_summed = CHECKSUM_NONE;
+
+       return skb;
+}
+
+/**************************************************************************
+ * Add the used skb to recycle bin or free it
+ */
+inline static void
+mspeth_free_skb(struct sk_buff *skb)
+{
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+       /*
+        * First try to recycle the skb.
+        * Check if the skb can be recycled.
+        */
+       if ((skb->end - skb->head) >= SKBUFF_RECYCLABLE_SIZE &&
+           (!skb->destructor) &&
+           (!skb->cloned) &&
+           (atomic_dec_and_test(&skb->users))) {
+               /* skb is recyclable */
+               spin_lock_bh(&skb_bin.lock);
+               
+               /* check the bin has room to add our skb */
+               if (likely(skb_bin.recycle_count < skb_bin.recycle_max)) {
+                       /* everything ok; go recycle it */
+                       /* prerequisite before adding to recycle bin */
+                       mspeth_skb_headerinit(skb);
+                       
+                       /* now we can add the skb to bin */
+                       skb->next = skb_bin.recycle_queue;
+                       skb_bin.recycle_queue = skb;
+                       
+                       /* we have one more skb in bin, increase the count */
+                       skb_bin.recycle_count++;
+                       
+                       spin_unlock_bh(&skb_bin.lock);
+                       return;
+               } else {
+                       /* bin has no room */
+                       spin_unlock_bh(&skb_bin.lock);
+               }
+       }
+#endif /* CONFIG_MSPETH_SKB_RECYCLE */
+
+       /* Can't add skb to recycle bin, so free it in normal way. */
+       dev_kfree_skb_any(skb);
+}
+
+/**************************************************************************
+ * Error reporting functions -- used for debugging mostly
+ */
+static void
+dump_qdesc(struct q_desc *fd)
+{
+       printk(KERN_INFO "  q_desc(%p): %08x %08x %08x %08x\n",
+               fd, fd->fd.FDNext, fd->fd.FDSystem,
+               fd->fd.FDStat, fd->fd.FDCtl);
+       printk(KERN_INFO "    BD: %08x %08x\n",
+               fd->bd.BuffData, fd->bd.BDCtl);
+}
+
+static void
+print_buf(char *add, int length)
+{
+       int i;
+       int len = length;
+
+       printk(KERN_INFO "print_buf(%08x)(%x)\n",
+               (unsigned int)add, length);
+
+       if (len > 100)
+               len = 100;
+       for (i = 0; i < len; i++) {
+               printk(KERN_INFO " %2.2X", (unsigned char)add[i]);
+               if (!(i % 16))
+                       printk(KERN_INFO "\n");
+       }
+       printk(KERN_INFO "\n");
+}
+
+static void
+print_eth(int rx, char *add, int len)
+{
+       int i;
+       int lentyp;
+
+       if (rx)
+               printk(KERN_INFO "\n************************** RX packet "
+                       "0x%08x ****************************\n", (u32)add);
+       else
+               printk(KERN_INFO "\n************************** TX packet "
+                       "0x%08x ****************************\n", (u32)add);
+
+       printk(KERN_INFO "---- ethernet ----\n");
+       printk(KERN_INFO "==> dest: ");
+       for (i = 0; i < 6; i++) {
+               printk(KERN_INFO "%02x", (unsigned char)add[i]);
+               printk((i < 5) ? KERN_INFO ":" : KERN_INFO "\n");
+       }
+
+       printk(KERN_INFO "==>  src: ");
+       for (i = 0; i < 6; i++) {
+               printk(KERN_INFO "%02x", (unsigned char)add[i + 6]);
+               printk((i < 5) ? KERN_INFO ":" : KERN_INFO "\n");
+       }
+       lentyp = ((unsigned char)add[12] << 8) | (unsigned char)add[13];
+       if (lentyp <= 1500)
+               printk(KERN_INFO "==>  len: %d\n", lentyp);
+       else if (lentyp > 1535)
+               printk(KERN_INFO "==> type: 0x%04x\n", lentyp);
+       else
+               printk(KERN_INFO "==> ltyp: 0x%04x\n", lentyp);
+
+       if (len > 0x100)
+               len = 0x100;
+
+       for (i = 0; i < ((u32)add & 0x0000000F); i++)
+               printk(KERN_INFO "   ");
+       for (i = 0; i < len; i++, add++) {
+               printk(KERN_INFO " %02x", *((unsigned char *)add));
+               if (!(((u32)add + 1) % 16))
+                       printk(KERN_INFO "\n");
+       }
+       printk(KERN_INFO "\n");
+}
+
+/*
+ * Used mainly for debugging unusual conditions signalled by a
+ * fatal error interrupt (eg, IntBLEx). This function stops the transmit
+ * and receive in an attempt to capture the true state of the queues
+ * at the time of the interrupt.
+ */
+#undef MSPETH_DUMP_QUEUES
+#ifdef MSPETH_DUMP_QUEUES
+static void
+dump_blist(struct bl_desc *fd)
+{
+       int i;
+
+       printk(KERN_INFO "  bl_desc(%p): %08x %08x %08x %08x\n",
+               fd, fd->fd.FDNext,
+                       fd->fd.FDSystem, fd->fd.FDStat, fd->fd.FDCtl);
+       for (i = 0; i < RX_BUF_NUM << 1; i++)
+               printk(KERN_INFO "    BD #%d: %08x %08x\n",
+                       i, fd->bd[i].BuffData, fd->bd[i].BDCtl);
+}
+
+/* Catalog the received buffers numbers */
+static int rx_bdnums[2][RX_BUF_NUM << 2];
+static int rx_bdnums_ind[2] = {0, 0};
+static inline void
+catalog_rx_bdnum(int hwnum, int bdnum)
+{
+       rx_bdnums_ind[hwnum] = (rx_bdnums_ind[hwnum] + 1) &
+                               ((RX_BUF_NUM << 2) - 1);
+       rx_bdnums[hwnum][rx_bdnums_ind[hwnum]] = bdnum;
+}
+
+static void
+mspeth_dump_queues(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       int unit = lp->unit;
+       int i;
+
+       /* Halt Xmit and Recv to preserve the state of queues */
+       msp_write(lp, MSPETH_Rx_Ctl, msp_read(lp, MSPETH_Rx_Ctl) & ~Rx_RxEn);
+       msp_write(lp, MSPETH_Tx_Ctl, msp_read(lp, MSPETH_Tx_Ctl) & ~Tx_En);
+
+       /* Print receive queue */
+       printk(KERN_INFO "Receive Queue\n");
+       printk(KERN_INFO "=============\n\n");
+       printk(KERN_INFO "rxfd_base = 0x%08x\n",
+               (unsigned int) lp->rxfd_base);
+       printk(KERN_INFO "rxfd_curr = 0x%08x\n",
+               (unsigned int) lp->rxfd_curr);
+       for (i = 0; i < RX_BUF_NUM; i++) {
+               printk(KERN_INFO "%d:", i);
+               dump_qdesc((struct q_desc *) &lp->rxfd_base[i]);
+       }
+
+       /* Print transmit queue */
+       printk(KERN_INFO "\nTransmit Queue\n");
+       printk(KERN_INFO "==============\n");
+       printk(KERN_INFO "txfd_base = 0x%08x\n",
+               (unsigned int) lp->txfd_base);
+       printk(KERN_INFO "tx_head = %d, tx_tail = %d\n",
+               lp->tx_head, lp->tx_tail);
+       for (i = 0; i < TX_BUF_NUM; i++) {
+               printk(KERN_INFO "%d:", i);
+               dump_qdesc((struct q_desc *) &lp->txfd_base[i]);
+       }
+
+       /* Print the free buffer list */
+       printk(KERN_INFO "\nFree Buffer List\n");
+       printk(KERN_INFO "================\n");
+       printk(KERN_INFO "blfd_ptr = 0x%08x\n", (unsigned int) lp->blfd_ptr);
+       dump_blist(lp->blfd_ptr);
+
+       /* Print the bdnum history and current index as a reference */
+       printk(KERN_INFO "\nbdnum history\n");
+       printk(KERN_INFO "=============\n");
+       for (i = 0; i < RX_BUF_NUM; i++) {
+               printk(KERN_INFO "\t%d\t%d\t%d\t%d\n",
+                       rx_bdnums[unit][4 * i],
+                       rx_bdnums[unit][4 * i + 1],
+                       rx_bdnums[unit][4 * i + 2],
+                       rx_bdnums[unit][4 * i + 3]);
+       }
+       printk(KERN_INFO "Current bdnum index: %d\n", rx_bdnums_ind[unit]);
+
+       /* Re-enable Xmit/Recv */
+       msp_write(lp, MSPETH_Rx_Ctl, msp_read(lp, MSPETH_Rx_Ctl) | Rx_RxEn);
+       msp_write(lp, MSPETH_Tx_Ctl, msp_read(lp, MSPETH_Tx_Ctl) | Tx_En);
+}
+
+static void
+mspeth_dump_stats(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+
+       printk(KERN_INFO "Interface stats:\n");
+       printk(KERN_INFO "\ttx_ints: %d\n", lp->lstats.tx_ints);
+       printk(KERN_INFO "\trx_ints: %d\n", lp->lstats.rx_ints);
+       printk(KERN_INFO "\ttx_full: %d\n", lp->lstats.tx_full);
+       printk(KERN_INFO "\tfd_exha: %d\n", lp->lstats.fd_exha);
+}
+#else
+#define mspeth_dump_stats(a) do {} while (0)
+#define mspeth_dump_queues(a) do {} while (0)
+#define catalog_rx_bdnum(a, b) do {} while (0)
+#define dump_blist(a) do {} while (0)
+#endif /* MSPETH_DUMP_QUEUES */
+
+/*
+ * Actual functions used in the driver are defined here. They should
+ * all start with mspeth.
+ */
+
+/**************************************************************************
+ * Check for an mspeth ethernet device and return 0 if there is one.
+ * Also a good time to fill out some of the device fields and do some
+ * preliminary initialization. The mspeth resources are statically
+ * allocated.
+ */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+int mspeth_probe(struct platform_device *pldev)
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+int __init mspeth_probe(struct net_device *dev)
+#endif
+{
+       int unit, hwunit;
+       int i, err;
+       u8 macaddr[8];
+       struct mspeth_priv *lp;
+       char tmp_str[128];
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+       struct net_device *dev = NULL;
+       struct resource *res;
+       void *mapaddr;
+       unit = pldev->id;
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+       sscanf(dev->name, "eth%d", &unit);
+#endif
+
+       /* default return value -- no device here */
+       err = -ENODEV;
+
+       /*
+        * Scan the hardware list and associate a logical unit with a
+        * hardware unit it's important to keep these two straight.
+        * hwunit is used for accessing the prom and all hardware.
+        * unit is used when parsing the commandline and any other
+        * uses that might refer to *all* eth devices (not just mspeth
+        * devices) in the system.
+        */
+       for (i = 0, hwunit = 0; hwunit < MSPETH_MAX_UNITS; hwunit++) {
+               if (identify_enet(hwunit) != FEATURE_NOEXIST)
+                       if (i++ == unit)
+                               break;
+       }
+
+       /* Sanity checks on hardware parameters */
+       if (unit < 0 || hwunit >= MSPETH_MAX_UNITS)
+               goto out_err;
+
+       /* Retrieve the mac address from the PROM */
+       snprintf(tmp_str, 128, "ethaddr%d", hwunit);
+       if (get_ethernet_addr(tmp_str, macaddr)) {
+               printk(KERN_WARNING "MSPETH(probe): "
+                       "No Mac addr specified for eth%d, hwunit %d\n",
+                       unit, hwunit);
+               goto out_err;
+       }
+
+       if (macaddr[0] & 0x01) {
+               printk(KERN_WARNING "MSPETH(probe): "
+                       "Bad Multicast Mac addr specified for eth%d, "
+                       "hwunit %d %02x:%02x:%02x:%02x:%02x:%02x\n",
+                       unit, hwunit,
+                       macaddr[0], macaddr[1], macaddr[2],
+                       macaddr[3], macaddr[4], macaddr[5]);
+               goto out_err;
+       }
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+       dev = alloc_etherdev(sizeof(struct mspeth_priv));
+       if (!dev) {
+               err = -ENOMEM;
+               goto out_err;
+       }
+
+       SET_MODULE_OWNER(dev);
+       SET_NETDEV_DEV(dev, &pldev->dev);
+       dev_set_drvdata(&pldev->dev, dev);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+       /* Create & initialize the local device structure */
+       if (dev->priv == NULL) {
+               dev->priv = kmalloc(sizeof(struct mspeth_priv),
+                                       GFP_KERNEL);
+               if (dev->priv == NULL)
+                       goto out_err;
+       }
+#endif
+
+       lp = netdev_priv(dev);
+       memset(lp, 0, sizeof(struct mspeth_priv));
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+       lp->dev = &pldev->dev;
+
+       res = platform_get_resource(pldev, IORESOURCE_MEM, 0);
+       if (!res) {
+               printk(KERN_ERR "MSPETH(probe) %s: "
+                       "IOMEM resource not found for eth%d\n",
+                       dev->name, unit);
+               goto out_netdev;
+       }
+       
+       /* reserve the memory region */
+       if (!request_mem_region(res->start, res->end - res->start + 1,
+                               cardname)) {
+               printk(KERN_ERR "MSPETH(probe) %s: unable to "
+                       "get memory/io address region 0x08%lx\n",
+                       dev->name, dev->base_addr);
+               goto out_netdev;
+       }
+
+       /* remap the memory */
+       mapaddr = ioremap_nocache(res->start, res->end - res->start + 1);
+       if (!mapaddr) {
+               printk(KERN_WARNING "MSPETH(probe) %s: "
+                       "unable to ioremap address 0x%08x\n",
+                       dev->name, res->start);
+               goto out_unreserve;
+       }
+       
+       lp->mapaddr = mapaddr;
+       dev->base_addr = res->start;
+       dev->irq = platform_get_irq(pldev, 0);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+       /*
+        * Dig out the parameters from the defines and do other
+        * hwunit specific stuff
+        */
+       switch (hwunit) {
+       case 0:
+               dev->base_addr = MSP_MAC0_BASE;
+               dev->irq = MSP_INT_MAC0;
+               break;
+       case 1:
+               dev->base_addr = MSP_MAC1_BASE;
+               dev->irq = MSP_INT_MAC1;
+               break;
+       case 2:
+               dev->base_addr = MSP_MAC2_BASE;
+               dev->irq = MSP_INT_MAC2;
+               break;
+       default:
+               printk(KERN_WARNING "MSPETH(probe): "
+                       "Unsupported hardware unit %d\n", hwunit);
+               goto out_unmap;
+       }
+
+       /* reserve the memory region */
+       if (!request_mem_region(dev->base_addr, MSP_MAC_SIZE, cardname)) {
+               printk(KERN_ERR "MSPETH(probe) %s: unable to "
+                       "get memory/io address region 0x08%lx\n",
+                       dev->name, dev->base_addr);
+               goto out_err;
+       }
+
+       /* remap the memory */
+       lp->mapaddr = ioremap_nocache(dev->base_addr, MSP_MAC_SIZE);
+       if (!lp->mapaddr) {
+               printk(KERN_ERR "MSPETH(probe) %s: unable to "
+                       "ioremap address 0x%08lx\n",
+                       dev->name, dev->base_addr);
+               goto out_unreserve;
+       }
+#endif
+       
+       /* remap the system reset registers */
+       lp->rstaddr = ioremap_nocache(MSP_RST_BASE, MSP_RST_SIZE);
+       if (!lp->rstaddr) {
+               printk(KERN_ERR "MSPETH(probe) %s: unable to "
+                       "ioremap address 0x%08x\n",
+                       dev->name, MSP_RST_BASE);
+               goto out_unmap;
+       }
+
+       /* set the logical and hardware units */
+       lp->unit = unit;
+       lp->hwunit = hwunit;
+
+       /* probe for PHYS attached to this MACs MDIO interface */
+       if (mspeth_phyprobe(dev))
+               goto out_unmap;
+
+       /* parse the environment and command line */
+       mspeth_init_cmdline(dev);
+       mspeth_init_phyaddr(dev);
+
+       /* MAC address */
+       dev->addr_len = ETH_ALEN;
+       for (i = 0; i < dev->addr_len; i++)
+               dev->dev_addr[i] = macaddr[i];
+
+       /* register the /proc entry */
+       snprintf(tmp_str, 128, "pmcmspeth%d", unit);
+       create_proc_read_entry(tmp_str, 0644, proc_net,
+                               mspeth_proc_info, dev);
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+       ether_setup(dev);
+#endif
+       /* set the various call back functions */
+       dev->open               = mspeth_open;
+       dev->stop               = mspeth_close;
+       dev->tx_timeout         = mspeth_tx_timeout;
+       dev->watchdog_timeo     = TX_TIMEOUT * HZ;
+       dev->hard_start_xmit    = mspeth_send_packet;
+       dev->get_stats          = mspeth_get_stats;
+       dev->set_multicast_list = mspeth_set_multicast_list;
+#ifdef CONFIG_MSPETH_NAPI
+       dev->poll               = mspeth_poll;
+       dev->weight             = NAPI_WEIGHT;
+#endif
+
+       /* debugging output */
+       printk(KERN_INFO
+               "eth%d: found at physical address %lx, irq %d\n",
+               unit, dev->base_addr, dev->irq);
+       if (mspeth_debug > 1) {
+               printk(KERN_INFO "MSPETH(probe) eth%d: "
+                       "associated with hardware unit %d\n",
+                       unit, hwunit);
+               printk(KERN_INFO "MSPETH(probe) eth%d: assigned "
+                       "MAC address %02x:%02x:%02x:%02x:%02x:%02x\n",
+                       unit, macaddr[0], macaddr[1], macaddr[2],
+                       macaddr[3], macaddr[4], macaddr[5]);
+               printk(KERN_INFO "MSPETH(probe) eth%d: "
+                       "phytype %c, phyclk %c\n",
+                       unit, identify_enet(hwunit),
+                       identify_enetTxD(hwunit));
+       }
+
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+       /* initialize the socket buffer recycle bin */
+       init_skbuff_bin();
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+       err = register_netdev(dev);
+       if (err) {
+               printk(KERN_WARNING "MSPETH(probe) eth%d: "
+                       "unable to register network device\n", unit);
+               goto out_unmap;
+       }
+#endif
+
+       return 0;
+
+out_unmap:
+       if (lp->rstaddr)
+               iounmap(lp->rstaddr);   
+       iounmap(lp->mapaddr);
+       
+out_unreserve:
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+       release_mem_region(res->start, res->end - res->start + 1);
+
+out_netdev: 
+       free_netdev(dev);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+       release_mem_region(dev->base_addr, MSP_MAC_SIZE);
+#endif
+
+out_err:
+       return err;
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+/**************************************************************************
+ * Release the mspeth ethernet device and return 0 if there is one.
+ */
+static int
+mspeth_remove(struct platform_device *pldev)
+{
+       struct net_device *dev = dev_get_drvdata(&pldev->dev);
+       struct mspeth_priv *lp = netdev_priv(dev);
+       struct mspeth_phy **tail_pp;
+
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+       skb_bin.user_count--;
+       if (skb_bin.user_count == 0) {
+               /* free the recycle bin */
+               free_skbuff_bin();
+       }
+#endif
+
+       for (tail_pp = &root_phy_dev; *tail_pp != NULL; ) {
+               struct mspeth_phy **next_pp = &((*tail_pp)->next_phy);
+               kfree(*tail_pp);
+               tail_pp = next_pp;
+       }
+
+       unregister_netdev(dev);
+               
+       iounmap(lp->rstaddr);
+       lp->rstaddr = NULL;
+       iounmap(lp->mapaddr);
+       lp->mapaddr = NULL;
+       release_mem_region(dev->base_addr, MSP_MAC_SIZE);
+
+       free_netdev(dev);
+       
+       return 0;       
+}
+#endif
+
+/**************************************************************************
+ * Probe the hardware and fill out the array of PHY control elements
+ */
+static int
+mspeth_phyprobe(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       u32 reg1;
+       int phyaddr;
+       struct mspeth_phy tmp_phy;
+       struct mspeth_phy **tail_pp;
+
+       tmp_phy.next_phy = NULL;
+       tmp_phy.hwunit = lp->hwunit;
+       tmp_phy.phyaddr = 0;
+       tmp_phy.memaddr = lp->mapaddr + MSPETH_MD_DATA;
+       tmp_phy.assigned = false;
+       tmp_phy.linkup = false;
+       spin_lock_init(&tmp_phy.lock);
+
+       /* find the tail of the phy list */
+       for (tail_pp = &root_phy_dev; *tail_pp != NULL;
+               tail_pp = &((*tail_pp)->next_phy)) {;}
+
+       /* probe the phys and add to list */
+       for (phyaddr = 0; phyaddr < MD_MAX_PHY; phyaddr++) {
+               tmp_phy.phyaddr = phyaddr;
+               reg1 = mspphy_read(&tmp_phy, MII_BMSR);
+
+               if ((reg1 & BMSR_EXISTS) &&
+                   reg1 != 0xffff && reg1 != 0xc000) {
+                       if (mspeth_debug > 1)
+                               printk(KERN_INFO "MSPETH(phyprobe): "
+                                       "phyaddr = %d, hwindex = %d has "
+                                       "phy status 0x%04x\n",
+                                       phyaddr, lp->hwunit, reg1);
+
+                       *tail_pp = kmalloc(sizeof(struct mspeth_phy),
+                                               GFP_KERNEL);
+                       if (!*tail_pp) {
+                               printk(KERN_WARNING "MSPETH(phyprobe) "
+                                       "eth%d: unable to allocate phy\n",
+                                       lp->hwunit);
+                               return -1;
+                       }
+
+                       **tail_pp = tmp_phy;
+                       spin_lock_init(&((*tail_pp)->lock));
+                       tail_pp = &((*tail_pp)->next_phy);
+               }
+       }
+
+       return 0;
+}
+
+/**************************************************************************
+ * Scan the environment and fill the phyaddresses
+ */
+static void
+mspeth_init_phyaddr(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       int hwunit;
+       int phyaddr;
+       char *phystr;
+       char name[80];
+
+       /* defaults */
+       lp->phyptr = NULL;
+
+       /* new style enviroment scan to determine the phy addresses */
+       sprintf(name, "phyaddr%d", lp->hwunit);
+       phystr = prom_getenv(name);
+
+       if (mspeth_debug > 0)
+               printk(KERN_INFO "MSPETH(init_phyaddr): "
+                       "hwunit = %d, phystr prom = \"%s\"\n",
+                       lp->hwunit, phystr);
+
+       if (phystr != NULL &&
+           sscanf(phystr, "%d:%d", &hwunit, &phyaddr) == 2 &&
+           hwunit < MSPETH_MAX_UNITS &&
+           (phyaddr < MD_MAX_PHY || phyaddr == MD_DYNAMIC_PHY)) {
+               /*
+                * Look through the phylist and find a phy that matches
+                * the PROM settings
+                */
+               for (lp->phyptr = root_phy_dev; lp->phyptr != NULL;
+                               lp->phyptr = lp->phyptr->next_phy) {
+                       if (lp->phyptr->phyaddr == phyaddr &&
+                           lp->phyptr->hwunit == hwunit) {
+                               if (lp->phyptr->assigned) {
+                                       lp->phyptr = NULL;
+                                       printk(KERN_WARNING
+                                               "MSPETH(init_phyaddr) %s: "
+                                               "PROM phyaddress is already "
+                                               "in use!\
+                                               phystr prom = \"%s\"\n",
+                                               dev->name, phystr);
+                               } else
+                                       lp->phyptr->assigned = true;
+
+                               break;
+                       }
+               }
+       } else {
+               /*
+                * No acceptable PROM settings so we have to make
+                * something up
+                */
+               if (lp->option & MSP_OPT_SWITCH) {
+                       /*
+                        * Commandline set us to a switch so no phy
+                        * settings required. Consider changing this later
+                        * so that we can access the registers in the
+                        * switch through MDIO etc. Could be autoprobed too.
+                        */
+               } else {
+                       /*
+                        * Search through the list of phys and use the
+                        * first unassigned one. We need some way of
+                        * determining which phy is connected to which
+                        * MAC other than first come, first serve.
+                        *
+                        * stjeanma, 2006-02-13:
+                        * We must keep all PHYs on a global list for
+                        * boards which have all PHY MDIOs hooked to a
+                        * single MAC. However for boards with PHYs hooked
+                        * up to inidvidual MACs, we must first search the
+                        * list for PHYs belonging to the MAC being
+                        * initialized.
+                        */
+                       for (lp->phyptr = root_phy_dev; lp->phyptr != NULL;
+                                       lp->phyptr = lp->phyptr->next_phy) {
+                               if (!lp->phyptr->assigned &&
+                                   lp->phyptr->hwunit == lp->hwunit) {
+                                       lp->phyptr->assigned = true;
+                                       break;
+                               }
+                       }
+
+                       if (lp->phyptr == NULL) {
+                               for (lp->phyptr = root_phy_dev;
+                                    lp->phyptr != NULL;
+                                    lp->phyptr = lp->phyptr->next_phy) {
+                                       if (!lp->phyptr->assigned) {
+                                               lp->phyptr->assigned = true;
+                                               break;
+                                       }
+                               }
+                       }
+               }
+
+               /* rudimentary error checking */
+               if (phystr != NULL)
+                       printk(KERN_WARNING "MSPETH(init_phyaddr) "
+                               "eth%d: bad phyaddr value %s\n",
+                               lp->unit, phystr);
+       }
+}
+
+/**************************************************************************
+ * Scan the environment to get the kernel command line options
+ * for ethernet.
+ */
+static void
+mspeth_init_cmdline(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       int index;
+       int unit;
+       char c = ' ';
+       char command_line[COMMAND_LINE_SIZE];
+       char *ptr = command_line;
+       char *ethptr = NULL;
+
+       /* default options */
+       lp->option = MSP_OPT_AUTO;
+
+       /* scan the command line looking for static configurations */
+       strcpy(command_line, prom_getcmdline());
+       while (c != '\0') {
+               if (c != ' ' || memcmp(ptr, "ip=", 3) != 0) {
+                       c = *ptr++;
+                       continue;
+               }
+
+               c = *ptr++;
+               index = 0;
+               unit = -1;
+
+               while (index < 8) {
+                       c = *ptr++;
+
+                       if (c == '\0' || c == ' ') {
+                               if (index == 7) {
+                                       index++;
+                                       *--ptr = '\0';
+                                       ptr++;
+                               }
+                               break;
+                       }
+
+                       if (c == ':') {
+                               index++;
+                               if (index == 5) {
+                                       if (memcmp(ptr, "eth", 3) != 0)
+                                               break;
+
+                                       ethptr = &ptr[3];
+                                       ptr = ethptr;
+                               }
+
+                               if (index == 6) {
+                                       *--ptr = '\0';
+                                       ptr++;
+                                       unit = simple_strtol(
+                                                       ethptr, NULL, 0);
+                               }
+
+                               if (index == 7) {
+                                       ethptr = ptr;
+                               }
+
+                               if (index == 8) {
+                                       *--ptr = '\0';
+                                       ptr++;
+                               }
+                       }
+               }
+
+               if (index < 8 || unit < 0 || unit > MSPETH_MAX_UNITS)
+                       continue;
+
+               /* check to see if this our option and parse them out */
+               if (lp->unit == unit) {
+                       if (memcmp(ethptr, "100fs", 5) == 0)
+                               /* 100M full-duplex switch */
+                               lp->option = MSP_OPT_100M | MSP_OPT_FDUP |
+                                               MSP_OPT_SWITCH;
+                       else if (memcmp(ethptr, "100hs", 5) == 0)
+                               /* 100M half-duplex switch */
+                               lp->option = MSP_OPT_100M | MSP_OPT_HDUP |
+                                               MSP_OPT_SWITCH;
+                       else if (memcmp(ethptr, "10fs", 4) == 0)
+                               /* 10M full-duplex switch */
+                               lp->option = MSP_OPT_10M | MSP_OPT_FDUP |
+                                               MSP_OPT_SWITCH;
+                       else if (memcmp(ethptr, "10hs", 4) == 0)
+                               /* 10M half-duplex switch */
+                               lp->option = MSP_OPT_100M | MSP_OPT_HDUP |
+                                               MSP_OPT_SWITCH;
+                       else if (memcmp(ethptr, "100f", 4) == 0)
+                               /* 100M full-duplex */
+                               lp->option = MSP_OPT_100M | MSP_OPT_FDUP;
+                       else if (memcmp(ethptr, "100h", 4) == 0)
+                               /* 100M half-duplex */
+                               lp->option = MSP_OPT_100M | MSP_OPT_HDUP;
+                       else if (memcmp(ethptr, "10f", 3) == 0)
+                               /* 10M full-duplex */
+                               lp->option = MSP_OPT_10M | MSP_OPT_FDUP;
+                       else if (memcmp(ethptr, "10h", 3) == 0)
+                               /* 100M half-duplex */
+                               lp->option = MSP_OPT_10M | MSP_OPT_HDUP;
+               }
+
+               if (mspeth_debug > 0)
+                       printk(KERN_INFO "MSPETH(init_cmdline) eth%d: "
+                               "boot = %s, option = %02x\n",
+                               lp->unit, command_line, lp->option);
+       }
+}
+
+/**************************************************************************
+ * Reset the phy
+ */
+static void
+mspeth_phy_reset(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       u32 id0, id1;
+
+       if (lp->phyptr == NULL)
+               return;
+
+       /* reset the phy */
+       mspphy_write(lp->phyptr, MII_BMCR, BMCR_RESET);
+       while ((mspphy_read(lp->phyptr, MII_BMCR) & BMCR_RESET) != 0)
+               udelay(100);
+
+       if (mspeth_debug > 0) {
+               id0 = mspphy_read(lp->phyptr, MII_PHYSID1);
+               id1 = mspphy_read(lp->phyptr, MII_PHYSID2);
+               printk(KERN_INFO "MSPETH(phy_reset) eth%d: "
+                       "PHY ID %04x %04x\n", lp->unit, id0, id1);
+               printk(KERN_INFO "MSPETH(phy_reset) eth%d: "
+                       "speed = %d, duplex = %s\n", lp->unit, lp->speed,
+                       ((lp->fullduplex) ? "FULL" : "HALF"));
+       }
+}
+
+/**************************************************************************
+ * Initialize the phy -- set the speed and duplex. Wait for
+ * autonegotiation to complete. If it doesn't then force the
+ * renegotiation. If *that* fails then reset the phy and try
+ * again. Finally just make some assumptions. If autonegotiation
+ * is disabled then just force values.
+ */
+static void
+mspeth_phy_init(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       u32 ctl, neg_result;
+       int i;
+       enum {AUTONEG, AUTONEG_FORCE, PHYRESET} auto_status;
+       char *link_type;
+       char *link_stat;
+
+       /* check for defaults and autonegotiate */
+       if (lp->option == MSP_OPT_AUTO) {
+               /*
+                * Make sure the autonegotiation is enabled and then wait
+                * for the autonegotion to complete.
+                */
+               link_type = "Autoneg";
+               for (auto_status = AUTONEG; auto_status <= PHYRESET;
+                                               auto_status++) {
+                       /*
+                        * Run through all the various autonegotion methods
+                        * until we fail
+                        */
+                       switch (auto_status) {
+                       case AUTONEG:
+                               mspphy_write(lp->phyptr, MII_BMCR,
+                                               BMCR_ANENABLE);
+                               break;
+                       case AUTONEG_FORCE:
+                               printk(KERN_INFO "MSPETH(phy_init) "
+                                       "%s: Forcing autonegotiation\n",
+                                       dev->name);
+                               mspphy_write(lp->phyptr, MII_BMCR,
+                                       BMCR_ANENABLE | BMCR_ANRESTART);
+                               break;
+                       case PHYRESET:
+                               printk(KERN_INFO "MSPETH(phy_init) "
+                                       "%s: Resetting phy\n", dev->name);
+                               mspphy_write(lp->phyptr, MII_BMCR,
+                                               BMCR_RESET);
+                               while ((mspphy_read(lp->phyptr, MII_BMCR) &
+                                       BMCR_RESET) != 0)
+                                       udelay(100);
+                               mspphy_write(lp->phyptr, MII_BMCR,
+                                       BMCR_ANENABLE | BMCR_ANRESTART);
+                               break;
+                       default:
+                               printk(KERN_WARNING "MSPETH(phy_init) "
+                                       "%s: Unknown autonegotation mode?\n",
+                                       dev->name);
+                               return;
+                       }
+
+                       /*
+                        * Autoneg should be underway, so lets loop
+                        * and wait for it to exit.
+                        */
+                       printk(KERN_INFO
+                               "%s: Auto Negotiation...", dev->name);
+
+                       for (i = 0; i < 2000 &&
+                                   !(mspphy_read(lp->phyptr, MII_BMSR) &
+                                   BMSR_ANEGCOMPLETE); i++) {
+                               mdelay(1);
+                       }
+
+                       if (i == 2000) {
+                               /*
+                                * Autonegotiation failed to complete so
+                                * go to next level of negotiation.
+                                */
+                               printk(KERN_INFO " failed.\n");
+                               continue;
+                       }
+
+                       /* must have succeeded so we can set the speed etc */
+                       printk(KERN_INFO " done.\n");
+                       neg_result = mspphy_read(lp->phyptr, MII_LPA);
+                       if (neg_result & (LPA_100FULL | LPA_100HALF))
+                               lp->speed = 100;
+                       else
+                               lp->speed = 10;
+
+                       if (neg_result & (LPA_100FULL | LPA_10FULL))
+                               lp->fullduplex = true;
+                       else
+                               lp->fullduplex = false;
+                       break;
+               }
+
+               /*
+                * Check to see if *everything* failed and try to set
+                * some default values.
+                */
+               if (auto_status > PHYRESET) {
+                       printk(KERN_WARNING "Autonegotion failed. "
+                               "Assuming 10Mbps, half-duplex.\n");
+                       link_type = "Autoneg (failed)";
+                       lp->speed = 10;
+                       lp->fullduplex = false;
+               }
+       } else {
+               /*
+                * If speed and duplex are statically configured then
+                * set that here.
+                */
+               link_type = "Static";
+               ctl = 0;
+               if (lp->option & MSP_OPT_100M) {
+                       lp->speed = 100;
+                       ctl |= BMCR_SPEED100;
+               } else {
+                       lp->speed = 10;
+                       ctl &= ~BMCR_SPEED100;
+               }
+
+               if (lp->option & MSP_OPT_FDUP) {
+                       lp->fullduplex = true;
+                       ctl |= BMCR_FULLDPLX;
+               } else {
+                       lp->fullduplex = false;
+                       ctl &= ~BMCR_FULLDPLX;
+               }
+
+               /* stjeanma: Don't write to the PHY for a switch */
+               if (!(lp->option & MSP_OPT_SWITCH))
+                       mspphy_write(lp->phyptr, MII_BMCR, ctl);
+       }
+
+       if (!(lp->option & MSP_OPT_SWITCH)) {
+               /*
+                * Wait for a little bit to see if we've got a carrier
+                * -- don't go crazy though.
+                */
+               printk(KERN_INFO
+                       "%s: Waiting for carrier ...", dev->name);
+               for (i = 0; i < 1000 &&
+                           !(mspphy_read(lp->phyptr, MII_BMSR) &
+                           BMSR_LSTATUS); i++) {
+                       mdelay(1);
+               }
+
+               if (i == 1000) {
+                       printk(KERN_INFO " no carrier.\n");
+                       lp->phyptr->linkup = false;
+                       netif_carrier_off(dev);
+                       link_stat = "Link down";
+               } else {
+                       printk(KERN_INFO " carrier detected.\n");
+                       lp->phyptr->linkup = true;
+                       netif_carrier_on(dev);
+                       link_stat = "Link up";
+               }
+       } else {
+
+               /*
+                * Assume we're connected. If we're using a switch
+                * we always will be.
+                */
+               printk(KERN_INFO
+                       "%s: Using internal switch\n", dev->name);
+
+               /* stjeanma: PHY might not be allocated for a switch */
+               if (lp->phyptr != NULL)
+                       lp->phyptr->linkup = true;
+
+               /* Turn on the carrier */
+               netif_carrier_on(dev);
+               link_stat = "Link up";
+       }
+
+       /*
+        * Configure the MAC with the duplex setting
+        * -- it doesn't care about speed.
+        */
+       if (lp->fullduplex)
+               msp_write(lp, MSPETH_MAC_Ctl,
+                       msp_read(lp, MSPETH_MAC_Ctl) | MAC_FullDup);
+       else
+               msp_write(lp, MSPETH_MAC_Ctl,
+                       msp_read(lp, MSPETH_MAC_Ctl) & ~MAC_FullDup);
+
+       printk(KERN_INFO
+               "%s: %s, %s, linkspeed %dMbps, %s Duplex\n",
+               dev->name, link_type, link_stat, lp->speed,
+               (lp->fullduplex) ? "Full" : "Half");
+}
+
+/**************************************************************************
+ * Check the link for a carrier when the link check timer expires.
+ * If the link is down and it has been down for a while (at least 1
+ * timer delay) then change the upper layer link state to match.
+ * Do a soft-restart if we're bringing the link up. Reschedule the
+ * timer of course.
+ */
+static void
+mspeth_link_check(unsigned long data)
+{
+       struct net_device *dev = (struct net_device *)data;
+       struct mspeth_priv *lp = netdev_priv(dev);
+       enum {LINKGOOD, LINKBAD, LINKUNKNOWN} linkstatus;
+
+       /* check the current link status */
+       linkstatus = LINKUNKNOWN;
+       if (mspphy_read(lp->phyptr, MII_BMSR) & BMSR_LSTATUS) {
+               if (lp->phyptr->linkup)
+                       linkstatus = LINKGOOD;
+               lp->phyptr->linkup = true;
+       } else {
+               if (!lp->phyptr->linkup)
+                       linkstatus = LINKBAD;
+               lp->phyptr->linkup = false;
+       }
+
+       /* check the upper layer status */
+       if (netif_carrier_ok(dev)) {
+               /*
+                * Upper layer thinks we're ok but the link is bad, so
+                * take the link down.
+                */
+               if (linkstatus == LINKBAD) {
+                       printk(KERN_INFO "MSPETH(link_check) %s: "
+                               "NO LINK DETECTED\n", dev->name);
+                       netif_stop_queue(dev);
+                       netif_carrier_off(dev);
+               }
+       } else {
+               /*
+                * Upper layer thinks we're broken but we've recovered so
+                * do a soft-restart and bring the link back up.
+                */
+               if (linkstatus == LINKGOOD) {
+                       printk(KERN_INFO "MSPETH(link_check) %s: "
+                               "LINK DETECTED\n", dev->name);
+                       mspeth_soft_restart(dev);
+                       netif_carrier_on(dev);
+               }
+       }
+
+       /* reschedule the timer */
+       lp->link_timer.expires = jiffies + HZ / LINK_DELAY_DIV;
+       add_timer(&lp->link_timer);
+}
+
+/**************************************************************************
+ * Reset the hardware and restore defaults. Queues etc must be
+ * cleared afterwards, although we don't change the pointers so
+ * they don't need to be reallocated.
+ */
+static void
+mspeth_mac_reset(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       int i;
+       u32 rstpat;
+
+       /* hardware reset */
+       switch (lp->hwunit) {
+       case 0:
+               rstpat = MSP_EA_RST;
+               break;
+       case 1:
+               rstpat = MSP_EB_RST;
+               break;
+       case 2:
+               rstpat = MSP_EC_RST;
+               break;
+       default:
+               printk(KERN_WARNING
+                       "MSPETH(mac_reset) %s: Unsupported hwunit %d\n",
+                       dev->name, lp->hwunit);
+               return;
+       }
+       
+       __raw_writel(rstpat, lp->rstaddr + MSPRST_SET);
+       mdelay(100);
+       __raw_writel(rstpat, lp->rstaddr + MSPRST_CLR);
+
+       /* Wait for the MAC to come out of reset */
+       for (i = 0; i < 10; i++) {
+               if ((__raw_readl(lp->rstaddr + MSPRST_STS) & rstpat) == 0)
+                       break;
+               ndelay(100);
+       }
+
+       /* initialize registers to default value */
+       msp_write(lp, MSPETH_MAC_Ctl, 0);
+       msp_write(lp, MSPETH_DMA_Ctl, 0);
+       msp_write(lp, MSPETH_TxThrsh, 0);
+       msp_write(lp, MSPETH_TxPollCtr, 0);
+       msp_write(lp, MSPETH_RxFragSize, 0);
+       msp_write(lp, MSPETH_Int_En, 0);
+       msp_write(lp, MSPETH_FDA_Bas, 0);
+       msp_write(lp, MSPETH_FDA_Lim, 0);
+       msp_write(lp, MSPETH_Int_Src, 0xffffffff); /* Write 1 to clear */
+       msp_write(lp, MSPETH_ARC_Ctl, 0);
+       msp_write(lp, MSPETH_Tx_Ctl, 0);
+       msp_write(lp, MSPETH_Rx_Ctl, 0);
+       msp_write(lp, MSPETH_ARC_Ena, 0);
+       (void)msp_read(lp, MSPETH_Miss_Cnt);    /* Read to clear */
+}
+
+/**************************************************************************
+ * Initialize the hardware and start the DMA/MAC RX/TX. The queues must
+ * be setup before this is called.
+ */
+static void
+mspeth_mac_init(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       int flags;
+
+       /* do not interrupt me while I'm configuring the MAC */
+       local_irq_save(flags);
+
+       /* configure the BRCTL RMII registers if we're an RMII device */
+       if (identify_enet(lp->hwunit) == ENET_RMII) {
+               u32 brctl = msp_read(lp, MSPETH_BCTRL_Reg) & ~RMII_Reset;
+               if (identify_enetTxD(lp->hwunit) == ENETTXD_RISING)
+                       brctl |= RMII_ClkRising;
+               if (identify_enetTxD(lp->hwunit) == ENETTXD_FALLING)
+                       brctl &= ~RMII_ClkRising;
+               if (lp->speed == 10)
+                       brctl |= RMII_10MBIT;
+               else
+                       brctl &= ~RMII_10MBIT;
+               msp_write(lp, MSPETH_BCTRL_Reg, brctl);
+       }
+
+       /* set some device structure parameters */
+       dev->tx_queue_len = TX_BUF_NUM;
+
+       /* load station address to ARC */
+       mspeth_set_arc_entry(dev, ARC_ENTRY_SOURCE, dev->dev_addr);
+
+       /* Enable ARC (broadcast and unicast) */
+       msp_write(lp, MSPETH_ARC_Ena, ARC_Ena_Bit(ARC_ENTRY_SOURCE));
+       msp_write(lp, MSPETH_ARC_Ctl, ARC_CompEn | ARC_BroadAcc);
+
+       /* configure DMA */
+       msp_write(lp, MSPETH_DMA_Ctl, DMA_CTL_CMD);
+
+       /* configure the RX/TX mac */
+       msp_write(lp, MSPETH_RxFragSize, 0);
+       msp_write(lp, MSPETH_TxPollCtr, TX_POLL_CNT);
+       msp_write(lp, MSPETH_TxThrsh, TX_THRESHOLD);
+
+       /* zero and enable the interrupts */
+       lp->fatal_icnt = 0;
+       msp_write(lp, MSPETH_Int_En, INT_EN_CMD);
+
+       /*
+        * Set queues
+        *
+        * hammtrev, 2005-11-25:
+        * Using the formula used in the old driver, which gives a
+        * little bit less than (RX_BUF_NUM - 1) << 5, allowing for more
+        * buffer descriptors attached to a frame descriptor.
+        */
+       msp_write(lp, MSPETH_FDA_Bas, (u32)lp->rxfd_base);
+       msp_write(lp, MSPETH_FDA_Lim, (RX_BUF_NUM - 1) << 5);
+
+       /*
+        * Activation method:
+        * First, enable the MAC Transmitter and the DMA Receive circuits.
+        * Then enable the DMA Transmitter and the MAC Receive circuits.
+        */
+       /* start DMA receiver */
+       msp_write(lp, MSPETH_BLFrmPtr, (u32)lp->blfd_ptr);
+       /* start MAC receiver */
+       msp_write(lp, MSPETH_Rx_Ctl, RX_CTL_CMD);
+
+       /* start the DMA transmitter */
+       msp_write(lp, MSPETH_TxFrmPtr, (u32)lp->txfd_base);
+
+#ifdef CONFIG_MSPETH_NAPI
+       /* start the MAC transmitter */
+       msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD & ~Tx_EnComp);
+#else
+       msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD);
+#endif /* CONFIG_MSPETH_NAPI */
+
+       /* turn the interrupts back on */
+       local_irq_restore(flags);
+}
+
+/**************************************************************************
+ * Start the Address Recognition circuit. It must be initialized with
+ * address of the device (which can be changed in the PROM).
+ */
+static void
+mspeth_set_arc_entry(struct net_device *dev, int index, unsigned char *addr)
+{
+       int arc_index = index * 6;
+       unsigned long arc_data;
+       unsigned long saved_addr;
+       struct mspeth_priv *lp = netdev_priv(dev);
+
+       saved_addr = msp_read(lp, MSPETH_ARC_Adr);
+
+       if (mspeth_debug > 1) {
+               int i;
+               printk(KERN_INFO "MSPETH(set_arc_entry) %s: "
+                       "arc %d:", dev->name, index);
+               for (i = 0; i < 6; i++)
+                       printk(KERN_INFO " %02x", addr[i]);
+               printk(KERN_INFO "\n");
+       }
+
+       if (index & 1) {
+               /* read modify write */
+               msp_write(lp, MSPETH_ARC_Adr, arc_index - 2);
+               arc_data = msp_read(lp, MSPETH_ARC_Data) & 0xffff0000;
+               arc_data |= addr[0] << 8 | addr[1];
+               msp_write(lp, MSPETH_ARC_Data, arc_data);
+
+               /* write whole word */
+               msp_write(lp, MSPETH_ARC_Adr, arc_index + 2);
+               arc_data = (addr[2] << 24) | (addr[3] << 16) |
+                               (addr[4] << 8) | addr[5];
+               msp_write(lp, MSPETH_ARC_Data, arc_data);
+       } else {
+               /* write whole word */
+               msp_write(lp, MSPETH_ARC_Adr, arc_index);
+               arc_data = (addr[0] << 24) | (addr[1] << 16) |
+                               (addr[2] << 8) | addr[3];
+               msp_write(lp, MSPETH_ARC_Data, arc_data);
+
+               /* read modify write */
+               msp_write(lp, MSPETH_ARC_Adr, arc_index + 4);
+               arc_data = msp_read(lp, MSPETH_ARC_Data) & 0x0000ffff;
+               arc_data |= addr[4] << 24 | (addr[5] << 16);
+               msp_write(lp, MSPETH_ARC_Data, arc_data);
+       }
+
+       if (mspeth_debug > 2) {
+               int i;
+               for (i = arc_index / 4; i < arc_index / 4 + 2; i++) {
+                       msp_write(lp, MSPETH_ARC_Adr, i * 4);
+                       printk(KERN_INFO "arc 0x%x: %08x\n",
+                               i * 4, msp_read(lp, MSPETH_ARC_Data));
+               }
+       }
+       msp_write(lp, MSPETH_ARC_Adr, saved_addr);
+}
+
+/**************************************************************************
+ * Initialize the RX/TX queues and the free buffer list. This routine
+ * allocates memory and care must be taken to free the memory when it
+ * is no longer required
+ */
+static bool
+mspeth_init_queues(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       int i, size;
+       u32 tmp_addr;
+       struct sk_buff *skb;
+       dma_addr_t dma_skb;
+
+       /*
+        * The queue structure allocates individual buffers large enough
+        * to hold an entire packet. There is no packing so each FD
+        * requires a single BD. There is one q_desc (an FD and a BD,
+        * 16-byte aligned) for each packet recieved and the same for
+        * each packet to transmit. The list of free buffers has one
+        * FD and an arbitrary number of BDs following it (but even).
+        * There is one BD for each RX buffer.
+        */
+
+       /*
+        * TODO: Need to add some error checking here for reentry into
+        * this routine.
+        */
+       /* descriptors for the rx/tx buffers and the buffer list */
+       size = (RX_BUF_NUM + TX_BUF_NUM) * sizeof(struct q_desc) +
+               sizeof(struct bl_desc);
+
+       /* test for allocation requirements */
+       if (lp->fd_base == NULL) {
+               /* add enough margin to align to 16-byte boundary */
+               lp->fd_base = kmalloc(size + (L1_CACHE_BYTES - 1),
+                                       GFP_KERNEL);
+               if (lp->fd_base == NULL) {
+                       printk(KERN_ERR "MSPETH(init_queues) %s: "
+                               "Cannot allocate space for descriptors!\n",
+                               dev->name);
+                       return false;
+               }
+
+               /*
+                * Move frame descriptors to uncached addresses. This
+                * prevents spurious IntBLEx interrupts.
+                */
+               lp->fd_base = (void*)KSEG1ADDR((u32)lp->fd_base);
+               memset(lp->fd_base, 0, size + (L1_CACHE_BYTES - 1));
+               
+               if (mspeth_debug > 1)
+                       printk(KERN_INFO
+                               "MSPETH(init_queues) %s: fd_base = %p\n",
+                               dev->name, lp->fd_base);
+       }
+
+       /*
+        * stjeanma, 2006-01-26:
+        * Add instead of subtract and take into account the
+        * architecture's cache line size.
+        */
+       tmp_addr = ((u32) lp->fd_base +
+                       (L1_CACHE_BYTES - 1)) & ~(L1_CACHE_BYTES - 1);
+
+       /* allocate the RX queue (aka free descriptor area) */
+       lp->rxfd_base = (struct q_desc *)tmp_addr;
+       lp->rxfd_curr = lp->rxfd_base;
+       tmp_addr += RX_BUF_NUM * sizeof(struct q_desc);
+
+       /*
+        * Initialize the RX queue (these values are mostly
+        * overwritten by the MAC).
+        */
+       for (i = 0; i < RX_BUF_NUM; i++) {
+               lp->rxfd_base[i].fd0.FDNext = 0x00000000;
+               lp->rxfd_base[i].fd0.FDSystem = 0x00000000;
+               lp->rxfd_base[i].fd0.FDStat = 0x00000000;
+               lp->rxfd_base[i].fd0.FDCtl = FD_CownsFD;
+               lp->rxfd_base[i].fd1.FDNext = 0x00000000;
+               lp->rxfd_base[i].fd1.FDSystem = 0x00000000;
+               lp->rxfd_base[i].fd1.FDStat = 0x00000000;
+               lp->rxfd_base[i].fd1.FDCtl = FD_CownsFD;
+       }
+
+       /* initialize the actual TX sk_buff pointers */
+       if (lp->txfd_base != NULL) {
+               for (i = 0; i < TX_BUF_NUM; i++) {
+                       skb = (struct sk_buff *)lp->txfd_base[i].fd.FDSystem;
+#if defined(CONFIG_DMA_NONCOHERENT) && \
+    LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+                       dma_skb = lp->txfd_base[i].fd1.FDStat;
+                       if (dma_skb != 0x00000000) {
+                               lp->txfd_base[i].fd1.FDStat = 0x00000000;
+                               /* unmap any dma pointers */
+                               dma_unmap_single(lp->dev, dma_skb,
+                                       skb->len, DMA_BIDIRECTIONAL);
+                       }
+#endif
+                       if (skb != NULL) {
+                               lp->txfd_base[i].fd.FDSystem = 0x00000000;
+                               dev_kfree_skb_any(skb);
+                       }
+               }
+       }
+
+       /* allocate the TX queue */
+       lp->txfd_base = (struct q_desc *)tmp_addr;
+       lp->tx_head = lp->tx_tail = 0;
+       tmp_addr += TX_BUF_NUM * sizeof(struct q_desc);
+
+       /* initialize the TX queue */
+       for (i = 0; i < TX_BUF_NUM; i++) {
+               lp->txfd_base[i].fd.FDNext = (u32)(&lp->txfd_base[i + 1]);
+               lp->txfd_base[i].fd.FDSystem = 0x00000000;
+               lp->txfd_base[i].fd.FDStat = 0x00000000;
+               lp->txfd_base[i].fd.FDCtl = 0x00000000;
+       }
+       lp->txfd_base[TX_BUF_NUM - 1].fd.FDNext = (u32)(&lp->txfd_base[0]);
+
+       /* initialize the buffer list FD */
+       lp->blfd_ptr = (struct bl_desc *)tmp_addr;
+       lp->blfd_ptr->fd.FDNext = (u32)lp->blfd_ptr;
+       lp->blfd_ptr->fd.FDCtl = (RX_BUF_NUM << 1) | FD_CownsFD;
+
+       /* allocate the RX sk_buff array */
+       if (lp->rx_skbp == NULL) {
+               lp->rx_skbp = (struct sk_buff **)kmalloc(
+                               (RX_BUF_NUM << 1) * sizeof(struct sk_buff *),
+                               GFP_KERNEL);
+               if (lp->rx_skbp == NULL) {
+                       printk(KERN_ERR "MSPETH(init_queues) %s: "
+                               "Cannot allocate the array of "
+                               "sk_buff pointers!\n", dev->name);
+                       return false;
+               }
+               
+               for (i = 0; i < RX_BUF_NUM << 1; i++)
+                       lp->rx_skbp[i] = NULL;
+       }
+
+       /* initialize the actual RX sk_buff pointers */
+       for (i = 0; i < RX_BUF_NUM << 1; i++) {
+               /* free up old sk_buffs */
+               skb = lp->rx_skbp[i];
+               if (skb != NULL) {
+                       lp->rx_skbp[i] = NULL;
+                       dev_kfree_skb_any(skb);
+               }
+
+               /* allocate and align the skb */
+               skb = dev_alloc_skb(MSP_END_BUFSIZE + 2);
+               if (skb == NULL) {
+                       printk(KERN_ERR "MSPETH(init_queues) %s: "
+                               "Cannot allocate the sk_buffs!\n", dev->name);
+                       return false;
+               }
+               lp->rx_skbp[i] = skb;
+               
+               /*
+                * Slign and fill out fields specific to our
+                * device. Notice that our device is smart about
+                * FCS etc.
+                */
+               skb_reserve(skb, 2);
+               skb->dev = dev;
+               skb->ip_summed = CHECKSUM_NONE;
+
+               /*
+                * Initialize the buffer list entries reserving 2 bytes
+                * in the skb results in a 16-byte aligned  IP header,
+                * but also puts the skb->data at a 16-bit boundary.
+                * The hardware requires a 32-bit aligned buffer. So we
+                * round back two bytes and then instruct the hardware
+                * to skip forward 2 bytes into the buffer.
+                */
+               lp->blfd_ptr->bd[i].BuffData = (u32)skb->data &
+                                               BD_DataAlign_MASK;
+               lp->blfd_ptr->bd[i].BDCtl = (BD_CownsBD |
+                       (i << BD_RxBDID_SHIFT) | MSP_END_BUFSIZE);
+       }
+
+       /* allocate the RX dma array */
+       if (lp->rx_dma_skbp == NULL) {
+               lp->rx_dma_skbp = (dma_addr_t *)kmalloc(
+                               (RX_BUF_NUM << 1) * sizeof(dma_addr_t),
+                               GFP_KERNEL);
+               if (lp->rx_dma_skbp == NULL) {
+                       printk(KERN_ERR "MSPETH(init_queues) %s: "
+                               "Cannot allocate the array of "
+                               "RX dma addresses!\n", dev->name);
+                       return false;
+               }
+               
+               for (i = 0; i < RX_BUF_NUM << 1; i++)
+                       lp->rx_dma_skbp[i] = 0x00000000;
+       }
+
+       /* initialize the RX dma pointers */
+       for (i = 0; i < RX_BUF_NUM << 1; i++) {
+#if defined(CONFIG_DMA_NONCOHERENT) && \
+    LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+               dma_skb = lp->rx_dma_skbp[i];
+               /* unmap any dma pointers */
+               if (dma_skb != 0x00000000) {
+                       lp->rx_dma_skbp[i] = 0x00000000;
+                       dma_unmap_single(lp->dev, dma_skb,
+                                       MSP_END_BUFSIZE, DMA_BIDIRECTIONAL);
+               }
+#endif
+       }
+
+       /* configure the queue length and return */
+       atomic_set(&lp->tx_qspc, TX_BUF_NUM);
+
+       return true;
+}
+
+/**************************************************************************
+ * Converse of the mspeth_init_queues routine. This frees all the memory
+ * associated with the queues. It must be called when closing the device.
+ */
+static void
+mspeth_free_queues(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       struct sk_buff *skb;
+       dma_addr_t dma_skb;
+       int i;
+
+       /* free up any TX buffers */
+       if (lp->txfd_base != NULL) {
+               for (i = 0; i < TX_BUF_NUM; i++) {
+                       skb = (struct sk_buff *)lp->txfd_base[i].fd.FDSystem;
+#if defined(CONFIG_DMA_NONCOHERENT) && \
+    LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+                       dma_skb = lp->txfd_base[i].fd1.FDStat;
+                       if (dma_skb != 0x00000000) {
+                               lp->txfd_base[i].fd1.FDStat = 0x00000000;
+                               /* unmap any dma pointers */
+                               dma_unmap_single(lp->dev, dma_skb,
+                                               skb->len, DMA_BIDIRECTIONAL);
+                       }
+#endif
+                       if (skb != NULL) {
+                               lp->txfd_base[i].fd.FDSystem = 0x00000000;
+                               dev_kfree_skb_any(skb);
+                       }
+               }
+       }
+
+       /* free up the RX sk_buff buffer and array */
+       if (lp->rx_skbp != NULL) {
+               for (i = 0; i < RX_BUF_NUM << 1; i++) {
+                       skb = lp->rx_skbp[i];
+                       if (skb != NULL) {
+                               dev_kfree_skb_any(skb);
+                       }
+               }
+               kfree(lp->rx_skbp);
+       }
+
+       /* unmap any RX dma pointers and free up the array */
+       if (lp->rx_dma_skbp != NULL) {
+#if defined(CONFIG_DMA_NONCOHERENT) && \
+    LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+               for (i = 0; i < RX_BUF_NUM << 1; i++) {
+                       dma_skb = lp->rx_dma_skbp[i];
+                       if (dma_skb != 0x00000000)
+                               dma_unmap_single(lp->dev, dma_skb,
+                                       MSP_END_BUFSIZE, DMA_BIDIRECTIONAL);
+               }
+#endif
+               kfree(lp->rx_dma_skbp);
+       }
+
+       /*
+        * Free the descriptor area. Move fd_base back to KSEG0 before
+        * freeing it.
+        */
+       if (lp->fd_base != NULL)
+               kfree((void*)KSEG0ADDR(lp->fd_base));
+
+       /* nullify all the pointers and zero out the queue space */
+       lp->fd_base = NULL;
+       lp->rxfd_base = NULL;
+       lp->rxfd_curr = NULL;
+       lp->txfd_base = NULL;
+       lp->blfd_ptr = NULL;
+       lp->rx_skbp = NULL;
+       lp->rx_dma_skbp = NULL;
+       lp->tx_head = lp->tx_tail = 0;
+
+       atomic_set(&lp->tx_qspc, 0);
+}
+
+/**************************************************************************
+ * Do a safe soft restart of the device. This *will* cause packet loss,
+ * so it's only used as a recovery mechanism.
+ */
+static void
+mspeth_soft_restart(struct net_device *dev)
+{
+       int flags;
+
+       printk(KERN_INFO "MSPETH(soft_restart) %s: "
+               "Soft device restart\n", dev->name);
+
+       netif_stop_queue(dev);
+
+       /* please don't interrupt me while I'm resetting everything */
+       local_irq_save(flags);
+
+       /* Try to restart the adaptor. */
+       mspeth_mac_reset(dev);
+       mspeth_init_queues(dev);
+       mspeth_mac_init(dev);
+       mspeth_phy_init(dev);
+
+       /* turn back on the interrupts */
+       local_irq_restore(flags);
+
+       /* and start up the queue! We should be fixed .... */
+       dev->trans_start = jiffies;
+       netif_wake_queue(dev);
+}
+
+/**************************************************************************
+ * Do a *hard* restart of the device. This *will* cause packet loss, so
+ * it's only used as a recovery mechanism
+ */
+static void
+mspeth_hard_restart(struct net_device *dev)
+{
+       int flags;
+
+       printk(KERN_INFO "MSPETH(hard_restart) %s: "
+               "Hard device restart\n", dev->name);
+
+       netif_stop_queue(dev);
+
+       /* please don't interrupt me while I'm resetting everything */
+       local_irq_save(flags);
+
+       /* Try to restart the adaptor. */
+       mspeth_mac_reset(dev);
+       mspeth_phy_reset(dev);
+       mspeth_free_queues(dev);
+       mspeth_init_queues(dev);
+       mspeth_mac_init(dev);
+       mspeth_phy_init(dev);
+
+       /* turn back on the interrupts */
+       local_irq_restore(flags);
+
+       /* and start up the queue! We should be fixed .... */
+       dev->trans_start = jiffies;
+       netif_wake_queue(dev);
+}
+
+/**************************************************************************
+ * Open/initialize the board. This is called (in the current kernel)
+ * sometime after booting when the 'ifconfig' program is run.
+ *
+ * This routine should set everything up anew at each open, even
+ * registers that "should" only need to be set once at boot, so that
+ * there is non-reboot way to recover if something goes wrong.
+ */
+static int
+mspeth_open(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       int err = -EBUSY;
+
+       /* reset the hardware, disabling/clearing all interrupts */
+       mspeth_mac_reset(dev);
+       mspeth_phy_reset(dev);
+
+       /* determine preset speed and duplex settings */
+       if (lp->option & MSP_OPT_10M)
+               lp->speed = 10;
+       else
+               lp->speed = 100;
+
+       if (lp->option & MSP_OPT_FDUP)
+               lp->fullduplex = true;
+       else
+               lp->fullduplex = false;
+
+       /* initialize the queues and the hardware */
+       if (!mspeth_init_queues(dev)) {
+               printk(KERN_ERR "MSPETH(open) %s: "
+                       "Unable to allocate queues\n", dev->name);
+               goto out_err;
+       }
+
+       /* allocate and initialize the tasklets */
+#ifndef CONFIG_MSPETH_NAPI
+       tasklet_init(&lp->rx_tasklet, mspeth_rx, (u32)dev);
+       tasklet_init(&lp->tx_tasklet, mspeth_txdone, (u32)dev);
+#endif
+
+       /*
+        * hammtrev, 2005/12/08:
+        * Adding a new BH handler to reset the device in response to BLEx.
+        */
+       tasklet_init(&lp->hard_restart_tasklet, mspeth_hard_restart_bh,
+                       (u32)dev);
+
+       mspeth_mac_init(dev);
+       mspeth_phy_init(dev);
+
+       /* stjeanma: No need to poll the link status for a switch */
+       if (!(lp->option & MSP_OPT_SWITCH)) {
+               /* initialize the link check timer */
+               init_timer(&lp->link_timer);
+               lp->link_timer.expires = jiffies + HZ / LINK_DELAY_DIV;
+               lp->link_timer.data = (u32)dev;
+               lp->link_timer.function = mspeth_link_check;
+               add_timer(&lp->link_timer);
+       }
+
+       /* Allocate the IRQ */
+       if (request_irq(dev->irq, &mspeth_interrupt, 0, cardname, dev)) {
+               printk(KERN_ERR
+                       "MSPETH(open) %s: unable to reserve IRQ %d\n",
+                       dev->name, dev->irq);
+               goto out_err;
+       }
+       
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+       skb_bin.user_count++;
+#endif
+       /* and start up the queue */
+       netif_start_queue(dev);
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+       MOD_INC_USE_COUNT;
+#endif
+       return 0;
+
+out_err:
+       return err;
+}
+
+/**************************************************************************
+ * The inverse routine to mspeth_open(). Close the device and clean up
+ */
+static int
+mspeth_close(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       u32 flags;
+
+       /* please don't interrupt me while I'm shutting down everything */
+       local_irq_save(flags);
+
+       /* stop the queue & let the world know about it */
+       netif_stop_queue(dev);
+       netif_carrier_off(dev);
+
+       /* kill the tasklets before resetting devices */
+#ifndef CONFIG_MSPETH_NAPI
+       tasklet_kill(&lp->rx_tasklet);
+       tasklet_kill(&lp->tx_tasklet);
+#endif
+       tasklet_kill(&lp->hard_restart_tasklet);
+
+       /* smite the link check timers */
+       del_timer_sync(&lp->link_timer);
+
+       /* Clean up the adaptor. */
+       mspeth_mac_reset(dev);
+       mspeth_phy_reset(dev);
+
+       /* free the the queue memeory */
+       mspeth_free_queues(dev);
+
+       /* free up the resources */
+       free_irq(dev->irq, dev);
+
+       /*
+        * Deassign the phy.
+        * stjeanma: PHY might not be allocated for a switch.
+        */
+       if (lp->phyptr != NULL)
+               lp->phyptr->assigned = false;
+
+       /* turn back on the interrupts */
+       local_irq_restore(flags);
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+       MOD_DEC_USE_COUNT;
+#endif
+
+       return 0;
+}
+
+/**************************************************************************
+ * The typical workload of the driver:
+ *     Handle the network interface interrupts.
+ */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+static irqreturn_t mspeth_interrupt(int irq, void *dev_id)
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+static void mspeth_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+#endif
+{
+       struct net_device *dev = dev_id;
+       struct mspeth_priv *lp = netdev_priv(dev);
+       u32 status;
+
+       if (unlikely(dev == NULL)) {
+               printk(KERN_WARNING "MSPETH(interrupt) %s: "
+                       "irq %d for unknown device.\n", dev->name, irq);
+               return IRQ_NONE;
+       }
+
+       /*
+        * stjeanma, 2006-02-08:
+        * This read flushes the dma queue in addition to obtaining
+        * status.
+        */
+       status = msp_read(lp, MSPETH_Int_Src);
+
+       /* acknowledge the interrupts and check for null entry */
+       if (unlikely(status == 0))
+               return IRQ_HANDLED;
+       else
+               msp_write(lp, MSPETH_Int_Src, status);
+
+#if MSPETH_DEBUG
+       /* collect debugging stats */
+       if (likely(status & IntSrc_MacRx))
+               lp->lstats.rx_ints++;
+       if (status & IntSrc_MacTx)
+               lp->lstats.tx_ints++;
+#endif
+
+#ifdef CONFIG_MSPETH_NAPI
+       /* if NAPI is enabled schedule rx jobs */
+       if (likely(status == IntSrc_MacRx)) {
+               if (netif_rx_schedule_prep(dev)) {
+                       msp_write(lp, MSPETH_Rx_Ctl,
+                                       RX_CTL_CMD & ~Rx_EnGood);
+                       msp_write(lp, MSPETH_Int_En,
+                                       INT_EN_CMD & ~IntEn_FDAEx);
+                       __netif_rx_schedule(dev);
+               }
+               return IRQ_HANDLED;
+       }
+
+       if (status & IntSrc_MacRx) {
+               /* if NAPI is enabled schedule rx jobs */
+                if (netif_rx_schedule_prep(dev)) {
+                       msp_write(lp, MSPETH_Rx_Ctl,
+                                       RX_CTL_CMD & ~Rx_EnGood);
+                       msp_write(lp, MSPETH_Int_En,
+                                       INT_EN_CMD & ~IntEn_FDAEx);
+                       __netif_rx_schedule(dev);
+               }
+       }
+
+       /*
+        * Workaround for transmission timeouts due to transmit queue
+        * exhaust even if the queue has room.
+        */
+       if (status & IntSrc_MacTx) {
+               msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD & ~Tx_EnComp);
+               netif_wake_queue(dev);
+       }
+#else
+       /*
+        * At least for every TXDONE_MAX_PKT one IntSrc_MacTx will be
+        * generated.
+        */
+       if (likely(status == IntSrc_MacRx)) {
+               /* disable interrupt and schedule tasklet */
+               msp_write(lp, MSPETH_Rx_Ctl, RX_CTL_CMD & ~Rx_EnGood);
+               tasklet_schedule(&lp->rx_tasklet);
+               return IRQ_HANDLED;
+       }
+
+       if (likely(status == IntSrc_MacTx)) {
+               /* disable interrupt and schedule tasklet */
+               msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD & ~Tx_EnComp);
+               tasklet_schedule(&lp->tx_tasklet);
+               return IRQ_HANDLED;
+       }
+
+       if (likely(status == (IntSrc_MacRx | IntSrc_MacTx))) {
+               /* disable interrupt and schedule tasklet */
+               msp_write(lp, MSPETH_Rx_Ctl, RX_CTL_CMD & ~Rx_EnGood);
+               msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD & ~Tx_EnComp);
+               tasklet_schedule(&lp->tx_tasklet);
+               tasklet_schedule(&lp->rx_tasklet);
+               return IRQ_HANDLED;
+       }
+
+       if (status & IntSrc_MacRx) {
+               /* disable interrupt and schedule tasklet */
+               msp_write(lp, MSPETH_Rx_Ctl, RX_CTL_CMD & ~Rx_EnGood);
+               tasklet_schedule(&lp->rx_tasklet);
+       }
+
+       /* all other combined cases */
+       if (status & IntSrc_MacTx) {
+               /* disable interrupt and schedule tasklet */
+               msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD & ~Tx_EnComp);
+               tasklet_schedule(&lp->tx_tasklet);
+       }
+#endif /* CONFIG_MSPETH_NAPI */
+
+       /* recoverable errors */
+       if (status & IntSrc_FDAEx) {
+               /* disable FDAEx int. (until we make room...) */
+               msp_write(lp, MSPETH_Int_En, INT_EN_CMD & ~IntEn_FDAEx);
+               lp->lstats.fd_exha++;
+               lp->stats.rx_dropped++;
+       }
+
+       /*
+        * hammtrev, 2005/08/30:
+        * Some boards generate a link state interrupt on power-up.
+        * ACK it and it will go away.
+        */
+       if (status & IntSrc_Link_St)
+               msp_write(lp, MSPETH_MAC_Ctl,
+                         msp_read(lp, MSPETH_MAC_Ctl) | MAC_LnkChg);
+
+       /*
+        * And now all the unrecoverable fatal error conditions, this
+        * includes BLEx errors since we can *never* have one -- if we
+        * do, it indicates that there is some sort of queue corruption.
+        */
+       if (status & FATAL_ERROR_INT) {
+               /* Disable further interrupts until device reset. */
+               msp_write(lp, MSPETH_DMA_Ctl,
+                               msp_read(lp, MSPETH_DMA_Ctl) | DMA_IntMask);
+               /* this one may be overkill... */
+               msp_write(lp, MSPETH_MAC_Ctl,
+                               msp_read(lp, MSPETH_MAC_Ctl) | MAC_HaltImm);
+               mspeth_fatal_error_interrupt(dev, status);
+       }
+
+       return IRQ_HANDLED;
+}
+
+/**************************************************************************
+ * Fatal error interrupts reset the entire device but they don't require
+ * reallocating the queues, just clearing them
+ */
+static void
+mspeth_fatal_error_interrupt(struct net_device *dev, int status)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+
+       printk(KERN_WARNING
+               "MSPETH(fatal_error_interrupt) %s: "
+               "Fatal Error Interrupt (0x%08x):", dev->name, status);
+
+       if (status & IntSrc_DmParErr)
+               printk(KERN_WARNING " DmParErr");
+       if (status & IntSrc_NRAB)
+               printk(KERN_WARNING " IntNRAB");
+       if (status & IntSrc_BLEx)
+               printk(KERN_WARNING " IntBLEx");
+       printk(KERN_WARNING "\n");
+
+       /* panic if it gets too crazy */
+       if (lp->fatal_icnt++ > 100)
+               panic("MSPETH(fatal_error_interrupt) %s: "
+                       "too many fatal errors.\n", dev->name);
+
+       /* Dump our descriptors, if desired */
+       if (mspeth_debug > 0) {
+               mspeth_dump_queues(dev);
+               mspeth_dump_stats(dev);
+       }
+
+       /*
+        * Try to restart the adaptor.
+        *
+        * hammtrev, 2005/12/08:
+        * This is too much work for a top-half interrupt handler, and
+        * may result in unexpected race conditions with other tasklets.
+        * Now deferring the device reset to a bottom-half tasklet, to
+        * allow any currently-running tasklet to complete without
+        * unexpected changes to frame/buffer descriptors, etc.
+        */
+       tasklet_schedule(&lp->hard_restart_tasklet);
+}
+
+/**************************************************************************
+ * Handle deferred processing of the IntBLEx interrupt.
+ */
+static void
+mspeth_hard_restart_bh(unsigned long dev_addr)
+{
+       struct net_device *dev = (struct net_device *)dev_addr;
+
+       printk(KERN_WARNING "MSPETH(hard_restart_bh) %s: "
+               "restarting device\n", dev->name);
+       mspeth_hard_restart(dev);
+}
+
+
+/**************************************************************************
+ * Process a single RX packet, including sending it up the stack and
+ * reallocating the buffer. Return the next buffer in the RX queue.
+ * This routine assumes that the current FD pointed to by rxfd_curr
+ * has been invalidated with the cache and is current with main memory.
+ *
+ * Changed __hotnet to inline: slight performance improvement.
+ */
+inline static struct q_desc *
+mspeth_rx_onepkt(struct net_device *dev) {
+       struct mspeth_priv *lp = netdev_priv(dev);
+       u32 status;
+       struct q_desc *next_rxfd;
+       int bdnum, len;
+       struct sk_buff *skb;
+       dma_addr_t dma_skb;
+
+       /* collect all the relevent information */
+       status = lp->rxfd_curr->fd.FDStat;
+       /* Drop the FCS from the length */
+       len = (lp->rxfd_curr->bd.BDCtl & BD_BuffLength_MASK) - 4;
+       bdnum = (lp->rxfd_curr->bd.BDCtl & BD_RxBDID_MASK) >> BD_RxBDID_SHIFT;
+
+       if (mspeth_debug > 2)
+               printk(KERN_INFO "MSPETH(rx_onepkt) %s: "
+                       "RxFD.\n", dev->name);
+       if (mspeth_debug > 3)
+               dump_qdesc(lp->rxfd_curr);
+#ifdef MSPETH_DUMP_QUEUES
+       if (mspeth_debug > 2 &&
+           (!bdnum && (rx_bdnums[lp->unit][rx_bdnums_ind[lp->unit]]
+                                       != ((RX_BUF_NUM << 1) - 1))))
+               dump_qdesc(lp->rxfd_curr);
+       catalog_rx_bdnum(lp->unit, bdnum);
+#endif /* MSPETH_DUMP_QUEUES */
+
+       /*
+        * The packet has been received correctly so prepare to send
+        * it up the stack
+        */
+       if (likely(status & Rx_Good)) {
+               skb = lp->rx_skbp[bdnum];
+               dma_skb = lp->rx_dma_skbp[bdnum];
+
+               /*
+                * If a replacement buffer can be allocated then send
+                * the skb up the stack otherwise we drop the packet
+                * and reuse the existing buffer
+                */
+               lp->rx_skbp[bdnum] = mspeth_alloc_skb(dev);
+               if (likely(lp->rx_skbp[bdnum] != NULL)) {
+#if defined(CONFIG_DMA_NONCOHERENT) && \
+    LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+                       /* Replacement buffer map and sync for dma */
+                       lp->rx_dma_skbp[bdnum] = dma_map_single(
+                                       lp->dev, lp->rx_skbp[bdnum]->data, 
+                                       MSP_END_BUFSIZE, DMA_FROM_DEVICE);
+
+                       /*
+                        * Replacement buffer has been allocated
+                        * successfully, so sync and un-map original
+                        * buffer.
+                        */
+                       dma_sync_single_for_cpu(lp->dev, dma_skb,
+                                               len, DMA_FROM_DEVICE);
+                       dma_unmap_single(lp->dev, dma_skb,
+                                       MSP_END_BUFSIZE, DMA_NONE);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+                       invalidate_buffer(skb->data, len);
+#endif
+
+                       /* complete the skb and send it up the stack */
+                       skb_put(skb, len);
+                       skb->protocol = eth_type_trans(skb, dev);
+
+#ifdef CONFIG_MSPETH_NAPI
+                       netif_receive_skb(skb);
+#else
+                       netif_rx(skb);
+#endif /* CONFIG_MSPETH_NAPI */
+                       dev->last_rx = jiffies;
+
+                       lp->stats.rx_packets++;
+                       lp->stats.rx_bytes += len;
+
+                       if (mspeth_debug > 4) {
+                               print_eth(1, skb->data, len);
+                               if (mspeth_debug > 5)
+                                       print_buf(skb->data, len);
+                       }
+               } else {
+                       printk(KERN_WARNING "MSPETH(rx_onepkt) %s: "
+                               "Memory squeeze, dropping packet.\n",
+                               dev->name);
+                       lp->rx_skbp[bdnum] = skb;
+                       lp->stats.rx_dropped++;
+               }
+
+               /* Do the rounding for the 32-bit data alignment */
+               lp->blfd_ptr->bd[bdnum].BuffData =
+                               (u32)lp->rx_skbp[bdnum]->data &
+                               BD_DataAlign_MASK;
+       } else {
+               lp->stats.rx_errors++;
+               /* WORKAROUND: LongErr and CRCErr means Overflow. */
+               if ((status & Rx_LongErr) && (status & Rx_CRCErr)) {
+                       status &= ~(Rx_LongErr | Rx_CRCErr);
+                       status |= Rx_Over;
+               }
+               if (status & Rx_LongErr)
+                       lp->stats.rx_length_errors++;
+               if (status & Rx_Over)
+                       lp->stats.rx_fifo_errors++;
+               if (status & Rx_CRCErr)
+                       lp->stats.rx_crc_errors++;
+               if (status & Rx_Align)
+                       lp->stats.rx_frame_errors++;
+       }
+
+       /* allocate buffer back to controller */
+       lp->blfd_ptr->bd[bdnum].BDCtl =
+               (BD_CownsBD | (bdnum << BD_RxBDID_SHIFT) | MSP_END_BUFSIZE);
+       blocking_read_reg32(&lp->blfd_ptr->bd[bdnum].BDCtl);
+       
+       /* save next FD before allocating current one to controller */
+       next_rxfd = (struct q_desc *)lp->rxfd_curr->fd.FDNext;
+
+       /*
+        * Return q_desc to the controller. Setting fd0.FDCtl last prevents
+        * the controller from using this q_desc until we're done.
+        *
+        * Writeback the changes back to the RAM so that MAC can see the
+        * available buffers on a write-through cache this doesn't really
+        * do anything, but on a writeback cache this is quite important.
+        *
+        * stjeanma, 2006-02-08:
+        * Uncached writes need to be read back to ensure they reach RAM.
+        */
+       lp->rxfd_curr->fd0.FDNext = 0;
+       lp->rxfd_curr->fd0.FDSystem = 0;
+       lp->rxfd_curr->fd0.FDStat = 0;
+       lp->rxfd_curr->fd1.FDNext = 0;
+       lp->rxfd_curr->fd1.FDSystem = 0;
+       lp->rxfd_curr->fd1.FDStat = 0;
+       lp->rxfd_curr->fd1.FDCtl = FD_CownsFD;
+       lp->rxfd_curr->fd0.FDCtl = FD_CownsFD;
+       blocking_read_reg32(&lp->rxfd_curr->fd0.FDCtl);
+
+       return next_rxfd;
+}
+
+#ifdef CONFIG_MSPETH_NAPI
+/*************************************************************************
+ * mspeth polling method used by NAPI.
+ */
+static int __hotnet
+mspeth_poll(struct net_device *dev, int *budget)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       int work_limit = min(*budget, dev->quota);
+       int work_done;
+       int done = 1;
+       
+       flush_memqueue();
+
+       for (work_done = 0; (work_done < work_limit) &&
+                               !(lp->rxfd_curr->fd.FDCtl & FD_CownsFD);
+                               work_done++)
+               lp->rxfd_curr = mspeth_rx_onepkt(dev);
+
+       if (likely(work_done > 0)) {
+               *budget -= work_done;
+               dev->quota -= work_done;
+               done = (work_done < work_limit);
+       }
+
+       if (done) {
+               /*
+                * Reenable rx and FDAEXhaust interrupts since we
+                * handled all recieved packets.
+                */
+               local_irq_disable();
+               __netif_rx_complete(dev);
+               msp_write(lp, MSPETH_Rx_Ctl, RX_CTL_CMD | Rx_EnGood);
+               msp_write(lp, MSPETH_Int_En, INT_EN_CMD);
+               local_irq_enable();
+       }
+
+       return !done;
+}
+#else
+/**************************************************************************
+ * A packet has been received so shove it up the network stack and
+ * allocate another buffer for reception. Called by the rx_tasklet which
+ * is scheduled by the interrupt handler.
+ */
+static void __hotnet
+mspeth_rx(unsigned long dev_addr)
+{
+       struct net_device *dev = (struct net_device *)dev_addr;
+       struct mspeth_priv *lp = netdev_priv(dev);
+       u32 status;
+       int rx_cnt;
+
+       /*
+        * Make sure the memory queue is flushed and the cache is
+        * invalidated this is only really important in the case where
+        * we have a single packet to process otherwise the packet at
+        * the head of the queue will *certainly* be flushed from the
+        * memory queue. We don't need to flush the DMA queue since the
+        * ISR that scheduled this routine will have done it already.
+        */
+       flush_memqueue();
+
+       /*
+        * Loop around processing the rx packet queue.
+        * This should be adjusted to process a maximum number of
+        * packets, or perhaps insert a call to "schedule" within it
+        * so that it doesn't monopolize the CPU.
+        */
+       for (rx_cnt = 0; rx_cnt < RX_MAX_PKT &&
+            !(lp->rxfd_curr->fd.FDCtl & FD_CownsFD); rx_cnt++) {
+               /*
+                * Process the current packet and move to the next
+                * frame descriptor.
+                */
+               lp->rxfd_curr = mspeth_rx_onepkt(dev);
+       }
+
+       /* re-enable FDA Exhausted interupts 'cause there's room now */
+       if (rx_cnt > 0)
+               msp_write(lp, MSPETH_Int_En, INT_EN_CMD);
+
+       /*
+        * Check to see if there is an unprocessed packet
+        * -- reschedule if so.
+        *
+        * hammtrev, 2005-12-16:
+        * Flush the memory queue and invalidate the cache
+        * lines before re-examining the current rxfd.
+        */
+       flush_memqueue();
+
+       if (!(lp->rxfd_curr->fd.FDCtl & FD_CownsFD)) {
+               tasklet_schedule(&lp->rx_tasklet);
+       } else {
+               /*
+                * Re-enable the RX completion interrupt and check to see
+                * if there is an outstanding interrupt.
+                */
+               msp_write(lp, MSPETH_Rx_Ctl, RX_CTL_CMD);
+               status = msp_read(lp, MSPETH_Int_Src);
+
+               /*
+                * If there is an outstanding RX interrupt, then reschedule
+                * the routine
+                */
+               if (status & IntSrc_MacRx) {
+                       /* ack the interrupt, disable it and reschedule */
+                       msp_write(lp, MSPETH_Int_Src, IntSrc_MacRx);
+                       msp_write(lp, MSPETH_Rx_Ctl,
+                                       RX_CTL_CMD & ~Rx_EnGood);
+                       tasklet_schedule(&lp->rx_tasklet);
+               }
+       }
+}
+#endif /* CONFIG_MSPETH_NAPI */
+
+/**************************************************************************
+ * Basic transmit function -- called from the upper network layers
+ */
+static int __hotnet
+mspeth_send_packet(struct sk_buff *skb, struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       struct q_desc *txfd_ptr;
+
+       /*
+        * NOTE that if we cannot transmit then we must return 1 and
+        * *not touch* the skb since it doesn't belong to us. The
+        * networking layer above will take care of it.
+        */
+
+#ifdef CONFIG_MSPETH_NAPI
+       /*
+        * We have no txdone interrupt on NAPI.
+        * Free transmitted buffers here.
+        */
+       mspeth_txdone((unsigned long)dev);
+#endif
+
+       /*
+        * Don't take drastic action right away if the queue is stopped,
+        * but if its been that way for quite a while we'll attempt to
+        * restart the adatper.
+        */
+       if (netif_queue_stopped(dev)) {
+               /*
+                * If we get here, some higher level has decided we are
+                * broken. There should really be a "kick me" function
+                * call instead.
+                */
+               int tickssofar = jiffies - dev->trans_start;
+               if (tickssofar < 5) {
+                       printk(KERN_WARNING "MSPETH(send_packet) %s: "
+                               "queue stopped ...\n", dev->name);
+                       return 1;
+               }
+
+               printk(KERN_WARNING "MSPETH(send_packet) %s: "
+                       "transmit timed out, restarting adaptor. "
+                       "TX_Status = %08x\n",
+                       dev->name, msp_read(lp, MSPETH_Tx_Stat));
+
+               /* do a hard restart and return */
+               mspeth_hard_restart(dev);
+               return 1;
+       }
+
+       /*
+        * Protect access to the transmit queue with the atomic queue
+        * space variable.
+        */
+       if (atomic_read(&lp->tx_qspc) == 0) {
+               /* no room on queue for another packet */
+               netif_stop_queue(dev);
+#ifdef CONFIG_MSPETH_NAPI
+               /* workaround for waking the queue */
+               msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD);
+#endif
+               lp->lstats.tx_full++;
+               return 1;
+       }
+
+       lp->stats.tx_bytes += skb->len;
+
+       /* we have room, so get the next availabe tx FD */
+       txfd_ptr = &(lp->txfd_base[lp->tx_head]);
+       lp->tx_head = (lp->tx_head + 1) & TX_BUF_MASK;
+
+#if defined(CONFIG_DMA_NONCOHERENT) && \
+    LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+       /* map and sync for dma */
+       txfd_ptr->fd1.FDStat = dma_map_single(lp->dev, skb->data,
+                                               skb->len, DMA_TO_DEVICE);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
+       /* writeback the cache and flush the sdram queue */
+       writeback_buffer(skb->data, skb->len);
+#endif
+
+       /*
+        * stjeanma, 2006-02-08:
+        * Uncached writes need to be read back to ensure they reach RAM.
+        */
+       txfd_ptr->bd.BuffData = (u32)skb->data;
+       txfd_ptr->bd.BDCtl = skb->len;
+       txfd_ptr->fd.FDSystem = (u32)skb;
+       txfd_ptr->fd.FDCtl = FD_CownsFD_Set;
+       blocking_read_reg32(&txfd_ptr->fd.FDCtl);
+
+       /* one more packet on the TX queue */
+       atomic_dec(&lp->tx_qspc);
+
+       if (mspeth_debug > 4) {
+               print_eth(0, (unsigned char *)skb->data, skb->len);
+               if (mspeth_debug > 5)
+                       print_buf(skb->data, skb->len);
+       }
+
+       /* wake up the transmitter */
+       msp_write(lp, MSPETH_DMA_Ctl, DMA_CTL_CMD | DMA_TxWakeUp);
+
+       dev->trans_start = jiffies;
+
+       return 0;
+}
+
+/**************************************************************************
+ * Free the buffers which have been transmitted from the transmit queue.
+ * Called from the tx_tasklet which is scheduled by the interrupt handler
+ */
+#ifdef CONFIG_MSPETH_NAPI
+inline static void
+#else
+static void __hotnet
+#endif
+mspeth_txdone(unsigned long dev_addr)
+{
+       struct net_device *dev = (struct net_device *)dev_addr;
+       struct mspeth_priv *lp = netdev_priv(dev);
+       struct q_desc *txfd_ptr;
+       int num_done = 0;
+       u32 status;
+
+       /*
+        * Walk the queue until we come to the end or a buffer we don't
+        * control we don't worry much about leaving a buffer or two on
+        * the tx queue; we'll get to them later and if we're busy then
+        * we'll get to them RSN.
+        *
+        * stjeanma, 2006-02-08:
+        * Flush the memory queue to see the MAC queue updates.
+        */
+       txfd_ptr = &(lp->txfd_base[lp->tx_tail]);
+       flush_memqueue();
+
+       while (atomic_read(&lp->tx_qspc) < TXDONE_MAX_PKT &&
+                       !(txfd_ptr->fd.FDCtl & FD_CownsFD)) {
+               struct sk_buff *skb;
+               dma_addr_t dma_skb;
+
+               status = txfd_ptr->fd.FDStat;
+               mspeth_check_tx_stat(dev, status);
+
+               if (mspeth_debug > 2)
+                       printk(KERN_INFO "MSPETH(txdone) %s: "
+                               "TxFD done.\n", dev->name);
+               if (mspeth_debug > 3)
+                       dump_qdesc(txfd_ptr);
+
+               /*
+                * Free the current socket buffer and change ownership of
+                * the TX descriptor.
+                *
+                * Writeback the change to RAM so that the controller can
+                * see them.
+                *
+                * stjeanma, 2006-02-08:
+                * Uncached writes need to be read back to ensure they
+                * reach RAM.
+                */
+               dma_skb = txfd_ptr->fd1.FDStat;
+               txfd_ptr->fd1.FDStat = 0x00000000;
+
+               skb = (struct sk_buff *)(txfd_ptr->fd.FDSystem);
+               txfd_ptr->fd.FDSystem = 0x00000000;
+               txfd_ptr->fd.FDCtl = 0x00000000;
+               blocking_read_reg32(&txfd_ptr->fd.FDCtl);
+
+#if defined(CONFIG_DMA_NONCOHERENT) && \
+    LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+               /* unmap dma sync */
+               if (dma_skb != 0x00000000)
+                       dma_unmap_single(lp->dev, dma_skb,
+                                       skb->len, DMA_NONE);
+#endif
+               if (skb != NULL)
+                       mspeth_free_skb(skb);
+
+               /* advance to the next TX descriptor */
+               atomic_inc(&lp->tx_qspc);
+               num_done++;
+               lp->tx_tail = (lp->tx_tail + 1) & TX_BUF_MASK;
+               
+               txfd_ptr = &(lp->txfd_base[lp->tx_tail]);
+               flush_memqueue();
+       }
+
+#ifndef CONFIG_MSPETH_NAPI
+       /*
+        * If we freed at least one buffer and the queue is stopped
+        * then restart it.
+        */
+       if (num_done > 0 && netif_queue_stopped(dev))
+               netif_wake_queue(dev);
+
+       /* re-enable interrupts regardless */
+       msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD);
+
+       /* Check for outstanding packets */
+       status = msp_read(lp, MSPETH_Int_Src);
+
+       /* If we have an outstanding packet, reschedule the tasklet */
+       if (status & IntSrc_MacTx) {
+               /* ack interrupt, disable it, and reschedule */
+               msp_write(lp, MSPETH_Int_Src, IntSrc_MacTx);
+               msp_write(lp, MSPETH_Tx_Ctl, TX_CTL_CMD & ~Tx_EnComp);
+               tasklet_schedule(&lp->tx_tasklet);
+       }
+#endif /* CONFIG_MSPETH_NAPI */
+}
+
+/**************************************************************************
+ * If there is a timeout we soft restart the entire device
+ */
+static void
+mspeth_tx_timeout(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       printk(KERN_WARNING "MSPETH(tx_timeout) %s: "
+               "transmit timed out, status 0x%08x\n",
+               dev->name, msp_read(lp, MSPETH_Tx_Stat));
+
+       /* try to restart the adaptor */
+       mspeth_soft_restart(dev);
+}
+
+/**************************************************************************
+ * Debugging code to dump out the transmit status register
+ *
+ * hammtrev, 2005-11-25:
+ * The Tx_NCarr condition makes a lot of noise on the PMC RG, but
+ * doesn't seem to affect the success of transmissions. Removing for now.
+ */
+#define TX_STA_ERR \
+       (Tx_ExColl | Tx_Under | Tx_Defer | Tx_LateColl | Tx_TxPar | Tx_SQErr)
+static void
+mspeth_check_tx_stat(struct net_device *dev, int status)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       const char *msg = NULL;
+
+       /* count collisions */
+       if (status & Tx_ExColl)
+               lp->stats.collisions += 16;
+       if (status & Tx_TxColl_MASK)
+               lp->stats.collisions += status & Tx_TxColl_MASK;
+
+       /* WORKAROUND: ignore LostCrS when there is no carrier .... */
+       if (!netif_carrier_ok(dev))
+               status &= ~Tx_NCarr;
+
+       if (likely(!(status & TX_STA_ERR))) {
+               /* no error. */
+               lp->stats.tx_packets++;
+               return;
+       }
+
+       lp->stats.tx_errors++;
+       if (status & Tx_ExColl) {
+               lp->stats.tx_aborted_errors++;
+               msg = "Excessive Collision.";
+       }
+       if (status & Tx_Under) {
+               lp->stats.tx_fifo_errors++;
+               msg = "Tx FIFO Underrun.";
+       }
+       if (status & Tx_Defer) {
+               lp->stats.tx_fifo_errors++;
+               msg = "Excessive Deferral.";
+       }
+#if 0
+       if (status & Tx_NCarr) {
+               lp->stats.tx_carrier_errors++;
+               msg = "Lost Carrier Sense.";
+       }
+#endif
+       if (status & Tx_LateColl) {
+               lp->stats.tx_aborted_errors++;
+               msg = "Late Collision.";
+       }
+       if (status & Tx_TxPar) {
+               lp->stats.tx_fifo_errors++;
+               msg = "Transmit Parity Error.";
+       }
+       if (status & Tx_SQErr) {
+               lp->stats.tx_heartbeat_errors++;
+               msg = "Signal Quality Error.";
+       }
+       if (msg)
+               printk(KERN_WARNING
+                       "MSPETH(check_tx_stats) %s: %s (%#x)\n",
+                       dev->name, msg, status);
+}
+
+/*
+ * Get the current statistics.
+ * This may be called with the card open or closed.
+ */
+static struct net_device_stats *
+mspeth_get_stats(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+       unsigned long flags;
+
+       if (netif_running(dev)) {
+               local_irq_save(flags);
+               /* Update the statistics from the device registers. */
+               lp->stats.rx_missed_errors = msp_read(lp, MSPETH_Miss_Cnt);
+               local_irq_restore(flags);
+       }
+
+       return &lp->stats;
+}
+
+/*
+ * Set or clear the multicast filter for this adaptor.
+ * num_addrs == -1     Promiscuous mode, receive all packets
+ * num_addrs == 0      Normal mode, clear multicast list
+ * num_addrs > 0       Multicast mode, receive normal and MC packets,
+ *                     and do best-effort filtering.
+ */
+static void
+mspeth_set_multicast_list(struct net_device *dev)
+{
+       struct mspeth_priv *lp = netdev_priv(dev);
+
+       if (dev->flags & IFF_PROMISC) {
+               /* Enable promiscuous mode */
+               msp_write(lp, MSPETH_ARC_Ctl,
+                               ARC_CompEn | ARC_BroadAcc |
+                               ARC_GroupAcc | ARC_StationAcc);
+       } else if ((dev->flags & IFF_ALLMULTI) ||
+                  dev->mc_count > ARC_ENTRY_MAX - 3) {
+               /* ARC 0, 1, 20 are reserved. */
+               /* Disable promiscuous mode, use normal mode. */
+               msp_write(lp, MSPETH_ARC_Ctl,
+                               ARC_CompEn | ARC_BroadAcc | ARC_GroupAcc);
+       } else if (dev->mc_count) {
+               struct dev_mc_list* cur_addr = dev->mc_list;
+               int i;
+               int ena_bits = ARC_Ena_Bit(ARC_ENTRY_SOURCE);
+
+               msp_write(lp, MSPETH_ARC_Ctl, 0);
+               /* Walk the address list, and load the filter */
+               for (i = 0; i < dev->mc_count; i++,
+                               cur_addr = cur_addr->next) {
+                       if (!cur_addr)
+                               break;
+
+                       /* entry 0, 1 is reserved. */
+                       mspeth_set_arc_entry(dev, i + 2, cur_addr->dmi_addr);
+                       ena_bits |= ARC_Ena_Bit(i + 2);
+               }
+               msp_write(lp, MSPETH_ARC_Ena, ena_bits);
+               msp_write(lp, MSPETH_ARC_Ctl, ARC_CompEn | ARC_BroadAcc);
+       } else {
+               msp_write(lp, MSPETH_ARC_Ena, ARC_Ena_Bit(ARC_ENTRY_SOURCE));
+               msp_write(lp, MSPETH_ARC_Ctl, ARC_CompEn | ARC_BroadAcc);
+       }
+}
+
+static int
+mspeth_proc_info(char *buf, char **bloc, off_t off,
+                       int length, int *eof, void *data)
+{
+       int len = 0;
+       int i, cnt;
+       struct net_device *dev = (struct net_device *)data;
+       struct mspeth_priv *lp = netdev_priv(dev);
+
+       /* finished reading regardless of anything else */
+       if (off > 0)
+               return 0;
+
+       len += sprintf(buf, "MSPETH hwunit %d statistics:\n", lp->hwunit);
+       len += sprintf(buf + len, "%s: tx_ints %d, rx_ints %d, "
+                       "max_tx_qlen %d, tx_full %d, fd_exha %d\n",
+                       dev->name,
+                       lp->lstats.tx_ints,
+                       lp->lstats.rx_ints,
+                       lp->lstats.max_tx_qlen,
+                       lp->lstats.tx_full,
+                       lp->lstats.fd_exha);
+       len += sprintf(buf + len, "    fd_base = %p\n\n", lp->fd_base);
+       len += sprintf(buf + len, "    rxfd_base = %p, rxfd_curr = %p\n",
+                       lp->rxfd_base, lp->rxfd_curr);
+
+       if (lp->rxfd_base != NULL) {
+               cnt = 0;
+               for (i = 0; i < RX_BUF_NUM; i++) {
+                       if (lp->rxfd_base[i].fd.FDCtl & FD_CownsFD)
+                               cnt++;
+               }
+               len += sprintf(buf + len,
+                               "    Controller FD count = %d\n\n", cnt);
+       }
+       len += sprintf(buf + len, "    tx_base = %p, tx_head = %d, "
+                       "tx_tail = %d, qspc = %d\n",
+                       lp->txfd_base, lp->tx_head, lp->tx_tail,
+                       atomic_read(&lp->tx_qspc));
+       len += sprintf(buf + len, "    blfd_ptr = %p, rx_skbp = %p\n\n",
+                       lp->blfd_ptr, lp->rx_skbp);
+       if (lp->mapaddr != NULL)
+               len += sprintf(buf + len,
+                               "    pause sent: %d, pause recv: %d\n\n",
+                               msp_read(lp, MSPETH_PauseCnt),
+                               msp_read(lp, MSPETH_RemPauCnt));
+#ifdef CONFIG_MSPETH_NAPI
+       len += sprintf(buf + len, "    NAPI is enabled\n\n");
+#endif
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+       len += sprintf(buf + len,
+                       "    Socket Buffer Recycling is enabled\n");
+       len += sprintf(buf + len,
+                       "        recycle hits = %lu, recycle misses = %lu\n",
+                       skb_bin.recycle_hits, skb_bin.recycle_misses);
+       len += sprintf(buf + len, "        recycle bin skb count = %lu\n\n",
+                       skb_bin.recycle_count);
+#endif
+
+       return len;
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+/* platform device stuff for linux 2.6 */
+static char mspeth_string[] = "mspeth";
+
+static struct platform_driver mspeth_driver = {
+       .probe  = mspeth_probe,
+       .remove = __devexit_p(mspeth_remove),
+       .driver {
+               .name = mspeth_string,
+       },
+};
+
+/*
+ * Register the mspeth with the kernel
+ */
+static int __init mspeth_init_module(void)
+{
+       printk(KERN_INFO "PMC MSPETH 10/100 Ethernet Driver\n");
+
+       if (platform_driver_register(&mspeth_driver)) {
+               printk(KERN_ERR "Driver registration failed\n");
+               return -ENOMEM;
+       }
+
+       return 0;
+}
+
+/*
+ * Unregister the mspeth from the kernel
+ */
+static void __exit mspeth_cleanup_module(void)
+{
+       platform_driver_unregister(&mspeth_driver);
+}
+
+MODULE_DESCRIPTION("PMC MSPETH 10/100 Ethernet Driver");
+MODULE_LICENSE("GPL");
+
+module_init(mspeth_init_module);
+module_exit(mspeth_cleanup_module);
+#endif
diff --git a/drivers/net/pmcmspeth.h b/drivers/net/pmcmspeth.h
new file mode 100644
index 0000000..f1909aa
--- /dev/null
+++ b/drivers/net/pmcmspeth.h
@@ -0,0 +1,624 @@
+/*
+ * PMC-Sierra MSP EVM ethernet driver for linux
+ *
+ * Copyright 2005-2007 PMC-Sierra, Inc
+ *
+ * Originally based on mspeth.c driver which contains substantially the
+ * same hardware.
+ * Based on skelton.c by Donald Becker.
+ *
+ * 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 (at your
+ * option) any later version.
+ *
+ * THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' A    ANY  EXPRESS OR IMPLIED
+ * WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ * NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ * USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * 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.
+ */
+
+#ifndef _MSPETH_H_
+#define _MSPETH_H_
+
+/**************************************************************************
+ * Cache size externs and defines
+ */
+extern int ic_lsize, dc_lsize; /* Primary cache linesize in bytes */
+extern int sc_lsize;           /* Secondary cache linesize in bytes */
+                               /* must be included after the above */
+
+/**************************************************************************
+ * Temporary define to determine cache policy -- at some time in the near
+ * future, this will get migrated to something in the configuration
+ */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+#if !defined(CONFIG_UCLINUX) && \
+    (CONF_CM_DEFAULT == CONF_CM_CACHABLE_NONCOHERENT)
+#define CONFIG_DMA_NONCOHERENT
+#endif
+#endif
+
+/* Get the private data pointer */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+#define netdev_priv(dev) ((struct mspeth_priv *)dev->priv)
+#endif
+
+/* Define __hotnet macro for 2.6 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+#define __hotnet
+#endif
+
+/* Define dma_addr_t for 2.4 */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+#define dma_addr_t     u32
+#endif
+
+/**************************************************************************
+ * Device constants for our various types of MSP chips
+ */
+#define MSPETH_MAX_UNITS       3
+#define STDETH_MAX_UNITS       8
+
+/**************************************************************************
+ * Tuning parameters
+ */
+#define DMA_BURST_SIZE 32      /* maximum burst size for the DMA transfers */
+#define TX_TIMEOUT     1       /* time (in seconds) for the TX timeout */
+
+#if defined(CONFIG_PMC_MSP7120_EVAL) || \
+    defined(CONFIG_PMC_MSP7120_GW) || \
+    defined(CONFIG_PMC_MSP7120_FPGA)
+#define TX_THRESHOLD   100     /* MAC TX fifo depth before we start sending */
+#else
+#define TX_THRESHOLD   1000    /* MAC TX fifo depth before we start sending */
+#endif
+#define TX_POLL_CNT    0       /* interval for the TX poll mechanism
+                                * -- not used, leave at zero */
+#define LINK_DELAY_DIV 4       /* delay for checking the link status   */
+#define RX_MAX_PKT     16      /* maximum number of packet the RX handler */
+                               /* will process at one time             */
+
+/*
+ * Define the RX/TX buffer counts. Notice that they *must* be <= 256 and
+ * also a power of two. So much so that we test for it at compile time and
+ * set the order  of the queue lengths instead of the numbers directly.
+ *
+ * cavanaug 2006-02-21: Changed buffer order from 5 to 6. This prevents
+ * corruption of the queues on eth1 that were preventing eth1 from working
+ * without the cable being unplugged and plugged back in.
+ */
+#define RX_BUF_ORDER   6       /* 64 buffers */
+#define TX_BUF_ORDER   6       /* 64 buffers */
+
+/* Use 0 for production, 1 for verification, >2 for debug */
+#ifndef MSPETH_DEBUG
+#define MSPETH_DEBUG   0
+#endif
+
+/**************************************************************************
+ * Buffer sizes
+ */
+#define MAX_PKT_SIZE           1532
+#define MSP_END_PREPEND                224
+#define MAX_ETH_BUFFER_SIZE    (MAX_PKT_SIZE + MSP_END_PREPEND)
+#define MSP_END_BUFSIZE                (MAX_ETH_BUFFER_SIZE + 24)
+
+/**************************************************************************
+ * Option defines
+ */
+#define MSP_OPT_AUTO   0x00
+#define MSP_OPT_10M    0x01
+#define MSP_OPT_100M   0x02
+#define MSP_OPT_FDUP   0x04
+#define MSP_OPT_HDUP   0x08
+#define MSP_OPT_SWITCH 0x10
+
+/**************************************************************************
+ * Local error codes etc (mac errors start at 9000)
+ */
+#define MSP_SUCCESS            0
+#define MSP_FAIL               -1
+#define MSP_MAC_MEM_ALLOC_ERROR        9002
+#define MSP_MAC_PHY_ERROR      9006
+#define MSP_MAC_PHY_NO_LINK    9012
+
+/**************************************************************************
+ * Hardware register locations & constants
+ */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+#define MSP_MAC0_BASE  0xB8600000      /* Base address to MAC0 Controller */
+#define MSP_MAC1_BASE  0xB8700000      /* Base address to MAC1 Controller */
+#define MSP_MAC2_BASE  0xB8900000      /* Base address to MAC2 Controller */
+#define MSP_RST_BASE   SYS_RST_REG     /* Base address to system reset    */
+
+#define MSP_EA_RST     MAC0_RST
+#define MSP_EB_RST     MAC1_RST
+#define MSP_EC_RST     MAC2_RST
+
+#define        MSP_INT_MAC0    BRECISINT_MAC0
+#define        MSP_INT_MAC1    BRECISINT_MAC1
+#define        MSP_INT_MAC2    BRECISINT_MAC2
+
+#define MEM_CFG1_REG   MEM_CNFG1_REG
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
+#ifndef MSP_INT_MAC2
+#define MSP_INT_MAC2   0
+#endif
+#endif
+
+/**************************************************************************
+ * Macros & inline functions
+ */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+#define IRQ_HANDLED
+#define IRQ_NONE
+#endif
+
+/* Select the correct cache flush/invalidate operations */
+#if CONFIG_MIPS_L1_CACHE_SHIFT == 4
+#define CACHE_UNROLL   cache16_unroll32
+#define UNROLL_INCR    0x200
+#elif CONFIG_MIPS_L1_CACHE_SHIFT == 5
+#define CACHE_UNROLL   cache32_unroll32
+#define UNROLL_INCR    0x400
+#elif CONFIG_MIPS_L1_CACHE_SHIFT == 6
+#define CACHE_UNROLL   cache64_unroll32
+#define UNROLL_INCR    0x800
+#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
+      (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+#define CACHE_UNROLL   cache16_unroll32
+#define UNROLL_INCR    0x200
+#endif
+
+/**************************************************************************
+ * Register definitions
+ */
+
+/* MAC */
+#define MSPETH_DMA_Ctl         0x00
+#define MSPETH_TxFrmPtr                0x04
+#define MSPETH_TxThrsh         0x08
+#define MSPETH_TxPollCtr       0x0c
+#define MSPETH_BLFrmPtr                0x10
+#define MSPETH_RxFragSize      0x14
+#define MSPETH_Int_En          0x18
+#define MSPETH_FDA_Bas         0x1c
+#define MSPETH_FDA_Lim         0x20
+#define MSPETH_Int_Src         0x24
+#define MSPETH_PauseCnt                0x30
+#define MSPETH_RemPauCnt       0x34
+#define MSPETH_TxCtlFrmStat    0x38
+#define MSPETH_MAC_Ctl         0x40
+#define MSPETH_ARC_Ctl         0x44
+#define MSPETH_Tx_Ctl          0x48
+#define MSPETH_Tx_Stat         0x4c
+#define MSPETH_Rx_Ctl          0x50
+#define MSPETH_Rx_Stat         0x54
+#define MSPETH_MD_DATA         0x58
+#define MSPETH_MD_CA           0x5c
+#define MSPETH_ARC_Adr         0x60
+#define MSPETH_ARC_Data                0x64
+#define MSPETH_ARC_Ena         0x68
+#define MSPETH_Miss_Cnt                0x7c
+#define MSPETH_BSWE1_Add       0xc0
+#define MSPETH_BSWE2_Add       0xc4
+#define MSPETH_BMWE1_Add       0xc8
+#define MSPETH_BMWE2_Add       0xcc
+#define MSPETH_INTBRW_Add      0xd0
+#define MSPETH_BCTRL_Reg       0xd4
+
+/* PHY */
+#define MSPPHY_MII_DATA                0x00
+#define MSPPHY_MII_CTRL                0x04
+
+/* Reset */
+#define MSPRST_STS             0x00
+#define MSPRST_SET             0x04
+#define MSPRST_CLR             0x08
+
+/*
+ * Bit Assignments
+ */
+
+/* DMA_Ctl (0x00) bit assign -------------------------------------------*/
+#define DMA_RxAlign3   0x00C00000 /* Receive Alignment (skip 3 bytes)  */
+#define DMA_RxAlign2   0x00800000 /* Receive Alignment (skip 2 bytes)  */
+#define DMA_RxAlign1   0x00400000 /* Receive Alignment (skip 1 byte)   */
+/* RESERVED            0x00300000    Not used, must be zero            */
+#define DMA_M66EnStat  0x00080000 /* 1:Station clock/30                */
+#define DMA_IntMask    0x00040000 /* 1:Interupt mask                   */
+#define DMA_SWIntReq   0x00020000 /* 1:Software Interrupt request      */
+#define DMA_TxWakeUp   0x00010000 /* 1:Transmit Wake Up                */
+#define DMA_RxBigE     0x00008000 /* 1:Receive Big Endian              */
+#define DMA_TxBigE     0x00004000 /* 1:Transmit Big Endian             */
+#define DMA_TestMode   0x00002000 /* 1:Test Mode                       */
+#define DMA_PowrMgmnt  0x00001000 /* 1:Power Management                */
+#define DMA_BRST_Mask  0x000001fc /* DMA Burst size                    */
+#define DMA_BRST_Shift 2
+
+/* RxFragSize (0x14) bit assign --------------------------------------- */
+#define RxFrag_EnPack          0x00008000 /* 1:Enable Packing          */
+#define RxFrag_MinFragMask     0x00000ffc /* Minimum Fragment          */
+
+/*
+ * Int_En (0x18) bit assign -------------------------------------------
+ * Since bit 6 of the Int_En register at 0x18 is reserved and even writing
+ * to this register bit causes random interrupts, take caution when writing
+ * to this register - always write 0 there. For this reason there are two
+ * definitions for Enable and Disable and couldn't use the ~ of the Enable
+ * for Disable,
+ */
+#define IntEn_NRAB     0x00000800 /* Non-recoverable abort enable      */
+#define IntEn_TxCtlCmp 0x00000400 /* Transmit Ctl Complete enable      */
+#define IntEn_DmParErr 0x00000200 /* DMA Parity Error enable           */
+#define IntEn_DParD    0x00000100 /* Data Parity Detected enable       */
+#define IntEn_EarNot   0x00000080 /* Early Rx Notify enable            */
+/* RESERVED            0x00000040    Not used, must be zero            */
+#define IntEn_SSysErr  0x00000020 /* Signalled System Error enable     */
+#define IntEn_RMAB     0x00000010 /* Received Master Abort enable      */
+#define IntEn_RTAB     0x00000008 /* Received Target Abort enable      */
+#define IntEn_STAB     0x00000004 /* Signaled Target Abort enable      */
+#define IntEn_BLEx     0x00000002 /* Buffer List Exhausted enable      */
+#define IntEn_FDAEx    0x00000001 /* FDA Exhausted Enable              */
+
+/* Int_Src (0x24) bit assign ------------------------------------------ */
+#define IntSrc_ExtE            0x00040000 /* External Event int.       */
+/* RESERVED                    0x00020000    Not used, must be zero    */
+#define IntSrc_ExDefer         0x00010000 /* Excessive Tx Deferrals int. */
+#define IntSrc_Link_St         0x00008000 /* Link State Change status  */
+#define IntSrc_NRAB            0x00004000 /* Non-recoverable abort int.*/
+#define IntSrc_DmParErr                0x00002000 /* DMA Parity Error int.     
*/
+#define IntSrc_BLEx            0x00001000 /* Buffer List Exhausted int */
+#define IntSrc_FDAEx           0x00000800 /* FDA Exhausted, int.       */
+#define IntSrc_NRAB_St         0x00000400 /* Non-recoverable abort status */
+#define        IntSrc_Cmp              0x00000200 /* MAC ctrl packet int.      
*/
+#define IntSrc_ExBD            0x00000100 /* Excessive BD status       */
+#define IntSrc_DmParErr_St     0x00000080 /* DMA Parity Error status   */
+#define IntSrc_EarNot          0x00000040 /* Rx early notify int.      */
+#define IntSrc_SWInt_St                0x00000020 /* Software Request status   
*/
+#define IntSrc_BLEx_St         0x00000010 /* Buffer List Exhausted status */
+#define IntSrc_FDAEx_St                0x00000008 /* FDA Exhausted status      
*/
+/* RESERVED                    0x00000004    Not used, must be zero    */
+#define IntSrc_MacRx           0x00000002 /* Rx packet int.            */
+#define IntSrc_MacTx           0x00000001 /* Tx packet int.            */
+
+/* MAC_Ctl (0x40) bit assign ------------------------------------------ */
+#define MAC_Link10             0x00008000 /* 1:Link Status 10Mbits     */
+/* RESERVED                    0x00004000    Not used, must be zero    */
+#define MAC_EnMissRoll         0x00002000 /* 1:Enable Missed Roll      */
+#define MAC_MissRoll           0x00000400 /* 1:Missed Roll             */
+#define MAC_LnkChg             0x00000100 /* write 1 to clear Int_Link */
+#define MAC_Loop10             0x00000080 /* 1:Loop 10 Mbps            */
+#define MAC_Conn_Auto          0x00000000 /* 00:Connection mode (Automatic) */
+#define MAC_Conn_10M           0x00000020 /* 01:10Mbps endec)          */
+#define MAC_Conn_Mll           0x00000040 /* 10:(Mll clock)            */
+#define MAC_MacLoop            0x00000010 /* 1:MAC Loopback            */
+#define MAC_FullDup            0x00000008 /* 1:Full Duplex 0:Half Duplex */
+#define MAC_Reset              0x00000004 /* 1:Software Reset          */
+#define MAC_HaltImm            0x00000002 /* 1:Halt Immediate          */
+#define MAC_HaltReq            0x00000001 /* 1:Halt request            */
+
+ /* ARC_Ctl (0x44) (bit assign ---------------------------------------- */
+#define ARC_CompEn             0x00000010 /* 1:ARC Compare Enable      */
+#define ARC_NegCAM             0x00000008 /* 1:Reject packets ARC      */
+                                          /* recognizes, accept other */
+#define ARC_BroadAcc           0x00000004 /* 1:Broadcast accept        */
+#define ARC_GroupAcc           0x00000002 /* 1:Multicast accept        */
+#define ARC_StationAcc         0x00000001 /* 1:unicast accept          */
+
+/* Tx_Ctl (0x48) bit assign ------------------------------------------- */
+#define Tx_EnComp              0x00004000 /* 1:Enable Completion       */
+#define Tx_EnTxPar             0x00002000 /* 1:Enable Transmit Parity  */
+#define Tx_EnLateColl          0x00001000 /* 1:Enable Late Collision   */
+#define Tx_EnExColl            0x00000800 /* 1:Enable Excessive Collision */
+#define Tx_EnLCarr             0x00000400 /* 1:Enable Lost Carrier     */
+#define Tx_EnExDefer           0x00000200 /* 1:Enable Excessive Deferral */
+#define Tx_EnUnder             0x00000100 /* 1:Enable Underrun         */
+#define Tx_FBack               0x00000010 /* 1:Fast Back-off           */
+#define Tx_NoCRC               0x00000008 /* 1:Suppress Padding        */
+#define Tx_NoPad               0x00000004 /* 1:Suppress Padding        */
+#define Tx_TxHalt              0x00000002 /* 1:Transmit Halt Request   */
+#define Tx_En                  0x00000001 /* 1:Transmit enable         */
+
+/* Tx_Stat (0x4C) bit assign ------------------------------------------ */
+#define Tx_SQErr               0x00010000 /* Signal Quality Error(SQE) */
+#define Tx_Halted              0x00008000 /* Tx Halted                 */
+#define Tx_Comp                        0x00004000 /* Completion                
*/
+#define Tx_TxPar               0x00002000 /* Tx Parity Error           */
+#define Tx_LateColl            0x00001000 /* Late Collision            */
+#define Tx_10Stat              0x00000800 /* 10Mbps Status             */
+#define Tx_NCarr               0x00000400 /* No Carrier                */
+#define Tx_Defer               0x00000200 /* Deferral                  */
+#define Tx_Under               0x00000100 /* Underrun                  */
+#define Tx_IntTx               0x00000080 /* Interrupt on Tx           */
+#define Tx_Paused              0x00000040 /* Transmit Paused           */
+#define Tx_TXDefer             0x00000020 /* Transmit Defered          */
+#define Tx_ExColl              0x00000010 /* Excessive Collision       */
+#define Tx_TxColl_MASK         0x0000000F /* Tx Collision Count        */
+
+/*
+ * Rx_Ctl (0x50) bit assign -------------------------------------------
+ * EnLenErr is a bit that is NOT defined in the manual but was added
+ * It indicates the reception of a frame whose protocol id field value
+ * does not match a length. This interrupt allows us the process IP
+ * and other packets whose protocol id field is not treated as a length
+ */
+#define Rx_EnGood              0x00004000 /* 1:Enable Good             */
+#define Rx_EnRxPar             0x00002000 /* 1:Enable Receive Parity   */
+#define Rx_EnLenErr            0x00001000 /* 1:Enable Length Error     */
+#define Rx_EnLongErr           0x00000800 /* 1:Enable Long Error       */
+#define Rx_EnOver              0x00000400 /* 1:Enable OverFlow         */
+#define Rx_EnCRCErr            0x00000200 /* 1:Enable CRC Error        */
+#define Rx_EnAlign             0x00000100 /* 1:Enable Alignment        */
+/* RESERVED                    0x00000080    Not used, must be zero    */
+#define Rx_IgnoreCRC           0x00000040 /* 1:Ignore CRC Value        */
+#define Rx_StripCRC            0x00000010 /* 1:Strip CRC Value         */
+#define Rx_ShortEn             0x00000008 /* 1:Short Enable            */
+#define Rx_LongEn              0x00000004 /* 1:Long Enable             */
+#define Rx_RxHalt              0x00000002 /* 1:Receive Halt Request    */
+#define Rx_RxEn                        0x00000001 /* 1:Receive Intrrupt Enable 
*/
+
+/* Rx_Stat (0x54) bit assign ------------------------------------------ */
+#define Rx_Halted              0x00008000 /* Rx Halted                 */
+#define Rx_Good                        0x00004000 /* Rx Good                   
*/
+#define Rx_RxPar               0x00002000 /* Rx Parity Error           */
+/* RESERVED                    0x00001000    Not used, must be zero    */
+#define Rx_LongErr             0x00000800 /* Rx Long Error             */
+#define Rx_Over                        0x00000400 /* Rx Overflow               
*/
+#define Rx_CRCErr              0x00000200 /* Rx CRC Error              */
+#define Rx_Align               0x00000100 /* Rx Alignment Error        */
+#define Rx_10Stat              0x00000080 /* Rx 10Mbps Status          */
+#define Rx_IntRx               0x00000040 /* Rx Interrupt              */
+#define Rx_CtlRecd             0x00000020 /* Rx Control Receive        */
+#define Rx_Stat_Mask           0x0000EFC0 /* Rx All Status Mask        */
+
+/* MD_CA (0x5C) bit assign -------------------------------------------- */
+#define MD_CA_PreSup           0x00001000 /* 1:Preamble Supress        */
+#define MD_CA_BUSY_BIT         0x00000800 /* 1:Busy (Start Operation)  */
+#define MD_CA_Wr               0x00000400 /* 1:Write 0:Read            */
+#define MD_CA_PHYADD           0x000003E0 /* bits 9:5                  */
+#define MD_CA_PHYREG           0x0000001F /* bits 4:0                  */
+#define MD_CA_PhyShift         5
+#define MD_MAX_PHY             32      /* Maximum number of PHY per MII */
+#define MD_UNASSIGNED_PHY      0xFD    /* PHY address has not been     */
+                                       /* determined yet               */
+#define MD_SWITCH_PHY          0xFE    /* No PHY exists                */
+#define MD_DYNAMIC_PHY         0xFF    /* Dynamically find phy         */
+
+/* ARC_Ena (0x68) bit assign ------------------------------------------ */
+#define ARC_ENTRY_MAX          21       /* ARC Data entry max count    */
+#define ARC_Ena_Mask           ((1 << ARC_ENTRY_MAX) - 1)
+                                       /* ARC Enable bits (Max 21) */
+#define ARC_Ena_Bit(index)     (1 << (index))
+#define ARC_ENTRY_DESTINATION  0
+#define ARC_ENTRY_SOURCE       1
+#define ARC_ENTRY_MACCTL       20
+
+/* BCTRL_Reg (0xd4) bit assign ---------------------------------------- */
+#define RMII_Reset             0x00000004 /* RMII Reset                */
+#define RMII_10MBIT            0x00000002 /* 1 if 10 Mbs, 0 if 100 Mbs */
+#define RMII_ClkRising         0x00000001 /* 0 if TxD generated off    */
+                                          /* falling edge,             */
+                                          /* 1 if generated off        */
+                                          /* rising edge of Tx-CLK     */
+
+/**********************************************************************
+ * Data structures
+ */
+
+/* Frame descripter */
+struct f_desc {
+       volatile u32 FDNext;
+       volatile u32 FDSystem;
+       volatile u32 FDStat;
+       volatile u32 FDCtl;
+};
+
+/* Buffer descripter */
+struct b_desc {
+       volatile u32 BuffData;
+       volatile u32 BDCtl;
+};
+
+#define FD_ALIGN       16
+
+/* Frame Descripter bit assign ---------------------------------------- */
+#define FD_Next_EOL            0x00000001 /* FDNext EOL indicator      */
+#define FD_Next_MASK           0xFFFFFFF0 /* FDNext valid pointer      */
+
+#define FD_FDLength_MASK       0x0000FFFF /* Length MASK               */
+#define FD_BDCnt_MASK          0x001F0000 /* BD count MASK in FD       */
+#define FD_FrmOpt_MASK         0x7C000000 /* Frame option MASK         */
+#define FD_FrmOpt_BigEndian    0x40000000 /* Tx/Rx                     */
+#define FD_FrmOpt_IntTx                0x20000000 /* Tx only                   
*/
+#define FD_FrmOpt_NoCRC                0x10000000 /* Tx only                   
*/
+#define FD_FrmOpt_NoPadding    0x08000000 /* Tx only                   */
+#define FD_FrmOpt_Packing      0x04000000 /* Rx only                   */
+#define FD_CownsFD             0x80000000 /* FD Controller owner bit   */
+#define FD_BDCnt_SHIFT         16
+#define FD_CownsFD_Set         0x80010000 /* (FD_CownsFD |             */
+                                          /* (1 << FD_BDCnt_SHIFT))    */
+
+/* Buffer Descripter bit assign --------------------------------------- */
+#define BD_BuffLength_MASK     0x0000FFFF /* Recieve Data Size         */
+#define BD_RxBDID_MASK         0x00FF0000 /* BD ID Number MASK         */
+#define BD_RxBDSeqN_MASK       0x7F000000 /* Rx BD Sequence Number     */
+#define BD_CownsBD             0x80000000 /* BD Controller owner bit   */
+#define BD_DataAlign_MASK      0xFFFFFFF0 /* Buffer alignment mask     */
+#define BD_RxBDID_SHIFT                16
+#define BD_RxBDSeqN_SHIFT      24
+
+/* Operational constants */
+#define DMA_CTL_CMD (DMA_M66EnStat | DMA_RxBigE | DMA_TxBigE | \
+                       DMA_RxAlign2 | (DMA_BURST_SIZE << DMA_BRST_Shift))
+
+#define TX_CTL_CMD (Tx_EnComp | Tx_EnTxPar | Tx_EnLateColl | \
+                       Tx_EnExColl | Tx_EnLCarr | Tx_EnExDefer | \
+                       Tx_EnUnder | Tx_En)
+
+#define RX_CTL_CMD (Rx_EnGood | Rx_EnRxPar | Rx_EnLongErr | Rx_EnOver | \
+                       Rx_EnCRCErr | Rx_EnAlign | Rx_RxEn)
+
+#define INT_EN_CMD (IntEn_NRAB | IntEn_DmParErr | IntEn_SSysErr | \
+                       IntEn_BLEx | IntEn_FDAEx)
+
+#define FATAL_ERROR_INT (IntSrc_NRAB | IntSrc_DmParErr | IntSrc_BLEx)
+
+#define BMSR_EXISTS (BMSR_ANEGCAPABLE | BMSR_10HALF | BMSR_10FULL | \
+                       BMSR_100HALF | BMSR_100FULL)
+
+/* Error check and calculate constants & masks */
+#if RX_BUF_ORDER > 8 || RX_BUF_ORDER < 0
+#error "RX buffer order out of limits. 0 < ORDER < 9"
+#endif
+
+#if TX_BUF_ORDER > 8 || TX_BUF_ORDER < 0
+#error "TX buffer order out of limits. 0 < ORDER < 9"
+#endif
+
+#define RX_BUF_NUM     (1 << RX_BUF_ORDER)
+#define RX_BUF_MASK    (RX_BUF_NUM - 1)
+#define TX_BUF_NUM     (1 << TX_BUF_ORDER)
+#define TX_BUF_MASK    (TX_BUF_NUM - 1)
+
+#ifdef CONFIG_MSPETH_NAPI
+#define TXDONE_MAX_PKT 4
+#define NAPI_WEIGHT    64      /* Number of packets handled at one poll */
+#else
+#define TXDONE_MAX_PKT TX_BUF_NUM
+#endif /* CONFIG_MSPETH_NAPI */
+
+#ifdef CONFIG_MSPETH_SKB_RECYCLE
+#define SKBUFF_RECYCLABLE_SIZE (SKB_DATA_ALIGN(MSP_END_BUFSIZE + 2 + 16))
+
+/* Handler for skb recycle bin */
+struct {
+       struct sk_buff  *recycle_queue; /* recyclable skbs are queued here */
+       unsigned long   recycle_max;    /* storage capacity in no.of skbs */
+       unsigned long   recycle_count;  /* avilable skbs in bin */
+       unsigned long   user_count;     /* bin usage count */
+       unsigned long   recycle_hits;   /* number of hits */
+       unsigned long   recycle_misses; /* number of misses */
+       spinlock_t      lock;           /* for mutual exclusion */
+} skb_bin;
+#endif /* CONFIG_MSPETH_SKB_RECYCLE */
+
+struct q_desc {
+       union {
+               struct f_desc fd;
+               struct f_desc fd0;
+       };
+       union {
+               struct b_desc bd;
+               struct f_desc fd1;
+       };
+};
+
+/*
+ * hammtrev, 2005-11-25:
+ * Apparently, the MSP Ethernet has a hardware issue which could hang the
+ * device if a BLEx interrupt comes before a FDAEx, so they should be
+ * avoided if at all possible. Changing to ensure there are twice as many
+ * buffer descriptors as frame descriptors.
+ */
+struct bl_desc {
+       struct f_desc fd;
+       struct b_desc bd[RX_BUF_NUM << 1];
+};
+
+
+/* Structure to define access to each phy (for control purposes) */
+struct mspeth_phy {
+       struct mspeth_phy *next_phy;
+       u8 hwunit;
+       u8 phyaddr;
+       void *memaddr;
+       bool assigned;
+       bool linkup;
+       spinlock_t lock;
+};
+
+/* Information that need to be kept for each board. */
+struct mspeth_priv {
+       /* device configuration & constants */
+       u8 unit;                /* logical unit number */
+       u8 hwunit;              /* hardware unit number */
+       u8 option;              /* option setting from PROM or bootline */
+       int speed;              /* actual speed, 10 or 100 */
+       bool fullduplex;        /* actual duplex */
+
+       /* device object pointer */
+       struct device *dev;
+
+       /* phy configuration & control index */
+       struct mspeth_phy *phyptr;
+
+       /* ioremapped register access cookie */
+       void *mapaddr;
+       
+       /* ioremapped system reset registers */
+       void *rstaddr;
+
+       /* tasklet queues */
+       struct tasklet_struct rx_tasklet;
+       struct tasklet_struct tx_tasklet;
+       struct tasklet_struct hard_restart_tasklet;
+
+       /* link monitor timer */
+       struct timer_list link_timer;
+
+       /* statistics */
+       struct net_device_stats stats; /* statistics */
+       int fatal_icnt;
+       struct {
+               int max_tx_qlen;
+               int tx_ints;
+               int rx_ints;
+               int tx_full;
+               int fd_exha;
+       } lstats;
+
+       /*
+        * Buffer structures
+        *
+        * Transmitting: Batch Mode.
+        * 1 BD in 1 TxFD
+        * circular list of FDs
+        * Receiving: Non-Packing mode
+        * 1 circular FD for Free Buffer List.
+        * RX_BUF_NUM BD in Free Buffer FD.
+        * One Free Buffer BD has preallocated skb data
+        */
+       void *fd_base;
+
+       struct q_desc *rxfd_base; /* RX FD region ptr */
+       struct q_desc *rxfd_curr; /* RX FD current ptr */
+       struct q_desc *txfd_base; /* TX FD region ptr */
+
+       u32 tx_head, tx_tail;   /* insert/delete for TX queue */
+       atomic_t tx_qspc;       /* space available on the transmit queue */
+
+       struct bl_desc *blfd_ptr; /* Free list FD head */
+       struct sk_buff **rx_skbp; /* RX skb ptr array */
+       dma_addr_t *rx_dma_skbp;  /* RX dma map array */
+};
+
+#endif /* _MSPETH_H_ */
diff --git a/arch/mips/pmc-sierra/msp71xx/msp_eth.c 
b/arch/mips/pmc-sierra/msp71xx/msp_eth.c
new file mode 100644
index 0000000..8799960
--- /dev/null
+++ b/arch/mips/pmc-sierra/msp71xx/msp_eth.c
@@ -0,0 +1,122 @@
+/*
+ * The setup file for ethernet related hardware on PMC-Sierra MSP processors.
+ *
+ * Copyright 2005-2006 PMC-Sierra, Inc.
+ *
+ *  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 (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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.
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+
+#include <msp_regs.h>
+#include <msp_int.h>
+
+#if defined(CONFIG_PMC_MSP4200_GW)
+#include <msp_regops.h>
+#include <msp_gpio.h>
+#define        MSP_ETH_GPIO            9
+#define        MSP_ETH_GPIO_MODE_REG   GPIO_CFG3_REG
+#define        MSP_ETH_GPIO_DATA_REG   GPIO_DATA3_REG
+#elif defined(CONFIG_PMC_MSP7120_GW)
+#include <msp_regops.h>
+#include <msp_gpio.h>
+#define MSP_ETH_GPIO           14
+#define        MSP_ETH_GPIO_MODE_REG   GPIO_CFG4_REG
+#define        MSP_ETH_GPIO_DATA_REG   GPIO_DATA4_REG
+#endif
+
+#define MSP_ETH_ID     "mspeth"
+
+static struct resource msp_eth0_resources[] = {
+       [0] = {
+               .start  = MSP_MAC0_BASE,
+               .end    = MSP_MAC0_BASE + MSP_MAC_SIZE - 1,
+               .flags  = IORESOURCE_MEM,
+       },
+       [1] = {
+               .start  = MSP_INT_MAC0,
+               .end    = MSP_INT_MAC0,
+               .flags  = IORESOURCE_IRQ,
+       },
+};
+
+static struct resource msp_eth1_resources[] = {
+       [0] = {
+               .start  = MSP_MAC1_BASE,
+               .end    = MSP_MAC1_BASE + MSP_MAC_SIZE - 1,
+               .flags  = IORESOURCE_MEM,
+       },
+       [1] = {
+               .start  = MSP_INT_MAC1,
+               .end    = MSP_INT_MAC1,
+               .flags  = IORESOURCE_IRQ,
+       },
+};
+
+static struct platform_device msp_eth_devs[] = {
+       [0] = {
+               .name   = MSP_ETH_ID,
+               .id     = 0,
+               .num_resources = ARRAY_SIZE(msp_eth0_resources),
+               .resource = msp_eth0_resources,
+       },
+       [1] = {
+               .name   = MSP_ETH_ID,
+               .id     = 1,
+               .num_resources = ARRAY_SIZE(msp_eth1_resources),
+               .resource = msp_eth1_resources,
+       },
+};
+
+static int __init msp_eth_setup(void)
+{
+       int i, ret = 0;
+       
+#if defined(CONFIG_PMC_MSP4200_GW) || \
+    defined(CONFIG_PMC_MSP7120_GW)
+       /* Configure the GPIO and take the ethernet PHY out of reset */
+       set_value_reg32(MSP_ETH_GPIO_MODE_REG,
+                       BASIC_MODE_MASK(MSP_ETH_GPIO),
+                       BASIC_MODE(MSP_GPIO_OUTPUT, MSP_ETH_GPIO));
+       set_reg32(MSP_ETH_GPIO_DATA_REG, 
+                       BASIC_DATA_MASK(MSP_ETH_GPIO));
+#endif
+
+       /* Register the ethernet devices and bind the drivers */
+       for (i = 0; i < ARRAY_SIZE(msp_eth_devs); i++) {
+               ret = platform_device_register(&msp_eth_devs[i]);
+               if (ret) {
+                       while (--i >= 0)
+                               platform_device_unregister(&msp_eth_devs[i]);
+                       break;
+               }
+       }
+       
+       if (ret)
+               printk(KERN_WARNING
+                       "Could not initialize MSPETH device structures.\n");
+
+       return ret;
+}
+
+subsys_initcall(msp_eth_setup);

<Prev in Thread] Current Thread [Next in Thread>
  • [PATCH 10/12] drivers: PMC MSP71xx ethernet driver, Marc St-Jean <=