Attachment 234431 Details for Bug 236869 – Netxen 2.6.23 patch

Netxen 2.6.23 patch

netxen-2.6.23.patch (text/plain), 142.60 KB, created by IBM Bug Proxy on 2007-10-22 20:20:52 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: IBM Bug Proxy

Created: 2007-10-22 20:20:52 UTC

Size: 142.60 KB

patch

obsolete

>Backport netxen driver from 2.6.23 to the real-time linux R1-SR3 kernel.
>
>This patch brings the netxen driver up to date with the latest version in
>the mainline kernel.  It includes lots of cleanups provided by others working
>in the kernel tree as well as some stability and throughput fixes from the
>netxen developers.
>
>Since this is really just an incorparated patch set, I have included the
>DCO of all those that have touched the netxen files from 2.6.21.4 to 2.6.23
>as found in the git tree.
>
>Signed-off-by: Vernon Mauery <vernux@us.ibm.com>
>
>-- original contributors --
>
>    Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
>    Signed-off-by: Andy Gospodarek <andy@greyhouse.net>
>    Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
>    Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
>    Signed-off-by: Bill Nottingham <notting@redhat.com>
>    Signed-off-by: David S. Miller <davem@davemloft.net>
>    Signed-off-by: Dhananjay Phadke <dhananjay@netxen.com>
>    Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>    Signed-off-by: Matthew Wilcox <matthew@wil.cx>
>    Signed-off-by: Milan Bag <mbag@netxen.com>
>    Signed-off-by: Mithlesh Thukral <mithlesh@netxen.com>
>    Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
>    Signed-off-by: Wen Xiong <wenxiong@us.ibm.com>
>
>===============================================================================
>
> netxen_nic.h          |  347 +++++++++--------
> netxen_nic_ethtool.c  |  221 ++++++-----
> netxen_nic_hdr.h      |   20 -
> netxen_nic_hw.c       |  467 +++++++++++++++++-------
> netxen_nic_hw.h       |   85 +++-
> netxen_nic_init.c     |  208 ++++------
> netxen_nic_isr.c      |  125 +++---
> netxen_nic_main.c     |  972 +++++++++++++++++++++++++++++++-------------------
> netxen_nic_niu.c      |  172 ++++----
> netxen_nic_phan_reg.h |  148 +------
> 10 files changed, 1639 insertions(+), 1126 deletions(-)
>
>===============================================================================
>
>Index: linux-git/drivers/net/netxen/netxen_nic_ethtool.c
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_ethtool.c	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_ethtool.c	2007-09-27 10:36:10.000000000 -0700
>@@ -40,8 +40,8 @@
> #include <linux/ethtool.h>
> #include <linux/version.h>
> 
>-#include "netxen_nic_hw.h"
> #include "netxen_nic.h"
>+#include "netxen_nic_hw.h"
> #include "netxen_nic_phan_reg.h"
> 
> struct netxen_nic_stats {
>@@ -50,8 +50,8 @@
> 	int stat_offset;
> };
> 
>-#define NETXEN_NIC_STAT(m) sizeof(((struct netxen_port *)0)->m), \
>-			offsetof(struct netxen_port, m)
>+#define NETXEN_NIC_STAT(m) sizeof(((struct netxen_adapter *)0)->m), \
>+			offsetof(struct netxen_adapter, m)
> 
> #define NETXEN_NIC_PORT_WINDOW 0x10000
> #define NETXEN_NIC_INVALID_DATA 0xDEADBEEF
>@@ -94,14 +94,13 @@
> 
> static int netxen_nic_get_eeprom_len(struct net_device *dev)
> {
>-	return FLASH_TOTAL_SIZE;
>+	return NETXEN_FLASH_TOTAL_SIZE;
> }
> 
> static void
> netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	u32 fw_major = 0;
> 	u32 fw_minor = 0;
> 	u32 fw_build = 0;
>@@ -115,7 +114,7 @@
> 	fw_build = readl(NETXEN_CRB_NORMALIZE(adapter, NETXEN_FW_VERSION_SUB));
> 	sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
> 
>-	strncpy(drvinfo->bus_info, pci_name(port->pdev), 32);
>+	strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
> 	drvinfo->n_stats = NETXEN_NIC_STATS_LEN;
> 	drvinfo->testinfo_len = NETXEN_NIC_TEST_LEN;
> 	drvinfo->regdump_len = NETXEN_NIC_REGS_LEN;
>@@ -125,8 +124,7 @@
> static int
> netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	struct netxen_board_info *boardinfo = &adapter->ahw.boardcfg;
> 
> 	/* read which mode */
>@@ -146,8 +144,8 @@
> 		ecmd->port = PORT_TP;
> 
> 		if (netif_running(dev)) {
>-			ecmd->speed = port->link_speed;
>-			ecmd->duplex = port->link_duplex;
>+			ecmd->speed = adapter->link_speed;
>+			ecmd->duplex = adapter->link_duplex;
> 		} else
> 			return -EIO;	/* link absent */
> 	} else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
>@@ -165,7 +163,7 @@
> 	} else
> 		return -EIO;
> 
>-	ecmd->phy_address = port->portnum;
>+	ecmd->phy_address = adapter->portnum;
> 	ecmd->transceiver = XCVR_EXTERNAL;
> 
> 	switch ((netxen_brdtype_t) boardinfo->board_type) {
>@@ -179,7 +177,7 @@
> 		ecmd->port = PORT_TP;
> 		ecmd->autoneg = (boardinfo->board_type ==
> 				 NETXEN_BRDTYPE_P2_SB31_10G_CX4) ?
>-		    (AUTONEG_DISABLE) : (port->link_autoneg);
>+		    (AUTONEG_DISABLE) : (adapter->link_autoneg);
> 		break;
> 	case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
> 	case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
>@@ -206,23 +204,22 @@
> static int
> netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	__u32 status;
> 
> 	/* read which mode */
> 	if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
> 		/* autonegotiation */
> 		if (adapter->phy_write
>-		    && adapter->phy_write(adapter, port->portnum,
>+		    && adapter->phy_write(adapter,
> 					  NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
> 					  ecmd->autoneg) != 0)
> 			return -EIO;
> 		else
>-			port->link_autoneg = ecmd->autoneg;
>+			adapter->link_autoneg = ecmd->autoneg;
> 
> 		if (adapter->phy_read
>-		    && adapter->phy_read(adapter, port->portnum,
>+		    && adapter->phy_read(adapter,
> 					 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
> 					 &status) != 0)
> 			return -EIO;
>@@ -245,13 +242,13 @@
> 		if (ecmd->duplex == DUPLEX_FULL)
> 			netxen_set_phy_duplex(status);
> 		if (adapter->phy_write
>-		    && adapter->phy_write(adapter, port->portnum,
>+		    && adapter->phy_write(adapter,
> 					  NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
> 					  *((int *)&status)) != 0)
> 			return -EIO;
> 		else {
>-			port->link_speed = ecmd->speed;
>-			port->link_duplex = ecmd->duplex;
>+			adapter->link_speed = ecmd->speed;
>+			adapter->link_duplex = ecmd->duplex;
> 		}
> 	} else
> 		return -EOPNOTSUPP;
>@@ -360,15 +357,14 @@
> static void
> netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	__u32 mode, *regs_buff = p;
> 	void __iomem *addr;
> 	int i, window;
> 
> 	memset(p, 0, NETXEN_NIC_REGS_LEN);
> 	regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
>-	    (port->pdev)->device;
>+	    (adapter->pdev)->device;
> 	/* which mode */
> 	NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_MODE, &regs_buff[0]);
> 	mode = regs_buff[0];
>@@ -383,7 +379,8 @@
> 		for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) {
> 			/* GB: port specific registers */
> 			if (mode == 0 && i >= 19)
>-				window = port->portnum * NETXEN_NIC_PORT_WINDOW;
>+				window = physical_port[adapter->portnum] *
>+					NETXEN_NIC_PORT_WINDOW;
> 
> 			NETXEN_NIC_LOCKED_READ_REG(niu_registers[mode].
> 						   reg[i - 3] + window,
>@@ -395,15 +392,14 @@
> 
> static u32 netxen_nic_test_link(struct net_device *dev)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	__u32 status;
> 	int val;
> 
> 	/* read which mode */
> 	if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
> 		if (adapter->phy_read
>-		    && adapter->phy_read(adapter, port->portnum,
>+		    && adapter->phy_read(adapter,
> 					 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
> 					 &status) != 0)
> 			return -EIO;
>@@ -422,15 +418,15 @@
> netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
> 		      u8 * bytes)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	int offset;
> 	int ret;
> 
> 	if (eeprom->len == 0)
> 		return -EINVAL;
> 
>-	eeprom->magic = (port->pdev)->vendor | ((port->pdev)->device << 16);
>+	eeprom->magic = (adapter->pdev)->vendor | 
>+			((adapter->pdev)->device << 16);
> 	offset = eeprom->offset;
> 
> 	ret = netxen_rom_fast_read_words(adapter, offset, bytes, 
>@@ -445,8 +441,7 @@
> netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
> 			u8 * bytes)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	int offset = eeprom->offset;
> 	static int flash_start;
> 	static int ready_to_flash;
>@@ -475,7 +470,7 @@
> 		return 0;
> 	}
> 
>-	if (offset == BOOTLD_START) {
>+	if (offset == NETXEN_BOOTLD_START) {
> 		ret = netxen_flash_erase_primary(adapter);
> 		if (ret != FLASH_SUCCESS) {
> 			printk(KERN_ERR "%s: Flash erase failed.\n", 
>@@ -483,10 +478,10 @@
> 			return ret;
> 		}
> 
>-		ret = netxen_rom_se(adapter, USER_START);
>+		ret = netxen_rom_se(adapter, NETXEN_USER_START);
> 		if (ret != FLASH_SUCCESS)
> 			return ret;
>-		ret = netxen_rom_se(adapter, FIXED_START);
>+		ret = netxen_rom_se(adapter, NETXEN_FIXED_START);
> 		if (ret != FLASH_SUCCESS)
> 			return ret;
> 
>@@ -516,8 +511,7 @@
> static void
> netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	int i;
> 
> 	ring->rx_pending = 0;
>@@ -541,19 +535,45 @@
> netxen_nic_get_pauseparam(struct net_device *dev,
> 			  struct ethtool_pauseparam *pause)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	__u32 val;
>+	int port = physical_port[adapter->portnum];
> 
> 	if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
>+		if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
>+			return;
> 		/* get flow control settings */
>-		netxen_nic_read_w0(adapter,
>-				   NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum),
>-				   &val);
>+		netxen_nic_read_w0(adapter,NETXEN_NIU_GB_MAC_CONFIG_0(port),
>+				&val);
> 		pause->rx_pause = netxen_gb_get_rx_flowctl(val);
>-		pause->tx_pause = netxen_gb_get_tx_flowctl(val);
>-		/* get autoneg settings */
>-		pause->autoneg = port->link_autoneg;
>+		netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
>+		switch (port) {
>+			case 0:
>+				pause->tx_pause = !(netxen_gb_get_gb0_mask(val));
>+				break;
>+			case 1:
>+				pause->tx_pause = !(netxen_gb_get_gb1_mask(val));
>+				break;
>+			case 2:
>+				pause->tx_pause = !(netxen_gb_get_gb2_mask(val));
>+				break;
>+			case 3:
>+			default:
>+				pause->tx_pause = !(netxen_gb_get_gb3_mask(val));
>+				break;
>+		}
>+	} else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
>+		if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
>+			return;
>+		pause->rx_pause = 1;
>+		netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
>+		if (port == 0)
>+			pause->tx_pause = !(netxen_xg_get_xg0_mask(val));
>+		else
>+			pause->tx_pause = !(netxen_xg_get_xg1_mask(val));
>+	} else {
>+		printk(KERN_ERR"%s: Unknown board type: %x\n", 
>+				netxen_nic_driver_name, adapter->ahw.board_type);
> 	}
> }
> 
>@@ -561,42 +581,76 @@
> netxen_nic_set_pauseparam(struct net_device *dev,
> 			  struct ethtool_pauseparam *pause)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	__u32 val;
>-	unsigned int autoneg;
>-
>+	int port = physical_port[adapter->portnum];
> 	/* read mode */
> 	if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
>+		if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
>+			return -EIO;
> 		/* set flow control */
> 		netxen_nic_read_w0(adapter,
>-				   NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum),
>-				   (u32 *) & val);
>-		if (pause->tx_pause)
>-			netxen_gb_tx_flowctl(val);
>-		else
>-			netxen_gb_unset_tx_flowctl(val);
>+					NETXEN_NIU_GB_MAC_CONFIG_0(port), &val);
>+		
> 		if (pause->rx_pause)
> 			netxen_gb_rx_flowctl(val);
> 		else
> 			netxen_gb_unset_rx_flowctl(val);
> 
>-		netxen_nic_write_w0(adapter,
>-				    NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum),
>-				    *&val);
>+		netxen_nic_write_w0(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
>+				val);
> 		/* set autoneg */
>-		autoneg = pause->autoneg;
>-		if (adapter->phy_write
>-		    && adapter->phy_write(adapter, port->portnum,
>-					  NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
>-					  autoneg) != 0)
>+		netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
>+		switch (port) {
>+			case 0:
>+				if (pause->tx_pause)
>+					netxen_gb_unset_gb0_mask(val);
>+				else
>+					netxen_gb_set_gb0_mask(val);
>+				break;
>+			case 1:
>+				if (pause->tx_pause)
>+					netxen_gb_unset_gb1_mask(val);
>+				else
>+					netxen_gb_set_gb1_mask(val);
>+				break;
>+			case 2:
>+				if (pause->tx_pause)
>+					netxen_gb_unset_gb2_mask(val);
>+				else
>+					netxen_gb_set_gb2_mask(val);
>+				break;
>+			case 3:
>+			default:
>+				if (pause->tx_pause)
>+					netxen_gb_unset_gb3_mask(val);
>+				else
>+					netxen_gb_set_gb3_mask(val);
>+				break;
>+		}
>+		netxen_nic_write_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, val);
>+	} else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
>+		if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
> 			return -EIO;
>-		else {
>-			port->link_autoneg = pause->autoneg;
>-			return 0;
>+		netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
>+		if (port == 0) {
>+			if (pause->tx_pause)
>+				netxen_xg_unset_xg0_mask(val);
>+			else
>+				netxen_xg_set_xg0_mask(val);
>+		} else {
>+			if (pause->tx_pause)
>+				netxen_xg_unset_xg1_mask(val);
>+			else
>+				netxen_xg_set_xg1_mask(val);
> 		}
>-	} else
>-		return -EOPNOTSUPP;
>+		netxen_nic_write_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);			
>+	} else {
>+		printk(KERN_ERR "%s: Unknown board type: %x\n",
>+				netxen_nic_driver_name, 
>+				adapter->ahw.board_type);
>+	}
>+	return 0;
> }
> 
> static int netxen_nic_reg_test(struct net_device *dev)
>@@ -627,23 +681,12 @@
> netxen_nic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
> 		     u64 * data)
> {
>-	if (eth_test->flags == ETH_TEST_FL_OFFLINE) {	/* offline tests */
>-		/* link test */
>-		if ((data[1] = (u64) netxen_nic_test_link(dev)))
>-			eth_test->flags |= ETH_TEST_FL_FAILED;
>-
>-		/* register tests */
>-		if ((data[0] = netxen_nic_reg_test(dev)))
>-			eth_test->flags |= ETH_TEST_FL_FAILED;
>-	} else {		/* online tests */
>-		/* register tests */
>-		if((data[0] = netxen_nic_reg_test(dev)))
>-			eth_test->flags |= ETH_TEST_FL_FAILED;
>-
>-		/* link test */
>-		if ((data[1] = (u64) netxen_nic_test_link(dev)))
>-			eth_test->flags |= ETH_TEST_FL_FAILED;
>-	}
>+	memset(data, 0, sizeof(uint64_t) * NETXEN_NIC_TEST_LEN);
>+	if ((data[0] = netxen_nic_reg_test(dev)))
>+		eth_test->flags |= ETH_TEST_FL_FAILED;
>+	/* link test */
>+	if ((data[1] = (u64) netxen_nic_test_link(dev)))
>+		eth_test->flags |= ETH_TEST_FL_FAILED;
> }
> 
> static void
>@@ -675,12 +718,13 @@
> netxen_nic_get_ethtool_stats(struct net_device *dev,
> 			     struct ethtool_stats *stats, u64 * data)
> {
>-	struct netxen_port *port = netdev_priv(dev);
>+	struct netxen_adapter *adapter = netdev_priv(dev);
> 	int index;
> 
> 	for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
> 		char *p =
>-		    (char *)port + netxen_nic_gstrings_stats[index].stat_offset;
>+		    (char *)adapter +
>+		    netxen_nic_gstrings_stats[index].stat_offset;
> 		data[index] =
> 		    (netxen_nic_gstrings_stats[index].sizeof_stat ==
> 		     sizeof(u64)) ? *(u64 *) p : *(u32 *) p;
>@@ -711,5 +755,4 @@
> 	.get_strings = netxen_nic_get_strings,
> 	.get_stats_count = netxen_nic_get_stats_count,
> 	.get_ethtool_stats = netxen_nic_get_ethtool_stats,
>-	.get_perm_addr = ethtool_op_get_perm_addr,
> };
>Index: linux-git/drivers/net/netxen/netxen_nic.h
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic.h	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic.h	2007-09-27 10:36:10.000000000 -0700
>@@ -64,13 +64,14 @@
> #include "netxen_nic_hw.h"
> 
> #define _NETXEN_NIC_LINUX_MAJOR 3
>-#define _NETXEN_NIC_LINUX_MINOR 3
>-#define _NETXEN_NIC_LINUX_SUBVERSION 3
>-#define NETXEN_NIC_LINUX_VERSIONID  "3.3.3"
>-
>-#define NUM_FLASH_SECTORS (64)
>-#define FLASH_SECTOR_SIZE (64 * 1024)
>-#define FLASH_TOTAL_SIZE  (NUM_FLASH_SECTORS * FLASH_SECTOR_SIZE)
>+#define _NETXEN_NIC_LINUX_MINOR 4
>+#define _NETXEN_NIC_LINUX_SUBVERSION 2
>+#define NETXEN_NIC_LINUX_VERSIONID  "3.4.2"
>+
>+#define NETXEN_NUM_FLASH_SECTORS (64)
>+#define NETXEN_FLASH_SECTOR_SIZE (64 * 1024)
>+#define NETXEN_FLASH_TOTAL_SIZE  (NETXEN_NUM_FLASH_SECTORS \
>+					* NETXEN_FLASH_SECTOR_SIZE)
> 
> #define PHAN_VENDOR_ID 0x4040
> 
>@@ -131,8 +132,8 @@
> #define FIRST_PAGE_GROUP_START	0
> #define FIRST_PAGE_GROUP_END	0x100000
> 
>-#define SECOND_PAGE_GROUP_START	0x4000000
>-#define SECOND_PAGE_GROUP_END	0x66BC000
>+#define SECOND_PAGE_GROUP_START	0x6000000
>+#define SECOND_PAGE_GROUP_END	0x68BC000
> 
> #define THIRD_PAGE_GROUP_START	0x70E4000
> #define THIRD_PAGE_GROUP_END	0x8000000
>@@ -205,6 +206,8 @@
> 
> #define MAX_CMD_DESCRIPTORS		1024
> #define MAX_RCV_DESCRIPTORS		16384
>+#define MAX_CMD_DESCRIPTORS_HOST	(MAX_CMD_DESCRIPTORS / 4)
>+#define MAX_RCV_DESCRIPTORS_1G		(MAX_RCV_DESCRIPTORS / 4)
> #define MAX_JUMBO_RCV_DESCRIPTORS	1024
> #define MAX_LRO_RCV_DESCRIPTORS		64
> #define MAX_RCVSTATUS_DESCRIPTORS	MAX_RCV_DESCRIPTORS
>@@ -230,7 +233,9 @@
> 	(((index) + (count)) & ((length) - 1))
> 
> #define MPORT_SINGLE_FUNCTION_MODE 0x1111
>+#define MPORT_MULTI_FUNCTION_MODE 0x2222
> 
>+#include "netxen_nic_phan_reg.h"
> extern unsigned long long netxen_dma_mask;
> extern unsigned long last_schedule_time;
> 
>@@ -300,6 +305,8 @@
> 
> #define netxen_set_cmd_desc_port(cmd_desc, var)	\
> 	((cmd_desc)->port_ctxid |= ((var) & 0x0F))
>+#define netxen_set_cmd_desc_ctxid(cmd_desc, var)	\
>+	((cmd_desc)->port_ctxid |= ((var) & 0xF0))
> 
> #define netxen_set_cmd_desc_flags(cmd_desc, val)	\
> 	((cmd_desc)->flags_opcode &= ~cpu_to_le16(0x7f), \
>@@ -442,7 +449,7 @@
> 	/* Bit pattern: 0-6 lro_count indicates frag sequence,
> 	   7 last_frag indicates last frag */
> 	u8 lro;
>-} __attribute__ ((aligned(8)));
>+} __attribute__ ((aligned(16)));
> 
> enum {
> 	NETXEN_RCV_PEG_0 = 0,
>@@ -671,28 +678,28 @@
> 
> /* Flash memory map */
> typedef enum {
>-	CRBINIT_START = 0,	/* Crbinit section */
>-	BRDCFG_START = 0x4000,	/* board config */
>-	INITCODE_START = 0x6000,	/* pegtune code */
>-	BOOTLD_START = 0x10000,	/* bootld */
>-	IMAGE_START = 0x43000,	/* compressed image */
>-	SECONDARY_START = 0x200000,	/* backup images */
>-	PXE_START = 0x3E0000,	/* user defined region */
>-	USER_START = 0x3E8000,	/* User defined region for new boards */
>-	FIXED_START = 0x3F0000	/* backup of crbinit */
>+	NETXEN_CRBINIT_START = 0,	/* Crbinit section */
>+	NETXEN_BRDCFG_START = 0x4000,	/* board config */
>+	NETXEN_INITCODE_START = 0x6000,	/* pegtune code */
>+	NETXEN_BOOTLD_START = 0x10000,	/* bootld */
>+	NETXEN_IMAGE_START = 0x43000,	/* compressed image */
>+	NETXEN_SECONDARY_START = 0x200000,	/* backup images */
>+	NETXEN_PXE_START = 0x3E0000,	/* user defined region */
>+	NETXEN_USER_START = 0x3E8000,	/* User defined region for new boards */
>+	NETXEN_FIXED_START = 0x3F0000	/* backup of crbinit */
> } netxen_flash_map_t;
> 
>-#define USER_START_OLD PXE_START	/* for backward compatibility */
>+#define NETXEN_USER_START_OLD NETXEN_PXE_START	/* for backward compatibility */
> 
>-#define FLASH_START		(CRBINIT_START)
>-#define INIT_SECTOR		(0)
>-#define PRIMARY_START 		(BOOTLD_START)
>-#define FLASH_CRBINIT_SIZE 	(0x4000)
>-#define FLASH_BRDCFG_SIZE 	(sizeof(struct netxen_board_info))
>-#define FLASH_USER_SIZE		(sizeof(struct netxen_user_info)/sizeof(u32))
>-#define FLASH_SECONDARY_SIZE 	(USER_START-SECONDARY_START)
>-#define NUM_PRIMARY_SECTORS	(0x20)
>-#define NUM_CONFIG_SECTORS 	(1)
>+#define NETXEN_FLASH_START		(NETXEN_CRBINIT_START)
>+#define NETXEN_INIT_SECTOR		(0)
>+#define NETXEN_PRIMARY_START 		(NETXEN_BOOTLD_START)
>+#define NETXEN_FLASH_CRBINIT_SIZE 	(0x4000)
>+#define NETXEN_FLASH_BRDCFG_SIZE 	(sizeof(struct netxen_board_info))
>+#define NETXEN_FLASH_USER_SIZE		(sizeof(struct netxen_user_info)/sizeof(u32))
>+#define NETXEN_FLASH_SECONDARY_SIZE 	(NETXEN_USER_START-NETXEN_SECONDARY_START)
>+#define NETXEN_NUM_PRIMARY_SECTORS	(0x20)
>+#define NETXEN_NUM_CONFIG_SECTORS 	(1)
> #define PFX "NetXen: "
> extern char netxen_nic_driver_name[];
> 
>@@ -703,10 +710,8 @@
> #else
> #define DPRINTK(klevel, fmt, args...)	do { \
> 	printk(KERN_##klevel PFX "%s: %s: " fmt, __FUNCTION__,\
>-		(adapter != NULL && \
>-		adapter->port[0] != NULL && \
>-		adapter->port[0]->netdev != NULL) ? \
>-		adapter->port[0]->netdev->name : NULL, \
>+		(adapter != NULL && adapter->netdev != NULL) ? \
>+		adapter->netdev->name : NULL, \
> 		## args); } while(0)
> #endif
> 
>@@ -722,6 +727,18 @@
> 	u32 length;
> };
> 
>+#define _netxen_set_bits(config_word, start, bits, val)	{\
>+	unsigned long long __tmask = (((1ULL << (bits)) - 1) << (start));\
>+	unsigned long long __tvalue = (val);    \
>+	(config_word) &= ~__tmask;      \
>+	(config_word) |= (((__tvalue) << (start)) & __tmask); \
>+}
>+	
>+#define _netxen_clear_bits(config_word, start, bits) {\
>+	unsigned long long __tmask = (((1ULL << (bits)) - 1) << (start));  \
>+	(config_word) &= ~__tmask; \
>+}		
>+
> /*    Following defines are for the state of the buffers    */
> #define	NETXEN_BUFFER_FREE	0
> #define	NETXEN_BUFFER_BUSY	1
>@@ -766,6 +783,8 @@
> 	void __iomem *pci_base0;
> 	void __iomem *pci_base1;
> 	void __iomem *pci_base2;
>+	unsigned long first_page_group_end;
>+	unsigned long first_page_group_start;
> 	void __iomem *db_base;
> 	unsigned long db_len;
> 
>@@ -780,6 +799,7 @@
> 	struct pci_dev *cmd_desc_pdev;
> 	dma_addr_t cmd_desc_phys_addr;
> 	struct netxen_adapter *adapter;
>+	int pci_func;
> };
> 
> #define RCV_RING_LRO	RCV_DESC_LRO
>@@ -788,17 +808,27 @@
> #define ETHERNET_FCS_SIZE		4
> 
> struct netxen_adapter_stats {
>-	u64 ints;
>-	u64 hostints;
>-	u64 otherints;
>-	u64 process_rcv;
>-	u64 process_xmit;
>-	u64 noxmitdone;
>-	u64 xmitcsummed;
>-	u64 post_called;
>-	u64 posted;
>-	u64 lastposted;
>-	u64 goodskbposts;
>+	u64  rcvdbadskb;
>+	u64  xmitcalled;
>+	u64  xmitedframes;
>+	u64  xmitfinished;
>+	u64  badskblen;
>+	u64  nocmddescriptor;
>+	u64  polled;
>+	u64  uphappy;
>+	u64  updropped;
>+	u64  uplcong;
>+	u64  uphcong;
>+	u64  upmcong;
>+	u64  updunno;
>+	u64  skbfreed;
>+	u64  txdropped;
>+	u64  txnullskb;
>+	u64  csummed;
>+	u64  no_rcv;
>+	u64  rxbytes;
>+	u64  txbytes;
>+	u64  ints;
> };
> 
> /*
>@@ -846,13 +876,20 @@
> 
> struct netxen_adapter {
> 	struct netxen_hardware_context ahw;
>-	int port_count;		/* Number of configured ports  */
>-	int active_ports;	/* Number of open ports */
>-	struct netxen_port *port[NETXEN_MAX_PORTS];	/* ptr to each port  */
>+	
>+	struct netxen_adapter *master;
>+	struct net_device *netdev;
>+	struct pci_dev *pdev;
>+	struct net_device_stats net_stats;
>+	unsigned char mac_addr[ETH_ALEN];
>+	int mtu;
>+	int portnum;
>+
> 	spinlock_t tx_lock;
> 	spinlock_t lock;
> 	struct work_struct watchdog_task;
> 	struct timer_list watchdog_timer;
>+	struct work_struct  tx_timeout_task;
> 
> 	u32 curr_window;
> 
>@@ -875,6 +912,15 @@
> 	u32 temp;
> 
> 	struct netxen_adapter_stats stats;
>+	
>+	u16 portno;
>+	u16 link_speed;
>+	u16 link_duplex;
>+	u16 state;
>+	u16 link_autoneg;
>+	int rcsum;
>+	int status;
>+	spinlock_t stats_lock;
> 
> 	struct netxen_cmd_buffer *cmd_buf_arr;	/* Command buffers for xmit */
> 
>@@ -891,64 +937,41 @@
> 	struct netxen_ring_ctx *ctx_desc;
> 	struct pci_dev *ctx_desc_pdev;
> 	dma_addr_t ctx_desc_phys_addr;
>-	int (*enable_phy_interrupts) (struct netxen_adapter *, int);
>-	int (*disable_phy_interrupts) (struct netxen_adapter *, int);
>+	int intr_scheme;
>+	int (*enable_phy_interrupts) (struct netxen_adapter *);
>+	int (*disable_phy_interrupts) (struct netxen_adapter *);
> 	void (*handle_phy_intr) (struct netxen_adapter *);
>-	int (*macaddr_set) (struct netxen_port *, netxen_ethernet_macaddr_t);
>-	int (*set_mtu) (struct netxen_port *, int);
>-	int (*set_promisc) (struct netxen_adapter *, int,
>-			    netxen_niu_prom_mode_t);
>-	int (*unset_promisc) (struct netxen_adapter *, int,
>-			      netxen_niu_prom_mode_t);
>-	int (*phy_read) (struct netxen_adapter *, long phy, long reg, u32 *);
>-	int (*phy_write) (struct netxen_adapter *, long phy, long reg, u32 val);
>+	int (*macaddr_set) (struct netxen_adapter *, netxen_ethernet_macaddr_t);
>+	int (*set_mtu) (struct netxen_adapter *, int);
>+	int (*set_promisc) (struct netxen_adapter *, netxen_niu_prom_mode_t);
>+	int (*unset_promisc) (struct netxen_adapter *, netxen_niu_prom_mode_t);
>+	int (*phy_read) (struct netxen_adapter *, long reg, u32 *);
>+	int (*phy_write) (struct netxen_adapter *, long reg, u32 val);
> 	int (*init_port) (struct netxen_adapter *, int);
> 	void (*init_niu) (struct netxen_adapter *);
>-	int (*stop_port) (struct netxen_adapter *, int);
>+	int (*stop_port) (struct netxen_adapter *);
> };				/* netxen_adapter structure */
> 
>-/* Max number of xmit producer threads that can run simultaneously */
>-#define	MAX_XMIT_PRODUCERS		16
>-
>-struct netxen_port_stats {
>-	u64 rcvdbadskb;
>-	u64 xmitcalled;
>-	u64 xmitedframes;
>-	u64 xmitfinished;
>-	u64 badskblen;
>-	u64 nocmddescriptor;
>-	u64 polled;
>-	u64 uphappy;
>-	u64 updropped;
>-	u64 uplcong;
>-	u64 uphcong;
>-	u64 upmcong;
>-	u64 updunno;
>-	u64 skbfreed;
>-	u64 txdropped;
>-	u64 txnullskb;
>-	u64 csummed;
>-	u64 no_rcv;
>-	u64 rxbytes;
>-	u64 txbytes;
>-};
>-
>-struct netxen_port {
>-	struct netxen_adapter *adapter;
>-
>-	u16 portnum;		/* GBE port number */
>-	u16 link_speed;
>-	u16 link_duplex;
>-	u16 link_autoneg;
>+/*
>+ * NetXen dma watchdog control structure
>+ *
>+ *	Bit 0		: enabled => R/O: 1 watchdog active, 0 inactive
>+ *	Bit 1		: disable_request => 1 req disable dma watchdog
>+ *	Bit 2		: enable_request =>  1 req enable dma watchdog
>+ *	Bit 3-31	: unused
>+ */
> 
>-	int flags;
>+#define netxen_set_dma_watchdog_disable_req(config_word) \
>+	_netxen_set_bits(config_word, 1, 1, 1)
>+#define netxen_set_dma_watchdog_enable_req(config_word) \
>+	_netxen_set_bits(config_word, 2, 1, 1)
>+#define netxen_get_dma_watchdog_enabled(config_word) \
>+	((config_word) & 0x1)
>+#define netxen_get_dma_watchdog_disabled(config_word) \
>+	(((config_word) >> 1) & 0x1)
> 
>-	struct net_device *netdev;
>-	struct pci_dev *pdev;
>-	struct net_device_stats net_stats;
>-	struct netxen_port_stats stats;
>-	struct work_struct tx_timeout_task;
>-};
>+/* Max number of xmit producer threads that can run simultaneously */
>+#define	MAX_XMIT_PRODUCERS		16
> 
> #define PCI_OFFSET_FIRST_RANGE(adapter, off)    \
> 	((adapter)->ahw.pci_base0 + (off))
>@@ -987,32 +1010,26 @@
> 	return NULL;
> }
> 
>-int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter,
>-					  int port);
>-int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter,
>-					 int port);
>-int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter,
>-					   int port);
>-int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter,
>-					  int port);
>-int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter,
>-					 int port);
>-int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter,
>-					int port);
>+int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter);
>+int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter);
>+int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter);
>+int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter);
>+int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter);
>+int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter);
> void netxen_nic_xgbe_handle_phy_intr(struct netxen_adapter *adapter);
> void netxen_nic_gbe_handle_phy_intr(struct netxen_adapter *adapter);
> void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter, int port,
> 				 long enable);
> void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter, int port,
> 				  long enable);
>-int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long phy, long reg,
>+int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
> 			    __u32 * readval);
>-int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long phy,
>+int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter,
> 			     long reg, __u32 val);
> 
> /* Functions available from netxen_nic_hw.c */
>-int netxen_nic_set_mtu_xgb(struct netxen_port *port, int new_mtu);
>-int netxen_nic_set_mtu_gb(struct netxen_port *port, int new_mtu);
>+int netxen_nic_set_mtu_xgb(struct netxen_adapter *adapter, int new_mtu);
>+int netxen_nic_set_mtu_gb(struct netxen_adapter *adapter, int new_mtu);
> void netxen_nic_init_niu_gb(struct netxen_adapter *adapter);
> void netxen_nic_pci_change_crbwindow(struct netxen_adapter *adapter, u32 wndw);
> void netxen_nic_reg_write(struct netxen_adapter *adapter, u64 off, u32 val);
>@@ -1027,12 +1044,13 @@
> 			   int len);
> void netxen_crb_writelit_adapter(struct netxen_adapter *adapter,
> 				 unsigned long off, int data);
>+int netxen_nic_erase_pxe(struct netxen_adapter *adapter);
> 
> /* Functions from netxen_nic_init.c */
> void netxen_free_adapter_offload(struct netxen_adapter *adapter);
> int netxen_initialize_adapter_offload(struct netxen_adapter *adapter);
>-void netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val);
>-void netxen_load_firmware(struct netxen_adapter *adapter);
>+int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val);
>+int netxen_load_firmware(struct netxen_adapter *adapter);
> int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose);
> int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp);
> int netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr, 
>@@ -1050,12 +1068,10 @@
> int netxen_do_rom_se(struct netxen_adapter *adapter, int addr);
> 
> /* Functions from netxen_nic_isr.c */
>+int netxen_nic_link_ok(struct netxen_adapter *adapter);
> void netxen_nic_isr_other(struct netxen_adapter *adapter);
>-void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 port,
>-				 u32 link);
>-void netxen_handle_port_int(struct netxen_adapter *adapter, u32 port,
>-			    u32 enable);
>-void netxen_nic_stop_all_ports(struct netxen_adapter *adapter);
>+void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 link);
>+void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable);
> void netxen_initialize_adapter_sw(struct netxen_adapter *adapter);
> void netxen_initialize_adapter_hw(struct netxen_adapter *adapter);
> void *netxen_alloc(struct pci_dev *pdev, size_t sz, dma_addr_t * ptr,
>@@ -1081,39 +1097,6 @@
> int netxen_nic_set_mac(struct net_device *netdev, void *p);
> struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev);
> 
>-static inline void netxen_nic_disable_int(struct netxen_adapter *adapter)
>-{
>-	/*
>-	 * ISR_INT_MASK: Can be read from window 0 or 1.
>-	 */
>-	writel(0x7ff, PCI_OFFSET_SECOND_RANGE(adapter, ISR_INT_MASK));
>-
>-}
>-
>-static inline void netxen_nic_enable_int(struct netxen_adapter *adapter)
>-{
>-	u32 mask;
>-
>-	switch (adapter->ahw.board_type) {
>-	case NETXEN_NIC_GBE:
>-		mask = 0x77b;
>-		break;
>-	case NETXEN_NIC_XGBE:
>-		mask = 0x77f;
>-		break;
>-	default:
>-		mask = 0x7ff;
>-		break;
>-	}
>-
>-	writel(mask, PCI_OFFSET_SECOND_RANGE(adapter, ISR_INT_MASK));
>-
>-	if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
>-		mask = 0xbff;
>-		writel(mask, PCI_OFFSET_SECOND_RANGE(adapter,
>-						     ISR_INT_TARGET_MASK));
>-	}
>-}
> 
> /*
>  * NetXen Board information
>@@ -1166,6 +1149,61 @@
> 		name = "Unknown";
> }
> 
>+static inline int
>+dma_watchdog_shutdown_request(struct netxen_adapter *adapter)
>+{
>+	u32 ctrl;
>+
>+	/* check if already inactive */
>+	if (netxen_nic_hw_read_wx(adapter,
>+	    NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), &ctrl, 4))
>+		printk(KERN_ERR "failed to read dma watchdog status\n");
>+
>+	if (netxen_get_dma_watchdog_enabled(ctrl) == 0)
>+		return 1;
>+
>+	/* Send the disable request */
>+	netxen_set_dma_watchdog_disable_req(ctrl);
>+	netxen_crb_writelit_adapter(adapter,
>+		NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), ctrl);
>+
>+	return 0;
>+}
>+
>+static inline int
>+dma_watchdog_shutdown_poll_result(struct netxen_adapter *adapter)
>+{
>+	u32 ctrl;
>+
>+	if (netxen_nic_hw_read_wx(adapter,
>+	    NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), &ctrl, 4))
>+		printk(KERN_ERR "failed to read dma watchdog status\n");
>+
>+	return (netxen_get_dma_watchdog_enabled(ctrl) == 0);
>+}
>+
>+static inline int
>+dma_watchdog_wakeup(struct netxen_adapter *adapter)
>+{
>+	u32 ctrl;
>+
>+	if (netxen_nic_hw_read_wx(adapter,
>+		NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), &ctrl, 4))
>+		printk(KERN_ERR "failed to read dma watchdog status\n");
>+
>+	if (netxen_get_dma_watchdog_enabled(ctrl))
>+		return 1;
>+
>+	/* send the wakeup request */
>+	netxen_set_dma_watchdog_enable_req(ctrl);
>+
>+	netxen_crb_writelit_adapter(adapter,
>+		NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), ctrl);
>+
>+	return 0;
>+}
>+
>+
> int netxen_is_flash_supported(struct netxen_adapter *adapter);
> int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, u64 mac[]);
> extern void netxen_change_ringparam(struct netxen_adapter *adapter);
>@@ -1174,4 +1212,5 @@
> 
> extern struct ethtool_ops netxen_nic_ethtool_ops;
> 
>+extern int physical_port[];	/* physical port # from virtual port.*/
> #endif				/* __NETXEN_NIC_H_ */
>Index: linux-git/drivers/net/netxen/netxen_nic_hdr.h
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_hdr.h	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_hdr.h	2007-09-27 10:36:10.000000000 -0700
>@@ -467,6 +467,8 @@
> #define NETXEN_PCI_OCM1		(0x05100000UL)
> #define NETXEN_PCI_OCM1_MAX	(0x051fffffUL)
> #define NETXEN_PCI_CRBSPACE	(0x06000000UL)
>+#define NETXEN_PCI_128MB_SIZE	(0x08000000UL)
>+#define NETXEN_PCI_32MB_SIZE	(0x02000000UL)
> 
> #define NETXEN_CRB_CAM	NETXEN_PCI_CRB_WINDOW(NETXEN_HW_PX_MAP_CRB_CAM)
> 
>@@ -484,6 +486,7 @@
> 	/* 10 seconds before we give up */
> #define	NETXEN_NIU_PHY_WAITMAX		50
> #define	NETXEN_NIU_MAX_GBE_PORTS	4
>+#define	NETXEN_NIU_MAX_XG_PORTS		2
> 
> #define	NETXEN_NIU_MODE			(NETXEN_CRB_NIU + 0x00000)
> 
>@@ -527,6 +530,7 @@
> #define	NETXEN_NIU_XG_PAUSE_CTL		(NETXEN_CRB_NIU + 0x00098)
> #define	NETXEN_NIU_XG_PAUSE_LEVEL	(NETXEN_CRB_NIU + 0x000dc)
> #define	NETXEN_NIU_XG_SEL		(NETXEN_CRB_NIU + 0x00128)
>+#define NETXEN_NIU_GB_PAUSE_CTL		(NETXEN_CRB_NIU + 0x0030c)
> 
> #define NETXEN_NIU_FULL_LEVEL_XG	(NETXEN_CRB_NIU + 0x00450)
> 
>@@ -645,15 +649,25 @@
> #define PCIX_INT_VECTOR		(0x10100)
> #define PCIX_INT_MASK		(0x10104)
> 
>-#define PCIX_MN_WINDOW		(0x10200)
>+#define PCIX_MN_WINDOW_F0	(0x10200)
>+#define PCIX_MN_WINDOW(_f)	(PCIX_MN_WINDOW_F0 + (0x20 * (_f)))
> #define PCIX_MS_WINDOW		(0x10204)
>-#define PCIX_SN_WINDOW		(0x10208)
>+#define PCIX_SN_WINDOW_F0	(0x10208)
>+#define PCIX_SN_WINDOW(_f)	(PCIX_SN_WINDOW_F0 + (0x20 * (_f)))
> #define PCIX_CRB_WINDOW		(0x10210)
>+#define PCIX_CRB_WINDOW_F0	(0x10210)
>+#define PCIX_CRB_WINDOW_F1	(0x10230)
>+#define PCIX_CRB_WINDOW_F2	(0x10250)
>+#define PCIX_CRB_WINDOW_F3	(0x10270)
> 
> #define PCIX_TARGET_STATUS	(0x10118)
> #define PCIX_TARGET_MASK	(0x10128)
> 
> #define PCIX_MSI_F0		(0x13000)
>+#define PCIX_MSI_F1		(0x13004)
>+#define PCIX_MSI_F2		(0x13008)
>+#define PCIX_MSI_F3		(0x1300c)
>+#define PCIX_MSI_F(i)		(0x13000+((i)*4))
> 
> #define PCIX_PS_MEM_SPACE	(0x90000)
> 
>@@ -675,4 +689,6 @@
> 
> #define PCIE_MAX_MASTER_SPLIT	(0x14048)
> 
>+#define NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL		(0x14)
>+
> #endif				/* __NETXEN_NIC_HDR_H_ */
>Index: linux-git/drivers/net/netxen/netxen_nic_hw.c
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_hw.c	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_hw.c	2007-09-27 10:36:10.000000000 -0700
>@@ -33,14 +33,231 @@
> 
> #include "netxen_nic.h"
> #include "netxen_nic_hw.h"
>+#define DEFINE_GLOBAL_RECV_CRB
> #include "netxen_nic_phan_reg.h"
> 
>+
>+#include <net/ip.h>
>+
>+struct netxen_recv_crb recv_crb_registers[] = {
>+	/*
>+	 * Instance 0.
>+	 */
>+	{
>+	 /* rcv_desc_crb: */
>+	 {
>+	  {
>+	   /* crb_rcv_producer_offset: */
>+	   NETXEN_NIC_REG(0x100),
>+	   /* crb_rcv_consumer_offset: */
>+	   NETXEN_NIC_REG(0x104),
>+	   /* crb_gloablrcv_ring: */
>+	   NETXEN_NIC_REG(0x108),
>+	   /* crb_rcv_ring_size */
>+	   NETXEN_NIC_REG(0x10c),
>+
>+	   },
>+	  /* Jumbo frames */
>+	  {
>+	   /* crb_rcv_producer_offset: */
>+	   NETXEN_NIC_REG(0x110),
>+	   /* crb_rcv_consumer_offset: */
>+	   NETXEN_NIC_REG(0x114),
>+	   /* crb_gloablrcv_ring: */
>+	   NETXEN_NIC_REG(0x118),
>+	   /* crb_rcv_ring_size */
>+	   NETXEN_NIC_REG(0x11c),
>+	   },
>+	  /* LRO */
>+	  {
>+	   /* crb_rcv_producer_offset: */
>+	   NETXEN_NIC_REG(0x120),
>+	   /* crb_rcv_consumer_offset: */
>+	   NETXEN_NIC_REG(0x124),
>+	   /* crb_gloablrcv_ring: */
>+	   NETXEN_NIC_REG(0x128),
>+	   /* crb_rcv_ring_size */
>+	   NETXEN_NIC_REG(0x12c),
>+	   }
>+	  },
>+	 /* crb_rcvstatus_ring: */
>+	 NETXEN_NIC_REG(0x130),
>+	 /* crb_rcv_status_producer: */
>+	 NETXEN_NIC_REG(0x134),
>+	 /* crb_rcv_status_consumer: */
>+	 NETXEN_NIC_REG(0x138),
>+	 /* crb_rcvpeg_state: */
>+	 NETXEN_NIC_REG(0x13c),
>+	 /* crb_status_ring_size */
>+	 NETXEN_NIC_REG(0x140),
>+
>+	 },
>+	/*
>+	 * Instance 1,
>+	 */
>+	{
>+	 /* rcv_desc_crb: */
>+	 {
>+	  {
>+	   /* crb_rcv_producer_offset: */
>+	   NETXEN_NIC_REG(0x144),
>+	   /* crb_rcv_consumer_offset: */
>+	   NETXEN_NIC_REG(0x148),
>+	   /* crb_globalrcv_ring: */
>+	   NETXEN_NIC_REG(0x14c),
>+	   /* crb_rcv_ring_size */
>+	   NETXEN_NIC_REG(0x150),
>+
>+	   },
>+	  /* Jumbo frames */
>+	  {
>+	   /* crb_rcv_producer_offset: */
>+	   NETXEN_NIC_REG(0x154),
>+	   /* crb_rcv_consumer_offset: */
>+	   NETXEN_NIC_REG(0x158),
>+	   /* crb_globalrcv_ring: */
>+	   NETXEN_NIC_REG(0x15c),
>+	   /* crb_rcv_ring_size */
>+	   NETXEN_NIC_REG(0x160),
>+	   },
>+	  /* LRO */
>+	  {
>+	   /* crb_rcv_producer_offset: */
>+	   NETXEN_NIC_REG(0x164),
>+	   /* crb_rcv_consumer_offset: */
>+	   NETXEN_NIC_REG(0x168),
>+	   /* crb_globalrcv_ring: */
>+	   NETXEN_NIC_REG(0x16c),
>+	   /* crb_rcv_ring_size */
>+	   NETXEN_NIC_REG(0x170),
>+	   }
>+
>+	  },
>+	 /* crb_rcvstatus_ring: */
>+	 NETXEN_NIC_REG(0x174),
>+	 /* crb_rcv_status_producer: */
>+	 NETXEN_NIC_REG(0x178),
>+	 /* crb_rcv_status_consumer: */
>+	 NETXEN_NIC_REG(0x17c),
>+	 /* crb_rcvpeg_state: */
>+	 NETXEN_NIC_REG(0x180),
>+	 /* crb_status_ring_size */
>+	 NETXEN_NIC_REG(0x184),
>+	 },
>+	/*
>+	 * Instance 2,
>+	 */
>+	{
>+	  {
>+	    {
>+	    /* crb_rcv_producer_offset: */
>+	    NETXEN_NIC_REG(0x1d8),
>+	    /* crb_rcv_consumer_offset: */
>+	    NETXEN_NIC_REG(0x1dc),
>+	    /* crb_gloablrcv_ring: */
>+	    NETXEN_NIC_REG(0x1f0),
>+	    /* crb_rcv_ring_size */
>+	    NETXEN_NIC_REG(0x1f4),
>+	    },
>+	    /* Jumbo frames */
>+	    {
>+	    /* crb_rcv_producer_offset: */		    
>+	    NETXEN_NIC_REG(0x1f8),
>+	    /* crb_rcv_consumer_offset: */
>+	    NETXEN_NIC_REG(0x1fc),
>+	    /* crb_gloablrcv_ring: */
>+	    NETXEN_NIC_REG(0x200),
>+	    /* crb_rcv_ring_size */
>+	    NETXEN_NIC_REG(0x204),
>+	    },
>+	    /* LRO */
>+	    {
>+	    /* crb_rcv_producer_offset: */
>+	    NETXEN_NIC_REG(0x208),
>+	    /* crb_rcv_consumer_offset: */
>+	    NETXEN_NIC_REG(0x20c),
>+	    /* crb_gloablrcv_ring: */
>+	    NETXEN_NIC_REG(0x210),
>+	    /* crb_rcv_ring_size */
>+	    NETXEN_NIC_REG(0x214),
>+	    }
>+	  },
>+	  /* crb_rcvstatus_ring: */
>+	  NETXEN_NIC_REG(0x218),
>+	  /* crb_rcv_status_producer: */
>+	  NETXEN_NIC_REG(0x21c),
>+	  /* crb_rcv_status_consumer: */
>+	  NETXEN_NIC_REG(0x220),
>+	  /* crb_rcvpeg_state: */
>+	  NETXEN_NIC_REG(0x224),
>+	  /* crb_status_ring_size */
>+	  NETXEN_NIC_REG(0x228),
>+	},
>+	/*
>+	 * Instance 3,
>+	 */
>+	{
>+	  {
>+	    {
>+	    /* crb_rcv_producer_offset: */
>+	    NETXEN_NIC_REG(0x22c),
>+	    /* crb_rcv_consumer_offset: */
>+	    NETXEN_NIC_REG(0x230),
>+	    /* crb_gloablrcv_ring: */
>+	    NETXEN_NIC_REG(0x234),
>+	    /* crb_rcv_ring_size */
>+	    NETXEN_NIC_REG(0x238),
>+	    },
>+	    /* Jumbo frames */
>+	    {
>+	    /* crb_rcv_producer_offset: */ 
>+	    NETXEN_NIC_REG(0x23c),
>+	    /* crb_rcv_consumer_offset: */
>+	    NETXEN_NIC_REG(0x240),
>+	    /* crb_gloablrcv_ring: */
>+	    NETXEN_NIC_REG(0x244),
>+	    /* crb_rcv_ring_size */
>+	    NETXEN_NIC_REG(0x248),
>+	    },
>+	    /* LRO */
>+	    {
>+	    /* crb_rcv_producer_offset: */
>+	    NETXEN_NIC_REG(0x24c),
>+	    /* crb_rcv_consumer_offset: */
>+	    NETXEN_NIC_REG(0x250),
>+	    /* crb_gloablrcv_ring: */
>+	    NETXEN_NIC_REG(0x254),
>+	    /* crb_rcv_ring_size */
>+	    NETXEN_NIC_REG(0x258),
>+	    }
>+	  },
>+	  /* crb_rcvstatus_ring: */
>+	  NETXEN_NIC_REG(0x25c),
>+	  /* crb_rcv_status_producer: */
>+	  NETXEN_NIC_REG(0x260),
>+	  /* crb_rcv_status_consumer: */
>+	  NETXEN_NIC_REG(0x264),
>+	  /* crb_rcvpeg_state: */
>+	  NETXEN_NIC_REG(0x268),
>+	  /* crb_status_ring_size */
>+	  NETXEN_NIC_REG(0x26c),
>+	},
>+};
>+
>+u64 ctx_addr_sig_regs[][3] = {
>+	{NETXEN_NIC_REG(0x188), NETXEN_NIC_REG(0x18c), NETXEN_NIC_REG(0x1c0)},
>+	{NETXEN_NIC_REG(0x190), NETXEN_NIC_REG(0x194), NETXEN_NIC_REG(0x1c4)},
>+	{NETXEN_NIC_REG(0x198), NETXEN_NIC_REG(0x19c), NETXEN_NIC_REG(0x1c8)},
>+	{NETXEN_NIC_REG(0x1a0), NETXEN_NIC_REG(0x1a4), NETXEN_NIC_REG(0x1cc)}
>+};
>+
>+
> /*  PCI Windowing for DDR regions.  */
> 
> #define ADDR_IN_RANGE(addr, low, high)	\
> 	(((addr) <= (high)) && ((addr) >= (low)))
> 
>-#define NETXEN_FLASH_BASE	(BOOTLD_START)
>+#define NETXEN_FLASH_BASE	(NETXEN_BOOTLD_START)
> #define NETXEN_PHANTOM_MEM_BASE	(NETXEN_FLASH_BASE)
> #define NETXEN_MAX_MTU		8000 + NETXEN_ENET_HEADER_SIZE + NETXEN_ETH_FCS_SIZE
> #define NETXEN_MIN_MTU		64
>@@ -68,8 +285,7 @@
> 
> int netxen_nic_set_mac(struct net_device *netdev, void *p)
> {
>-	struct netxen_port *port = netdev_priv(netdev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(netdev);
> 	struct sockaddr *addr = p;
> 
> 	if (netif_running(netdev))
>@@ -82,7 +298,7 @@
> 	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
> 
> 	if (adapter->macaddr_set)
>-		adapter->macaddr_set(port, addr->sa_data);
>+		adapter->macaddr_set(adapter, addr->sa_data);
> 
> 	return 0;
> }
>@@ -92,56 +308,19 @@
>  */
> void netxen_nic_set_multi(struct net_device *netdev)
> {
>-	struct netxen_port *port = netdev_priv(netdev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(netdev);
> 	struct dev_mc_list *mc_ptr;
>-	__u32 netxen_mac_addr_cntl_data = 0;
> 
> 	mc_ptr = netdev->mc_list;
> 	if (netdev->flags & IFF_PROMISC) {
> 		if (adapter->set_promisc)
> 			adapter->set_promisc(adapter,
>-					     port->portnum,
> 					     NETXEN_NIU_PROMISC_MODE);
> 	} else {
>-		if (adapter->unset_promisc &&
>-		    adapter->ahw.boardcfg.board_type
>-		    != NETXEN_BRDTYPE_P2_SB31_10G_IMEZ)
>+		if (adapter->unset_promisc)
> 			adapter->unset_promisc(adapter,
>-					       port->portnum,
> 					       NETXEN_NIU_NON_PROMISC_MODE);
> 	}
>-	if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
>-		netxen_nic_mcr_set_mode_select(netxen_mac_addr_cntl_data, 0x03);
>-		netxen_nic_mcr_set_id_pool0(netxen_mac_addr_cntl_data, 0x00);
>-		netxen_nic_mcr_set_id_pool1(netxen_mac_addr_cntl_data, 0x00);
>-		netxen_nic_mcr_set_id_pool2(netxen_mac_addr_cntl_data, 0x00);
>-		netxen_nic_mcr_set_id_pool3(netxen_mac_addr_cntl_data, 0x00);
>-		netxen_nic_mcr_set_enable_xtnd0(netxen_mac_addr_cntl_data);
>-		netxen_nic_mcr_set_enable_xtnd1(netxen_mac_addr_cntl_data);
>-		netxen_nic_mcr_set_enable_xtnd2(netxen_mac_addr_cntl_data);
>-		netxen_nic_mcr_set_enable_xtnd3(netxen_mac_addr_cntl_data);
>-	} else {
>-		netxen_nic_mcr_set_mode_select(netxen_mac_addr_cntl_data, 0x00);
>-		netxen_nic_mcr_set_id_pool0(netxen_mac_addr_cntl_data, 0x00);
>-		netxen_nic_mcr_set_id_pool1(netxen_mac_addr_cntl_data, 0x01);
>-		netxen_nic_mcr_set_id_pool2(netxen_mac_addr_cntl_data, 0x02);
>-		netxen_nic_mcr_set_id_pool3(netxen_mac_addr_cntl_data, 0x03);
>-	}
>-	writel(netxen_mac_addr_cntl_data,
>-	       NETXEN_CRB_NORMALIZE(adapter, NETXEN_MAC_ADDR_CNTL_REG));
>-	if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
>-		writel(netxen_mac_addr_cntl_data,
>-		       NETXEN_CRB_NORMALIZE(adapter,
>-					    NETXEN_MULTICAST_ADDR_HI_0));
>-	} else {
>-		writel(netxen_mac_addr_cntl_data,
>-		       NETXEN_CRB_NORMALIZE(adapter,
>-					    NETXEN_MULTICAST_ADDR_HI_1));
>-	}
>-	netxen_mac_addr_cntl_data = 0;
>-	writel(netxen_mac_addr_cntl_data,
>-	       NETXEN_CRB_NORMALIZE(adapter, NETXEN_NIU_GB_DROP_WRONGADDR));
> }
> 
> /*
>@@ -150,8 +329,7 @@
>  */
> int netxen_nic_change_mtu(struct net_device *netdev, int mtu)
> {
>-	struct netxen_port *port = netdev_priv(netdev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(netdev);
> 	int eff_mtu = mtu + NETXEN_ENET_HEADER_SIZE + NETXEN_ETH_FCS_SIZE;
> 
> 	if ((eff_mtu > NETXEN_MAX_MTU) || (eff_mtu < NETXEN_MIN_MTU)) {
>@@ -161,7 +339,7 @@
> 	}
> 
> 	if (adapter->set_mtu)
>-		adapter->set_mtu(port, mtu);
>+		adapter->set_mtu(adapter, mtu);
> 	netdev->mtu = mtu;
> 
> 	return 0;
>@@ -178,9 +356,9 @@
> 	void *addr;
> 	int loops = 0, err = 0;
> 	int ctx, ring;
>-	u32 card_cmdring = 0;
> 	struct netxen_recv_context *recv_ctx;
> 	struct netxen_rcv_desc_ctx *rcv_desc;
>+	int func_id = adapter->portnum;
> 
> 	DPRINTK(INFO, "crb_base: %lx %x", NETXEN_PCI_CRBSPACE,
> 		PCI_OFFSET_SECOND_RANGE(adapter, NETXEN_PCI_CRBSPACE));
>@@ -189,11 +367,6 @@
> 	DPRINTK(INFO, "cam RAM: %lx %x", NETXEN_CAM_RAM_BASE,
> 		pci_base_offset(adapter, NETXEN_CAM_RAM_BASE));
> 
>-	/* Window 1 call */
>-	card_cmdring = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_CMDRING));
>-
>-	DPRINTK(INFO, "Command Peg sends 0x%x for cmdring base\n",
>-		card_cmdring);
> 
> 	for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
> 		DPRINTK(INFO, "Command Peg ready..waiting for rcv peg\n");
>@@ -204,7 +377,7 @@
> 						   recv_crb_registers[ctx].
> 						   crb_rcvpeg_state));
> 		while (state != PHAN_PEG_RCV_INITIALIZED && loops < 20) {
>-			udelay(100);
>+			msleep(1);
> 			/* Window 1 call */
> 			state = readl(NETXEN_CRB_NORMALIZE(adapter,
> 							   recv_crb_registers
>@@ -219,7 +392,11 @@
> 			return err;
> 		}
> 	}
>-	DPRINTK(INFO, "Recieve Peg ready too. starting stuff\n");
>+	adapter->intr_scheme = readl(
>+		NETXEN_CRB_NORMALIZE(adapter, CRB_NIC_CAPABILITIES_FW));
>+	printk(KERN_NOTICE "%s: FW capabilities:0x%x\n", netxen_nic_driver_name,
>+			adapter->intr_scheme);
>+	DPRINTK(INFO, "Receive Peg ready too. starting stuff\n");
> 
> 	addr = netxen_alloc(adapter->ahw.pdev,
> 			    sizeof(struct netxen_ring_ctx) +
>@@ -227,7 +404,7 @@
> 			    (dma_addr_t *) & adapter->ctx_desc_phys_addr,
> 			    &adapter->ctx_desc_pdev);
> 
>-	printk("ctx_desc_phys_addr: 0x%llx\n",
>+	printk(KERN_INFO "ctx_desc_phys_addr: 0x%llx\n",
> 	       (unsigned long long) adapter->ctx_desc_phys_addr);
> 	if (addr == NULL) {
> 		DPRINTK(ERR, "bad return from pci_alloc_consistent\n");
>@@ -236,6 +413,7 @@
> 	}
> 	memset(addr, 0, sizeof(struct netxen_ring_ctx));
> 	adapter->ctx_desc = (struct netxen_ring_ctx *)addr;
>+	adapter->ctx_desc->ctx_id = cpu_to_le32(adapter->portnum);
> 	adapter->ctx_desc->cmd_consumer_offset =
> 	    cpu_to_le64(adapter->ctx_desc_phys_addr +
> 			sizeof(struct netxen_ring_ctx));
>@@ -247,7 +425,7 @@
> 			    adapter->max_tx_desc_count,
> 			    (dma_addr_t *) & hw->cmd_desc_phys_addr,
> 			    &adapter->ahw.cmd_desc_pdev);
>-	printk("cmd_desc_phys_addr: 0x%llx\n",
>+	printk(KERN_INFO "cmd_desc_phys_addr: 0x%llx\n",
> 	       (unsigned long long) hw->cmd_desc_phys_addr);
> 
> 	if (addr == NULL) {
>@@ -306,11 +484,11 @@
> 	/* Window = 1 */
> 
> 	writel(lower32(adapter->ctx_desc_phys_addr),
>-	       NETXEN_CRB_NORMALIZE(adapter, CRB_CTX_ADDR_REG_LO));
>+	       NETXEN_CRB_NORMALIZE(adapter, CRB_CTX_ADDR_REG_LO(func_id)));
> 	writel(upper32(adapter->ctx_desc_phys_addr),
>-	       NETXEN_CRB_NORMALIZE(adapter, CRB_CTX_ADDR_REG_HI));
>-	writel(NETXEN_CTX_SIGNATURE,
>-	       NETXEN_CRB_NORMALIZE(adapter, CRB_CTX_SIGNATURE_REG));
>+	       NETXEN_CRB_NORMALIZE(adapter, CRB_CTX_ADDR_REG_HI(func_id)));
>+	writel(NETXEN_CTX_SIGNATURE | func_id,
>+	       NETXEN_CRB_NORMALIZE(adapter, CRB_CTX_SIGNATURE_REG(func_id)));
> 	return err;
> }
> 
>@@ -337,10 +515,6 @@
> 				    adapter->ahw.cmd_desc_phys_addr);
> 		adapter->ahw.cmd_desc_head = NULL;
> 	}
>-	/* Special handling: there are 2 ports on this board */
>-	if (adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB31_10G_IMEZ) {
>-		adapter->ahw.max_ports = 2;
>-	}
> 
> 	for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
> 		recv_ctx = &adapter->recv_ctx[ctx];
>@@ -371,22 +545,20 @@
> 		      struct cmd_desc_type0 *desc, struct sk_buff *skb)
> {
> 	if (desc->mss) {
>-		desc->total_hdr_length = sizeof(struct ethhdr) +
>-		    ((skb->nh.iph)->ihl * sizeof(u32)) +
>-		    ((skb->h.th)->doff * sizeof(u32));
>+		desc->total_hdr_length = (sizeof(struct ethhdr) +
>+					  ip_hdrlen(skb) + tcp_hdrlen(skb));
> 		netxen_set_cmd_desc_opcode(desc, TX_TCP_LSO);
> 	} else if (skb->ip_summed == CHECKSUM_PARTIAL) {
>-		if (skb->nh.iph->protocol == IPPROTO_TCP) {
>+		if (ip_hdr(skb)->protocol == IPPROTO_TCP) {
> 			netxen_set_cmd_desc_opcode(desc, TX_TCP_PKT);
>-		} else if (skb->nh.iph->protocol == IPPROTO_UDP) {
>+		} else if (ip_hdr(skb)->protocol == IPPROTO_UDP) {
> 			netxen_set_cmd_desc_opcode(desc, TX_UDP_PKT);
> 		} else {
> 			return;
> 		}
> 	}
>-	adapter->stats.xmitcsummed++;
>-	desc->tcp_hdr_offset = skb->h.raw - skb->data;
>-	desc->ip_hdr_offset = skb->nh.raw - skb->data;
>+	desc->tcp_hdr_offset = skb_transport_offset(skb);
>+	desc->ip_hdr_offset = skb_network_offset(skb);
> }
> 
> int netxen_is_flash_supported(struct netxen_adapter *adapter)
>@@ -443,7 +615,7 @@
> 	u32 *pmac = (u32 *) & mac[0];
> 
> 	if (netxen_get_flash_block(adapter,
>-				   USER_START +
>+				   NETXEN_USER_START +
> 				   offsetof(struct netxen_new_user_info,
> 					    mac_addr),
> 				   FLASH_NUM_PORTS * sizeof(u64), pmac) == -1) {
>@@ -451,7 +623,7 @@
> 	}
> 	if (*mac == ~0ULL) {
> 		if (netxen_get_flash_block(adapter,
>-					   USER_START_OLD +
>+					   NETXEN_USER_START_OLD +
> 					   offsetof(struct netxen_user_old_info,
> 						    mac_addr),
> 					   FLASH_NUM_PORTS * sizeof(u64),
>@@ -474,7 +646,30 @@
> 
> 	if (adapter->curr_window == wndw)
> 		return;
>-
>+	switch(adapter->ahw.pci_func) {
>+		case 0:
>+			offset = PCI_OFFSET_SECOND_RANGE(adapter,
>+					NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW));
>+			break;
>+		case 1:
>+			offset = PCI_OFFSET_SECOND_RANGE(adapter,
>+					NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW_F1));
>+			break;
>+		case 2:
>+			offset = PCI_OFFSET_SECOND_RANGE(adapter,
>+					NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW_F2));
>+			break;
>+		case 3:
>+			offset = PCI_OFFSET_SECOND_RANGE(adapter,
>+					NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW_F3));
>+			break;
>+		default:
>+			printk(KERN_INFO "Changing the window for PCI function"
>+					"%d\n",	adapter->ahw.pci_func);
>+			offset = PCI_OFFSET_SECOND_RANGE(adapter,
>+					NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW));
>+			break;
>+	}
> 	/*
> 	 * Move the CRB window.
> 	 * We need to write to the "direct access" region of PCI
>@@ -483,9 +678,6 @@
> 	 * register address is received by PCI. The direct region bypasses
> 	 * the CRB bus.
> 	 */
>-	offset =
>-	    PCI_OFFSET_SECOND_RANGE(adapter,
>-				    NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW));
> 
> 	if (wndw & 0x1)
> 		wndw = NETXEN_WINDOW_ONE;
>@@ -503,10 +695,13 @@
> 		count++;
> 	}
> 
>-	adapter->curr_window = wndw;
>+	if (wndw == NETXEN_WINDOW_ONE)
>+		adapter->curr_window = 1;
>+	else
>+		adapter->curr_window = 0;
> }
> 
>-void netxen_load_firmware(struct netxen_adapter *adapter)
>+int netxen_load_firmware(struct netxen_adapter *adapter)
> {
> 	int i;
> 	u32 data, size = 0;
>@@ -518,15 +713,24 @@
> 	writel(1, NETXEN_CRB_NORMALIZE(adapter, NETXEN_ROMUSB_GLB_CAS_RST));
> 
> 	for (i = 0; i < size; i++) {
>-		if (netxen_rom_fast_read(adapter, flashaddr, (int *)&data) != 0) {
>-			DPRINTK(ERR,
>-				"Error in netxen_rom_fast_read(). Will skip"
>-				"loading flash image\n");
>-			return;
>-		}
>+		int retries = 10;
>+		if (netxen_rom_fast_read(adapter, flashaddr, (int *)&data) != 0)
>+			return -EIO;
>+
> 		off = netxen_nic_pci_set_window(adapter, memaddr);
> 		addr = pci_base_offset(adapter, off);
> 		writel(data, addr);
>+		do {
>+			if (readl(addr) == data)
>+				break;
>+			msleep(100);
>+			writel(data, addr);
>+		} while (--retries);
>+		if (!retries) {
>+			printk(KERN_ERR "%s: firmware load aborted, write failed at 0x%x\n",
>+					netxen_nic_driver_name, memaddr);
>+			return -EIO;
>+		}
> 		flashaddr += 4;
> 		memaddr += 4;
> 	}
>@@ -536,7 +740,7 @@
> 	       NETXEN_CRB_NORMALIZE(adapter, NETXEN_ROMUSB_GLB_CHIP_CLK_CTRL));
> 	writel(0, NETXEN_CRB_NORMALIZE(adapter, NETXEN_ROMUSB_GLB_CAS_RST));
> 
>-	udelay(100);
>+	return 0;
> }
> 
> int
>@@ -700,11 +904,11 @@
> 			ddr_mn_window = window;
> 			writel(window, PCI_OFFSET_SECOND_RANGE(adapter,
> 							       NETXEN_PCIX_PH_REG
>-							       (PCIX_MN_WINDOW)));
>+							       (PCIX_MN_WINDOW(adapter->ahw.pci_func))));
> 			/* MUST make sure window is set before we forge on... */
> 			readl(PCI_OFFSET_SECOND_RANGE(adapter,
> 						      NETXEN_PCIX_PH_REG
>-						      (PCIX_MN_WINDOW)));
>+						      (PCIX_MN_WINDOW(adapter->ahw.pci_func))));
> 		}
> 		addr -= (window * NETXEN_WINDOW_ONE);
> 		addr += NETXEN_PCI_DDR_NET;
>@@ -725,11 +929,11 @@
> 			writel((window << 22),
> 			       PCI_OFFSET_SECOND_RANGE(adapter,
> 						       NETXEN_PCIX_PH_REG
>-						       (PCIX_SN_WINDOW)));
>+						       (PCIX_SN_WINDOW(adapter->ahw.pci_func))));
> 			/* MUST make sure window is set before we forge on... */
> 			readl(PCI_OFFSET_SECOND_RANGE(adapter,
> 						      NETXEN_PCIX_PH_REG
>-						      (PCIX_SN_WINDOW)));
>+						      (PCIX_SN_WINDOW(adapter->ahw.pci_func))));
> 		}
> 		addr -= (window * 0x400000);
> 		addr += NETXEN_PCI_QDR_NET;
>@@ -748,10 +952,21 @@
> 	return addr;
> }
> 
>+int
>+netxen_nic_erase_pxe(struct netxen_adapter *adapter)
>+{
>+	if (netxen_rom_fast_write(adapter, NETXEN_PXE_START, 0) == -1) {
>+		printk(KERN_ERR "%s: erase pxe failed\n", 
>+			netxen_nic_driver_name);
>+		return -1;
>+	}
>+	return 0;
>+}
>+
> int netxen_nic_get_board_info(struct netxen_adapter *adapter)
> {
> 	int rv = 0;
>-	int addr = BRDCFG_START;
>+	int addr = NETXEN_BRDCFG_START;
> 	struct netxen_board_info *boardinfo;
> 	int index;
> 	u32 *ptr32;
>@@ -809,43 +1024,29 @@
> 
> /* NIU access sections */
> 
>-int netxen_nic_set_mtu_gb(struct netxen_port *port, int new_mtu)
>+int netxen_nic_set_mtu_gb(struct netxen_adapter *adapter, int new_mtu)
> {
>-	struct netxen_adapter *adapter = port->adapter;
> 	netxen_nic_write_w0(adapter,
>-			    NETXEN_NIU_GB_MAX_FRAME_SIZE(port->portnum),
>-			    new_mtu);
>+			NETXEN_NIU_GB_MAX_FRAME_SIZE(
>+				physical_port[adapter->portnum]), new_mtu);
> 	return 0;
> }
> 
>-int netxen_nic_set_mtu_xgb(struct netxen_port *port, int new_mtu)
>+int netxen_nic_set_mtu_xgb(struct netxen_adapter *adapter, int new_mtu)
> {
>-	struct netxen_adapter *adapter = port->adapter;
> 	new_mtu += NETXEN_NIU_HDRSIZE + NETXEN_NIU_TLRSIZE;
>-	if (port->portnum == 0)
>-	    netxen_nic_write_w0(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE, new_mtu);
>-	else if (port->portnum == 1)
>-	    netxen_nic_write_w0(adapter, NETXEN_NIU_XG1_MAX_FRAME_SIZE, new_mtu);
>+	if (physical_port[adapter->portnum] == 0)
>+		netxen_nic_write_w0(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE, 
>+				new_mtu);
>+	else 
>+		netxen_nic_write_w0(adapter, NETXEN_NIU_XG1_MAX_FRAME_SIZE,
>+				new_mtu);
> 	return 0;
> }
> 
> void netxen_nic_init_niu_gb(struct netxen_adapter *adapter)
> {
>-	int portno;
>-	for (portno = 0; portno < NETXEN_NIU_MAX_GBE_PORTS; portno++)
>-		netxen_niu_gbe_init_port(adapter, portno);
>-}
>-
>-void netxen_nic_stop_all_ports(struct netxen_adapter *adapter)
>-{
>-	int port_nr;
>-	struct netxen_port *port;
>-
>-	for (port_nr = 0; port_nr < adapter->ahw.max_ports; port_nr++) {
>-		port = adapter->port[port_nr];
>-		if (adapter->stop_port)
>-			adapter->stop_port(adapter, port->portnum);
>-	}
>+	netxen_niu_gbe_init_port(adapter, physical_port[adapter->portnum]);
> }
> 
> void
>@@ -864,9 +1065,8 @@
> 	}
> }
> 
>-void netxen_nic_set_link_parameters(struct netxen_port *port)
>+void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
> {
>-	struct netxen_adapter *adapter = port->adapter;
> 	__u32 status;
> 	__u32 autoneg;
> 	__u32 mode;
>@@ -875,47 +1075,47 @@
> 	if (netxen_get_niu_enable_ge(mode)) {	/* Gb 10/100/1000 Mbps mode */
> 		if (adapter->phy_read
> 		    && adapter->
>-		    phy_read(adapter, port->portnum,
>+		    phy_read(adapter,
> 			     NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
> 			     &status) == 0) {
> 			if (netxen_get_phy_link(status)) {
> 				switch (netxen_get_phy_speed(status)) {
> 				case 0:
>-					port->link_speed = SPEED_10;
>+					adapter->link_speed = SPEED_10;
> 					break;
> 				case 1:
>-					port->link_speed = SPEED_100;
>+					adapter->link_speed = SPEED_100;
> 					break;
> 				case 2:
>-					port->link_speed = SPEED_1000;
>+					adapter->link_speed = SPEED_1000;
> 					break;
> 				default:
>-					port->link_speed = -1;
>+					adapter->link_speed = -1;
> 					break;
> 				}
> 				switch (netxen_get_phy_duplex(status)) {
> 				case 0:
>-					port->link_duplex = DUPLEX_HALF;
>+					adapter->link_duplex = DUPLEX_HALF;
> 					break;
> 				case 1:
>-					port->link_duplex = DUPLEX_FULL;
>+					adapter->link_duplex = DUPLEX_FULL;
> 					break;
> 				default:
>-					port->link_duplex = -1;
>+					adapter->link_duplex = -1;
> 					break;
> 				}
> 				if (adapter->phy_read
> 				    && adapter->
>-				    phy_read(adapter, port->portnum,
>+				    phy_read(adapter,
> 					     NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
> 					     &autoneg) != 0)
>-					port->link_autoneg = autoneg;
>+					adapter->link_autoneg = autoneg;
> 			} else
> 				goto link_down;
> 		} else {
> 		      link_down:
>-			port->link_speed = -1;
>-			port->link_duplex = -1;
>+			adapter->link_speed = -1;
>+			adapter->link_duplex = -1;
> 		}
> 	}
> }
>@@ -928,8 +1128,8 @@
> 	u32 fw_build = 0;
> 	char brd_name[NETXEN_MAX_SHORT_NAME];
> 	struct netxen_new_user_info user_info;
>-	int i, addr = USER_START;
>-	u32 *ptr32;
>+	int i, addr = NETXEN_USER_START;
>+	__le32 *ptr32;
> 
> 	struct netxen_board_info *board_info = &(adapter->ahw.boardcfg);
> 	if (board_info->magic != NETXEN_BDINFO_MAGIC) {
>@@ -955,7 +1155,6 @@
> 				       netxen_nic_driver_name);
> 				return;
> 			}
>-			*ptr32 = le32_to_cpu(*ptr32);
> 			ptr32++;
> 			addr += sizeof(u32);
> 		}
>Index: linux-git/drivers/net/netxen/netxen_nic_hw.h
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_hw.h	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_hw.h	2007-09-27 10:36:10.000000000 -0700
>@@ -6,12 +6,12 @@
>  * modify it under the terms of the GNU General Public License
>  * as published by the Free Software Foundation; either version 2
>  * of the License, or (at your option) any later version.
>- *                            
>+ *
>  * This program is distributed in the hope that it will be useful, but
>  * WITHOUT ANY WARRANTY; without even the implied warranty of
>  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>  * GNU General Public License for more details.
>- *                                   
>+ *
>  * You should have received a copy of the GNU General Public License
>  * along with this program; if not, write to the Free Software
>  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
>@@ -87,7 +87,7 @@
> 	*(u32 *)Y = readl((void __iomem*) addr);
> 
> struct netxen_port;
>-void netxen_nic_set_link_parameters(struct netxen_port *port);
>+void netxen_nic_set_link_parameters(struct netxen_adapter *adapter);
> void netxen_nic_flash_print(struct netxen_adapter *adapter);
> int netxen_nic_hw_write_wx(struct netxen_adapter *adapter, u64 off,
> 			   void *data, int len);
>@@ -220,6 +220,69 @@
> 		_netxen_crb_get_bit(config_word, 1)
> #define netxen_get_gb_mii_mgmt_notvalid(config_word)	\
> 		_netxen_crb_get_bit(config_word, 2)
>+/*
>+ * NIU XG Pause Ctl Register
>+ *
>+ *      Bit 0       : xg0_mask => 1:disable tx pause frames
>+ *      Bit 1       : xg0_request => 1:request single pause frame
>+ *      Bit 2       : xg0_on_off => 1:request is pause on, 0:off
>+ *      Bit 3       : xg1_mask => 1:disable tx pause frames
>+ *      Bit 4       : xg1_request => 1:request single pause frame
>+ *      Bit 5       : xg1_on_off => 1:request is pause on, 0:off
>+ */
>+
>+#define netxen_xg_set_xg0_mask(config_word)    \
>+	((config_word) |= 1 << 0)
>+#define netxen_xg_set_xg1_mask(config_word)    \
>+	((config_word) |= 1 << 3)
>+		
>+#define netxen_xg_get_xg0_mask(config_word)    \
>+	_netxen_crb_get_bit((config_word), 0)
>+#define netxen_xg_get_xg1_mask(config_word)    \
>+	_netxen_crb_get_bit((config_word), 3)
>+
>+#define netxen_xg_unset_xg0_mask(config_word)  \
>+	((config_word) &= ~(1 << 0))
>+#define netxen_xg_unset_xg1_mask(config_word)  \
>+	((config_word) &= ~(1 << 3))
>+
>+/*
>+ * NIU XG Pause Ctl Register
>+ *
>+ *      Bit 0       : xg0_mask => 1:disable tx pause frames
>+ *      Bit 1       : xg0_request => 1:request single pause frame
>+ *      Bit 2       : xg0_on_off => 1:request is pause on, 0:off
>+ *      Bit 3       : xg1_mask => 1:disable tx pause frames
>+ *      Bit 4       : xg1_request => 1:request single pause frame
>+ *      Bit 5       : xg1_on_off => 1:request is pause on, 0:off
>+ */
>+#define netxen_gb_set_gb0_mask(config_word)    \
>+	((config_word) |= 1 << 0)
>+#define netxen_gb_set_gb1_mask(config_word)    \
>+	((config_word) |= 1 << 2)
>+#define netxen_gb_set_gb2_mask(config_word)    \
>+	((config_word) |= 1 << 4)
>+#define netxen_gb_set_gb3_mask(config_word)    \
>+	((config_word) |= 1 << 6)
>+
>+#define netxen_gb_get_gb0_mask(config_word)    \
>+	_netxen_crb_get_bit((config_word), 0)
>+#define netxen_gb_get_gb1_mask(config_word)    \
>+	_netxen_crb_get_bit((config_word), 2)
>+#define netxen_gb_get_gb2_mask(config_word)    \
>+	_netxen_crb_get_bit((config_word), 4)
>+#define netxen_gb_get_gb3_mask(config_word)    \
>+	_netxen_crb_get_bit((config_word), 6)
>+	
>+#define netxen_gb_unset_gb0_mask(config_word)  \
>+	((config_word) &= ~(1 << 0))
>+#define netxen_gb_unset_gb1_mask(config_word)  \
>+	((config_word) &= ~(1 << 2))
>+#define netxen_gb_unset_gb2_mask(config_word)  \
>+	((config_word) &= ~(1 << 4))
>+#define netxen_gb_unset_gb3_mask(config_word)  \
>+	((config_word) &= ~(1 << 6))
>+
> 
> /*
>  * PHY-Specific MII control/status registers.
>@@ -452,21 +515,21 @@
> 		((config) |= (((val) & 0x0f) << 28))
> 
> /* Set promiscuous mode for a GbE interface */
>-int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, int port,
>+int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, 
> 				    netxen_niu_prom_mode_t mode);
> int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
>-				       int port, netxen_niu_prom_mode_t mode);
>+				       netxen_niu_prom_mode_t mode);
> 
> /* get/set the MAC address for a given MAC */
>-int netxen_niu_macaddr_get(struct netxen_adapter *adapter, int port,
>+int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
> 			   netxen_ethernet_macaddr_t * addr);
>-int netxen_niu_macaddr_set(struct netxen_port *port,
>+int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
> 			   netxen_ethernet_macaddr_t addr);
> 
> /* XG versons */
>-int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int port,
>+int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter,
> 			      netxen_ethernet_macaddr_t * addr);
>-int netxen_niu_xg_macaddr_set(struct netxen_port *port,
>+int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
> 			      netxen_ethernet_macaddr_t addr);
> 
> /* Generic enable for GbE ports. Will detect the speed of the link. */
>@@ -475,8 +538,8 @@
> int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port);
> 
> /* Disable a GbE interface */
>-int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter, int port);
>+int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter);
> 
>-int netxen_niu_disable_xg_port(struct netxen_adapter *adapter, int port);
>+int netxen_niu_disable_xg_port(struct netxen_adapter *adapter);
> 
> #endif				/* __NETXEN_NIC_HW_H_ */
>Index: linux-git/drivers/net/netxen/netxen_nic_init.c
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_init.c	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_init.c	2007-09-27 10:36:10.000000000 -0700
>@@ -139,7 +139,9 @@
> 		return err;
> 	}
> 	/* Window 1 call */
>-	writel(MPORT_SINGLE_FUNCTION_MODE,
>+	writel(INTR_SCHEME_PERPORT,
>+	       NETXEN_CRB_NORMALIZE(adapter, CRB_NIC_CAPABILITIES_HOST));
>+	writel(MPORT_MULTI_FUNCTION_MODE,
> 	       NETXEN_CRB_NORMALIZE(adapter, CRB_MPORT_MODE));
> 	writel(PHAN_INITIALIZE_ACK,
> 	       NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
>@@ -226,7 +228,6 @@
> 		adapter->unset_promisc = netxen_niu_set_promiscuous_mode;
> 		adapter->phy_read = netxen_niu_gbe_phy_read;
> 		adapter->phy_write = netxen_niu_gbe_phy_write;
>-		adapter->init_port = netxen_niu_gbe_init_port;
> 		adapter->init_niu = netxen_nic_init_niu_gb;
> 		adapter->stop_port = netxen_niu_disable_gbe_port;
> 		break;
>@@ -277,8 +278,8 @@
> 		return (pci_base + offset);
> }
> 
>-static long rom_max_timeout = 10000;
>-static long rom_lock_timeout = 1000000;
>+static long rom_max_timeout = 100;
>+static long rom_lock_timeout = 10000;
> static long rom_write_timeout = 700;
> 
> static inline int rom_lock(struct netxen_adapter *adapter)
>@@ -406,10 +407,7 @@
> static inline int
> do_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
> {
>-	if (jiffies > (last_schedule_time + (8 * HZ))) {
>-		last_schedule_time = jiffies;
>-		schedule();
>-	}
>+	cond_resched();
> 
> 	netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
> 	netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
>@@ -438,9 +436,9 @@
> 
> 	for (addridx = addr; addridx < (addr + size); addridx += 4) {
> 		ret = do_rom_fast_read(adapter, addridx, (int *)bytes);
>-		*(int *)bytes = cpu_to_le32(*(int *)bytes);
> 		if (ret != 0)
> 			break;
>+		*(int *)bytes = cpu_to_le32(*(int *)bytes);
> 		bytes += 4;
> 	}
> 
>@@ -499,7 +497,6 @@
> 		int data;
> 
> 		data = le32_to_cpu((*(u32*)bytes));
>-
> 		ret = do_rom_fast_write(adapter, addridx, data);
> 		if (ret < 0)
> 			return ret;
>@@ -587,7 +584,7 @@
> {
> 	int ret = FLASH_SUCCESS;
> 	int val;
>-	char *buffer = kmalloc(FLASH_SECTOR_SIZE, GFP_KERNEL);
>+	char *buffer = kmalloc(NETXEN_FLASH_SECTOR_SIZE, GFP_KERNEL);
> 
> 	if (!buffer)
> 		return -ENOMEM;	
>@@ -603,13 +600,13 @@
> 		goto out_kfree;
> 
> 	/* copy  sector 0 to sector 63 */
>-	ret = netxen_rom_fast_read_words(adapter, CRBINIT_START, 
>-						buffer, FLASH_SECTOR_SIZE);
>+	ret = netxen_rom_fast_read_words(adapter, NETXEN_CRBINIT_START, 
>+					buffer, NETXEN_FLASH_SECTOR_SIZE);
> 	if (ret != FLASH_SUCCESS)
> 		goto out_kfree;
> 
>-	ret = netxen_rom_fast_write_words(adapter, FIXED_START, 
>-						buffer, FLASH_SECTOR_SIZE);
>+	ret = netxen_rom_fast_write_words(adapter, NETXEN_FIXED_START, 
>+					buffer, NETXEN_FLASH_SECTOR_SIZE);
> 	if (ret != FLASH_SUCCESS)
> 		goto out_kfree;
> 
>@@ -656,7 +653,8 @@
> 	int count = 0, erased_errors = 0;
> 	int range;
> 
>-	range = (addr == USER_START) ? FIXED_START : addr + FLASH_SECTOR_SIZE;
>+	range = (addr == NETXEN_USER_START) ? 
>+		NETXEN_FIXED_START : addr + NETXEN_FLASH_SECTOR_SIZE;
> 	
> 	for (i = addr; i < range; i += 4) {
> 		netxen_rom_fast_read(adapter, i, &val);
>@@ -691,7 +689,7 @@
> 	int i;
> 
> 	for (i = start; i < end; i++) {
>-		ret = netxen_rom_se(adapter, i * FLASH_SECTOR_SIZE);
>+		ret = netxen_rom_se(adapter, i * NETXEN_FLASH_SECTOR_SIZE);
> 		if (ret)
> 			break;
> 		ret = netxen_rom_wip_poll(adapter);
>@@ -708,8 +706,8 @@
> 	int ret = FLASH_SUCCESS;
> 	int start, end;
> 
>-	start = SECONDARY_START / FLASH_SECTOR_SIZE;
>-	end   = USER_START / FLASH_SECTOR_SIZE;
>+	start = NETXEN_SECONDARY_START / NETXEN_FLASH_SECTOR_SIZE;
>+	end   = NETXEN_USER_START / NETXEN_FLASH_SECTOR_SIZE;
> 	ret = netxen_flash_erase_sections(adapter, start, end);
> 
> 	return ret;
>@@ -721,8 +719,8 @@
> 	int ret = FLASH_SUCCESS;
> 	int start, end;
> 
>-	start = PRIMARY_START / FLASH_SECTOR_SIZE;
>-	end   = SECONDARY_START / FLASH_SECTOR_SIZE;
>+	start = NETXEN_PRIMARY_START / NETXEN_FLASH_SECTOR_SIZE;
>+	end   = NETXEN_SECONDARY_START / NETXEN_FLASH_SECTOR_SIZE;
> 	ret = netxen_flash_erase_sections(adapter, start, end);
> 
> 	return ret;
>@@ -855,10 +853,10 @@
> 				netxen_nic_pci_change_crbwindow(adapter, 1);
> 			}
> 			if (init_delay == 1) {
>-				ssleep(1);
>+				msleep(2000);
> 				init_delay = 0;
> 			}
>-			msleep(1);
>+			msleep(20);
> 		}
> 		kfree(buf);
> 
>@@ -934,10 +932,6 @@
> void netxen_free_adapter_offload(struct netxen_adapter *adapter)
> {
> 	if (adapter->dummy_dma.addr) {
>-		writel(0, NETXEN_CRB_NORMALIZE(adapter,
>-			CRB_HOST_DUMMY_BUF_ADDR_HI));
>-		writel(0, NETXEN_CRB_NORMALIZE(adapter,
>-			CRB_HOST_DUMMY_BUF_ADDR_LO));
> 		pci_free_consistent(adapter->ahw.pdev,
> 				    NETXEN_HOST_DUMMY_DMA_SIZE,
> 				    adapter->dummy_dma.addr,
>@@ -946,24 +940,32 @@
> 	}
> }
> 
>-void netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
>+int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
> {
> 	u32 val = 0;
>-	int loops = 0;
>+	int retries = 30;
> 
> 	if (!pegtune_val) {
>-		val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
>-		while (val != PHAN_INITIALIZE_COMPLETE && loops < 200000) {
>-			udelay(100);
>-			schedule();
>-			val =
>-			    readl(NETXEN_CRB_NORMALIZE
>+		do {
>+			val = readl(NETXEN_CRB_NORMALIZE
> 				  (adapter, CRB_CMDPEG_STATE));
>-			loops++;
>+			pegtune_val = readl(NETXEN_CRB_NORMALIZE
>+				  (adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
>+
>+			if (val == PHAN_INITIALIZE_COMPLETE ||
>+				val == PHAN_INITIALIZE_ACK)
>+				return 0;
>+
>+			msleep(1000);
>+		} while (--retries);
>+		if (!retries) {
>+			printk(KERN_WARNING "netxen_phantom_init: init failed, "
>+					"pegtune_val=%x\n", pegtune_val);
>+			return -1;
> 		}
>-		if (val != PHAN_INITIALIZE_COMPLETE)
>-			printk("WARNING: Initial boot wait loop failed...\n");
> 	}
>+
>+	return 0;
> }
> 
> int netxen_nic_rx_has_work(struct netxen_adapter *adapter)
>@@ -990,9 +992,7 @@
> 
> static inline int netxen_nic_check_temp(struct netxen_adapter *adapter)
> {
>-	int port_num;
>-	struct netxen_port *port;
>-	struct net_device *netdev;
>+	struct net_device *netdev = adapter->netdev;
> 	uint32_t temp, temp_state, temp_val;
> 	int rv = 0;
> 
>@@ -1006,14 +1006,9 @@
> 		       "%s: Device temperature %d degrees C exceeds"
> 		       " maximum allowed. Hardware has been shut down.\n",
> 		       netxen_nic_driver_name, temp_val);
>-		for (port_num = 0; port_num < adapter->ahw.max_ports;
>-		     port_num++) {
>-			port = adapter->port[port_num];
>-			netdev = port->netdev;
> 
>-			netif_carrier_off(netdev);
>-			netif_stop_queue(netdev);
>-		}
>+		netif_carrier_off(netdev);
>+		netif_stop_queue(netdev);
> 		rv = 1;
> 	} else if (temp_state == NX_TEMP_WARN) {
> 		if (adapter->temp == NX_TEMP_NORMAL) {
>@@ -1037,31 +1032,30 @@
> 
> void netxen_watchdog_task(struct work_struct *work)
> {
>-	int port_num;
>-	struct netxen_port *port;
> 	struct net_device *netdev;
> 	struct netxen_adapter *adapter =
> 		container_of(work, struct netxen_adapter, watchdog_task);
> 
>-	if (netxen_nic_check_temp(adapter))
>+	if ((adapter->portnum  == 0) && netxen_nic_check_temp(adapter))
> 		return;
> 
>-	for (port_num = 0; port_num < adapter->ahw.max_ports; port_num++) {
>-		port = adapter->port[port_num];
>-		netdev = port->netdev;
>-
>-		if ((netif_running(netdev)) && !netif_carrier_ok(netdev)) {
>-			printk(KERN_INFO "%s port %d, %s carrier is now ok\n",
>-			       netxen_nic_driver_name, port_num, netdev->name);
>-			netif_carrier_on(netdev);
>-		}
>+	if (adapter->handle_phy_intr)
>+		adapter->handle_phy_intr(adapter);
> 
>-		if (netif_queue_stopped(netdev))
>-			netif_wake_queue(netdev);
>+	netdev = adapter->netdev;
>+	if ((netif_running(netdev)) && !netif_carrier_ok(netdev) &&
>+			netxen_nic_link_ok(adapter) ) {
>+		printk(KERN_INFO "%s %s (port %d), Link is up\n",
>+			       netxen_nic_driver_name, netdev->name, adapter->portnum);
>+		netif_carrier_on(netdev);
>+		netif_wake_queue(netdev);
>+	} else if(!(netif_running(netdev)) && netif_carrier_ok(netdev)) {
>+		printk(KERN_ERR "%s %s Link is Down\n",
>+				netxen_nic_driver_name, netdev->name);
>+		netif_carrier_off(netdev);
>+		netif_stop_queue(netdev);
> 	}
> 
>-	if (adapter->handle_phy_intr)
>-		adapter->handle_phy_intr(adapter);
> 	mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
> }
> 
>@@ -1074,9 +1068,8 @@
> netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
> 		   struct status_desc *desc)
> {
>-	struct netxen_port *port = adapter->port[netxen_get_sts_port(desc)];
>-	struct pci_dev *pdev = port->pdev;
>-	struct net_device *netdev = port->netdev;
>+	struct pci_dev *pdev = adapter->pdev;
>+	struct net_device *netdev = adapter->netdev;
> 	int index = netxen_get_sts_refhandle(desc);
> 	struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctxid]);
> 	struct netxen_rx_buffer *buffer;
>@@ -1126,7 +1119,7 @@
> 	skb = (struct sk_buff *)buffer->skb;
> 
> 	if (likely(netxen_get_sts_status(desc) == STATUS_CKSUM_OK)) {
>-		port->stats.csummed++;
>+		adapter->stats.csummed++;
> 		skb->ip_summed = CHECKSUM_UNNECESSARY;
> 	}
> 	skb->dev = netdev;
>@@ -1147,27 +1140,27 @@
> 	 */
> 	switch (ret) {
> 	case NET_RX_SUCCESS:
>-		port->stats.uphappy++;
>+		adapter->stats.uphappy++;
> 		break;
> 
> 	case NET_RX_CN_LOW:
>-		port->stats.uplcong++;
>+		adapter->stats.uplcong++;
> 		break;
> 
> 	case NET_RX_CN_MOD:
>-		port->stats.upmcong++;
>+		adapter->stats.upmcong++;
> 		break;
> 
> 	case NET_RX_CN_HIGH:
>-		port->stats.uphcong++;
>+		adapter->stats.uphcong++;
> 		break;
> 
> 	case NET_RX_DROP:
>-		port->stats.updropped++;
>+		adapter->stats.updropped++;
> 		break;
> 
> 	default:
>-		port->stats.updunno++;
>+		adapter->stats.updunno++;
> 		break;
> 	}
> 
>@@ -1179,14 +1172,13 @@
> 	/*
> 	 * We just consumed one buffer so post a buffer.
> 	 */
>-	adapter->stats.post_called++;
> 	buffer->skb = NULL;
> 	buffer->state = NETXEN_BUFFER_FREE;
> 	buffer->lro_current_frags = 0;
> 	buffer->lro_expected_frags = 0;
> 
>-	port->stats.no_rcv++;
>-	port->stats.rxbytes += length;
>+	adapter->stats.no_rcv++;
>+	adapter->stats.rxbytes += length;
> }
> 
> /* Process Receive status ring */
>@@ -1227,15 +1219,15 @@
> 
> 	/* update the consumer index in phantom */
> 	if (count) {
>-		adapter->stats.process_rcv++;
> 		recv_ctx->status_rx_consumer = consumer;
> 		recv_ctx->status_rx_producer = producer;
> 
> 		/* Window = 1 */
> 		writel(consumer,
> 		       NETXEN_CRB_NORMALIZE(adapter,
>-					    recv_crb_registers[ctxid].
>+					    recv_crb_registers[adapter->portnum].
> 					    crb_rcv_status_consumer));
>+		wmb();
> 	}
> 
> 	return count;
>@@ -1250,13 +1242,10 @@
> 	int count1 = 0;
> 	int count2 = 0;
> 	struct netxen_cmd_buffer *buffer;
>-	struct netxen_port *port;	/* port #1 */
>-	struct netxen_port *nport;
> 	struct pci_dev *pdev;
> 	struct netxen_skb_frag *frag;
> 	u32 i;
> 	struct sk_buff *skb = NULL;
>-	int p;
> 	int done;
> 
> 	spin_lock(&adapter->tx_lock);
>@@ -1277,7 +1266,6 @@
> 	}
> 
> 	adapter->proc_cmd_buf_counter++;
>-	adapter->stats.process_xmit++;
> 	/*
> 	 * Not needed - does not seem to be used anywhere.
> 	 * adapter->cmd_consumer = consumer;
>@@ -1286,38 +1274,38 @@
> 
> 	while ((last_consumer != consumer) && (count1 < MAX_STATUS_HANDLE)) {
> 		buffer = &adapter->cmd_buf_arr[last_consumer];
>-		port = adapter->port[buffer->port];
>-		pdev = port->pdev;
>+		pdev = adapter->pdev;
> 		frag = &buffer->frag_array[0];
> 		skb = buffer->skb;
> 		if (skb && (cmpxchg(&buffer->skb, skb, 0) == skb)) {
> 			pci_unmap_single(pdev, frag->dma, frag->length,
> 					 PCI_DMA_TODEVICE);
>+			frag->dma = 0ULL;
> 			for (i = 1; i < buffer->frag_count; i++) {
> 				DPRINTK(INFO, "getting fragment no %d\n", i);
> 				frag++;	/* Get the next frag */
> 				pci_unmap_page(pdev, frag->dma, frag->length,
> 					       PCI_DMA_TODEVICE);
>+				frag->dma = 0ULL;
> 			}
> 
>-			port->stats.skbfreed++;
>+			adapter->stats.skbfreed++;
> 			dev_kfree_skb_any(skb);
> 			skb = NULL;
> 		} else if (adapter->proc_cmd_buf_counter == 1) {
>-			port->stats.txnullskb++;
>+			adapter->stats.txnullskb++;
> 		}
>-		if (unlikely(netif_queue_stopped(port->netdev)
>-			     && netif_carrier_ok(port->netdev))
>-		    && ((jiffies - port->netdev->trans_start) >
>-			port->netdev->watchdog_timeo)) {
>-			SCHEDULE_WORK(&port->tx_timeout_task);
>+		if (unlikely(netif_queue_stopped(adapter->netdev)
>+			     && netif_carrier_ok(adapter->netdev))
>+		    && ((jiffies - adapter->netdev->trans_start) >
>+			adapter->netdev->watchdog_timeo)) {
>+			SCHEDULE_WORK(&adapter->tx_timeout_task);
> 		}
> 
> 		last_consumer = get_next_index(last_consumer,
> 					       adapter->max_tx_desc_count);
> 		count1++;
> 	}
>-	adapter->stats.noxmitdone += count1;
> 
> 	count2 = 0;
> 	spin_lock(&adapter->tx_lock);
>@@ -1337,13 +1325,10 @@
> 		}
> 	}
> 	if (count1 || count2) {
>-		for (p = 0; p < adapter->ahw.max_ports; p++) {
>-			nport = adapter->port[p];
>-			if (netif_queue_stopped(nport->netdev)
>-			    && (nport->flags & NETXEN_NETDEV_STATUS)) {
>-				netif_wake_queue(nport->netdev);
>-				nport->flags &= ~NETXEN_NETDEV_STATUS;
>-			}
>+		if (netif_queue_stopped(adapter->netdev)
>+		    && (adapter->flags & NETXEN_NETDEV_STATUS)) {
>+			netif_wake_queue(adapter->netdev);
>+			adapter->flags &= ~NETXEN_NETDEV_STATUS;
> 		}
> 	}
> 	/*
>@@ -1389,7 +1374,6 @@
> 	netxen_ctx_msg msg = 0;
> 	dma_addr_t dma;
> 
>-	adapter->stats.post_called++;
> 	rcv_desc = &recv_ctx->rcv_desc[ringid];
> 
> 	producer = rcv_desc->producer;
>@@ -1442,8 +1426,6 @@
> 	if (count) {
> 		rcv_desc->begin_alloc = index;
> 		rcv_desc->rcv_pending += count;
>-		adapter->stats.lastposted = count;
>-		adapter->stats.posted += count;
> 		rcv_desc->producer = producer;
> 		if (rcv_desc->rcv_free >= 32) {
> 			rcv_desc->rcv_free = 0;
>@@ -1451,7 +1433,8 @@
> 			writel((producer - 1) &
> 			       (rcv_desc->max_rx_desc_count - 1),
> 			       NETXEN_CRB_NORMALIZE(adapter,
>-						    recv_crb_registers[0].
>+						    recv_crb_registers[
>+						    adapter->portnum].
> 						    rcv_desc_crb[ringid].
> 						    crb_rcv_producer_offset));
> 			/*
>@@ -1464,11 +1447,12 @@
> 					     ((producer -
> 					       1) & (rcv_desc->
> 						     max_rx_desc_count - 1)));
>-			netxen_set_msg_ctxid(msg, 0);
>+			netxen_set_msg_ctxid(msg, adapter->portnum);
> 			netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid));
> 			writel(msg,
> 			       DB_NORMALIZE(adapter,
> 					    NETXEN_RCV_PRODUCER_OFFSET));
>+			wmb();
> 		}
> 	}
> }
>@@ -1486,7 +1470,6 @@
> 	int count = 0;
> 	int index = 0;
> 
>-	adapter->stats.post_called++;
> 	rcv_desc = &recv_ctx->rcv_desc[ringid];
> 
> 	producer = rcv_desc->producer;
>@@ -1533,8 +1516,6 @@
> 	if (count) {
> 		rcv_desc->begin_alloc = index;
> 		rcv_desc->rcv_pending += count;
>-		adapter->stats.lastposted = count;
>-		adapter->stats.posted += count;
> 		rcv_desc->producer = producer;
> 		if (rcv_desc->rcv_free >= 32) {
> 			rcv_desc->rcv_free = 0;
>@@ -1542,7 +1523,8 @@
> 			writel((producer - 1) &
> 			       (rcv_desc->max_rx_desc_count - 1),
> 			       NETXEN_CRB_NORMALIZE(adapter,
>-						    recv_crb_registers[0].
>+						    recv_crb_registers[
>+						    adapter->portnum].
> 						    rcv_desc_crb[ringid].
> 						    crb_rcv_producer_offset));
> 			wmb();
>@@ -1563,13 +1545,7 @@
> 
> void netxen_nic_clear_stats(struct netxen_adapter *adapter)
> {
>-	struct netxen_port *port;
>-	int port_num;
>-
> 	memset(&adapter->stats, 0, sizeof(adapter->stats));
>-	for (port_num = 0; port_num < adapter->ahw.max_ports; port_num++) {
>-		port = adapter->port[port_num];
>-		memset(&port->stats, 0, sizeof(port->stats));
>-	}
>+	return;
> }
> 
>Index: linux-git/drivers/net/netxen/netxen_nic_isr.c
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_isr.c	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_isr.c	2007-09-27 10:36:10.000000000 -0700
>@@ -6,12 +6,12 @@
>  * modify it under the terms of the GNU General Public License
>  * as published by the Free Software Foundation; either version 2
>  * of the License, or (at your option) any later version.
>- *                            
>+ *
>  * This program is distributed in the hope that it will be useful, but
>  * WITHOUT ANY WARRANTY; without even the implied warranty of
>  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>  * GNU General Public License for more details.
>- *                                   
>+ *
>  * You should have received a copy of the GNU General Public License
>  * along with this program; if not, write to the Free Software
>  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
>@@ -40,35 +40,35 @@
>  */
> struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
> {
>-	struct netxen_port *port = netdev_priv(netdev);
>-	struct net_device_stats *stats = &port->net_stats;
>+	struct netxen_adapter *adapter = netdev_priv(netdev);
>+	struct net_device_stats *stats = &adapter->net_stats;
> 
> 	memset(stats, 0, sizeof(*stats));
> 
> 	/* total packets received   */
>-	stats->rx_packets = port->stats.no_rcv;
>+	stats->rx_packets = adapter->stats.no_rcv;
> 	/* total packets transmitted    */
>-	stats->tx_packets = port->stats.xmitedframes + port->stats.xmitfinished;
>+	stats->tx_packets = adapter->stats.xmitedframes + 
>+		adapter->stats.xmitfinished;
> 	/* total bytes received     */
>-	stats->rx_bytes = port->stats.rxbytes;
>+	stats->rx_bytes = adapter->stats.rxbytes;
> 	/* total bytes transmitted  */
>-	stats->tx_bytes = port->stats.txbytes;
>+	stats->tx_bytes = adapter->stats.txbytes;
> 	/* bad packets received     */
>-	stats->rx_errors = port->stats.rcvdbadskb;
>+	stats->rx_errors = adapter->stats.rcvdbadskb;
> 	/* packet transmit problems */
>-	stats->tx_errors = port->stats.nocmddescriptor;
>+	stats->tx_errors = adapter->stats.nocmddescriptor;
> 	/* no space in linux buffers    */
>-	stats->rx_dropped = port->stats.updropped;
>+	stats->rx_dropped = adapter->stats.updropped;
> 	/* no space available in linux  */
>-	stats->tx_dropped = port->stats.txdropped;
>+	stats->tx_dropped = adapter->stats.txdropped;
> 
> 	return stats;
> }
> 
>-void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 portno,
>-				 u32 link)
>+void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 link)
> {
>-	struct net_device *netdev = (adapter->port[portno])->netdev;
>+	struct net_device *netdev = adapter->netdev;
> 
> 	if (link)
> 		netif_carrier_on(netdev);
>@@ -76,15 +76,13 @@
> 		netif_carrier_off(netdev);
> }
> 
>-void netxen_handle_port_int(struct netxen_adapter *adapter, u32 portno,
>-			    u32 enable)
>+void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable)
> {
> 	__u32 int_src;
>-	struct netxen_port *port;
> 
> 	/*  This should clear the interrupt source */
> 	if (adapter->phy_read)
>-		adapter->phy_read(adapter, portno,
>+		adapter->phy_read(adapter, 
> 				  NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
> 				  &int_src);
> 	if (int_src == 0) {
>@@ -92,9 +90,7 @@
> 		return;
> 	}
> 	if (adapter->disable_phy_interrupts)
>-		adapter->disable_phy_interrupts(adapter, portno);
>-
>-	port = adapter->port[portno];
>+		adapter->disable_phy_interrupts(adapter);
> 
> 	if (netxen_get_phy_int_jabber(int_src))
> 		DPRINTK(INFO, "Jabber interrupt \n");
>@@ -115,64 +111,57 @@
> 		DPRINTK(INFO, "SPEED CHANGED OR LINK STATUS CHANGED \n");
> 
> 		if (adapter->phy_read
>-		    && adapter->phy_read(adapter, portno,
>+		    && adapter->phy_read(adapter, 
> 					 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
> 					 &status) == 0) {
> 			if (netxen_get_phy_int_link_status_changed(int_src)) {
> 				if (netxen_get_phy_link(status)) {
>-					netxen_niu_gbe_init_port(adapter,
>-								 portno);
>-					printk("%s: %s Link UP\n",
>+					printk(KERN_INFO "%s: %s Link UP\n",
> 					       netxen_nic_driver_name,
>-					       port->netdev->name);
>+					       adapter->netdev->name);
> 
> 				} else {
>-					printk("%s: %s Link DOWN\n",
>+					printk(KERN_INFO "%s: %s Link DOWN\n",
> 					       netxen_nic_driver_name,
>-					       port->netdev->name);
>+					       adapter->netdev->name);
> 				}
>-				netxen_indicate_link_status(adapter, portno,
>+				netxen_indicate_link_status(adapter, 
> 							    netxen_get_phy_link
> 							    (status));
> 			}
> 		}
> 	}
> 	if (adapter->enable_phy_interrupts)
>-		adapter->enable_phy_interrupts(adapter, portno);
>+		adapter->enable_phy_interrupts(adapter);
> }
> 
> void netxen_nic_isr_other(struct netxen_adapter *adapter)
> {
>-	u32 portno;
>+	int portno = adapter->portnum;
> 	u32 val, linkup, qg_linksup;
> 
> 	/* verify the offset */
> 	val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
>+	val = val >> physical_port[adapter->portnum];
> 	if (val == adapter->ahw.qg_linksup)
> 		return;
> 
> 	qg_linksup = adapter->ahw.qg_linksup;
> 	adapter->ahw.qg_linksup = val;
> 	DPRINTK(INFO, "link update 0x%08x\n", val);
>-	for (portno = 0; portno < NETXEN_NIU_MAX_GBE_PORTS; portno++) {
>-		linkup = val & 1;
>-		if (linkup != (qg_linksup & 1)) {
>-			printk(KERN_INFO "%s: %s PORT %d link %s\n",
>-			       adapter->port[portno]->netdev->name,
>-			       netxen_nic_driver_name, portno,
>-			       ((linkup == 0) ? "down" : "up"));
>-			netxen_indicate_link_status(adapter, portno, linkup);
>-			if (linkup)
>-				netxen_nic_set_link_parameters(adapter->
>-							       port[portno]);
> 
>-		}
>-		val = val >> 1;
>-		qg_linksup = qg_linksup >> 1;
>-	}
>+	linkup = val & 1;
> 
>-	adapter->stats.otherints++;
>+	if (linkup != (qg_linksup & 1)) {
>+		printk(KERN_INFO "%s: %s PORT %d link %s\n",
>+		       adapter->netdev->name,
>+		       netxen_nic_driver_name, portno,
>+		       ((linkup == 0) ? "down" : "up"));
>+		netxen_indicate_link_status(adapter, linkup);
>+		if (linkup)
>+			netxen_nic_set_link_parameters(adapter);
> 
>+	}
> }
> 
> void netxen_nic_gbe_handle_phy_intr(struct netxen_adapter *adapter)
>@@ -180,30 +169,56 @@
> 	netxen_nic_isr_other(adapter);
> }
> 
>+int netxen_nic_link_ok(struct netxen_adapter *adapter)
>+{
>+	switch (adapter->ahw.board_type) {
>+	case NETXEN_NIC_GBE:
>+		return ((adapter->ahw.qg_linksup) & 1);
>+
>+	case NETXEN_NIC_XGBE:
>+		return ((adapter->ahw.xg_linkup) & 1);
>+
>+	default:
>+		printk(KERN_ERR"%s: Function: %s, Unknown board type\n",
>+			netxen_nic_driver_name, __FUNCTION__);
>+		break;
>+	}
>+
>+	return 0;
>+}
>+
> void netxen_nic_xgbe_handle_phy_intr(struct netxen_adapter *adapter)
> {
>-	struct net_device *netdev = adapter->port[0]->netdev;
>-	u32 val;
>+	struct net_device *netdev = adapter->netdev;
>+	u32 val, val1;
> 
> 	/* WINDOW = 1 */
> 	val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
>+	val >>= (physical_port[adapter->portnum] * 8);
>+	val1 = val & 0xff;
> 
>-	if (adapter->ahw.xg_linkup == 1 && val != XG_LINK_UP) {
>+	if (adapter->ahw.xg_linkup == 1 && val1 != XG_LINK_UP) {
> 		printk(KERN_INFO "%s: %s NIC Link is down\n",
> 		       netxen_nic_driver_name, netdev->name);
> 		adapter->ahw.xg_linkup = 0;
>+		if (netif_running(netdev)) {
>+			netif_carrier_off(netdev);
>+			netif_stop_queue(netdev);
>+		}
> 		/* read twice to clear sticky bits */
> 		/* WINDOW = 0 */
>-		netxen_nic_read_w0(adapter, NETXEN_NIU_XG_STATUS, &val);
>-		netxen_nic_read_w0(adapter, NETXEN_NIU_XG_STATUS, &val);
>+		netxen_nic_read_w0(adapter, NETXEN_NIU_XG_STATUS, &val1);
>+		netxen_nic_read_w0(adapter, NETXEN_NIU_XG_STATUS, &val1);
> 
> 		if ((val & 0xffb) != 0xffb) {
> 			printk(KERN_INFO "%s ISR: Sync/Align BAD: 0x%08x\n",
>-			       netxen_nic_driver_name, val);
>+			       netxen_nic_driver_name, val1);
> 		}
>-	} else if (adapter->ahw.xg_linkup == 0 && val == XG_LINK_UP) {
>+	} else if (adapter->ahw.xg_linkup == 0 && val1 == XG_LINK_UP) {
> 		printk(KERN_INFO "%s: %s NIC Link is up\n",
> 		       netxen_nic_driver_name, netdev->name);
> 		adapter->ahw.xg_linkup = 1;
>+		netif_carrier_on(netdev);
>+		netif_wake_queue(netdev);
> 	}
> }
>Index: linux-git/drivers/net/netxen/netxen_nic_main.c
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_main.c	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_main.c	2007-09-27 10:36:10.000000000 -0700
>@@ -36,17 +36,17 @@
> #include "netxen_nic_hw.h"
> 
> #include "netxen_nic.h"
>-#define DEFINE_GLOBAL_RECV_CRB
> #include "netxen_nic_phan_reg.h"
> 
> #include <linux/dma-mapping.h>
> #include <linux/vmalloc.h>
>+#include <net/ip.h>
> 
> MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
> MODULE_LICENSE("GPL");
> MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID);
> 
>-char netxen_nic_driver_name[] = "netxen-nic";
>+char netxen_nic_driver_name[] = "netxen_nic";
> static char netxen_nic_driver_string[] = "NetXen Network Driver version "
>     NETXEN_NIC_LINUX_VERSIONID;
> 
>@@ -54,8 +54,6 @@
> #define NETXEN_ADAPTER_UP_MAGIC 777
> #define NETXEN_NIC_PEG_TUNE 0
> 
>-u8 nx_p2_id = NX_P2_C0;
>-
> #define DMA_32BIT_MASK	0x00000000ffffffffULL
> #define DMA_35BIT_MASK	0x00000007ffffffffULL
> 
>@@ -76,6 +74,8 @@
> #endif
> static irqreturn_t netxen_intr(int irq, void *data);
> 
>+int physical_port[] = {0, 1, 2, 3};
>+
> /*  PCI Device ID Table  */
> static struct pci_device_id netxen_pci_tbl[] __devinitdata = {
> 	{PCI_DEVICE(0x4040, 0x0001)},
>@@ -93,6 +93,164 @@
> struct workqueue_struct *netxen_workq;
> static void netxen_watchdog(unsigned long);
> 
>+static inline void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
>+							uint32_t crb_producer)
>+{
>+	switch (adapter->portnum) {
>+		case 0:
>+			writel(crb_producer, NETXEN_CRB_NORMALIZE
>+					(adapter, CRB_CMD_PRODUCER_OFFSET));
>+			return;
>+		case 1:
>+			writel(crb_producer, NETXEN_CRB_NORMALIZE
>+					(adapter, CRB_CMD_PRODUCER_OFFSET_1));
>+			return;
>+		case 2:
>+			writel(crb_producer, NETXEN_CRB_NORMALIZE
>+					(adapter, CRB_CMD_PRODUCER_OFFSET_2));
>+			return;
>+		case 3:
>+			writel(crb_producer, NETXEN_CRB_NORMALIZE
>+					(adapter, CRB_CMD_PRODUCER_OFFSET_3));
>+			return;
>+		default:
>+			printk(KERN_WARNING "We tried to update "
>+					"CRB_CMD_PRODUCER_OFFSET for invalid "
>+					"PCI function id %d\n",
>+					adapter->portnum);
>+			return;
>+	}
>+}
>+
>+static inline void netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
>+							u32 crb_consumer)
>+{
>+	switch (adapter->portnum) {
>+		case 0:
>+			writel(crb_consumer, NETXEN_CRB_NORMALIZE
>+				(adapter, CRB_CMD_CONSUMER_OFFSET));
>+			return;
>+		case 1:
>+			writel(crb_consumer, NETXEN_CRB_NORMALIZE
>+				(adapter, CRB_CMD_CONSUMER_OFFSET_1));
>+			return;
>+		case 2:
>+			writel(crb_consumer, NETXEN_CRB_NORMALIZE
>+				(adapter, CRB_CMD_CONSUMER_OFFSET_2));
>+			return;
>+		case 3:
>+			writel(crb_consumer, NETXEN_CRB_NORMALIZE
>+				(adapter, CRB_CMD_CONSUMER_OFFSET_3));
>+			return;
>+		default:
>+			printk(KERN_WARNING "We tried to update "
>+					"CRB_CMD_PRODUCER_OFFSET for invalid "
>+					"PCI function id %d\n",
>+					adapter->portnum);
>+			return;
>+	}
>+}
>+
>+#define	ADAPTER_LIST_SIZE 12
>+int netxen_cards_found;
>+
>+static void netxen_nic_disable_int(struct netxen_adapter *adapter)
>+{
>+	uint32_t	mask = 0x7ff;
>+	int retries = 32;
>+
>+	DPRINTK(1, INFO, "Entered ISR Disable \n");
>+
>+	switch (adapter->portnum) {
>+	case 0:
>+		writel(0x0, NETXEN_CRB_NORMALIZE(adapter, CRB_SW_INT_MASK_0));
>+		break;
>+	case 1:
>+		writel(0x0, NETXEN_CRB_NORMALIZE(adapter, CRB_SW_INT_MASK_1));
>+		break;
>+	case 2:
>+		writel(0x0, NETXEN_CRB_NORMALIZE(adapter, CRB_SW_INT_MASK_2));
>+		break;
>+	case 3:
>+		writel(0x0, NETXEN_CRB_NORMALIZE(adapter, CRB_SW_INT_MASK_3));
>+		break;
>+	}
>+
>+	if (adapter->intr_scheme != -1 &&
>+	    adapter->intr_scheme != INTR_SCHEME_PERPORT)
>+		writel(mask,PCI_OFFSET_SECOND_RANGE(adapter, ISR_INT_MASK));
>+
>+	/* Window = 0 or 1 */
>+	if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
>+		do {
>+			writel(0xffffffff,
>+			       PCI_OFFSET_SECOND_RANGE(adapter, ISR_INT_TARGET_STATUS));
>+			mask = readl(pci_base_offset(adapter, ISR_INT_VECTOR));
>+			if (!(mask & 0x80))
>+				break;
>+			udelay(10);
>+		} while (--retries);
>+
>+		if (!retries) {
>+			printk(KERN_NOTICE "%s: Failed to disable interrupt completely\n",
>+					netxen_nic_driver_name);
>+		}
>+	}
>+
>+	DPRINTK(1, INFO, "Done with Disable Int\n");
>+}
>+
>+static void netxen_nic_enable_int(struct netxen_adapter *adapter)
>+{
>+	u32 mask;
>+
>+	DPRINTK(1, INFO, "Entered ISR Enable \n");
>+
>+	if (adapter->intr_scheme != -1 &&
>+		adapter->intr_scheme != INTR_SCHEME_PERPORT) {
>+		switch (adapter->ahw.board_type) {
>+		case NETXEN_NIC_GBE:
>+			mask  =  0x77b;
>+			break;
>+		case NETXEN_NIC_XGBE:
>+			mask  =  0x77f;
>+			break;
>+		default:
>+			mask  =  0x7ff;
>+			break;
>+		}
>+
>+		writel(mask, PCI_OFFSET_SECOND_RANGE(adapter, ISR_INT_MASK));
>+	}
>+
>+	switch (adapter->portnum) {
>+	case 0:
>+		writel(0x1, NETXEN_CRB_NORMALIZE(adapter, CRB_SW_INT_MASK_0));
>+		break;
>+	case 1:
>+		writel(0x1, NETXEN_CRB_NORMALIZE(adapter, CRB_SW_INT_MASK_1));
>+		break;
>+	case 2:
>+		writel(0x1, NETXEN_CRB_NORMALIZE(adapter, CRB_SW_INT_MASK_2));
>+		break;
>+	case 3:
>+		writel(0x1, NETXEN_CRB_NORMALIZE(adapter, CRB_SW_INT_MASK_3));
>+		break;
>+	}
>+
>+	if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
>+		mask = 0xbff;
>+		if (adapter->intr_scheme != -1 &&
>+			adapter->intr_scheme != INTR_SCHEME_PERPORT) {
>+			writel(0X0, NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
>+		}
>+		writel(mask,
>+		       PCI_OFFSET_SECOND_RANGE(adapter, ISR_INT_TARGET_MASK));
>+	}
>+
>+	DPRINTK(1, INFO, "Done with enable Int\n");
>+}
>+
> /*
>  * netxen_nic_probe()
>  *
>@@ -110,26 +268,30 @@
> {
> 	struct net_device *netdev = NULL;
> 	struct netxen_adapter *adapter = NULL;
>-	struct netxen_port *port = NULL;
> 	void __iomem *mem_ptr0 = NULL;
> 	void __iomem *mem_ptr1 = NULL;
> 	void __iomem *mem_ptr2 = NULL;
>+	unsigned long first_page_group_end;
>+	unsigned long first_page_group_start;
>+
> 
> 	u8 __iomem *db_ptr = NULL;
> 	unsigned long mem_base, mem_len, db_base, db_len;
>-	int pci_using_dac, i, err;
>+	int pci_using_dac, i = 0, err;
> 	int ring;
> 	struct netxen_recv_context *recv_ctx = NULL;
> 	struct netxen_rcv_desc_ctx *rcv_desc = NULL;
> 	struct netxen_cmd_buffer *cmd_buf_arr = NULL;
> 	u64 mac_addr[FLASH_NUM_PORTS + 1];
> 	int valid_mac = 0;
>+	u32 val;
>+	int pci_func_id = PCI_FUNC(pdev->devfn);
> 
> 	printk(KERN_INFO "%s \n", netxen_nic_driver_string);
>-	/* In current scheme, we use only PCI function 0 */
>-	if (PCI_FUNC(pdev->devfn) != 0) {
>-		DPRINTK(ERR, "NetXen function %d will not be enabled.\n",
>-			PCI_FUNC(pdev->devfn));
>+
>+	if (pdev->class != 0x020000) {
>+		printk(KERN_ERR"NetXen function %d, class %x will not"
>+				"be enabled.\n",pci_func_id, pdev->class);
> 		return -ENODEV;
> 	}
> 	if ((err = pci_enable_device(pdev)))
>@@ -143,8 +305,7 @@
> 		goto err_out_disable_pdev;
> 
> 	pci_set_master(pdev);
>-	pci_read_config_byte(pdev, PCI_REVISION_ID, &nx_p2_id);
>-	if (nx_p2_id == NX_P2_C1 &&
>+	if (pdev->revision == NX_P2_C1 &&
> 	    (pci_set_dma_mask(pdev, DMA_35BIT_MASK) == 0) &&
> 	    (pci_set_consistent_dma_mask(pdev, DMA_35BIT_MASK) == 0)) {
> 		pci_using_dac = 1;
>@@ -156,18 +317,51 @@
> 		pci_using_dac = 0;
> 	}
> 
>+
>+	netdev = alloc_etherdev(sizeof(struct netxen_adapter));
>+	if(!netdev) {
>+		printk(KERN_ERR"%s: Failed to allocate memory for the "
>+				"device block.Check system memory resource"
>+				" usage.\n", netxen_nic_driver_name);
>+		goto err_out_free_res;
>+	}
>+
>+	SET_MODULE_OWNER(netdev);
>+	SET_NETDEV_DEV(netdev, &pdev->dev);
>+
>+	adapter = netdev->priv;
>+	memset(adapter, 0 , sizeof(struct netxen_adapter));
>+
>+	adapter->ahw.pdev = pdev;
>+	adapter->ahw.pci_func  = pci_func_id;
>+	spin_lock_init(&adapter->tx_lock);
>+
> 	/* remap phys address */
> 	mem_base = pci_resource_start(pdev, 0);	/* 0 is for BAR 0 */
> 	mem_len = pci_resource_len(pdev, 0);
> 
> 	/* 128 Meg of memory */
>-	mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
>-	mem_ptr1 =
>-	    ioremap(mem_base + SECOND_PAGE_GROUP_START, SECOND_PAGE_GROUP_SIZE);
>-	mem_ptr2 =
>-	    ioremap(mem_base + THIRD_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
>+	if (mem_len == NETXEN_PCI_128MB_SIZE) {
>+		mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
>+		mem_ptr1 = ioremap(mem_base + SECOND_PAGE_GROUP_START,
>+				SECOND_PAGE_GROUP_SIZE);
>+		mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START,
>+				THIRD_PAGE_GROUP_SIZE);
>+		first_page_group_start = FIRST_PAGE_GROUP_START;
>+		first_page_group_end   = FIRST_PAGE_GROUP_END;
>+	} else if (mem_len == NETXEN_PCI_32MB_SIZE) {
>+		mem_ptr1 = ioremap(mem_base, SECOND_PAGE_GROUP_SIZE);
>+		mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
>+			SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
>+		first_page_group_start = 0;
>+		first_page_group_end   = 0;
>+	} else {
>+		err = -EIO; 
>+		goto err_out_free_netdev;
>+	}
> 
>-	if ((mem_ptr0 == 0UL) || (mem_ptr1 == 0UL) || (mem_ptr2 == 0UL)) {
>+	if (((mem_ptr0 == 0UL) && (mem_len == NETXEN_PCI_128MB_SIZE)) ||
>+			(mem_ptr1 == 0UL) || (mem_ptr2 == 0UL)) {
> 		DPRINTK(ERR,
> 			"Cannot remap adapter memory aborting.:"
> 			"0 -> %p, 1 -> %p, 2 -> %p\n",
>@@ -197,30 +391,84 @@
> 	}
> 	DPRINTK(INFO, "doorbell ioremaped at %p\n", db_ptr);
> 
>-/*
>- *      Allocate a adapter structure which will manage all the initialization
>- *      as well as the common resources for all ports...
>- *      all the ports will have pointer to this adapter as well as Adapter
>- *      will have pointers of all the ports structures.
>- */
>+	adapter->ahw.pci_base0 = mem_ptr0;
>+	adapter->ahw.first_page_group_start = first_page_group_start;
>+	adapter->ahw.first_page_group_end   = first_page_group_end;
>+	adapter->ahw.pci_base1 = mem_ptr1;
>+	adapter->ahw.pci_base2 = mem_ptr2;
>+	adapter->ahw.db_base = db_ptr;
>+	adapter->ahw.db_len = db_len;
> 
>-	/* One adapter structure for all 4 ports....   */
>-	adapter = kzalloc(sizeof(struct netxen_adapter), GFP_KERNEL);
>-	if (adapter == NULL) {
>-		printk(KERN_ERR "%s: Could not allocate adapter memory:%d\n",
>-		       netxen_nic_driver_name,
>-		       (int)sizeof(struct netxen_adapter));
>-		err = -ENOMEM;
>-		goto err_out_dbunmap;
>-	}
>+	adapter->netdev  = netdev;
>+	adapter->pdev    = pdev;
>+
>+	/* this will be read from FW later */
>+	adapter->intr_scheme = -1;
>+
>+	/* This will be reset for mezz cards  */
>+	adapter->portnum = pci_func_id;
>+	adapter->status   &= ~NETXEN_NETDEV_STATUS;
>+
>+	netdev->open		   = netxen_nic_open;
>+	netdev->stop		   = netxen_nic_close;
>+	netdev->hard_start_xmit    = netxen_nic_xmit_frame;
>+	netdev->get_stats	   = netxen_nic_get_stats;	
>+	netdev->set_multicast_list = netxen_nic_set_multi;
>+	netdev->set_mac_address    = netxen_nic_set_mac;
>+	netdev->change_mtu	   = netxen_nic_change_mtu;
>+	netdev->tx_timeout	   = netxen_tx_timeout;
>+	netdev->watchdog_timeo     = HZ;
>+
>+	netxen_nic_change_mtu(netdev, netdev->mtu);
>+
>+	SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
>+	netdev->poll = netxen_nic_poll;
>+	netdev->weight = NETXEN_NETDEV_WEIGHT;
>+#ifdef CONFIG_NET_POLL_CONTROLLER
>+	netdev->poll_controller = netxen_nic_poll_controller;
>+#endif
>+	/* ScatterGather support */
>+	netdev->features = NETIF_F_SG;
>+	netdev->features |= NETIF_F_IP_CSUM;
>+	netdev->features |= NETIF_F_TSO;
>+
>+	if (pci_using_dac)
>+		netdev->features |= NETIF_F_HIGHDMA;
> 
>-	adapter->max_tx_desc_count = MAX_CMD_DESCRIPTORS;
>-	adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS;
>+	if (pci_enable_msi(pdev))
>+		adapter->flags &= ~NETXEN_NIC_MSI_ENABLED;
>+	else
>+		adapter->flags |= NETXEN_NIC_MSI_ENABLED;
>+
>+	netdev->irq = pdev->irq;
>+	INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
>+
>+	/*
>+	 * Set the CRB window to invalid. If any register in window 0 is
>+	 * accessed it should set the window to 0 and then reset it to 1.
>+	 */
>+	adapter->curr_window = 255;
>+
>+	/* initialize the adapter */
>+	netxen_initialize_adapter_hw(adapter);
>+
>+	/*
>+	 *  Adapter in our case is quad port so initialize it before
>+	 *  initializing the ports
>+	 */
>+
>+	netxen_initialize_adapter_ops(adapter);
>+
>+	adapter->max_tx_desc_count = MAX_CMD_DESCRIPTORS_HOST;
>+	if ((adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB35_4G) ||
>+			(adapter->ahw.boardcfg.board_type == 
>+			 NETXEN_BRDTYPE_P2_SB31_2G)) 
>+		adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
>+	else
>+		adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS;
> 	adapter->max_jumbo_rx_desc_count = MAX_JUMBO_RCV_DESCRIPTORS;
> 	adapter->max_lro_rx_desc_count = MAX_LRO_RCV_DESCRIPTORS;
> 
>-	pci_set_drvdata(pdev, adapter);
>-
> 	cmd_buf_arr = (struct netxen_cmd_buffer *)vmalloc(TX_RINGSIZE);
> 	if (cmd_buf_arr == NULL) {
> 		printk(KERN_ERR
>@@ -230,6 +478,7 @@
> 		goto err_out_free_adapter;
> 	}
> 	memset(cmd_buf_arr, 0, TX_RINGSIZE);
>+	adapter->cmd_buf_arr = cmd_buf_arr;
> 
> 	for (i = 0; i < MAX_RCV_CTX; ++i) {
> 		recv_ctx = &adapter->recv_ctx[i];
>@@ -277,33 +526,20 @@
> 
> 	}
> 
>-	adapter->cmd_buf_arr = cmd_buf_arr;
>-	adapter->ahw.pci_base0 = mem_ptr0;
>-	adapter->ahw.pci_base1 = mem_ptr1;
>-	adapter->ahw.pci_base2 = mem_ptr2;
>-	adapter->ahw.db_base = db_ptr;
>-	adapter->ahw.db_len = db_len;
>-	spin_lock_init(&adapter->tx_lock);
>-	spin_lock_init(&adapter->lock);
> 	netxen_initialize_adapter_sw(adapter);	/* initialize the buffers in adapter */
>-#ifdef CONFIG_IA64
>-	netxen_pinit_from_rom(adapter, 0);
>-	udelay(500);
>-	netxen_load_firmware(adapter);
>-#endif
> 
>-	/*
>-	 * Set the CRB window to invalid. If any register in window 0 is
>-	 * accessed it should set the window to 0 and then reset it to 1.
>-	 */
>-	adapter->curr_window = 255;
>-	/*
>-	 *  Adapter in our case is quad port so initialize it before
>-	 *  initializing the ports
>-	 */
>-	netxen_initialize_adapter_hw(adapter);	/* initialize the adapter */
>+	/* Mezz cards have PCI function 0,2,3 enabled */
>+	if ((adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB31_10G_IMEZ)
>+		&& (pci_func_id >= 2))
>+			adapter->portnum = pci_func_id - 2;
> 
>-	netxen_initialize_adapter_ops(adapter);
>+#ifdef CONFIG_IA64
>+	if(adapter->portnum == 0) {
>+		netxen_pinit_from_rom(adapter, 0);
>+		udelay(500);
>+		netxen_load_firmware(adapter);
>+	}
>+#endif
> 
> 	init_timer(&adapter->watchdog_timer);
> 	adapter->ahw.xg_linkup = 0;
>@@ -312,14 +548,14 @@
> 	INIT_WORK(&adapter->watchdog_task, netxen_watchdog_task);
> 	adapter->ahw.pdev = pdev;
> 	adapter->proc_cmd_buf_counter = 0;
>-	adapter->ahw.revision_id = nx_p2_id;
>+	adapter->ahw.revision_id = pdev->revision;
> 
>-	if (pci_enable_msi(pdev)) {
>-		adapter->flags &= ~NETXEN_NIC_MSI_ENABLED;
>-		printk(KERN_WARNING "%s: unable to allocate MSI interrupt"
>-		       " error\n", netxen_nic_driver_name);
>-	} else
>-		adapter->flags |= NETXEN_NIC_MSI_ENABLED;
>+	/* make sure Window == 1 */
>+	netxen_nic_pci_change_crbwindow(adapter, 1);
>+
>+	netxen_nic_update_cmd_producer(adapter, 0);
>+	netxen_nic_update_cmd_consumer(adapter, 0);
>+	writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_HOST_CMD_ADDR_LO));
> 
> 	if (netxen_is_flash_supported(adapter) == 0 &&
> 	    netxen_get_flash_mac_addr(adapter, mac_addr) == 0)
>@@ -327,153 +563,126 @@
> 	else
> 		valid_mac = 0;
> 
>-	/*
>-	 * Initialize all the CRB registers here.
>-	 */
>-	writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMD_PRODUCER_OFFSET));
>-	writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMD_CONSUMER_OFFSET));
>-	writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_HOST_CMD_ADDR_LO));
>-
>-	/* do this before waking up pegs so that we have valid dummy dma addr */
>-	err = netxen_initialize_adapter_offload(adapter);
>-	if (err) {
>-		goto err_out_free_dev;
>+	if (valid_mac) {
>+		unsigned char *p = (unsigned char *)&mac_addr[adapter->portnum];
>+		netdev->dev_addr[0] = *(p + 5);
>+		netdev->dev_addr[1] = *(p + 4);
>+		netdev->dev_addr[2] = *(p + 3);
>+		netdev->dev_addr[3] = *(p + 2);
>+		netdev->dev_addr[4] = *(p + 1);
>+		netdev->dev_addr[5] = *(p + 0);
>+
>+		memcpy(netdev->perm_addr, netdev->dev_addr,
>+			netdev->addr_len);
>+		if (!is_valid_ether_addr(netdev->perm_addr)) {
>+			printk(KERN_ERR "%s: Bad MAC address "
>+				"%02x:%02x:%02x:%02x:%02x:%02x.\n",
>+				netxen_nic_driver_name,
>+				netdev->dev_addr[0],
>+				netdev->dev_addr[1],
>+				netdev->dev_addr[2],
>+				netdev->dev_addr[3],
>+				netdev->dev_addr[4],
>+				netdev->dev_addr[5]);
>+		} else {
>+			if (adapter->macaddr_set)
>+				adapter->macaddr_set(adapter,
>+							netdev->dev_addr);
>+		}
> 	}
> 
>-	/* Unlock the HW, prompting the boot sequence */
>-	writel(1,
>-	       NETXEN_CRB_NORMALIZE(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
>-
>-	/* Handshake with the card before we register the devices. */
>-	netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
>-
>-	/* initialize the all the ports */
>-	adapter->active_ports = 0;
>-
>-	for (i = 0; i < adapter->ahw.max_ports; i++) {
>-		netdev = alloc_etherdev(sizeof(struct netxen_port));
>-		if (!netdev) {
>-			printk(KERN_ERR "%s: could not allocate netdev for port"
>-			       " %d\n", netxen_nic_driver_name, i + 1);
>-			goto err_out_free_dev;
>-		}
>-
>-		SET_MODULE_OWNER(netdev);
>-		SET_NETDEV_DEV(netdev, &pdev->dev);
>-
>-		port = netdev_priv(netdev);
>-		port->netdev = netdev;
>-		port->pdev = pdev;
>-		port->adapter = adapter;
>-		port->portnum = i;	/* Gigabit port number from 0-3 */
>-
>-		netdev->open = netxen_nic_open;
>-		netdev->stop = netxen_nic_close;
>-		netdev->hard_start_xmit = netxen_nic_xmit_frame;
>-		netdev->get_stats = netxen_nic_get_stats;
>-		netdev->set_multicast_list = netxen_nic_set_multi;
>-		netdev->set_mac_address = netxen_nic_set_mac;
>-		netdev->change_mtu = netxen_nic_change_mtu;
>-		netdev->tx_timeout = netxen_tx_timeout;
>-		netdev->watchdog_timeo = HZ;
>-
>-		netxen_nic_change_mtu(netdev, netdev->mtu);
>-
>-		SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
>-		netdev->poll = netxen_nic_poll;
>-		netdev->weight = NETXEN_NETDEV_WEIGHT;
>-#ifdef CONFIG_NET_POLL_CONTROLLER
>-		netdev->poll_controller = netxen_nic_poll_controller;
>-#endif
>-		/* ScatterGather support */
>-		netdev->features = NETIF_F_SG;
>-		netdev->features |= NETIF_F_IP_CSUM;
>-		netdev->features |= NETIF_F_TSO;
>-
>-		if (pci_using_dac)
>-			netdev->features |= NETIF_F_HIGHDMA;
>-
>-		if (valid_mac) {
>-			unsigned char *p = (unsigned char *)&mac_addr[i];
>-			netdev->dev_addr[0] = *(p + 5);
>-			netdev->dev_addr[1] = *(p + 4);
>-			netdev->dev_addr[2] = *(p + 3);
>-			netdev->dev_addr[3] = *(p + 2);
>-			netdev->dev_addr[4] = *(p + 1);
>-			netdev->dev_addr[5] = *(p + 0);
>-
>-			memcpy(netdev->perm_addr, netdev->dev_addr,
>-			       netdev->addr_len);
>-			if (!is_valid_ether_addr(netdev->perm_addr)) {
>-				printk(KERN_ERR "%s: Bad MAC address "
>-				       "%02x:%02x:%02x:%02x:%02x:%02x.\n",
>-				       netxen_nic_driver_name,
>-				       netdev->dev_addr[0],
>-				       netdev->dev_addr[1],
>-				       netdev->dev_addr[2],
>-				       netdev->dev_addr[3],
>-				       netdev->dev_addr[4],
>-				       netdev->dev_addr[5]);
>-			} else {
>-				if (adapter->macaddr_set)
>-					adapter->macaddr_set(port,
>-							     netdev->dev_addr);
>+	if (adapter->portnum == 0) {
>+		err = netxen_initialize_adapter_offload(adapter);
>+		if (err) 
>+			goto err_out_free_rx_buffer;
>+		val = readl(NETXEN_CRB_NORMALIZE(adapter, 
>+					NETXEN_CAM_RAM(0x1fc)));
>+		if (val == 0x55555555) {
>+		    /* This is the first boot after power up */
>+		    netxen_nic_read_w0(adapter, NETXEN_PCIE_REG(0x4), &val);
>+			if (!(val & 0x4)) {
>+				val |= 0x4;
>+				netxen_nic_write_w0(adapter, NETXEN_PCIE_REG(0x4), val);
>+				netxen_nic_read_w0(adapter, NETXEN_PCIE_REG(0x4), &val);
>+				if (!(val & 0x4))
>+					printk(KERN_ERR "%s: failed to set MSI bit in PCI-e reg\n",
>+							netxen_nic_driver_name);
> 			}
>-		}
>-		INIT_WORK(&port->tx_timeout_task, netxen_tx_timeout_task);
>-		netif_carrier_off(netdev);
>-		netif_stop_queue(netdev);
>+		    val = readl(NETXEN_CRB_NORMALIZE(adapter,
>+					NETXEN_ROMUSB_GLB_SW_RESET));
>+		    printk(KERN_INFO"NetXen: read 0x%08x for reset reg.\n",val);
>+		    if (val != 0x80000f) {
>+			/* clear the register for future unloads/loads */
>+				writel(0, NETXEN_CRB_NORMALIZE(adapter,
>+							NETXEN_CAM_RAM(0x1fc)));
>+				printk(KERN_ERR "ERROR in NetXen HW init sequence.\n");
>+				err = -ENODEV;
>+				goto err_out_free_dev;
>+		    }
>+		}
>+
>+		/* clear the register for future unloads/loads */
>+		writel(0, NETXEN_CRB_NORMALIZE(adapter, NETXEN_CAM_RAM(0x1fc)));
>+		printk(KERN_INFO "State: 0x%0x\n",
>+			readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE)));
>+
>+		/*
>+		 * Tell the hardware our version number.
>+		 */
>+		i = (_NETXEN_NIC_LINUX_MAJOR << 16) 
>+			| ((_NETXEN_NIC_LINUX_MINOR << 8))
>+			| (_NETXEN_NIC_LINUX_SUBVERSION);
>+		writel(i, NETXEN_CRB_NORMALIZE(adapter, CRB_DRIVER_VERSION));
>+
>+		/* Unlock the HW, prompting the boot sequence */
>+		writel(1,
>+			NETXEN_CRB_NORMALIZE(adapter,
>+				NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
>+		/* Handshake with the card before we register the devices. */
>+		netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
>+	}
> 
>-		if ((err = register_netdev(netdev))) {
>-			printk(KERN_ERR "%s: register_netdev failed port #%d"
>-			       " aborting\n", netxen_nic_driver_name, i + 1);
>-			err = -EIO;
>-			free_netdev(netdev);
>-			goto err_out_free_dev;
>-		}
>-		adapter->port_count++;
>-		adapter->port[i] = port;
>-	}
>-	writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
>-	netxen_pinit_from_rom(adapter, 0);
>-	udelay(500);
>-	netxen_load_firmware(adapter);
>-	netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
> 	/*
>-	 * delay a while to ensure that the Pegs are up & running.
>-	 * Otherwise, we might see some flaky behaviour.
>+	 * See if the firmware gave us a virtual-physical port mapping.
> 	 */
>-	udelay(100);
>+	i = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_V2P(adapter->portnum)));
>+	if (i != 0x55555555)
>+		physical_port[adapter->portnum] = i;
>+
>+	netif_carrier_off(netdev);
>+	netif_stop_queue(netdev);
>+
>+	if ((err = register_netdev(netdev))) {
>+		printk(KERN_ERR "%s: register_netdev failed port #%d"
>+			       " aborting\n", netxen_nic_driver_name,
>+			       adapter->portnum);
>+		err = -EIO;
>+		goto err_out_free_dev;
>+	}
>+
>+	pci_set_drvdata(pdev, adapter);
> 
> 	switch (adapter->ahw.board_type) {
>-	case NETXEN_NIC_GBE:
>-		printk("%s: QUAD GbE board initialized\n",
>-		       netxen_nic_driver_name);
>-		break;
>+		case NETXEN_NIC_GBE:
>+			printk(KERN_INFO "%s: QUAD GbE board initialized\n",
>+			       netxen_nic_driver_name);
>+			break;
> 
>-	case NETXEN_NIC_XGBE:
>-		printk("%s: XGbE board initialized\n", netxen_nic_driver_name);
>-		break;
>+		case NETXEN_NIC_XGBE:
>+			printk(KERN_INFO "%s: XGbE board initialized\n", 
>+					netxen_nic_driver_name);
>+			break;
> 	}
> 
> 	adapter->driver_mismatch = 0;
> 
> 	return 0;
> 
>-      err_out_free_dev:
>-	if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
>-		pci_disable_msi(pdev);
>-	for (i = 0; i < adapter->port_count; i++) {
>-		port = adapter->port[i];
>-		if ((port) && (port->netdev)) {
>-			unregister_netdev(port->netdev);
>-			free_netdev(port->netdev);
>-		}
>-	}
>+err_out_free_dev:
>+	if (adapter->portnum == 0)
>+		netxen_free_adapter_offload(adapter);
> 
>-	netxen_free_adapter_offload(adapter);
>-
>-      err_out_free_rx_buffer:
>+err_out_free_rx_buffer:
> 	for (i = 0; i < MAX_RCV_CTX; ++i) {
> 		recv_ctx = &adapter->recv_ctx[i];
> 		for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
>@@ -486,15 +695,16 @@
> 	}
> 	vfree(cmd_buf_arr);
> 
>-      err_out_free_adapter:
>+err_out_free_adapter:
>+	if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
>+		pci_disable_msi(pdev);
>+
> 	pci_set_drvdata(pdev, NULL);
>-	kfree(adapter);
> 
>-      err_out_dbunmap:
> 	if (db_ptr)
> 		iounmap(db_ptr);
> 
>-      err_out_iounmap:
>+err_out_iounmap:
> 	if (mem_ptr0)
> 		iounmap(mem_ptr0);
> 	if (mem_ptr1)
>@@ -502,9 +712,13 @@
> 	if (mem_ptr2)
> 		iounmap(mem_ptr2);
> 
>-      err_out_free_res:
>+err_out_free_netdev:
>+	free_netdev(netdev);
>+
>+err_out_free_res:
> 	pci_release_regions(pdev);
>-      err_out_disable_pdev:
>+
>+err_out_disable_pdev:
> 	pci_disable_device(pdev);
> 	return err;
> }
>@@ -512,49 +726,30 @@
> static void __devexit netxen_nic_remove(struct pci_dev *pdev)
> {
> 	struct netxen_adapter *adapter;
>-	struct netxen_port *port;
>+	struct net_device *netdev;
> 	struct netxen_rx_buffer *buffer;
> 	struct netxen_recv_context *recv_ctx;
> 	struct netxen_rcv_desc_ctx *rcv_desc;
>-	int i;
>-	int ctxid, ring;
>+	int i, ctxid, ring;
>+	static int init_firmware_done = 0;
> 
> 	adapter = pci_get_drvdata(pdev);
> 	if (adapter == NULL)
> 		return;
> 
>-	if (adapter->irq)
>-		free_irq(adapter->irq, adapter);
>-	netxen_nic_stop_all_ports(adapter);
>-	/* leave the hw in the same state as reboot */
>-	writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
>-	netxen_pinit_from_rom(adapter, 0);
>-	udelay(500);
>-	netxen_load_firmware(adapter);
>-	netxen_free_adapter_offload(adapter);
>-
>-	mdelay(1000);		/* Delay for a while to drain the DMA engines */
>-	for (i = 0; i < adapter->port_count; i++) {
>-		port = adapter->port[i];
>-		if ((port) && (port->netdev)) {
>-			unregister_netdev(port->netdev);
>-			free_netdev(port->netdev);
>-		}
>-	}
>+	netdev = adapter->netdev;
> 
>-	if ((adapter->flags & NETXEN_NIC_MSI_ENABLED))
>-		pci_disable_msi(pdev);
>-	if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
>-		netxen_free_hw_resources(adapter);
>+	unregister_netdev(netdev);
> 
>-	iounmap(adapter->ahw.db_base);
>-	iounmap(adapter->ahw.pci_base0);
>-	iounmap(adapter->ahw.pci_base1);
>-	iounmap(adapter->ahw.pci_base2);
>+	if (adapter->stop_port)
>+		adapter->stop_port(adapter);
> 
>-	pci_release_regions(pdev);
>-	pci_disable_device(pdev);
>-	pci_set_drvdata(pdev, NULL);
>+	netxen_nic_disable_int(adapter);
>+
>+	if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
>+		init_firmware_done++;
>+		netxen_free_hw_resources(adapter);
>+	}
> 
> 	for (ctxid = 0; ctxid < MAX_RCV_CTX; ++ctxid) {
> 		recv_ctx = &adapter->recv_ctx[ctxid];
>@@ -575,7 +770,73 @@
> 	}
> 
> 	vfree(adapter->cmd_buf_arr);
>-	kfree(adapter);
>+
>+	if (adapter->portnum == 0) {
>+		if (init_firmware_done) {
>+			i = 100;
>+			do {
>+				if (dma_watchdog_shutdown_request(adapter) == 1)
>+					break;
>+				msleep(100);
>+				if (dma_watchdog_shutdown_poll_result(adapter) == 1)
>+					break;
>+			} while (--i);
>+
>+			if (i == 0)
>+				printk(KERN_ERR "%s: dma_watchdog_shutdown failed\n",
>+						netdev->name);
>+
>+			/* clear the register for future unloads/loads */
>+			writel(0, NETXEN_CRB_NORMALIZE(adapter, NETXEN_CAM_RAM(0x1fc)));
>+			printk(KERN_INFO "State: 0x%0x\n",
>+				readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE)));
>+
>+			/* leave the hw in the same state as reboot */
>+			writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
>+			netxen_pinit_from_rom(adapter, 0);
>+			msleep(1);
>+			netxen_load_firmware(adapter);
>+			netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
>+		}
>+
>+		/* clear the register for future unloads/loads */
>+		writel(0, NETXEN_CRB_NORMALIZE(adapter, NETXEN_CAM_RAM(0x1fc)));
>+		printk(KERN_INFO "State: 0x%0x\n",
>+			readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE)));
>+
>+		i = 100;
>+		do {
>+			if (dma_watchdog_shutdown_request(adapter) == 1)
>+				break;
>+			msleep(100);
>+			if (dma_watchdog_shutdown_poll_result(adapter) == 1)
>+				break;
>+		} while (--i);
>+
>+		if (i) {
>+			netxen_free_adapter_offload(adapter);
>+		} else {
>+			printk(KERN_ERR "%s: dma_watchdog_shutdown failed\n",
>+					netdev->name);
>+		}
>+	}
>+
>+	if (adapter->irq)
>+		free_irq(adapter->irq, adapter);
>+
>+	if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
>+		pci_disable_msi(pdev);
>+
>+	iounmap(adapter->ahw.db_base);
>+	iounmap(adapter->ahw.pci_base0);
>+	iounmap(adapter->ahw.pci_base1);
>+	iounmap(adapter->ahw.pci_base2);
>+
>+	pci_release_regions(pdev);
>+	pci_disable_device(pdev);
>+	pci_set_drvdata(pdev, NULL);
>+
>+	free_netdev(netdev);
> }
> 
> /*
>@@ -584,8 +845,7 @@
>  */
> static int netxen_nic_open(struct net_device *netdev)
> {
>-	struct netxen_port *port = netdev_priv(netdev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = (struct netxen_adapter *)netdev->priv;
> 	int err = 0;
> 	int ctx, ring;
> 
>@@ -596,8 +856,6 @@
> 			return -EIO;
> 		}
> 		netxen_nic_flash_print(adapter);
>-		if (adapter->init_niu)
>-			adapter->init_niu(adapter);
> 
> 		/* setup all the resources for the Phantom... */
> 		/* this include the descriptors for rcv, tx, and status */
>@@ -608,21 +866,14 @@
> 			       err);
> 			return err;
> 		}
>-		if (adapter->init_port
>-		    && adapter->init_port(adapter, port->portnum) != 0) {
>-			printk(KERN_ERR "%s: Failed to initialize port %d\n",
>-			       netxen_nic_driver_name, port->portnum);
>-			netxen_free_hw_resources(adapter);
>-			return -EIO;
>-		}
> 		for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
> 			for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++)
> 				netxen_post_rx_buffers(adapter, ctx, ring);
> 		}
> 		adapter->irq = adapter->ahw.pdev->irq;
>-		err = request_irq(adapter->ahw.pdev->irq, &netxen_intr,
>-				  IRQF_SHARED | IRQF_SAMPLE_RANDOM,
>-				  netdev->name, adapter);
>+		err = request_irq(adapter->ahw.pdev->irq, netxen_intr,
>+				  IRQF_SHARED|IRQF_SAMPLE_RANDOM, netdev->name,
>+				  adapter);
> 		if (err) {
> 			printk(KERN_ERR "request_irq failed with: %d\n", err);
> 			netxen_free_hw_resources(adapter);
>@@ -631,23 +882,28 @@
> 
> 		adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
> 	}
>-	adapter->active_ports++;
>-	if (adapter->active_ports == 1) {
>-		if (!adapter->driver_mismatch)
>-			mod_timer(&adapter->watchdog_timer, jiffies);
>+	if (!adapter->driver_mismatch)
>+		mod_timer(&adapter->watchdog_timer, jiffies);
> 
>-		netxen_nic_enable_int(adapter);
>-	}
>+	netxen_nic_enable_int(adapter);
> 
> 	/* Done here again so that even if phantom sw overwrote it,
> 	 * we set it */
>+	if (adapter->init_port
>+	    && adapter->init_port(adapter, adapter->portnum) != 0) {
>+	    del_timer_sync(&adapter->watchdog_timer);
>+		printk(KERN_ERR "%s: Failed to initialize port %d\n",
>+				netxen_nic_driver_name, adapter->portnum);
>+		return -EIO;
>+	}
> 	if (adapter->macaddr_set)
>-		adapter->macaddr_set(port, netdev->dev_addr);
>-	netxen_nic_set_link_parameters(port);
>+		adapter->macaddr_set(adapter, netdev->dev_addr);
>+
>+	netxen_nic_set_link_parameters(adapter);
> 
> 	netxen_nic_set_multi(netdev);
> 	if (adapter->set_mtu)
>-		adapter->set_mtu(port, netdev->mtu);
>+		adapter->set_mtu(adapter, netdev->mtu);
> 
> 	if (!adapter->driver_mismatch)
> 		netif_start_queue(netdev);
>@@ -660,8 +916,7 @@
>  */
> static int netxen_nic_close(struct net_device *netdev)
> {
>-	struct netxen_port *port = netdev_priv(netdev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(netdev);
> 	int i, j;
> 	struct netxen_cmd_buffer *cmd_buff;
> 	struct netxen_skb_frag *buffrag;
>@@ -669,36 +924,33 @@
> 	netif_carrier_off(netdev);
> 	netif_stop_queue(netdev);
> 
>-	adapter->active_ports--;
>+	netxen_nic_disable_int(adapter);
> 
>-	if (!adapter->active_ports) {
>-		netxen_nic_disable_int(adapter);
>-		cmd_buff = adapter->cmd_buf_arr;
>-		for (i = 0; i < adapter->max_tx_desc_count; i++) {
>-			buffrag = cmd_buff->frag_array;
>+	cmd_buff = adapter->cmd_buf_arr;
>+	for (i = 0; i < adapter->max_tx_desc_count; i++) {
>+		buffrag = cmd_buff->frag_array;
>+		if (buffrag->dma) {
>+			pci_unmap_single(adapter->pdev, buffrag->dma,
>+					 buffrag->length, PCI_DMA_TODEVICE);
>+			buffrag->dma = 0ULL;
>+		}
>+		for (j = 0; j < cmd_buff->frag_count; j++) {
>+			buffrag++;
> 			if (buffrag->dma) {
>-				pci_unmap_single(port->pdev, buffrag->dma,
>-						 buffrag->length,
>-						 PCI_DMA_TODEVICE);
>-				buffrag->dma = (u64) NULL;
>-			}
>-			for (j = 0; j < cmd_buff->frag_count; j++) {
>-				buffrag++;
>-				if (buffrag->dma) {
>-					pci_unmap_page(port->pdev,
>-						       buffrag->dma,
>-						       buffrag->length,
>-						       PCI_DMA_TODEVICE);
>-					buffrag->dma = (u64) NULL;
>-				}
>+				pci_unmap_page(adapter->pdev, buffrag->dma,
>+					       buffrag->length, 
>+					       PCI_DMA_TODEVICE);
>+				buffrag->dma = 0ULL;
> 			}
>-			/* Free the skb we received in netxen_nic_xmit_frame */
>-			if (cmd_buff->skb) {
>-				dev_kfree_skb_any(cmd_buff->skb);
>-				cmd_buff->skb = NULL;
>-			}
>-			cmd_buff++;
> 		}
>+		/* Free the skb we received in netxen_nic_xmit_frame */
>+		if (cmd_buff->skb) {
>+			dev_kfree_skb_any(cmd_buff->skb);
>+			cmd_buff->skb = NULL;
>+		}
>+		cmd_buff++;
>+	}
>+	if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
> 		FLUSH_SCHEDULED_WORK();
> 		del_timer_sync(&adapter->watchdog_timer);
> 	}
>@@ -708,8 +960,7 @@
> 
> static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
> {
>-	struct netxen_port *port = netdev_priv(netdev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(netdev);
> 	struct netxen_hardware_context *hw = &adapter->ahw;
> 	unsigned int first_seg_len = skb->len - skb->data_len;
> 	struct netxen_skb_frag *buffrag;
>@@ -727,12 +978,12 @@
> 	u32 last_cmd_consumer = 0;
> 	int no_of_desc;
> 
>-	port->stats.xmitcalled++;
>+	adapter->stats.xmitcalled++;
> 	frag_count = skb_shinfo(skb)->nr_frags + 1;
> 
> 	if (unlikely(skb->len <= 0)) {
> 		dev_kfree_skb_any(skb);
>-		port->stats.badskblen++;
>+		adapter->stats.badskblen++;
> 		return NETDEV_TX_OK;
> 	}
> 
>@@ -741,7 +992,7 @@
> 		       "too large, can handle only %d frags\n",
> 		       netxen_nic_driver_name, netdev->name,
> 		       frag_count, MAX_BUFFERS_PER_CMD);
>-		port->stats.txdropped++;
>+		adapter->stats.txdropped++;
> 		if ((++dropped_packet & 0xff) == 0xff)
> 			printk("%s: %s droppped packets = %d\n",
> 			       netxen_nic_driver_name, netdev->name,
>@@ -758,7 +1009,7 @@
> 	 */
>       retry_getting_window:
> 	spin_lock_bh(&adapter->tx_lock);
>-	if (adapter->total_threads == MAX_XMIT_PRODUCERS) {
>+	if (adapter->total_threads >= MAX_XMIT_PRODUCERS) {
> 		spin_unlock_bh(&adapter->tx_lock);
> 		/*
> 		 * Yield CPU
>@@ -778,9 +1029,8 @@
> 		if (skb_shinfo(skb)->gso_size > 0) {
> 
> 			no_of_desc++;
>-			if (((skb->nh.iph)->ihl * sizeof(u32)) +
>-			    ((skb->h.th)->doff * sizeof(u32)) +
>-			    sizeof(struct ethhdr) >
>+			if ((ip_hdrlen(skb) + tcp_hdrlen(skb) +
>+			     sizeof(struct ethhdr)) >
> 			    (sizeof(struct cmd_desc_type0) - 2)) {
> 				no_of_desc++;
> 			}
>@@ -792,15 +1042,8 @@
> 	if ((k + no_of_desc) >=
> 	    ((last_cmd_consumer <= k) ? last_cmd_consumer + max_tx_desc_count :
> 	     last_cmd_consumer)) {
>-		port->stats.nocmddescriptor++;
>-		DPRINTK(ERR, "No command descriptors available,"
>-			" producer = %d, consumer = %d count=%llu,"
>-			" dropping packet\n", producer,
>-			adapter->last_cmd_consumer,
>-			port->stats.nocmddescriptor);
>-
> 		netif_stop_queue(netdev);
>-		port->flags |= NETXEN_NETDEV_STATUS;
>+		adapter->flags |= NETXEN_NETDEV_STATUS;
> 		spin_unlock_bh(&adapter->tx_lock);
> 		return NETDEV_TX_BUSY;
> 	}
>@@ -828,16 +1071,17 @@
> 	pbuf->skb = skb;
> 	pbuf->cmd = TX_ETHER_PKT;
> 	pbuf->frag_count = frag_count;
>-	pbuf->port = port->portnum;
>+	pbuf->port = adapter->portnum;
> 	buffrag = &pbuf->frag_array[0];
>-	buffrag->dma = pci_map_single(port->pdev, skb->data, first_seg_len,
>+	buffrag->dma = pci_map_single(adapter->pdev, skb->data, first_seg_len,
> 				      PCI_DMA_TODEVICE);
> 	buffrag->length = first_seg_len;
> 	netxen_set_cmd_desc_totallength(hwdesc, skb->len);
> 	netxen_set_cmd_desc_num_of_buff(hwdesc, frag_count);
> 	netxen_set_cmd_desc_opcode(hwdesc, TX_ETHER_PKT);
> 
>-	netxen_set_cmd_desc_port(hwdesc, port->portnum);
>+	netxen_set_cmd_desc_port(hwdesc, adapter->portnum);
>+	netxen_set_cmd_desc_ctxid(hwdesc, adapter->portnum);
> 	hwdesc->buffer1_length = cpu_to_le16(first_seg_len);
> 	hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
> 
>@@ -860,7 +1104,7 @@
> 		offset = frag->page_offset;
> 
> 		temp_len = len;
>-		temp_dma = pci_map_page(port->pdev, frag->page, offset,
>+		temp_dma = pci_map_page(adapter->pdev, frag->page, offset,
> 					len, PCI_DMA_TODEVICE);
> 
> 		buffrag++;
>@@ -920,26 +1164,36 @@
> 			/* copy the next 64 bytes - should be enough except
> 			 * for pathological case
> 			 */
>-			memcpy((void *)hwdesc, (void *)(skb->data) +
>-			       first_hdr_len, hdr_len - first_hdr_len);
>+			skb_copy_from_linear_data_offset(skb, first_hdr_len,
>+							 hwdesc,
>+							 (hdr_len -
>+							  first_hdr_len));
> 			producer = get_next_index(producer, max_tx_desc_count);
> 		}
> 	}
>+
>+	i = netxen_get_cmd_desc_totallength(&hw->cmd_desc_head[saved_producer]);
>+
>+	hw->cmd_desc_head[saved_producer].flags_opcode =
>+		cpu_to_le16(hw->cmd_desc_head[saved_producer].flags_opcode);
>+	hw->cmd_desc_head[saved_producer].num_of_buffers_total_length =
>+	  cpu_to_le32(hw->cmd_desc_head[saved_producer].
>+			  num_of_buffers_total_length);
>+
> 	spin_lock_bh(&adapter->tx_lock);
>-	port->stats.txbytes +=
>-	    netxen_get_cmd_desc_totallength(&hw->cmd_desc_head[saved_producer]);
>+	adapter->stats.txbytes += i;
>+
> 	/* Code to update the adapter considering how many producer threads
> 	   are currently working */
> 	if ((--adapter->num_threads) == 0) {
> 		/* This is the last thread */
> 		u32 crb_producer = adapter->cmd_producer;
>-		writel(crb_producer,
>-		       NETXEN_CRB_NORMALIZE(adapter, CRB_CMD_PRODUCER_OFFSET));
>+		netxen_nic_update_cmd_producer(adapter, crb_producer);
> 		wmb();
> 		adapter->total_threads = 0;
> 	}
> 
>-	port->stats.xmitfinished++;
>+	adapter->stats.xmitfinished++;
> 	spin_unlock_bh(&adapter->tx_lock);
> 
> 	netdev->trans_start = jiffies;
>@@ -959,27 +1213,23 @@
> 
> static void netxen_tx_timeout(struct net_device *netdev)
> {
>-	struct netxen_port *port = (struct netxen_port *)netdev_priv(netdev);
>-
>-	SCHEDULE_WORK(&port->tx_timeout_task);
>+	struct netxen_adapter *adapter = (struct netxen_adapter *)
>+						netdev_priv(netdev);
>+	SCHEDULE_WORK(&adapter->tx_timeout_task);
> }
> 
> static void netxen_tx_timeout_task(struct work_struct *work)
> {
>-	struct netxen_port *port =
>-		container_of(work, struct netxen_port, tx_timeout_task);
>-	struct net_device *netdev = port->netdev;
>-	unsigned long flags;
>+	struct netxen_adapter *adapter = 
>+		container_of(work, struct netxen_adapter, tx_timeout_task);
> 
> 	printk(KERN_ERR "%s %s: transmit timeout, resetting.\n",
>-	       netxen_nic_driver_name, netdev->name);
>+	       netxen_nic_driver_name, adapter->netdev->name);
> 
>-	spin_lock_irqsave(&port->adapter->lock, flags);
>-	netxen_nic_close(netdev);
>-	netxen_nic_open(netdev);
>-	spin_unlock_irqrestore(&port->adapter->lock, flags);
>-	netdev->trans_start = jiffies;
>-	netif_wake_queue(netdev);
>+	netxen_nic_close(adapter->netdev);
>+	netxen_nic_open(adapter->netdev);
>+	adapter->netdev->trans_start = jiffies;
>+	netif_wake_queue(adapter->netdev);
> }
> 
> static int
>@@ -988,29 +1238,9 @@
> 	u32 ret = 0;
> 
> 	DPRINTK(INFO, "Entered handle ISR\n");
>-
> 	adapter->stats.ints++;
> 
>-	if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
>-		int count = 0;
>-		u32 mask;
>-		mask = readl(pci_base_offset(adapter, ISR_INT_VECTOR));
>-		if ((mask & 0x80) == 0) {
>-			/* not our interrupt */
>-			return ret;
>-		}
>-		netxen_nic_disable_int(adapter);
>-		/* Window = 0 or 1 */
>-		do {
>-			writel(0xffffffff, PCI_OFFSET_SECOND_RANGE(adapter,
>-						ISR_INT_TARGET_STATUS));
>-			mask = readl(pci_base_offset(adapter, ISR_INT_VECTOR));
>-		} while (((mask & 0x80) != 0) && (++count < 32));
>-		if ((mask & 0x80) != 0)
>-			printk("Could not disable interrupt completely\n");
>-
>-	}
>-	adapter->stats.hostints++;
>+	netxen_nic_disable_int(adapter);
> 
> 	if (netxen_nic_rx_has_work(adapter) || netxen_nic_tx_has_work(adapter)) {
> 		if (netif_rx_schedule_prep(netdev)) {
>@@ -1021,7 +1251,7 @@
> 		} else {
> 			static unsigned int intcount = 0;
> 			if ((++intcount & 0xfff) == 0xfff)
>-				printk(KERN_ERR
>+				DPRINTK(KERN_ERR
> 				       "%s: %s interrupt %d while in poll\n",
> 				       netxen_nic_driver_name, netdev->name,
> 				       intcount);
>@@ -1044,33 +1274,40 @@
> irqreturn_t netxen_intr(int irq, void *data)
> {
> 	struct netxen_adapter *adapter;
>-	struct netxen_port *port;
> 	struct net_device *netdev;
>-	int i;
>+	u32 our_int = 0;
> 
> 	if (unlikely(!irq)) {
> 		return IRQ_NONE;	/* Not our interrupt */
> 	}
> 
> 	adapter = (struct netxen_adapter *)data;
>-	for (i = 0; i < adapter->ahw.max_ports; i++) {
>-		port = adapter->port[i];
>-		netdev = port->netdev;
>-
>-		/* process our status queue (for all 4 ports) */
>-		if (netif_running(netdev)) {
>-			netxen_handle_int(adapter, netdev);
>-			break;
>+	netdev  = adapter->netdev;
>+
>+	if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
>+		our_int = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
>+		/* not our interrupt */
>+		if ((our_int & (0x80 << adapter->portnum)) == 0)
>+			return IRQ_NONE;
>+	}
>+
>+	if (adapter->intr_scheme == INTR_SCHEME_PERPORT) {
>+		/* claim interrupt */
>+		if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
>+			writel(our_int & ~((u32)(0x80 << adapter->portnum)),
>+			NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
> 		}
> 	}
> 
>+	if (netif_running(netdev))
>+		netxen_handle_int(adapter, netdev);
>+
> 	return IRQ_HANDLED;
> }
> 
> static int netxen_nic_poll(struct net_device *netdev, int *budget)
> {
>-	struct netxen_port *port = (struct netxen_port *)netdev_priv(netdev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(netdev);
> 	int work_to_do = min(*budget, netdev->quota);
> 	int done = 1;
> 	int ctx;
>@@ -1078,7 +1315,6 @@
> 	int work_done = 0;
> 
> 	DPRINTK(INFO, "polling for %d descriptors\n", *budget);
>-	port->stats.polled++;
> 
> 	work_done = 0;
> 	for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
>@@ -1122,8 +1358,7 @@
> #ifdef CONFIG_NET_POLL_CONTROLLER
> static void netxen_nic_poll_controller(struct net_device *netdev)
> {
>-	struct netxen_port *port = netdev_priv(netdev);
>-	struct netxen_adapter *adapter = port->adapter;
>+	struct netxen_adapter *adapter = netdev_priv(netdev);
> 	disable_irq(adapter->irq);
> 	netxen_intr(adapter->irq, adapter);
> 	enable_irq(adapter->irq);
>@@ -1154,6 +1389,7 @@
> 	/*
> 	 * Wait for some time to allow the dma to drain, if any.
> 	 */
>+	msleep(100);
> 	pci_unregister_driver(&netxen_driver);
> 	destroy_workqueue(netxen_workq);
> }
>Index: linux-git/drivers/net/netxen/netxen_nic_niu.c
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_niu.c	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_niu.c	2007-09-27 10:36:10.000000000 -0700
>@@ -88,12 +88,13 @@
>  *	  -1 on error
>  *
>  */
>-int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long phy,
>-			    long reg, __u32 * readval)
>+int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg, 
>+				__u32 * readval)
> {
> 	long timeout = 0;
> 	long result = 0;
> 	long restore = 0;
>+	long phy = physical_port[adapter->portnum];
> 	__u32 address;
> 	__u32 command;
> 	__u32 status;
>@@ -183,12 +184,13 @@
>  *	  -1 on error
>  *
>  */
>-int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter,
>-			     long phy, long reg, __u32 val)
>+int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg, 
>+				__u32 val)
> {
> 	long timeout = 0;
> 	long result = 0;
> 	long restore = 0;
>+	long phy = physical_port[adapter->portnum];
> 	__u32 address;
> 	__u32 command;
> 	__u32 status;
>@@ -258,15 +260,13 @@
> 	return result;
> }
> 
>-int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter,
>-					  int port)
>+int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter)
> {
> 	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x3f);
> 	return 0;
> }
> 
>-int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter,
>-					 int port)
>+int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter)
> {
> 	int result = 0;
> 	__u32 enable = 0;
>@@ -275,7 +275,7 @@
> 	netxen_set_phy_int_speed_changed(enable);
> 
> 	if (0 !=
>-	    netxen_niu_gbe_phy_write(adapter, port,
>+	    netxen_niu_gbe_phy_write(adapter, 
> 				     NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE,
> 				     enable))
> 		result = -EIO;
>@@ -283,38 +283,34 @@
> 	return result;
> }
> 
>-int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter,
>-					   int port)
>+int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter)
> {
> 	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x7f);
> 	return 0;
> }
> 
>-int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter,
>-					  int port)
>+int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter)
> {
> 	int result = 0;
> 	if (0 !=
>-	    netxen_niu_gbe_phy_write(adapter, port,
>+	    netxen_niu_gbe_phy_write(adapter,
> 				     NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE, 0))
> 		result = -EIO;
> 
> 	return result;
> }
> 
>-int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter,
>-					 int port)
>+int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter)
> {
> 	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_ACTIVE_INT, -1);
> 	return 0;
> }
> 
>-int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter,
>-					int port)
>+int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter)
> {
> 	int result = 0;
> 	if (0 !=
>-	    netxen_niu_gbe_phy_write(adapter, port,
>+	    netxen_niu_gbe_phy_write(adapter, 
> 				     NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
> 				     -EIO))
> 		result = -EIO;
>@@ -355,9 +351,9 @@
> 					    0x5);
> 	}
> 
>-	if (netxen_niu_gbe_enable_phy_interrupts(adapter, port))
>+	if (netxen_niu_gbe_enable_phy_interrupts(adapter))
> 		printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
>-	if (netxen_niu_gbe_clear_phy_interrupts(adapter, port))
>+	if (netxen_niu_gbe_clear_phy_interrupts(adapter))
> 		printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
> }
> 
>@@ -393,9 +389,9 @@
> 					    0x5);
> 	}
> 
>-	if (netxen_niu_gbe_enable_phy_interrupts(adapter, port))
>+	if (netxen_niu_gbe_enable_phy_interrupts(adapter))
> 		printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
>-	if (netxen_niu_gbe_clear_phy_interrupts(adapter, port))
>+	if (netxen_niu_gbe_clear_phy_interrupts(adapter))
> 		printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
> }
> 
>@@ -404,11 +400,11 @@
> 	int result = 0;
> 	__u32 status;
> 	if (adapter->disable_phy_interrupts)
>-		adapter->disable_phy_interrupts(adapter, port);
>+		adapter->disable_phy_interrupts(adapter);
> 	mdelay(2);
> 
> 	if (0 ==
>-	    netxen_niu_gbe_phy_read(adapter, port,
>+	    netxen_niu_gbe_phy_read(adapter,
> 				    NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
> 				    &status)) {
> 		if (netxen_get_phy_link(status)) {
>@@ -439,13 +435,13 @@
> 						    | NETXEN_GB_MAC_ENABLE_TX_RX
> 						    |
> 						    NETXEN_GB_MAC_PAUSED_FRMS);
>-			if (netxen_niu_gbe_clear_phy_interrupts(adapter, port))
>+			if (netxen_niu_gbe_clear_phy_interrupts(adapter))
> 				printk(KERN_ERR PFX
> 				       "ERROR clearing PHY interrupts\n");
>-			if (netxen_niu_gbe_enable_phy_interrupts(adapter, port))
>+			if (netxen_niu_gbe_enable_phy_interrupts(adapter))
> 				printk(KERN_ERR PFX
> 				       "ERROR enabling PHY interrupts\n");
>-			if (netxen_niu_gbe_clear_phy_interrupts(adapter, port))
>+			if (netxen_niu_gbe_clear_phy_interrupts(adapter))
> 				printk(KERN_ERR PFX
> 				       "ERROR clearing PHY interrupts\n");
> 			result = -1;
>@@ -458,26 +454,14 @@
> 
> int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
> {
>-	u32 reg = 0, ret = 0;
>+	u32 portnum = physical_port[adapter->portnum];
> 
>-	if (adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB31_10G_IMEZ) {
>-		netxen_crb_writelit_adapter(adapter,
>-					    NETXEN_NIU_XG1_CONFIG_0, 0x5);
>-		/* XXX hack for Mez cards: both ports in promisc mode */
>-		netxen_nic_hw_read_wx(adapter,
>-				      NETXEN_NIU_XGE_CONFIG_1, &reg, 4);
>-		reg = (reg | 0x2000UL);
>-		netxen_crb_writelit_adapter(adapter,
>-					    NETXEN_NIU_XGE_CONFIG_1, reg);
>-		reg = 0;
>-		netxen_nic_hw_read_wx(adapter,
>-				      NETXEN_NIU_XG1_CONFIG_1, &reg, 4);
>-		reg = (reg | 0x2000UL);
>-		netxen_crb_writelit_adapter(adapter,
>-					    NETXEN_NIU_XG1_CONFIG_1, reg);
>-	}
>+	netxen_crb_writelit_adapter(adapter,
>+		NETXEN_NIU_XGE_CONFIG_1+(0x10000*portnum), 0x1447);
>+	netxen_crb_writelit_adapter(adapter,
>+		NETXEN_NIU_XGE_CONFIG_0+(0x10000*portnum), 0x5);
> 
>-	return ret;
>+	return 0;
> }
> 
> /* 
>@@ -498,7 +482,7 @@
> 	 * The read of the PHY INT status will clear the pending
> 	 * interrupt status
> 	 */
>-	if (netxen_niu_gbe_phy_read(adapter, port,
>+	if (netxen_niu_gbe_phy_read(adapter,
> 				    NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
> 				    &int_src) != 0)
> 		result = -EINVAL;
>@@ -535,7 +519,7 @@
> 			printk(KERN_INFO PFX
> 			       "speed_changed or link status changed");
> 			if (netxen_niu_gbe_phy_read
>-			    (adapter, port,
>+			    (adapter,
> 			     NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
> 			     &status) == 0) {
> 				if (netxen_get_phy_speed(status) == 2) {
>@@ -581,10 +565,11 @@
>  * Note that the passed-in value must already be in network byte order.
>  */
> int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
>-			   int phy, netxen_ethernet_macaddr_t * addr)
>+			   netxen_ethernet_macaddr_t * addr)
> {
> 	u32 stationhigh;
> 	u32 stationlow;
>+	int phy = physical_port[adapter->portnum];
> 	u8 val[8];
> 
> 	if (addr == NULL)
>@@ -610,13 +595,12 @@
>  * Set the station MAC address.
>  * Note that the passed-in value must already be in network byte order.
>  */
>-int netxen_niu_macaddr_set(struct netxen_port *port,
>+int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
> 			   netxen_ethernet_macaddr_t addr)
> {
> 	u8 temp[4];
> 	u32 val;
>-	struct netxen_adapter *adapter = port->adapter;
>-	int phy = port->portnum;
>+	int phy = physical_port[adapter->portnum];
> 	unsigned char mac_addr[6];
> 	int i;
> 
>@@ -634,7 +618,7 @@
> 		    (adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy), &val, 4))
> 			return -2;
> 
>-		netxen_niu_macaddr_get(adapter, phy,
>+		netxen_niu_macaddr_get(adapter, 
> 				       (netxen_ethernet_macaddr_t *) mac_addr);
> 		if (memcmp(mac_addr, addr, 6) == 0)
> 			break;
>@@ -642,7 +626,7 @@
> 
> 	if (i == 10) {
> 		printk(KERN_ERR "%s: cannot set Mac addr for %s\n",
>-		       netxen_nic_driver_name, port->netdev->name);
>+		       netxen_nic_driver_name, adapter->netdev->name);
> 		printk(KERN_ERR "MAC address set: "
> 		       "%02x:%02x:%02x:%02x:%02x:%02x.\n",
> 		       addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
>@@ -735,13 +719,13 @@
> }
> 
> /* Disable a GbE interface */
>-int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter, int port)
>+int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter)
> {
> 	__u32 mac_cfg0;
>+	u32 port = physical_port[adapter->portnum];
> 
>-	if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
>+	if (port > NETXEN_NIU_MAX_GBE_PORTS)
> 		return -EINVAL;
>-
> 	mac_cfg0 = 0;
> 	netxen_gb_soft_reset(mac_cfg0);
> 	if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
>@@ -751,13 +735,13 @@
> }
> 
> /* Disable an XG interface */
>-int netxen_niu_disable_xg_port(struct netxen_adapter *adapter, int port)
>+int netxen_niu_disable_xg_port(struct netxen_adapter *adapter)
> {
> 	__u32 mac_cfg;
>+	u32 port = physical_port[adapter->portnum];
> 
> 	if (port != 0)
> 		return -EINVAL;
>-
> 	mac_cfg = 0;
> 	netxen_xg_soft_reset(mac_cfg);
> 	if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_CONFIG_0,
>@@ -767,12 +751,13 @@
> }
> 
> /* Set promiscuous mode for a GbE interface */
>-int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, int port,
>+int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, 
> 				    netxen_niu_prom_mode_t mode)
> {
> 	__u32 reg;
>+	u32 port = physical_port[adapter->portnum];
> 
>-	if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
>+	if (port > NETXEN_NIU_MAX_GBE_PORTS)
> 		return -EINVAL;
> 
> 	/* save previous contents */
>@@ -824,25 +809,50 @@
>  * Set the MAC address for an XG port
>  * Note that the passed-in value must already be in network byte order.
>  */
>-int netxen_niu_xg_macaddr_set(struct netxen_port *port,
>+int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
> 			      netxen_ethernet_macaddr_t addr)
> {
>+	int phy = physical_port[adapter->portnum];
> 	u8 temp[4];
> 	u32 val;
>-	struct netxen_adapter *adapter = port->adapter;
> 
>-	temp[0] = temp[1] = 0;
>-	memcpy(temp + 2, addr, 2);
>-	val = le32_to_cpu(*(__le32 *)temp);
>-	if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
>-				   &val, 4))
>+	if ((phy < 0) || (phy > NETXEN_NIU_MAX_XG_PORTS))
> 		return -EIO;
> 
>-	memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
>-	val = le32_to_cpu(*(__le32 *)temp);
>-	if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
>-				   &val, 4))
>-		return -EIO;
>+	temp[0] = temp[1] = 0;
>+	switch (phy) {
>+	case 0:
>+	    memcpy(temp + 2, addr, 2);
>+	    val = le32_to_cpu(*(__le32 *)temp);
>+	    if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
>+				&val, 4))
>+		return -EIO;
>+
>+	    memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
>+	    val = le32_to_cpu(*(__le32 *)temp);
>+	    if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
>+				&val, 4))
>+		return -EIO;
>+	    break;
>+
>+	case 1:
>+	    memcpy(temp + 2, addr, 2);
>+	    val = le32_to_cpu(*(__le32 *)temp);
>+	    if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_1,
>+				&val, 4))
>+		return -EIO;
>+
>+	    memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
>+	    val = le32_to_cpu(*(__le32 *)temp);
>+	    if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_HI,
>+				&val, 4))
>+		return -EIO;
>+	    break;
>+
>+	default:
>+	    printk(KERN_ERR "Unknown port %d\n", phy);
>+	    break;
>+	}
> 
> 	return 0;
> }
>@@ -851,9 +861,10 @@
>  * Return the current station MAC address.
>  * Note that the passed-in value must already be in network byte order.
>  */
>-int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int phy,
>+int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter,
> 			      netxen_ethernet_macaddr_t * addr)
> {
>+	int phy = physical_port[adapter->portnum];
> 	u32 stationhigh;
> 	u32 stationlow;
> 	u8 val[8];
>@@ -878,21 +889,24 @@
> }
> 
> int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
>-				       int port, netxen_niu_prom_mode_t mode)
>+				       netxen_niu_prom_mode_t mode)
> {
> 	__u32 reg;
>+	u32 port = physical_port[adapter->portnum];
> 
>-	if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
>+	if (port > NETXEN_NIU_MAX_XG_PORTS)
> 		return -EINVAL;
> 
>-	if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_XGE_CONFIG_1, &reg, 4))
>-		return -EIO;
>+	if (netxen_nic_hw_read_wx(adapter,
>+		NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), &reg, 4))
>+			return -EIO;
> 	if (mode == NETXEN_NIU_PROMISC_MODE)
> 		reg = (reg | 0x2000UL);
> 	else
> 		reg = (reg & ~0x2000UL);
> 
>-	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_XGE_CONFIG_1, reg);
>+	netxen_crb_writelit_adapter(adapter,
>+		NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), reg);
> 
> 	return 0;
> }
>Index: linux-git/drivers/net/netxen/netxen_nic_phan_reg.h
>===================================================================
>--- linux-2.6.21.4/drivers/net/netxen/netxen_nic_phan_reg.h	2007-09-27 10:32:52.000000000 -0700
>+++ linux-git/drivers/net/netxen/netxen_nic_phan_reg.h	2007-09-27 10:36:10.000000000 -0700
>@@ -100,8 +100,35 @@
> 
> #define CRB_CMD_PRODUCER_OFFSET_1   NETXEN_NIC_REG(0x1ac)
> #define CRB_CMD_CONSUMER_OFFSET_1   NETXEN_NIC_REG(0x1b0)
>+#define CRB_CMD_PRODUCER_OFFSET_2   NETXEN_NIC_REG(0x1b8)
>+#define CRB_CMD_CONSUMER_OFFSET_2   NETXEN_NIC_REG(0x1bc)
>+
>+// 1c0 to 1cc used for signature reg
>+#define CRB_CMD_PRODUCER_OFFSET_3   NETXEN_NIC_REG(0x1d0)
>+#define CRB_CMD_CONSUMER_OFFSET_3   NETXEN_NIC_REG(0x1d4)
> #define CRB_TEMP_STATE              NETXEN_NIC_REG(0x1b4)
> 
>+#define CRB_V2P_0		    NETXEN_NIC_REG(0x290)
>+#define CRB_V2P_1		    NETXEN_NIC_REG(0x294)
>+#define CRB_V2P_2		    NETXEN_NIC_REG(0x298)
>+#define CRB_V2P_3		    NETXEN_NIC_REG(0x29c)
>+#define CRB_V2P(port)		    (CRB_V2P_0+((port)*4))
>+#define CRB_DRIVER_VERSION	    NETXEN_NIC_REG(0x2a0)
>+/* sw int status/mask registers */
>+#define CRB_SW_INT_MASK_0	   NETXEN_NIC_REG(0x1d8)
>+#define CRB_SW_INT_MASK_1	   NETXEN_NIC_REG(0x1e0)
>+#define CRB_SW_INT_MASK_2	   NETXEN_NIC_REG(0x1e4)
>+#define CRB_SW_INT_MASK_3	   NETXEN_NIC_REG(0x1e8)
>+
>+/*
>+ * capabilities register, can be used to selectively enable/disable features
>+ * for backward compability
>+ */
>+#define CRB_NIC_CAPABILITIES_HOST	NETXEN_NIC_REG(0x1a8)
>+#define CRB_NIC_CAPABILITIES_FW	  	NETXEN_NIC_REG(0x1dc)
>+
>+#define INTR_SCHEME_PERPORT	      	0x1
>+
> /* used for ethtool tests */
> #define CRB_SCRATCHPAD_TEST	    NETXEN_NIC_REG(0x280)
> 
>@@ -139,128 +166,13 @@
> };
> 
> #if defined(DEFINE_GLOBAL_RECV_CRB)
>-struct netxen_recv_crb recv_crb_registers[] = {
>-	/*
>-	 * Instance 0.
>-	 */
>-	{
>-	 /* rcv_desc_crb: */
>-	 {
>-	  {
>-	   /* crb_rcv_producer_offset: */
>-	   NETXEN_NIC_REG(0x100),
>-	   /* crb_rcv_consumer_offset: */
>-	   NETXEN_NIC_REG(0x104),
>-	   /* crb_gloablrcv_ring: */
>-	   NETXEN_NIC_REG(0x108),
>-	   /* crb_rcv_ring_size */
>-	   NETXEN_NIC_REG(0x10c),
>-
>-	   },
>-	  /* Jumbo frames */
>-	  {
>-	   /* crb_rcv_producer_offset: */
>-	   NETXEN_NIC_REG(0x110),
>-	   /* crb_rcv_consumer_offset: */
>-	   NETXEN_NIC_REG(0x114),
>-	   /* crb_gloablrcv_ring: */
>-	   NETXEN_NIC_REG(0x118),
>-	   /* crb_rcv_ring_size */
>-	   NETXEN_NIC_REG(0x11c),
>-	   },
>-	  /* LRO */
>-	  {
>-	   /* crb_rcv_producer_offset: */
>-	   NETXEN_NIC_REG(0x120),
>-	   /* crb_rcv_consumer_offset: */
>-	   NETXEN_NIC_REG(0x124),
>-	   /* crb_gloablrcv_ring: */
>-	   NETXEN_NIC_REG(0x128),
>-	   /* crb_rcv_ring_size */
>-	   NETXEN_NIC_REG(0x12c),
>-	   }
>-	  },
>-	 /* crb_rcvstatus_ring: */
>-	 NETXEN_NIC_REG(0x130),
>-	 /* crb_rcv_status_producer: */
>-	 NETXEN_NIC_REG(0x134),
>-	 /* crb_rcv_status_consumer: */
>-	 NETXEN_NIC_REG(0x138),
>-	 /* crb_rcvpeg_state: */
>-	 NETXEN_NIC_REG(0x13c),
>-	 /* crb_status_ring_size */
>-	 NETXEN_NIC_REG(0x140),
>-
>-	 },
>-	/*
>-	 * Instance 1,
>-	 */
>-	{
>-	 /* rcv_desc_crb: */
>-	 {
>-	  {
>-	   /* crb_rcv_producer_offset: */
>-	   NETXEN_NIC_REG(0x144),
>-	   /* crb_rcv_consumer_offset: */
>-	   NETXEN_NIC_REG(0x148),
>-	   /* crb_globalrcv_ring: */
>-	   NETXEN_NIC_REG(0x14c),
>-	   /* crb_rcv_ring_size */
>-	   NETXEN_NIC_REG(0x150),
>-
>-	   },
>-	  /* Jumbo frames */
>-	  {
>-	   /* crb_rcv_producer_offset: */
>-	   NETXEN_NIC_REG(0x154),
>-	   /* crb_rcv_consumer_offset: */
>-	   NETXEN_NIC_REG(0x158),
>-	   /* crb_globalrcv_ring: */
>-	   NETXEN_NIC_REG(0x15c),
>-	   /* crb_rcv_ring_size */
>-	   NETXEN_NIC_REG(0x160),
>-	   },
>-	  /* LRO */
>-	  {
>-	   /* crb_rcv_producer_offset: */
>-	   NETXEN_NIC_REG(0x164),
>-	   /* crb_rcv_consumer_offset: */
>-	   NETXEN_NIC_REG(0x168),
>-	   /* crb_globalrcv_ring: */
>-	   NETXEN_NIC_REG(0x16c),
>-	   /* crb_rcv_ring_size */
>-	   NETXEN_NIC_REG(0x170),
>-	   }
>-
>-	  },
>-	 /* crb_rcvstatus_ring: */
>-	 NETXEN_NIC_REG(0x174),
>-	 /* crb_rcv_status_producer: */
>-	 NETXEN_NIC_REG(0x178),
>-	 /* crb_rcv_status_consumer: */
>-	 NETXEN_NIC_REG(0x17c),
>-	 /* crb_rcvpeg_state: */
>-	 NETXEN_NIC_REG(0x180),
>-	 /* crb_status_ring_size */
>-	 NETXEN_NIC_REG(0x184),
>-
>-	 },
>-};
>-
>-u64 ctx_addr_sig_regs[][3] = {
>-	{NETXEN_NIC_REG(0x188), NETXEN_NIC_REG(0x18c), NETXEN_NIC_REG(0x1c0)},
>-	{NETXEN_NIC_REG(0x190), NETXEN_NIC_REG(0x194), NETXEN_NIC_REG(0x1c4)},
>-	{NETXEN_NIC_REG(0x198), NETXEN_NIC_REG(0x19c), NETXEN_NIC_REG(0x1c8)},
>-	{NETXEN_NIC_REG(0x1a0), NETXEN_NIC_REG(0x1a4), NETXEN_NIC_REG(0x1cc)}
>-};
>-
> #else
> extern struct netxen_recv_crb recv_crb_registers[];
> extern u64 ctx_addr_sig_regs[][3];
>-#define CRB_CTX_ADDR_REG_LO            (ctx_addr_sig_regs[0][0])
>-#define CRB_CTX_ADDR_REG_HI            (ctx_addr_sig_regs[0][2])
>-#define CRB_CTX_SIGNATURE_REG       (ctx_addr_sig_regs[0][1])
> #endif				/* DEFINE_GLOBAL_RECEIVE_CRB */
>+#define CRB_CTX_ADDR_REG_LO(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][0])
>+#define CRB_CTX_ADDR_REG_HI(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][2])
>+#define CRB_CTX_SIGNATURE_REG(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][1])
> 
> /*
>  * Temperature control.

Actions: View

Attachments on bug 236869: 158374 | 158378 | 158823 | 234421 | 234431