NetXen: Use multiple PCI functions

NetXen: Make driver use multiple PCI functions.
This patch will make NetXen driver work with multiple PCI functions. This will
make the usage of memory resources as well as interrupts more independent
among different functions which results in better throughput. This change has
been done after the multiport support is added in firmware.

Signed-off by: Mithlesh Thukral <mithlesh@netxen.com>

Signed-off-by: Jeff Garzik <jeff@garzik.org>

1 files changed, 269 insertions, 257 deletions

diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index ab25c225a07e..514cb393f489 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -36,7 +36,6 @@
 #include "netxen_nic_hw.h"
 
 #include "netxen_nic.h"
-#define DEFINE_GLOBAL_RECV_CRB
 #include "netxen_nic_phan_reg.h"
 
 #include <linux/dma-mapping.h>
@@ -94,6 +93,67 @@ 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)
+{
+        switch (adapter->portnum) {
+                case 0:
+                        writel(crb_producer, NETXEN_CRB_NORMALIZE
+                                        (adapter, CRB_CMD_PRODUCER_OFFSET));
+                        return;
+                case 1:
+                        writel(crb_producer, NETXEN_CRB_NORMALIZE
+                                        (adapter, CRB_CMD_PRODUCER_OFFSET_1));
+                        return;
+                case 2:
+                        writel(crb_producer, NETXEN_CRB_NORMALIZE
+                                        (adapter, CRB_CMD_PRODUCER_OFFSET_2));
+                        return;
+                case 3:
+                        writel(crb_producer, NETXEN_CRB_NORMALIZE
+                                        (adapter, CRB_CMD_PRODUCER_OFFSET_3));
+                        return;
+                default:
+                        printk(KERN_WARNING "We tried to update "
+                                        "CRB_CMD_PRODUCER_OFFSET for invalid "
+                                        "PCI function id %d\n",
+                                        adapter->portnum);
+                        return;
+        }
+}
+
+static inline void netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
+                                                        u32 crb_consumer)
+{
+        switch (adapter->portnum) {
+                case 0:
+                        writel(crb_consumer, NETXEN_CRB_NORMALIZE
+                                (adapter, CRB_CMD_CONSUMER_OFFSET));
+                        return;
+                case 1:
+                        writel(crb_consumer, NETXEN_CRB_NORMALIZE
+                                (adapter, CRB_CMD_CONSUMER_OFFSET_1));
+                        return;
+                case 2:
+                        writel(crb_consumer, NETXEN_CRB_NORMALIZE
+                                (adapter, CRB_CMD_CONSUMER_OFFSET_2));
+                        return;
+                case 3:
+                        writel(crb_consumer, NETXEN_CRB_NORMALIZE
+                                (adapter, CRB_CMD_CONSUMER_OFFSET_3));
+                        return;
+                default:
+                        printk(KERN_WARNING "We tried to update "
+                                        "CRB_CMD_PRODUCER_OFFSET for invalid "
+                                        "PCI function id %d\n",
+                                        adapter->portnum);
+                        return;
+        }
+}
+
+#define ADAPTER_LIST_SIZE 12
+int netxen_cards_found;
+
 /*
  * netxen_nic_probe()
  *
@@ -111,26 +171,26 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         struct net_device *netdev = NULL;
         struct netxen_adapter *adapter = NULL;
-        struct netxen_port *port = NULL;
         void __iomem *mem_ptr0 = NULL;
         void __iomem *mem_ptr1 = NULL;
         void __iomem *mem_ptr2 = NULL;
 
         u8 __iomem *db_ptr = NULL;
         unsigned long mem_base, mem_len, db_base, db_len;
-        int pci_using_dac, i, err;
+        int pci_using_dac, i = 0, err;
         int ring;
         struct netxen_recv_context *recv_ctx = NULL;
         struct netxen_rcv_desc_ctx *rcv_desc = NULL;
         struct netxen_cmd_buffer *cmd_buf_arr = NULL;
         u64 mac_addr[FLASH_NUM_PORTS + 1];
-        int valid_mac = 0;
+        static int valid_mac = 0;
+        static int netxen_probe_flag;
+        int pci_func_id = PCI_FUNC(pdev->devfn);
 
         printk(KERN_INFO "%s \n", netxen_nic_driver_string);
-        /* In current scheme, we use only PCI function 0 */
-        if (PCI_FUNC(pdev->devfn) != 0) {
-                DPRINTK(ERR, "NetXen function %d will not be enabled.\n",
-                        PCI_FUNC(pdev->devfn));
+        if (pdev->class != 0x020000) {
+                printk(KERN_ERR"NetXen function %d, class %x will not"
+                                "be enabled.\n",pci_func_id, pdev->class);
                 return -ENODEV;
         }
         if ((err = pci_enable_device(pdev)))
@@ -157,6 +217,22 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 pci_using_dac = 0;
         }
 
