(6/6) bcm57xx: package

This is the bcm57xx package.  I have tested default vlan functions,
but I dont have the equipment to test more advanced setups.  The default
vlan setup seems to be working fine.  I also added the activate_gpio
parameter which will make the driver activate the switch via gpio before
probing for it.

I'm not sure which method is best for autoload.  For the wrt350n, I
need the activate_gpio parameter.  But its probably not a good idea
to add that to the autoload file.  On a system without a bcm57xx switch,
isn't it a bad idea to mess with the gpios looking for the switch? Ideally,
wouldn't it be best to load the bcm57xx module from broadcom-diag, after
it has determined which router its on?  I tried using 'request_module' from
there, but had no success.  For now, I am relying on preinit to load
the bcm57xx module with activate_gpio param, after it has failed to load
switch_robo and switch_adm.

Signed-off-by: Ben Pfountz <netprince (at) vt (dot) edu>

SVN-Revision: 11471

1 files changed, 5563 insertions, 0 deletions

diff --git a/package/broadcom-57xx/src/b57um.c b/package/broadcom-57xx/src/b57um.c
new file mode 100644
index 0000000000..752241dd4b
--- /dev/null
+++ b/package/broadcom-57xx/src/b57um.c
@@ -0,0 +1,5563 @@
+/******************************************************************************/
+/*                                                                            */
+/* Broadcom BCM5700 Linux Network Driver, Copyright (c) 2000 - 2005 Broadcom  */
+/* Corporation.                                                               */
+/* All rights reserved.                                                       */
+/*                                                                            */
+/* 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, located in the file LICENSE.                 */
+/*                                                                            */
+/******************************************************************************/
+
+/* $Id: b57um.c,v 1.32 2007/09/06 07:28:06 yogo Exp $ */
+
+char bcm5700_driver[] = "bcm57xx";
+char bcm5700_version[] = "8.3.14";
+char bcm5700_date[] = "(11/2/05)";
+
+#define B57UM
+#include "mm.h"
+#include "linux/mii.h" //@.@jack add it 2006/06/28.
+#include "typedefs.h"
+#include "osl.h"
+#include "bcmdefs.h"
+#include "bcmdevs.h"
+#include "sbconfig.h"
+#include "sbutils.h"
+#include "hndgige.h"
+#include "bcmrobo.h"
+#include "robo_register.c"
+
+#include "bcmendian.h"
+#include "bcmnvram.h"
+#include "proto/ethernet.h"
+#include "proto/vlan.h"
+#include "proto/bcmtcp.h"
+#include "proto/bcmip.h"
+#define	PKTDATA(osh, skb)		(((struct sk_buff*)(skb))->data)
+
+/* this is needed to get good and stable performances */
+#define EXTRA_HDR BCMEXTRAHDROOM
+
+#define SIOCGREG_STATUS  0x8996          /* Read Switch register (for debug)*/
+#define SIOCSREG_STATUS  0x8997          /* Write Switch register(for debug)*/
+
+/* This structure is used in SIOCXREG_STATUS ioctl calls*/
+struct reg_ioctl_data {
+        u16             page_num;
+        u16             addr_num;
+        u16             len;
+	u16		val_in[4];
+	u16		val_out[4];
+};
+
+/* A few user-configurable values. */
+
+#define MAX_UNITS 16
+/* Used to pass the full-duplex flag, etc. */
+static int line_speed[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static int auto_speed[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static int full_duplex[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static int rx_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static int tx_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static int auto_flow_control[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+static int mtu[MAX_UNITS] = {1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500};	/* Jumbo MTU for interfaces. */
+#endif
+static int tx_checksum[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static int rx_checksum[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static int scatter_gather[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static int activate_gpio = -1;
+
+#define TX_DESC_CNT DEFAULT_TX_PACKET_DESC_COUNT
+static unsigned int tx_pkt_desc_cnt[MAX_UNITS] =
+	{TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
+	TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
+	TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,TX_DESC_CNT,
+	TX_DESC_CNT};
+
+#define RX_DESC_CNT DEFAULT_STD_RCV_DESC_COUNT
+static unsigned int rx_std_desc_cnt[MAX_UNITS] =
+	{RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
+	RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
+	RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,RX_DESC_CNT,
+	RX_DESC_CNT };
+
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+#define JBO_DESC_CNT DEFAULT_JUMBO_RCV_DESC_COUNT
+static unsigned int rx_jumbo_desc_cnt[MAX_UNITS] =
+	{JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
+	JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
+	JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,JBO_DESC_CNT,
+	JBO_DESC_CNT };
+#endif
+
+#ifdef BCM_INT_COAL
+#ifdef BCM_NAPI_RXPOLL
+static unsigned int adaptive_coalesce[MAX_UNITS] =
+	{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+#else
+static unsigned int adaptive_coalesce[MAX_UNITS] =
+	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+#endif
+
+#define RX_COAL_TK DEFAULT_RX_COALESCING_TICKS
+static unsigned int rx_coalesce_ticks[MAX_UNITS] =
+	{RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
+	RX_COAL_TK, RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
+	RX_COAL_TK,RX_COAL_TK, RX_COAL_TK,RX_COAL_TK,RX_COAL_TK,
+	RX_COAL_TK};
+
+#define RX_COAL_FM DEFAULT_RX_MAX_COALESCED_FRAMES
+static unsigned int rx_max_coalesce_frames[MAX_UNITS] =
+	{RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
+	RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
+	RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,RX_COAL_FM,
+	RX_COAL_FM};
+
+#define TX_COAL_TK DEFAULT_TX_COALESCING_TICKS
+static unsigned int tx_coalesce_ticks[MAX_UNITS] =
+	{TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
+	TX_COAL_TK, TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
+	TX_COAL_TK,TX_COAL_TK, TX_COAL_TK,TX_COAL_TK,TX_COAL_TK,
+	TX_COAL_TK};
+
+#define TX_COAL_FM DEFAULT_TX_MAX_COALESCED_FRAMES
+static unsigned int tx_max_coalesce_frames[MAX_UNITS] =
+	{TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
+	TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
+	TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,TX_COAL_FM,
+	TX_COAL_FM};
+
+#define ST_COAL_TK DEFAULT_STATS_COALESCING_TICKS
+static unsigned int stats_coalesce_ticks[MAX_UNITS] =
+	{ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
+	ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
+	ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,ST_COAL_TK,
+	ST_COAL_TK,};
+
+#endif
+#ifdef BCM_WOL
+static int enable_wol[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+#endif
+#ifdef BCM_TSO
+static int enable_tso[MAX_UNITS] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+#endif
+#ifdef BCM_NIC_SEND_BD
+static int nic_tx_bd[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+#endif
+#ifdef BCM_ASF
+static int vlan_tag_mode[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+#endif
+static int delay_link[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static int disable_d3hot[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+static int disable_msi[MAX_UNITS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static int bcm_msi_chipset_bug = 0;
+#endif
+
+#define BCM_TIMER_GRANULARITY  (1000000 / HZ)
+
+/* Hack to hook the data path to the BCM WL dirver */
+#ifdef BCM_WL_EMULATOR
+#include "bcmnvram.h"
+#include "wl_bcm57emu.h" 
+#ifdef SKB_MANAGER
+int skb_old_alloc = 0;
+#endif
+#endif /* BCM_WL_EMULATOR */
+
+/* Operational parameters that usually are not changed. */
+/* Time in jiffies before concluding the transmitter is hung. */
+#define TX_TIMEOUT  (2*HZ)
+
+#if (LINUX_VERSION_CODE < 0x02030d)
+#define pci_resource_start(dev, bar)	(dev->base_address[bar] & PCI_BASE_ADDRESS_MEM_MASK)
+#elif (LINUX_VERSION_CODE < 0x02032b)
+#define pci_resource_start(dev, bar)	(dev->resource[bar] & PCI_BASE_ADDRESS_MEM_MASK)
+#endif
+
+#if (LINUX_VERSION_CODE < 0x02032b)
+#define dev_kfree_skb_irq(skb)  dev_kfree_skb(skb)
+#define netif_wake_queue(dev)	clear_bit(0, &dev->tbusy); mark_bh(NET_BH)
+#define netif_stop_queue(dev)	set_bit(0, &dev->tbusy)
+
+static inline void netif_start_queue(struct net_device *dev)
+{
+	dev->tbusy = 0;
+	dev->interrupt = 0;
+	dev->start = 1;
+}
+
+#define netif_queue_stopped(dev)	dev->tbusy
+#define netif_running(dev)		dev->start
+
+static inline void tasklet_schedule(struct tasklet_struct *tasklet)
+{
+	queue_task(tasklet, &tq_immediate);
+	mark_bh(IMMEDIATE_BH);
+}
+
+static inline void tasklet_init(struct tasklet_struct *tasklet,
+				void (*func)(unsigned long),
+				unsigned long data)
+{
+		tasklet->next = NULL;
+		tasklet->sync = 0;
+		tasklet->routine = (void (*)(void *))func;
+		tasklet->data = (void *)data;
+}
+
+#define tasklet_kill(tasklet)
+
+#endif
+
+#if (LINUX_VERSION_CODE < 0x020300)
+struct pci_device_id {
+	unsigned int vendor, device;		/* Vendor and device ID or PCI_ANY_ID */
+	unsigned int subvendor, subdevice;	/* Subsystem ID's or PCI_ANY_ID */
+	unsigned int class, class_mask;		/* (class,subclass,prog-if) triplet */
+	unsigned long driver_data;		/* Data private to the driver */
+};
+
+#define PCI_ANY_ID		0
+
+#define pci_set_drvdata(pdev, dev)
+#define pci_get_drvdata(pdev) 0
+
+#define pci_enable_device(pdev) 0
+
+#define __devinit		__init
+#define __devinitdata		__initdata
+#define __devexit
+
+#define SET_MODULE_OWNER(dev)
+#define MODULE_DEVICE_TABLE(pci, pci_tbl)
+
+#endif
+
+#if (LINUX_VERSION_CODE < 0x020411)
+#ifndef __devexit_p
+#define __devexit_p(x)	x
+#endif
+#endif
+
+#ifndef MODULE_LICENSE
+#define MODULE_LICENSE(license)
+#endif
+
+#ifndef IRQ_RETVAL
+typedef void irqreturn_t;
+#define IRQ_RETVAL(x)
+#endif
+
+#if (LINUX_VERSION_CODE < 0x02032a)
+static inline void *pci_alloc_consistent(struct pci_dev *pdev, size_t size,
+					 dma_addr_t *dma_handle)
+{
+	void *virt_ptr;
+
+	/* Maximum in slab.c */
+	if (size > 131072)
+		return 0;
+
+	virt_ptr = kmalloc(size, GFP_KERNEL);
+	*dma_handle = virt_to_bus(virt_ptr);
+	return virt_ptr;
+}
+#define pci_free_consistent(dev, size, ptr, dma_ptr)	kfree(ptr)
+
+#endif /*#if (LINUX_VERSION_CODE < 0x02032a) */
+
+
+#if (LINUX_VERSION_CODE < 0x02040d)
+
+#if (LINUX_VERSION_CODE >= 0x020409) && defined(RED_HAT_LINUX_KERNEL)
+
+#define BCM_32BIT_DMA_MASK ((u64) 0x00000000ffffffffULL)
+#define BCM_64BIT_DMA_MASK ((u64) 0xffffffffffffffffULL)
+
+#else
+/* pci_set_dma_mask is using dma_addr_t */
+
+#define BCM_32BIT_DMA_MASK ((dma_addr_t) 0xffffffff)
+#define BCM_64BIT_DMA_MASK ((dma_addr_t) 0xffffffff)
+
+#endif
+
+#else /* (LINUX_VERSION_CODE < 0x02040d) */
+
+#define BCM_32BIT_DMA_MASK ((u64) 0x00000000ffffffffULL)
+#define BCM_64BIT_DMA_MASK ((u64) 0xffffffffffffffffULL)
+#endif
+
+#if (LINUX_VERSION_CODE < 0x020329)
+#define pci_set_dma_mask(pdev, mask) (0)
+#else
+#if (LINUX_VERSION_CODE < 0x020403)
+int
+pci_set_dma_mask(struct pci_dev *dev, dma_addr_t mask)
+{
+    if(! pci_dma_supported(dev, mask))
+        return -EIO;
+
+    dev->dma_mask = mask;
+
+    return 0;
+}
+#endif
+#endif
+
+#if (LINUX_VERSION_CODE < 0x020547)
+#define pci_set_consistent_dma_mask(pdev, mask) (0)
+#endif
+
+#if (LINUX_VERSION_CODE < 0x020402)
+#define pci_request_regions(pdev, name) (0)
+#define pci_release_regions(pdev)
+#endif
+
+#if !defined(spin_is_locked)
+#define spin_is_locked(lock)    (test_bit(0,(lock)))
+#endif
+
+#define BCM5700_LOCK(pUmDevice, flags)					\
+	if ((pUmDevice)->do_global_lock) {				\
+		spin_lock_irqsave(&(pUmDevice)->global_lock, flags);	\
+	}
+
+#define BCM5700_UNLOCK(pUmDevice, flags)				\
+	if ((pUmDevice)->do_global_lock) {				\
+		spin_unlock_irqrestore(&(pUmDevice)->global_lock, flags);\
+	}
+
+inline void
+bcm5700_intr_lock(PUM_DEVICE_BLOCK pUmDevice)
+{
+	if (pUmDevice->do_global_lock) {
+		spin_lock(&pUmDevice->global_lock);
+	}
+}
+
+inline void
+bcm5700_intr_unlock(PUM_DEVICE_BLOCK pUmDevice)
+{
+	if (pUmDevice->do_global_lock) {
+		spin_unlock(&pUmDevice->global_lock);
+	}
+}
+
+void
+bcm5700_intr_off(PUM_DEVICE_BLOCK pUmDevice)
+{
+	atomic_inc(&pUmDevice->intr_sem);
+	LM_DisableInterrupt(&pUmDevice->lm_dev);
+#if (LINUX_VERSION_CODE >= 0x2051c)
+	synchronize_irq(pUmDevice->dev->irq);
+#else
+	synchronize_irq();
+#endif
+	LM_DisableInterrupt(&pUmDevice->lm_dev);
+}
+
+void
+bcm5700_intr_on(PUM_DEVICE_BLOCK pUmDevice)
+{
+	if (atomic_dec_and_test(&pUmDevice->intr_sem)) {
+		LM_EnableInterrupt(&pUmDevice->lm_dev);
+	}
+}
+
+
+int MM_Packet_Desc_Size = sizeof(UM_PACKET);
+
+#if defined(MODULE)
+MODULE_AUTHOR("Michael Chan <mchan at broadcom dot com> and Gary Zambrano <zambrano at broadcom dot com>");
+MODULE_DESCRIPTION("BCM5700 Driver");
+MODULE_LICENSE("GPL");
+
+#if (LINUX_VERSION_CODE < 0x020605)
+
+MODULE_PARM(debug, "i");
+MODULE_PARM(msglevel, "i");
+MODULE_PARM(activate_gpio, "0-15i");
+MODULE_PARM(line_speed, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(auto_speed, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(rx_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(tx_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(auto_flow_control, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+MODULE_PARM(mtu, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#endif
+MODULE_PARM(tx_checksum, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(rx_checksum, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(scatter_gather, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(tx_pkt_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(rx_std_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+MODULE_PARM(rx_jumbo_desc_cnt, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#endif
+#ifdef BCM_INT_COAL
+MODULE_PARM(adaptive_coalesce, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(rx_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(rx_max_coalesce_frames, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(tx_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(tx_max_coalesce_frames, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(stats_coalesce_ticks, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#endif
+#ifdef BCM_WOL
+MODULE_PARM(enable_wol, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#endif
+#ifdef BCM_TSO
+MODULE_PARM(enable_tso, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#endif
+#ifdef BCM_NIC_SEND_BD
+MODULE_PARM(nic_tx_bd, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#endif
+#ifdef BCM_ASF
+MODULE_PARM(vlan_tag_mode, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#endif
+MODULE_PARM(delay_link, "1-" __MODULE_STRING(MAX_UNITS) "i");
+MODULE_PARM(disable_d3hot, "1-" __MODULE_STRING(MAX_UNITS) "i");
+
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+MODULE_PARM(disable_msi, "1-" __MODULE_STRING(MAX_UNITS) "i");
+#endif
+
+#else /* parms*/
+
+#if (LINUX_VERSION_CODE >= 0x020605) && (LINUX_VERSION_CODE < 0x02060a)
+
+static int var;
+
+#define numvar var
+
+#endif
+
+#if (LINUX_VERSION_CODE >= 0x2060a)
+
+#define numvar NULL
+
+#endif
+
+module_param_array(line_speed, int, numvar, 0);
+module_param_array(auto_speed, int, numvar, 0);
+module_param_array(full_duplex, int, numvar, 0);
+module_param_array(rx_flow_control, int, numvar, 0);
+module_param_array(tx_flow_control, int, numvar, 0);
+module_param_array(auto_flow_control, int, numvar, 0);
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+module_param_array(mtu, int, numvar, 0);
+#endif
+module_param_array(tx_checksum, int, numvar, 0);
+module_param_array(rx_checksum, int, numvar, 0);
+module_param_array(scatter_gather, int, numvar, 0);
+module_param_array(tx_pkt_desc_cnt, int, numvar, 0);
+module_param_array(rx_std_desc_cnt, int, numvar, 0);
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+module_param_array(rx_jumbo_desc_cnt, int, numvar, 0);
+#endif
+#ifdef BCM_INT_COAL
+module_param_array(adaptive_coalesce, int, numvar, 0);
+module_param_array(rx_coalesce_ticks, int, numvar, 0);
+module_param_array(rx_max_coalesce_frames, int, numvar, 0);
+module_param_array(tx_coalesce_ticks, int, numvar, 0);
+module_param_array(tx_max_coalesce_frames, int, numvar, 0);
+module_param_array(stats_coalesce_ticks, int, numvar, 0);
+#endif
+#ifdef BCM_WOL
+module_param_array(enable_wol, int, numvar, 0);
+#endif
+#ifdef BCM_TSO
+module_param_array(enable_tso, int, numvar, 0);
+#endif
+#ifdef BCM_NIC_SEND_BD
+module_param_array(nic_tx_bd, int, numvar, 0);
+#endif
+#ifdef BCM_ASF
+module_param_array(vlan_tag_mode, int, numvar, 0);
+#endif
+module_param_array(delay_link, int, numvar, 0);
+module_param_array(disable_d3hot, int, numvar, 0);
+
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+module_param_array(disable_msi, int, numvar, 0);
+#endif
+
+
+#endif /* params */
+
+
+#endif
+
+#define RUN_AT(x) (jiffies + (x))
+
+char kernel_version[] = UTS_RELEASE;
+
+#define PCI_SUPPORT_VER2
+
+#if !defined(CAP_NET_ADMIN)
+#define capable(CAP_XXX) (suser())
+#endif
+
+#define tigon3_debug debug
+#if TIGON3_DEBUG
+static int tigon3_debug = TIGON3_DEBUG;
+#else
+static int tigon3_debug = 0;
+#endif
+static int msglevel = 0xdeadbeef;
+int b57_msg_level;
+
+int bcm5700_open(struct net_device *dev);
+STATIC void bcm5700_timer(unsigned long data);
+STATIC void bcm5700_stats_timer(unsigned long data);
+STATIC void bcm5700_reset(struct net_device *dev);
+STATIC int bcm5700_start_xmit(struct sk_buff *skb, struct net_device *dev);
+STATIC irqreturn_t bcm5700_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
+#ifdef BCM_TASKLET
+STATIC void bcm5700_tasklet(unsigned long data);
+#endif
+STATIC int bcm5700_close(struct net_device *dev);
+STATIC struct net_device_stats *bcm5700_get_stats(struct net_device *dev);
+STATIC int bcm5700_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
+STATIC void bcm5700_do_rx_mode(struct net_device *dev);
+STATIC void bcm5700_set_rx_mode(struct net_device *dev);
+STATIC int bcm5700_set_mac_addr(struct net_device *dev, void *p);
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+STATIC int bcm5700_change_mtu(struct net_device *dev, int new_mtu);
+#endif
+#ifdef BCM_NAPI_RXPOLL
+STATIC int bcm5700_poll(struct net_device *dev, int *budget);
+#endif
+STATIC int replenish_rx_buffers(PUM_DEVICE_BLOCK pUmDevice, int max);
+STATIC int bcm5700_freemem(struct net_device *dev);
+#ifdef BCM_INT_COAL
+#ifndef BCM_NAPI_RXPOLL
+STATIC int bcm5700_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice);
+#endif
+#endif
+STATIC void bcm5700_set_vlan_mode(UM_DEVICE_BLOCK *pUmDevice);
+STATIC int bcm5700_init_counters(PUM_DEVICE_BLOCK pUmDevice);
+#ifdef BCM_VLAN
+STATIC void bcm5700_vlan_rx_register(struct net_device *dev, struct vlan_group *vlgrp);
+STATIC void bcm5700_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid);
+#endif
+void bcm5700_shutdown(UM_DEVICE_BLOCK *pUmDevice);
+void bcm5700_free_remaining_rx_bufs(UM_DEVICE_BLOCK *pUmDevice);
+void bcm5700_validate_param_range(UM_DEVICE_BLOCK *pUmDevice, int *param,
+	char *param_name, int min, int max, int deflt);
+
+static int bcm5700_notify_reboot(struct notifier_block *this, unsigned long event, void *unused);
+static struct notifier_block bcm5700_reboot_notifier = {
+	bcm5700_notify_reboot,
+	NULL,
+	0
+};
+
+#if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
+STATIC void poll_bcm5700(struct net_device *dev);
+#endif
+
+/* A list of all installed bcm5700 devices. */
+static struct net_device *root_tigon3_dev = NULL;
+
+#if defined(CONFIG_SPARC64) || defined(CONFIG_X86_64) ||defined(CONFIG_PPC64)
+
+#endif
+
+typedef enum {
+	BCM5700A6 = 0,
+	BCM5700T6,
+	BCM5700A9,
+	BCM5700T9,
+	BCM5700,
+	BCM5701A5,
+	BCM5701T1,
+	BCM5701T8,
+	BCM5701A7,
+	BCM5701A10,
+	BCM5701A12,
+	BCM5701,
+	BCM5702,
+	BCM5703,
+	BCM5703A31,
+	BCM5703ARBUCKLE,
+	TC996T,
+	TC996ST,
+	TC996SSX,
+	TC996SX,
+	TC996BT,
+	TC997T,
+	TC997SX,
+	TC1000T,
+	TC1000BT,
+	TC940BR01,
+	TC942BR01,
+	TC998T,
+	TC998SX,
+	TC999T,
+	NC6770,
+	NC1020,
+	NC150T,
+	NC7760,
+	NC7761,
+	NC7770,
+	NC7771,
+	NC7780,
+	NC7781,
+	NC7772,
+	NC7782,
+	NC7783,
+	NC320T,
+	NC320I,
+	NC325I,
+	NC324I,
+	NC326I,
+	BCM5704CIOBE,
+	BCM5704,
+	BCM5704S,
+	BCM5705,
+	BCM5705M,
+	BCM5705F,
+	BCM5901,
+	BCM5782,
+	BCM5788,
+	BCM5789,
+	BCM5750,
+	BCM5750M,
+	BCM5720,
+	BCM5751,
+	BCM5751M,
+	BCM5751F,
+	BCM5721,
+	BCM5753,
+	BCM5753M,
+	BCM5753F,
+	BCM5781,
+	BCM5752,
+	BCM5752M,
+	BCM5714,
+	BCM5780,
+	BCM5780S,
+	BCM5715,
+	BCM4785,
+	BCM5903M,
+	UNK5788
+} board_t;
+
+
+/* indexed by board_t, above */
+static struct {
+	char *name;
+} board_info[] __devinitdata = {
+	{ "Broadcom BCM5700 1000Base-T" },
+	{ "Broadcom BCM5700 1000Base-SX" },
+	{ "Broadcom BCM5700 1000Base-SX" },
+	{ "Broadcom BCM5700 1000Base-T" },
+	{ "Broadcom BCM5700" },
+	{ "Broadcom BCM5701 1000Base-T" },
+	{ "Broadcom BCM5701 1000Base-T" },
+	{ "Broadcom BCM5701 1000Base-T" },
+	{ "Broadcom BCM5701 1000Base-SX" },
+	{ "Broadcom BCM5701 1000Base-T" },
+	{ "Broadcom BCM5701 1000Base-T" },
+	{ "Broadcom BCM5701" },
+	{ "Broadcom BCM5702 1000Base-T" },
+	{ "Broadcom BCM5703 1000Base-T" },
+	{ "Broadcom BCM5703 1000Base-SX" },
+	{ "Broadcom B5703 1000Base-SX" },
+	{ "3Com 3C996 10/100/1000 Server NIC" },
+	{ "3Com 3C996 10/100/1000 Server NIC" },
+	{ "3Com 3C996 Gigabit Fiber-SX Server NIC" },
+	{ "3Com 3C996 Gigabit Fiber-SX Server NIC" },
+	{ "3Com 3C996B Gigabit Server NIC" },
+	{ "3Com 3C997 Gigabit Server NIC" },
+	{ "3Com 3C997 Gigabit Fiber-SX Server NIC" },
+	{ "3Com 3C1000 Gigabit NIC" },
+	{ "3Com 3C1000B-T 10/100/1000 PCI" },
+	{ "3Com 3C940 Gigabit LOM (21X21)" },
+	{ "3Com 3C942 Gigabit LOM (31X31)" },
+	{ "3Com 3C998-T Dual Port 10/100/1000 PCI-X Server NIC" },
+	{ "3Com 3C998-SX Dual Port 1000-SX PCI-X Server NIC" },
+	{ "3Com 3C999-T Quad Port 10/100/1000 PCI-X Server NIC" },
+	{ "HP NC6770 Gigabit Server Adapter" },
+	{ "NC1020 HP ProLiant Gigabit Server Adapter 32 PCI" },
+	{ "HP ProLiant NC 150T PCI 4-port Gigabit Combo Switch Adapter" },
+	{ "HP NC7760 Gigabit Server Adapter" },
+	{ "HP NC7761 Gigabit Server Adapter" },
+	{ "HP NC7770 Gigabit Server Adapter" },
+	{ "HP NC7771 Gigabit Server Adapter" },
+	{ "HP NC7780 Gigabit Server Adapter" },
+	{ "HP NC7781 Gigabit Server Adapter" },
+	{ "HP NC7772 Gigabit Server Adapter" },
+	{ "HP NC7782 Gigabit Server Adapter" },
+	{ "HP NC7783 Gigabit Server Adapter" },
+	{ "HP ProLiant NC 320T PCI Express Gigabit Server Adapter" },
+	{ "HP ProLiant NC 320i PCI Express Gigabit Server Adapter" },
+	{ "HP NC325i Integrated Dual Port PCI Express Gigabit Server Adapter" },
+	{ "HP NC324i Integrated Dual Port PCI Express Gigabit Server Adapter" },
+	{ "HP NC326i Integrated Dual Port PCI Express Gigabit Server Adapter" },
+	{ "Broadcom BCM5704 CIOB-E 1000Base-T" },
+	{ "Broadcom BCM5704 1000Base-T" },
+	{ "Broadcom BCM5704 1000Base-SX" },
+	{ "Broadcom BCM5705 1000Base-T" },
+	{ "Broadcom BCM5705M 1000Base-T" },
+	{ "Broadcom 570x 10/100 Integrated Controller" },
+	{ "Broadcom BCM5901 100Base-TX" },
+	{ "Broadcom NetXtreme Gigabit Ethernet for hp" },
+	{ "Broadcom BCM5788 NetLink 1000Base-T" },
+	{ "Broadcom BCM5789 NetLink 1000Base-T PCI Express" },
+	{ "Broadcom BCM5750 1000Base-T PCI" },
+	{ "Broadcom BCM5750M 1000Base-T PCI" },
+	{ "Broadcom BCM5720 1000Base-T PCI" },
+	{ "Broadcom BCM5751 1000Base-T PCI Express" },
+	{ "Broadcom BCM5751M 1000Base-T PCI Express" },
+	{ "Broadcom BCM5751F 100Base-TX PCI Express" },
+	{ "Broadcom BCM5721 1000Base-T PCI Express" },
+	{ "Broadcom BCM5753 1000Base-T PCI Express" },
+	{ "Broadcom BCM5753M 1000Base-T PCI Express" },
+	{ "Broadcom BCM5753F 100Base-TX PCI Express" },
+	{ "Broadcom BCM5781 NetLink 1000Base-T PCI Express" },
+	{ "Broadcom BCM5752 1000Base-T PCI Express" },
+	{ "Broadcom BCM5752M 1000Base-T PCI Express" },
+	{ "Broadcom BCM5714 1000Base-T " },
+	{ "Broadcom BCM5780 1000Base-T" },
+	{ "Broadcom BCM5780S 1000Base-SX" },
+	{ "Broadcom BCM5715 1000Base-T " },
+	{ "Broadcom BCM4785 10/100/1000 Integrated Controller" },
+	{ "Broadcom BCM5903M Gigabit Ethernet " },
+	{ "Unknown BCM5788 Gigabit Ethernet " },
+	{ 0 }
+	};
+
+static struct pci_device_id bcm5700_pci_tbl[] __devinitdata = {
+	{0x14e4, 0x1644, 0x14e4, 0x1644, 0, 0, BCM5700A6 },
+	{0x14e4, 0x1644, 0x14e4, 0x2, 0, 0, BCM5700T6 },
+	{0x14e4, 0x1644, 0x14e4, 0x3, 0, 0, BCM5700A9 },
+	{0x14e4, 0x1644, 0x14e4, 0x4, 0, 0, BCM5700T9 },
+	{0x14e4, 0x1644, 0x1028, 0xd1, 0, 0, BCM5700 },
+	{0x14e4, 0x1644, 0x1028, 0x0106, 0, 0, BCM5700 },
+	{0x14e4, 0x1644, 0x1028, 0x0109, 0, 0, BCM5700 },
+	{0x14e4, 0x1644, 0x1028, 0x010a, 0, 0, BCM5700 },
+	{0x14e4, 0x1644, 0x10b7, 0x1000, 0, 0, TC996T },
+	{0x14e4, 0x1644, 0x10b7, 0x1001, 0, 0, TC996ST },
+	{0x14e4, 0x1644, 0x10b7, 0x1002, 0, 0, TC996SSX },
+	{0x14e4, 0x1644, 0x10b7, 0x1003, 0, 0, TC997T },
+	{0x14e4, 0x1644, 0x10b7, 0x1005, 0, 0, TC997SX },
+	{0x14e4, 0x1644, 0x10b7, 0x1008, 0, 0, TC942BR01 },
+	{0x14e4, 0x1644, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5700 },
+	{0x14e4, 0x1645, 0x14e4, 1, 0, 0, BCM5701A5 },
+	{0x14e4, 0x1645, 0x14e4, 5, 0, 0, BCM5701T1 },
+	{0x14e4, 0x1645, 0x14e4, 6, 0, 0, BCM5701T8 },
+	{0x14e4, 0x1645, 0x14e4, 7, 0, 0, BCM5701A7 },
+	{0x14e4, 0x1645, 0x14e4, 8, 0, 0, BCM5701A10 },
+	{0x14e4, 0x1645, 0x14e4, 0x8008, 0, 0, BCM5701A12 },
+	{0x14e4, 0x1645, 0x0e11, 0xc1, 0, 0, NC6770 },
+	{0x14e4, 0x1645, 0x0e11, 0x7c, 0, 0, NC7770 },
+	{0x14e4, 0x1645, 0x0e11, 0x85, 0, 0, NC7780 },
+	{0x14e4, 0x1645, 0x1028, 0x0121, 0, 0, BCM5701 },
+	{0x14e4, 0x1645, 0x10b7, 0x1004, 0, 0, TC996SX },
+	{0x14e4, 0x1645, 0x10b7, 0x1006, 0, 0, TC996BT },
+	{0x14e4, 0x1645, 0x10b7, 0x1007, 0, 0, TC1000T },
+	{0x14e4, 0x1645, 0x10b7, 0x1008, 0, 0, TC940BR01 },
+	{0x14e4, 0x1645, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5701 },
+	{0x14e4, 0x1646, 0x14e4, 0x8009, 0, 0, BCM5702 },
+	{0x14e4, 0x1646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
+	{0x14e4, 0x16a6, 0x14e4, 0x8009, 0, 0, BCM5702 },
+	{0x14e4, 0x16a6, 0x14e4, 0x000c, 0, 0, BCM5702 },
+	{0x14e4, 0x16a6, 0x0e11, 0xbb, 0, 0, NC7760 },
+	{0x14e4, 0x16a6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
+	{0x14e4, 0x16c6, 0x10b7, 0x1100, 0, 0, TC1000BT },
+	{0x14e4, 0x16c6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5702 },
+	{0x14e4, 0x1647, 0x14e4, 0x0009, 0, 0, BCM5703 },
+	{0x14e4, 0x1647, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
+	{0x14e4, 0x1647, 0x14e4, 0x000b, 0, 0, BCM5703 },
+	{0x14e4, 0x1647, 0x14e4, 0x800a, 0, 0, BCM5703 },
+	{0x14e4, 0x1647, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
+	{0x14e4, 0x16a7, 0x14e4, 0x0009, 0, 0, BCM5703 },
+	{0x14e4, 0x16a7, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
+	{0x14e4, 0x16a7, 0x14e4, 0x000b, 0, 0, BCM5703 },
+	{0x14e4, 0x16a7, 0x14e4, 0x800a, 0, 0, BCM5703 },
+	{0x14e4, 0x16a7, 0x0e11, 0xca, 0, 0, NC7771 },
+	{0x14e4, 0x16a7, 0x0e11, 0xcb, 0, 0, NC7781 },
+	{0x14e4, 0x16a7, 0x1014, 0x0281, 0, 0, BCM5703ARBUCKLE },
+	{0x14e4, 0x16a7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
+	{0x14e4, 0x16c7, 0x14e4, 0x000a, 0, 0, BCM5703A31 },
+	{0x14e4, 0x16c7, 0x0e11, 0xca, 0, 0, NC7771 },
+	{0x14e4, 0x16c7, 0x0e11, 0xcb, 0, 0, NC7781 },
+	{0x14e4, 0x16c7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5703 },
+	{0x14e4, 0x1648, 0x0e11, 0xcf, 0, 0, NC7772 },
+	{0x14e4, 0x1648, 0x0e11, 0xd0, 0, 0, NC7782 },
+	{0x14e4, 0x1648, 0x0e11, 0xd1, 0, 0, NC7783 },
+	{0x14e4, 0x1648, 0x10b7, 0x2000, 0, 0, TC998T },
+	{0x14e4, 0x1648, 0x10b7, 0x3000, 0, 0, TC999T },
+	{0x14e4, 0x1648, 0x1166, 0x1648, 0, 0, BCM5704CIOBE },
+	{0x14e4, 0x1648, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704 },
+	{0x14e4, 0x1649, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704S },
+	{0x14e4, 0x16a8, 0x14e4, 0x16a8, 0, 0, BCM5704S },
+	{0x14e4, 0x16a8, 0x10b7, 0x2001, 0, 0, TC998SX },
+	{0x14e4, 0x16a8, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5704S },
+	{0x14e4, 0x1653, 0x0e11, 0x00e3, 0, 0, NC7761 },
+	{0x14e4, 0x1653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705 },
+	{0x14e4, 0x1654, 0x0e11, 0x00e3, 0, 0, NC7761 },
+	{0x14e4, 0x1654, 0x103c, 0x3100, 0, 0, NC1020 },
+	{0x14e4, 0x1654, 0x103c, 0x3226, 0, 0, NC150T },
+	{0x14e4, 0x1654, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705 },
+	{0x14e4, 0x165d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705M },
+	{0x14e4, 0x165e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705M },
+	{0x14e4, 0x166e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5705F },
+	{0x14e4, 0x1696, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5782 },
+	{0x14e4, 0x169c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5788 },
+	{0x14e4, 0x169d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5789 },
+	{0x14e4, 0x170d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5901 },
+	{0x14e4, 0x170e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5901 },
+	{0x14e4, 0x1676, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5750 },
+	{0x14e4, 0x167c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5750M },
+	{0x14e4, 0x1677, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751 },
+	{0x14e4, 0x167d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751M },
+	{0x14e4, 0x167e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5751F },
+	{0x14e4, 0x1658, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5720 },
+	{0x14e4, 0x1659, 0x103c, 0x7031, 0, 0, NC320T },
+	{0x14e4, 0x1659, 0x103c, 0x7032, 0, 0, NC320T },
+	{0x14e4, 0x166a, 0x103c, 0x7035, 0, 0, NC325I },
+	{0x14e4, 0x166b, 0x103c, 0x7036, 0, 0, NC325I },
+	{0x14e4, 0x1668, 0x103c, 0x7039, 0, 0, NC324I },
+	{0x14e4, 0x1669, 0x103c, 0x703a, 0, 0, NC324I },
+	{0x14e4, 0x1678, 0x103c, 0x703e, 0, 0, NC326I },
+	{0x14e4, 0x1679, 0x103c, 0x703c, 0, 0, NC326I },
+	{0x14e4, 0x1659, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5721 },
+	{0x14e4, 0x16f7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753 },
+	{0x14e4, 0x16fd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753M },
+	{0x14e4, 0x16fe, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5753F },
+	{0x14e4, 0x16dd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5781 },
+	{0x14e4, 0x1600, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5752 },
+	{0x14e4, 0x1601, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5752M },
+	{0x14e4, 0x1668, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5714 },
+	{0x14e4, 0x166a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5780 },
+	{0x14e4, 0x166b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5780S },
+	{0x14e4, 0x1678, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5715 },
+	{0x14e4, 0x471f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM4785 },
+	{0x14e4, 0x16ff, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5903M },
+	{0x173b, 0x03ed, PCI_ANY_ID, PCI_ANY_ID, 0, 0, UNK5788 },
+	{0,}
+	};
+
+MODULE_DEVICE_TABLE(pci, bcm5700_pci_tbl);
+
+#if (LINUX_VERSION_CODE >= 0x2060a)
+	static struct pci_device_id pci_AMD762id[]={
+		{ PCI_DEVICE(PCI_VENDOR_ID_AMD,
+			PCI_DEVICE_ID_AMD_FE_GATE_700C) },
+		{ }
+	};
+#endif
+
+static int sbgige = -1;
+
+/*******************************************************************************
+ *******************************************************************************
+*/
+
+int get_csum_flag(LM_UINT32 ChipRevId)
+{
+        return NETIF_F_IP_CSUM;
+}
+
+/*******************************************************************************
+ *******************************************************************************
+
+   This function returns true if the device passed to it is attached to an
+   ICH-ICH4. If the chip is not attached to an ICH, or is attached to an ICH5
+   or newer, it returns false.
+
+   This function determines which bridge it is attached to by scaning the pci
+   bus looking for bridge chips (hdr_type=1). When a bridge chip is detected,
+   the bridge's subordinate's secondary bus number is compared with this
+   devices bus number. If they match, then the device is attached to this
+   bridge. The bridge's device id is compared to a list of known device ids for
+   ICH-ICH4. Since many older ICH's (ICH2-ICH7) share the same device id, the
+   chip revision must also be checked to determine if the chip is older than an
+   ICH5.
+
+   To scan the bus, one of two functions is used depending on the kernel
+   version. For 2.4 kernels, the pci_find_device function is used. This
+   function has been depricated in the 2.6 kernel and replaced with the
+   fucntion pci_get_device. The macro walk_pci_bus determines which function to
+   use when the driver is built.
+*/
+
+#if (LINUX_VERSION_CODE >= 0x2060a)
+#define walk_pci_bus(d)		while ((d = pci_get_device( \
+					PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
+
+#define unwalk_pci_bus(d)	pci_dev_put(d)
+
+#else
+#define walk_pci_bus(d)		while ((d = pci_find_device( \
+					PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
+#define unwalk_pci_bus(d)
+
+#endif
+
+#define ICH5_CHIP_VERSION	0xc0
+
+static struct pci_device_id pci_ICHtable[] = {
+	{0x8086, 0x2418}, /* PCI_DEVICE_ID_INTEL_82801AA_8  */
+	{0x8086, 0x2428}, /* PCI_DEVICE_ID_INTEL_82801AB_8  */
+	{0x8086, 0x244e}, /* PCI_DEVICE_ID_INTEL_82801BA_6  */
+	{0x8086, 0x2448}, /* PCI_DEVICE_ID_INTEL_82801BA_11 */
+	{0, 0}
+};
+
+int attached_to_ICH4_or_older( struct pci_dev *pdev)
+{
+	struct pci_dev *tmp_pdev = NULL;
+	struct pci_device_id *ich_table;
+	u8 chip_rev;
+
+	walk_pci_bus (tmp_pdev) {
+		if ((tmp_pdev->hdr_type == 1) &&
+		   (tmp_pdev->subordinate != NULL) &&
+		   (tmp_pdev->subordinate->secondary == pdev->bus->number)) {
+
+			ich_table = pci_ICHtable;
+
+			while (ich_table->vendor) {
+				if ((ich_table->vendor == tmp_pdev->vendor) &&
+				    (ich_table->device == tmp_pdev->device)) {
+
+					pci_read_config_byte( tmp_pdev,
+						PCI_REVISION_ID, &chip_rev);
+
+					if (chip_rev < ICH5_CHIP_VERSION) {
+						unwalk_pci_bus( tmp_pdev);
+						return 1;
+					}
+				}
+				ich_table++;
+			}
+		}
+	}
+	return 0;
+}
+
+static void robo_set_power_mode(void *h)
+{
+	//int status = 0;
+	int i;
+	//uint8 mode8;
+	//uint16 mode16;
+	uint32 flags = 0, temp32 = 0,val32 = 0, savephyaddr = 0;
+	PUM_DEVICE_BLOCK pudev = (PUM_DEVICE_BLOCK)h;
+	PLM_DEVICE_BLOCK pdev = &pudev->lm_dev;
+
+	/*Brcm,Alex,2006.7.20. Adding Phy power mode setting*/
+	BCM5700_PHY_LOCK(pudev, flags);
+	savephyaddr = pdev->PhyAddr;
+
+	for(i = 0; i < 8; i++)
+	{
+		pdev->PhyAddr = i;
+		temp32 = 0x2007;
+		LM_WritePhy(pdev, 0x18, temp32);
+		LM_ReadPhy(pdev, 0x18, &val32);
+//		printk(KERN_DEBUG "Alex: port = %x, read value =%x\n",i, val32);
+		temp32 = 0xc042;
+		LM_WritePhy(pdev, 0x18, temp32);
+		/*Read back*/
+		temp32 = 0x2007;
+		val32 = 0;
+		LM_WritePhy(pdev, 0x18, temp32);
+		LM_ReadPhy(pdev, 0x18, &val32);
+//		printk(KERN_ERR "Alex: read back value =%x\n",val32);
+	}
+
+	pdev->PhyAddr = savephyaddr;
+	BCM5700_PHY_UNLOCK(pudev, flags);
+
+	/*end of Brcm,Alex,2006.7.20. Adding Phy power mode setting*/
+
+}
+
+static int
+__devinit bcm5700_init_board(struct pci_dev *pdev, struct net_device **dev_out, int board_idx)
+{
+	struct net_device *dev;
+	PUM_DEVICE_BLOCK pUmDevice;
+	PLM_DEVICE_BLOCK pDevice;
+	bool rgmii = FALSE;
+	sb_t *sbh = NULL;
+	int rc;
+
+	*dev_out = NULL;
+
+	/* dev zeroed in init_etherdev */
+#if (LINUX_VERSION_CODE >= 0x20600)
+	dev = alloc_etherdev(sizeof(*pUmDevice));
+#else
+	dev = init_etherdev(NULL, sizeof(*pUmDevice));
+#endif
+	if (dev == NULL) {
+		printk(KERN_ERR "%s: unable to alloc new ethernet\n", bcm5700_driver);
+		return -ENOMEM;
+	}
+	SET_MODULE_OWNER(dev);
+#if (LINUX_VERSION_CODE >= 0x20600)
+	SET_NETDEV_DEV(dev, &pdev->dev);
+#endif
+	pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
+
+	/* enable device (incl. PCI PM wakeup), and bus-mastering */
+	rc = pci_enable_device(pdev);
+	if (rc)
+		goto err_out;
+
+	/* init core specific stuff */
+	if (pdev->device == T3_PCI_DEVICE_ID(T3_PCI_ID_BCM471F)) {
+		sbh = sb_kattach(SB_OSH);
+		sb_gige_init(sbh, ++sbgige, &rgmii);
+	}
+
+	rc = pci_request_regions(pdev, bcm5700_driver);
+	if (rc) {
+		if (!sbh)
+			goto err_out;
+		printk(KERN_INFO "bcm5700_init_board: pci_request_regions returned error %d\n"
+				 "This may be because the region is already requested by"
+				 " the SMBus driver. Ignore the PCI error messages.\n", rc);
+	}
+
+	pci_set_master(pdev);
+
+	if (pci_set_dma_mask(pdev, BCM_64BIT_DMA_MASK) == 0) {
+		pUmDevice->using_dac = 1;
+		if (pci_set_consistent_dma_mask(pdev, BCM_64BIT_DMA_MASK) != 0) {
+			printk(KERN_ERR "pci_set_consistent_dma_mask failed\n");
+			pci_release_regions(pdev);
+			goto err_out;
+		}
+	} else if (pci_set_dma_mask(pdev, BCM_32BIT_DMA_MASK) == 0) {
+		pUmDevice->using_dac = 0;
+	} else {
+		printk(KERN_ERR "System does not support DMA\n");
+		pci_release_regions(pdev);
+		goto err_out;
+	}
+
+	pUmDevice->dev = dev;
+	pUmDevice->pdev = pdev;
+	pUmDevice->mem_list_num = 0;
+	pUmDevice->next_module = root_tigon3_dev;
+	pUmDevice->index = board_idx;
+	pUmDevice->sbh = (void *)sbh;
+	root_tigon3_dev = dev;
+
+	spin_lock_init(&pUmDevice->global_lock);
+
+	spin_lock_init(&pUmDevice->undi_lock);
+
+	spin_lock_init(&pUmDevice->phy_lock);
+
+	pDevice = &pUmDevice->lm_dev;
+	pDevice->Flags = 0;
+	pDevice->FunctNum = PCI_FUNC(pUmDevice->pdev->devfn);
+	pUmDevice->boardflags = getintvar(NULL, "boardflags");
+	if (sbh) {
+		if (pUmDevice->boardflags & BFL_ENETROBO)
+			pDevice->Flags |= ROBO_SWITCH_FLAG;
+		pDevice->Flags |= rgmii ? RGMII_MODE_FLAG : 0;
+		if (sb_chip(sbh) == BCM4785_CHIP_ID && sb_chiprev(sbh) < 2)
+			pDevice->Flags |= ONE_DMA_AT_ONCE_FLAG;
+		pDevice->Flags |= SB_CORE_FLAG;
+		if (sb_chip(sbh) == BCM4785_CHIP_ID)
+			pDevice->Flags |= FLUSH_POSTED_WRITE_FLAG;
+	}
+
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+	if (board_idx < MAX_UNITS) {
+		bcm5700_validate_param_range(pUmDevice, &mtu[board_idx], "mtu", 1500, 9000, 1500);
+		dev->mtu = mtu[board_idx];
+	}
+#endif
+
+	if (attached_to_ICH4_or_older(pdev)) {
+		pDevice->Flags |= UNDI_FIX_FLAG;
+	}
+
+#if (LINUX_VERSION_CODE >= 0x2060a)
+	if (pci_dev_present(pci_AMD762id)) {
+		pDevice->Flags |= FLUSH_POSTED_WRITE_FLAG;
+		pDevice->Flags &= ~NIC_SEND_BD_FLAG;
+	}
+#else
+	if (pci_find_device(0x1022, 0x700c, NULL)) {
+		/* AMD762 writes I/O out of order */
+		/* Setting bit 1 in 762's register 0x4C still doesn't work */
+		/* in all cases */
+		pDevice->Flags |= FLUSH_POSTED_WRITE_FLAG;
+		pDevice->Flags &= ~NIC_SEND_BD_FLAG;
+	}
+#endif
+	if (LM_GetAdapterInfo(pDevice) != LM_STATUS_SUCCESS) {
+		rc = -ENODEV;
+		goto err_out_unmap;
+	}
+
+	if (pDevice->Flags & ROBO_SWITCH_FLAG) {
+		robo_info_t	*robo;
+
+		if ((robo = bcm_robo_attach(sbh, pDevice, dev->name, NULL,
+		                            robo_miird, robo_miiwr)) == NULL) {
+			B57_ERR(("robo_setup: failed to attach robo switch \n"));
+			goto robo_fail;
+		}
+
+		if (bcm_robo_enable_device(robo)) {
+			B57_ERR(("robo_setup: failed to enable robo switch \n"));
+robo_fail:
+			bcm_robo_detach(robo);
+			rc = -ENODEV;
+			goto err_out_unmap;
+		}
+
+		/* 5397 power mode setting */
+		robo_set_power_mode(robo->h);
+
+		pUmDevice->robo = (void *)robo;
+	}
+
+	if ((pDevice->Flags & JUMBO_CAPABLE_FLAG) == 0) {
+		if (dev->mtu > 1500) {
+			dev->mtu = 1500;
+			printk(KERN_WARNING
+			       "%s-%d: Jumbo mtu sizes not supported, using mtu=1500\n",
+			       bcm5700_driver, pUmDevice->index);
+		}
+	}
+
+	pUmDevice->do_global_lock = 0;
+	if (T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5700) {
+		/* The 5700 chip works best without interleaved register */
+		/* accesses on certain machines. */
+		pUmDevice->do_global_lock = 1;
+	}
+
+	if ((T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5701) &&
+		((pDevice->PciState & T3_PCI_STATE_NOT_PCI_X_BUS) == 0)) {
+
+		pUmDevice->rx_buf_align = 0;
+	} else {
+		pUmDevice->rx_buf_align = 2;
+	}
+	dev->mem_start = pci_resource_start(pdev, 0);
+	dev->mem_end = dev->mem_start + sizeof(T3_STD_MEM_MAP);
+	dev->irq = pdev->irq;
+
+	*dev_out = dev;
+	return 0;
+
+err_out_unmap:
+	pci_release_regions(pdev);
+	bcm5700_freemem(dev);
+
+err_out:
+#if (LINUX_VERSION_CODE < 0x020600)
+	unregister_netdev(dev);
+	kfree(dev);
+#else
+	free_netdev(dev);
+#endif
+	return rc;
+}
+
+static int __devinit
+bcm5700_print_ver(void)
+{
+	printk(KERN_INFO "Broadcom Gigabit Ethernet Driver %s ",
+		bcm5700_driver);
+	printk("ver. %s %s\n", bcm5700_version, bcm5700_date);
+	return 0;
+}
+
+static int __devinit
+bcm5700_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+	struct net_device *dev = NULL;
+	PUM_DEVICE_BLOCK pUmDevice;
+	PLM_DEVICE_BLOCK pDevice;
+	int i;
+	static int board_idx = -1;
+	static int printed_version = 0;
+	struct pci_dev *pci_dev;
+
+	board_idx++;
+
+	if (!printed_version) {
+		bcm5700_print_ver();
+		printed_version = 1;
+	}
+
+	i = bcm5700_init_board(pdev, &dev, board_idx);
+	if (i < 0) {
+		return i;
+	}
+
+	if (dev == NULL)
+		return -ENOMEM;
+
+#ifdef BCM_IOCTL32
+	if (atomic_read(&bcm5700_load_count) == 0) {
+		register_ioctl32_conversion(SIOCNICE, bcm5700_ioctl32);
+	}
+	atomic_inc(&bcm5700_load_count);
+#endif
+	dev->open = bcm5700_open;
+	dev->hard_start_xmit = bcm5700_start_xmit;
+	dev->stop = bcm5700_close;
+	dev->get_stats = bcm5700_get_stats;
+	dev->set_multicast_list = bcm5700_set_rx_mode;
+	dev->do_ioctl = bcm5700_ioctl;
+	dev->set_mac_address = &bcm5700_set_mac_addr;
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+	dev->change_mtu = &bcm5700_change_mtu;
+#endif
+#if (LINUX_VERSION_CODE >= 0x20400)
+	dev->tx_timeout = bcm5700_reset;
+	dev->watchdog_timeo = TX_TIMEOUT;
+#endif
+#ifdef BCM_VLAN
+	dev->vlan_rx_register = &bcm5700_vlan_rx_register;
+	dev->vlan_rx_kill_vid = &bcm5700_vlan_rx_kill_vid;
+#endif
+#ifdef BCM_NAPI_RXPOLL
+	dev->poll = bcm5700_poll;
+	dev->weight = 64;
+#endif
+
+	pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
+	pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+
+	dev->base_addr = pci_resource_start(pdev, 0);
+	dev->irq = pdev->irq;
+#if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
+	dev->poll_controller = poll_bcm5700;
+#endif
+
+#if (LINUX_VERSION_CODE >= 0x20600)
+	if ((i = register_netdev(dev))) {
+		printk(KERN_ERR "%s: Cannot register net device\n",
+			bcm5700_driver);
+		if (pUmDevice->lm_dev.pMappedMemBase)
+			iounmap(pUmDevice->lm_dev.pMappedMemBase);
+		pci_release_regions(pdev);
+		bcm5700_freemem(dev);
+		free_netdev(dev);
+		return i;
+	}
+#endif
+
+
+	pci_set_drvdata(pdev, dev);
+
+	memcpy(dev->dev_addr, pDevice->NodeAddress, 6);
+	pUmDevice->name = board_info[ent->driver_data].name,
+	printk(KERN_INFO "%s: %s found at mem %lx, IRQ %d, ",
+		dev->name, pUmDevice->name, dev->base_addr,
+		dev->irq);
+	printk("node addr ");
+	for (i = 0; i < 6; i++) {
+		printk("%2.2x", dev->dev_addr[i]);
+	}
+	printk("\n");
+
+	printk(KERN_INFO "%s: ", dev->name);
+	if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5400_PHY_ID)
+		printk("Broadcom BCM5400 Copper ");
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5401_PHY_ID)
+		printk("Broadcom BCM5401 Copper ");
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5411_PHY_ID)
+		printk("Broadcom BCM5411 Copper ");
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5461_PHY_ID)
+		printk("Broadcom BCM5461 Copper ");
+	else if (((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5701_PHY_ID) &&
+		!(pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
+		printk("Broadcom BCM5701 Integrated Copper ");
+	}
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5703_PHY_ID) {
+		printk("Broadcom BCM5703 Integrated ");
+		if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
+			printk("SerDes ");
+		else
+			printk("Copper ");
+	}
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5704_PHY_ID) {
+		printk("Broadcom BCM5704 Integrated ");
+		if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
+			printk("SerDes ");
+		else
+			printk("Copper ");
+	}
+        else if (pDevice->PhyFlags & PHY_IS_FIBER){
+            if(( pDevice->PhyId & PHY_ID_MASK ) == PHY_BCM5780_PHY_ID)
+                printk("Broadcom BCM5780S Integrated Serdes ");
+
+        }        
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5705_PHY_ID)
+		printk("Broadcom BCM5705 Integrated Copper ");
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5750_PHY_ID)
+		printk("Broadcom BCM5750 Integrated Copper ");
+
+        else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5714_PHY_ID)
+                printk("Broadcom BCM5714 Integrated Copper ");
+        else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5780_PHY_ID)
+                printk("Broadcom BCM5780 Integrated Copper ");
+
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM5752_PHY_ID)
+		printk("Broadcom BCM5752 Integrated Copper ");
+	else if ((pDevice->PhyId & PHY_ID_MASK) == PHY_BCM8002_PHY_ID)
+		printk("Broadcom BCM8002 SerDes ");
+	else if (pDevice->TbiFlags & ENABLE_TBI_FLAG) {
+		if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) {
+			printk("Broadcom BCM5703 Integrated SerDes ");
+		}
+		else if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
+			printk("Broadcom BCM5704 Integrated SerDes ");
+		}
+		else {
+			printk("Agilent HDMP-1636 SerDes ");
+		}
+	}
+	else {
+		printk("Unknown ");
+	}
+	printk("transceiver found\n");
+
+#if (LINUX_VERSION_CODE >= 0x20400)
+	if (scatter_gather[board_idx]) {
+		dev->features |= NETIF_F_SG;
+		if (pUmDevice->using_dac && !(pDevice->Flags & BCM5788_FLAG))
+			dev->features |= NETIF_F_HIGHDMA;
+	}
+	if ((pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TX_TCP_CHECKSUM) &&
+		tx_checksum[board_idx]) {
+
+		dev->features |= get_csum_flag( pDevice->ChipRevId);
+	}
+#ifdef BCM_VLAN
+	dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
+#endif
+#ifdef BCM_TSO
+	/* On 5714/15/80 chips, Jumbo Frames and TSO cannot both be enabled at
+	   the same time. Since only one of these features can be enable at a
+           time, we'll enable only Jumbo Frames and disable TSO when the user
+	   tries to enable both.
+	*/
+	dev->features &= ~NETIF_F_TSO;
+
+	if ((pDevice->TaskToOffload & LM_TASK_OFFLOAD_TCP_SEGMENTATION) &&
+	    (enable_tso[board_idx])) {
+		if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
+		   (dev->mtu > 1500)) {
+			printk(KERN_ALERT "%s: Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
+		} else {
+			dev->features |= NETIF_F_TSO;
+		}
+	}
+#endif
+	printk(KERN_INFO "%s: Scatter-gather %s, 64-bit DMA %s, Tx Checksum %s, ",
+			dev->name,
+			(char *) ((dev->features & NETIF_F_SG) ? "ON" : "OFF"),
+			(char *) ((dev->features & NETIF_F_HIGHDMA) ? "ON" : "OFF"),
+			(char *) ((dev->features & get_csum_flag( pDevice->ChipRevId)) ? "ON" : "OFF"));
+#endif
+	if ((pDevice->ChipRevId != T3_CHIP_ID_5700_B0) &&
+		rx_checksum[board_idx])
+		printk("Rx Checksum ON");
+	else
+		printk("Rx Checksum OFF");
+#ifdef BCM_VLAN
+	printk(", 802.1Q VLAN ON");
+#endif
+#ifdef BCM_TSO
+	if (dev->features & NETIF_F_TSO) {
+		printk(", TSO ON");
+	}
+	else
+#endif
+#ifdef BCM_NAPI_RXPOLL
+	printk(", NAPI ON");
+#endif
+	printk("\n");
+
+	register_reboot_notifier(&bcm5700_reboot_notifier);
+#ifdef BCM_TASKLET
+	tasklet_init(&pUmDevice->tasklet, bcm5700_tasklet,
+		(unsigned long) pUmDevice);
+#endif
+	if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
+		if ((REG_RD(pDevice, PciCfg.DualMacCtrl) &
+			T3_DUAL_MAC_CH_CTRL_MASK) == 3) {
+
+printk(KERN_WARNING "%s: Device is configured for Hardware Based Teaming which is not supported with this operating system. Please consult the user diagnostic guide to disable Turbo Teaming.\n", dev->name);
+		}
+	}
+
+#if (LINUX_VERSION_CODE > 0x20605)
+
+	if ((pci_dev = pci_get_device(0x1022, 0x700c, NULL)))
+#else
+	if ((pci_dev = pci_find_device(0x1022, 0x700c, NULL)))
+#endif
+	{
+		u32 val;
+
+		/* Found AMD 762 North bridge */
+		pci_read_config_dword(pci_dev, 0x4c, &val);
+		if ((val & 0x02) == 0) {
+			pci_write_config_dword(pci_dev, 0x4c, val | 0x02);
+			printk(KERN_INFO "%s: Setting AMD762 Northbridge to enable PCI ordering compliance\n", bcm5700_driver);
+		}
+	}
+
+#if (LINUX_VERSION_CODE > 0x20605)
+
+	pci_dev_put(pci_dev);
+
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+
+	if ((pci_dev = pci_get_device(0x1066, 0x0017, NULL))) {
+		bcm_msi_chipset_bug = 1;
+	}
+	pci_dev_put(pci_dev);
+#endif
+#endif
+
+	return 0;
+}
+
+
+static void __devexit
+bcm5700_remove_one (struct pci_dev *pdev)
+{
+	struct net_device *dev = pci_get_drvdata (pdev);
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+
+#ifdef BCM_IOCTL32
+	atomic_dec(&bcm5700_load_count);
+	if (atomic_read(&bcm5700_load_count) == 0)
+		unregister_ioctl32_conversion(SIOCNICE);
+#endif
+	unregister_netdev(dev);
+
+	if (pUmDevice->lm_dev.pMappedMemBase)
+		iounmap(pUmDevice->lm_dev.pMappedMemBase);
+
+	pci_release_regions(pdev);
+
+#if (LINUX_VERSION_CODE < 0x020600)
+	kfree(dev);
+#else
+	free_netdev(dev);
+#endif
+
+	pci_set_drvdata(pdev, NULL);
+
+}
+
+int b57_test_intr(UM_DEVICE_BLOCK *pUmDevice);
+ 
+#ifdef BCM_WL_EMULATOR
+/* new transmit callback  */ 
+static int bcm5700emu_start_xmit(struct sk_buff *skb, struct net_device *dev);
+/* keep track of the 2 gige devices */ 
+static PLM_DEVICE_BLOCK pDev1;
+static PLM_DEVICE_BLOCK pDev2;
+
+static void 
+bcm5700emu_open(struct net_device *dev)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;       
+	static int instance = 0;
+	static char *wlemu_if = NULL;
+	char *wlemu_mode = NULL;
+	//int wlemu_idx = 0;
+	static int rx_enable = 0;
+	static int tx_enable = 0;
+	
+	/* which interface is the emulator ? */
+	if(instance == 0) {
+		wlemu_if = nvram_get("wlemu_if");
+		/* do we emulate rx, tx or both  */
+		wlemu_mode = nvram_get("wlemu_mode");
+		if(wlemu_mode) {
+			if (!strcmp(wlemu_mode,"rx"))
+			{
+				rx_enable = 1;
+			} 
+			else if (!strcmp(wlemu_mode,"tx"))
+			{
+				
+				tx_enable = 1;
+				
+			}
+			else if (!strcmp(wlemu_mode,"rx_tx"))
+			{
+				
+				rx_enable = 1;
+				tx_enable = 1;
+			}
+		}
+	}
+	
+	instance++;
+
+	/* The context is used for accessing the OSL for emulating devices */
+	pDevice->wlc = NULL;
+	
+	/* determines if this device is an emulator */
+	pDevice->wl_emulate_rx = 0;
+	pDevice->wl_emulate_tx = 0;
+
+	if(wlemu_if && !strcmp(dev->name,wlemu_if))
+	{
+		/* create an emulator context. */
+		pDevice->wlc = (void *)wlcemu_wlccreate((void *)dev);
+		B57_INFO(("Using %s for wl emulation \n", dev->name));
+		if(rx_enable)
+		{
+			B57_INFO(("Enabling wl RX emulation \n"));
+			pDevice->wl_emulate_rx = 1;
+		}
+		/* re-direct transmit callback to emulator */
+		if(tx_enable)
+		{
+			pDevice->wl_emulate_tx = 1;
+			dev->hard_start_xmit = bcm5700emu_start_xmit;
+			B57_INFO(("Enabling wl TX emulation \n"));
+		}  
+	}
+	/* for debug access to configured devices only */
+	if(instance == 1)
+		pDev1 = pDevice;
+	else if (instance == 2)
+		pDev2 = pDevice;	
+}	
+
+/* Public API to get current emulation info */
+int bcm5700emu_get_info(char *buf)
+{
+	int len = 0;
+	PLM_DEVICE_BLOCK p;
+	
+	/* look for an emulating device */
+	if(pDev1->wlc) {
+		p = pDev1;
+		len += sprintf(buf+len,"emulation device : eth0\n");
+	}
+	else if (pDev2->wlc) {
+		p = pDev2;
+		len += sprintf(buf+len,"emulation device : eth1\n");
+	}
+	else {
+		len += sprintf(buf+len,"emulation not activated\n");
+		return len;
+	}
+	if(p->wl_emulate_rx)
+		len += sprintf(buf+len,"RX emulation enabled\n");
+	else 
+		len += sprintf(buf+len,"RX emulation disabled\n");
+	if(p->wl_emulate_tx)
+		len += sprintf(buf+len,"TX emulation enabled\n");
+	else 
+		len += sprintf(buf+len,"TX emulation disabled\n");
+	return len;
+	
+} 
+
+
+/* Public API to access the bcm5700_start_xmit callback */
+
+int 
+bcm5700emu_forward_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+  return bcm5700_start_xmit(skb, dev);
+}
+
+
+/* hook to kernel txmit callback */
+STATIC int
+bcm5700emu_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+
+  PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+  PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+  return wlcemu_start_xmit(skb,pDevice->wlc);
+}	
+	 
+#endif /* BCM_WL_EMULATOR */
+ 
+int
+bcm5700_open(struct net_device *dev)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	int rc;
+
+	if (pUmDevice->suspended){
+            return -EAGAIN;
+        }
+
+#ifdef BCM_WL_EMULATOR
+	bcm5700emu_open(dev);
+#endif
+
+	/* delay for 6 seconds */
+	pUmDevice->delayed_link_ind = (6 * HZ) / pUmDevice->timer_interval;
+
+#ifdef BCM_INT_COAL
+#ifndef BCM_NAPI_RXPOLL
+	pUmDevice->adaptive_expiry = HZ / pUmDevice->timer_interval;
+#endif
+#endif
+
+#ifdef INCLUDE_TBI_SUPPORT
+	if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
+		(pDevice->TbiFlags & TBI_POLLING_FLAGS)) {
+		pUmDevice->poll_tbi_interval = HZ / pUmDevice->timer_interval;
+		if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) {
+			pUmDevice->poll_tbi_interval /= 4;
+		}
+		pUmDevice->poll_tbi_expiry = pUmDevice->poll_tbi_interval;
+	}
+#endif
+	/* set this timer for 2 seconds */
+	pUmDevice->asf_heartbeat = (2 * HZ) / pUmDevice->timer_interval;
+
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+
+
+	if ( (  (T3_ASIC_IS_575X_PLUS(pDevice->ChipRevId) ) &&
+		(T3_ASIC_REV(pDevice->ChipRevId) != T3_ASIC_REV_5714_A0 ) &&
+		(T3_CHIP_REV(pDevice->ChipRevId) != T3_CHIP_REV_5750_AX ) &&
+		(T3_CHIP_REV(pDevice->ChipRevId) != T3_CHIP_REV_5750_BX ) ) &&
+		!bcm_msi_chipset_bug	){
+
+		if (disable_msi[pUmDevice->index]==1){
+			/* do nothing-it's not turned on */
+		}else{
+			pDevice->Flags |= USING_MSI_FLAG;
+
+                        REG_WR(pDevice, Msi.Mode,  2 );
+
+			rc = pci_enable_msi(pUmDevice->pdev);
+
+			if(rc!=0){
+				pDevice->Flags &= ~ USING_MSI_FLAG;
+                        	REG_WR(pDevice, Msi.Mode,  1 );
+			}
+		}
+	}
+
+
+#endif
+
+	if ((rc= request_irq(pUmDevice->pdev->irq, &bcm5700_interrupt, SA_SHIRQ, dev->name, dev)))
+	{
+
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+
+		if(pDevice->Flags & USING_MSI_FLAG)  {
+
+			pci_disable_msi(pUmDevice->pdev);
+			pDevice->Flags &= ~USING_MSI_FLAG;
+                       	REG_WR(pDevice, Msi.Mode,  1 );
+
+		}
+#endif
+		return rc;
+	}
+
+	pUmDevice->opened = 1;
+	if (LM_InitializeAdapter(pDevice) != LM_STATUS_SUCCESS) {
+		pUmDevice->opened = 0;
+		free_irq(dev->irq, dev);
+		bcm5700_freemem(dev);
+		return -EAGAIN;
+	}
+
+	bcm5700_set_vlan_mode(pUmDevice);
+	bcm5700_init_counters(pUmDevice);
+
+	if (pDevice->Flags & UNDI_FIX_FLAG) {
+		printk(KERN_INFO "%s: Using indirect register access\n", dev->name);
+	}
+
+	if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6))
+	{
+		/* Do not use invalid eth addrs: any multicast & all zeros */
+		if( is_valid_ether_addr(dev->dev_addr) ){
+			LM_SetMacAddress(pDevice, dev->dev_addr);
+		}
+		else
+		{
+			printk(KERN_INFO "%s: Invalid administered node address\n",dev->name);
+			memcpy(dev->dev_addr, pDevice->NodeAddress, 6);
+		}
+	}
+
+	if (tigon3_debug > 1)
+		printk(KERN_DEBUG "%s: tigon3_open() irq %d.\n", dev->name, dev->irq);
+
+	QQ_InitQueue(&pUmDevice->rx_out_of_buf_q.Container,
+        MAX_RX_PACKET_DESC_COUNT);
+
+
+#if (LINUX_VERSION_CODE < 0x020300)
+	MOD_INC_USE_COUNT;
+#endif
+
+	atomic_set(&pUmDevice->intr_sem, 0);
+
+	LM_EnableInterrupt(pDevice);
+
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+
+	if (pDevice->Flags & USING_MSI_FLAG){
+
+		/* int test to check support on older machines */
+		if (b57_test_intr(pUmDevice) != 1) {
+
+			LM_DisableInterrupt(pDevice);
+			free_irq(pUmDevice->pdev->irq, dev);
+			pci_disable_msi(pUmDevice->pdev);
+                        REG_WR(pDevice, Msi.Mode,  1 );
+			pDevice->Flags &= ~USING_MSI_FLAG;
+
+			rc = LM_ResetAdapter(pDevice);
+printk(KERN_ALERT " The MSI support in this system is not functional.\n");
+
+			if (rc == LM_STATUS_SUCCESS)
+				rc = 0;
+			else
+				rc = -ENODEV;
+
+			if(rc == 0){
+				rc = request_irq(pUmDevice->pdev->irq, &bcm5700_interrupt,
+					    SA_SHIRQ, dev->name, dev);
+			}
+
+			if(rc){
+				LM_Halt(pDevice);
+				bcm5700_freemem(dev);
+				pUmDevice->opened = 0;
+				return rc;
+			}
+
+
+			pDevice->InitDone = TRUE;
+			atomic_set(&pUmDevice->intr_sem, 0);
+			LM_EnableInterrupt(pDevice);
+		}
+	}
+#endif
+
+	init_timer(&pUmDevice->timer);
+	pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
+	pUmDevice->timer.data = (unsigned long)dev;
+	pUmDevice->timer.function = &bcm5700_timer;
+	add_timer(&pUmDevice->timer);
+
+	if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
+		init_timer(&pUmDevice->statstimer);
+		pUmDevice->statstimer.expires = RUN_AT(pUmDevice->statstimer_interval);
+		pUmDevice->statstimer.data = (unsigned long)dev;
+		pUmDevice->statstimer.function = &bcm5700_stats_timer;
+		add_timer(&pUmDevice->statstimer);
+	}
+
+	if(pDevice->Flags & USING_MSI_FLAG)
+		printk(KERN_INFO "%s: Using Message Signaled Interrupt (MSI)  \n", dev->name);
+	else
+		printk(KERN_INFO "%s: Using PCI INTX interrupt \n", dev->name);
+
+	netif_start_queue(dev);
+
+	return 0;
+}
+
+
+STATIC void
+bcm5700_stats_timer(unsigned long data)
+{
+	struct net_device *dev = (struct net_device *)data;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	unsigned long flags = 0;
+
+	if (!pUmDevice->opened)
+		return;
+
+	if (!atomic_read(&pUmDevice->intr_sem) &&
+	    !pUmDevice->suspended              &&
+	   (pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE)) {
+		BCM5700_LOCK(pUmDevice, flags);
+		LM_GetStats(pDevice);
+		BCM5700_UNLOCK(pUmDevice, flags);
+	}
+
+	pUmDevice->statstimer.expires = RUN_AT(pUmDevice->statstimer_interval);
+
+	add_timer(&pUmDevice->statstimer);
+}
+
+
+STATIC void
+bcm5700_timer(unsigned long data)
+{
+	struct net_device *dev = (struct net_device *)data;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	unsigned long flags = 0;
+	LM_UINT32 value32;
+
+	if (!pUmDevice->opened)
+		return;
+
+	/* BCM4785: Flush posted writes from GbE to host memory. */
+	if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
+		REG_RD(pDevice, HostCoalesce.Mode);
+
+	if (atomic_read(&pUmDevice->intr_sem) || pUmDevice->suspended) {
+		pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
+		add_timer(&pUmDevice->timer);
+		return;
+	}
+
+#ifdef INCLUDE_TBI_SUPPORT
+	if ((pDevice->TbiFlags & TBI_POLLING_FLAGS) &&
+		(--pUmDevice->poll_tbi_expiry <= 0)) {
+
+		BCM5700_PHY_LOCK(pUmDevice, flags);
+		value32 = REG_RD(pDevice, MacCtrl.Status);
+		if (((pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE) &&
+			((value32 & (MAC_STATUS_LINK_STATE_CHANGED |
+				MAC_STATUS_CFG_CHANGED)) ||
+			!(value32 & MAC_STATUS_PCS_SYNCED)))
+			||
+			((pDevice->LinkStatus != LM_STATUS_LINK_ACTIVE) &&
+			(value32 & (MAC_STATUS_PCS_SYNCED |
+				MAC_STATUS_SIGNAL_DETECTED))))
+		{
+			LM_SetupPhy(pDevice);
+		}
+		BCM5700_PHY_UNLOCK(pUmDevice, flags);
+		pUmDevice->poll_tbi_expiry = pUmDevice->poll_tbi_interval;
+
+        }
+#endif
+
+	if (pUmDevice->delayed_link_ind > 0) {
+		if (pUmDevice->delayed_link_ind == 1)
+			MM_IndicateStatus(pDevice, pDevice->LinkStatus);
+		else
+			pUmDevice->delayed_link_ind--;
+	}
+
+	if (pUmDevice->crc_counter_expiry > 0)
+		pUmDevice->crc_counter_expiry--;
+
+	if (!pUmDevice->interrupt) {
+		if (!(pDevice->Flags & USE_TAGGED_STATUS_FLAG)) {
+			BCM5700_LOCK(pUmDevice, flags);
+			if (pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) {
+				/* This will generate an interrupt */
+				REG_WR(pDevice, Grc.LocalCtrl,
+					pDevice->GrcLocalCtrl |
+					GRC_MISC_LOCAL_CTRL_SET_INT);
+			}
+			else {
+				REG_WR(pDevice, HostCoalesce.Mode,
+					pDevice->CoalesceMode |
+					HOST_COALESCE_ENABLE |
+					HOST_COALESCE_NOW);
+			}
+			if (!(REG_RD(pDevice, DmaWrite.Mode) &
+				DMA_WRITE_MODE_ENABLE)) {
+				BCM5700_UNLOCK(pUmDevice, flags);
+				bcm5700_reset(dev);
+			}
+			else {
+				BCM5700_UNLOCK(pUmDevice, flags);
+			}
+			if (pUmDevice->tx_queued) {
+				pUmDevice->tx_queued = 0;
+				netif_wake_queue(dev);
+			}
+		}
+#if (LINUX_VERSION_CODE < 0x02032b)
+		if ((QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container) !=
+			pDevice->TxPacketDescCnt) &&
+			((jiffies - dev->trans_start) > TX_TIMEOUT)) {
+
+			printk(KERN_WARNING "%s: Tx hung\n", dev->name);
+			bcm5700_reset(dev);
+		}
+#endif
+	}
+#ifdef BCM_INT_COAL
+#ifndef BCM_NAPI_RXPOLL
+	if (pUmDevice->adaptive_coalesce) {
+		pUmDevice->adaptive_expiry--;
+		if (pUmDevice->adaptive_expiry == 0) {
+			pUmDevice->adaptive_expiry = HZ /
+				pUmDevice->timer_interval;
+			bcm5700_adapt_coalesce(pUmDevice);
+		}
+	}
+#endif
+#endif
+	if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container) >
+		(unsigned int) pUmDevice->rx_buf_repl_panic_thresh) {
+		/* Generate interrupt and let isr allocate buffers */
+		REG_WR(pDevice, HostCoalesce.Mode, pDevice->CoalesceMode |
+			HOST_COALESCE_ENABLE | HOST_COALESCE_NOW);
+	}
+
+#ifdef BCM_ASF
+	if (pDevice->AsfFlags & ASF_ENABLED) {
+		pUmDevice->asf_heartbeat--;
+		if (pUmDevice->asf_heartbeat == 0) {
+			if( (pDevice->Flags & UNDI_FIX_FLAG) || 
+			    (pDevice->Flags & ENABLE_PCIX_FIX_FLAG)) {
+				MEM_WR_OFFSET(pDevice, T3_CMD_MAILBOX,
+					T3_CMD_NICDRV_ALIVE2);
+				MEM_WR_OFFSET(pDevice, T3_CMD_LENGTH_MAILBOX,
+					4);
+				MEM_WR_OFFSET(pDevice, T3_CMD_DATA_MAILBOX, 5);
+			} else {
+				LM_RegWr(pDevice, 
+					 (T3_NIC_MBUF_POOL_ADDR + 
+					  T3_CMD_MAILBOX), 
+					 T3_CMD_NICDRV_ALIVE2, 1);
+				LM_RegWr(pDevice, 
+					 (T3_NIC_MBUF_POOL_ADDR + 
+					  T3_CMD_LENGTH_MAILBOX),4,1);
+				LM_RegWr(pDevice, 
+					 (T3_NIC_MBUF_POOL_ADDR + 
+					  T3_CMD_DATA_MAILBOX),5,1);
+ 			}
+
+			value32 = REG_RD(pDevice, Grc.RxCpuEvent);
+			REG_WR(pDevice, Grc.RxCpuEvent, value32 | BIT_14);
+			pUmDevice->asf_heartbeat = (2 * HZ) /
+				pUmDevice->timer_interval;
+		}
+	}
+#endif
+
+	if (pDevice->PhyFlags & PHY_IS_FIBER){
+		BCM5700_PHY_LOCK(pUmDevice, flags);
+		LM_5714_FamFiberCheckLink(pDevice);
+		BCM5700_PHY_UNLOCK(pUmDevice, flags);
+	}
+
+	pUmDevice->timer.expires = RUN_AT(pUmDevice->timer_interval);
+	add_timer(&pUmDevice->timer);
+}
+
+STATIC int
+bcm5700_init_counters(PUM_DEVICE_BLOCK pUmDevice)
+{
+#ifdef BCM_INT_COAL
+#ifndef BCM_NAPI_RXPOLL
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+
+	pUmDevice->rx_curr_coalesce_frames = pDevice->RxMaxCoalescedFrames;
+	pUmDevice->rx_curr_coalesce_ticks = pDevice->RxCoalescingTicks;
+	pUmDevice->tx_curr_coalesce_frames = pDevice->TxMaxCoalescedFrames;
+	pUmDevice->rx_last_cnt = 0;
+	pUmDevice->tx_last_cnt = 0;
+#endif
+#endif
+	pUmDevice->phy_crc_count = 0;
+#if TIGON3_DEBUG
+	pUmDevice->tx_zc_count = 0;
+	pUmDevice->tx_chksum_count = 0;
+	pUmDevice->tx_himem_count = 0;
+	pUmDevice->rx_good_chksum_count = 0;
+	pUmDevice->rx_bad_chksum_count = 0;
+#endif
+#ifdef BCM_TSO
+	pUmDevice->tso_pkt_count = 0;
+#endif
+	return 0;
+}
+
+#ifdef BCM_INT_COAL
+#ifndef BCM_NAPI_RXPOLL
+STATIC int
+bcm5700_do_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice,
+	int rx_frames, int rx_ticks, int tx_frames, int rx_frames_intr)
+{
+	unsigned long flags = 0;
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+
+	if (pUmDevice->do_global_lock) {
+		if (spin_is_locked(&pUmDevice->global_lock))
+			return 0;
+		spin_lock_irqsave(&pUmDevice->global_lock, flags);
+	}
+	pUmDevice->rx_curr_coalesce_frames = rx_frames;
+	pUmDevice->rx_curr_coalesce_ticks = rx_ticks;
+	pUmDevice->tx_curr_coalesce_frames = tx_frames;
+	pUmDevice->rx_curr_coalesce_frames_intr = rx_frames_intr;
+	REG_WR(pDevice, HostCoalesce.RxMaxCoalescedFrames, rx_frames);
+
+	REG_WR(pDevice, HostCoalesce.RxCoalescingTicks, rx_ticks);
+
+	REG_WR(pDevice, HostCoalesce.TxMaxCoalescedFrames, tx_frames);
+
+	REG_WR(pDevice, HostCoalesce.RxMaxCoalescedFramesDuringInt,
+		rx_frames_intr);
+
+	BCM5700_UNLOCK(pUmDevice, flags);
+	return 0;
+}
+
+STATIC int
+bcm5700_adapt_coalesce(PUM_DEVICE_BLOCK pUmDevice)
+{
+	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
+	uint rx_curr_cnt, tx_curr_cnt, rx_delta, tx_delta, total_delta;
+
+	rx_curr_cnt = pDevice->pStatsBlkVirt->ifHCInUcastPkts.Low;
+	tx_curr_cnt = pDevice->pStatsBlkVirt->ifHCOutUcastPkts.Low;
+	if ((rx_curr_cnt <= pUmDevice->rx_last_cnt) ||
+		(tx_curr_cnt < pUmDevice->tx_last_cnt)) {
+
+		/* skip if there is counter rollover */
+		pUmDevice->rx_last_cnt = rx_curr_cnt;
+		pUmDevice->tx_last_cnt = tx_curr_cnt;
+		return 0;
+	}
+
+	rx_delta = rx_curr_cnt - pUmDevice->rx_last_cnt;
+	tx_delta = tx_curr_cnt - pUmDevice->tx_last_cnt;
+	total_delta = (((rx_delta + rx_delta) + tx_delta) / 3) << 1;
+
+	pUmDevice->rx_last_cnt = rx_curr_cnt;
+	pUmDevice->tx_last_cnt = tx_curr_cnt;
+
+	if (total_delta < ADAPTIVE_LO_PKT_THRESH) {
+		if (pUmDevice->rx_curr_coalesce_frames !=
+			ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES) {
+
+			bcm5700_do_adapt_coalesce(pUmDevice,
+				ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES,
+				ADAPTIVE_LO_RX_COALESCING_TICKS,
+				ADAPTIVE_LO_TX_MAX_COALESCED_FRAMES,
+				ADAPTIVE_LO_RX_MAX_COALESCED_FRAMES_DURING_INT);
+		}
+	}
+	else if (total_delta < ADAPTIVE_HI_PKT_THRESH) {
+		if (pUmDevice->rx_curr_coalesce_frames !=
+			DEFAULT_RX_MAX_COALESCED_FRAMES) {
+
+			bcm5700_do_adapt_coalesce(pUmDevice,
+				DEFAULT_RX_MAX_COALESCED_FRAMES,
+				DEFAULT_RX_COALESCING_TICKS,
+				DEFAULT_TX_MAX_COALESCED_FRAMES,
+				DEFAULT_RX_MAX_COALESCED_FRAMES_DURING_INT);
+		}
+	}
+	else {
+		if (pUmDevice->rx_curr_coalesce_frames !=
+			ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES) {
+
+			bcm5700_do_adapt_coalesce(pUmDevice,
+				ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES,
+				ADAPTIVE_HI_RX_COALESCING_TICKS,
+				ADAPTIVE_HI_TX_MAX_COALESCED_FRAMES,
+				ADAPTIVE_HI_RX_MAX_COALESCED_FRAMES_DURING_INT);
+		}
+	}
+	return 0;
+}
+#endif
+#endif
+
+STATIC void
+bcm5700_reset(struct net_device *dev)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	unsigned long flags;
+
+#ifdef BCM_TSO
+
+	if( (dev->features & NETIF_F_TSO) &&
+		(pUmDevice->tx_full) )	   {
+
+		dev->features &= ~NETIF_F_TSO;
+	}
+#endif
+
+	netif_stop_queue(dev);
+	bcm5700_intr_off(pUmDevice);
+	BCM5700_PHY_LOCK(pUmDevice, flags);
+	LM_ResetAdapter(pDevice);
+	pDevice->InitDone = TRUE;
+	bcm5700_do_rx_mode(dev);
+	bcm5700_set_vlan_mode(pUmDevice);
+	bcm5700_init_counters(pUmDevice);
+	if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6)) {
+		LM_SetMacAddress(pDevice, dev->dev_addr);
+	}
+	BCM5700_PHY_UNLOCK(pUmDevice, flags);
+	atomic_set(&pUmDevice->intr_sem, 1);
+	bcm5700_intr_on(pUmDevice);
+	netif_wake_queue(dev);
+}
+
+STATIC void
+bcm5700_set_vlan_mode(UM_DEVICE_BLOCK *pUmDevice)
+{
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+	LM_UINT32 ReceiveMask = pDevice->ReceiveMask;
+	int vlan_tag_mode = pUmDevice->vlan_tag_mode;
+
+	if (vlan_tag_mode == VLAN_TAG_MODE_AUTO_STRIP) {
+	        if (pDevice->AsfFlags & ASF_ENABLED) {
+			vlan_tag_mode = VLAN_TAG_MODE_FORCED_STRIP;
+		}
+		else {
+			vlan_tag_mode = VLAN_TAG_MODE_NORMAL_STRIP;
+		}
+	}
+	if (vlan_tag_mode == VLAN_TAG_MODE_NORMAL_STRIP) {
+		ReceiveMask |= LM_KEEP_VLAN_TAG;
+#ifdef BCM_VLAN
+		if (pUmDevice->vlgrp)
+			ReceiveMask &= ~LM_KEEP_VLAN_TAG;
+#endif
+	}
+	else if (vlan_tag_mode == VLAN_TAG_MODE_FORCED_STRIP) {
+		ReceiveMask &= ~LM_KEEP_VLAN_TAG;
+	}
+	if (ReceiveMask != pDevice->ReceiveMask)
+	{
+		LM_SetReceiveMask(pDevice, ReceiveMask);
+	}
+}
+
+static void
+bcm5700_poll_wait(UM_DEVICE_BLOCK *pUmDevice)
+{
+#ifdef BCM_NAPI_RXPOLL
+	while (pUmDevice->lm_dev.RxPoll) {
+		current->state = TASK_INTERRUPTIBLE;
+		schedule_timeout(1);
+	}
+#endif
+}
+
+
+#ifdef BCM_VLAN
+STATIC void
+bcm5700_vlan_rx_register(struct net_device *dev, struct vlan_group *vlgrp)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
+
+	bcm5700_intr_off(pUmDevice);
+	bcm5700_poll_wait(pUmDevice);
+	pUmDevice->vlgrp = vlgrp;
+	bcm5700_set_vlan_mode(pUmDevice);
+	bcm5700_intr_on(pUmDevice);
+}
+
+STATIC void
+bcm5700_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
+
+	bcm5700_intr_off(pUmDevice);
+	bcm5700_poll_wait(pUmDevice);
+	if (pUmDevice->vlgrp) {
+		pUmDevice->vlgrp->vlan_devices[vid] = NULL;
+	}
+	bcm5700_intr_on(pUmDevice);
+}
+#endif
+
+STATIC int
+bcm5700_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	PLM_PACKET pPacket;
+	PUM_PACKET pUmPacket;
+	unsigned long flags = 0;
+	int frag_no;
+#ifdef BCM_TSO
+	LM_UINT32 mss = 0 ;
+	uint16_t ip_tcp_len, tcp_opt_len, tcp_seg_flags;
+#endif
+
+	if ((pDevice->LinkStatus == LM_STATUS_LINK_DOWN) ||
+		!pDevice->InitDone || pUmDevice->suspended)
+	{
+		dev_kfree_skb(skb);
+		return 0;
+	}
+
+#if (LINUX_VERSION_CODE < 0x02032b)
+	if (test_and_set_bit(0, &dev->tbusy)) {
+	    return 1;
+	}
+#endif
+
+	if (pUmDevice->do_global_lock && pUmDevice->interrupt) {
+		netif_stop_queue(dev);
+		pUmDevice->tx_queued = 1;
+		if (!pUmDevice->interrupt) {
+			netif_wake_queue(dev);
+			pUmDevice->tx_queued = 0;
+		}
+	    return 1;
+	}
+
+	pPacket = (PLM_PACKET)
+		QQ_PopHead(&pDevice->TxPacketFreeQ.Container);
+	if (pPacket == 0) {
+		netif_stop_queue(dev);
+		pUmDevice->tx_full = 1;
+		if (QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container)) {
+			netif_wake_queue(dev);
+			pUmDevice->tx_full = 0;
+		}
+	    return 1;
+	}
+	pUmPacket = (PUM_PACKET) pPacket;
+	pUmPacket->skbuff = skb;
+	pUmDevice->stats.tx_bytes += skb->len; 
+
+	if (skb->ip_summed == CHECKSUM_HW) {
+		pPacket->Flags = SND_BD_FLAG_TCP_UDP_CKSUM;
+#if TIGON3_DEBUG
+		pUmDevice->tx_chksum_count++;
+#endif
+	}
+	else {
+		pPacket->Flags = 0;
+	}
+#if MAX_SKB_FRAGS
+	frag_no = skb_shinfo(skb)->nr_frags;
+#else
+	frag_no = 0;
+#endif
+	if (atomic_read(&pDevice->SendBdLeft) < (frag_no + 1)) {
+		netif_stop_queue(dev);
+		pUmDevice->tx_full = 1;
+		QQ_PushHead(&pDevice->TxPacketFreeQ.Container, pPacket);
+		if (atomic_read(&pDevice->SendBdLeft) >= (frag_no + 1)) {
+			netif_wake_queue(dev);
+			pUmDevice->tx_full = 0;
+		}
+		return 1;
+	}
+
+	pPacket->u.Tx.FragCount = frag_no + 1;
+#if TIGON3_DEBUG
+	if (pPacket->u.Tx.FragCount > 1)
+		pUmDevice->tx_zc_count++;
+#endif
+
+#ifdef BCM_VLAN
+	if (pUmDevice->vlgrp && vlan_tx_tag_present(skb)) {
+		pPacket->VlanTag = vlan_tx_tag_get(skb);
+		pPacket->Flags |= SND_BD_FLAG_VLAN_TAG;
+	}
+#endif
+
+#ifdef BCM_TSO
+	if ((mss = (LM_UINT32) skb_shinfo(skb)->tso_size) &&
+		(skb->len > pDevice->TxMtu)) {
+
+#if (LINUX_VERSION_CODE >= 0x02060c)
+
+		if (skb_header_cloned(skb) &&
+			pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
+
+			dev_kfree_skb(skb);
+			return 0;
+		}
+#endif
+		pUmDevice->tso_pkt_count++;
+
+		pPacket->Flags |= SND_BD_FLAG_CPU_PRE_DMA |
+			SND_BD_FLAG_CPU_POST_DMA;
+
+		tcp_opt_len = 0;
+		if (skb->h.th->doff > 5) {
+			tcp_opt_len = (skb->h.th->doff - 5) << 2;
+		}
+		ip_tcp_len = (skb->nh.iph->ihl << 2) + sizeof(struct tcphdr);
+		skb->nh.iph->check = 0;
+
+		if ( T3_ASIC_IS_575X_PLUS(pDevice->ChipRevId) ){
+			skb->h.th->check = 0;
+			pPacket->Flags &= ~SND_BD_FLAG_TCP_UDP_CKSUM;
+		}
+		else {
+			skb->h.th->check = ~csum_tcpudp_magic(
+				skb->nh.iph->saddr, skb->nh.iph->daddr,
+				0, IPPROTO_TCP, 0);
+		}
+
+		skb->nh.iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len);
+		tcp_seg_flags = 0;
+
+		if (tcp_opt_len || (skb->nh.iph->ihl > 5)) {
+			if ( T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId) ){
+				tcp_seg_flags =
+					((skb->nh.iph->ihl - 5) +
+					(tcp_opt_len >> 2)) << 11;
+			}
+			else {
+				pPacket->Flags |=
+					((skb->nh.iph->ihl - 5) +
+					(tcp_opt_len >> 2)) << 12;
+			}
+		}
+		pPacket->u.Tx.MaxSegmentSize = mss | tcp_seg_flags;
+	}
+	else
+	{
+		pPacket->u.Tx.MaxSegmentSize = 0;
+	}
+#endif
+	BCM5700_LOCK(pUmDevice, flags);
+	LM_SendPacket(pDevice, pPacket);
+	BCM5700_UNLOCK(pUmDevice, flags);
+
+#if (LINUX_VERSION_CODE < 0x02032b)
+	netif_wake_queue(dev);
+#endif
+	dev->trans_start = jiffies;
+
+
+	return 0;
+}
+
+#ifdef BCM_NAPI_RXPOLL
+STATIC int
+bcm5700_poll(struct net_device *dev, int *budget)
+{
+	int orig_budget = *budget;
+	int work_done;
+	UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) dev->priv;
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+	unsigned long flags = 0;
+	LM_UINT32 tag;
+
+	if (orig_budget > dev->quota)
+		orig_budget = dev->quota;
+
+	BCM5700_LOCK(pUmDevice, flags);
+	/* BCM4785: Flush posted writes from GbE to host memory. */
+	if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
+		REG_RD(pDevice, HostCoalesce.Mode);
+	work_done = LM_ServiceRxPoll(pDevice, orig_budget);
+	*budget -= work_done;
+	dev->quota -= work_done;
+
+	if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
+		replenish_rx_buffers(pUmDevice, 0);
+	}
+	BCM5700_UNLOCK(pUmDevice, flags);
+	if (work_done) {
+		MM_IndicateRxPackets(pDevice);
+		BCM5700_LOCK(pUmDevice, flags);
+		LM_QueueRxPackets(pDevice);
+		BCM5700_UNLOCK(pUmDevice, flags);
+	}
+	if ((work_done < orig_budget) || atomic_read(&pUmDevice->intr_sem) ||
+		pUmDevice->suspended) {
+
+		netif_rx_complete(dev);
+		BCM5700_LOCK(pUmDevice, flags);
+		REG_WR(pDevice, Grc.Mode, pDevice->GrcMode);
+		pDevice->RxPoll = FALSE;
+		if (pDevice->RxPoll) {
+			BCM5700_UNLOCK(pUmDevice, flags);
+			return 0;
+		}
+		/* Take care of possible missed rx interrupts */
+		REG_RD_BACK(pDevice, Grc.Mode);	/* flush the register write */
+		tag = pDevice->pStatusBlkVirt->StatusTag;
+		if ((pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) ||
+			(pDevice->pStatusBlkVirt->Idx[0].RcvProdIdx !=
+			pDevice->RcvRetConIdx)) {
+
+			REG_WR(pDevice, HostCoalesce.Mode,
+				pDevice->CoalesceMode | HOST_COALESCE_ENABLE |
+				HOST_COALESCE_NOW);
+		}
+		/* If a new status block is pending in the WDMA state machine */
+		/* before the register write to enable the rx interrupt,      */
+		/* the new status block may DMA with no interrupt. In this    */
+		/* scenario, the tag read above will be older than the tag in */
+		/* the pending status block and writing the older tag will    */
+		/* cause interrupt to be generated.                           */
+		else if (pDevice->Flags & USE_TAGGED_STATUS_FLAG) {
+			MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low,
+				tag << 24);
+			/* Make sure we service tx in case some tx interrupts */
+			/* are cleared */
+			if (atomic_read(&pDevice->SendBdLeft) <
+				(T3_SEND_RCB_ENTRY_COUNT / 2)) {
+				REG_WR(pDevice, HostCoalesce.Mode,
+					pDevice->CoalesceMode |
+					HOST_COALESCE_ENABLE |
+					HOST_COALESCE_NOW);
+			}
+		}
+		BCM5700_UNLOCK(pUmDevice, flags);
+		return 0;
+	}
+	return 1;
+}
+#endif /* BCM_NAPI_RXPOLL */
+
+STATIC irqreturn_t
+bcm5700_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
+{
+	struct net_device *dev = (struct net_device *)dev_instance;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	LM_UINT32 oldtag, newtag;
+	int i, max_intr_loop;
+#ifdef BCM_TASKLET
+	int repl_buf_count;
+#endif
+	unsigned int handled = 1;
+
+	if (!pDevice->InitDone) {
+		handled = 0;
+		return IRQ_RETVAL(handled);
+	}
+
+	bcm5700_intr_lock(pUmDevice);
+	if (atomic_read(&pUmDevice->intr_sem)) {
+		MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
+		bcm5700_intr_unlock(pUmDevice);
+		handled = 0;
+		return IRQ_RETVAL(handled);
+	}
+
+	if (test_and_set_bit(0, (void*)&pUmDevice->interrupt)) {
+		printk(KERN_ERR "%s: Duplicate entry of the interrupt handler\n",
+			dev->name);
+		bcm5700_intr_unlock(pUmDevice);
+		handled = 0;
+		return IRQ_RETVAL(handled);
+	}
+
+	/* BCM4785: Flush posted writes from GbE to host memory. */
+	if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
+		REG_RD(pDevice, HostCoalesce.Mode);
+
+	if ((pDevice->Flags & USING_MSI_FLAG) ||
+		(pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) ||
+		!(REG_RD(pDevice,PciCfg.PciState) & T3_PCI_STATE_INTERRUPT_NOT_ACTIVE) )
+	{
+
+		if (pUmDevice->intr_test) {
+			if (!(REG_RD(pDevice, PciCfg.PciState) &
+					T3_PCI_STATE_INTERRUPT_NOT_ACTIVE) ||
+						pDevice->Flags & USING_MSI_FLAG ) {
+				pUmDevice->intr_test_result = 1;
+			}
+			pUmDevice->intr_test = 0;
+		}
+
+#ifdef BCM_NAPI_RXPOLL
+		max_intr_loop = 1;
+#else
+		max_intr_loop = 50;
+#endif
+		if (pDevice->Flags & USE_TAGGED_STATUS_FLAG) {
+			MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
+			oldtag = pDevice->pStatusBlkVirt->StatusTag;
+
+			for (i = 0; ; i++) {
+				pDevice->pStatusBlkVirt->Status &= ~STATUS_BLOCK_UPDATED;
+
+				LM_ServiceInterrupts(pDevice);
+				/* BCM4785: Flush GbE posted writes to host memory. */
+				if (pDevice->Flags & FLUSH_POSTED_WRITE_FLAG)
+					MB_REG_RD(pDevice, Mailbox.Interrupt[0].Low);
+				newtag = pDevice->pStatusBlkVirt->StatusTag;
+				if ((newtag == oldtag) || (i > max_intr_loop)) {
+					MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, oldtag << 24);
+					pDevice->LastTag = oldtag;
+					if (pDevice->Flags & UNDI_FIX_FLAG) {
+						REG_WR(pDevice, Grc.LocalCtrl,
+						pDevice->GrcLocalCtrl | 0x2);
+					}
+					break;
+				}
+				oldtag = newtag;
+			}
+		}
+		else
+		{
+			i = 0;
+			do {
+				uint dummy;
+
+				MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 1);
+				pDevice->pStatusBlkVirt->Status &= ~STATUS_BLOCK_UPDATED;
+				LM_ServiceInterrupts(pDevice);
+				MB_REG_WR(pDevice, Mailbox.Interrupt[0].Low, 0);
+				dummy = MB_REG_RD(pDevice, Mailbox.Interrupt[0].Low);
+				i++;
+			}
+			while ((pDevice->pStatusBlkVirt->Status & STATUS_BLOCK_UPDATED) &&
+				(i < max_intr_loop));
+
+			if (pDevice->Flags & UNDI_FIX_FLAG) {
+				REG_WR(pDevice, Grc.LocalCtrl,
+				pDevice->GrcLocalCtrl | 0x2);
+			}
+		}
+	}
+	else
+	{
+		/* not my interrupt */
+		handled = 0;
+	}
+
+#ifdef BCM_TASKLET
+	repl_buf_count = QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container);
+	if (((repl_buf_count > pUmDevice->rx_buf_repl_panic_thresh) ||
+		pDevice->QueueAgain) &&
+		(!test_and_set_bit(0, &pUmDevice->tasklet_busy))) {
+
+		replenish_rx_buffers(pUmDevice, pUmDevice->rx_buf_repl_isr_limit);
+		clear_bit(0, (void*)&pUmDevice->tasklet_busy);
+	}
+	else if ((repl_buf_count > pUmDevice->rx_buf_repl_thresh) &&
+		!pUmDevice->tasklet_pending) {
+
+		pUmDevice->tasklet_pending = 1;
+		tasklet_schedule(&pUmDevice->tasklet);
+	}
+#else
+#ifdef BCM_NAPI_RXPOLL
+	if (!pDevice->RxPoll &&
+		QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
+		pDevice->RxPoll = 1;
+		MM_ScheduleRxPoll(pDevice);
+	}
+#else
+	if (QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container)) {
+		replenish_rx_buffers(pUmDevice, 0);
+	}
+
+	if (QQ_GetEntryCnt(&pDevice->RxPacketFreeQ.Container) ||
+		pDevice->QueueAgain) {
+
+		LM_QueueRxPackets(pDevice);
+	}
+#endif
+#endif
+
+	clear_bit(0, (void*)&pUmDevice->interrupt);
+	bcm5700_intr_unlock(pUmDevice);
+	if (pUmDevice->tx_queued) {
+		pUmDevice->tx_queued = 0;
+		netif_wake_queue(dev);
+	}
+	return IRQ_RETVAL(handled);
+}
+
+
+#ifdef BCM_TASKLET
+STATIC void
+bcm5700_tasklet(unsigned long data)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)data;
+	unsigned long flags = 0;
+
+	/* RH 7.2 Beta 3 tasklets are reentrant */
+	if (test_and_set_bit(0, &pUmDevice->tasklet_busy)) {
+		pUmDevice->tasklet_pending = 0;
+		return;
+	}
+
+	pUmDevice->tasklet_pending = 0;
+	if (pUmDevice->opened && !pUmDevice->suspended) {
+		BCM5700_LOCK(pUmDevice, flags);
+		replenish_rx_buffers(pUmDevice, 0);
+		BCM5700_UNLOCK(pUmDevice, flags);
+	}
+
+	clear_bit(0, &pUmDevice->tasklet_busy);
+}
+#endif
+
+STATIC int
+bcm5700_close(struct net_device *dev)
+{
+
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+
+#if (LINUX_VERSION_CODE < 0x02032b)
+	dev->start = 0;
+#endif
+	netif_stop_queue(dev);
+	pUmDevice->opened = 0;
+
+#ifdef BCM_ASF
+	if( !(pDevice->AsfFlags & ASF_ENABLED) )
+#endif
+#ifdef BCM_WOL
+		if( enable_wol[pUmDevice->index] == 0 )
+#endif
+			B57_INFO(("%s: %s NIC Link is DOWN\n", bcm5700_driver, dev->name));
+
+	if (tigon3_debug > 1)
+		printk(KERN_DEBUG "%s: Shutting down Tigon3\n",
+			   dev->name);
+
+	LM_MulticastClear(pDevice);
+	bcm5700_shutdown(pUmDevice);
+
+	if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
+		del_timer_sync(&pUmDevice->statstimer);
+	}
+
+	del_timer_sync(&pUmDevice->timer);
+
+	free_irq(pUmDevice->pdev->irq, dev);
+
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+
+	if(pDevice->Flags & USING_MSI_FLAG) {
+		pci_disable_msi(pUmDevice->pdev);
+                REG_WR(pDevice, Msi.Mode,  1 );
+		pDevice->Flags &= ~USING_MSI_FLAG;
+	}
+
+#endif
+
+
+#if (LINUX_VERSION_CODE < 0x020300)
+	MOD_DEC_USE_COUNT;
+#endif
+	{
+	/* BCM4785: Don't go to low-power state because it will power down the smbus block. */
+	if (!(pDevice->Flags & SB_CORE_FLAG))
+		LM_SetPowerState(pDevice, LM_POWER_STATE_D3);
+	}
+
+	bcm5700_freemem(dev);
+
+	QQ_InitQueue(&pDevice->RxPacketFreeQ.Container,
+        		MAX_RX_PACKET_DESC_COUNT);
+
+	return 0;
+}
+
+STATIC int
+bcm5700_freemem(struct net_device *dev)
+{
+	int i;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	LM_DEVICE_BLOCK	 *pDevice = &pUmDevice->lm_dev;
+
+	for (i = 0; i < pUmDevice->mem_list_num; i++) {
+		if (pUmDevice->mem_size_list[i] == 0) {
+			kfree(pUmDevice->mem_list[i]);
+		}
+		else {
+			pci_free_consistent(pUmDevice->pdev,
+				(size_t) pUmDevice->mem_size_list[i],
+				pUmDevice->mem_list[i],
+				pUmDevice->dma_list[i]);
+		}
+	}
+
+	pDevice->pStatusBlkVirt = 0;
+	pDevice->pStatsBlkVirt  = 0;
+	pUmDevice->mem_list_num = 0;
+
+	return 0;
+}
+
+uint64_t
+bcm5700_crc_count(PUM_DEVICE_BLOCK pUmDevice)
+{
+	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
+	LM_UINT32 Value32;
+	PT3_STATS_BLOCK pStats = (PT3_STATS_BLOCK) pDevice->pStatsBlkVirt;
+	unsigned long flags;
+
+	if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5700 ||
+		T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5701) &&
+		!(pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
+
+		if (!pUmDevice->opened || !pDevice->InitDone)
+		{
+
+			return 0;
+		}
+
+		/* regulate MDIO access during run time */
+		if (pUmDevice->crc_counter_expiry > 0)
+			return pUmDevice->phy_crc_count;
+
+		pUmDevice->crc_counter_expiry = (5 * HZ) /
+			pUmDevice->timer_interval;
+
+		BCM5700_PHY_LOCK(pUmDevice, flags);
+		LM_ReadPhy(pDevice, 0x1e, &Value32);
+		if ((Value32 & 0x8000) == 0)
+			LM_WritePhy(pDevice, 0x1e, Value32 | 0x8000);
+		LM_ReadPhy(pDevice, 0x14, &Value32);
+		BCM5700_PHY_UNLOCK(pUmDevice, flags);
+		/* Sometimes data on the MDIO bus can be corrupted */
+		if (Value32 != 0xffff)
+			pUmDevice->phy_crc_count += Value32;
+		return pUmDevice->phy_crc_count;
+	}
+	else if (pStats == 0) {
+		return 0;
+	}
+	else {
+		return (MM_GETSTATS64(pStats->dot3StatsFCSErrors));
+	}
+}
+
+uint64_t
+bcm5700_rx_err_count(UM_DEVICE_BLOCK *pUmDevice)
+{
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+	T3_STATS_BLOCK *pStats = (T3_STATS_BLOCK *) pDevice->pStatsBlkVirt;
+
+	if (pStats == 0)
+		return 0;
+	return (bcm5700_crc_count(pUmDevice) +
+		MM_GETSTATS64(pStats->dot3StatsAlignmentErrors) +
+		MM_GETSTATS64(pStats->etherStatsUndersizePkts) +
+		MM_GETSTATS64(pStats->etherStatsFragments) +
+		MM_GETSTATS64(pStats->dot3StatsFramesTooLong) +
+		MM_GETSTATS64(pStats->etherStatsJabbers));
+}
+
+STATIC struct net_device_stats *
+bcm5700_get_stats(struct net_device *dev)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	PT3_STATS_BLOCK pStats = (PT3_STATS_BLOCK) pDevice->pStatsBlkVirt;
+	struct net_device_stats *p_netstats = &pUmDevice->stats;
+
+	if (pStats == 0)
+		return p_netstats;
+
+	/* Get stats from LM */
+	p_netstats->rx_packets =
+		MM_GETSTATS(pStats->ifHCInUcastPkts) +
+		MM_GETSTATS(pStats->ifHCInMulticastPkts) +
+		MM_GETSTATS(pStats->ifHCInBroadcastPkts);
+	p_netstats->tx_packets =
+		MM_GETSTATS(pStats->ifHCOutUcastPkts) +
+		MM_GETSTATS(pStats->ifHCOutMulticastPkts) +
+		MM_GETSTATS(pStats->ifHCOutBroadcastPkts);
+	/* There counters seem to be innacurate. Use byte number accumulation 
+	   instead.
+	   p_netstats->rx_bytes = MM_GETSTATS(pStats->ifHCInOctets);
+	   p_netstats->tx_bytes = MM_GETSTATS(pStats->ifHCOutOctets);
+	*/
+	p_netstats->tx_errors =
+		MM_GETSTATS(pStats->dot3StatsInternalMacTransmitErrors) +
+		MM_GETSTATS(pStats->dot3StatsCarrierSenseErrors) +
+		MM_GETSTATS(pStats->ifOutDiscards) +
+		MM_GETSTATS(pStats->ifOutErrors);
+	p_netstats->multicast = MM_GETSTATS(pStats->ifHCInMulticastPkts);
+	p_netstats->collisions = MM_GETSTATS(pStats->etherStatsCollisions);
+	p_netstats->rx_length_errors =
+		MM_GETSTATS(pStats->dot3StatsFramesTooLong) +
+		MM_GETSTATS(pStats->etherStatsUndersizePkts);
+	p_netstats->rx_over_errors = MM_GETSTATS(pStats->nicNoMoreRxBDs);
+	p_netstats->rx_frame_errors =
+		MM_GETSTATS(pStats->dot3StatsAlignmentErrors);
+	p_netstats->rx_crc_errors = (unsigned long)
+		bcm5700_crc_count(pUmDevice);
+	p_netstats->rx_errors = (unsigned long)
+		bcm5700_rx_err_count(pUmDevice);
+
+	p_netstats->tx_aborted_errors = MM_GETSTATS(pStats->ifOutDiscards);
+	p_netstats->tx_carrier_errors =
+		MM_GETSTATS(pStats->dot3StatsCarrierSenseErrors);
+
+	return p_netstats;
+}
+
+void
+b57_suspend_chip(UM_DEVICE_BLOCK *pUmDevice)
+{
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+
+	if (pUmDevice->opened) {
+		bcm5700_intr_off(pUmDevice);
+		netif_carrier_off(pUmDevice->dev);
+		netif_stop_queue(pUmDevice->dev);
+#ifdef BCM_TASKLET
+		tasklet_kill(&pUmDevice->tasklet);
+#endif
+		bcm5700_poll_wait(pUmDevice);
+	}
+	pUmDevice->suspended = 1;
+	LM_ShutdownChip(pDevice, LM_SUSPEND_RESET);
+}
+
+void
+b57_resume_chip(UM_DEVICE_BLOCK *pUmDevice)
+{
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+
+	if (pUmDevice->suspended) {
+		pUmDevice->suspended = 0;
+		if (pUmDevice->opened) {
+			bcm5700_reset(pUmDevice->dev);
+		}
+		else {
+			LM_ShutdownChip(pDevice, LM_SHUTDOWN_RESET);
+		}
+	}
+}
+
+/* Returns 0 on failure, 1 on success */
+int
+b57_test_intr(UM_DEVICE_BLOCK *pUmDevice)
+{
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+	int j;
+
+	if (!pUmDevice->opened)
+		return 0;
+	pUmDevice->intr_test_result = 0;
+	pUmDevice->intr_test = 1;
+
+	REG_WR(pDevice, HostCoalesce.Mode,
+		pDevice->CoalesceMode | HOST_COALESCE_ENABLE |
+		HOST_COALESCE_NOW);
+
+	for (j = 0; j < 10; j++) {
+		if (pUmDevice->intr_test_result){
+			break;
+		}
+
+		REG_WR(pDevice, HostCoalesce.Mode,
+		pDevice->CoalesceMode | HOST_COALESCE_ENABLE |
+		HOST_COALESCE_NOW);
+
+		MM_Sleep(pDevice, 1);
+	}
+
+	return pUmDevice->intr_test_result;
+
+}
+
+#ifdef SIOCETHTOOL
+
+#ifdef ETHTOOL_GSTRINGS
+
+#define ETH_NUM_STATS 30
+#define RX_CRC_IDX 5
+#define RX_MAC_ERR_IDX 14
+
+struct {
+	char string[ETH_GSTRING_LEN];
+} bcm5700_stats_str_arr[ETH_NUM_STATS] = {
+	{ "rx_unicast_packets" },
+	{ "rx_multicast_packets" },
+	{ "rx_broadcast_packets" },
+	{ "rx_bytes" },
+	{ "rx_fragments" },
+	{ "rx_crc_errors" },	/* this needs to be calculated */
+	{ "rx_align_errors" },
+	{ "rx_xon_frames" },
+	{ "rx_xoff_frames" },
+	{ "rx_long_frames" },
+	{ "rx_short_frames" },
+	{ "rx_jabber" },
+	{ "rx_discards" },
+	{ "rx_errors" },
+	{ "rx_mac_errors" },	/* this needs to be calculated */
+	{ "tx_unicast_packets" },
+	{ "tx_multicast_packets" },
+	{ "tx_broadcast_packets" },
+	{ "tx_bytes" },
+	{ "tx_deferred" },
+	{ "tx_single_collisions" },
+	{ "tx_multi_collisions" },
+	{ "tx_total_collisions" },
+	{ "tx_excess_collisions" },
+	{ "tx_late_collisions" },
+	{ "tx_xon_frames" },
+	{ "tx_xoff_frames" },
+	{ "tx_internal_mac_errors" },
+	{ "tx_carrier_errors" },
+	{ "tx_errors" },
+};
+
+#define STATS_OFFSET(offset_name) ((OFFSETOF(T3_STATS_BLOCK, offset_name)) / sizeof(uint64_t))
+
+#ifdef __BIG_ENDIAN
+#define SWAP_DWORD_64(x) (x)
+#else
+#define SWAP_DWORD_64(x) ((x << 32) | (x >> 32))
+#endif
+
+unsigned long bcm5700_stats_offset_arr[ETH_NUM_STATS] = {
+	STATS_OFFSET(ifHCInUcastPkts),
+	STATS_OFFSET(ifHCInMulticastPkts),
+	STATS_OFFSET(ifHCInBroadcastPkts),
+	STATS_OFFSET(ifHCInOctets),
+	STATS_OFFSET(etherStatsFragments),
+	0,
+	STATS_OFFSET(dot3StatsAlignmentErrors),
+	STATS_OFFSET(xonPauseFramesReceived),
+	STATS_OFFSET(xoffPauseFramesReceived),
+	STATS_OFFSET(dot3StatsFramesTooLong),
+	STATS_OFFSET(etherStatsUndersizePkts),
+	STATS_OFFSET(etherStatsJabbers),
+	STATS_OFFSET(ifInDiscards),
+	STATS_OFFSET(ifInErrors),
+	0,
+	STATS_OFFSET(ifHCOutUcastPkts),
+	STATS_OFFSET(ifHCOutMulticastPkts),
+	STATS_OFFSET(ifHCOutBroadcastPkts),
+	STATS_OFFSET(ifHCOutOctets),
+	STATS_OFFSET(dot3StatsDeferredTransmissions),
+	STATS_OFFSET(dot3StatsSingleCollisionFrames),
+	STATS_OFFSET(dot3StatsMultipleCollisionFrames),
+	STATS_OFFSET(etherStatsCollisions),
+	STATS_OFFSET(dot3StatsExcessiveCollisions),
+	STATS_OFFSET(dot3StatsLateCollisions),
+	STATS_OFFSET(outXonSent),
+	STATS_OFFSET(outXoffSent),
+	STATS_OFFSET(dot3StatsInternalMacTransmitErrors),
+	STATS_OFFSET(dot3StatsCarrierSenseErrors),
+	STATS_OFFSET(ifOutErrors),
+};
+
+#endif /* ETHTOOL_GSTRINGS */
+
+
+#ifdef ETHTOOL_GREGS
+#if (LINUX_VERSION_CODE >= 0x02040f)
+static void
+bcm5700_get_reg_blk(UM_DEVICE_BLOCK *pUmDevice, u32 **buf, u32 start, u32 end,
+		int reserved)
+{
+	u32 offset;
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+
+	if (reserved) {
+		memset(*buf, 0, end - start);
+		*buf = *buf + (end - start)/4;
+		return;
+	}
+	for (offset = start; offset < end; offset+=4, *buf = *buf + 1) {
+		if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)){
+			if (((offset >= 0x3400) && (offset < 0x3c00)) ||
+				((offset >= 0x5400) && (offset < 0x5800)) ||
+				((offset >= 0x6400) && (offset < 0x6800))) {
+				**buf = 0;
+				continue;
+			}
+		}
+		**buf = REG_RD_OFFSET(pDevice, offset);
+	}
+}
+#endif
+#endif
+
+static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
+{
+	struct ethtool_cmd ethcmd;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+
+	if (mm_copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
+		return -EFAULT;
+
+        switch (ethcmd.cmd) {
+#ifdef ETHTOOL_GDRVINFO
+        case ETHTOOL_GDRVINFO: {
+		struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
+
+		strcpy(info.driver,  bcm5700_driver);
+#ifdef INCLUDE_5701_AX_FIX
+		if(pDevice->ChipRevId == T3_CHIP_ID_5701_A0) {
+			extern int t3FwReleaseMajor;
+			extern int t3FwReleaseMinor;
+			extern int t3FwReleaseFix;
+
+			sprintf(info.fw_version, "%i.%i.%i",
+				t3FwReleaseMajor, t3FwReleaseMinor,
+				t3FwReleaseFix);
+		}
+#endif
+		strcpy(info.fw_version, pDevice->BootCodeVer);
+		strcpy(info.version, bcm5700_version);
+#if (LINUX_VERSION_CODE <= 0x020422)
+		strcpy(info.bus_info, pUmDevice->pdev->slot_name);
+#else
+		strcpy(info.bus_info, pci_name(pUmDevice->pdev));
+#endif
+
+
+
+#ifdef ETHTOOL_GEEPROM
+		BCM_EEDUMP_LEN(&info, pDevice->NvramSize);
+#endif
+#ifdef ETHTOOL_GREGS
+		/* dump everything, including holes in the register space */
+		info.regdump_len = 0x6c00;
+#endif
+#ifdef ETHTOOL_GSTATS
+		info.n_stats = ETH_NUM_STATS;
+#endif
+		if (mm_copy_to_user(useraddr, &info, sizeof(info)))
+			return -EFAULT;
+		return 0;
+	}
+#endif
+        case ETHTOOL_GSET: {
+		if ((pDevice->TbiFlags & ENABLE_TBI_FLAG)||
+			(pDevice->PhyFlags & PHY_IS_FIBER)) {
+			ethcmd.supported =
+				(SUPPORTED_1000baseT_Full |
+				SUPPORTED_Autoneg);
+			ethcmd.supported |= SUPPORTED_FIBRE;
+			ethcmd.port = PORT_FIBRE;
+		} else {
+			ethcmd.supported =
+				(SUPPORTED_10baseT_Half |
+				SUPPORTED_10baseT_Full |
+				SUPPORTED_100baseT_Half |
+				SUPPORTED_100baseT_Full |
+				SUPPORTED_1000baseT_Half |
+				SUPPORTED_1000baseT_Full |
+				SUPPORTED_Autoneg);
+			ethcmd.supported |= SUPPORTED_TP;
+			ethcmd.port = PORT_TP;
+		}
+
+		ethcmd.transceiver = XCVR_INTERNAL;
+		ethcmd.phy_address = 0;
+
+		if (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS)
+			ethcmd.speed = SPEED_1000;
+		else if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS)
+			ethcmd.speed = SPEED_100;
+		else if (pDevice->LineSpeed == LM_LINE_SPEED_10MBPS)
+			ethcmd.speed = SPEED_10;
+		else
+			ethcmd.speed = 0;
+
+		if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL)
+			ethcmd.duplex = DUPLEX_FULL;
+		else
+			ethcmd.duplex = DUPLEX_HALF;
+
+		if (pDevice->DisableAutoNeg == FALSE) {
+			ethcmd.autoneg = AUTONEG_ENABLE;
+			ethcmd.advertising = ADVERTISED_Autoneg;
+			if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) ||
+				(pDevice->PhyFlags & PHY_IS_FIBER)) {
+				ethcmd.advertising |=
+					ADVERTISED_1000baseT_Full |
+					ADVERTISED_FIBRE;
+			}
+			else {
+				ethcmd.advertising |=
+					ADVERTISED_TP;
+				if (pDevice->advertising &
+					PHY_AN_AD_10BASET_HALF) {
+
+					ethcmd.advertising |=
+						ADVERTISED_10baseT_Half;
+				}
+				if (pDevice->advertising &
+					PHY_AN_AD_10BASET_FULL) {
+
+					ethcmd.advertising |=
+						ADVERTISED_10baseT_Full;
+				}
+				if (pDevice->advertising &
+					PHY_AN_AD_100BASETX_HALF) {
+
+					ethcmd.advertising |=
+						ADVERTISED_100baseT_Half;
+				}
+				if (pDevice->advertising &
+					PHY_AN_AD_100BASETX_FULL) {
+
+					ethcmd.advertising |=
+						ADVERTISED_100baseT_Full;
+				}
+				if (pDevice->advertising1000 &
+					BCM540X_AN_AD_1000BASET_HALF) {
+
+					ethcmd.advertising |=
+						ADVERTISED_1000baseT_Half;
+				}
+				if (pDevice->advertising1000 &
+					BCM540X_AN_AD_1000BASET_FULL) {
+
+					ethcmd.advertising |=
+						ADVERTISED_1000baseT_Full;
+				}
+			}
+		}
+		else {
+			ethcmd.autoneg = AUTONEG_DISABLE;
+			ethcmd.advertising = 0;
+		}
+
+		ethcmd.maxtxpkt = pDevice->TxMaxCoalescedFrames;
+		ethcmd.maxrxpkt = pDevice->RxMaxCoalescedFrames;
+
+		if(mm_copy_to_user(useraddr, &ethcmd, sizeof(ethcmd)))
+			return -EFAULT;
+		return 0;
+	}
+	case ETHTOOL_SSET: {
+		unsigned long flags;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (ethcmd.autoneg == AUTONEG_ENABLE) {
+			pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
+			pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_UNKNOWN;
+			pDevice->DisableAutoNeg = FALSE;
+		}
+		else {
+			if (ethcmd.speed == SPEED_1000 &&
+				pDevice->PhyFlags & PHY_NO_GIGABIT)
+					return -EINVAL;
+
+			if (ethcmd.speed == SPEED_1000 &&
+			    (pDevice->TbiFlags & ENABLE_TBI_FLAG ||
+			     pDevice->PhyFlags & PHY_IS_FIBER ) ) {
+
+				pDevice->RequestedLineSpeed =
+					LM_LINE_SPEED_1000MBPS;
+
+				pDevice->RequestedDuplexMode =
+					LM_DUPLEX_MODE_FULL;
+			}
+			else if (ethcmd.speed == SPEED_100 &&
+			        !(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
+			     	!(pDevice->PhyFlags & PHY_IS_FIBER)) {
+
+				pDevice->RequestedLineSpeed =
+					LM_LINE_SPEED_100MBPS;
+			}
+			else if (ethcmd.speed == SPEED_10  &&
+			        !(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
+			     	!(pDevice->PhyFlags & PHY_IS_FIBER)) {
+
+                                pDevice->RequestedLineSpeed =
+					LM_LINE_SPEED_10MBPS;
+			}
+			else {
+				return -EINVAL;
+			}
+
+			pDevice->DisableAutoNeg = TRUE;
+			if (ethcmd.duplex == DUPLEX_FULL) {
+				pDevice->RequestedDuplexMode =
+					LM_DUPLEX_MODE_FULL;
+			}
+			else {
+				if (!(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
+			     	    !(pDevice->PhyFlags & PHY_IS_FIBER)  ) {
+
+					pDevice->RequestedDuplexMode =
+							LM_DUPLEX_MODE_HALF;
+				}
+			}
+		}
+		if (netif_running(dev)) {
+			BCM5700_PHY_LOCK(pUmDevice, flags);
+			LM_SetupPhy(pDevice);
+			BCM5700_PHY_UNLOCK(pUmDevice, flags);
+		}
+		return 0;
+	}
+#ifdef ETHTOOL_GWOL
+#ifdef BCM_WOL
+	case ETHTOOL_GWOL: {
+		struct ethtool_wolinfo wol = {ETHTOOL_GWOL};
+
+		if (((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
+			!(pDevice->Flags & FIBER_WOL_CAPABLE_FLAG)) ||
+			(pDevice->Flags & DISABLE_D3HOT_FLAG)) {
+			wol.supported = 0;
+			wol.wolopts = 0;
+		}
+		else {
+			wol.supported = WAKE_MAGIC;
+			if (pDevice->WakeUpMode == LM_WAKE_UP_MODE_MAGIC_PACKET)
+			{
+				wol.wolopts = WAKE_MAGIC;
+			}
+			else {
+				wol.wolopts = 0;
+			}
+		}
+		if (mm_copy_to_user(useraddr, &wol, sizeof(wol)))
+			return -EFAULT;
+		return 0;
+	}
+	case ETHTOOL_SWOL: {
+		struct ethtool_wolinfo wol;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (mm_copy_from_user(&wol, useraddr, sizeof(wol)))
+			return -EFAULT;
+		if ((((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
+			!(pDevice->Flags & FIBER_WOL_CAPABLE_FLAG)) ||
+			(pDevice->Flags & DISABLE_D3HOT_FLAG)) &&
+			wol.wolopts) {
+			return -EINVAL;
+		}
+
+		if ((wol.wolopts & ~WAKE_MAGIC) != 0) {
+			return -EINVAL;
+		}
+		if (wol.wolopts & WAKE_MAGIC) {
+			pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_MAGIC_PACKET;
+			pDevice->WakeUpMode = LM_WAKE_UP_MODE_MAGIC_PACKET;
+		}
+		else {
+			pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_NONE;
+			pDevice->WakeUpMode = LM_WAKE_UP_MODE_NONE;
+		}
+		return 0;
+        }
+#endif
+#endif
+#ifdef ETHTOOL_GLINK
+	case ETHTOOL_GLINK: {
+		struct ethtool_value edata = {ETHTOOL_GLINK};
+
+		/* ifup only waits for 5 seconds for link up */
+		/* NIC may take more than 5 seconds to establish link */
+		if ((pUmDevice->delayed_link_ind > 0) &&
+			delay_link[pUmDevice->index])
+			return -EOPNOTSUPP;
+
+		if (pDevice->LinkStatus == LM_STATUS_LINK_ACTIVE) {
+			edata.data =  1;
+		}
+		else {
+			edata.data =  0;
+		}
+		if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
+			return -EFAULT;
+		return 0;
+	}
+#endif
+#ifdef ETHTOOL_NWAY_RST
+	case ETHTOOL_NWAY_RST: {
+		LM_UINT32 phyctrl;
+		unsigned long flags;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (pDevice->DisableAutoNeg) {
+			return -EINVAL;
+		}
+		if (!netif_running(dev))
+			return -EAGAIN;
+		BCM5700_PHY_LOCK(pUmDevice, flags);
+		if (pDevice->TbiFlags & ENABLE_TBI_FLAG) { 
+			pDevice->RequestedLineSpeed = LM_LINE_SPEED_1000MBPS;
+			pDevice->DisableAutoNeg = TRUE;
+			LM_SetupPhy(pDevice);
+
+			pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
+			pDevice->DisableAutoNeg = FALSE;
+			LM_SetupPhy(pDevice);
+		}
+		else {
+			if ((T3_ASIC_REV(pDevice->ChipRevId) ==
+					T3_ASIC_REV_5703) ||
+				(T3_ASIC_REV(pDevice->ChipRevId) ==
+					T3_ASIC_REV_5704) ||
+				(T3_ASIC_REV(pDevice->ChipRevId) ==
+					T3_ASIC_REV_5705))
+			{
+				LM_ResetPhy(pDevice);
+				LM_SetupPhy(pDevice);
+			}
+			pDevice->PhyFlags &= ~PHY_FIBER_FALLBACK;
+			LM_ReadPhy(pDevice, PHY_CTRL_REG, &phyctrl);
+			LM_WritePhy(pDevice, PHY_CTRL_REG, phyctrl |
+				PHY_CTRL_AUTO_NEG_ENABLE |
+				PHY_CTRL_RESTART_AUTO_NEG);
+		}
+		BCM5700_PHY_UNLOCK(pUmDevice, flags);
+		return 0;
+	}
+#endif
+#ifdef ETHTOOL_GEEPROM
+	case ETHTOOL_GEEPROM: {
+		struct ethtool_eeprom eeprom;
+		LM_UINT32 *buf = 0;
+		LM_UINT32 buf1[64/4];
+		int i, j, offset, len;
+
+		if (mm_copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
+			return -EFAULT;
+
+		if (eeprom.offset >= pDevice->NvramSize)
+			return -EFAULT;
+
+		/* maximum data limited */
+		/* to read more, call again with a different offset */
+		if (eeprom.len > 0x800) {
+			eeprom.len = 0x800;
+			if (mm_copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
+				return -EFAULT;
+		}
+
+		if (eeprom.len > 64) {
+			buf = kmalloc(eeprom.len, GFP_KERNEL);
+			if (!buf)
+				return -ENOMEM;
+		}
+		else {
+			buf = buf1;
+		}
+		useraddr += offsetof(struct ethtool_eeprom, data);
+
+		offset = eeprom.offset;
+		len = eeprom.len;
+		if (offset & 3) {
+			offset &= 0xfffffffc;
+			len += (offset & 3);
+		}
+		len = (len + 3) & 0xfffffffc;
+		for (i = 0, j = 0; j < len; i++, j += 4) {
+			if (LM_NvramRead(pDevice, offset + j, buf + i) !=
+				LM_STATUS_SUCCESS) {
+				break;
+			}
+		}
+		if (j >= len) {
+			buf += (eeprom.offset & 3);
+			i = mm_copy_to_user(useraddr, buf, eeprom.len);
+		}
+		if (eeprom.len > 64) {
+			kfree(buf);
+		}
+		if ((j < len) || i)
+			return -EFAULT;
+		return 0;
+	}
+	case ETHTOOL_SEEPROM: {
+		struct ethtool_eeprom eeprom;
+		LM_UINT32 buf[64/4];
+		int i, offset, len;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (mm_copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
+			return -EFAULT;
+
+		if ((eeprom.offset & 3) || (eeprom.len & 3) ||
+			(eeprom.offset >= pDevice->NvramSize)) {
+			return -EFAULT;
+		}
+
+		if ((eeprom.offset + eeprom.len) >= pDevice->NvramSize) {
+			eeprom.len = pDevice->NvramSize - eeprom.offset;
+		}
+
+		useraddr += offsetof(struct ethtool_eeprom, data);
+
+		len = eeprom.len;
+		offset = eeprom.offset;
+		for (; len > 0; ) {
+			if (len < 64)
+				i = len;
+			else
+				i = 64;
+			if (mm_copy_from_user(&buf, useraddr, i))
+				return -EFAULT;
+
+			bcm5700_intr_off(pUmDevice);
+			/* Prevent race condition on Grc.Mode register */
+			bcm5700_poll_wait(pUmDevice);
+
+			if (LM_NvramWriteBlock(pDevice, offset, buf, i/4) !=
+				LM_STATUS_SUCCESS) {
+				bcm5700_intr_on(pUmDevice);
+				return -EFAULT;
+			}
+			bcm5700_intr_on(pUmDevice);
+			len -= i;
+			offset += i;
+			useraddr += i;
+		}
+		return 0;
+	}
+#endif
+#ifdef ETHTOOL_GREGS
+#if (LINUX_VERSION_CODE >= 0x02040f)
+	case ETHTOOL_GREGS: {
+		struct ethtool_regs eregs;
+		LM_UINT32 *buf, *buf1;
+		unsigned int i;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (pDevice->Flags & UNDI_FIX_FLAG)
+			return -EOPNOTSUPP;
+		if (mm_copy_from_user(&eregs, useraddr, sizeof(eregs)))
+			return -EFAULT;
+		if (eregs.len > 0x6c00)
+			eregs.len = 0x6c00;
+		eregs.version = 0x0;
+		if (mm_copy_to_user(useraddr, &eregs, sizeof(eregs)))
+			return -EFAULT;
+		buf = buf1 = kmalloc(eregs.len, GFP_KERNEL);
+		if (!buf)
+			return -ENOMEM;
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0,      0xb0,   0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0xb0,   0x200,  1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x200,  0x8f0,  0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x8f0,  0xc00,  1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0xc00,  0xce0,  0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0xce0,  0x1000, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x1000, 0x1004, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x1004, 0x1400, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x1400, 0x1480, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x1480, 0x1800, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x1800, 0x1848, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x1848, 0x1c00, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x1c00, 0x1c04, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x1c04, 0x2000, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x2000, 0x225c, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x225c, 0x2400, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x2400, 0x24c4, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x24c4, 0x2800, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x2800, 0x2804, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x2804, 0x2c00, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x2c00, 0x2c20, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x2c20, 0x3000, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x3000, 0x3014, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x3014, 0x3400, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x3400, 0x3408, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x3408, 0x3800, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x3800, 0x3808, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x3808, 0x3c00, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x3c00, 0x3d00, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x3d00, 0x4000, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x4000, 0x4010, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x4010, 0x4400, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x4400, 0x4458, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x4458, 0x4800, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x4800, 0x4808, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x4808, 0x4c00, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x4c00, 0x4c08, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x4c08, 0x5000, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x5000, 0x5050, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x5050, 0x5400, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x5400, 0x5450, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x5450, 0x5800, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x5800, 0x5a10, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x5a10, 0x6000, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x6000, 0x600c, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x600c, 0x6400, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x6400, 0x6404, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x6404, 0x6800, 1);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x6800, 0x6848, 0);
+		bcm5700_get_reg_blk(pUmDevice, &buf, 0x6848, 0x6c00, 1);
+
+		i = mm_copy_to_user(useraddr + sizeof(eregs), buf1, eregs.len);
+		kfree(buf1);
+		if (i)
+			return -EFAULT;
+		return 0;
+	}
+#endif
+#endif
+#ifdef ETHTOOL_GPAUSEPARAM
+	case ETHTOOL_GPAUSEPARAM: {
+		struct ethtool_pauseparam epause = { ETHTOOL_GPAUSEPARAM };
+
+		if (!pDevice->DisableAutoNeg) {
+			epause.autoneg = (pDevice->FlowControlCap &
+				LM_FLOW_CONTROL_AUTO_PAUSE) != 0;
+		}
+		else {
+			epause.autoneg = 0;
+		}
+		epause.rx_pause =
+			(pDevice->FlowControl &
+			LM_FLOW_CONTROL_RECEIVE_PAUSE) != 0;
+		epause.tx_pause =
+			(pDevice->FlowControl &
+			LM_FLOW_CONTROL_TRANSMIT_PAUSE) != 0;
+		if (mm_copy_to_user(useraddr, &epause, sizeof(epause)))
+			return -EFAULT;
+
+		return 0;
+	}
+	case ETHTOOL_SPAUSEPARAM: {
+		struct ethtool_pauseparam epause;
+		unsigned long flags;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (mm_copy_from_user(&epause, useraddr, sizeof(epause)))
+			return -EFAULT;
+		pDevice->FlowControlCap = 0;
+		if (epause.autoneg && !pDevice->DisableAutoNeg) {
+			pDevice->FlowControlCap |= LM_FLOW_CONTROL_AUTO_PAUSE;
+		}
+		if (epause.rx_pause)  {
+			pDevice->FlowControlCap |=
+				LM_FLOW_CONTROL_RECEIVE_PAUSE;
+		}
+		if (epause.tx_pause)  {
+			pDevice->FlowControlCap |=
+				LM_FLOW_CONTROL_TRANSMIT_PAUSE;
+		}
+		if (netif_running(dev)) {
+			BCM5700_PHY_LOCK(pUmDevice, flags);
+			LM_SetupPhy(pDevice);
+			BCM5700_PHY_UNLOCK(pUmDevice, flags);
+		}
+
+		return 0;
+	}
+#endif
+#ifdef ETHTOOL_GRXCSUM
+	case ETHTOOL_GRXCSUM: {
+		struct ethtool_value edata = { ETHTOOL_GRXCSUM };
+
+		edata.data =
+			(pDevice->TaskToOffload &
+			LM_TASK_OFFLOAD_RX_TCP_CHECKSUM) != 0;
+		if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
+			return -EFAULT;
+
+		return 0;
+	}
+	case ETHTOOL_SRXCSUM: {
+		struct ethtool_value edata;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
+			return -EFAULT;
+		if (edata.data) {
+			if (!(pDevice->TaskOffloadCap &
+				LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
+
+				return -EINVAL;
+			}
+			pDevice->TaskToOffload |=
+				LM_TASK_OFFLOAD_RX_TCP_CHECKSUM |
+				LM_TASK_OFFLOAD_RX_UDP_CHECKSUM;
+		}
+		else {
+			pDevice->TaskToOffload &=
+				~(LM_TASK_OFFLOAD_RX_TCP_CHECKSUM |
+				LM_TASK_OFFLOAD_RX_UDP_CHECKSUM);
+		}
+		return 0;
+	}
+	case ETHTOOL_GTXCSUM: {
+		struct ethtool_value edata = { ETHTOOL_GTXCSUM };
+
+		edata.data =
+			(dev->features & get_csum_flag( pDevice->ChipRevId)) != 0;
+		if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
+			return -EFAULT;
+
+		return 0;
+	}
+	case ETHTOOL_STXCSUM: {
+		struct ethtool_value edata;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
+			return -EFAULT;
+		if (edata.data) {
+			if (!(pDevice->TaskOffloadCap &
+				LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
+
+				return -EINVAL;
+			}
+			dev->features |= get_csum_flag( pDevice->ChipRevId);
+			pDevice->TaskToOffload |=
+				LM_TASK_OFFLOAD_TX_TCP_CHECKSUM |
+				LM_TASK_OFFLOAD_TX_UDP_CHECKSUM;
+		}
+		else {
+			dev->features &= ~get_csum_flag( pDevice->ChipRevId);
+			pDevice->TaskToOffload &=
+				~(LM_TASK_OFFLOAD_TX_TCP_CHECKSUM |
+				LM_TASK_OFFLOAD_TX_UDP_CHECKSUM);
+		}
+		return 0;
+	}
+	case ETHTOOL_GSG: {
+		struct ethtool_value edata = { ETHTOOL_GSG };
+
+		edata.data =
+			(dev->features & NETIF_F_SG) != 0;
+		if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
+			return -EFAULT;
+		return 0;
+	}
+	case ETHTOOL_SSG: {
+		struct ethtool_value edata;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
+			return -EFAULT;
+		if (edata.data) {
+			dev->features |= NETIF_F_SG;
+		}
+		else {
+			dev->features &= ~NETIF_F_SG;
+		}
+		return 0;
+	}
+#endif
+#ifdef ETHTOOL_GRINGPARAM
+	case ETHTOOL_GRINGPARAM: {
+		struct ethtool_ringparam ering = { ETHTOOL_GRINGPARAM };
+
+		ering.rx_max_pending = T3_STD_RCV_RCB_ENTRY_COUNT - 1;
+		ering.rx_pending = pDevice->RxStdDescCnt;
+		ering.rx_mini_max_pending = 0;
+		ering.rx_mini_pending = 0;
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+		ering.rx_jumbo_max_pending = T3_JUMBO_RCV_RCB_ENTRY_COUNT - 1;
+		ering.rx_jumbo_pending = pDevice->RxJumboDescCnt;
+#else
+		ering.rx_jumbo_max_pending = 0;
+		ering.rx_jumbo_pending = 0;
+#endif
+		ering.tx_max_pending = MAX_TX_PACKET_DESC_COUNT - 1;
+		ering.tx_pending = pDevice->TxPacketDescCnt;
+		if (mm_copy_to_user(useraddr, &ering, sizeof(ering)))
+			return -EFAULT;
+		return 0;
+	}
+#endif
+#ifdef ETHTOOL_PHYS_ID
+	case ETHTOOL_PHYS_ID: {
+		struct ethtool_value edata;
+
+		if(!capable(CAP_NET_ADMIN))
+			return -EPERM;
+		if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
+			return -EFAULT;
+		if (LM_BlinkLED(pDevice, edata.data) == LM_STATUS_SUCCESS)
+			return 0;
+		return -EINTR;
+	}
+#endif
+#ifdef ETHTOOL_GSTRINGS
+	case ETHTOOL_GSTRINGS: {
+		struct ethtool_gstrings egstr = { ETHTOOL_GSTRINGS };
+
+		if (mm_copy_from_user(&egstr, useraddr, sizeof(egstr)))
+			return -EFAULT;
+		switch(egstr.string_set) {
+#ifdef ETHTOOL_GSTATS
+		case ETH_SS_STATS:
+			egstr.len = ETH_NUM_STATS;
+			if (mm_copy_to_user(useraddr, &egstr, sizeof(egstr)))
+				return -EFAULT;
+			if (mm_copy_to_user(useraddr + sizeof(egstr),
+				bcm5700_stats_str_arr,
+				sizeof(bcm5700_stats_str_arr)))
+				return -EFAULT;
+			return 0;
+#endif
+		default:
+			return -EOPNOTSUPP;
+		}
+		}
+#endif
+#ifdef ETHTOOL_GSTATS
+	case ETHTOOL_GSTATS: {
+		struct ethtool_stats estats = { ETHTOOL_GSTATS };
+		uint64_t stats[ETH_NUM_STATS];
+		int i;
+		uint64_t *pStats =
+			(uint64_t *) pDevice->pStatsBlkVirt;
+
+		estats.n_stats = ETH_NUM_STATS;
+		if (pStats == 0) {
+			memset(stats, 0, sizeof(stats));
+		}
+		else {
+
+			for (i = 0; i < ETH_NUM_STATS; i++) {
+				if (bcm5700_stats_offset_arr[i] != 0) {
+					stats[i] = SWAP_DWORD_64(*(pStats +
+						bcm5700_stats_offset_arr[i]));
+				}
+				else if (i == RX_CRC_IDX) {
+					stats[i] =
+						bcm5700_crc_count(pUmDevice);
+				}
+				else if (i == RX_MAC_ERR_IDX) {
+					stats[i] =
+						bcm5700_rx_err_count(pUmDevice);
+				}
+			}
+		}
+		if (mm_copy_to_user(useraddr, &estats, sizeof(estats))) {
+			return -EFAULT;
+		}
+		if (mm_copy_to_user(useraddr + sizeof(estats), &stats,
+			sizeof(stats))) {
+			return -EFAULT;
+		}
+		return 0;
+	}
+#endif
+#ifdef ETHTOOL_GTSO
+	case ETHTOOL_GTSO: {
+		struct ethtool_value edata = { ETHTOOL_GTSO };
+
+#ifdef BCM_TSO
+		edata.data =
+			(dev->features & NETIF_F_TSO) != 0;
+#else
+		edata.data = 0;
+#endif
+		if (mm_copy_to_user(useraddr, &edata, sizeof(edata)))
+			return -EFAULT;
+		return 0;
+	}
+#endif
+#ifdef ETHTOOL_STSO
+	case ETHTOOL_STSO: {
+#ifdef BCM_TSO
+		struct ethtool_value edata;
+
+		if (!capable(CAP_NET_ADMIN))
+			return -EPERM;
+
+		if (mm_copy_from_user(&edata, useraddr, sizeof(edata)))
+			return -EFAULT;
+
+		if (!(pDevice->TaskToOffload &
+			LM_TASK_OFFLOAD_TCP_SEGMENTATION)) {
+			return -EINVAL;
+		}
+
+		dev->features &= ~NETIF_F_TSO;
+
+		if (edata.data) {
+			if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
+			   (dev->mtu > 1500)) {
+				printk(KERN_ALERT "%s: Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
+			return -EINVAL;
+			} else {
+				dev->features |= NETIF_F_TSO;
+			}
+	        }
+		return 0;
+#else
+		return -EINVAL;
+#endif
+	}
+#endif
+	}
+
+	return -EOPNOTSUPP;
+}
+#endif /* #ifdef SIOCETHTOOL */
+
+#if (LINUX_VERSION_CODE >= 0x20400) && (LINUX_VERSION_CODE < 0x20600)
+#include <linux/iobuf.h>
+#endif
+
+/* Provide ioctl() calls to examine the MII xcvr state. */
+STATIC int bcm5700_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	u16 *data = (u16 *)&rq->ifr_data;
+	u32 value = 0;
+	u16 page_num =0, addr_num =0, len =0;
+	unsigned long flags;
+
+	switch(cmd) {
+	case SIOCGREG_STATUS: //Get register
+	{
+		struct reg_ioctl_data *rdata =(struct reg_ioctl_data *)rq->ifr_data;
+                robo_info_t *robo = (robo_info_t *)pUmDevice->robo;
+		page_num = rdata->page_num;
+		addr_num = rdata->addr_num;
+		len = rdata->len;
+                printk("b57um SIOCGREG_STATUS cmd page[0x%x]addr[0x%x]len[%d].\n",page_num,addr_num,len);
+		if (len == 6)
+		{
+			ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
+			printk("val[0x%04x-0x%04x-0x%04x].\n",rdata->val_out[0],rdata->val_out[1],rdata->val_out[2]);
+		}
+		else if (len == 8)
+		{
+			ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
+                        printk("val[0x%04x%04x-0x%04x%04x].\n",rdata->val_out[0],rdata->val_out[1],
+				rdata->val_out[2],rdata->val_out[3]);
+		}
+		else if (len == 4) 
+		{
+			ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
+                        printk("val[0x%04x%04x].\n",rdata->val_out[0],rdata->val_out[1]);
+		}
+		else 
+		{
+                        ReadDataFromRegister(robo,page_num,addr_num,len,(void *)&rdata->val_out);
+                        printk("val[0x%04x].\n",rdata->val_out[0]);
+
+		}
+                if (mm_copy_to_user(rq->ifr_data, rdata, sizeof(struct reg_ioctl_data)))
+		{
+			printk("Fail mm_copy_to_user.\n");
+                        return -EFAULT;
+		}
+                return 0;
+	}
+	break;
+	case SIOCSREG_STATUS://Set register
+	{
+                struct reg_ioctl_data * wdata =(struct reg_ioctl_data *)rq->ifr_data;
+		len = wdata->len;
+		page_num = wdata->page_num;
+		addr_num = wdata->addr_num;
+                robo_info_t *robo = (robo_info_t *)pUmDevice->robo;
+                if (len == 6)
+                {
+                        WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
+                        //printk("val[0x%04x-0x%04x-0x%04x].\n",val48[0],val48[1],val48[2]);
+                }
+                else if (len == 8)
+                {
+                        WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
+                        //printk("val[0x%04x-0x%04x-0x%04x-0x%04x].\n",val64[0],val64[1],val64[2],val64[3]);
+                }
+                else if (len == 4)
+                {
+                        WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
+                        //printk("val[0x%08x].\n",value);
+                }
+		else
+		{
+                        WriteDataToRegister(robo,page_num,addr_num,len,(void *)&wdata->val_in);
+                        //printk("len[%d] val[0x%04x].\n",len,val16);
+		}
+
+                return 0;
+	}
+	break;
+#ifdef SIOCGMIIPHY
+	case SIOCGMIIPHY:		/* Get the address of the PHY in use. */
+
+		data[0] = pDevice->PhyAddr;
+		return 0;
+#endif
+
+#ifdef SIOCGMIIREG
+	case SIOCGMIIREG:		/* Read the specified MII register. */
+	{
+		uint32 savephyaddr = 0;
+
+		if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
+			return -EOPNOTSUPP;
+
+		/* ifup only waits for 5 seconds for link up */
+		/* NIC may take more than 5 seconds to establish link */
+		if ((pUmDevice->delayed_link_ind > 0) &&
+			delay_link[pUmDevice->index]) {
+			return -EAGAIN;
+		}
+
+		BCM5700_PHY_LOCK(pUmDevice, flags);
+		if (data[0] != 0xffff) {
+			savephyaddr = pDevice->PhyAddr;
+			pDevice->PhyAddr = data[0];
+		}
+		LM_ReadPhy(pDevice, data[1] & 0x1f, (LM_UINT32 *)&value);
+		if (data[0] != 0xffff)
+			pDevice->PhyAddr = savephyaddr;
+		BCM5700_PHY_UNLOCK(pUmDevice, flags);
+		data[3] = value & 0xffff;
+		return 0;
+	}
+#endif
+
+#ifdef SIOCSMIIREG
+	case SIOCSMIIREG:		/* Write the specified MII register */
+	{
+		uint32 savephyaddr = 0;
+
+		if (!capable(CAP_NET_ADMIN))
+			return -EPERM;
+
+		if (pDevice->TbiFlags & ENABLE_TBI_FLAG)
+			return -EOPNOTSUPP;
+
+		BCM5700_PHY_LOCK(pUmDevice, flags);
+		if (data[0] != 0xffff) {
+			savephyaddr = pDevice->PhyAddr;
+			pDevice->PhyAddr = data[0];
+		}
+		LM_WritePhy(pDevice, data[1] & 0x1f, data[2]);
+		if (data[0] != 0xffff)
+			pDevice->PhyAddr = savephyaddr;
+		BCM5700_PHY_UNLOCK(pUmDevice, flags);
+		data[3] = 0;
+		return 0;
+	}
+#endif
+
+#ifdef SIOCETHTOOL
+	case SIOCETHTOOL:
+		return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
+#endif
+	default:
+		return -EOPNOTSUPP;
+	}
+	return -EOPNOTSUPP;
+}
+
+STATIC void bcm5700_do_rx_mode(struct net_device *dev)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	int i;
+	struct dev_mc_list *mclist;
+
+	LM_MulticastClear(pDevice);
+	for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
+			 i++, mclist = mclist->next) {
+		LM_MulticastAdd(pDevice, (PLM_UINT8) &mclist->dmi_addr);
+	}
+	if (dev->flags & IFF_ALLMULTI) {
+		if (!(pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST)) {
+			LM_SetReceiveMask(pDevice,
+				pDevice->ReceiveMask | LM_ACCEPT_ALL_MULTICAST);
+		}
+	}
+	else if (pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST) {
+		LM_SetReceiveMask(pDevice,
+			pDevice->ReceiveMask & ~LM_ACCEPT_ALL_MULTICAST);
+	}
+	if (dev->flags & IFF_PROMISC) {
+		if (!(pDevice->ReceiveMask & LM_PROMISCUOUS_MODE)) {
+			LM_SetReceiveMask(pDevice,
+				pDevice->ReceiveMask | LM_PROMISCUOUS_MODE);
+		}
+	}
+	else if (pDevice->ReceiveMask & LM_PROMISCUOUS_MODE) {
+		LM_SetReceiveMask(pDevice,
+			pDevice->ReceiveMask & ~LM_PROMISCUOUS_MODE);
+	}
+
+}
+
+STATIC void bcm5700_set_rx_mode(struct net_device *dev)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	int i;
+	struct dev_mc_list *mclist;
+	unsigned long flags;
+
+	BCM5700_PHY_LOCK(pUmDevice, flags);
+
+	LM_MulticastClear(pDevice);
+	for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
+			 i++, mclist = mclist->next) {
+		LM_MulticastAdd(pDevice, (PLM_UINT8) &mclist->dmi_addr);
+	}
+	if (dev->flags & IFF_ALLMULTI) {
+		if (!(pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST)) {
+			LM_SetReceiveMask(pDevice,
+				pDevice->ReceiveMask | LM_ACCEPT_ALL_MULTICAST);
+		}
+	}
+	else if (pDevice->ReceiveMask & LM_ACCEPT_ALL_MULTICAST) {
+		LM_SetReceiveMask(pDevice,
+			pDevice->ReceiveMask & ~LM_ACCEPT_ALL_MULTICAST);
+	}
+	if (dev->flags & IFF_PROMISC) {
+		if (!(pDevice->ReceiveMask & LM_PROMISCUOUS_MODE)) {
+			LM_SetReceiveMask(pDevice,
+				pDevice->ReceiveMask | LM_PROMISCUOUS_MODE);
+		}
+	}
+	else if (pDevice->ReceiveMask & LM_PROMISCUOUS_MODE) {
+		LM_SetReceiveMask(pDevice,
+			pDevice->ReceiveMask & ~LM_PROMISCUOUS_MODE);
+	}
+
+	BCM5700_PHY_UNLOCK(pUmDevice, flags);
+}
+
+/*
+ * Set the hardware MAC address.
+ */
+STATIC int bcm5700_set_mac_addr(struct net_device *dev, void *p)
+{
+	struct sockaddr *addr=p;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) dev->priv;
+	UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
+
+	if(is_valid_ether_addr(addr->sa_data)){
+
+	    memcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
+	    if (pUmDevice->opened)
+	        LM_SetMacAddress(pDevice, dev->dev_addr);
+			bcm_robo_set_macaddr(pUmDevice->robo, dev->dev_addr);
+            return 0;
+        }
+	return -EINVAL;
+}
+
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+STATIC int bcm5700_change_mtu(struct net_device *dev, int new_mtu)
+{
+	int pkt_size = new_mtu + ETHERNET_PACKET_HEADER_SIZE;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK)dev->priv;
+	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
+	unsigned long flags;
+	int reinit = 0;
+
+	if ((pkt_size < MIN_ETHERNET_PACKET_SIZE_NO_CRC) ||
+		(pkt_size > MAX_ETHERNET_JUMBO_PACKET_SIZE_NO_CRC)) {
+
+		return -EINVAL;
+	}
+	if ( !(pDevice->Flags & JUMBO_CAPABLE_FLAG)    &&
+		(pkt_size > MAX_ETHERNET_PACKET_SIZE_NO_CRC) ) {
+
+		return -EINVAL;
+	}
+	if (pUmDevice->suspended)
+		return -EAGAIN;
+
+	if (pUmDevice->opened && (new_mtu != dev->mtu) &&
+		(pDevice->Flags & JUMBO_CAPABLE_FLAG)) {
+		reinit = 1;
+	}
+
+	BCM5700_PHY_LOCK(pUmDevice, flags);
+	if (reinit) {
+		netif_stop_queue(dev);
+		bcm5700_shutdown(pUmDevice);
+		bcm5700_freemem(dev);
+	}
+
+	dev->mtu = new_mtu;
+	if (pkt_size < MAX_ETHERNET_PACKET_SIZE_NO_CRC) {
+		pDevice->RxMtu = pDevice->TxMtu =
+			MAX_ETHERNET_PACKET_SIZE_NO_CRC;
+	}
+	else {
+		pDevice->RxMtu = pDevice->TxMtu = pkt_size;
+	}
+
+	if (dev->mtu <= 1514)  {
+		pDevice->RxJumboDescCnt = 0;
+	}
+	else if (pDevice->Flags & JUMBO_CAPABLE_FLAG){
+		pDevice->RxJumboDescCnt =
+			rx_jumbo_desc_cnt[pUmDevice->index];
+	}
+	pDevice->RxPacketDescCnt = pDevice->RxJumboDescCnt +
+		pDevice->RxStdDescCnt;
+
+	pDevice->RxJumboBufferSize = (pDevice->RxMtu + 8 /* CRC + VLAN */ +
+		COMMON_CACHE_LINE_SIZE-1) & ~COMMON_CACHE_LINE_MASK;
+
+#ifdef BCM_TSO
+	if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
+	   (dev->mtu > 1514) ) {
+		if (dev->features & NETIF_F_TSO) {
+			dev->features &= ~NETIF_F_TSO;
+			printk(KERN_ALERT "%s: TSO previously enabled. Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
+		}
+	}
+#endif
+
+	if (reinit) {
+		LM_InitializeAdapter(pDevice);
+		bcm5700_do_rx_mode(dev);
+		bcm5700_set_vlan_mode(pUmDevice);
+		bcm5700_init_counters(pUmDevice);
+		if (memcmp(dev->dev_addr, pDevice->NodeAddress, 6)) {
+			LM_SetMacAddress(pDevice, dev->dev_addr);
+		}
+		netif_start_queue(dev);
+		bcm5700_intr_on(pUmDevice);
+	}
+	BCM5700_PHY_UNLOCK(pUmDevice, flags);
+
+	return 0;
+}
+#endif
+
+
+#if (LINUX_VERSION_CODE < 0x020300)
+int
+bcm5700_probe(struct net_device *dev)
+{
+	int cards_found = 0;
+	struct pci_dev *pdev = NULL;
+	struct pci_device_id *pci_tbl;
+	u16 ssvid, ssid;
+
+	if ( ! pci_present())
+		return -ENODEV;
+
+	pci_tbl = bcm5700_pci_tbl;
+	while ((pdev = pci_find_class(PCI_CLASS_NETWORK_ETHERNET << 8, pdev))) {
+		int idx;
+
+		pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &ssvid);
+		pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &ssid);
+		for (idx = 0; pci_tbl[idx].vendor; idx++) {
+			if ((pci_tbl[idx].vendor == PCI_ANY_ID ||
+				pci_tbl[idx].vendor == pdev->vendor) &&
+				(pci_tbl[idx].device == PCI_ANY_ID ||
+				pci_tbl[idx].device == pdev->device) &&
+				(pci_tbl[idx].subvendor == PCI_ANY_ID ||
+				pci_tbl[idx].subvendor == ssvid) &&
+				(pci_tbl[idx].subdevice == PCI_ANY_ID ||
+				pci_tbl[idx].subdevice == ssid))
+			{
+
+				break;
+			}
+		}
+		if (pci_tbl[idx].vendor == 0)
+			continue;
+
+
+		if (bcm5700_init_one(pdev, &pci_tbl[idx]) == 0)
+			cards_found++;
+	}
+
+	return cards_found ? 0 : -ENODEV;
+}
+
+#ifdef MODULE
+int init_module(void)
+{
+	return bcm5700_probe(NULL);
+}
+
+void cleanup_module(void)
+{
+	struct net_device *next_dev;
+	PUM_DEVICE_BLOCK pUmDevice;
+
+	/* No need to check MOD_IN_USE, as sys_delete_module() checks. */
+	while (root_tigon3_dev) {
+		pUmDevice = (PUM_DEVICE_BLOCK)root_tigon3_dev->priv;
+		next_dev = pUmDevice->next_module;
+		unregister_netdev(root_tigon3_dev);
+		if (pUmDevice->lm_dev.pMappedMemBase)
+			iounmap(pUmDevice->lm_dev.pMappedMemBase);
+#if (LINUX_VERSION_CODE < 0x020600)
+		kfree(root_tigon3_dev);
+#else
+		free_netdev(root_tigon3_dev);
+#endif
+		root_tigon3_dev = next_dev;
+	}
+#ifdef BCM_IOCTL32
+	unregister_ioctl32_conversion(SIOCNICE);
+#endif
+}
+
+#endif  /* MODULE */
+#else	/* LINUX_VERSION_CODE < 0x020300 */
+
+#if (LINUX_VERSION_CODE >= 0x020406)
+static int bcm5700_suspend (struct pci_dev *pdev, u32 state)
+#else
+static void bcm5700_suspend (struct pci_dev *pdev)
+#endif
+{
+	struct net_device *dev = (struct net_device *) pci_get_drvdata(pdev);
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
+	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
+
+	if (!netif_running(dev))
+#if (LINUX_VERSION_CODE >= 0x020406)
+		return 0;
+#else
+		return;
+#endif
+
+	netif_device_detach (dev);
+	bcm5700_shutdown(pUmDevice);
+
+	LM_SetPowerState(pDevice, LM_POWER_STATE_D3);
+
+/*	pci_power_off(pdev, -1);*/
+#if (LINUX_VERSION_CODE >= 0x020406)
+	return 0;
+#endif
+}
+
+
+#if (LINUX_VERSION_CODE >= 0x020406)
+static int bcm5700_resume(struct pci_dev *pdev)
+#else
+static void bcm5700_resume(struct pci_dev *pdev)
+#endif
+{
+	struct net_device *dev = (struct net_device *) pci_get_drvdata(pdev);
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) dev->priv;
+	PLM_DEVICE_BLOCK pDevice = &pUmDevice->lm_dev;
+
+	if (!netif_running(dev))
+#if (LINUX_VERSION_CODE >= 0x020406)
+		return 0;
+#else
+		return;
+#endif
+/*	pci_power_on(pdev);*/
+	netif_device_attach(dev);
+	LM_SetPowerState(pDevice, LM_POWER_STATE_D0);
+	MM_InitializeUmPackets(pDevice);
+	bcm5700_reset(dev);
+#if (LINUX_VERSION_CODE >= 0x020406)
+	return 0;
+#endif
+}
+
+
+static struct pci_driver bcm5700_pci_driver = {
+	name:		bcm5700_driver,
+	id_table:	bcm5700_pci_tbl,
+	probe:		bcm5700_init_one,
+	remove:		__devexit_p(bcm5700_remove_one),
+	suspend:	bcm5700_suspend,
+	resume:		bcm5700_resume,
+};
+
+static int
+bcm5700_notify_reboot(struct notifier_block *this, unsigned long event, void *unused)
+{
+	switch (event) {
+	case SYS_HALT:
+	case SYS_POWER_OFF:
+	case SYS_RESTART:
+		break;
+	default:
+		return NOTIFY_DONE;
+	}
+
+	B57_INFO(("bcm5700 reboot notification\n"));
+	pci_unregister_driver(&bcm5700_pci_driver);
+	return NOTIFY_DONE;
+}
+
+static int __init bcm5700_init_module (void)
+{
+	int pin = 1 << 2;
+
+	if (nvram_match("disabled_5397", "1") || (activate_gpio != -1)) {
+		if ( activate_gpio != -1 ) pin = activate_gpio;
+		printk("5397 switch GPIO-Reset (pin %d)\n", pin);
+		sb_t *gpio_sbh;
+		if (!(gpio_sbh = sb_kattach(SB_OSH))) return -ENODEV;
+		sb_gpiosetcore(gpio_sbh);
+//		sb_gpioreserve(gpio_sbh, 0x4, GPIO_HI_PRIORITY);
+		sb_gpioouten(gpio_sbh, 0x4, 0x4, GPIO_HI_PRIORITY);
+		sb_gpioout(gpio_sbh, 0x4, 0x4, GPIO_HI_PRIORITY);
+		sb_detach(gpio_sbh);
+	}
+
+	if (msglevel != 0xdeadbeef) {
+		b57_msg_level = msglevel;
+		printf("%s: msglevel set to 0x%x\n", __FUNCTION__, b57_msg_level);
+	} else
+		b57_msg_level = B57_ERR_VAL;
+
+	return pci_module_init(&bcm5700_pci_driver);
+}
+
+static void __exit bcm5700_cleanup_module (void)
+{
+	unregister_reboot_notifier(&bcm5700_reboot_notifier);
+	pci_unregister_driver(&bcm5700_pci_driver);
+}
+
+module_init(bcm5700_init_module);
+module_exit(bcm5700_cleanup_module);
+#endif
+
+/*
+ * Middle Module
+ *
+ */
+
+
+#ifdef BCM_NAPI_RXPOLL
+LM_STATUS
+MM_ScheduleRxPoll(LM_DEVICE_BLOCK *pDevice)
+{
+	struct net_device *dev = ((UM_DEVICE_BLOCK *) pDevice)->dev;
+
+	if (netif_rx_schedule_prep(dev)) {
+		__netif_rx_schedule(dev);
+		return LM_STATUS_SUCCESS;
+	}
+	return LM_STATUS_FAILURE;
+}
+#endif
+
+LM_STATUS
+MM_ReadConfig16(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
+	LM_UINT16 *pValue16)
+{
+	UM_DEVICE_BLOCK *pUmDevice;
+
+	pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
+	pci_read_config_word(pUmDevice->pdev, Offset, (u16 *) pValue16);
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_ReadConfig32(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
+	LM_UINT32 *pValue32)
+{
+	UM_DEVICE_BLOCK *pUmDevice;
+
+	pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
+	pci_read_config_dword(pUmDevice->pdev, Offset, (u32 *) pValue32);
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_WriteConfig16(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
+	LM_UINT16 Value16)
+{
+	UM_DEVICE_BLOCK *pUmDevice;
+
+	pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
+	pci_write_config_word(pUmDevice->pdev, Offset, Value16);
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_WriteConfig32(PLM_DEVICE_BLOCK pDevice, LM_UINT32 Offset,
+	LM_UINT32 Value32)
+{
+	UM_DEVICE_BLOCK *pUmDevice;
+
+	pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
+	pci_write_config_dword(pUmDevice->pdev, Offset, Value32);
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_AllocateSharedMemory(PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize,
+	PLM_VOID *pMemoryBlockVirt, PLM_PHYSICAL_ADDRESS pMemoryBlockPhy,
+	LM_BOOL Cached)
+{
+	PLM_VOID pvirt;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+	dma_addr_t mapping;
+
+	pvirt = pci_alloc_consistent(pUmDevice->pdev, BlockSize,
+					       &mapping);
+	if (!pvirt) {
+		return LM_STATUS_FAILURE;
+	}
+	pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt;
+	pUmDevice->dma_list[pUmDevice->mem_list_num] = mapping;
+	pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = BlockSize;
+	memset(pvirt, 0, BlockSize);
+	*pMemoryBlockVirt = (PLM_VOID) pvirt;
+	MM_SetAddr(pMemoryBlockPhy, mapping);
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_AllocateMemory(PLM_DEVICE_BLOCK pDevice, LM_UINT32 BlockSize,
+	PLM_VOID *pMemoryBlockVirt)
+{
+	PLM_VOID pvirt;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+
+
+	/* Maximum in slab.c */
+	if (BlockSize > 131072) {
+		goto MM_Alloc_error;
+	}
+
+	pvirt = kmalloc(BlockSize, GFP_ATOMIC);
+	if (!pvirt) {
+		goto MM_Alloc_error;
+	}
+	pUmDevice->mem_list[pUmDevice->mem_list_num] = pvirt;
+	pUmDevice->dma_list[pUmDevice->mem_list_num] = 0;
+	pUmDevice->mem_size_list[pUmDevice->mem_list_num++] = 0;
+	/* mem_size_list[i] == 0 indicates that the memory should be freed */
+	/* using kfree */
+	memset(pvirt, 0, BlockSize);
+	*pMemoryBlockVirt = pvirt;
+	return LM_STATUS_SUCCESS;
+
+MM_Alloc_error:
+	printk(KERN_WARNING "%s: Memory allocation failed - buffer parameters may be set too high\n", pUmDevice->dev->name);
+	return LM_STATUS_FAILURE;
+}
+
+LM_STATUS
+MM_MapMemBase(PLM_DEVICE_BLOCK pDevice)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+
+	pDevice->pMappedMemBase = ioremap_nocache(
+		pci_resource_start(pUmDevice->pdev, 0), sizeof(T3_STD_MEM_MAP));
+	if (pDevice->pMappedMemBase == 0)
+		return LM_STATUS_FAILURE;
+
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_InitializeUmPackets(PLM_DEVICE_BLOCK pDevice)
+{
+	unsigned int i;
+	struct sk_buff *skb;
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+	PUM_PACKET pUmPacket;
+	PLM_PACKET pPacket;
+
+	for (i = 0; i < pDevice->RxPacketDescCnt; i++) {
+		pPacket = QQ_PopHead(&pDevice->RxPacketFreeQ.Container);
+		pUmPacket = (PUM_PACKET) pPacket;
+		if (pPacket == 0) {
+			printk(KERN_DEBUG "Bad RxPacketFreeQ\n");
+		}
+		if (pUmPacket->skbuff == 0) {
+#ifdef BCM_WL_EMULATOR
+			skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2);
+#else
+			skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR);
+#endif
+			if (skb == 0) {
+				pUmPacket->skbuff = 0;
+				QQ_PushTail(
+					&pUmDevice->rx_out_of_buf_q.Container,
+					pPacket);
+				continue;
+			}
+			pUmPacket->skbuff = skb;
+			skb->dev = pUmDevice->dev;
+#ifndef BCM_WL_EMULATOR
+			skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
+#endif
+		}
+		QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
+	}
+	if (T3_ASIC_REV(pUmDevice->lm_dev.ChipRevId) == T3_ASIC_REV_5700) {
+		/* reallocate buffers in the ISR */
+		pUmDevice->rx_buf_repl_thresh = 0;
+		pUmDevice->rx_buf_repl_panic_thresh = 0;
+		pUmDevice->rx_buf_repl_isr_limit = 0;
+	}
+	else {
+		pUmDevice->rx_buf_repl_thresh = pDevice->RxPacketDescCnt / 8;
+		pUmDevice->rx_buf_repl_panic_thresh =
+			pDevice->RxPacketDescCnt  * 7 / 8;
+
+		/* This limits the time spent in the ISR when the receiver */
+		/* is in a steady state of being overrun. */
+		pUmDevice->rx_buf_repl_isr_limit = pDevice->RxPacketDescCnt / 8;
+
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+		if (pDevice->RxJumboDescCnt != 0) {
+			if (pUmDevice->rx_buf_repl_thresh >=
+				pDevice->RxJumboDescCnt) {
+
+				pUmDevice->rx_buf_repl_thresh =
+				pUmDevice->rx_buf_repl_panic_thresh =
+					pDevice->RxJumboDescCnt - 1;
+			}
+			if (pUmDevice->rx_buf_repl_thresh >=
+				pDevice->RxStdDescCnt) {
+
+				pUmDevice->rx_buf_repl_thresh =
+				pUmDevice->rx_buf_repl_panic_thresh =
+					pDevice->RxStdDescCnt - 1;
+			}
+		}
+#endif
+	}
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_GetConfig(PLM_DEVICE_BLOCK pDevice)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+	int index = pUmDevice->index;
+	struct net_device *dev = pUmDevice->dev;
+
+	if (index >= MAX_UNITS)
+		return LM_STATUS_SUCCESS;
+
+#if LINUX_KERNEL_VERSION < 0x0020609
+
+	bcm5700_validate_param_range(pUmDevice, &auto_speed[index], "auto_speed",
+		0, 1, 1);
+	if (auto_speed[index] == 0)
+		pDevice->DisableAutoNeg = TRUE;
+	else
+		pDevice->DisableAutoNeg = FALSE;
+
+	if (line_speed[index] == 0) {
+		pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
+		pDevice->DisableAutoNeg = FALSE;
+	}
+	else {
+		bcm5700_validate_param_range(pUmDevice, &full_duplex[index],
+			"full_duplex", 0, 1, 1);
+		if (full_duplex[index]) {
+			pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_FULL;
+		}
+		else {
+			pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_HALF;
+		}
+
+		if (line_speed[index] == 1000) {
+			pDevice->RequestedLineSpeed = LM_LINE_SPEED_1000MBPS;
+			if (pDevice->PhyFlags & PHY_NO_GIGABIT) {
+				pDevice->RequestedLineSpeed =
+					LM_LINE_SPEED_100MBPS;
+				printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (1000), using 100\n", bcm5700_driver, index);
+			}
+			else {
+				if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
+					!full_duplex[index]) {
+					printk(KERN_WARNING "%s-%d: Invalid full_duplex parameter (0) for fiber, using 1\n", bcm5700_driver, index);
+					pDevice->RequestedDuplexMode =
+						LM_DUPLEX_MODE_FULL;
+				}
+
+				if (!(pDevice->TbiFlags & ENABLE_TBI_FLAG) &&
+					!auto_speed[index] && !(pDevice->PhyFlags & PHY_IS_FIBER) ) {
+					printk(KERN_WARNING "%s-%d: Invalid auto_speed parameter (0) for copper, using 1\n", bcm5700_driver, index);
+					pDevice->DisableAutoNeg = FALSE;
+				}
+			}
+		}
+		else if ((pDevice->TbiFlags & ENABLE_TBI_FLAG) ||
+                         (pDevice->PhyFlags & PHY_IS_FIBER)){
+			 pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
+			 pDevice->RequestedDuplexMode = LM_DUPLEX_MODE_FULL;
+			 pDevice->DisableAutoNeg = FALSE;
+			 printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using auto\n", bcm5700_driver, index, line_speed[index]);
+		}
+		else if (line_speed[index] == 100) {
+
+                        pDevice->RequestedLineSpeed = LM_LINE_SPEED_100MBPS;
+		}
+		else if (line_speed[index] == 10) {
+
+			pDevice->RequestedLineSpeed = LM_LINE_SPEED_10MBPS;
+		}
+		else {
+			pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
+			pDevice->DisableAutoNeg = FALSE;
+			printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using 0\n", bcm5700_driver, index, line_speed[index]);
+		}
+
+	}
+
+#endif /* LINUX_KERNEL_VERSION */
+
+	/* This is an unmanageable switch nic and will have link problems if
+	   not set to auto
+	*/
+	if(pDevice->SubsystemVendorId==0x103c && pDevice->SubsystemId==0x3226)
+	{
+	    if(pDevice->RequestedLineSpeed != LM_LINE_SPEED_AUTO)
+	    {
+		printk(KERN_WARNING "%s-%d: Invalid line_speed parameter (%d), using 0\n",
+			bcm5700_driver, index, line_speed[index]);
+	    }
+	    pDevice->RequestedLineSpeed = LM_LINE_SPEED_AUTO;
+	    pDevice->DisableAutoNeg = FALSE;
+	}
+
+#if LINUX_KERNEL_VERSION < 0x0020609
+
+	pDevice->FlowControlCap = 0;
+	bcm5700_validate_param_range(pUmDevice, &rx_flow_control[index],
+		"rx_flow_control", 0, 1, 0);
+	if (rx_flow_control[index] != 0) {
+		pDevice->FlowControlCap |= LM_FLOW_CONTROL_RECEIVE_PAUSE;
+	}
+	bcm5700_validate_param_range(pUmDevice, &tx_flow_control[index],
+		"tx_flow_control", 0, 1, 0);
+	if (tx_flow_control[index] != 0) {
+		pDevice->FlowControlCap |= LM_FLOW_CONTROL_TRANSMIT_PAUSE;
+	}
+	bcm5700_validate_param_range(pUmDevice, &auto_flow_control[index],
+		"auto_flow_control", 0, 1, 0);
+	if (auto_flow_control[index] != 0) {
+		if (pDevice->DisableAutoNeg == FALSE) {
+
+			pDevice->FlowControlCap |= LM_FLOW_CONTROL_AUTO_PAUSE;
+			if ((tx_flow_control[index] == 0) &&
+				(rx_flow_control[index] == 0)) {
+
+				pDevice->FlowControlCap |=
+					LM_FLOW_CONTROL_TRANSMIT_PAUSE |
+					LM_FLOW_CONTROL_RECEIVE_PAUSE;
+			}
+		}
+	}
+
+	if (dev->mtu > 1500) {
+#ifdef BCM_TSO
+		if (T3_ASIC_5714_FAMILY(pDevice->ChipRevId) &&
+		   (dev->features & NETIF_F_TSO)) {
+				dev->features &= ~NETIF_F_TSO;
+				printk(KERN_ALERT "%s: TSO previously enabled. Jumbo Frames and TSO cannot simultaneously be enabled. Jumbo Frames enabled. TSO disabled.\n", dev->name);
+		}
+#endif
+		pDevice->RxMtu = dev->mtu + 14;
+	}
+
+	if ((T3_ASIC_REV(pDevice->ChipRevId) != T3_ASIC_REV_5700) &&
+		!(pDevice->Flags & BCM5788_FLAG)) {
+		pDevice->Flags |= USE_TAGGED_STATUS_FLAG;
+		pUmDevice->timer_interval = HZ;
+		if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703) &&
+			(pDevice->TbiFlags & ENABLE_TBI_FLAG)) {
+			pUmDevice->timer_interval = HZ/4;
+		}
+	}
+	else {
+		pUmDevice->timer_interval = HZ/10;
+	}
+
+	bcm5700_validate_param_range(pUmDevice, &tx_pkt_desc_cnt[index],
+		"tx_pkt_desc_cnt", 1, MAX_TX_PACKET_DESC_COUNT-1, TX_DESC_CNT);
+	pDevice->TxPacketDescCnt = tx_pkt_desc_cnt[index];
+	bcm5700_validate_param_range(pUmDevice, &rx_std_desc_cnt[index],
+		"rx_std_desc_cnt", 1, T3_STD_RCV_RCB_ENTRY_COUNT-1,
+		RX_DESC_CNT);
+	pDevice->RxStdDescCnt = rx_std_desc_cnt[index];
+
+#if T3_JUMBO_RCV_RCB_ENTRY_COUNT
+	bcm5700_validate_param_range(pUmDevice, &rx_jumbo_desc_cnt[index],
+		"rx_jumbo_desc_cnt", 1, T3_JUMBO_RCV_RCB_ENTRY_COUNT-1,
+		JBO_DESC_CNT);
+
+	if (mtu[index] <= 1514)
+		pDevice->RxJumboDescCnt = 0;
+	else if(!T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)){
+		pDevice->RxJumboDescCnt = rx_jumbo_desc_cnt[index];
+        }
+#endif
+
+#ifdef BCM_INT_COAL
+	bcm5700_validate_param_range(pUmDevice, &adaptive_coalesce[index],
+		"adaptive_coalesce", 0, 1, 1);
+#ifdef BCM_NAPI_RXPOLL
+	if (adaptive_coalesce[index]) {
+		printk(KERN_WARNING "%s-%d: adaptive_coalesce not used in NAPI mode\n", bcm5700_driver, index);
+		adaptive_coalesce[index] = 0;
+
+	}
+#endif
+	pUmDevice->adaptive_coalesce = adaptive_coalesce[index];
+	if (!pUmDevice->adaptive_coalesce) {
+		bcm5700_validate_param_range(pUmDevice,
+			&rx_coalesce_ticks[index], "rx_coalesce_ticks", 0,
+			MAX_RX_COALESCING_TICKS, RX_COAL_TK);
+		if ((rx_coalesce_ticks[index] == 0) &&
+			(rx_max_coalesce_frames[index] == 0)) {
+
+			printk(KERN_WARNING "%s-%d: Conflicting rx_coalesce_ticks (0) and rx_max_coalesce_frames (0) parameters, using %d and %d respectively\n",
+				bcm5700_driver, index, RX_COAL_TK, RX_COAL_FM);
+
+			rx_coalesce_ticks[index] = RX_COAL_TK;
+			rx_max_coalesce_frames[index] = RX_COAL_FM;
+		}
+		pDevice->RxCoalescingTicks = pUmDevice->rx_curr_coalesce_ticks =
+			rx_coalesce_ticks[index];
+#ifdef BCM_NAPI_RXPOLL
+		pDevice->RxCoalescingTicksDuringInt = rx_coalesce_ticks[index];
+#endif
+
+		bcm5700_validate_param_range(pUmDevice,
+			&rx_max_coalesce_frames[index],
+			"rx_max_coalesce_frames", 0,
+			MAX_RX_MAX_COALESCED_FRAMES, RX_COAL_FM);
+
+		pDevice->RxMaxCoalescedFrames =
+			pUmDevice->rx_curr_coalesce_frames =
+			rx_max_coalesce_frames[index];
+#ifdef BCM_NAPI_RXPOLL
+		pDevice->RxMaxCoalescedFramesDuringInt =
+			rx_max_coalesce_frames[index];
+#endif
+
+		bcm5700_validate_param_range(pUmDevice,
+			&tx_coalesce_ticks[index], "tx_coalesce_ticks", 0,
+			MAX_TX_COALESCING_TICKS, TX_COAL_TK);
+		if ((tx_coalesce_ticks[index] == 0) &&
+			(tx_max_coalesce_frames[index] == 0)) {
+
+			printk(KERN_WARNING "%s-%d: Conflicting tx_coalesce_ticks (0) and tx_max_coalesce_frames (0) parameters, using %d and %d respectively\n",
+				bcm5700_driver, index, TX_COAL_TK, TX_COAL_FM);
+
+			tx_coalesce_ticks[index] = TX_COAL_TK;
+			tx_max_coalesce_frames[index] = TX_COAL_FM;
+		}
+		pDevice->TxCoalescingTicks = tx_coalesce_ticks[index];
+		bcm5700_validate_param_range(pUmDevice,
+			&tx_max_coalesce_frames[index],
+			"tx_max_coalesce_frames", 0,
+			MAX_TX_MAX_COALESCED_FRAMES, TX_COAL_FM);
+		pDevice->TxMaxCoalescedFrames = tx_max_coalesce_frames[index];
+		pUmDevice->tx_curr_coalesce_frames =
+			pDevice->TxMaxCoalescedFrames;
+
+		bcm5700_validate_param_range(pUmDevice,
+			&stats_coalesce_ticks[index], "stats_coalesce_ticks",
+			0, MAX_STATS_COALESCING_TICKS, ST_COAL_TK);
+		if (adaptive_coalesce[index]) {
+			printk(KERN_WARNING "%s-%d: Invalid stats_coalesce_ticks parameter set with with adaptive_coalesce parameter. Using adaptive_coalesce.\n", bcm5700_driver, index);
+		}else{
+			if ((stats_coalesce_ticks[index] > 0) &&
+				(stats_coalesce_ticks[index] < 100)) {
+				printk(KERN_WARNING "%s-%d: Invalid stats_coalesce_ticks parameter (%u), using 100\n", bcm5700_driver, index, (unsigned int) stats_coalesce_ticks[index]);
+				stats_coalesce_ticks[index] = 100;
+				pDevice->StatsCoalescingTicks = stats_coalesce_ticks[index];
+				pDevice->StatsCoalescingTicks = stats_coalesce_ticks[index];
+			}
+		}
+	}
+	else {
+		pUmDevice->rx_curr_coalesce_frames = RX_COAL_FM;
+		pUmDevice->rx_curr_coalesce_ticks = RX_COAL_TK;
+		pUmDevice->tx_curr_coalesce_frames = TX_COAL_FM;
+	}
+#endif
+
+	if (T3_ASIC_IS_5705_BEYOND(pDevice->ChipRevId)) {
+		unsigned int tmpvar;
+
+		tmpvar = pDevice->StatsCoalescingTicks / BCM_TIMER_GRANULARITY;
+
+		/*
+		 * If the result is zero, the request is too demanding.
+		 */
+		if (tmpvar == 0) {
+			tmpvar = 1;
+		}
+
+		pDevice->StatsCoalescingTicks = tmpvar * BCM_TIMER_GRANULARITY;
+
+		pUmDevice->statstimer_interval = tmpvar;
+	}
+
+#ifdef BCM_WOL
+	bcm5700_validate_param_range(pUmDevice, &enable_wol[index],
+		"enable_wol", 0, 1, 0);
+	if (enable_wol[index]) {
+		pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_MAGIC_PACKET;
+		pDevice->WakeUpMode = LM_WAKE_UP_MODE_MAGIC_PACKET;
+	}
+#endif
+#ifdef INCLUDE_TBI_SUPPORT
+	if (pDevice->TbiFlags & ENABLE_TBI_FLAG) {
+		if ((T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) ||
+			(T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5703)) {
+			/* just poll since we have hardware autoneg. in 5704 */
+			pDevice->TbiFlags |= TBI_PURE_POLLING_FLAG;
+		}
+		else {
+			pDevice->TbiFlags |= TBI_POLLING_INTR_FLAG;
+		}
+	}
+#endif
+	bcm5700_validate_param_range(pUmDevice, &scatter_gather[index],
+		"scatter_gather", 0, 1, 1);
+	bcm5700_validate_param_range(pUmDevice, &tx_checksum[index],
+		"tx_checksum", 0, 1, 1);
+	bcm5700_validate_param_range(pUmDevice, &rx_checksum[index],
+		"rx_checksum", 0, 1, 1);
+	if (!(pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TX_TCP_CHECKSUM)) {
+		if (tx_checksum[index] || rx_checksum[index]) {
+
+			pDevice->TaskToOffload = LM_TASK_OFFLOAD_NONE;
+			printk(KERN_WARNING "%s-%d: Checksum offload not available on this NIC\n", bcm5700_driver, index);
+		}
+	}
+	else {
+		if (rx_checksum[index]) {
+			pDevice->TaskToOffload |=
+				LM_TASK_OFFLOAD_RX_TCP_CHECKSUM |
+				LM_TASK_OFFLOAD_RX_UDP_CHECKSUM;
+		}
+		if (tx_checksum[index]) {
+			pDevice->TaskToOffload |=
+				LM_TASK_OFFLOAD_TX_TCP_CHECKSUM |
+				LM_TASK_OFFLOAD_TX_UDP_CHECKSUM;
+			pDevice->Flags |= NO_TX_PSEUDO_HDR_CSUM_FLAG;
+		}
+	}
+#ifdef BCM_TSO
+	bcm5700_validate_param_range(pUmDevice, &enable_tso[index],
+		"enable_tso", 0, 1, 1);
+
+	/* Always enable TSO firmware if supported */
+	/* This way we can turn it on or off on the fly */
+	if (pDevice->TaskOffloadCap & LM_TASK_OFFLOAD_TCP_SEGMENTATION)
+	{
+		pDevice->TaskToOffload |=
+			LM_TASK_OFFLOAD_TCP_SEGMENTATION;
+	}
+	if (enable_tso[index] &&
+		!(pDevice->TaskToOffload & LM_TASK_OFFLOAD_TCP_SEGMENTATION))
+	{
+		printk(KERN_WARNING "%s-%d: TSO not available on this NIC\n", bcm5700_driver, index);
+	}
+#endif
+#ifdef BCM_ASF
+	bcm5700_validate_param_range(pUmDevice, &vlan_tag_mode[index],
+		"vlan_strip_mode", 0, 2, 0);
+	pUmDevice->vlan_tag_mode = vlan_tag_mode[index];
+#else
+	pUmDevice->vlan_tag_mode = VLAN_TAG_MODE_NORMAL_STRIP;
+#endif
+
+#endif /* LINUX_KERNEL_VERSION */
+
+#ifdef BCM_NIC_SEND_BD
+	bcm5700_validate_param_range(pUmDevice, &nic_tx_bd[index], "nic_tx_bd",
+		0, 1, 0);
+	if (nic_tx_bd[index])
+		pDevice->Flags |= NIC_SEND_BD_FLAG;
+	if ((pDevice->Flags & ENABLE_PCIX_FIX_FLAG) ||
+		(T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5705)) {
+		if (pDevice->Flags & NIC_SEND_BD_FLAG) {
+			pDevice->Flags &= ~NIC_SEND_BD_FLAG;
+			printk(KERN_WARNING "%s-%d: Nic Send BDs not available on this NIC or not possible on this system\n", bcm5700_driver, index);
+		}
+	}
+#endif
+#if defined(CONFIG_PCI_MSI) || defined(CONFIG_PCI_USE_VECTOR)
+	bcm5700_validate_param_range(pUmDevice, &disable_msi[pUmDevice->index],
+		"disable_msi", 0, 1, 0);
+#endif
+
+	bcm5700_validate_param_range(pUmDevice, &delay_link[index],
+		"delay_link", 0, 1, 0);
+
+	bcm5700_validate_param_range(pUmDevice, &disable_d3hot[index],
+		"disable_d3hot", 0, 1, 0);
+	if (disable_d3hot[index]) {
+
+#ifdef BCM_WOL
+		if (enable_wol[index]) {
+			pDevice->WakeUpModeCap = LM_WAKE_UP_MODE_NONE;
+			pDevice->WakeUpMode = LM_WAKE_UP_MODE_NONE;
+			printk(KERN_WARNING "%s-%d: Wake-On-Lan disabled because D3Hot is disabled\n", bcm5700_driver, index);
+		}
+#endif
+		pDevice->Flags |= DISABLE_D3HOT_FLAG;
+	}
+
+    return LM_STATUS_SUCCESS;
+}
+
+/* From include/proto/ethernet.h */
+#define ETHER_TYPE_8021Q	0x8100		/* 802.1Q */
+
+/* From include/proto/vlan.h */
+#define VLAN_PRI_MASK		7	/* 3 bits of priority */
+#define VLAN_PRI_SHIFT		13
+
+/* Replace the priority in a vlan tag */
+#define	UPD_VLANTAG_PRIO(tag, prio) do { \
+	tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT); \
+	tag |= prio << VLAN_PRI_SHIFT; \
+} while (0)
+
+/* Takes an Ethernet frame and sets out-of-bound PKTPRIO.
+ * Also updates the inplace vlan tag if requested.
+ * For debugging, it returns an indication of what it did.
+ */
+#define	PKTPRIO_VDSCP	0x100		/* DSCP prio found after VLAN tag */
+#define	PKTPRIO_VLAN	0x200		/* VLAN prio found */
+#define	PKTPRIO_UPD	0x400		/* DSCP used to update VLAN prio */
+#define	PKTPRIO_DSCP	0x800		/* DSCP prio found */
+#define	PKTSETPRIO(skb, x)		(((struct sk_buff*)(skb))->priority = (x))
+static uint
+pktsetprio(void *pkt, bool update_vtag)
+{
+	struct ether_header *eh;
+	struct ethervlan_header *evh;
+	uint8 *pktdata;
+	int priority = 0;
+	int rc = 0;
+
+	pktdata = (uint8 *) PKTDATA(NULL, pkt);
+	ASSERT(ISALIGNED((uintptr)pktdata, sizeof(uint16)));
+
+	eh = (struct ether_header *) pktdata;
+
+	if (ntoh16(eh->ether_type) == ETHER_TYPE_8021Q) {
+		uint16 vlan_tag;
+		int vlan_prio, dscp_prio = 0;
+
+		evh = (struct ethervlan_header *)eh;
+
+		vlan_tag = ntoh16(evh->vlan_tag);
+		vlan_prio = (int) (vlan_tag >> VLAN_PRI_SHIFT) & VLAN_PRI_MASK;
+
+		if (ntoh16(evh->ether_type) == ETHER_TYPE_IP) {
+			uint8 *ip_body = pktdata + sizeof(struct ethervlan_header);
+			uint8 tos_tc = IP_TOS(ip_body);
+			dscp_prio = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
+			if ((IP_VER(ip_body) == IP_VER_4) && (IPV4_PROT(ip_body) == IP_PROT_TCP)) {
+				int ip_len;
+				int src_port;
+				bool src_port_exc;
+				uint8 *tcp_hdr;
+
+				ip_len = IPV4_PAYLOAD_LEN(ip_body);
+				tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD(ip_body);
+				src_port = TCP_SRC_PORT(tcp_hdr);
+				src_port_exc = (src_port == 10110) || (src_port == 10120) ||
+					(src_port == 10130) || (src_port == 10140);
+
+				if ((ip_len == 40) && src_port_exc && TCP_IS_ACK(tcp_hdr)) {
+					dscp_prio = 7;
+				}
+			}
+		}
+
+		/* DSCP priority gets precedence over 802.1P (vlan tag) */
+		if (dscp_prio != 0) {
+			priority = dscp_prio;
+			rc |= PKTPRIO_VDSCP;
+		} else {
+			priority = vlan_prio;
+			rc |= PKTPRIO_VLAN;
+		}
+		/* 
+		 * If the DSCP priority is not the same as the VLAN priority,
+		 * then overwrite the priority field in the vlan tag, with the
+		 * DSCP priority value. This is required for Linux APs because
+		 * the VLAN driver on Linux, overwrites the skb->priority field
+		 * with the priority value in the vlan tag
+		 */
+		if (update_vtag && (priority != vlan_prio)) {
+			vlan_tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT);
+			vlan_tag |= (uint16)priority << VLAN_PRI_SHIFT;
+			evh->vlan_tag = hton16(vlan_tag);
+			rc |= PKTPRIO_UPD;
+		}
+	} else if (ntoh16(eh->ether_type) == ETHER_TYPE_IP) {
+		uint8 *ip_body = pktdata + sizeof(struct ether_header);
+		uint8 tos_tc = IP_TOS(ip_body);
+		priority = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
+		rc |= PKTPRIO_DSCP;
+		if ((IP_VER(ip_body) == IP_VER_4) && (IPV4_PROT(ip_body) == IP_PROT_TCP)) {
+			int ip_len;
+			int src_port;
+			bool src_port_exc;
+			uint8 *tcp_hdr;
+
+			ip_len = IPV4_PAYLOAD_LEN(ip_body);
+			tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD(ip_body);
+			src_port = TCP_SRC_PORT(tcp_hdr);
+			src_port_exc = (src_port == 10110) || (src_port == 10120) ||
+				(src_port == 10130) || (src_port == 10140);
+
+			if ((ip_len == 40) && src_port_exc && TCP_IS_ACK(tcp_hdr)) {
+				priority = 7;
+			}
+		}
+	}
+
+	ASSERT(priority >= 0 && priority <= MAXPRIO);
+	PKTSETPRIO(pkt, priority);
+	return (rc | priority);
+}
+
+LM_STATUS
+MM_IndicateRxPackets(PLM_DEVICE_BLOCK pDevice)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+	PLM_PACKET pPacket;
+	PUM_PACKET pUmPacket;
+	struct sk_buff *skb;
+	int size;
+	int vlan_tag_size = 0;
+	uint16 dscp_prio;
+
+	if (pDevice->ReceiveMask & LM_KEEP_VLAN_TAG)
+		vlan_tag_size = 4;
+
+	while (1) {
+		pPacket = (PLM_PACKET)
+			QQ_PopHead(&pDevice->RxPacketReceivedQ.Container);
+		if (pPacket == 0)
+			break;
+		pUmPacket = (PUM_PACKET) pPacket;
+#if !defined(NO_PCI_UNMAP)
+		pci_unmap_single(pUmDevice->pdev,
+				pci_unmap_addr(pUmPacket, map[0]),
+				pPacket->u.Rx.RxBufferSize,
+				PCI_DMA_FROMDEVICE);
+#endif
+		if ((pPacket->PacketStatus != LM_STATUS_SUCCESS) ||
+			((size = pPacket->PacketSize) >
+			(pDevice->RxMtu + vlan_tag_size))) {
+
+			/* reuse skb */
+#ifdef BCM_TASKLET
+			QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
+#else
+			QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
+#endif
+			pUmDevice->rx_misc_errors++;
+			continue;
+		}
+		skb = pUmPacket->skbuff;
+		skb_put(skb, size);
+		skb->pkt_type = 0;
+		/* Extract priority from payload and put it in skb->priority */
+		dscp_prio = 0;
+		if (pUmDevice->qos) {
+			uint rc;
+
+			rc = pktsetprio(skb, TRUE);
+			if (rc & (PKTPRIO_VDSCP | PKTPRIO_DSCP))
+				dscp_prio = rc & VLAN_PRI_MASK;
+			if (rc != 0)
+				B57_INFO(("pktsetprio returned 0x%x, skb->priority: %d\n",
+				          rc, skb->priority));
+		}
+		skb->protocol = eth_type_trans(skb, skb->dev);
+		if (size > pDevice->RxMtu) {
+			/* Make sure we have a valid VLAN tag */
+			if (htons(skb->protocol) != ETHER_TYPE_8021Q) {
+				dev_kfree_skb_irq(skb);
+				pUmDevice->rx_misc_errors++;
+				goto drop_rx;
+			}
+		}
+
+		pUmDevice->stats.rx_bytes += skb->len;
+
+		if ((pPacket->Flags & RCV_BD_FLAG_TCP_UDP_CHKSUM_FIELD) &&
+			(pDevice->TaskToOffload &
+				LM_TASK_OFFLOAD_RX_TCP_CHECKSUM)) {
+			if (pPacket->u.Rx.TcpUdpChecksum == 0xffff) {
+
+				skb->ip_summed = CHECKSUM_UNNECESSARY;
+#if TIGON3_DEBUG
+				pUmDevice->rx_good_chksum_count++;
+#endif
+			}
+			else {
+				skb->ip_summed = CHECKSUM_NONE;
+				pUmDevice->rx_bad_chksum_count++;
+			}
+		}
+		else {
+			skb->ip_summed = CHECKSUM_NONE;
+		}
+		{
+#ifdef BCM_VLAN
+			if (pUmDevice->vlgrp &&
+				(pPacket->Flags & RCV_BD_FLAG_VLAN_TAG)) {
+				/* Override vlan priority with dscp priority */
+				if (dscp_prio)
+					UPD_VLANTAG_PRIO(pPacket->VlanTag, dscp_prio);
+#ifdef BCM_NAPI_RXPOLL
+				vlan_hwaccel_receive_skb(skb, pUmDevice->vlgrp,
+					pPacket->VlanTag);
+#else
+				vlan_hwaccel_rx(skb, pUmDevice->vlgrp,
+					pPacket->VlanTag);
+#endif
+			} else
+#endif
+			{
+#ifdef BCM_WL_EMULATOR
+				if(pDevice->wl_emulate_rx) {
+					/* bcmstats("emu recv %d %d"); */
+					wlcemu_receive_skb(pDevice->wlc, skb);
+					/* bcmstats("emu recv end %d %d"); */
+				}
+				else 
+#endif /* BCM_WL_EMULATOR  */
+				{
+#ifdef BCM_NAPI_RXPOLL
+				netif_receive_skb(skb);
+#else
+				netif_rx(skb);
+#endif
+				}
+			}
+		}
+		pUmDevice->dev->last_rx = jiffies;
+
+drop_rx:
+#ifdef BCM_TASKLET
+		pUmPacket->skbuff = 0;
+		QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
+#else
+#ifdef BCM_WL_EMULATOR
+		skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2);
+#else
+		skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR);
+#endif /* BCM_WL_EMULATOR  */
+		if (skb == 0) {
+			pUmPacket->skbuff = 0;
+			QQ_PushTail(&pUmDevice->rx_out_of_buf_q.Container, pPacket);
+		}
+		else {
+			pUmPacket->skbuff = skb;
+			skb->dev = pUmDevice->dev;
+#ifndef BCM_WL_EMULATOR
+			skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
+#endif
+			QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
+		}
+#endif
+	}
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_CoalesceTxBuffer(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
+{
+	PUM_PACKET pUmPacket = (PUM_PACKET) pPacket;
+	struct sk_buff *skb = pUmPacket->skbuff;
+	struct sk_buff *nskb;
+#if !defined(NO_PCI_UNMAP)
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+
+	pci_unmap_single(pUmDevice->pdev,
+			pci_unmap_addr(pUmPacket, map[0]),
+			pci_unmap_len(pUmPacket, map_len[0]),
+			PCI_DMA_TODEVICE);
+#if MAX_SKB_FRAGS
+	{
+		int i;
+
+		for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+			pci_unmap_page(pUmDevice->pdev,
+				pci_unmap_addr(pUmPacket, map[i + 1]),
+				pci_unmap_len(pUmPacket, map_len[i + 1]),
+				PCI_DMA_TODEVICE);
+		}
+	}
+#endif
+#endif
+	if ((nskb = skb_copy(skb, GFP_ATOMIC))) {
+		pUmPacket->lm_packet.u.Tx.FragCount = 1;
+		dev_kfree_skb(skb);
+		pUmPacket->skbuff = nskb;
+		return LM_STATUS_SUCCESS;
+	}
+	dev_kfree_skb(skb);
+	pUmPacket->skbuff = 0;
+	return LM_STATUS_FAILURE;
+}
+
+/* Returns 1 if not all buffers are allocated */
+STATIC int
+replenish_rx_buffers(PUM_DEVICE_BLOCK pUmDevice, int max)
+{
+	PLM_PACKET pPacket;
+	PUM_PACKET pUmPacket;
+	PLM_DEVICE_BLOCK pDevice = (PLM_DEVICE_BLOCK) pUmDevice;
+	struct sk_buff *skb;
+	int queue_rx = 0;
+	int alloc_cnt = 0;
+	int ret = 0;
+
+	while ((pUmPacket = (PUM_PACKET)
+		QQ_PopHead(&pUmDevice->rx_out_of_buf_q.Container)) != 0) {
+		pPacket = (PLM_PACKET) pUmPacket;
+		if (pUmPacket->skbuff) {
+			/* reuse an old skb */
+			QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
+			queue_rx = 1;
+			continue;
+		}
+#ifdef BCM_WL_EMULATOR
+		if ((skb = (struct sk_buff *)wlcemu_pktget(pDevice->wlc,pPacket->u.Rx.RxBufferSize + 2)) == 0)
+#else 
+	       if ((skb = dev_alloc_skb(pPacket->u.Rx.RxBufferSize + 2 + EXTRA_HDR)) == 0)
+#endif /* BCM_WL_EMULATOR  */
+	       {
+		       QQ_PushHead(&pUmDevice->rx_out_of_buf_q.Container,
+		                   pPacket);
+		       ret = 1;
+		       break;
+	       }
+		pUmPacket->skbuff = skb;
+		skb->dev = pUmDevice->dev;
+#ifndef BCM_WL_EMULATOR
+			skb_reserve(skb, EXTRA_HDR - pUmDevice->rx_buf_align);
+#endif
+		QQ_PushTail(&pDevice->RxPacketFreeQ.Container, pPacket);
+		queue_rx = 1;
+		if (max > 0) {
+			alloc_cnt++;
+			if (alloc_cnt >= max)
+				break;
+		}
+	}
+	if (queue_rx || pDevice->QueueAgain) {
+		LM_QueueRxPackets(pDevice);
+	}
+	return ret;
+}
+
+LM_STATUS
+MM_IndicateTxPackets(PLM_DEVICE_BLOCK pDevice)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+	PLM_PACKET pPacket;
+	PUM_PACKET pUmPacket;
+	struct sk_buff *skb;
+#if !defined(NO_PCI_UNMAP) && MAX_SKB_FRAGS
+	int i;
+#endif
+
+	while (1) {
+		pPacket = (PLM_PACKET)
+			QQ_PopHead(&pDevice->TxPacketXmittedQ.Container);
+		if (pPacket == 0)
+			break;
+		pUmPacket = (PUM_PACKET) pPacket;
+		skb = pUmPacket->skbuff;
+#if !defined(NO_PCI_UNMAP)
+		pci_unmap_single(pUmDevice->pdev,
+				pci_unmap_addr(pUmPacket, map[0]),
+				pci_unmap_len(pUmPacket, map_len[0]),
+				PCI_DMA_TODEVICE);
+#if MAX_SKB_FRAGS
+		for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+			pci_unmap_page(pUmDevice->pdev,
+				pci_unmap_addr(pUmPacket, map[i + 1]),
+				pci_unmap_len(pUmPacket, map_len[i + 1]),
+				PCI_DMA_TODEVICE);
+		}
+#endif
+#endif
+		dev_kfree_skb_irq(skb);
+		pUmPacket->skbuff = 0;
+		QQ_PushTail(&pDevice->TxPacketFreeQ.Container, pPacket);
+	}
+	if (pUmDevice->tx_full) {
+		if (QQ_GetEntryCnt(&pDevice->TxPacketFreeQ.Container) >=
+			(pDevice->TxPacketDescCnt >> 1)) {
+
+			pUmDevice->tx_full = 0;
+			netif_wake_queue(pUmDevice->dev);
+		}
+	}
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_IndicateStatus(PLM_DEVICE_BLOCK pDevice, LM_STATUS Status)
+{
+	PUM_DEVICE_BLOCK pUmDevice = (PUM_DEVICE_BLOCK) pDevice;
+	struct net_device *dev = pUmDevice->dev;
+	LM_FLOW_CONTROL flow_control;
+	int speed = 0;
+
+	if (!pUmDevice->opened)
+		return LM_STATUS_SUCCESS;
+
+	if (!pUmDevice->suspended) {
+		if (Status == LM_STATUS_LINK_DOWN) {
+			netif_carrier_off(dev);
+		}
+		else if (Status == LM_STATUS_LINK_ACTIVE) {
+			netif_carrier_on(dev);
+		}
+	}
+
+	if (pUmDevice->delayed_link_ind > 0) {
+		pUmDevice->delayed_link_ind = 0;
+		if (Status == LM_STATUS_LINK_DOWN) {
+			B57_INFO(("%s: %s NIC Link is DOWN\n", bcm5700_driver, dev->name));
+		}
+		else if (Status == LM_STATUS_LINK_ACTIVE) {
+			B57_INFO(("%s: %s NIC Link is UP, ", bcm5700_driver, dev->name));
+		}
+	}
+	else {
+		if (Status == LM_STATUS_LINK_DOWN) {
+			B57_INFO(("%s: %s NIC Link is Down\n", bcm5700_driver, dev->name));
+		}
+		else if (Status == LM_STATUS_LINK_ACTIVE) {
+			B57_INFO(("%s: %s NIC Link is Up, ", bcm5700_driver, dev->name));
+		}
+	}
+
+	if (Status == LM_STATUS_LINK_ACTIVE) {
+		if (pDevice->LineSpeed == LM_LINE_SPEED_1000MBPS)
+			speed = 1000;
+		else if (pDevice->LineSpeed == LM_LINE_SPEED_100MBPS)
+			speed = 100;
+		else if (pDevice->LineSpeed == LM_LINE_SPEED_10MBPS)
+			speed = 10;
+
+		B57_INFO(("%d Mbps ", speed));
+
+		if (pDevice->DuplexMode == LM_DUPLEX_MODE_FULL)
+			B57_INFO(("full duplex"));
+		else
+			B57_INFO(("half duplex"));
+
+		flow_control = pDevice->FlowControl &
+			(LM_FLOW_CONTROL_RECEIVE_PAUSE |
+			LM_FLOW_CONTROL_TRANSMIT_PAUSE);
+		if (flow_control) {
+			if (flow_control & LM_FLOW_CONTROL_RECEIVE_PAUSE) {
+				B57_INFO((", receive "));
+				if (flow_control & LM_FLOW_CONTROL_TRANSMIT_PAUSE)
+					B57_INFO(("& transmit "));
+			}
+			else {
+				B57_INFO((", transmit "));
+			}
+			B57_INFO(("flow control ON"));
+		}
+		B57_INFO(("\n"));
+	}
+	return LM_STATUS_SUCCESS;
+}
+
+void
+MM_UnmapRxDma(LM_DEVICE_BLOCK *pDevice, LM_PACKET *pPacket)
+{
+#if !defined(NO_PCI_UNMAP)
+	UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
+	UM_PACKET *pUmPacket = (UM_PACKET *) pPacket;
+
+	if (!pUmPacket->skbuff)
+		return;
+
+	pci_unmap_single(pUmDevice->pdev,
+			pci_unmap_addr(pUmPacket, map[0]),
+			pPacket->u.Rx.RxBufferSize,
+			PCI_DMA_FROMDEVICE);
+#endif
+}
+
+LM_STATUS
+MM_FreeRxBuffer(PLM_DEVICE_BLOCK pDevice, PLM_PACKET pPacket)
+{
+	PUM_PACKET pUmPacket;
+	struct sk_buff *skb;
+
+	if (pPacket == 0)
+		return LM_STATUS_SUCCESS;
+	pUmPacket = (PUM_PACKET) pPacket;
+	if ((skb = pUmPacket->skbuff)) {
+		/* DMA address already unmapped */
+		dev_kfree_skb(skb);
+	}
+	pUmPacket->skbuff = 0;
+	return LM_STATUS_SUCCESS;
+}
+
+LM_STATUS
+MM_Sleep(LM_DEVICE_BLOCK *pDevice, LM_UINT32 msec)
+{
+	current->state = TASK_INTERRUPTIBLE;
+	if (schedule_timeout(HZ * msec / 1000) != 0) {
+		return LM_STATUS_FAILURE;
+	}
+	if (signal_pending(current))
+		return LM_STATUS_FAILURE;
+
+	return LM_STATUS_SUCCESS;
+}
+
+void
+bcm5700_shutdown(UM_DEVICE_BLOCK *pUmDevice)
+{
+	LM_DEVICE_BLOCK *pDevice = (LM_DEVICE_BLOCK *) pUmDevice;
+
+	bcm5700_intr_off(pUmDevice);
+	netif_carrier_off(pUmDevice->dev);
+#ifdef BCM_TASKLET
+	tasklet_kill(&pUmDevice->tasklet);
+#endif
+	bcm5700_poll_wait(pUmDevice);
+
+	LM_Halt(pDevice);
+
+	pDevice->InitDone = 0;
+	bcm5700_free_remaining_rx_bufs(pUmDevice);
+}
+
+void
+bcm5700_free_remaining_rx_bufs(UM_DEVICE_BLOCK *pUmDevice)
+{
+	LM_DEVICE_BLOCK *pDevice = &pUmDevice->lm_dev;
+	UM_PACKET *pUmPacket;
+	int cnt, i;
+
+	cnt = QQ_GetEntryCnt(&pUmDevice->rx_out_of_buf_q.Container);
+	for (i = 0; i < cnt; i++) {
+		if ((pUmPacket =
+			QQ_PopHead(&pUmDevice->rx_out_of_buf_q.Container))
+			!= 0) {
+
+			MM_UnmapRxDma(pDevice, (LM_PACKET *) pUmPacket);
+			MM_FreeRxBuffer(pDevice, &pUmPacket->lm_packet);
+			QQ_PushTail(&pDevice->RxPacketFreeQ.Container,
+				pUmPacket);
+		}
+	}
+}
+
+void
+bcm5700_validate_param_range(UM_DEVICE_BLOCK *pUmDevice, int *param,
+	char *param_name, int min, int max, int deflt)
+{
+	if (((unsigned int) *param < (unsigned int) min) ||
+		((unsigned int) *param > (unsigned int) max)) {
+
+		printk(KERN_WARNING "%s-%d: Invalid %s parameter (%u), using %u\n", bcm5700_driver, pUmDevice->index, param_name, (unsigned int) *param, (unsigned int) deflt);
+		*param = deflt;
+	}
+}
+
+struct net_device *
+bcm5700_find_peer(struct net_device *dev)
+{
+	struct net_device *tmp_dev;
+	UM_DEVICE_BLOCK *pUmDevice, *pUmTmp;
+	LM_DEVICE_BLOCK *pDevice;
+
+	tmp_dev = 0;
+	pUmDevice = (UM_DEVICE_BLOCK *) dev->priv;
+	pDevice = &pUmDevice->lm_dev;
+	if (T3_ASIC_REV(pDevice->ChipRevId) == T3_ASIC_REV_5704) {
+		tmp_dev = root_tigon3_dev;
+		while (tmp_dev) {
+			pUmTmp = (PUM_DEVICE_BLOCK) tmp_dev->priv;
+			if ((tmp_dev != dev) &&
+				(pUmDevice->pdev->bus->number ==
+				pUmTmp->pdev->bus->number) &&
+				PCI_SLOT(pUmDevice->pdev->devfn) ==
+				PCI_SLOT(pUmTmp->pdev->devfn)) {
+
+				break;
+			}
+			tmp_dev = pUmTmp->next_module;
+		}
+	}
+	return tmp_dev;
+}
+
+LM_DEVICE_BLOCK *
+MM_FindPeerDev(LM_DEVICE_BLOCK *pDevice)
+{
+	UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
+	struct net_device *dev = pUmDevice->dev;
+	struct net_device *peer_dev;
+
+	peer_dev = bcm5700_find_peer(dev);
+	if (!peer_dev)
+		return 0;
+	return ((LM_DEVICE_BLOCK *) peer_dev->priv);
+}
+
+int MM_FindCapability(LM_DEVICE_BLOCK *pDevice, int capability)
+{
+	UM_DEVICE_BLOCK *pUmDevice = (UM_DEVICE_BLOCK *) pDevice;
+	return (pci_find_capability(pUmDevice->pdev, capability));
+}
+
+#if defined(HAVE_POLL_CONTROLLER)||defined(CONFIG_NET_POLL_CONTROLLER)
+STATIC void
+poll_bcm5700(struct net_device *dev)
+{
+	UM_DEVICE_BLOCK *pUmDevice = dev->priv;
+
+#if defined(RED_HAT_LINUX_KERNEL) && (LINUX_VERSION_CODE < 0x020605)
+	if (netdump_mode) {
+		bcm5700_interrupt(pUmDevice->pdev->irq, dev, NULL);
+#ifdef BCM_NAPI_RXPOLL
+		if (dev->poll_list.prev) {
+			int budget = 64;
+
+			bcm5700_poll(dev, &budget);
+		}
+#endif
+	}
+	else
+#endif
+	{
+		disable_irq(pUmDevice->pdev->irq);
+		bcm5700_interrupt(pUmDevice->pdev->irq, dev, NULL);
+		enable_irq(pUmDevice->pdev->irq);
+	}
+}
+#endif