Attachment 314444 Details for Bug 458863 – Patch 1

[patch] Patch 1

netxen-rhel4-patch1.diff (text/plain), 43.31 KB, created by Dhananjay Phadke on 2008-08-17 18:09:38 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Dhananjay Phadke

Created: 2008-08-17 18:09:38 UTC

Size: 43.31 KB

patch

obsolete

>Following commits backported from netdev-2.6 # upstream-fixes
>
>d230ce30f4eb2cec42cb501db586ce45815a8167
>200eef20db6de7535438c9af9becc8169c6cb6c0
>001a731ecfc2e5fdbb5022ad3708705d9edf801c
>72b0a7a8a40a50cf2eab42fd6a56e04b05090434
>53a01e00f8c78bc5875e09aca7749ea54bb09798
>5dc162682d4901025a02b7045f3112d569b4bab9
>443be7960be77f3345b44491c700ae4471b0fe57
>05aaa02d799e8e9548d57ac92fcb05e783027341
>ba53e6b4878e07411826312c59bfe49561594b6e
>d1847a722e79bbfc557755d78f44d3e2c8ae5ea9
>
>Signed-off-by: Dhananjay Phadke <dhananjay@netxen.com>
>
>Index: rhel4/drivers/net/netxen/netxen_nic_ethtool.c
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic_ethtool.c	2008-08-17 09:36:57.945129000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic_ethtool.c	2008-08-17 09:40:15.374313000 -0700
>@@ -64,15 +64,7 @@
> 	{"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 @@
> 	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 @@
> 	}
> }
> 
>+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 @@
> 	.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,
> };
>Index: rhel4/drivers/net/netxen/netxen_nic.h
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic.h	2008-08-17 09:36:57.962136000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic.h	2008-08-17 09:40:15.389320000 -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 @@
> 			? 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)
>@@ -309,23 +309,26 @@
> 	((cmd_desc)->port_ctxid |= ((var) & 0xF0))
> 
> #define netxen_set_cmd_desc_flags(cmd_desc, val)	\
>-	((cmd_desc)->flags_opcode &= ~cpu_to_le16(0x7f), \
>-	(cmd_desc)->flags_opcode |= cpu_to_le16((val) & 0x7f))
>+	(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 &= ~cpu_to_le16(0x3f<<7), \
>-	(cmd_desc)->flags_opcode |= cpu_to_le16(((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 &= ~cpu_to_le32(0xff), \
>-	(cmd_desc)->num_of_buffers_total_length |= cpu_to_le32((val) & 0xff))
>+	(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 &= ~cpu_to_le32(0xffffff00), \
>-	(cmd_desc)->num_of_buffers_total_length |= cpu_to_le32(val << 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)	\
>-	((le16_to_cpu((cmd_desc)->flags_opcode) >> 7) & 0x003F)
>+	((le16_to_cpu((cmd_desc)->flags_opcode) >> 7) & 0x003f)
> #define netxen_get_cmd_desc_totallength(cmd_desc)	\
>-	(le32_to_cpu((cmd_desc)->num_of_buffers_total_length) >> 8)
>+	((le32_to_cpu((cmd_desc)->num_of_buffers_total_length) >> 8) & 0xffffff)
> 
> struct cmd_desc_type0 {
> 	u8 tcp_hdr_offset;	/* For LSO only */
>@@ -412,29 +415,29 @@
> #define netxen_get_sts_desc_lro_last_frag(status_desc)  \
> 	(((status_desc)->lro & 0x80) >> 7)
> 
>-#define netxen_get_sts_port(status_desc)	\
>-	(le64_to_cpu((status_desc)->status_desc_data) & 0x0F)
>-#define netxen_get_sts_status(status_desc)      \
>-	((le64_to_cpu((status_desc)->status_desc_data) >> 4) & 0x0F)
>-#define netxen_get_sts_type(status_desc)        \
>-	((le64_to_cpu((status_desc)->status_desc_data) >> 8) & 0x0F)
>-#define netxen_get_sts_totallength(status_desc) \
>-	((le64_to_cpu((status_desc)->status_desc_data) >> 12) & 0xFFFF)
>-#define netxen_get_sts_refhandle(status_desc)   \
>-	((le64_to_cpu((status_desc)->status_desc_data) >> 28) & 0xFFFF)
>-#define netxen_get_sts_prot(status_desc)	\
>-	((le64_to_cpu((status_desc)->status_desc_data) >> 44) & 0x0F)
>+#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_owner(status_desc)       \
> 	((le64_to_cpu((status_desc)->status_desc_data) >> 56) & 0x03)
>-#define netxen_get_sts_opcode(status_desc)	\
>-	((le64_to_cpu((status_desc)->status_desc_data) >> 58) & 0x03F)
>-
>-#define netxen_clear_sts_owner(status_desc)	\
>-	((status_desc)->status_desc_data &=	\
>-	~cpu_to_le64(((unsigned long long)3) << 56 ))
>-#define netxen_set_sts_owner(status_desc, val)	\
>-	((status_desc)->status_desc_data |=	\
>-	cpu_to_le64(((unsigned long long)((val) & 0x3)) << 56 ))
>+#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 {
> 	/* Bit pattern: 0-3 port, 4-7 status, 8-11 type, 12-27 total_length
>@@ -815,15 +818,8 @@
> 	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;
>@@ -839,7 +835,6 @@
> 	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 */
>@@ -885,8 +880,6 @@
> 	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;
>@@ -901,10 +894,6 @@
> 	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;
>@@ -918,7 +907,7 @@
> 	u16 link_duplex;
> 	u16 state;
> 	u16 link_autoneg;
>-	int rcsum;
>+	int rx_csum;
> 	int status;
> 	spinlock_t stats_lock;
> 
>@@ -938,6 +927,7 @@
> 	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 *);
>@@ -1083,14 +1073,12 @@
> 		      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);
>Index: rhel4/drivers/net/netxen/netxen_nic_hdr.h
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic_hdr.h	2008-08-17 09:36:57.921126000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic_hdr.h	2008-08-17 09:40:15.413311000 -0700
>@@ -456,6 +456,12 @@
> #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)
>@@ -662,6 +668,12 @@
> 
> #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)
>Index: rhel4/drivers/net/netxen/netxen_nic_hw.c
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic_hw.c	2008-08-17 09:36:57.909140000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic_hw.c	2008-08-17 09:40:15.477316000 -0700
>@@ -394,6 +394,8 @@
> 		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,
>Index: rhel4/drivers/net/netxen/netxen_nic_init.c
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic_init.c	2008-08-17 09:36:57.924126000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic_init.c	2008-08-17 09:40:15.614310000 -0700
>@@ -141,6 +141,8 @@
> 	/* 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,
>@@ -179,7 +181,6 @@
> 		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;
>@@ -968,28 +969,6 @@
> 	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(desc) & STATUS_OWNER_HOST)
>-			return 1;
>-	}
>-
>-	return 0;
>-}
>-
> static inline int netxen_nic_check_temp(struct netxen_adapter *adapter)
> {
> 	struct net_device *netdev = adapter->netdev;
>@@ -1032,7 +1011,6 @@
> 
> 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))
>@@ -1041,20 +1019,6 @@
> 	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);
> }
> 
>@@ -1069,16 +1033,17 @@
> {
> 	struct pci_dev *pdev = adapter->pdev;
> 	struct net_device *netdev = adapter->netdev;
>-	int index = netxen_get_sts_refhandle(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(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(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);
>@@ -1117,10 +1082,13 @@
> 
> 	skb = (struct sk_buff *)buffer->skb;
> 
>-	if (likely(netxen_get_sts_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 */
>@@ -1132,40 +1100,8 @@
> 	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--;
> 
> 	/*
>@@ -1190,13 +1126,6 @@
> 	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 (!(netxen_get_sts_owner(desc) & STATUS_OWNER_HOST)) {
>@@ -1205,15 +1134,12 @@
> 			break;
> 		}
> 		netxen_process_rcv(adapter, ctxid, desc);
>-		netxen_clear_sts_owner(desc);
> 		netxen_set_sts_owner(desc, STATUS_OWNER_PHANTOM);
> 		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 */
>@@ -1224,110 +1150,58 @@
> 		/* 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_wake_queue(netdev);
>+			smp_mb();
> 		}
> 	}
> 	/*
>@@ -1343,16 +1217,9 @@
> 	 * 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);
> }
> 
>@@ -1426,8 +1293,6 @@
> 		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),
>@@ -1451,8 +1316,6 @@
> 			writel(msg,
> 			       DB_NORMALIZE(adapter,
> 					    NETXEN_RCV_PRODUCER_OFFSET));
>-			wmb();
>-		}
> 	}
> }
> 
>@@ -1516,8 +1379,6 @@
> 		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),
>@@ -1527,21 +1388,9 @@
> 						    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));
>Index: rhel4/drivers/net/netxen/netxen_nic_isr.c
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic_isr.c	2008-08-17 09:36:57.933133000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic_isr.c	2008-08-17 09:40:15.669311000 -0700
>@@ -59,7 +59,7 @@
> 	/* 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 @@
> 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 @@
> 			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;
>Index: rhel4/drivers/net/netxen/netxen_nic_main.c
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic_main.c	2008-08-17 09:36:57.936136000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic_main.c	2008-08-17 09:40:15.762310000 -0700
>@@ -68,12 +68,12 @@
> 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};
> 
>@@ -155,33 +155,31 @@
> #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)
> {
>-	uint32_t	mask = 0x7ff;
>+	u32 mask = 0x7ff;
> 	int retries = 32;
>+	int port = adapter->portnum;
>+	int pci_fn = adapter->ahw.pci_func;
> 
>-	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->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));
> 
>-	/* Window = 0 or 1 */
> 	if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
> 		do {
> 			writel(0xffffffff,
>@@ -196,14 +194,18 @@
> 			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]));
>+		}
> 	}
>-
>-	DPRINTK(1, INFO, "Done with Disable Int\n");
> }
> 
> static void netxen_nic_enable_int(struct netxen_adapter *adapter)
> {
> 	u32 mask;
>+	int port = adapter->portnum;
> 
> 	DPRINTK(1, INFO, "Entered ISR Enable \n");
> 
>@@ -224,20 +226,7 @@
> 		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;
>-	}
>+	writel(0x1, NETXEN_CRB_NORMALIZE(adapter, sw_int_mask[port]));
> 
> 	if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
> 		mask = 0xbff;
>@@ -336,7 +325,6 @@
> 
> 	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 */
>@@ -406,10 +394,12 @@
> 
> 	/* 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;
>@@ -419,7 +409,7 @@
> 	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);
> 
>@@ -551,7 +541,6 @@
> 	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 */
>@@ -743,11 +732,6 @@
> 
> 	unregister_netdev(netdev);
> 
>-	if (adapter->stop_port)
>-		adapter->stop_port(adapter);
>-
>-	netxen_nic_disable_int(adapter);
>-
> 	if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
> 		init_firmware_done++;
> 		netxen_free_hw_resources(adapter);
>@@ -850,6 +834,8 @@
> 	struct netxen_adapter *adapter = (struct netxen_adapter *)netdev->priv;
> 	int err = 0;
> 	int ctx, ring;
>+	irq_handler_t handler;
>+	unsigned long flags = SA_SAMPLE_RANDOM;
> 
> 	if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC) {
> 		err = netxen_init_firmware(adapter);
>@@ -873,9 +859,14 @@
> 				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 |= SA_SHIRQ;
>+			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);
>@@ -884,16 +875,10 @@
> 
> 		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->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;
>@@ -908,6 +893,11 @@
> 		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;
>@@ -926,6 +916,9 @@
> 	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;
>@@ -968,63 +961,17 @@
> 	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) {
>@@ -1038,25 +985,17 @@
> 			}
> 		}
> 	}
>-	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));
>@@ -1096,10 +1035,11 @@
> 		/* 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;
>@@ -1113,7 +1053,6 @@
> 		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);
>@@ -1134,7 +1073,7 @@
> 		}
> 		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);
>@@ -1155,52 +1094,35 @@
> 		}
> 		/* 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
> 			 */
> 			memcpy((void *)hwdesc, (void *)(skb->data) +
> 			       first_hdr_len, 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]);
>+	adapter->cmd_producer = producer;
>+	adapter->stats.txbytes += skb->len;
> 
>-	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);
>-	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;
> }
> 
>@@ -1233,38 +1155,31 @@
> 	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++;
> 
> 	netxen_nic_disable_int(adapter);
> 
>-	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)
>-				DPRINTK(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);
>+	// BUGLY - orig driver - if (netxen_nic_rx_has_work(adapter) || netxen_nic_tx_has_work(adapter))
>+	if (netif_rx_schedule_prep(adapter->netdev)) {
>+		/*
>+		 * Interrupts are already disabled.
>+		 */
>+		__netif_rx_schedule(adapter->netdev);
>+	} else {
>+		static unsigned int intcount = 0;
>+		if ((++intcount & 0xfff) == 0xfff)
>+			DPRINTK(KERN_ERR
>+			       "%s: %s interrupt %d while in poll\n",
>+			       netxen_nic_driver_name, adapter->netdev->name,
>+			       intcount);
> 	}
>+	// BUGLY - orig driver - if no work then enable ints and return 0
>+	// BUGLY - orig driver - if was work then return 1
> 
>-	return ret;
>+	return;
> }
> 
> /*
>@@ -1274,34 +1189,32 @@
>  */
> static irqreturn_t netxen_intr(int irq, void *data, struct pt_regs *regs)
> {
>-	struct netxen_adapter *adapter;
>-	struct net_device *netdev;
>-	u32 our_int = 0;
>-
>-	if (unlikely(!irq)) {
>-		return IRQ_NONE;	/* Not our interrupt */
>-	}
>+	struct netxen_adapter *adapter = data;
>+	u32 our_int;
> 
>-	adapter = (struct netxen_adapter *)data;
>-	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;
>-	}
>+	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)),
>+		writel(our_int & ~((u32)(0x80 << adapter->portnum)),
> 			NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
>-		}
> 	}
> 
>-	if (netif_running(netdev))
>-		netxen_handle_int(adapter, netdev);
>+	if (netif_running(adapter->netdev))
>+		netxen_handle_int(adapter);
>+
>+	return IRQ_HANDLED;
>+}
>+
>+static irqreturn_t netxen_msi_intr(int irq, void *data, struct pt_regs *regs)
>+{
>+	struct netxen_adapter *adapter = data;
>+
>+	if (netif_running(adapter->netdev))
>+		netxen_handle_int(adapter);
> 
> 	return IRQ_HANDLED;
> }
>@@ -1310,12 +1223,12 @@
> {
> 	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;
>+	int work_done;
> 
>-	DPRINTK(INFO, "polling for %d descriptors\n", *budget);
>+	tx_complete = netxen_process_cmd_ring(adapter);
> 
> 	work_done = 0;
> 	for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
>@@ -1340,20 +1253,13 @@
> 	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);
>+	// BUGLY - orig driver - no complete if netxen_nic_rx_has_work(adapter)
>+	if ((work_done < *budget) && tx_complete) {
>+		netif_rx_complete(adapter->netdev);
> 		netxen_nic_enable_int(adapter);
> 	}
> 
>-	return !done;
>+	return 0;
> }
> 
> #ifdef CONFIG_NET_POLL_CONTROLLER
>Index: rhel4/drivers/net/netxen/netxen_nic_niu.c
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic_niu.c	2008-08-17 09:36:57.932128000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic_niu.c	2008-08-17 09:40:15.827315000 -0700
>@@ -740,12 +740,12 @@
> 	__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;
> }
>Index: rhel4/drivers/net/netxen/netxen_nic_phan_reg.h
>===================================================================
>--- rhel4.orig/drivers/net/netxen/netxen_nic_phan_reg.h	2008-08-17 09:36:57.929130000 -0700
>+++ rhel4/drivers/net/netxen/netxen_nic_phan_reg.h	2008-08-17 09:40:16.057315000 -0700
>@@ -126,8 +126,11 @@
>  */
> #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)
>Index: rhel4/MAINTAINERS
>===================================================================
>--- rhel4.orig/MAINTAINERS	2008-08-17 09:40:38.447449000 -0700
>+++ rhel4/MAINTAINERS	2008-08-17 09:42:52.956256000 -0700
>@@ -1563,8 +1563,8 @@
> S:	Maintained
> 
> NETXEN (1/10) GbE SUPPORT
>-P:	Amit S. Kale
>-M:	amitkale@netxen.com
>+P:	Dhananjay Phadke
>+M:	dhananjay@netxen.com
> L:	netdev@vger.kernel.org
> W:	http://www.netxen.com
> S:	Supported

Actions: View | Diff

Attachments on bug 458863: 314126 | 314127 | 314128 | 314129 | 314444 | 314445 | 314446 | 314447 | 330585 | 330639