+
+        netdev = alloc_etherdev(sizeof(struct netxen_adapter));
+        if(!netdev) {
+                printk(KERN_ERR"%s: Failed to allocate memory for the "
+                                "device block.Check system memory resource"
+                                " usage.\n", netxen_nic_driver_name);
+                goto err_out_free_res;
+        }
+
+        SET_MODULE_OWNER(netdev);
+        SET_NETDEV_DEV(netdev, &pdev->dev);
+
+        adapter = netdev->priv;
+        memset(adapter, 0 , sizeof(struct netxen_adapter));
+
+        adapter->ahw.pdev = pdev;
         /* remap phys address */
         mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
         mem_len = pci_resource_len(pdev, 0);
@@ -198,23 +274,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         }
         DPRINTK(INFO, "doorbell ioremaped at %p\n", db_ptr);
 
-/*
- *      Allocate a adapter structure which will manage all the initialization
- *      as well as the common resources for all ports...
- *      all the ports will have pointer to this adapter as well as Adapter
- *      will have pointers of all the ports structures.
- */
-
-        /* One adapter structure for all 4 ports....   */
-        adapter = kzalloc(sizeof(struct netxen_adapter), GFP_KERNEL);
-        if (adapter == NULL) {
-                printk(KERN_ERR "%s: Could not allocate adapter memory:%d\n",
-                       netxen_nic_driver_name,
-                       (int)sizeof(struct netxen_adapter));
-                err = -ENOMEM;
-                goto err_out_dbunmap;
-        }
-
         adapter->max_tx_desc_count = MAX_CMD_DESCRIPTORS;
         adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS;
         adapter->max_jumbo_rx_desc_count = MAX_JUMBO_RCV_DESCRIPTORS;
@@ -222,6 +281,42 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         pci_set_drvdata(pdev, adapter);
 
