Attachment 299773 Details for Bug 438987 – backport of latest netxen driver from

backport of latest netxen driver from

netxen_irq_and_napi.patch (text/plain), 83.16 KB, created by IBM Bug Proxy on 2008-03-31 21:56:41 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: IBM Bug Proxy

Created: 2008-03-31 21:56:41 UTC

Size: 83.16 KB

patch

obsolete

>This patch was created using:
>
>git diff --patch-with-stat v2.6.24 HEAD -- drivers/net/netxen
>
>I have run quite a bit of stress testing on various versions of this patch (pre-git-commit versions) and have run some sanity testing on this exact patch and believe that it is good and ready for addition to the MRG kernel.
>
>Signed-off-by: Vernon Mauery <vernux@us.ibm.com>
>
>--
>
> drivers/net/netxen/netxen_nic.h          |   61 ++-----
> drivers/net/netxen/netxen_nic_ethtool.c  |   36 ++--
> drivers/net/netxen/netxen_nic_hdr.h      |   12 ++
> drivers/net/netxen/netxen_nic_hw.c       |   59 +++---
> drivers/net/netxen/netxen_nic_hw.h       |   18 +-
> drivers/net/netxen/netxen_nic_init.c     |  304 ++++++++----------------------
> drivers/net/netxen/netxen_nic_isr.c      |   34 ++--
> drivers/net/netxen/netxen_nic_main.c     |  306 ++++++++++--------------------
> drivers/net/netxen/netxen_nic_niu.c      |   64 ++++---
> drivers/net/netxen/netxen_nic_phan_reg.h |   18 +-
> 10 files changed, 321 insertions(+), 591 deletions(-)
>
>
>Commit log as follows:
>
>commit f0c88f9c45f39acd017328515890481adcb32607
>Author: Jeff Garzik <jeff@garzik.org>
>Date:   Tue Mar 25 23:53:24 2008 -0400
>
>    netxen, phy/marvell, skge: minor checkpatch fixes
>    
>    Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
>
>commit d1847a722e79bbfc557755d78f44d3e2c8ae5ea9
>Author: Dhananjay Phadke <dhananjay@netxen.com>
>Date:   Mon Mar 17 19:59:51 2008 -0700
>
>    netxen: fix rx dropped stats
>    
>    Don't count rx dropped packets based on return value of netif_receive_skb(),
>    which is misleading.
>    
>    Signed-off-by: Dhananjay Phadke <dhananjay@netxen.com>
>    Tested-by: Vernon Mauery <mauery@us.ibm.com>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>
>commit ba53e6b4878e07411826312c59bfe49561594b6e
>Author: Dhananjay Phadke <dhananjay@netxen.com>
>Date:   Mon Mar 17 19:59:50 2008 -0700
>
>    netxen: remove low level tx lock
>    
>    o eliminate tx lock in netxen adapter struct, instead pound on netdev
>      tx lock appropriately.
>    o remove old "concurrent transmit" code that unnecessarily drops and
>      reacquires tx lock in hard_xmit_frame(), this is already serialized
>      the netdev xmit lock.
>    o reduce scope of tx lock in tx cleanup. tx cleanup operates on
>      different section of the ring than transmitting cpus and is
>      guarded by producer and consumer indices. This fixes a race
>      caused by rx softirq preemption on realtime kernels.
>    
>    Signed-off-by: Dhananjay Phadke <dhananjay@netxen.com>
>    Tested-by: Vernon Mauery <mauery@us.ibm.com>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>
>commit 05aaa02d799e8e9548d57ac92fcb05e783027341
>Author: Dhananjay Phadke <dhananjay@netxen.com>
>Date:   Mon Mar 17 19:59:49 2008 -0700
>
>    netxen: napi and irq cleanup
>    
>    o separate and simpler irq handler for msi interrupts, avoids few checks
>      than legacy mode.
>    o avoid redudant tx_has_work() and rx_has_work() checks in interrupt
>      and napi, which can uncork irq based on racy (lockless) access to tx
>      and rx ring indices. If we get interrupt, there's sufficient reason to
>      schedule napi.
>    o replenish rx ring more often, remove self-imposed threshold rcv_free
>      that prevents posting rx desc to card. This improves performance in
>      low memory.
>    
>    Signed-off-by: Dhananjay Phadke <dhananjay@netxen.com>
>    Tested-by: Vernon Mauery <mauery@us.ibm.com>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>
>commit 443be7960be77f3345b44491c700ae4471b0fe57
>Author: Dhananjay Phadke <dhananjay@netxen.com>
>Date:   Mon Mar 17 19:59:48 2008 -0700
>
>    netxen: improve msi support
>    
>    Recent netxen firmware has new scheme of generating MSI interrupts, it
>    raises interrupt and blocks itself, waiting for driver to unmask. This
>    reduces chance of spurious interrupts.
>    
>    The driver will be able to deal with older firmware as well.
>    
>    Signed-off-by: Dhananjay Phadke <dhananjay@netxen.com>
>    Tested-by: Vernon Mauery <mauery@us.ibm.com>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>
>commit f305f789bb96ee6e35e71f58324b72abb7bd0b13
>Author: Al Viro <viro@ftp.linux.org.uk>
>Date:   Sat Dec 22 19:44:00 2007 +0000
>
>    annotate netxen
>    
>    Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>
>commit 79ea13ce07c951bb4d95471e7300baa0f1be9e78
>Author: Al Viro <viro@zeniv.linux.org.uk>
>Date:   Thu Jan 24 02:06:46 2008 -0800
>
>    NULL noise in drivers/net
>    
>    Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>    Signed-off-by: David S. Miller <davem@davemloft.net>
>
>commit 4790654c71b250018ecc234f6b9f1ed96a55572d
>Author: Jeff Garzik <jeff@garzik.org>
>Date:   Fri Nov 23 21:23:36 2007 -0500
>
>    [netdrvr] netxen: checkpatch fixes (98% trim trailing whitespace)
>    
>    Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
>
>commit 5bc51424b4d1c1121fb8861620f14262d828d1d9
>Author: Joe Perches <joe@perches.com>
>Date:   Mon Nov 19 17:48:24 2007 -0800
>
>    drivers/net/netxen: Add missing "space"
>    
>    Signed-off-by: Joe Perches <joe@perches.com>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>
>commit 993fb90c5b1727342362c43ed4e29c26682f54f7
>Author: Adrian Bunk <bunk@kernel.org>
>Date:   Mon Nov 5 18:07:31 2007 +0100
>
>    drivers/net/netxen/: cleanups
>    
>    This patch contains the following cleanups:
>    - static functions in .c files shouldn't be marked inline
>    - make needlessly global code static
>    - #if 0 unused code
>    
>    Signed-off-by: Adrian Bunk <bunk@kernel.org>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>
>commit 4c3616cdda0632a3d0e39069765f9ea0e6bd093e
>Author: Alejandro Martinez Ruiz <alex@flawedcode.org>
>Date:   Thu Oct 18 10:00:15 2007 +0200
>
>    netdev: use ARRAY_SIZE() instead of sizeof(array) / ETH_GSTRING_LEN
>    
>    Using ARRAY_SIZE() on arrays of the form array[][K] makes it unnecessary
>    to know the value of K when checking its size.
>    
>    Signed-off-by: Alejandro Martinez Ruiz <alex@flawedcode.org>
>    Signed-off-by: Jeff Garzik <jeff@garzik.org>
>
>diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
>index a8f63c4..7f20a03 100644
>--- a/drivers/net/netxen/netxen_nic.h
>+++ b/drivers/net/netxen/netxen_nic.h
>@@ -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
>@@ -113,8 +113,8 @@
> #define FLUSH_SCHEDULED_WORK()	flush_workqueue(netxen_workq)
> extern struct workqueue_struct *netxen_workq;
> 
>-/* 
>- * normalize a 64MB crb address to 32MB PCI window 
>+/*
>+ * normalize a 64MB crb address to 32MB PCI window
>  * To use NETXEN_CRB_NORMALIZE, window _must_ be set to 1
>  */
> #define NETXEN_CRB_NORMAL(reg)	\
>@@ -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)
>@@ -736,11 +736,11 @@ struct netxen_skb_frag {
> 	(config_word) &= ~__tmask;      \
> 	(config_word) |= (((__tvalue) << (start)) & __tmask); \
> }
>-	
>+
> #define _netxen_clear_bits(config_word, start, bits) {\
> 	unsigned long long __tmask = (((1ULL << (bits)) - 1) << (start));  \
> 	(config_word) &= ~__tmask; \
>-}		
>+}
> 
> /*    Following defines are for the state of the buffers    */
> #define	NETXEN_BUFFER_FREE	0
>@@ -818,15 +818,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;
>@@ -842,7 +835,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 */
>@@ -879,7 +871,7 @@ struct netxen_dummy_dma {
> 
> struct netxen_adapter {
> 	struct netxen_hardware_context ahw;
>-	
>+
> 	struct netxen_adapter *master;
> 	struct net_device *netdev;
> 	struct pci_dev *pdev;
>@@ -889,8 +881,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;
>@@ -898,17 +888,13 @@ struct netxen_adapter {
> 	u32 curr_window;
> 
> 	u32 cmd_producer;
>-	u32 *cmd_consumer;
>-
>+	__le32 *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;
>@@ -916,7 +902,7 @@ struct netxen_adapter {
> 	u32 temp;
> 
> 	struct netxen_adapter_stats stats;
>-	
>+
> 	u16 portno;
> 	u16 link_speed;
> 	u16 link_duplex;
>@@ -942,6 +928,7 @@ struct netxen_adapter {
> 	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 *);
>@@ -1018,14 +1005,8 @@ int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter);
> int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter);
> int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter);
> int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter);
>-int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter);
>-int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter);
> void netxen_nic_xgbe_handle_phy_intr(struct netxen_adapter *adapter);
> void netxen_nic_gbe_handle_phy_intr(struct netxen_adapter *adapter);
>-void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter, int port,
>-				 long enable);
>-void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter, int port,
>-				  long enable);
> int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
> 			    __u32 * readval);
> int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter,
>@@ -1048,7 +1029,6 @@ int netxen_nic_hw_write_wx(struct netxen_adapter *adapter, u64 off, void *data,
> 			   int len);
> void netxen_crb_writelit_adapter(struct netxen_adapter *adapter,
> 				 unsigned long off, int data);
>-int netxen_nic_erase_pxe(struct netxen_adapter *adapter);
> 
> /* Functions from netxen_nic_init.c */
> void netxen_free_adapter_offload(struct netxen_adapter *adapter);
>@@ -1057,9 +1037,9 @@ int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val);
> int netxen_load_firmware(struct netxen_adapter *adapter);
> int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose);
> int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp);
>-int netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr, 
>+int netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
> 				u8 *bytes, size_t size);
>-int netxen_rom_fast_write_words(struct netxen_adapter *adapter, int addr, 
>+int netxen_rom_fast_write_words(struct netxen_adapter *adapter, int addr,
> 				u8 *bytes, size_t size);
> int netxen_flash_unlock(struct netxen_adapter *adapter);
> int netxen_backup_crbinit(struct netxen_adapter *adapter);
>@@ -1067,15 +1047,10 @@ int netxen_flash_erase_secondary(struct netxen_adapter *adapter);
> int netxen_flash_erase_primary(struct netxen_adapter *adapter);
> void netxen_halt_pegs(struct netxen_adapter *adapter);
> 
>-int netxen_rom_fast_write(struct netxen_adapter *adapter, int addr, int data);
> int netxen_rom_se(struct netxen_adapter *adapter, int addr);
>-int netxen_do_rom_se(struct netxen_adapter *adapter, int addr);
> 
> /* Functions from netxen_nic_isr.c */
> int netxen_nic_link_ok(struct netxen_adapter *adapter);
>-void netxen_nic_isr_other(struct netxen_adapter *adapter);
>-void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 link);
>-void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable);
> void netxen_initialize_adapter_sw(struct netxen_adapter *adapter);
> void netxen_initialize_adapter_hw(struct netxen_adapter *adapter);
> void *netxen_alloc(struct pci_dev *pdev, size_t sz, dma_addr_t * ptr,
>@@ -1087,14 +1062,10 @@ void netxen_tso_check(struct netxen_adapter *adapter,
> 		      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(struct work_struct *work);
> 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);
>@@ -1209,7 +1180,7 @@ dma_watchdog_wakeup(struct netxen_adapter *adapter)
> 
> 
> int netxen_is_flash_supported(struct netxen_adapter *adapter);
>-int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, u64 mac[]);
>+int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, __le64 mac[]);
> extern void netxen_change_ringparam(struct netxen_adapter *adapter);
> extern int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr,
> 				int *valp);
>diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
>index cfb847b..6e98d83 100644
>--- a/drivers/net/netxen/netxen_nic_ethtool.c
>+++ b/drivers/net/netxen/netxen_nic_ethtool.c
>@@ -64,15 +64,7 @@ static const struct netxen_nic_stats netxen_nic_gstrings_stats[] = {
> 	{"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)},
>@@ -86,7 +78,7 @@ static const char netxen_nic_gstrings_test[][ETH_GSTRING_LEN] = {
> 	"Link_Test_on_offline"
> };
> 
>-#define NETXEN_NIC_TEST_LEN sizeof(netxen_nic_gstrings_test) / ETH_GSTRING_LEN
>+#define NETXEN_NIC_TEST_LEN	ARRAY_SIZE(netxen_nic_gstrings_test)
> 
> #define NETXEN_NIC_REGS_COUNT 42
> #define NETXEN_NIC_REGS_LEN (NETXEN_NIC_REGS_COUNT * sizeof(__le32))
>@@ -423,11 +415,11 @@ netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
> 	if (eeprom->len == 0)
> 		return -EINVAL;
> 
>-	eeprom->magic = (adapter->pdev)->vendor | 
>+	eeprom->magic = (adapter->pdev)->vendor |
> 			((adapter->pdev)->device << 16);
> 	offset = eeprom->offset;
> 
>-	ret = netxen_rom_fast_read_words(adapter, offset, bytes, 
>+	ret = netxen_rom_fast_read_words(adapter, offset, bytes,
> 						eeprom->len);
> 	if (ret < 0)
> 		return ret;
>@@ -453,16 +445,16 @@ netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
> 				netxen_nic_driver_name);
> 			return ret;
> 		}
>-		printk(KERN_INFO "%s: flash unlocked. \n", 
>+		printk(KERN_INFO "%s: flash unlocked. \n",
> 			netxen_nic_driver_name);
> 		last_schedule_time = jiffies;
> 		ret = netxen_flash_erase_secondary(adapter);
> 		if (ret != FLASH_SUCCESS) {
>-			printk(KERN_ERR "%s: Flash erase failed.\n", 
>+			printk(KERN_ERR "%s: Flash erase failed.\n",
> 				netxen_nic_driver_name);
> 			return ret;
> 		}
>-		printk(KERN_INFO "%s: secondary flash erased successfully.\n", 
>+		printk(KERN_INFO "%s: secondary flash erased successfully.\n",
> 			netxen_nic_driver_name);
> 		flash_start = 1;
> 		return 0;
>@@ -471,7 +463,7 @@ netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
> 	if (offset == NETXEN_BOOTLD_START) {
> 		ret = netxen_flash_erase_primary(adapter);
> 		if (ret != FLASH_SUCCESS) {
>-			printk(KERN_ERR "%s: Flash erase failed.\n", 
>+			printk(KERN_ERR "%s: Flash erase failed.\n",
> 				netxen_nic_driver_name);
> 			return ret;
> 		}
>@@ -483,16 +475,16 @@ netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
> 		if (ret != FLASH_SUCCESS)
> 			return ret;
> 
>-		printk(KERN_INFO "%s: primary flash erased successfully\n", 
>+		printk(KERN_INFO "%s: primary flash erased successfully\n",
> 			netxen_nic_driver_name);
> 
> 		ret = netxen_backup_crbinit(adapter);
> 		if (ret != FLASH_SUCCESS) {
>-			printk(KERN_ERR "%s: CRBinit backup failed.\n", 
>+			printk(KERN_ERR "%s: CRBinit backup failed.\n",
> 				netxen_nic_driver_name);
> 			return ret;
> 		}
>-		printk(KERN_INFO "%s: CRBinit backup done.\n", 
>+		printk(KERN_INFO "%s: CRBinit backup done.\n",
> 			netxen_nic_driver_name);
> 		ready_to_flash = 1;
> 	}
>@@ -570,7 +562,7 @@ netxen_nic_get_pauseparam(struct net_device *dev,
> 		else
> 			pause->tx_pause = !(netxen_xg_get_xg1_mask(val));
> 	} else {
>-		printk(KERN_ERR"%s: Unknown board type: %x\n", 
>+		printk(KERN_ERR"%s: Unknown board type: %x\n",
> 				netxen_nic_driver_name, adapter->ahw.board_type);
> 	}
> }
>@@ -589,7 +581,7 @@ netxen_nic_set_pauseparam(struct net_device *dev,
> 		/* set flow control */
> 		netxen_nic_read_w0(adapter,
> 					NETXEN_NIU_GB_MAC_CONFIG_0(port), &val);
>-		
>+
> 		if (pause->rx_pause)
> 			netxen_gb_rx_flowctl(val);
> 		else
>@@ -642,10 +634,10 @@ netxen_nic_set_pauseparam(struct net_device *dev,
> 			else
> 				netxen_xg_set_xg1_mask(val);
> 		}
>-		netxen_nic_write_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);			
>+		netxen_nic_write_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);
> 	} else {
> 		printk(KERN_ERR "%s: Unknown board type: %x\n",
>-				netxen_nic_driver_name, 
>+				netxen_nic_driver_name,
> 				adapter->ahw.board_type);
> 	}
> 	return 0;
>diff --git a/drivers/net/netxen/netxen_nic_hdr.h b/drivers/net/netxen/netxen_nic_hdr.h
>index d72f8f8..160f605 100644
>--- a/drivers/net/netxen/netxen_nic_hdr.h
>+++ b/drivers/net/netxen/netxen_nic_hdr.h
>@@ -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)
>@@ -662,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)
>diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
>index 2c19b8d..05748ca 100644
>--- a/drivers/net/netxen/netxen_nic_hw.c
>+++ b/drivers/net/netxen/netxen_nic_hw.c
>@@ -33,7 +33,6 @@
> 
> #include "netxen_nic.h"
> #include "netxen_nic_hw.h"
>-#define DEFINE_GLOBAL_RECV_CRB
> #include "netxen_nic_phan_reg.h"
> 
> 
>@@ -161,7 +160,7 @@ struct netxen_recv_crb recv_crb_registers[] = {
> 	    },
> 	    /* Jumbo frames */
> 	    {
>-	    /* crb_rcv_producer_offset: */		    
>+	    /* crb_rcv_producer_offset: */
> 	    NETXEN_NIC_REG(0x1f8),
> 	    /* crb_rcv_consumer_offset: */
> 	    NETXEN_NIC_REG(0x1fc),
>@@ -210,7 +209,7 @@ struct netxen_recv_crb recv_crb_registers[] = {
> 	    },
> 	    /* Jumbo frames */
> 	    {
>-	    /* crb_rcv_producer_offset: */ 
>+	    /* crb_rcv_producer_offset: */
> 	    NETXEN_NIC_REG(0x23c),
> 	    /* crb_rcv_consumer_offset: */
> 	    NETXEN_NIC_REG(0x240),
>@@ -244,12 +243,15 @@ struct netxen_recv_crb recv_crb_registers[] = {
> 	},
> };
> 
>-u64 ctx_addr_sig_regs[][3] = {
>+static u64 ctx_addr_sig_regs[][3] = {
> 	{NETXEN_NIC_REG(0x188), NETXEN_NIC_REG(0x18c), NETXEN_NIC_REG(0x1c0)},
> 	{NETXEN_NIC_REG(0x190), NETXEN_NIC_REG(0x194), NETXEN_NIC_REG(0x1c4)},
> 	{NETXEN_NIC_REG(0x198), NETXEN_NIC_REG(0x19c), NETXEN_NIC_REG(0x1c8)},
> 	{NETXEN_NIC_REG(0x1a0), NETXEN_NIC_REG(0x1a4), NETXEN_NIC_REG(0x1cc)}
> };
>+#define CRB_CTX_ADDR_REG_LO(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][0])
>+#define CRB_CTX_ADDR_REG_HI(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][2])
>+#define CRB_CTX_SIGNATURE_REG(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][1])
> 
> 
> /*  PCI Windowing for DDR regions.  */
>@@ -279,8 +281,8 @@ u64 ctx_addr_sig_regs[][3] = {
> 
> #define NETXEN_NIC_WINDOW_MARGIN 0x100000
> 
>-unsigned long netxen_nic_pci_set_window(struct netxen_adapter *adapter,
>-					unsigned long long addr);
>+static unsigned long netxen_nic_pci_set_window(struct netxen_adapter *adapter,
>+					       unsigned long long addr);
> void netxen_free_hw_resources(struct netxen_adapter *adapter);
> 
> int netxen_nic_set_mac(struct net_device *netdev, void *p)
>@@ -396,6 +398,8 @@ int netxen_nic_hw_resources(struct netxen_adapter *adapter)
> 		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,
>@@ -417,7 +421,7 @@ int netxen_nic_hw_resources(struct netxen_adapter *adapter)
> 	adapter->ctx_desc->cmd_consumer_offset =
> 	    cpu_to_le64(adapter->ctx_desc_phys_addr +
> 			sizeof(struct netxen_ring_ctx));
>-	adapter->cmd_consumer = (uint32_t *) (((char *)addr) +
>+	adapter->cmd_consumer = (__le32 *) (((char *)addr) +
> 					      sizeof(struct netxen_ring_ctx));
> 
> 	addr = netxen_alloc(adapter->ahw.pdev,
>@@ -584,35 +588,35 @@ int netxen_is_flash_supported(struct netxen_adapter *adapter)
> }
> 
> static int netxen_get_flash_block(struct netxen_adapter *adapter, int base,
>-				  int size, u32 * buf)
>+				  int size, __le32 * buf)
> {
> 	int i, addr;
>-	u32 *ptr32;
>+	__le32 *ptr32;
>+	u32 v;
> 
> 	addr = base;
> 	ptr32 = buf;
> 	for (i = 0; i < size / sizeof(u32); i++) {
>-		if (netxen_rom_fast_read(adapter, addr, ptr32) == -1)
>+		if (netxen_rom_fast_read(adapter, addr, &v) == -1)
> 			return -1;
>-		*ptr32 = cpu_to_le32(*ptr32);
>+		*ptr32 = cpu_to_le32(v);
> 		ptr32++;
> 		addr += sizeof(u32);
> 	}
> 	if ((char *)buf + size > (char *)ptr32) {
>-		u32 local;
>-
>-		if (netxen_rom_fast_read(adapter, addr, &local) == -1)
>+		__le32 local;
>+		if (netxen_rom_fast_read(adapter, addr, &v) == -1)
> 			return -1;
>-		local = cpu_to_le32(local);
>+		local = cpu_to_le32(v);
> 		memcpy(ptr32, &local, (char *)buf + size - (char *)ptr32);
> 	}
> 
> 	return 0;
> }
> 
>-int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, u64 mac[])
>+int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, __le64 mac[])
> {
>-	u32 *pmac = (u32 *) & mac[0];
>+	__le32 *pmac = (__le32 *) & mac[0];
> 
> 	if (netxen_get_flash_block(adapter,
> 				   NETXEN_USER_START +
>@@ -621,7 +625,7 @@ int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, u64 mac[])
> 				   FLASH_NUM_PORTS * sizeof(u64), pmac) == -1) {
> 		return -1;
> 	}
>-	if (*mac == ~0ULL) {
>+	if (*mac == cpu_to_le64(~0ULL)) {
> 		if (netxen_get_flash_block(adapter,
> 					   NETXEN_USER_START_OLD +
> 					   offsetof(struct netxen_user_old_info,
>@@ -629,7 +633,7 @@ int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, u64 mac[])
> 					   FLASH_NUM_PORTS * sizeof(u64),
> 					   pmac) == -1)
> 			return -1;
>-		if (*mac == ~0ULL)
>+		if (*mac == cpu_to_le64(~0ULL))
> 			return -1;
> 	}
> 	return 0;
>@@ -664,7 +668,7 @@ void netxen_nic_pci_change_crbwindow(struct netxen_adapter *adapter, u32 wndw)
> 					NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW_F3));
> 			break;
> 		default:
>-			printk(KERN_INFO "Changing the window for PCI function"
>+			printk(KERN_INFO "Changing the window for PCI function "
> 					"%d\n",	adapter->ahw.pci_func);
> 			offset = PCI_OFFSET_SECOND_RANGE(adapter,
> 					NETXEN_PCIX_PH_REG(PCIX_CRB_WINDOW));
>@@ -886,11 +890,10 @@ void netxen_nic_read_w0(struct netxen_adapter *adapter, u32 index, u32 * value)
> 	netxen_nic_pci_change_crbwindow(adapter, 1);
> }
> 
>-int netxen_pci_set_window_warning_count = 0;
>+static int netxen_pci_set_window_warning_count;
> 
>-unsigned long
>-netxen_nic_pci_set_window(struct netxen_adapter *adapter,
>-			  unsigned long long addr)
>+static  unsigned long netxen_nic_pci_set_window(struct netxen_adapter *adapter,
>+						unsigned long long addr)
> {
> 	static int ddr_mn_window = -1;
> 	static int qdr_sn_window = -1;
>@@ -952,16 +955,18 @@ netxen_nic_pci_set_window(struct netxen_adapter *adapter,
> 	return addr;
> }
> 
>+#if 0
> int
> netxen_nic_erase_pxe(struct netxen_adapter *adapter)
> {
> 	if (netxen_rom_fast_write(adapter, NETXEN_PXE_START, 0) == -1) {
>-		printk(KERN_ERR "%s: erase pxe failed\n", 
>+		printk(KERN_ERR "%s: erase pxe failed\n",
> 			netxen_nic_driver_name);
> 		return -1;
> 	}
> 	return 0;
> }
>+#endif  /*  0  */
> 
> int netxen_nic_get_board_info(struct netxen_adapter *adapter)
> {
>@@ -1036,9 +1041,9 @@ int netxen_nic_set_mtu_xgb(struct netxen_adapter *adapter, int new_mtu)
> {
> 	new_mtu += NETXEN_NIU_HDRSIZE + NETXEN_NIU_TLRSIZE;
> 	if (physical_port[adapter->portnum] == 0)
>-		netxen_nic_write_w0(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE, 
>+		netxen_nic_write_w0(adapter, NETXEN_NIU_XGE_MAX_FRAME_SIZE,
> 				new_mtu);
>-	else 
>+	else
> 		netxen_nic_write_w0(adapter, NETXEN_NIU_XG1_MAX_FRAME_SIZE,
> 				new_mtu);
> 	return 0;
>diff --git a/drivers/net/netxen/netxen_nic_hw.h b/drivers/net/netxen/netxen_nic_hw.h
>index 245bf13..a3ea1dd 100644
>--- a/drivers/net/netxen/netxen_nic_hw.h
>+++ b/drivers/net/netxen/netxen_nic_hw.h
>@@ -235,7 +235,7 @@ typedef enum {
> 	((config_word) |= 1 << 0)
> #define netxen_xg_set_xg1_mask(config_word)    \
> 	((config_word) |= 1 << 3)
>-		
>+
> #define netxen_xg_get_xg0_mask(config_word)    \
> 	_netxen_crb_get_bit((config_word), 0)
> #define netxen_xg_get_xg1_mask(config_word)    \
>@@ -273,7 +273,7 @@ typedef enum {
> 	_netxen_crb_get_bit((config_word), 4)
> #define netxen_gb_get_gb3_mask(config_word)    \
> 	_netxen_crb_get_bit((config_word), 6)
>-	
>+
> #define netxen_gb_unset_gb0_mask(config_word)  \
> 	((config_word) &= ~(1 << 0))
> #define netxen_gb_unset_gb1_mask(config_word)  \
>@@ -437,7 +437,7 @@ typedef enum {
> 
> /*
>  * NIU GB Drop CRC Register
>- * 
>+ *
>  * Bit 0 : drop_gb0 => 1:drop pkts with bad CRCs, 0:pass them on
>  * Bit 1 : drop_gb1 => 1:drop pkts with bad CRCs, 0:pass them on
>  * Bit 2 : drop_gb2 => 1:drop pkts with bad CRCs, 0:pass them on
>@@ -480,7 +480,7 @@ typedef enum {
> 
> /*
>  * MAC Control Register
>- * 
>+ *
>  * Bit 0-1   : id_pool0
>  * Bit 2     : enable_xtnd0
>  * Bit 4-5   : id_pool1
>@@ -515,20 +515,16 @@ typedef enum {
> 		((config) |= (((val) & 0x0f) << 28))
> 
> /* Set promiscuous mode for a GbE interface */
>-int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, 
>+int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
> 				    netxen_niu_prom_mode_t mode);
> int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
> 				       netxen_niu_prom_mode_t mode);
> 
>-/* get/set the MAC address for a given MAC */
>-int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
>-			   netxen_ethernet_macaddr_t * addr);
>+/* set the MAC address for a given MAC */
> int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
> 			   netxen_ethernet_macaddr_t addr);
> 
>-/* XG versons */
>-int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter,
>-			      netxen_ethernet_macaddr_t * addr);
>+/* XG version */
> int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
> 			      netxen_ethernet_macaddr_t addr);
> 
>diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
>index 485ff93..45fa33e 100644
>--- a/drivers/net/netxen/netxen_nic_init.c
>+++ b/drivers/net/netxen/netxen_nic_init.c
>@@ -54,13 +54,17 @@ static unsigned int crb_addr_xform[NETXEN_MAX_CRB_XFORM];
> 
> #define NETXEN_NIC_XDMA_RESET 0x8000ff
> 
>-static inline void
>-netxen_nic_locked_write_reg(struct netxen_adapter *adapter,
>-			    unsigned long off, int *data)
>+static void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
>+					uint32_t ctx, uint32_t ringid);
>+
>+#if 0
>+static void netxen_nic_locked_write_reg(struct netxen_adapter *adapter,
>+					unsigned long off, int *data)
> {
> 	void __iomem *addr = pci_base_offset(adapter, off);
> 	writel(*data, addr);
> }
>+#endif  /*  0  */
> 
> static void crb_addr_transform_setup(void)
> {
>@@ -141,6 +145,8 @@ int netxen_init_firmware(struct netxen_adapter *adapter)
> 	/* 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 +185,6 @@ void netxen_initialize_adapter_sw(struct netxen_adapter *adapter)
> 		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;
>@@ -255,7 +260,7 @@ void netxen_initialize_adapter_ops(struct netxen_adapter *adapter)
>  * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
>  * address to external PCI CRB address.
>  */
>-u32 netxen_decode_crb_addr(u32 addr)
>+static u32 netxen_decode_crb_addr(u32 addr)
> {
> 	int i;
> 	u32 base_addr, offset, pci_base;
>@@ -282,7 +287,7 @@ static long rom_max_timeout = 100;
> static long rom_lock_timeout = 10000;
> static long rom_write_timeout = 700;
> 
>-static inline int rom_lock(struct netxen_adapter *adapter)
>+static int rom_lock(struct netxen_adapter *adapter)
> {
> 	int iter;
> 	u32 done = 0;
>@@ -312,7 +317,7 @@ static inline int rom_lock(struct netxen_adapter *adapter)
> 	return 0;
> }
> 
>-int netxen_wait_rom_done(struct netxen_adapter *adapter)
>+static int netxen_wait_rom_done(struct netxen_adapter *adapter)
> {
> 	long timeout = 0;
> 	long done = 0;
>@@ -329,7 +334,7 @@ int netxen_wait_rom_done(struct netxen_adapter *adapter)
> 	return 0;
> }
> 
>-static inline int netxen_rom_wren(struct netxen_adapter *adapter)
>+static int netxen_rom_wren(struct netxen_adapter *adapter)
> {
> 	/* Set write enable latch in ROM status register */
> 	netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
>@@ -341,15 +346,15 @@ static inline int netxen_rom_wren(struct netxen_adapter *adapter)
> 	return 0;
> }
> 
>-static inline unsigned int netxen_rdcrbreg(struct netxen_adapter *adapter,
>-					   unsigned int addr)
>+static unsigned int netxen_rdcrbreg(struct netxen_adapter *adapter,
>+				    unsigned int addr)
> {
> 	unsigned int data = 0xdeaddead;
> 	data = netxen_nic_reg_read(adapter, addr);
> 	return data;
> }
> 
>-static inline int netxen_do_rom_rdsr(struct netxen_adapter *adapter)
>+static int netxen_do_rom_rdsr(struct netxen_adapter *adapter)
> {
> 	netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
> 			     M25P_INSTR_RDSR);
>@@ -359,7 +364,7 @@ static inline int netxen_do_rom_rdsr(struct netxen_adapter *adapter)
> 	return netxen_rdcrbreg(adapter, NETXEN_ROMUSB_ROM_RDATA);
> }
> 
>-static inline void netxen_rom_unlock(struct netxen_adapter *adapter)
>+static void netxen_rom_unlock(struct netxen_adapter *adapter)
> {
> 	u32 val;
> 
>@@ -368,7 +373,7 @@ static inline void netxen_rom_unlock(struct netxen_adapter *adapter)
> 
> }
> 
>-int netxen_rom_wip_poll(struct netxen_adapter *adapter)
>+static int netxen_rom_wip_poll(struct netxen_adapter *adapter)
> {
> 	long timeout = 0;
> 	long wip = 1;
>@@ -385,8 +390,8 @@ int netxen_rom_wip_poll(struct netxen_adapter *adapter)
> 	return 0;
> }
> 
>-static inline int do_rom_fast_write(struct netxen_adapter *adapter, int addr,
>-				    int data)
>+static int do_rom_fast_write(struct netxen_adapter *adapter, int addr,
>+			     int data)
> {
> 	if (netxen_rom_wren(adapter)) {
> 		return -1;
>@@ -404,8 +409,8 @@ static inline int do_rom_fast_write(struct netxen_adapter *adapter, int addr,
> 	return netxen_rom_wip_poll(adapter);
> }
> 
>-static inline int
>-do_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
>+static int do_rom_fast_read(struct netxen_adapter *adapter,
>+			    int addr, int *valp)
> {
> 	cond_resched();
> 
>@@ -427,18 +432,18 @@ do_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
> 	return 0;
> }
> 
>-static inline int 
>-do_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
>-			u8 *bytes, size_t size)
>+static int do_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
>+				  u8 *bytes, size_t size)
> {
> 	int addridx;
> 	int ret = 0;
> 
> 	for (addridx = addr; addridx < (addr + size); addridx += 4) {
>-		ret = do_rom_fast_read(adapter, addridx, (int *)bytes);
>+		int v;
>+		ret = do_rom_fast_read(adapter, addridx, &v);
> 		if (ret != 0)
> 			break;
>-		*(int *)bytes = cpu_to_le32(*(int *)bytes);
>+		*(__le32 *)bytes = cpu_to_le32(v);
> 		bytes += 4;
> 	}
> 
>@@ -446,7 +451,7 @@ do_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
> }
> 
> int
>-netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr, 
>+netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
> 				u8 *bytes, size_t size)
> {
> 	int ret;
>@@ -473,6 +478,7 @@ int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
> 	return ret;
> }
> 
>+#if 0
> int netxen_rom_fast_write(struct netxen_adapter *adapter, int addr, int data)
> {
> 	int ret = 0;
>@@ -484,9 +490,10 @@ int netxen_rom_fast_write(struct netxen_adapter *adapter, int addr, int data)
> 	netxen_rom_unlock(adapter);
> 	return ret;
> }
>+#endif  /*  0  */
> 
>-static inline int do_rom_fast_write_words(struct netxen_adapter *adapter, 
>-						int addr, u8 *bytes, size_t size)
>+static int do_rom_fast_write_words(struct netxen_adapter *adapter,
>+				   int addr, u8 *bytes, size_t size)
> {
> 	int addridx = addr;
> 	int ret = 0;
>@@ -496,11 +503,11 @@ static inline int do_rom_fast_write_words(struct netxen_adapter *adapter,
> 		int timeout = 0;
> 		int data;
> 
>-		data = le32_to_cpu((*(u32*)bytes));
>+		data = le32_to_cpu((*(__le32*)bytes));
> 		ret = do_rom_fast_write(adapter, addridx, data);
> 		if (ret < 0)
> 			return ret;
>-			
>+
> 		while(1) {
> 			int data1;
> 
>@@ -513,7 +520,7 @@ static inline int do_rom_fast_write_words(struct netxen_adapter *adapter,
> 
> 			if (timeout++ >= rom_write_timeout) {
> 				if (last_attempt++ < 4) {
>-					ret = do_rom_fast_write(adapter, 
>+					ret = do_rom_fast_write(adapter,
> 								addridx, data);
> 					if (ret < 0)
> 						return ret;
>@@ -533,7 +540,7 @@ static inline int do_rom_fast_write_words(struct netxen_adapter *adapter,
> 	return ret;
> }
> 
>-int netxen_rom_fast_write_words(struct netxen_adapter *adapter, int addr, 
>+int netxen_rom_fast_write_words(struct netxen_adapter *adapter, int addr,
> 					u8 *bytes, size_t size)
> {
> 	int ret = 0;
>@@ -548,7 +555,7 @@ int netxen_rom_fast_write_words(struct netxen_adapter *adapter, int addr,
> 	return ret;
> }
> 
>-int netxen_rom_wrsr(struct netxen_adapter *adapter, int data)
>+static int netxen_rom_wrsr(struct netxen_adapter *adapter, int data)
> {
> 	int ret;
> 
>@@ -557,7 +564,7 @@ int netxen_rom_wrsr(struct netxen_adapter *adapter, int data)
> 		return ret;
> 
> 	netxen_crb_writelit_adapter(adapter, NETXEN_ROMUSB_ROM_WDATA, data);
>-	netxen_crb_writelit_adapter(adapter, 
>+	netxen_crb_writelit_adapter(adapter,
> 					NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0x1);
> 
> 	ret = netxen_wait_rom_done(adapter);
>@@ -567,7 +574,7 @@ int netxen_rom_wrsr(struct netxen_adapter *adapter, int data)
> 	return netxen_rom_wip_poll(adapter);
> }
> 
>-int netxen_rom_rdsr(struct netxen_adapter *adapter)
>+static int netxen_rom_rdsr(struct netxen_adapter *adapter)
> {
> 	int ret;
> 
>@@ -587,7 +594,7 @@ int netxen_backup_crbinit(struct netxen_adapter *adapter)
> 	char *buffer = kmalloc(NETXEN_FLASH_SECTOR_SIZE, GFP_KERNEL);
> 
> 	if (!buffer)
>-		return -ENOMEM;	
>+		return -ENOMEM;
> 	/* unlock sector 63 */
> 	val = netxen_rom_rdsr(adapter);
> 	val = val & 0xe3;
>@@ -600,12 +607,12 @@ int netxen_backup_crbinit(struct netxen_adapter *adapter)
> 		goto out_kfree;
> 
> 	/* copy  sector 0 to sector 63 */
>-	ret = netxen_rom_fast_read_words(adapter, NETXEN_CRBINIT_START, 
>+	ret = netxen_rom_fast_read_words(adapter, NETXEN_CRBINIT_START,
> 					buffer, NETXEN_FLASH_SECTOR_SIZE);
> 	if (ret != FLASH_SUCCESS)
> 		goto out_kfree;
> 
>-	ret = netxen_rom_fast_write_words(adapter, NETXEN_FIXED_START, 
>+	ret = netxen_rom_fast_write_words(adapter, NETXEN_FIXED_START,
> 					buffer, NETXEN_FLASH_SECTOR_SIZE);
> 	if (ret != FLASH_SUCCESS)
> 		goto out_kfree;
>@@ -632,7 +639,7 @@ out_kfree:
> 	return ret;
> }
> 
>-int netxen_do_rom_se(struct netxen_adapter *adapter, int addr)
>+static int netxen_do_rom_se(struct netxen_adapter *adapter, int addr)
> {
> 	netxen_rom_wren(adapter);
> 	netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
>@@ -646,16 +653,16 @@ int netxen_do_rom_se(struct netxen_adapter *adapter, int addr)
> 	return netxen_rom_wip_poll(adapter);
> }
> 
>-void check_erased_flash(struct netxen_adapter *adapter, int addr)
>+static void check_erased_flash(struct netxen_adapter *adapter, int addr)
> {
> 	int i;
> 	int val;
> 	int count = 0, erased_errors = 0;
> 	int range;
> 
>-	range = (addr == NETXEN_USER_START) ? 
>+	range = (addr == NETXEN_USER_START) ?
> 		NETXEN_FIXED_START : addr + NETXEN_FLASH_SECTOR_SIZE;
>-	
>+
> 	for (i = addr; i < range; i += 4) {
> 		netxen_rom_fast_read(adapter, i, &val);
> 		if (val != 0xffffffff)
>@@ -682,8 +689,8 @@ int netxen_rom_se(struct netxen_adapter *adapter, int addr)
> 	return ret;
> }
> 
>-int
>-netxen_flash_erase_sections(struct netxen_adapter *adapter, int start, int end)
>+static int netxen_flash_erase_sections(struct netxen_adapter *adapter,
>+				       int start, int end)
> {
> 	int ret = FLASH_SUCCESS;
> 	int i;
>@@ -968,29 +975,7 @@ int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
> 	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)
>+static int netxen_nic_check_temp(struct netxen_adapter *adapter)
> {
> 	struct net_device *netdev = adapter->netdev;
> 	uint32_t temp, temp_state, temp_val;
>@@ -1032,7 +1017,6 @@ static inline int netxen_nic_check_temp(struct netxen_adapter *adapter)
> 
> void netxen_watchdog_task(struct work_struct *work)
> {
>-	struct net_device *netdev;
> 	struct netxen_adapter *adapter =
> 		container_of(work, struct netxen_adapter, watchdog_task);
> 
>@@ -1042,20 +1026,6 @@ void netxen_watchdog_task(struct work_struct *work)
> 	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);
> }
> 
>@@ -1064,9 +1034,8 @@ void netxen_watchdog_task(struct work_struct *work)
>  * and if the number of receives exceeds RX_BUFFERS_REFILL, then we
>  * invoke the routine to send more rx buffers to the Phantom...
>  */
>-void
>-netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
>-		   struct status_desc *desc)
>+static void netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
>+			       struct status_desc *desc)
> {
> 	struct pci_dev *pdev = adapter->pdev;
> 	struct net_device *netdev = adapter->netdev;
>@@ -1103,8 +1072,8 @@ netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
> 		}
> 		if (buffer->lro_current_frags != buffer->lro_expected_frags) {
> 			if (buffer->lro_expected_frags != 0) {
>-				printk("LRO: (refhandle:%x) recv frag."
>-				       "wait for last. flags: %x expected:%d"
>+				printk("LRO: (refhandle:%x) recv frag. "
>+				       "wait for last. flags: %x expected:%d "
> 				       "have:%d\n", index,
> 				       netxen_get_sts_desc_lro_last_frag(desc),
> 				       buffer->lro_expected_frags,
>@@ -1120,7 +1089,7 @@ netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
> 	skb = (struct sk_buff *)buffer->skb;
> 
> 	if (likely(adapter->rx_csum &&
>-				netxen_get_sts_status(sts_data) == STATUS_CKSUM_OK)) {
>+			netxen_get_sts_status(sts_data) == STATUS_CKSUM_OK)) {
> 		adapter->stats.csummed++;
> 		skb->ip_summed = CHECKSUM_UNNECESSARY;
> 	} else
>@@ -1137,40 +1106,8 @@ netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
> 	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--;
> 
> 	/*
>@@ -1195,13 +1132,6 @@ u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctxid, int max)
> 	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)) {
>@@ -1214,11 +1144,8 @@ u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctxid, int max)
> 		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 */
> 	if (count) {
>@@ -1228,108 +1155,60 @@ u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctxid, int max)
> 		/* 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;
>-	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;
> 		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++;
>+			adapter->stats.xmitfinished++;
> 			dev_kfree_skb_any(buffer->skb);
> 			buffer->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);
> 		}
> 
> 		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);
> 		}
> 	}
> 	/*
>@@ -1345,16 +1224,9 @@ int netxen_process_cmd_ring(unsigned long data)
> 	 * 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);
>+	consumer = le32_to_cpu(*(adapter->cmd_consumer));
>+	done = (last_consumer == consumer);
> 
>-	spin_unlock(&adapter->tx_lock);
>-	DPRINTK(INFO, "last consumer is %d in %s\n", last_consumer,
>-		__FUNCTION__);
> 	return (done);
> }
> 
>@@ -1428,8 +1300,6 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
> 		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),
>@@ -1453,13 +1323,11 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
> 			writel(msg,
> 			       DB_NORMALIZE(adapter,
> 					    NETXEN_RCV_PRODUCER_OFFSET));
>-			wmb();
>-		}
> 	}
> }
> 
>-void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
>-				 uint32_t ringid)
>+static void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
>+					uint32_t ctx, uint32_t ringid)
> {
> 	struct pci_dev *pdev = adapter->ahw.pdev;
> 	struct sk_buff *skb;
>@@ -1491,7 +1359,7 @@ void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
> 		count++;	/* now there should be no failure */
> 		pdesc = &rcv_desc->desc_head[producer];
> 		skb_reserve(skb, 2);
>-		/* 
>+		/*
> 		 * This will be setup when we receive the
> 		 * buffer after it has been filled
> 		 * skb->dev = netdev;
>@@ -1518,8 +1386,6 @@ void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
> 		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),
>@@ -1529,21 +1395,9 @@ void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
> 						    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 --git a/drivers/net/netxen/netxen_nic_isr.c b/drivers/net/netxen/netxen_nic_isr.c
>index b2de6b6..c81313b 100644
>--- a/drivers/net/netxen/netxen_nic_isr.c
>+++ b/drivers/net/netxen/netxen_nic_isr.c
>@@ -48,7 +48,7 @@ struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
> 	/* total packets received   */
> 	stats->rx_packets = adapter->stats.no_rcv;
> 	/* total packets transmitted    */
>-	stats->tx_packets = adapter->stats.xmitedframes + 
>+	stats->tx_packets = adapter->stats.xmitedframes +
> 		adapter->stats.xmitfinished;
> 	/* total bytes received     */
> 	stats->rx_bytes = adapter->stats.rxbytes;
>@@ -59,14 +59,15 @@ struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
> 	/* 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;
> 
> 	return stats;
> }
> 
>-void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 link)
>+static void netxen_indicate_link_status(struct netxen_adapter *adapter,
>+					u32 link)
> {
> 	struct net_device *netdev = adapter->netdev;
> 
>@@ -76,13 +77,14 @@ void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 link)
> 		netif_carrier_off(netdev);
> }
> 
>+#if 0
> void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable)
> {
> 	__u32 int_src;
> 
> 	/*  This should clear the interrupt source */
> 	if (adapter->phy_read)
>-		adapter->phy_read(adapter, 
>+		adapter->phy_read(adapter,
> 				  NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
> 				  &int_src);
> 	if (int_src == 0) {
>@@ -111,7 +113,7 @@ void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable)
> 		DPRINTK(INFO, "SPEED CHANGED OR LINK STATUS CHANGED \n");
> 
> 		if (adapter->phy_read
>-		    && adapter->phy_read(adapter, 
>+		    && adapter->phy_read(adapter,
> 					 NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
> 					 &status) == 0) {
> 			if (netxen_get_phy_int_link_status_changed(int_src)) {
>@@ -125,7 +127,7 @@ void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable)
> 					       netxen_nic_driver_name,
> 					       adapter->netdev->name);
> 				}
>-				netxen_indicate_link_status(adapter, 
>+				netxen_indicate_link_status(adapter,
> 							    netxen_get_phy_link
> 							    (status));
> 			}
>@@ -134,8 +136,9 @@ void netxen_handle_port_int(struct netxen_adapter *adapter, u32 enable)
> 	if (adapter->enable_phy_interrupts)
> 		adapter->enable_phy_interrupts(adapter);
> }
>+#endif  /*  0  */
> 
>-void netxen_nic_isr_other(struct netxen_adapter *adapter)
>+static void netxen_nic_isr_other(struct netxen_adapter *adapter)
> {
> 	int portno = adapter->portnum;
> 	u32 val, linkup, qg_linksup;
>@@ -190,14 +193,14 @@ int netxen_nic_link_ok(struct netxen_adapter *adapter)
> 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 +208,7 @@ void netxen_nic_xgbe_handle_phy_intr(struct netxen_adapter *adapter)
> 			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 --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
>index 263b55e..a8fb439 100644
>--- a/drivers/net/netxen/netxen_nic_main.c
>+++ b/drivers/net/netxen/netxen_nic_main.c
>@@ -63,12 +63,12 @@ static int netxen_nic_xmit_frame(struct sk_buff *, struct net_device *);
> static void netxen_tx_timeout(struct net_device *netdev);
> static void netxen_tx_timeout_task(struct work_struct *work);
> static void netxen_watchdog(unsigned long);
>-static int netxen_handle_int(struct netxen_adapter *, struct net_device *);
> static int netxen_nic_poll(struct napi_struct *napi, 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);
>+static irqreturn_t netxen_msi_intr(int irq, void *data);
> 
> int physical_port[] = {0, 1, 2, 3};
> 
>@@ -89,8 +89,8 @@ MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
> struct workqueue_struct *netxen_workq;
> static void netxen_watchdog(unsigned long);
> 
>-static inline void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
>-							uint32_t crb_producer)
>+static void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
>+					   uint32_t crb_producer)
> {
> 	switch (adapter->portnum) {
> 		case 0:
>@@ -118,8 +118,8 @@ static inline void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter
> 	}
> }
> 
>-static inline void netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
>-							u32 crb_consumer)
>+static void netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
>+					   u32 crb_consumer)
> {
> 	switch (adapter->portnum) {
> 		case 0:
>@@ -148,35 +148,31 @@ static inline void netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter
> }
> 
> #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,
>@@ -191,14 +187,18 @@ static void netxen_nic_disable_int(struct netxen_adapter *adapter)
> 			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");
> 
>@@ -219,20 +219,7 @@ static void netxen_nic_enable_int(struct netxen_adapter *adapter)
> 		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;
>@@ -278,7 +265,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 	struct netxen_recv_context *recv_ctx = NULL;
> 	struct netxen_rcv_desc_ctx *rcv_desc = NULL;
> 	struct netxen_cmd_buffer *cmd_buf_arr = NULL;
>-	u64 mac_addr[FLASH_NUM_PORTS + 1];
>+	__le64 mac_addr[FLASH_NUM_PORTS + 1];
> 	int valid_mac = 0;
> 	u32 val;
> 	int pci_func_id = PCI_FUNC(pdev->devfn);
>@@ -287,7 +274,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 	printk(KERN_INFO "%s \n", netxen_nic_driver_string);
> 
> 	if (pdev->class != 0x020000) {
>-		printk(KERN_ERR"NetXen function %d, class %x will not"
>+		printk(KERN_ERR"NetXen function %d, class %x will not "
> 				"be enabled.\n",pci_func_id, pdev->class);
> 		return -ENODEV;
> 	}
>@@ -329,7 +316,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 
> 	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 */
>@@ -351,12 +337,12 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 		first_page_group_start = 0;
> 		first_page_group_end   = 0;
> 	} else {
>-		err = -EIO; 
>+		err = -EIO;
> 		goto err_out_free_netdev;
> 	}
> 
>-	if (((mem_ptr0 == 0UL) && (mem_len == NETXEN_PCI_128MB_SIZE)) ||
>-			(mem_ptr1 == 0UL) || (mem_ptr2 == 0UL)) {
>+	if ((!mem_ptr0 && mem_len == NETXEN_PCI_128MB_SIZE) ||
>+			!mem_ptr1 || !mem_ptr2) {
> 		DPRINTK(ERR,
> 			"Cannot remap adapter memory aborting.:"
> 			"0 -> %p, 1 -> %p, 2 -> %p\n",
>@@ -402,6 +388,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 
> 	/* 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;
>@@ -411,12 +398,12 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 	netdev->open		   = netxen_nic_open;
> 	netdev->stop		   = netxen_nic_close;
> 	netdev->hard_start_xmit    = netxen_nic_xmit_frame;
>-	netdev->get_stats	   = netxen_nic_get_stats;	
>+	netdev->get_stats	   = netxen_nic_get_stats;
> 	netdev->set_multicast_list = netxen_nic_set_multi;
> 	netdev->set_mac_address    = netxen_nic_set_mac;
> 	netdev->change_mtu	   = netxen_nic_change_mtu;
> 	netdev->tx_timeout	   = netxen_tx_timeout;
>-	netdev->watchdog_timeo     = HZ;
>+	netdev->watchdog_timeo     = 2*HZ;
> 
> 	netxen_nic_change_mtu(netdev, netdev->mtu);
> 
>@@ -458,8 +445,8 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 
> 	adapter->max_tx_desc_count = MAX_CMD_DESCRIPTORS_HOST;
> 	if ((adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB35_4G) ||
>-			(adapter->ahw.boardcfg.board_type == 
>-			 NETXEN_BRDTYPE_P2_SB31_2G)) 
>+			(adapter->ahw.boardcfg.board_type ==
>+			 NETXEN_BRDTYPE_P2_SB31_2G))
> 		adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
> 	else
> 		adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS;
>@@ -511,7 +498,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 			    vmalloc(RCV_BUFFSIZE);
> 
> 			if (rcv_desc->rx_buf_arr == NULL) {
>-				printk(KERN_ERR "%s: Could not allocate"
>+				printk(KERN_ERR "%s: Could not allocate "
> 				       "rcv_desc->rx_buf_arr memory:%d\n",
> 				       netxen_nic_driver_name,
> 				       (int)RCV_BUFFSIZE);
>@@ -544,7 +531,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 	adapter->watchdog_timer.data = (unsigned long)adapter;
> 	INIT_WORK(&adapter->watchdog_task, netxen_watchdog_task);
> 	adapter->ahw.pdev = pdev;
>-	adapter->proc_cmd_buf_counter = 0;
> 	adapter->ahw.revision_id = pdev->revision;
> 
> 	/* make sure Window == 1 */
>@@ -584,9 +570,9 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 
> 	if (adapter->portnum == 0) {
> 		err = netxen_initialize_adapter_offload(adapter);
>-		if (err) 
>+		if (err)
> 			goto err_out_free_rx_buffer;
>-		val = readl(NETXEN_CRB_NORMALIZE(adapter, 
>+		val = readl(NETXEN_CRB_NORMALIZE(adapter,
> 					NETXEN_CAM_RAM(0x1fc)));
> 		if (val == 0x55555555) {
> 		    /* This is the first boot after power up */
>@@ -620,7 +606,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 		/*
> 		 * Tell the hardware our version number.
> 		 */
>-		i = (_NETXEN_NIC_LINUX_MAJOR << 16) 
>+		i = (_NETXEN_NIC_LINUX_MAJOR << 16)
> 			| ((_NETXEN_NIC_LINUX_MINOR << 8))
> 			| (_NETXEN_NIC_LINUX_SUBVERSION);
> 		writel(i, NETXEN_CRB_NORMALIZE(adapter, CRB_DRIVER_VERSION));
>@@ -660,7 +646,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> 			break;
> 
> 		case NETXEN_NIC_XGBE:
>-			printk(KERN_INFO "%s: XGbE board initialized\n", 
>+			printk(KERN_INFO "%s: XGbE board initialized\n",
> 					netxen_nic_driver_name);
> 			break;
> 	}
>@@ -834,6 +820,8 @@ static int netxen_nic_open(struct net_device *netdev)
> 	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);
>@@ -857,9 +845,14 @@ static int netxen_nic_open(struct net_device *netdev)
> 				netxen_post_rx_buffers(adapter, ctx, ring);
> 		}
> 		adapter->irq = adapter->ahw.pdev->irq;
>-		err = request_irq(adapter->ahw.pdev->irq, netxen_intr,
>-				  IRQF_SHARED|IRQF_SAMPLE_RANDOM, netdev->name,
>-				  adapter);
>+		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);
>@@ -868,21 +861,12 @@ static int netxen_nic_open(struct net_device *netdev)
> 
> 		adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
> 	}
>-	if (!adapter->driver_mismatch)
>-		mod_timer(&adapter->watchdog_timer, jiffies);
>-
>-	napi_enable(&adapter->napi);
>-
>-	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);
>-		napi_disable(&adapter->napi);
> 		return -EIO;
> 	}
> 	if (adapter->macaddr_set)
>@@ -895,6 +879,12 @@ static int netxen_nic_open(struct net_device *netdev)
> 		adapter->set_mtu(adapter, netdev->mtu);
> 
> 	if (!adapter->driver_mismatch)
>+		mod_timer(&adapter->watchdog_timer, jiffies);
>+
>+	napi_enable(&adapter->napi);
>+	netxen_nic_enable_int(adapter);
>+
>+	if (!adapter->driver_mismatch)
> 		netif_start_queue(netdev);
> 
> 	return 0;
>@@ -931,7 +921,7 @@ static int netxen_nic_close(struct net_device *netdev)
> 			buffrag++;
> 			if (buffrag->dma) {
> 				pci_unmap_page(adapter->pdev, buffrag->dma,
>-					       buffrag->length, 
>+					       buffrag->length,
> 					       PCI_DMA_TODEVICE);
> 				buffrag->dma = 0ULL;
> 			}
>@@ -959,41 +949,17 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
> 	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;
>-	}
>-
> 	/* There 4 fragments per descriptor */
> 	no_of_desc = (frag_count + 3) >> 2;
> 	if (netdev->features & NETIF_F_TSO) {
>@@ -1008,27 +974,16 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
> 		}
> 	}
> 
>-	spin_lock_bh(&adapter->tx_lock);
>-	if (adapter->total_threads >= MAX_XMIT_PRODUCERS) {
>-		goto out_requeue;
>+	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);
>+		smp_mb();
>+		return NETDEV_TX_BUSY;
> 	}
>-	local_producer = adapter->cmd_producer;
>-	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)) {
>-		goto out_requeue;
>-	}
>-	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));
>@@ -1068,8 +1023,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
> 		/* 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];
>@@ -1087,7 +1041,6 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
> 		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);
>@@ -1108,7 +1061,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
> 		}
> 		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);
>@@ -1135,7 +1088,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
> 		/* 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];
>@@ -1148,35 +1101,19 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
> 							 hwdesc,
> 							 (hdr_len -
> 							  first_hdr_len));
>-			producer = get_next_index(producer, max_tx_desc_count);
>+			producer = get_next_index(producer, num_txd);
> 		}
> 	}
> 
>-	spin_lock_bh(&adapter->tx_lock);
>+	adapter->cmd_producer = producer;
> 	adapter->stats.txbytes += skb->len;
> 
>-	/* 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;
>-	}
>+	netxen_nic_update_cmd_producer(adapter, adapter->cmd_producer);
> 
>-	adapter->stats.xmitfinished++;
>+	adapter->stats.xmitcalled++;
> 	netdev->trans_start = jiffies;
> 
>-	spin_unlock_bh(&adapter->tx_lock);
> 	return NETDEV_TX_OK;
>-
>-out_requeue:
>-	netif_stop_queue(netdev);
>-	adapter->flags |= NETXEN_NETDEV_STATUS;
>-
>-	spin_unlock_bh(&adapter->tx_lock);
>-	return NETDEV_TX_BUSY;
> }
> 
> static void netxen_watchdog(unsigned long v)
>@@ -1195,93 +1132,66 @@ static void netxen_tx_timeout(struct net_device *netdev)
> 
> static void netxen_tx_timeout_task(struct work_struct *work)
> {
>-	struct netxen_adapter *adapter = 
>+	struct netxen_adapter *adapter =
> 		container_of(work, struct netxen_adapter, tx_timeout_task);
> 
> 	printk(KERN_ERR "%s %s: transmit timeout, resetting.\n",
> 	       netxen_nic_driver_name, adapter->netdev->name);
> 
>-	netxen_nic_close(adapter->netdev);
>-	netxen_nic_open(adapter->netdev);
>+	netxen_nic_disable_int(adapter);
>+	napi_disable(&adapter->napi);
>+
> 	adapter->netdev->trans_start = jiffies;
>+
>+	napi_enable(&adapter->napi);
>+	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++;
>-
> 	netxen_nic_disable_int(adapter);
>-
>-	if (netxen_nic_rx_has_work(adapter) || netxen_nic_tx_has_work(adapter)) {
>-		if (netif_rx_schedule_prep(netdev, &adapter->napi)) {
>-			/*
>-			 * Interrupts are already disabled.
>-			 */
>-			__netif_rx_schedule(netdev, &adapter->napi);
>-		} 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);
>-	}
>-
>-	return ret;
>+	napi_schedule(&adapter->napi);
> }
> 
>-/*
>- * netxen_intr - Interrupt Handler
>- * @irq: interrupt number
>- * data points to adapter stucture (which may be handling more than 1 port
>- */
> irqreturn_t netxen_intr(int irq, void *data)
> {
> 	struct netxen_adapter *adapter = data;
>-	struct net_device *netdev = adapter->netdev;
> 	u32 our_int = 0;
> 
>-	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);
>+	netxen_handle_int(adapter);
> 
> 	return IRQ_HANDLED;
> }
> 
>+irqreturn_t netxen_msi_intr(int irq, void *data)
>+{
>+	struct netxen_adapter *adapter = data;
>+
>+	netxen_handle_int(adapter);
>+	return IRQ_HANDLED;
>+}
>+
> static int netxen_nic_poll(struct napi_struct *napi, int budget)
> {
> 	struct netxen_adapter *adapter = container_of(napi, struct netxen_adapter, napi);
>-	struct net_device *netdev = adapter->netdev;
>-	int done = 1;
>+	int tx_complete;
> 	int ctx;
> 	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) {
>@@ -1301,16 +1211,8 @@ static int netxen_nic_poll(struct napi_struct *napi, int budget)
> 						     budget / MAX_RCV_CTX);
> 	}
> 
>-	if (work_done >= budget)
>-		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, napi);
>+	if ((work_done < budget) && tx_complete) {
>+		netif_rx_complete(adapter->netdev, &adapter->napi);
> 		netxen_nic_enable_int(adapter);
> 	}
> 
>@@ -1338,7 +1240,7 @@ static struct pci_driver netxen_driver = {
> 
> static int __init netxen_init_module(void)
> {
>-	if ((netxen_workq = create_singlethread_workqueue("netxen")) == 0)
>+	if ((netxen_workq = create_singlethread_workqueue("netxen")) == NULL)
> 		return -ENOMEM;
> 
> 	return pci_register_driver(&netxen_driver);
>diff --git a/drivers/net/netxen/netxen_nic_niu.c b/drivers/net/netxen/netxen_nic_niu.c
>index d04ecb7..1c852a7 100644
>--- a/drivers/net/netxen/netxen_nic_niu.c
>+++ b/drivers/net/netxen/netxen_nic_niu.c
>@@ -40,7 +40,7 @@
> 
> static long phy_lock_timeout = 100000000;
> 
>-static inline int phy_lock(struct netxen_adapter *adapter)
>+static int phy_lock(struct netxen_adapter *adapter)
> {
> 	int i;
> 	int done = 0, timeout = 0;
>@@ -68,14 +68,14 @@ static inline int phy_lock(struct netxen_adapter *adapter)
> 	return 0;
> }
> 
>-static inline int phy_unlock(struct netxen_adapter *adapter)
>+static int phy_unlock(struct netxen_adapter *adapter)
> {
> 	readl(pci_base_offset(adapter, NETXEN_PCIE_REG(PCIE_SEM3_UNLOCK)));
> 
> 	return 0;
> }
> 
>-/* 
>+/*
>  * netxen_niu_gbe_phy_read - read a register from the GbE PHY via
>  * mii management interface.
>  *
>@@ -88,7 +88,7 @@ static inline int phy_unlock(struct netxen_adapter *adapter)
>  *	  -1 on error
>  *
>  */
>-int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg, 
>+int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
> 				__u32 * readval)
> {
> 	long timeout = 0;
>@@ -171,7 +171,7 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
> 	return result;
> }
> 
>-/* 
>+/*
>  * netxen_niu_gbe_phy_write - write a register to the GbE PHY via
>  * mii management interface.
>  *
>@@ -184,7 +184,7 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
>  *	  -1 on error
>  *
>  */
>-int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg, 
>+int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
> 				__u32 val)
> {
> 	long timeout = 0;
>@@ -275,7 +275,7 @@ int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter)
> 	netxen_set_phy_int_speed_changed(enable);
> 
> 	if (0 !=
>-	    netxen_niu_gbe_phy_write(adapter, 
>+	    netxen_niu_gbe_phy_write(adapter,
> 				     NETXEN_NIU_GB_MII_MGMT_ADDR_INT_ENABLE,
> 				     enable))
> 		result = -EIO;
>@@ -300,17 +300,19 @@ int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter)
> 	return result;
> }
> 
>+#if 0
> int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter)
> {
> 	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_ACTIVE_INT, -1);
> 	return 0;
> }
>+#endif  /*  0  */
> 
>-int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter)
>+static int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter)
> {
> 	int result = 0;
> 	if (0 !=
>-	    netxen_niu_gbe_phy_write(adapter, 
>+	    netxen_niu_gbe_phy_write(adapter,
> 				     NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
> 				     -EIO))
> 		result = -EIO;
>@@ -318,12 +320,12 @@ int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter)
> 	return result;
> }
> 
>-/* 
>+/*
>  * netxen_niu_gbe_set_mii_mode- Set 10/100 Mbit Mode for GbE MAC
>  *
>  */
>-void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
>-				 int port, long enable)
>+static void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
>+					int port, long enable)
> {
> 	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
> 	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
>@@ -342,9 +344,9 @@ void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
> 				    NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
> 
> 	if (enable) {
>-		/* 
>-		 * Do NOT enable flow control until a suitable solution for 
>-		 *  shutting down pause frames is found. 
>+		/*
>+		 * Do NOT enable flow control until a suitable solution for
>+		 *  shutting down pause frames is found.
> 		 */
> 		netxen_crb_writelit_adapter(adapter,
> 					    NETXEN_NIU_GB_MAC_CONFIG_0(port),
>@@ -357,11 +359,11 @@ void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
> 		printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
> }
> 
>-/* 
>+/*
>  * netxen_niu_gbe_set_gmii_mode- Set GbE Mode for GbE MAC
>  */
>-void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter,
>-				  int port, long enable)
>+static void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter,
>+					 int port, long enable)
> {
> 	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
> 	netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
>@@ -380,9 +382,9 @@ void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter,
> 				    NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
> 
> 	if (enable) {
>-		/* 
>-		 * Do NOT enable flow control until a suitable solution for 
>-		 *  shutting down pause frames is found. 
>+		/*
>+		 * Do NOT enable flow control until a suitable solution for
>+		 *  shutting down pause frames is found.
> 		 */
> 		netxen_crb_writelit_adapter(adapter,
> 					    NETXEN_NIU_GB_MAC_CONFIG_0(port),
>@@ -464,7 +466,8 @@ int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
> 	return 0;
> }
> 
>-/* 
>+#if 0
>+/*
>  * netxen_niu_gbe_handle_phy_interrupt - Handles GbE PHY interrupts
>  * @param enable 0 means don't enable the port
>  *		 1 means enable (or re-enable) the port
>@@ -544,8 +547,8 @@ int netxen_niu_gbe_handle_phy_interrupt(struct netxen_adapter *adapter,
> 								    port,
> 								    enable);
> 				} else {
>-					printk(KERN_ERR PFX "ERROR reading"
>-					       "PHY status. Illegal speed.\n");
>+					printk(KERN_ERR PFX "ERROR reading "
>+					       "PHY status. Invalid speed.\n");
> 					result = -1;
> 				}
> 			} else {
>@@ -559,13 +562,14 @@ int netxen_niu_gbe_handle_phy_interrupt(struct netxen_adapter *adapter,
> 	}
> 	return result;
> }
>+#endif  /*  0  */
> 
> /*
>  * Return the current station MAC address.
>  * Note that the passed-in value must already be in network byte order.
>  */
>-int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
>-			   netxen_ethernet_macaddr_t * addr)
>+static int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
>+				  netxen_ethernet_macaddr_t * addr)
> {
> 	u32 stationhigh;
> 	u32 stationlow;
>@@ -619,7 +623,7 @@ int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
> 		    (adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy), &val, 4))
> 			return -2;
> 
>-		netxen_niu_macaddr_get(adapter, 
>+		netxen_niu_macaddr_get(adapter,
> 				       (netxen_ethernet_macaddr_t *) mac_addr);
> 		if (memcmp(mac_addr, addr, 6) == 0)
> 			break;
>@@ -636,6 +640,7 @@ int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
> 	return 0;
> }
> 
>+#if 0
> /* Enable a GbE interface */
> int netxen_niu_enable_gbe_port(struct netxen_adapter *adapter,
> 			       int port, netxen_niu_gbe_ifmode_t mode)
>@@ -713,6 +718,7 @@ int netxen_niu_enable_gbe_port(struct netxen_adapter *adapter,
> 		return -EIO;
> 	return 0;
> }
>+#endif  /*  0  */
> 
> /* Disable a GbE interface */
> int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter)
>@@ -747,7 +753,7 @@ int netxen_niu_disable_xg_port(struct netxen_adapter *adapter)
> }
> 
> /* Set promiscuous mode for a GbE interface */
>-int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, 
>+int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
> 				    netxen_niu_prom_mode_t mode)
> {
> 	__u32 reg;
>@@ -853,6 +859,7 @@ int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
> 	return 0;
> }
> 
>+#if 0
> /*
>  * Return the current station MAC address.
>  * Note that the passed-in value must already be in network byte order.
>@@ -883,6 +890,7 @@ int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter,
> 
> 	return 0;
> }
>+#endif  /*  0  */
> 
> int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
> 				       netxen_niu_prom_mode_t mode)
>diff --git a/drivers/net/netxen/netxen_nic_phan_reg.h b/drivers/net/netxen/netxen_nic_phan_reg.h
>index 10fe6fa..a566b50 100644
>--- a/drivers/net/netxen/netxen_nic_phan_reg.h
>+++ b/drivers/net/netxen/netxen_nic_phan_reg.h
>@@ -1,7 +1,7 @@
> /*
>  * Copyright (C) 2003 - 2006 NetXen, Inc.
>  * All rights reserved.
>- * 
>+ *
>  * This program is free software; you can redistribute it and/or
>  * modify it under the terms of the GNU General Public License
>  * as published by the Free Software Foundation; either version 2
>@@ -16,10 +16,10 @@
>  * along with this program; if not, write to the Free Software
>  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
>  * MA  02111-1307, USA.
>- * 
>+ *
>  * The full GNU General Public License is included in this distribution
>  * in the file called LICENSE.
>- * 
>+ *
>  * Contact Information:
>  *    info@netxen.com
>  * NetXen,
>@@ -30,7 +30,7 @@
> #ifndef __NIC_PHAN_REG_H_
> #define __NIC_PHAN_REG_H_
> 
>-/* 
>+/*
>  * CRB Registers or queue message done only at initialization time.
>  */
> #define NIC_CRB_BASE               NETXEN_CAM_RAM(0x200)
>@@ -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)
>@@ -165,14 +168,7 @@ struct netxen_recv_crb {
> 	u32 crb_status_ring_size;
> };
> 
>-#if defined(DEFINE_GLOBAL_RECV_CRB)
>-#else
> extern struct netxen_recv_crb recv_crb_registers[];
>-extern u64 ctx_addr_sig_regs[][3];
>-#endif				/* DEFINE_GLOBAL_RECEIVE_CRB */
>-#define CRB_CTX_ADDR_REG_LO(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][0])
>-#define CRB_CTX_ADDR_REG_HI(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][2])
>-#define CRB_CTX_SIGNATURE_REG(FUNC_ID)		(ctx_addr_sig_regs[FUNC_ID][1])
> 
> /*
>  * Temperature control.

Actions: View

Attachments on bug 438987: 299773