Attachment 313475 Details for Bug 457958 – Patch 1 of 4 to support the backporting to support Firmware 4.0.xxx and chip revision >= 0x41

[patch] Patch 1 of 4 to support the backporting to support Firmware 4.0.xxx and chip revision >= 0x41

rhl53.patchset1.p2.p01-p18.patch (text/plain), 54.65 KB, created by Dhananjay Phadke on 2008-08-05 19:12:06 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Dhananjay Phadke

Created: 2008-08-05 19:12:06 UTC

Size: 54.65 KB

patch

obsolete

>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic_ethtool.c rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_ethtool.c
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic_ethtool.c	2008-07-22 18:07:57.106585000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_ethtool.c	2008-07-22 11:16:00.124359000 -0700
>@@ -64,15 +64,7 @@ static const struct netxen_nic_stats net
> 	{"bad_skb_len", NETXEN_NIC_STAT(stats.badskblen)},
> 	{"no_cmd_desc", NETXEN_NIC_STAT(stats.nocmddescriptor)},
> 	{"polled", NETXEN_NIC_STAT(stats.polled)},
>-	{"uphappy", NETXEN_NIC_STAT(stats.uphappy)},
>-	{"updropped", NETXEN_NIC_STAT(stats.updropped)},
>-	{"uplcong", NETXEN_NIC_STAT(stats.uplcong)},
>-	{"uphcong", NETXEN_NIC_STAT(stats.uphcong)},
>-	{"upmcong", NETXEN_NIC_STAT(stats.upmcong)},
>-	{"updunno", NETXEN_NIC_STAT(stats.updunno)},
>-	{"skb_freed", NETXEN_NIC_STAT(stats.skbfreed)},
> 	{"tx_dropped", NETXEN_NIC_STAT(stats.txdropped)},
>-	{"tx_null_skb", NETXEN_NIC_STAT(stats.txnullskb)},
> 	{"csummed", NETXEN_NIC_STAT(stats.csummed)},
> 	{"no_rcv", NETXEN_NIC_STAT(stats.no_rcv)},
> 	{"rx_bytes", NETXEN_NIC_STAT(stats.rxbytes)},
>@@ -518,17 +510,17 @@ netxen_nic_get_ringparam(struct net_devi
> 	ring->rx_jumbo_pending = 0;
> 	for (i = 0; i < MAX_RCV_CTX; ++i) {
> 		ring->rx_pending += adapter->recv_ctx[i].
>-		    rcv_desc[RCV_DESC_NORMAL_CTXID].rcv_pending;
>+		    rcv_desc[RCV_DESC_NORMAL_CTXID].max_rx_desc_count;
> 		ring->rx_jumbo_pending += adapter->recv_ctx[i].
>-		    rcv_desc[RCV_DESC_JUMBO_CTXID].rcv_pending;
>+		    rcv_desc[RCV_DESC_JUMBO_CTXID].max_rx_desc_count;
> 	}
>+	ring->tx_pending = adapter->max_tx_desc_count;
> 
>-	ring->rx_max_pending = adapter->max_rx_desc_count;
>-	ring->tx_max_pending = adapter->max_tx_desc_count;
>-	ring->rx_jumbo_max_pending = adapter->max_jumbo_rx_desc_count;
>+	ring->rx_max_pending = MAX_RCV_DESCRIPTORS;
>+	ring->tx_max_pending = MAX_CMD_DESCRIPTORS_HOST;
>+	ring->rx_jumbo_max_pending = MAX_JUMBO_RCV_DESCRIPTORS;
> 	ring->rx_mini_max_pending = 0;
> 	ring->rx_mini_pending = 0;
>-	ring->rx_jumbo_pending = 0;
> }
> 
> static void
>@@ -731,6 +723,19 @@ netxen_nic_get_ethtool_stats(struct net_
> 	}
> }
> 
>+static u32 netxen_nic_get_rx_csum(struct net_device *dev)
>+{
>+	struct netxen_adapter *adapter = netdev_priv(dev);
>+	return adapter->rx_csum;
>+}
>+
>+static int netxen_nic_set_rx_csum(struct net_device *dev, u32 data)
>+{
>+	struct netxen_adapter *adapter = netdev_priv(dev);
>+	adapter->rx_csum = !!data;
>+	return 0;
>+}
>+
> struct ethtool_ops netxen_nic_ethtool_ops = {
> 	.get_settings = netxen_nic_get_settings,
> 	.set_settings = netxen_nic_set_settings,
>@@ -755,4 +760,6 @@ struct ethtool_ops netxen_nic_ethtool_op
> 	.get_strings = netxen_nic_get_strings,
> 	.get_stats_count = netxen_nic_get_stats_count,
> 	.get_ethtool_stats = netxen_nic_get_ethtool_stats,
>+ 	.get_rx_csum = netxen_nic_get_rx_csum,
>+ 	.set_rx_csum = netxen_nic_set_rx_csum,
> };
>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic.h rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic.h
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic.h	2008-07-22 18:07:57.108581000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic.h	2008-07-22 11:16:00.130356000 -0700
>@@ -65,8 +65,8 @@
> 
> #define _NETXEN_NIC_LINUX_MAJOR 3
> #define _NETXEN_NIC_LINUX_MINOR 4
>-#define _NETXEN_NIC_LINUX_SUBVERSION 2
>-#define NETXEN_NIC_LINUX_VERSIONID  "3.4.2"
>+#define _NETXEN_NIC_LINUX_SUBVERSION 18
>+#define NETXEN_NIC_LINUX_VERSIONID  "3.4.18"
> 
> #define NETXEN_NUM_FLASH_SECTORS (64)
> #define NETXEN_FLASH_SECTOR_SIZE (64 * 1024)
>@@ -85,7 +85,7 @@
> 	(sizeof(struct netxen_cmd_buffer) * adapter->max_tx_desc_count)
> #define RCV_BUFFSIZE	\
> 	(sizeof(struct netxen_rx_buffer) * rcv_desc->max_rx_desc_count)
>-#define find_diff_among(a,b,range) ((a)<=(b)?((b)-(a)):((b)+(range)-(a)))
>+#define find_diff_among(a,b,range) ((a)<(b)?((b)-(a)):((b)+(range)-(a)))
> 
> #define NETXEN_NETDEV_STATUS		0x1
> #define NETXEN_RCV_PRODUCER_OFFSET	0
>@@ -204,7 +204,7 @@ enum {
> 			? RCV_DESC_LRO :	\
> 			(RCV_DESC_NORMAL)))
> 
>-#define MAX_CMD_DESCRIPTORS		1024
>+#define MAX_CMD_DESCRIPTORS		4096
> #define MAX_RCV_DESCRIPTORS		16384
> #define MAX_CMD_DESCRIPTORS_HOST	(MAX_CMD_DESCRIPTORS / 4)
> #define MAX_RCV_DESCRIPTORS_1G		(MAX_RCV_DESCRIPTORS / 4)
>@@ -310,21 +310,27 @@ struct netxen_ring_ctx {
> 	((cmd_desc)->port_ctxid &= ~(0xf<<4),	    \
> 	(cmd_desc)->port_ctxid |= (val & 0xf) << 4)
> 
>+#define netxen_set_cmd_desc_flags(cmd_desc, val)	\
>+ 	(cmd_desc)->flags_opcode = ((cmd_desc)->flags_opcode & \
>+ 		~cpu_to_le16(0x7f)) | cpu_to_le16((val) & 0x7f)
> #define netxen_set_cmd_desc_opcode(cmd_desc, val)	\
>-	((cmd_desc)->flags_opcode &= ~(0x3f<<7),        \
>-	(cmd_desc)->flags_opcode |= (val & 0x3f)<<7)
>+ 	(cmd_desc)->flags_opcode = ((cmd_desc)->flags_opcode & \
>+ 		~cpu_to_le16((u16)0x3f << 7)) | cpu_to_le16(((val) & 0x3f) << 7)
> 
> #define netxen_set_cmd_desc_num_of_buff(cmd_desc, val)			\
>-	((cmd_desc)->num_of_buffers_total_length &= ~(0xff<<0),		\
>-	(cmd_desc)->num_of_buffers_total_length |= (val & 0xff)<<0)
>+ 	(cmd_desc)->num_of_buffers_total_length = \
>+ 		((cmd_desc)->num_of_buffers_total_length & \
>+ 		~cpu_to_le32(0xff)) | cpu_to_le32((val) & 0xff)
> #define netxen_set_cmd_desc_totallength(cmd_desc, val)			\
>-	((cmd_desc)->num_of_buffers_total_length &= ~(0xffffff<<8),	\
>-	(cmd_desc)->num_of_buffers_total_length |= (val & 0xffffff) <<8)
>+ 	(cmd_desc)->num_of_buffers_total_length = \
>+ 		((cmd_desc)->num_of_buffers_total_length & \
>+ 		~cpu_to_le32((u32)0xffffff << 8)) | \
>+ 		cpu_to_le32(((val) & 0xffffff) << 8)
> 
> #define netxen_get_cmd_desc_opcode(cmd_desc)	\
>-	(((cmd_desc)->flags_opcode >> 7) & 0x003F)
>+ 	((le16_to_cpu((cmd_desc)->flags_opcode) >> 7) & 0x003f)
> #define netxen_get_cmd_desc_totallength(cmd_desc)	\
>-	(((cmd_desc)->num_of_buffers_total_length >> 8) & 0x0FFFFFF)
>+ 	((le32_to_cpu((cmd_desc)->num_of_buffers_total_length) >> 8) & 0xffffff)
> 
> struct cmd_desc_type0 {
> 	u8 tcp_hdr_offset;	/* For LSO only */
>@@ -411,25 +417,29 @@ struct rcv_desc {
> #define netxen_get_sts_desc_lro_last_frag(status_desc)  \
> 	((((status_desc)->lro) >> 7) & 0x1)
> 
>-#define netxen_get_sts_status(status_desc)      \
>-	(((status_desc) >> 4) & 0x0F)
>-#define netxen_get_sts_type(status_desc)        \
>-	(((status_desc) >> 8) & 0x0F)
>-#define netxen_get_sts_totallength(status_desc) \
>-	(((status_desc) >> 12) & 0xFFFF)
>-#define netxen_get_sts_refhandle(status_desc)   \
>-	(((status_desc) >> 28) & 0xFFFF)
>+#define netxen_get_sts_port(sts_data)	\
>+	((sts_data) & 0x0F)
>+#define netxen_get_sts_status(sts_data)	\
>+	(((sts_data) >> 4) & 0x0F)
>+#define netxen_get_sts_type(sts_data)	\
>+	(((sts_data) >> 8) & 0x0F)
>+#define netxen_get_sts_totallength(sts_data)	\
>+	(((sts_data) >> 12) & 0xFFFF)
>+#define netxen_get_sts_refhandle(sts_data)	\
>+	(((sts_data) >> 28) & 0xFFFF)
>+#define netxen_get_sts_prot(sts_data)	\
>+	(((sts_data) >> 44) & 0x0F)
>+#define netxen_get_sts_opcode(sts_data)	\
>+	(((sts_data) >> 58) & 0x03F)
> 
>-#define netxen_get_sts_prot(status_desc)	\
>-	(((status_desc) >> 44) & 0x0F)
> #define netxen_get_sts_owner(status_desc)       \
> 	(((status_desc) >> 56) & 0x03)
> 
>-#define netxen_set_sts_owner(status_desc, val) {        \
>-	u64 value = le64_to_cpu((status_desc)->status_desc_data);      \
>-	value &= ~(0x3ULL << 56);                                       \
>-	value |= (u64)(((u64)(val) << 56) & (0x3ULL << 56));            \
>-	(status_desc)->status_desc_data = cpu_to_le64(value);          \
>+#define netxen_set_sts_owner(status_desc, val)	{ \
>+	(status_desc)->status_desc_data = \
>+		((status_desc)->status_desc_data & \
>+		~cpu_to_le64(0x3ULL << 56)) | \
>+		cpu_to_le64((u64)((val) & 0x3) << 56); \
> }
> 
> struct status_desc {
>@@ -806,15 +816,8 @@ struct netxen_adapter_stats {
> 	u64  badskblen;
> 	u64  nocmddescriptor;
> 	u64  polled;
>-	u64  uphappy;
>-	u64  updropped;
>-	u64  uplcong;
>-	u64  uphcong;
>-	u64  upmcong;
>-	u64  updunno;
>-	u64  skbfreed;
>+	u64  rxdropped;
> 	u64  txdropped;
>-	u64  txnullskb;
> 	u64  csummed;
> 	u64  no_rcv;
> 	u64  rxbytes;
>@@ -830,7 +833,6 @@ struct netxen_rcv_desc_ctx {
> 	u32 flags;
> 	u32 producer;
> 	u32 rcv_pending;	/* Num of bufs posted in phantom */
>-	u32 rcv_free;		/* Num of bufs in free list */
> 	dma_addr_t phys_addr;
> 	struct pci_dev *phys_pdev;
> 	struct rcv_desc *desc_head;	/* address of rx ring in Phantom */
>@@ -876,8 +878,6 @@ struct netxen_adapter {
> 	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;
>@@ -886,16 +886,12 @@ struct netxen_adapter {
> 
> 	u32 cmd_producer;
> 	u32 *cmd_consumer;
>-
> 	u32 last_cmd_consumer;
>+
> 	u32 max_tx_desc_count;
> 	u32 max_rx_desc_count;
> 	u32 max_jumbo_rx_desc_count;
> 	u32 max_lro_rx_desc_count;
>-	/* Num of instances active on cmd buffer ring */
>-	u32 proc_cmd_buf_counter;
>-
>-	u32 num_threads, total_threads;	/*Use to keep track of xmit threads */
> 
> 	u32 flags;
> 	u32 irq;
>@@ -909,7 +905,7 @@ struct netxen_adapter {
> 	u16 link_duplex;
> 	u16 state;
> 	u16 link_autoneg;
>-	int rcsum;
>+	int rx_csum;
> 	int status;
> 	spinlock_t stats_lock;
> 
>@@ -928,6 +924,8 @@ struct netxen_adapter {
> 	struct netxen_ring_ctx *ctx_desc;
> 	struct pci_dev *ctx_desc_pdev;
> 	dma_addr_t ctx_desc_phys_addr;
>+	int intr_scheme;
>+	int msi_mode;
> 	int (*enable_phy_interrupts) (struct netxen_adapter *);
> 	int (*disable_phy_interrupts) (struct netxen_adapter *);
> 	void (*handle_phy_intr) (struct netxen_adapter *);
>@@ -960,6 +958,24 @@ struct netxen_adapter {
> #define netxen_get_dma_watchdog_disabled(config_word) \
> 	(((config_word) >> 1) & 0x1)
> 
>+/*
>+ * 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
>+ */
>+
>+#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)
>+
> /* Max number of xmit producer threads that can run simultaneously */
> #define	MAX_XMIT_PRODUCERS		16
> 
>@@ -1073,54 +1089,18 @@ void netxen_tso_check(struct netxen_adap
> 		      struct cmd_desc_type0 *desc, struct sk_buff *skb);
> int netxen_nic_hw_resources(struct netxen_adapter *adapter);
> void netxen_nic_clear_stats(struct netxen_adapter *adapter);
>-int netxen_nic_rx_has_work(struct netxen_adapter *adapter);
>-int netxen_nic_tx_has_work(struct netxen_adapter *adapter);
> void netxen_watchdog_task(unsigned long adapid);
> void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx,
> 			    u32 ringid);
> void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, u32 ctx,
> 				 u32 ringid);
>-int netxen_process_cmd_ring(unsigned long data);
>+int netxen_process_cmd_ring(struct netxen_adapter *adapter);
> u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctx, int max);
> void netxen_nic_set_multi(struct net_device *netdev);
> int netxen_nic_change_mtu(struct net_device *netdev, int new_mtu);
> 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(0X0, NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
>-		writel(mask, PCI_OFFSET_SECOND_RANGE(adapter,
>-						     ISR_INT_TARGET_MASK));
>-	}
>-}
> 
> /*
>  * NetXen Board information
>@@ -1203,8 +1183,7 @@ dma_watchdog_shutdown_poll_result(struct
> 	    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) &&
>-		(netxen_get_dma_watchdog_disabled(ctrl) == 0));
>+	return (netxen_get_dma_watchdog_enabled(ctrl) == 0);
> }
> 
> static inline int
>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic_hdr.h rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_hdr.h
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic_hdr.h	2008-07-22 18:07:57.109587000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_hdr.h	2008-07-22 11:16:00.136355000 -0700
>@@ -456,6 +456,12 @@ enum {
> #define ISR_INT_MASK_SLOW	(NETXEN_PCIX_PS_REG(PCIX_INT_MASK))
> #define ISR_INT_TARGET_STATUS	(NETXEN_PCIX_PS_REG(PCIX_TARGET_STATUS))
> #define ISR_INT_TARGET_MASK	(NETXEN_PCIX_PS_REG(PCIX_TARGET_MASK))
>+#define ISR_INT_TARGET_STATUS_F1   (NETXEN_PCIX_PS_REG(PCIX_TARGET_STATUS_F1))
>+#define ISR_INT_TARGET_MASK_F1     (NETXEN_PCIX_PS_REG(PCIX_TARGET_MASK_F1))
>+#define ISR_INT_TARGET_STATUS_F2   (NETXEN_PCIX_PS_REG(PCIX_TARGET_STATUS_F2))
>+#define ISR_INT_TARGET_MASK_F2     (NETXEN_PCIX_PS_REG(PCIX_TARGET_MASK_F2))
>+#define ISR_INT_TARGET_STATUS_F3   (NETXEN_PCIX_PS_REG(PCIX_TARGET_STATUS_F3))
>+#define ISR_INT_TARGET_MASK_F3     (NETXEN_PCIX_PS_REG(PCIX_TARGET_MASK_F3))
> 
> #define NETXEN_PCI_MAPSIZE	128
> #define NETXEN_PCI_DDR_NET	(0x00000000UL)
>@@ -649,9 +655,11 @@ enum {
> #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)
>@@ -660,6 +668,12 @@ enum {
> 
> #define PCIX_TARGET_STATUS	(0x10118)
> #define PCIX_TARGET_MASK	(0x10128)
>+#define PCIX_TARGET_STATUS_F1 (0x10160)
>+#define PCIX_TARGET_MASK_F1   (0x10170)
>+#define PCIX_TARGET_STATUS_F2 (0x10164)
>+#define PCIX_TARGET_MASK_F2   (0x10174)
>+#define PCIX_TARGET_STATUS_F3 (0x10168)
>+#define PCIX_TARGET_MASK_F3   (0x10178)
> 
> #define PCIX_MSI_F0		(0x13000)
> #define PCIX_MSI_F1		(0x13004)
>@@ -689,4 +703,6 @@ enum {
> 
> #define NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL		(0x14)
> 
>+#define NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL		(0x14)
>+
> #endif				/* __NETXEN_NIC_HDR_H_ */
>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic_hw.c rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_hw.c
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic_hw.c	2008-07-22 18:07:57.111585000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_hw.c	2008-07-22 11:16:00.144355000 -0700
>@@ -390,7 +390,13 @@ int netxen_nic_hw_resources(struct netxe
> 			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);
>+	adapter->msi_mode = readl(
>+		NETXEN_CRB_NORMALIZE(adapter, CRB_NIC_MSI_MODE_FW));
>+	DPRINTK(INFO, "Receive Peg ready too. starting stuff\n");
> 
> 	addr = netxen_alloc(adapter->ahw.pdev,
> 			    sizeof(struct netxen_ring_ctx) +
>@@ -899,11 +905,11 @@ netxen_nic_pci_set_window(struct netxen_
> 			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;
>@@ -924,11 +930,11 @@ netxen_nic_pci_set_window(struct netxen_
> 			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;
>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic_init.c rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_init.c
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic_init.c	2008-07-22 18:07:57.114587000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_init.c	2008-07-22 11:16:00.156354000 -0700
>@@ -139,6 +139,10 @@ int netxen_init_firmware(struct netxen_a
> 		return err;
> 	}
> 	/* Window 1 call */
>+	writel(INTR_SCHEME_PERPORT,
>+	       NETXEN_CRB_NORMALIZE(adapter, CRB_NIC_CAPABILITIES_HOST));
>+	writel(MSI_MODE_MULTIFUNC,
>+	       NETXEN_CRB_NORMALIZE(adapter, CRB_NIC_MSI_MODE_HOST));
> 	writel(MPORT_MULTI_FUNCTION_MODE,
> 	       NETXEN_CRB_NORMALIZE(adapter, CRB_MPORT_MODE));
> 	writel(PHAN_INITIALIZE_ACK,
>@@ -177,7 +181,6 @@ void netxen_initialize_adapter_sw(struct
> 		for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
> 			struct netxen_rx_buffer *rx_buf;
> 			rcv_desc = &adapter->recv_ctx[ctxid].rcv_desc[ring];
>-			rcv_desc->rcv_free = rcv_desc->max_rx_desc_count;
> 			rcv_desc->begin_alloc = 0;
> 			rx_buf = rcv_desc->rx_buf_arr;
> 			num_rx_bufs = rcv_desc->max_rx_desc_count;
>@@ -970,29 +973,6 @@ int netxen_phantom_init(struct netxen_ad
>  	return 0;
> }
> 
>-int netxen_nic_rx_has_work(struct netxen_adapter *adapter)
>-{
>-	int ctx;
>-
>-	for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
>-		struct netxen_recv_context *recv_ctx =
>-		    &(adapter->recv_ctx[ctx]);
>-		u32 consumer;
>-		struct status_desc *desc_head;
>-		struct status_desc *desc;
>-
>-		consumer = recv_ctx->status_rx_consumer;
>-		desc_head = recv_ctx->rcv_status_desc_head;
>-		desc = &desc_head[consumer];
>-
>-		if ((netxen_get_sts_owner(le64_to_cpu(desc->status_desc_data)))
>-				& STATUS_OWNER_HOST)
>-			return 1;
>-	}
>-
>-	return 0;
>-}
>-
> static inline int netxen_nic_check_temp(struct netxen_adapter *adapter)
> {
> 	struct net_device *netdev = adapter->netdev;
>@@ -1035,7 +1015,6 @@ static inline int netxen_nic_check_temp(
> 
> void netxen_watchdog_task(unsigned long adaptid)
> {
>-	struct net_device *netdev;
> 	struct netxen_adapter *adapter = (struct netxen_adapter *)adaptid;
> 
> 	if ((adapter->portnum  == 0) && netxen_nic_check_temp(adapter))
>@@ -1044,20 +1023,6 @@ void netxen_watchdog_task(unsigned long 
> 	if (adapter->handle_phy_intr)
> 		adapter->handle_phy_intr(adapter);
> 
>-	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);
>-	}
>-
> 	mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
> }
> 
>@@ -1070,19 +1035,19 @@ void
> netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
> 		   struct status_desc *desc)
> {
>-	u64 status_desc = le64_to_cpu(desc->status_desc_data);
> 	struct pci_dev *pdev = adapter->pdev;
> 	struct net_device *netdev = adapter->netdev;
>-	int index = netxen_get_sts_refhandle(status_desc);
>+	u64 sts_data = le64_to_cpu(desc->status_desc_data);
>+	int index = netxen_get_sts_refhandle(sts_data);
> 	struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctxid]);
> 	struct netxen_rx_buffer *buffer;
> 	struct sk_buff *skb;
>-	u32 length = netxen_get_sts_totallength(status_desc);
>+	u32 length = netxen_get_sts_totallength(sts_data);
> 	u32 desc_ctx;
> 	struct netxen_rcv_desc_ctx *rcv_desc;
> 	int ret;
> 
>-	desc_ctx = netxen_get_sts_type(status_desc);
>+	desc_ctx = netxen_get_sts_type(sts_data);
> 	if (unlikely(desc_ctx >= NUM_RCV_DESC_RINGS)) {
> 		printk("%s: %s Bad Rcv descriptor ring\n",
> 		       netxen_nic_driver_name, netdev->name);
>@@ -1121,10 +1086,13 @@ netxen_process_rcv(struct netxen_adapter
> 
> 	skb = (struct sk_buff *)buffer->skb;
> 
>-	if (likely(netxen_get_sts_status(status_desc) == STATUS_CKSUM_OK)) {
>+ 	if (likely(adapter->rx_csum &&
>+ 			netxen_get_sts_status(sts_data) == STATUS_CKSUM_OK)) {
> 		adapter->stats.csummed++;
> 		skb->ip_summed = CHECKSUM_UNNECESSARY;
>-	}
>+ 	} else
>+ 		skb->ip_summed = CHECKSUM_NONE;
>+
> 	skb->dev = netdev;
> 	if (desc_ctx == RCV_DESC_LRO_CTXID) {
> 		/* True length was only available on the last pkt */
>@@ -1136,40 +1104,8 @@ netxen_process_rcv(struct netxen_adapter
> 	skb->protocol = eth_type_trans(skb, netdev);
> 
> 	ret = netif_receive_skb(skb);
>-
>-	/*
>-	 * RH: Do we need these stats on a regular basis. Can we get it from
>-	 * Linux stats.
>-	 */
>-	switch (ret) {
>-	case NET_RX_SUCCESS:
>-		adapter->stats.uphappy++;
>-		break;
>-
>-	case NET_RX_CN_LOW:
>-		adapter->stats.uplcong++;
>-		break;
>-
>-	case NET_RX_CN_MOD:
>-		adapter->stats.upmcong++;
>-		break;
>-
>-	case NET_RX_CN_HIGH:
>-		adapter->stats.uphcong++;
>-		break;
>-
>-	case NET_RX_DROP:
>-		adapter->stats.updropped++;
>-		break;
>-
>-	default:
>-		adapter->stats.updunno++;
>-		break;
>-	}
>-
> 	netdev->last_rx = jiffies;
> 
>-	rcv_desc->rcv_free++;
> 	rcv_desc->rcv_pending--;
> 
> 	/*
>@@ -1194,13 +1130,6 @@ u32 netxen_process_rcv_ring(struct netxe
> 	u32 producer = 0;
> 	int count = 0, ring;
> 
>-	DPRINTK(INFO, "procesing receive\n");
>-	/*
>-	 * we assume in this case that there is only one port and that is
>-	 * port #1...changes need to be done in firmware to indicate port
>-	 * number as part of the descriptor. This way we will be able to get
>-	 * the netdev which is associated with that device.
>-	 */
> 	while (count < max) {
> 		desc = &desc_head[consumer];
> 		if (!
>@@ -1215,10 +1144,8 @@ u32 netxen_process_rcv_ring(struct netxe
> 		consumer = (consumer + 1) & (adapter->max_rx_desc_count - 1);
> 		count++;
> 	}
>-	if (count) {
>-		for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
>-			netxen_post_rx_buffers_nodb(adapter, ctxid, ring);
>-		}
>+	for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
>+		netxen_post_rx_buffers_nodb(adapter, ctxid, ring);
> 	}
> 
> 	/* update the consumer index in phantom */
>@@ -1229,110 +1156,60 @@ u32 netxen_process_rcv_ring(struct netxe
> 		/* Window = 1 */
> 		writel(consumer,
> 		       NETXEN_CRB_NORMALIZE(adapter,
>-					    recv_crb_registers[adapter->portnum].
>+				    recv_crb_registers[adapter->portnum].
> 					    crb_rcv_status_consumer));
>-		wmb();
> 	}
> 
> 	return count;
> }
> 
> /* Process Command status ring */
>-int netxen_process_cmd_ring(unsigned long data)
>+int netxen_process_cmd_ring(struct netxen_adapter *adapter)
> {
>-	u32 last_consumer;
>-	u32 consumer;
>-	struct netxen_adapter *adapter = (struct netxen_adapter *)data;
>-	int count1 = 0;
>-	int count2 = 0;
>+	u32 last_consumer, consumer;
>+	int count = 0, i;
> 	struct netxen_cmd_buffer *buffer;
>-	struct pci_dev *pdev;
>+	struct pci_dev *pdev = adapter->pdev;
>+	struct net_device *netdev = adapter->netdev;
> 	struct netxen_skb_frag *frag;
>-	u32 i;
>-	struct sk_buff *skb = NULL;
>-	int done;
>+	int done = 0;
> 
>-	spin_lock(&adapter->tx_lock);
> 	last_consumer = adapter->last_cmd_consumer;
>-	DPRINTK(INFO, "procesing xmit complete\n");
>-	/* we assume in this case that there is only one port and that is
>-	 * port #1...changes need to be done in firmware to indicate port
>-	 * number as part of the descriptor. This way we will be able to get
>-	 * the netdev which is associated with that device.
>-	 */
>-
> 	consumer = le32_to_cpu(*(adapter->cmd_consumer));
>-	if (last_consumer == consumer) {	/* Ring is empty    */
>-		DPRINTK(INFO, "last_consumer %d == consumer %d\n",
>-			last_consumer, consumer);
>-		spin_unlock(&adapter->tx_lock);
>-		return 1;
>-	}
> 
>-	adapter->proc_cmd_buf_counter++;
>-	/*
>-	 * Not needed - does not seem to be used anywhere.
>-	 * adapter->cmd_consumer = consumer;
>-	 */
>-	spin_unlock(&adapter->tx_lock);
>-
>-	while ((last_consumer != consumer) && (count1 < MAX_STATUS_HANDLE)) {
>+	while (last_consumer != consumer) {
> 		buffer = &adapter->cmd_buf_arr[last_consumer];
>-		pdev = adapter->pdev;
>-		frag = &buffer->frag_array[0];
>-		skb = buffer->skb;
>-		if (skb && (cmpxchg(&buffer->skb, skb, 0) == skb)) {
>+		if (buffer->skb) {
>+			frag = &buffer->frag_array[0];
> 			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;
> 			}
> 
>-			adapter->stats.skbfreed++;
>-			dev_kfree_skb_any(skb);
>-			skb = NULL;
>-		} else if (adapter->proc_cmd_buf_counter == 1) {
>-			adapter->stats.txnullskb++;
>-		}
>-		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);
>+			adapter->stats.xmitfinished++;
>+			dev_kfree_skb_any(buffer->skb);
>+			buffer->skb = NULL;
> 		}
> 
> 		last_consumer = get_next_index(last_consumer,
> 					       adapter->max_tx_desc_count);
>-		count1++;
>+		if (++count >= MAX_STATUS_HANDLE)
>+			break;
> 	}
> 
>-	count2 = 0;
>-	spin_lock(&adapter->tx_lock);
>-	if ((--adapter->proc_cmd_buf_counter) == 0) {
>+	if (count) {
> 		adapter->last_cmd_consumer = last_consumer;
>-		while ((adapter->last_cmd_consumer != consumer)
>-		       && (count2 < MAX_STATUS_HANDLE)) {
>-			buffer =
>-			    &adapter->cmd_buf_arr[adapter->last_cmd_consumer];
>-			count2++;
>-			if (buffer->skb)
>-				break;
>-			else
>-				adapter->last_cmd_consumer =
>-				    get_next_index(adapter->last_cmd_consumer,
>-						   adapter->max_tx_desc_count);
>-		}
>-	}
>-	if (count1 || count2) {
>-		if (netif_queue_stopped(adapter->netdev)
>-		    && (adapter->flags & NETXEN_NETDEV_STATUS)) {
>-			netif_wake_queue(adapter->netdev);
>-			adapter->flags &= ~NETXEN_NETDEV_STATUS;
>+		smp_mb();
>+		if (netif_queue_stopped(netdev) && netif_running(netdev)) {
>+			netif_tx_lock(netdev);
>+			netif_wake_queue(netdev);
>+			smp_mb();
>+			netif_tx_unlock(netdev);
> 		}
> 	}
> 	/*
>@@ -1348,16 +1225,9 @@ int netxen_process_cmd_ring(unsigned lon
> 	 * There is still a possible race condition and the host could miss an
> 	 * interrupt. The card has to take care of this.
> 	 */
>-	if (adapter->last_cmd_consumer == consumer &&
>-	    (((adapter->cmd_producer + 1) %
>-	      adapter->max_tx_desc_count) == adapter->last_cmd_consumer)) {
>-		consumer = le32_to_cpu(*(adapter->cmd_consumer));
>-	}
>-	done = (adapter->last_cmd_consumer == consumer);
>-
>-	spin_unlock(&adapter->tx_lock);
>-	DPRINTK(INFO, "last consumer is %d in %s\n", last_consumer,
>-		__FUNCTION__);
>+	consumer = le32_to_cpu(*(adapter->cmd_consumer));
>+	done = (last_consumer == consumer);
>+
> 	return (done);
> }
> 
>@@ -1431,8 +1301,6 @@ void netxen_post_rx_buffers(struct netxe
> 		rcv_desc->begin_alloc = index;
> 		rcv_desc->rcv_pending += count;
> 		rcv_desc->producer = producer;
>-		if (rcv_desc->rcv_free >= 32) {
>-			rcv_desc->rcv_free = 0;
> 			/* Window = 1 */
> 			writel((producer - 1) &
> 			       (rcv_desc->max_rx_desc_count - 1),
>@@ -1456,8 +1324,6 @@ void netxen_post_rx_buffers(struct netxe
> 			writel(msg,
> 			       DB_NORMALIZE(adapter,
> 					    NETXEN_RCV_PRODUCER_OFFSET));
>-			wmb();
>-		}
> 	}
> }
> 
>@@ -1521,8 +1387,6 @@ void netxen_post_rx_buffers_nodb(struct 
> 		rcv_desc->begin_alloc = index;
> 		rcv_desc->rcv_pending += count;
> 		rcv_desc->producer = producer;
>-		if (rcv_desc->rcv_free >= 32) {
>-			rcv_desc->rcv_free = 0;
> 			/* Window = 1 */
> 			writel((producer - 1) &
> 			       (rcv_desc->max_rx_desc_count - 1),
>@@ -1532,21 +1396,9 @@ void netxen_post_rx_buffers_nodb(struct 
> 						    rcv_desc_crb[ringid].
> 						    crb_rcv_producer_offset));
> 			wmb();
>-		}
> 	}
> }
> 
>-int netxen_nic_tx_has_work(struct netxen_adapter *adapter)
>-{
>-	if (find_diff_among(adapter->last_cmd_consumer,
>-			    adapter->cmd_producer,
>-			    adapter->max_tx_desc_count) > 0)
>-		return 1;
>-
>-	return 0;
>-}
>-
>-
> void netxen_nic_clear_stats(struct netxen_adapter *adapter)
> {
> 	memset(&adapter->stats, 0, sizeof(adapter->stats));
>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic_isr.c rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_isr.c
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic_isr.c	2008-07-22 18:07:57.116581000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_isr.c	2008-07-22 11:16:00.159355000 -0700
>@@ -59,7 +59,7 @@ struct net_device_stats *netxen_nic_get_
> 	/* packet transmit problems */
> 	stats->tx_errors = adapter->stats.nocmddescriptor;
> 	/* no space in linux buffers    */
>-	stats->rx_dropped = adapter->stats.updropped;
>+	stats->rx_dropped = adapter->stats.rxdropped;
> 	/* no space available in linux  */
> 	stats->tx_dropped = adapter->stats.txdropped;
> 
>@@ -190,14 +190,14 @@ int netxen_nic_link_ok(struct netxen_ada
> void netxen_nic_xgbe_handle_phy_intr(struct netxen_adapter *adapter)
> {
> 	struct net_device *netdev = adapter->netdev;
>-	u32 val, val1;
>+	u32 val;
> 
> 	/* WINDOW = 1 */
> 	val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
> 	val >>= (physical_port[adapter->portnum] * 8);
>-	val1 = val & 0xff;
>+	val &= 0xff;
> 
>-	if (adapter->ahw.xg_linkup == 1 && val1 != XG_LINK_UP) {
>+	if (adapter->ahw.xg_linkup == 1 && val != XG_LINK_UP) {
> 		printk(KERN_INFO "%s: %s NIC Link is down\n",
> 		       netxen_nic_driver_name, netdev->name);
> 		adapter->ahw.xg_linkup = 0;
>@@ -205,16 +205,7 @@ void netxen_nic_xgbe_handle_phy_intr(str
> 			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, &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, val1);
>-		}
>-	} else if (adapter->ahw.xg_linkup == 0 && val1 == XG_LINK_UP) {
>+	} else if (adapter->ahw.xg_linkup == 0 && val == XG_LINK_UP) {
> 		printk(KERN_INFO "%s: %s NIC Link is up\n",
> 		       netxen_nic_driver_name, netdev->name);
> 		adapter->ahw.xg_linkup = 1;
>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic_main.c rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_main.c
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic_main.c	2008-07-22 18:07:57.117591000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_main.c	2008-07-22 11:16:00.165358000 -0700
>@@ -45,7 +45,7 @@ MODULE_DESCRIPTION("NetXen Multi port (1
> 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;
> 
>@@ -68,12 +68,12 @@ static int netxen_nic_xmit_frame(struct 
> static void netxen_tx_timeout(struct net_device *netdev);
> static void netxen_tx_timeout_task(unsigned long adapid);
> static void netxen_watchdog(unsigned long);
>-static int netxen_handle_int(struct netxen_adapter *, struct net_device *);
> static int netxen_nic_poll(struct net_device *dev, int *budget);
> #ifdef CONFIG_NET_POLL_CONTROLLER
> static void netxen_nic_poll_controller(struct net_device *netdev);
> #endif
> static irqreturn_t netxen_intr(int irq, void *data, struct pt_regs *regs);
>+static irqreturn_t netxen_msi_intr(int irq, void *data, struct pt_regs *regs);
> 
> int physical_port[] = {0, 1, 2, 3};
> 
>@@ -153,7 +153,92 @@ static inline void netxen_nic_update_cmd
> }
> 
> #define	ADAPTER_LIST_SIZE 12
>-int netxen_cards_found;
>+
>+static uint32_t msi_tgt_status[4] = {
>+	ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
>+	ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3
>+};
>+
>+static uint32_t sw_int_mask[4] = {
>+	CRB_SW_INT_MASK_0, CRB_SW_INT_MASK_1,
>+	CRB_SW_INT_MASK_2, CRB_SW_INT_MASK_3
>+};
>+
>+static void netxen_nic_disable_int(struct netxen_adapter *adapter)
>+{
>+	u32 mask = 0x7ff;
>+	int retries = 32;
>+	int port = adapter->portnum;
>+	int pci_fn = adapter->ahw.pci_func;
>+
>+	if (adapter->msi_mode != MSI_MODE_MULTIFUNC) {
>+		writel(0x0, NETXEN_CRB_NORMALIZE(adapter, sw_int_mask[port]));
>+	}
>+
>+	if (adapter->intr_scheme != -1 &&
>+	    adapter->intr_scheme != INTR_SCHEME_PERPORT)
>+		writel(mask,PCI_OFFSET_SECOND_RANGE(adapter, ISR_INT_MASK));
>+
>+	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);
>+		}
>+	} else {
>+		if (adapter->msi_mode == MSI_MODE_MULTIFUNC) {
>+			writel(0xffffffff, PCI_OFFSET_SECOND_RANGE(adapter,
>+						msi_tgt_status[pci_fn]));
>+		}
>+	}
>+}
>+
>+static void netxen_nic_enable_int(struct netxen_adapter *adapter)
>+{
>+	u32 mask;
>+	int port = adapter->portnum;
>+
>+	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));
>+	}
>+
>+	writel(0x1, NETXEN_CRB_NORMALIZE(adapter, sw_int_mask[port]));
>+
>+	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()
>@@ -239,8 +324,6 @@ netxen_nic_probe(struct pci_dev *pdev, c
> 
> 	adapter->ahw.pdev = pdev;
> 	adapter->ahw.pci_func  = pci_func_id;
>-	spin_lock_init(&adapter->tx_lock);
>-	spin_lock_init(&adapter->lock);
> 
> 	/* remap phys address */
> 	mem_base = pci_resource_start(pdev, 0);	/* 0 is for BAR 0 */
>@@ -307,7 +390,15 @@ netxen_nic_probe(struct pci_dev *pdev, c
> 
> 	adapter->netdev  = netdev;
> 	adapter->pdev    = pdev;
>+
>+	/* this will be read from FW later */
>+	adapter->intr_scheme = -1;
>+	adapter->msi_mode = -1;
>+
>+	/* This will be reset for mezz cards  */
> 	adapter->portnum = pci_func_id;
>+	adapter->status   &= ~NETXEN_NETDEV_STATUS;
>+	adapter->rx_csum = 1;
> 
> 	netdev->open		   = netxen_nic_open;
> 	netdev->stop		   = netxen_nic_close;
>@@ -317,7 +408,7 @@ netxen_nic_probe(struct pci_dev *pdev, c
> 	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;
>+	netdev->watchdog_timeo     = 2*HZ;
> 
> 	netxen_nic_change_mtu(netdev, netdev->mtu);
> 
>@@ -336,11 +427,9 @@ netxen_nic_probe(struct pci_dev *pdev, c
> 		netdev->features |= NETIF_F_HIGHDMA;
> 
> #ifdef CONFIG_PCI_MSI
>-	if (pci_enable_msi(pdev)) {
>+ 	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
>+ 	else
> 		adapter->flags |= NETXEN_NIC_MSI_ENABLED;
> #endif
> 
>@@ -453,7 +542,6 @@ netxen_nic_probe(struct pci_dev *pdev, c
> 	INIT_WORK(&adapter->watchdog_task,
> 			(void (*)(void *))netxen_watchdog_task, adapter);
> 	adapter->ahw.pdev = pdev;
>-	adapter->proc_cmd_buf_counter = 0;
> 	adapter->ahw.revision_id = nx_p2_id;
> 
> 	/* make sure Window == 1 */
>@@ -503,8 +591,8 @@ netxen_nic_probe(struct pci_dev *pdev, c
> 					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)) {
>+			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);
>@@ -512,22 +600,21 @@ netxen_nic_probe(struct pci_dev *pdev, c
>  					printk(KERN_ERR "%s: failed to set MSI bit in PCI-e reg\n",
>  							netxen_nic_driver_name);
>  			}
>-		    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) {
>+  		    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;
>+ 				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)));
>+
>+ 		/* 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)));
> 
>@@ -648,14 +735,6 @@ static void __devexit netxen_nic_remove(
> 
>  	unregister_netdev(netdev);
> 
>-	if (adapter->stop_port)
>-		adapter->stop_port(adapter);
>-
>- 	netxen_nic_disable_int(adapter);
>-
>- 	if (adapter->irq)
>- 		free_irq(adapter->irq, adapter);
>-
>  	if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
>  		init_firmware_done++;
>  		netxen_free_hw_resources(adapter);
>@@ -679,28 +758,22 @@ static void __devexit netxen_nic_remove(
> 		}
> 	}
> 
>-	if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
>-		pci_disable_msi(pdev);
>-
> 	vfree(adapter->cmd_buf_arr);
> 
>-	pci_disable_device(pdev);
>-
> 	if (adapter->portnum == 0) {
> 		if (init_firmware_done) {
>-			dma_watchdog_shutdown_request(adapter);
>-			msleep(100);
> 			i = 100;
>-			while ((dma_watchdog_shutdown_poll_result(adapter) != 1) && i) {
>-				printk(KERN_INFO "dma_watchdog_shutdown_poll still in progress\n");
>+			do {
>+				if (dma_watchdog_shutdown_request(adapter) == 1)
>+					break;
> 				msleep(100);
>-				i--;
>-			}
>-
>-			if (i == 0) {
>-				printk(KERN_ERR "dma_watchdog_shutdown_request failed\n");
>-				return;
>-			}
>+				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)));
>@@ -709,11 +782,9 @@ static void __devexit netxen_nic_remove(
> 
> 			/* leave the hw in the same state as reboot */
> 			writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
>-			if (netxen_pinit_from_rom(adapter, 0))
>-				return;
>+			netxen_pinit_from_rom(adapter, 0);
> 			msleep(1);
>-			if (netxen_load_firmware(adapter))
>-				return;
>+			netxen_load_firmware(adapter);
> 			netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
> 		}
> 
>@@ -722,30 +793,36 @@ static void __devexit netxen_nic_remove(
> 		printk(KERN_INFO "State: 0x%0x\n",
> 			readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE)));
> 
>-		dma_watchdog_shutdown_request(adapter);
>-		mdelay(100);
> 		i = 100;
>-		while ((dma_watchdog_shutdown_poll_result(adapter) != 1) && i) {
>-			printk(KERN_INFO "dma_watchdog_shutdown_poll still in progress\n");
>-			mdelay(100);
>-			i--;
>-		}
>+ 		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 "failed to dma shutdown\n");
>-			return;
>+ 			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);
>@@ -760,6 +837,8 @@ static int netxen_nic_open(struct net_de
> 	struct netxen_adapter *adapter = (struct netxen_adapter *)netdev->priv;
> 	int err = 0;
> 	int ctx, ring;
>+	irq_handler_t handler;
>+	unsigned long flags = IRQF_SAMPLE_RANDOM;
> 
> 	if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC) {
> 		err = netxen_init_firmware(adapter);
>@@ -783,9 +862,14 @@ static int netxen_nic_open(struct net_de
> 				netxen_post_rx_buffers(adapter, ctx, ring);
> 		}
> 		adapter->irq = adapter->ahw.pdev->irq;
>-		err = request_irq(adapter->ahw.pdev->irq, netxen_intr,
>-				  SA_SHIRQ | SA_SAMPLE_RANDOM, netdev->name,
>-				  adapter);
>+		if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
>+			handler = netxen_msi_intr;
>+		else {
>+			flags |= IRQF_SHARED;
>+			handler = netxen_intr;
>+		}
>+		err = request_irq(adapter->irq, handler,
>+				  flags, netdev->name, adapter);
> 		if (err) {
> 			printk(KERN_ERR "request_irq failed with: %d\n", err);
> 			netxen_free_hw_resources(adapter);
>@@ -794,22 +878,16 @@ static int netxen_nic_open(struct net_de
> 
> 		adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
> 	}
>-	if (!adapter->driver_mismatch)
>-		mod_timer(&adapter->watchdog_timer, jiffies);
>-
>-	netxen_nic_enable_int(adapter);
>-
> 	/* Done here again so that even if phantom sw overwrote it,
> 	 * we set it */
>-	if (adapter->macaddr_set)
>-		adapter->macaddr_set(adapter, netdev->dev_addr);
> 	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(adapter, netdev->dev_addr);
> 
> 	netxen_nic_set_link_parameters(adapter);
> 
>@@ -818,6 +896,11 @@ static int netxen_nic_open(struct net_de
> 		adapter->set_mtu(adapter, netdev->mtu);
> 
> 	if (!adapter->driver_mismatch)
>+		mod_timer(&adapter->watchdog_timer, jiffies);
>+
>+	netxen_nic_enable_int(adapter);
>+
>+	if (!adapter->driver_mismatch)
> 		netif_start_queue(netdev);
> 
> 	return 0;
>@@ -836,6 +919,11 @@ static int netxen_nic_close(struct net_d
> 	netif_carrier_off(netdev);
> 	netif_stop_queue(netdev);
> 
>+	if (adapter->stop_port)
>+		adapter->stop_port(adapter);
>+
>+	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;
>@@ -876,63 +964,17 @@ static int netxen_nic_xmit_frame(struct 
> 	struct netxen_skb_frag *buffrag;
> 	unsigned int i;
> 
>-	u32 producer = 0;
>+	u32 producer, consumer;
> 	u32 saved_producer = 0;
> 	struct cmd_desc_type0 *hwdesc;
> 	int k;
> 	struct netxen_cmd_buffer *pbuf = NULL;
>-	static int dropped_packet = 0;
> 	int frag_count;
>-	u32 local_producer = 0;
>-	u32 max_tx_desc_count = 0;
>-	u32 last_cmd_consumer = 0;
> 	int no_of_desc;
>+	u32 num_txd = adapter->max_tx_desc_count;
> 
>-	adapter->stats.xmitcalled++;
> 	frag_count = skb_shinfo(skb)->nr_frags + 1;
> 
>-	if (unlikely(skb->len <= 0)) {
>-		dev_kfree_skb_any(skb);
>-		adapter->stats.badskblen++;
>-		return NETDEV_TX_OK;
>-	}
>-
>-	if (frag_count > MAX_BUFFERS_PER_CMD) {
>-		printk("%s: %s netxen_nic_xmit_frame: frag_count (%d)"
>-		       "too large, can handle only %d frags\n",
>-		       netxen_nic_driver_name, netdev->name,
>-		       frag_count, MAX_BUFFERS_PER_CMD);
>-		adapter->stats.txdropped++;
>-		if ((++dropped_packet & 0xff) == 0xff)
>-			printk("%s: %s droppped packets = %d\n",
>-			       netxen_nic_driver_name, netdev->name,
>-			       dropped_packet);
>-
>-		return NETDEV_TX_OK;
>-	}
>-
>-	/*
>-	 * Everything is set up. Now, we just need to transmit it out.
>-	 * Note that we have to copy the contents of buffer over to
>-	 * right place. Later on, this can be optimized out by de-coupling the
>-	 * producer index from the buffer index.
>-	 */
>-      retry_getting_window:
>-	spin_lock_bh(&adapter->tx_lock);
>-	if (adapter->total_threads >= MAX_XMIT_PRODUCERS) {
>-		spin_unlock_bh(&adapter->tx_lock);
>-		/*
>-		 * Yield CPU
>-		 */
>-		if (!in_atomic())
>-			schedule();
>-		else {
>-			for (i = 0; i < 20; i++)
>-				cpu_relax();	/*This a nop instr on i386 */
>-		}
>-		goto retry_getting_window;
>-	}
>-	local_producer = adapter->cmd_producer;
> 	/* There 4 fragments per descriptor */
> 	no_of_desc = (frag_count + 3) >> 2;
> 	if (netdev->features & NETIF_F_TSO) {
>@@ -946,25 +988,17 @@ static int netxen_nic_xmit_frame(struct 
> 			}
> 		}
> 	}
>-	k = adapter->cmd_producer;
>-	max_tx_desc_count = adapter->max_tx_desc_count;
>-	last_cmd_consumer = adapter->last_cmd_consumer;
>-	if ((k + no_of_desc) >=
>-	    ((last_cmd_consumer <= k) ? last_cmd_consumer + max_tx_desc_count :
>-	     last_cmd_consumer)) {
>+
>+	producer = adapter->cmd_producer;
>+	smp_mb();
>+	consumer = adapter->last_cmd_consumer;
>+	if ((no_of_desc+2) > find_diff_among(producer, consumer, num_txd)) {
> 		netif_stop_queue(netdev);
>-		adapter->flags |= NETXEN_NETDEV_STATUS;
>-		spin_unlock_bh(&adapter->tx_lock);
>+		smp_mb();
> 		return NETDEV_TX_BUSY;
> 	}
>-	k = get_index_range(k, max_tx_desc_count, no_of_desc);
>-	adapter->cmd_producer = k;
>-	adapter->total_threads++;
>-	adapter->num_threads++;
> 
>-	spin_unlock_bh(&adapter->tx_lock);
> 	/* Copy the descriptors into the hardware    */
>-	producer = local_producer;
> 	saved_producer = producer;
> 	hwdesc = &hw->cmd_desc_head[producer];
> 	memset(hwdesc, 0, sizeof(struct cmd_desc_type0));
>@@ -1004,10 +1038,11 @@ static int netxen_nic_xmit_frame(struct 
> 		/* move to next desc. if there is a need */
> 		if ((i & 0x3) == 0) {
> 			k = 0;
>-			producer = get_next_index(producer,
>-						  adapter->max_tx_desc_count);
>+			producer = get_next_index(producer, num_txd);
> 			hwdesc = &hw->cmd_desc_head[producer];
> 			memset(hwdesc, 0, sizeof(struct cmd_desc_type0));
>+			pbuf = &adapter->cmd_buf_arr[producer];
>+			pbuf->skb = NULL;
> 		}
> 		frag = &skb_shinfo(skb)->frags[i - 1];
> 		len = frag->size;
>@@ -1021,7 +1056,6 @@ static int netxen_nic_xmit_frame(struct 
> 		buffrag->dma = temp_dma;
> 		buffrag->length = temp_len;
> 
>-		DPRINTK(INFO, "for loop. i=%d k=%d\n", i, k);
> 		switch (k) {
> 		case 0:
> 			hwdesc->buffer1_length = cpu_to_le16(temp_len);
>@@ -1042,7 +1076,7 @@ static int netxen_nic_xmit_frame(struct 
> 		}
> 		frag++;
> 	}
>-	producer = get_next_index(producer, adapter->max_tx_desc_count);
>+	producer = get_next_index(producer, num_txd);
> 
> 	/* might change opcode to TX_TCP_LSO */
> 	netxen_tso_check(adapter, &hw->cmd_desc_head[saved_producer], skb);
>@@ -1063,14 +1097,18 @@ static int netxen_nic_xmit_frame(struct 
> 		}
> 		/* copy the MAC/IP/TCP headers to the cmd descriptor list */
> 		hwdesc = &hw->cmd_desc_head[producer];
>+		pbuf = &adapter->cmd_buf_arr[producer];
>+		pbuf->skb = NULL;
> 
> 		/* copy the first 64 bytes */
> 		memcpy(((void *)hwdesc) + 2,
> 		       (void *)(skb->data), first_hdr_len);
>-		producer = get_next_index(producer, max_tx_desc_count);
>+		producer = get_next_index(producer, num_txd);
> 
> 		if (more_hdr) {
> 			hwdesc = &hw->cmd_desc_head[producer];
>+			pbuf = &adapter->cmd_buf_arr[producer];
>+			pbuf->skb = NULL;
> 			/* copy the next 64 bytes - should be enough except
> 			 * for pathological case
> 			 */
>@@ -1078,39 +1116,18 @@ static int netxen_nic_xmit_frame(struct 
> 							 hwdesc,
> 							 (hdr_len -
> 							  first_hdr_len));
>-			producer = get_next_index(producer, max_tx_desc_count);
>+			producer = get_next_index(producer, num_txd);
> 		}
> 	}
> 
>-	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);
>+	adapter->cmd_producer = producer;
>+	adapter->stats.txbytes += skb->len;
> 
>-	spin_lock_bh(&adapter->tx_lock);
>-	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;
>-		netxen_nic_update_cmd_producer(adapter, crb_producer);
>-		wmb();
>-		adapter->total_threads = 0;
>-	}
>-
>-	adapter->stats.xmitfinished++;
>-	spin_unlock_bh(&adapter->tx_lock);
>+	netxen_nic_update_cmd_producer(adapter, adapter->cmd_producer);
> 
>+	adapter->stats.xmitcalled++;
> 	netdev->trans_start = jiffies;
> 
>-	DPRINTK(INFO, "wrote CMD producer %x to phantom\n", producer);
>-
>-	DPRINTK(INFO, "Done. Send\n");
> 	return NETDEV_TX_OK;
> }
> 
>@@ -1133,91 +1150,55 @@ static void netxen_tx_timeout_task(unsig
> 	struct net_device *netdev = (struct net_device *)adapid;
> 	struct netxen_adapter *adapter = (struct netxen_adapter *)
> 						netdev_priv(netdev);
>-	unsigned long flags;
> 
> 	printk(KERN_ERR "%s %s: transmit timeout, resetting.\n",
> 	       netxen_nic_driver_name, adapter->netdev->name);
> 
>-	spin_lock_irqsave(&adapter->lock, flags);
>-	netxen_nic_close(adapter->netdev);
>-	netxen_nic_open(adapter->netdev);
>-	spin_unlock_irqrestore(&adapter->lock, flags);
>+	netxen_nic_disable_int(adapter);
>+
> 	adapter->netdev->trans_start = jiffies;
>+
>+	netxen_nic_enable_int(adapter);
> 	netif_wake_queue(adapter->netdev);
> }
> 
>-static int
>-netxen_handle_int(struct netxen_adapter *adapter, struct net_device *netdev)
>+static inline void
>+netxen_handle_int(struct netxen_adapter *adapter)
> {
>-	u32 ret = 0;
>-
>-	DPRINTK(INFO, "Entered handle ISR\n");
>-	adapter->stats.ints++;
>-
>-	if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
>-		int count = 0;
>-		u32 mask;
>-		u32 our_int = 0;
>-		our_int = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
>-		/* not our interrupt */
>-		if ((our_int & (0x80 << adapter->portnum)) == 0)
>-			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");
>-
>-	}
>-
>-	if (netxen_nic_rx_has_work(adapter) || netxen_nic_tx_has_work(adapter)) {
>-		if (netif_rx_schedule_prep(netdev)) {
>-			/*
>-			 * Interrupts are already disabled.
>-			 */
>-			__netif_rx_schedule(netdev);
>-		} else {
>-			static unsigned int intcount = 0;
>-			if ((++intcount & 0xfff) == 0xfff)
>-				printk(KERN_ERR
>-				       "%s: %s interrupt %d while in poll\n",
>-				       netxen_nic_driver_name, netdev->name,
>-				       intcount);
>-		}
>-		ret = 1;
>-	}
>-
>-	if (ret == 0) {
>-		netxen_nic_enable_int(adapter);
>-	}
>-
>-	return ret;
>+	netxen_nic_disable_int(adapter);
>+	netif_rx_schedule(adapter->netdev);
> }
> 
>-/*
>- * netxen_intr - Interrupt Handler
>- * @irq: interrupt number
>- * data points to adapter stucture (which may be handling more than 1 port
>- */
> static irqreturn_t netxen_intr(int irq, void *data, struct pt_regs *regs)
> {
> 	struct netxen_adapter *adapter;
> 	struct net_device *netdev;
>-
>-	if (unlikely(!irq)) {
>-		return IRQ_NONE;	/* Not our interrupt */
>-	}
>+	u32 our_int = 0;
> 
> 	adapter = (struct netxen_adapter *)data;
> 	netdev  = adapter->netdev;
>-	/* process our status queue (for all 4 ports) */
>-	if (netif_running(netdev))
>-		netxen_handle_int(adapter, netdev);
> 
>+	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 */
>+		writel(our_int & ~((u32)(0x80 << adapter->portnum)),
>+			NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
>+	}
>+
>+	netxen_handle_int(adapter);
>+
>+	return IRQ_HANDLED;
>+}
>+
>+irqreturn_t netxen_msi_intr(int irq, void *data, struct pt_regs *regs)
>+{
>+	struct netxen_adapter *adapter = data;
>+
>+	netxen_handle_int(adapter);
> 	return IRQ_HANDLED;
> }
> 
>@@ -1225,12 +1206,13 @@ static int netxen_nic_poll(struct net_de
> {
> 	struct netxen_adapter *adapter = netdev_priv(netdev);
> 	int work_to_do = min(*budget, netdev->quota);
>-	int done = 1;
>+	int tx_complete;
> 	int ctx;
> 	int this_work_done;
> 	int work_done = 0;
> 
>-	DPRINTK(INFO, "polling for %d descriptors\n", *budget);
>+	adapter->stats.polled++;
>+	tx_complete = netxen_process_cmd_ring(adapter);
> 
> 	work_done = 0;
> 	for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
>@@ -1255,20 +1237,13 @@ static int netxen_nic_poll(struct net_de
> 	netdev->quota -= work_done;
> 	*budget -= work_done;
> 
>-	if (work_done >= work_to_do && netxen_nic_rx_has_work(adapter) != 0)
>-		done = 0;
>-
>-	if (netxen_process_cmd_ring((unsigned long)adapter) == 0)
>-		done = 0;
>-
>-	DPRINTK(INFO, "new work_done: %d work_to_do: %d\n",
>-		work_done, work_to_do);
>-	if (done) {
>-		netif_rx_complete(netdev);
>+	if ((work_done < work_to_do) && tx_complete) {
>+		netif_rx_complete(adapter->netdev);
> 		netxen_nic_enable_int(adapter);
>+		return 0;
> 	}
> 
>-	return !done;
>+	return 1;
> }
> 
> #ifdef CONFIG_NET_POLL_CONTROLLER
>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic_niu.c rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_niu.c
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic_niu.c	2008-07-22 18:07:57.119584000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_niu.c	2008-07-22 11:16:00.170355000 -0700
>@@ -740,12 +740,12 @@ int netxen_niu_disable_xg_port(struct ne
> 	__u32 mac_cfg;
> 	u32 port = physical_port[adapter->portnum];
> 
>-	if (port != 0)
>+	if (port > NETXEN_NIU_MAX_XG_PORTS)
> 		return -EINVAL;
>+
> 	mac_cfg = 0;
>-	netxen_xg_soft_reset(mac_cfg);
>-	if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_CONFIG_0,
>-				   &mac_cfg, 4))
>+	if (netxen_nic_hw_write_wx(adapter,
>+		NETXEN_NIU_XGE_CONFIG_0 + (0x10000 * port), &mac_cfg, 4))
> 		return -EIO;
> 	return 0;
> }
>diff -r --new-file -pu rhl53.p2.orig/drivers/net/netxen/netxen_nic_phan_reg.h rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_phan_reg.h
>--- rhl53.p2.orig/drivers/net/netxen/netxen_nic_phan_reg.h	2008-07-22 18:07:57.120584000 -0700
>+++ rhl53.p2.p01-p18/drivers/net/netxen/netxen_nic_phan_reg.h	2008-07-22 11:16:00.174353000 -0700
>@@ -114,6 +114,23 @@
> #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 CRB_NIC_MSI_MODE_HOST		NETXEN_NIC_REG(0x270)
>+#define CRB_NIC_MSI_MODE_FW	  		NETXEN_NIC_REG(0x274)
>+
>+#define INTR_SCHEME_PERPORT	      	0x1
>+#define MSI_MODE_MULTIFUNC	      	0x1
> 
> /* used for ethtool tests */
> #define CRB_SCRATCHPAD_TEST	    NETXEN_NIC_REG(0x280)

Actions: View | Diff

Attachments on bug 457958: 313475 | 313476 | 313477 | 313478 | 313849 | 313850 | 313851 | 314419 | 314420 | 314421 | 315321