+        adapter->netdev  = netdev;
+        adapter->pdev    = pdev;
+        adapter->portnum = pci_func_id;
+
+        netdev->open               = netxen_nic_open;
+        netdev->stop               = netxen_nic_close;
+        netdev->hard_start_xmit    = netxen_nic_xmit_frame;
+        netdev->set_multicast_list = netxen_nic_set_multi;
+        netdev->set_mac_address    = netxen_nic_set_mac;
+        netdev->change_mtu         = netxen_nic_change_mtu;
+        netdev->tx_timeout         = netxen_tx_timeout;
+        netdev->watchdog_timeo     = HZ;
+
+        netxen_nic_change_mtu(netdev, netdev->mtu);
+
+        SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
+        netdev->poll = netxen_nic_poll;
+        netdev->weight = NETXEN_NETDEV_WEIGHT;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        netdev->poll_controller = netxen_nic_poll_controller;
+#endif
+        /* ScatterGather support */
+        netdev->features = NETIF_F_SG;
+        netdev->features |= NETIF_F_IP_CSUM;
+        netdev->features |= NETIF_F_TSO;
+
+        if (pci_using_dac)
+                netdev->features |= NETIF_F_HIGHDMA;
+
+        if (pci_enable_msi(pdev)) {
+                adapter->flags &= ~NETXEN_NIC_MSI_ENABLED;
+                printk(KERN_WARNING "%s: unable to allocate MSI interrupt"
+                       " error\n", netxen_nic_driver_name);
+        } else
+                adapter->flags |= NETXEN_NIC_MSI_ENABLED;
+
         cmd_buf_arr = (struct netxen_cmd_buffer *)vmalloc(TX_RINGSIZE);
         if (cmd_buf_arr == NULL) {
                 printk(KERN_ERR
@@ -288,9 +383,11 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         spin_lock_init(&adapter->lock);
         netxen_initialize_adapter_sw(adapter);  /* initialize the buffers in adapter */
 #ifdef CONFIG_IA64
-        netxen_pinit_from_rom(adapter, 0);
-        udelay(500);
-        netxen_load_firmware(adapter);
+        if(netxen_probe_flag == 0) {
+                netxen_pinit_from_rom(adapter, 0);
+                udelay(500);
+                netxen_load_firmware(adapter);
+        }
 #endif
 
         /*
@@ -304,6 +401,10 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
          */
         netxen_initialize_adapter_hw(adapter);  /* initialize the adapter */
 
+        if (adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB31_10G_IMEZ)
+                if (pci_func_id >= 2)
+                        adapter->portnum = pci_func_id - 2;
+
         netxen_initialize_adapter_ops(adapter);
 
         init_timer(&adapter->watchdog_timer);
@@ -315,12 +416,8 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         adapter->proc_cmd_buf_counter = 0;
         adapter->ahw.revision_id = nx_p2_id;
 
-        if (pci_enable_msi(pdev)) {
-                adapter->flags &= ~NETXEN_NIC_MSI_ENABLED;
-                printk(KERN_WARNING "%s: unable to allocate MSI interrupt"
-                       " error\n", netxen_nic_driver_name);
-        } else
-                adapter->flags |= NETXEN_NIC_MSI_ENABLED;
+        netxen_nic_update_cmd_producer(adapter, 0);
+        netxen_nic_update_cmd_consumer(adapter, 0);
 
         if (netxen_is_flash_supported(adapter) == 0 &&
             netxen_get_flash_mac_addr(adapter, mac_addr) == 0)
@@ -328,6 +425,34 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         else
                 valid_mac = 0;
 
+        if (valid_mac) {
+                unsigned char *p = (unsigned char *)&mac_addr[i];
+                netdev->dev_addr[0] = *(p + 5);
+                netdev->dev_addr[1] = *(p + 4);
+                netdev->dev_addr[2] = *(p + 3);
+                netdev->dev_addr[3] = *(p + 2);
+                netdev->dev_addr[4] = *(p + 1);
+                netdev->dev_addr[5] = *(p + 0);
+
+                memcpy(netdev->perm_addr, netdev->dev_addr,
+                        netdev->addr_len);
+                if (!is_valid_ether_addr(netdev->perm_addr)) {
+                        printk(KERN_ERR "%s: Bad MAC address "
+                                "%02x:%02x:%02x:%02x:%02x:%02x.\n",
+                                netxen_nic_driver_name,
+                                netdev->dev_addr[0],
+                                netdev->dev_addr[1],
+                                netdev->dev_addr[2],
+                                netdev->dev_addr[3],
+                                netdev->dev_addr[4],
+                                netdev->dev_addr[5]);
+                } else {
+                        if (adapter->macaddr_set)
+                                adapter->macaddr_set(adapter,
+                                                        netdev->dev_addr);
+                }
+        }
+
         /*
          * Initialize all the CRB registers here.
          */
@@ -337,140 +462,62 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         /* do this before waking up pegs so that we have valid dummy dma addr */
         err = netxen_initialize_adapter_offload(adapter);
-        if (err) {
+        if (err) 
                 goto err_out_free_dev;
-        }
-
-        /* Unlock the HW, prompting the boot sequence */
-        writel(1,
-               NETXEN_CRB_NORMALIZE(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
-
-        /* Handshake with the card before we register the devices. */
-        netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
-
-        /* initialize the all the ports */
-        adapter->active_ports = 0;
-
-        for (i = 0; i < adapter->ahw.max_ports; i++) {
-                netdev = alloc_etherdev(sizeof(struct netxen_port));
-                if (!netdev) {
-                        printk(KERN_ERR "%s: could not allocate netdev for port"
-                               " %d\n", netxen_nic_driver_name, i + 1);
-                        goto err_out_free_dev;
-                }
 
-                SET_MODULE_OWNER(netdev);
-                SET_NETDEV_DEV(netdev, &pdev->dev);
-
-                port = netdev_priv(netdev);
-                port->netdev = netdev;
-                port->pdev = pdev;
-                port->adapter = adapter;
-                port->portnum = i;      /* Gigabit port number from 0-3 */
-
-                netdev->open = netxen_nic_open;
-                netdev->stop = netxen_nic_close;
-                netdev->hard_start_xmit = netxen_nic_xmit_frame;
-                netdev->get_stats = netxen_nic_get_stats;
-                netdev->set_multicast_list = netxen_nic_set_multi;
-                netdev->set_mac_address = netxen_nic_set_mac;
-                netdev->change_mtu = netxen_nic_change_mtu;
-                netdev->tx_timeout = netxen_tx_timeout;
-                netdev->watchdog_timeo = HZ;
-
-                netxen_nic_change_mtu(netdev, netdev->mtu);
-
-                SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
-                netdev->poll = netxen_nic_poll;
-                netdev->weight = NETXEN_NETDEV_WEIGHT;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-                netdev->poll_controller = netxen_nic_poll_controller;
-#endif
-                /* ScatterGather support */
-                netdev->features = NETIF_F_SG;
-                netdev->features |= NETIF_F_IP_CSUM;
-                netdev->features |= NETIF_F_TSO;
-
-                if (pci_using_dac)
-                        netdev->features |= NETIF_F_HIGHDMA;
-
-                if (valid_mac) {
-                        unsigned char *p = (unsigned char *)&mac_addr[i];
-                        netdev->dev_addr[0] = *(p + 5);
-                        netdev->dev_addr[1] = *(p + 4);
-                        netdev->dev_addr[2] = *(p + 3);
-                        netdev->dev_addr[3] = *(p + 2);
-                        netdev->dev_addr[4] = *(p + 1);
-                        netdev->dev_addr[5] = *(p + 0);
-
-                        memcpy(netdev->perm_addr, netdev->dev_addr,
-                               netdev->addr_len);
-                        if (!is_valid_ether_addr(netdev->perm_addr)) {
-                                printk(KERN_ERR "%s: Bad MAC address "
-                                       "%02x:%02x:%02x:%02x:%02x:%02x.\n",
-                                       netxen_nic_driver_name,
-                                       netdev->dev_addr[0],
-                                       netdev->dev_addr[1],
-                                       netdev->dev_addr[2],
-                                       netdev->dev_addr[3],
-                                       netdev->dev_addr[4],
-                                       netdev->dev_addr[5]);
-                        } else {
-                                if (adapter->macaddr_set)
-                                        adapter->macaddr_set(port,
-                                                             netdev->dev_addr);
-                        }
-                }
-                INIT_WORK(&port->tx_timeout_task, netxen_tx_timeout_task);
-                netif_carrier_off(netdev);
-                netif_stop_queue(netdev);
+        if (netxen_probe_flag == 0) {
+                /* Unlock the HW, prompting the boot sequence */
+                writel(1,
+                        NETXEN_CRB_NORMALIZE(adapter,
+                                NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
+                /* Handshake with the card before we register the devices. */
+                netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
+        }
 
-                if ((err = register_netdev(netdev))) {
-                        printk(KERN_ERR "%s: register_netdev failed port #%d"
-                               " aborting\n", netxen_nic_driver_name, i + 1);
-                        err = -EIO;
-                        free_netdev(netdev);
-                        goto err_out_free_dev;
-                }
-                adapter->port_count++;
-                adapter->port[i] = port;
+        if(netxen_probe_flag == 0) {
+                writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
+                netxen_pinit_from_rom(adapter, 0);
+                udelay(500);
+                netxen_load_firmware(adapter);
+                netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
         }
-        writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
-        netxen_pinit_from_rom(adapter, 0);
-        udelay(500);
-        netxen_load_firmware(adapter);
-        netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
         /*
          * delay a while to ensure that the Pegs are up & running.
          * Otherwise, we might see some flaky behaviour.
          */
         udelay(100);
+        INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
+        netif_carrier_off(netdev);
+        netif_stop_queue(netdev);
+
+        if((err = register_netdev(netdev)))
+                DPRINTK(1, ERR, "register_netdev failed port #%d"
+                                " aborting\n", i+1);
 
         switch (adapter->ahw.board_type) {
-        case NETXEN_NIC_GBE:
-                printk("%s: QUAD GbE board initialized\n",
-                       netxen_nic_driver_name);
-                break;
+                case NETXEN_NIC_GBE:
+                        printk(KERN_INFO "%s: QUAD GbE board initialized\n",
+                               netxen_nic_driver_name);
+                        break;
 
-        case NETXEN_NIC_XGBE:
-                printk("%s: XGbE board initialized\n", netxen_nic_driver_name);
-                break;
+                case NETXEN_NIC_XGBE:
+                        printk(KERN_INFO "%s: XGbE board initialized\n", 
+                                        netxen_nic_driver_name);
+                        break;
         }
 
         adapter->driver_mismatch = 0;
+        if(netxen_probe_flag == 0)
+                netxen_probe_flag ++;
 
         return 0;
 
       err_out_free_dev:
         if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
                 pci_disable_msi(pdev);
-        for (i = 0; i < adapter->port_count; i++) {
-                port = adapter->port[i];
-                if ((port) && (port->netdev)) {
-                        unregister_netdev(port->netdev);
-                        free_netdev(port->netdev);
-                }
-        }
+
+        unregister_netdev(adapter->netdev);
+        free_netdev(adapter->netdev);
 
         netxen_free_adapter_offload(adapter);
 
@@ -491,7 +538,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         pci_set_drvdata(pdev, NULL);
         kfree(adapter);
 
-      err_out_dbunmap:
         if (db_ptr)
                 iounmap(db_ptr);
 
@@ -513,35 +559,32 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 static void __devexit netxen_nic_remove(struct pci_dev *pdev)
 {
         struct netxen_adapter *adapter;
-        struct netxen_port *port;
+        struct net_device *netdev;
         struct netxen_rx_buffer *buffer;
         struct netxen_recv_context *recv_ctx;
         struct netxen_rcv_desc_ctx *rcv_desc;
         int i;
         int ctxid, ring;
 
-        adapter = pci_get_drvdata(pdev);
+        netdev = pci_get_drvdata(pdev);
+        adapter = netdev_priv(netdev);
         if (adapter == NULL)
                 return;
 
+        if (adapter->stop_port)
+                adapter->stop_port(adapter);
+
         if (adapter->irq)
                 free_irq(adapter->irq, adapter);
-        netxen_nic_stop_all_ports(adapter);
         /* leave the hw in the same state as reboot */
         writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
         netxen_pinit_from_rom(adapter, 0);
-        udelay(500);
         netxen_load_firmware(adapter);
         netxen_free_adapter_offload(adapter);
 
-        mdelay(1000);           /* Delay for a while to drain the DMA engines */
-        for (i = 0; i < adapter->port_count; i++) {
-                port = adapter->port[i];
-                if ((port) && (port->netdev)) {
-                        unregister_netdev(port->netdev);
-                        free_netdev(port->netdev);
-                }
-        }
+        udelay(500);
+        unregister_netdev(netdev);
+        free_netdev(netdev);
 
         if ((adapter->flags & NETXEN_NIC_MSI_ENABLED))
                 pci_disable_msi(pdev);
@@ -585,8 +628,7 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
  */
 static int netxen_nic_open(struct net_device *netdev)
 {
-        struct netxen_port *port = netdev_priv(netdev);
-        struct netxen_adapter *adapter = port->adapter;
+        struct netxen_adapter *adapter = (struct netxen_adapter *)netdev->priv;
         int err = 0;
         int ctx, ring;
 
@@ -610,9 +652,9 @@ static int netxen_nic_open(struct net_device *netdev)
                         return err;
                 }
                 if (adapter->init_port
-                    && adapter->init_port(adapter, port->portnum) != 0) {
+                    && adapter->init_port(adapter, adapter->portnum) != 0) {
                         printk(KERN_ERR "%s: Failed to initialize port %d\n",
-                               netxen_nic_driver_name, port->portnum);
+                               netxen_nic_driver_name, adapter->portnum);
                         netxen_free_hw_resources(adapter);
                         return -EIO;
                 }
@@ -632,23 +674,20 @@ static int netxen_nic_open(struct net_device *netdev)
 
                 adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
         }
-        adapter->active_ports++;
-        if (adapter->active_ports == 1) {
-                if (!adapter->driver_mismatch)
-                        mod_timer(&adapter->watchdog_timer, jiffies);
+        if (!adapter->driver_mismatch)
+                mod_timer(&adapter->watchdog_timer, jiffies);
 
-                netxen_nic_enable_int(adapter);
-        }
+        netxen_nic_enable_int(adapter);
 
         /* Done here again so that even if phantom sw overwrote it,
          * we set it */
         if (adapter->macaddr_set)
-                adapter->macaddr_set(port, netdev->dev_addr);
-        netxen_nic_set_link_parameters(port);
+                adapter->macaddr_set(adapter, netdev->dev_addr);
+        netxen_nic_set_link_parameters(adapter);
 
         netxen_nic_set_multi(netdev);
         if (adapter->set_mtu)
-                adapter->set_mtu(port, netdev->mtu);
+                adapter->set_mtu(adapter, netdev->mtu);
 
         if (!adapter->driver_mismatch)
                 netif_start_queue(netdev);
@@ -661,8 +700,7 @@ static int netxen_nic_open(struct net_device *netdev)
  */
 static int netxen_nic_close(struct net_device *netdev)
 {
-        struct netxen_port *port = netdev_priv(netdev);
-        struct netxen_adapter *adapter = port->adapter;
+        struct netxen_adapter *adapter = netdev_priv(netdev);
         int i, j;
         struct netxen_cmd_buffer *cmd_buff;
         struct netxen_skb_frag *buffrag;
@@ -670,47 +708,43 @@ static int netxen_nic_close(struct net_device *netdev)
         netif_carrier_off(netdev);
         netif_stop_queue(netdev);
 
-        adapter->active_ports--;
-
-        if (!adapter->active_ports) {
-                netxen_nic_disable_int(adapter);
-                cmd_buff = adapter->cmd_buf_arr;
-                for (i = 0; i < adapter->max_tx_desc_count; i++) {
-                        buffrag = cmd_buff->frag_array;
+        netxen_nic_disable_int(adapter);
+        if (adapter->irq)
+                free_irq(adapter->irq, adapter);
+        
+        cmd_buff = adapter->cmd_buf_arr;
+        for (i = 0; i < adapter->max_tx_desc_count; i++) {
+                buffrag = cmd_buff->frag_array;
+                if (buffrag->dma) {
+                        pci_unmap_single(adapter->pdev, buffrag->dma,
+                                         buffrag->length, PCI_DMA_TODEVICE);
+                        buffrag->dma = (u64) NULL;
+                }
+                for (j = 0; j < cmd_buff->frag_count; j++) {
+                        buffrag++;
                         if (buffrag->dma) {
-                                pci_unmap_single(port->pdev, buffrag->dma,
-                                                 buffrag->length,
-                                                 PCI_DMA_TODEVICE);
+                                pci_unmap_page(adapter->pdev, buffrag->dma,
+                                               buffrag->length, 
+                                               PCI_DMA_TODEVICE);
                                 buffrag->dma = (u64) NULL;
                         }
-                        for (j = 0; j < cmd_buff->frag_count; j++) {
-                                buffrag++;
-                                if (buffrag->dma) {
-                                        pci_unmap_page(port->pdev,
-                                                       buffrag->dma,
-                                                       buffrag->length,
-                                                       PCI_DMA_TODEVICE);
-                                        buffrag->dma = (u64) NULL;
-                                }
-                        }
-                        /* Free the skb we received in netxen_nic_xmit_frame */
-                        if (cmd_buff->skb) {
-                                dev_kfree_skb_any(cmd_buff->skb);
-                                cmd_buff->skb = NULL;
-                        }
-                        cmd_buff++;
                 }
-                FLUSH_SCHEDULED_WORK();
-                del_timer_sync(&adapter->watchdog_timer);
+                /* Free the skb we received in netxen_nic_xmit_frame */
+                if (cmd_buff->skb) {
+                        dev_kfree_skb_any(cmd_buff->skb);
+                        cmd_buff->skb = NULL;
+                }
+                cmd_buff++;
         }
+        FLUSH_SCHEDULED_WORK();
+        del_timer_sync(&adapter->watchdog_timer);
 
         return 0;
 }
 
 static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 {
-        struct netxen_port *port = netdev_priv(netdev);
-        struct netxen_adapter *adapter = port->adapter;
+        struct netxen_adapter *adapter = netdev_priv(netdev);
         struct netxen_hardware_context *hw = &adapter->ahw;
         unsigned int first_seg_len = skb->len - skb->data_len;
         struct netxen_skb_frag *buffrag;
@@ -728,12 +762,12 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         u32 last_cmd_consumer = 0;
         int no_of_desc;
 
-        port->stats.xmitcalled++;
+        adapter->stats.xmitcalled++;
         frag_count = skb_shinfo(skb)->nr_frags + 1;
 
         if (unlikely(skb->len <= 0)) {
                 dev_kfree_skb_any(skb);
-                port->stats.badskblen++;
+                adapter->stats.badskblen++;
                 return NETDEV_TX_OK;
         }
 
@@ -742,7 +776,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                        "too large, can handle only %d frags\n",
                        netxen_nic_driver_name, netdev->name,
                        frag_count, MAX_BUFFERS_PER_CMD);
-                port->stats.txdropped++;
+                adapter->stats.txdropped++;
                 if ((++dropped_packet & 0xff) == 0xff)
                         printk("%s: %s droppped packets = %d\n",
                                netxen_nic_driver_name, netdev->name,
@@ -759,7 +793,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
          */
       retry_getting_window:
         spin_lock_bh(&adapter->tx_lock);
-        if (adapter->total_threads == MAX_XMIT_PRODUCERS) {
+        if (adapter->total_threads >= MAX_XMIT_PRODUCERS) {
                 spin_unlock_bh(&adapter->tx_lock);
                 /*
                  * Yield CPU
@@ -792,15 +826,8 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         if ((k + no_of_desc) >=
             ((last_cmd_consumer <= k) ? last_cmd_consumer + max_tx_desc_count :
              last_cmd_consumer)) {
-                port->stats.nocmddescriptor++;
-                DPRINTK(ERR, "No command descriptors available,"
-                        " producer = %d, consumer = %d count=%llu,"
-                        " dropping packet\n", producer,
-                        adapter->last_cmd_consumer,
-                        port->stats.nocmddescriptor);
-
                 netif_stop_queue(netdev);
-                port->flags |= NETXEN_NETDEV_STATUS;
+                adapter->flags |= NETXEN_NETDEV_STATUS;
                 spin_unlock_bh(&adapter->tx_lock);
                 return NETDEV_TX_BUSY;
         }
@@ -828,16 +855,16 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         pbuf->skb = skb;
         pbuf->cmd = TX_ETHER_PKT;
         pbuf->frag_count = frag_count;
-        pbuf->port = port->portnum;
+        pbuf->port = adapter->portnum;
         buffrag = &pbuf->frag_array[0];
-        buffrag->dma = pci_map_single(port->pdev, skb->data, first_seg_len,
+        buffrag->dma = pci_map_single(adapter->pdev, skb->data, first_seg_len,
                                       PCI_DMA_TODEVICE);
         buffrag->length = first_seg_len;
         netxen_set_cmd_desc_totallength(hwdesc, skb->len);
         netxen_set_cmd_desc_num_of_buff(hwdesc, frag_count);
         netxen_set_cmd_desc_opcode(hwdesc, TX_ETHER_PKT);
 
-        netxen_set_cmd_desc_port(hwdesc, port->portnum);
+        netxen_set_cmd_desc_port(hwdesc, adapter->portnum);
         hwdesc->buffer1_length = cpu_to_le16(first_seg_len);
         hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
 
@@ -860,7 +887,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 offset = frag->page_offset;
 
                 temp_len = len;
-                temp_dma = pci_map_page(port->pdev, frag->page, offset,
+                temp_dma = pci_map_page(adapter->pdev, frag->page, offset,
                                         len, PCI_DMA_TODEVICE);
 
                 buffrag++;
@@ -928,20 +955,19 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 }
         }
         spin_lock_bh(&adapter->tx_lock);
-        port->stats.txbytes +=
+        adapter->stats.txbytes +=
             netxen_get_cmd_desc_totallength(&hw->cmd_desc_head[saved_producer]);
         /* Code to update the adapter considering how many producer threads
            are currently working */
         if ((--adapter->num_threads) == 0) {
                 /* This is the last thread */
                 u32 crb_producer = adapter->cmd_producer;
-                writel(crb_producer,
-                       NETXEN_CRB_NORMALIZE(adapter, CRB_CMD_PRODUCER_OFFSET));
+                netxen_nic_update_cmd_producer(adapter, crb_producer);
                 wmb();
                 adapter->total_threads = 0;
         }
 
-        port->stats.xmitfinished++;
+        adapter->stats.xmitfinished++;
         spin_unlock_bh(&adapter->tx_lock);
 
         netdev->trans_start = jiffies;
@@ -961,25 +987,25 @@ static void netxen_watchdog(unsigned long v)
 
 static void netxen_tx_timeout(struct net_device *netdev)
 {
-        struct netxen_port *port = (struct netxen_port *)netdev_priv(netdev);
-
-        SCHEDULE_WORK(&port->tx_timeout_task);
+        struct netxen_adapter *adapter = (struct netxen_adapter *)
+                                                netdev_priv(netdev);
+        SCHEDULE_WORK(&adapter->tx_timeout_task);
 }
 
 static void netxen_tx_timeout_task(struct work_struct *work)
 {
-        struct netxen_port *port =
-                container_of(work, struct netxen_port, tx_timeout_task);
-        struct net_device *netdev = port->netdev;
+        struct netxen_adapter *adapter = 
+                container_of(work, struct netxen_adapter, tx_timeout_task);
+        struct net_device *netdev = adapter->netdev;
         unsigned long flags;
 
         printk(KERN_ERR "%s %s: transmit timeout, resetting.\n",
                netxen_nic_driver_name, netdev->name);
 
-        spin_lock_irqsave(&port->adapter->lock, flags);
+        spin_lock_irqsave(&adapter->lock, flags);
         netxen_nic_close(netdev);
         netxen_nic_open(netdev);
-        spin_unlock_irqrestore(&port->adapter->lock, flags);
+        spin_unlock_irqrestore(&adapter->lock, flags);
         netdev->trans_start = jiffies;
         netif_wake_queue(netdev);
 }
@@ -991,16 +1017,14 @@ netxen_handle_int(struct netxen_adapter *adapter, struct net_device *netdev)
 
         DPRINTK(INFO, "Entered handle ISR\n");
 
-        adapter->stats.ints++;
-
         if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
                 int count = 0;
                 u32 mask;
-                mask = readl(pci_base_offset(adapter, ISR_INT_VECTOR));
-                if ((mask & 0x80) == 0) {
-                        /* not our interrupt */
+                u32 our_int = 0;
+                our_int = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
+                /* not our interrupt */
+                if ((our_int & (0x80 << adapter->portnum)) == 0)
                         return ret;
-                }
                 netxen_nic_disable_int(adapter);
                 /* Window = 0 or 1 */
                 do {
@@ -1012,7 +1036,6 @@ netxen_handle_int(struct netxen_adapter *adapter, struct net_device *netdev)
                         printk("Could not disable interrupt completely\n");
 
         }
-        adapter->stats.hostints++;
 
         if (netxen_nic_rx_has_work(adapter) || netxen_nic_tx_has_work(adapter)) {
                 if (netif_rx_schedule_prep(netdev)) {
@@ -1046,33 +1069,24 @@ netxen_handle_int(struct netxen_adapter *adapter, struct net_device *netdev)
 irqreturn_t netxen_intr(int irq, void *data)
 {
         struct netxen_adapter *adapter;
-        struct netxen_port *port;
         struct net_device *netdev;
-        int i;
 
         if (unlikely(!irq)) {
                 return IRQ_NONE;        /* Not our interrupt */
         }
 
         adapter = (struct netxen_adapter *)data;
-        for (i = 0; i < adapter->ahw.max_ports; i++) {
-                port = adapter->port[i];
-                netdev = port->netdev;
-
-                /* process our status queue (for all 4 ports) */
-                if (netif_running(netdev)) {
-                        netxen_handle_int(adapter, netdev);
-                        break;
-                }
-        }
+        netdev  = adapter->netdev;
+        /* process our status queue (for all 4 ports) */
+        if (netif_running(netdev))
+                netxen_handle_int(adapter, netdev);
 
         return IRQ_HANDLED;
 }
 
 static int netxen_nic_poll(struct net_device *netdev, int *budget)
 {
-        struct netxen_port *port = (struct netxen_port *)netdev_priv(netdev);
-        struct netxen_adapter *adapter = port->adapter;
+        struct netxen_adapter *adapter = netdev_priv(netdev);
         int work_to_do = min(*budget, netdev->quota);
         int done = 1;
         int ctx;
@@ -1080,7 +1094,6 @@ static int netxen_nic_poll(struct net_device *netdev, int *budget)
         int work_done = 0;
 
         DPRINTK(INFO, "polling for %d descriptors\n", *budget);
-        port->stats.polled++;
 
         work_done = 0;
         for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
@@ -1124,8 +1137,7 @@ static int netxen_nic_poll(struct net_device *netdev, int *budget)
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void netxen_nic_poll_controller(struct net_device *netdev)
 {
-        struct netxen_port *port = netdev_priv(netdev);
-        struct netxen_adapter *adapter = port->adapter;
+        struct netxen_adapter *adapter = netdev_priv(netdev);
         disable_irq(adapter->irq);
         netxen_intr(adapter->irq, adapter);
         enable_irq(adapter->irq);