1 files changed, 64 insertions, 76 deletions

diff --git a/drivers/net/vxge/vxge-main.c b/drivers/net/vxge/vxge-main.c
index 068d7a9d3e36..ba6d0da78c30 100644
--- a/drivers/net/vxge/vxge-main.c
+++ b/drivers/net/vxge/vxge-main.c
@@ -43,6 +43,7 @@
 
 #include <linux/if_vlan.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/tcp.h>
 #include <net/ip.h>
 #include <linux/netdevice.h>
@@ -54,7 +55,7 @@ MODULE_LICENSE("Dual BSD/GPL");
 MODULE_DESCRIPTION("Neterion's X3100 Series 10GbE PCIe I/O"
         "Virtualized Server Adapter");
 
-static struct pci_device_id vxge_id_table[] __devinitdata = {
+static DEFINE_PCI_DEVICE_TABLE(vxge_id_table) = {
         {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_TITAN_WIN, PCI_ANY_ID,
         PCI_ANY_ID},
         {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_TITAN_UNI, PCI_ANY_ID,
@@ -310,7 +311,7 @@ static int vxge_rx_map(void *dtrh, struct vxge_ring *ring)
         dma_addr = pci_map_single(ring->pdev, rx_priv->skb_data,
                                 rx_priv->data_size, PCI_DMA_FROMDEVICE);
 
-        if (dma_addr == 0) {
+        if (unlikely(pci_dma_mapping_error(ring->pdev, dma_addr))) {
                 ring->stats.pci_map_fail++;
                 return -EIO;
         }
@@ -1178,11 +1179,11 @@ static void vxge_set_multicast(struct net_device *dev)
 
         memset(&mac_info, 0, sizeof(struct macInfo));
         /* Update individual M_CAST address list */
-        if ((!vdev->all_multi_flg) && dev->mc_count) {
+        if ((!vdev->all_multi_flg) && netdev_mc_count(dev)) {
 
                 mcast_cnt = vdev->vpaths[0].mcast_addr_cnt;
                 list_head = &vdev->vpaths[0].mac_addr_list;
-                if ((dev->mc_count +
+                if ((netdev_mc_count(dev) +
                         (vdev->vpaths[0].mac_addr_cnt - mcast_cnt)) >
                                 vdev->vpaths[0].max_mac_addr_cnt)
                         goto _set_all_mcast;
@@ -1217,9 +1218,7 @@ static void vxge_set_multicast(struct net_device *dev)
                 }
 
                 /* Add new ones */
-                for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
-                        i++, mclist = mclist->next) {
-
+                netdev_for_each_mc_addr(mclist, dev) {
                         memcpy(mac_info.macaddr, mclist->dmi_addr, ETH_ALEN);
                         for (vpath_idx = 0; vpath_idx < vdev->no_of_vpath;
                                         vpath_idx++) {
@@ -2435,7 +2434,6 @@ static int vxge_add_isr(struct vxgedev *vdev)
         int ret = 0;
 #ifdef CONFIG_PCI_MSI
         int vp_idx = 0, intr_idx = 0, intr_cnt = 0, msix_idx = 0, irq_req = 0;
-        u64 function_mode = vdev->config.device_hw_info.function_mode;
         int pci_fun = PCI_FUNC(vdev->pdev->devfn);
 
         if (vdev->config.intr_type == MSI_X)
@@ -2444,20 +2442,9 @@ static int vxge_add_isr(struct vxgedev *vdev)
         if (ret) {
                 vxge_debug_init(VXGE_ERR,
                         "%s: Enabling MSI-X Failed", VXGE_DRIVER_NAME);
-                if ((function_mode == VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION) &&
-                        test_and_set_bit(__VXGE_STATE_CARD_UP,
-                                &driver_config->inta_dev_open))
-                        return VXGE_HW_FAIL;
-                else {
-                        vxge_debug_init(VXGE_ERR,
-                                "%s: Defaulting to INTA", VXGE_DRIVER_NAME);
-                        vdev->config.intr_type = INTA;
-                        vxge_hw_device_set_intr_type(vdev->devh,
-                                VXGE_HW_INTR_MODE_IRQLINE);
-                        vxge_close_vpaths(vdev, 1);
-                        vdev->no_of_vpath = 1;
-                        vdev->stats.vpaths_open = 1;
-                }
+                vxge_debug_init(VXGE_ERR,
+                        "%s: Defaulting to INTA", VXGE_DRIVER_NAME);
+                vdev->config.intr_type = INTA;
         }
 
         if (vdev->config.intr_type == MSI_X) {
@@ -2505,24 +2492,11 @@ static int vxge_add_isr(struct vxgedev *vdev)
                                         "%s: MSIX - %d  Registration failed",
                                         vdev->ndev->name, intr_cnt);
                                 vxge_rem_msix_isr(vdev);
-                                if ((function_mode ==
-                                        VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION) &&
-                                        test_and_set_bit(__VXGE_STATE_CARD_UP,
-                                                &driver_config->inta_dev_open))
-                                        return VXGE_HW_FAIL;
-                                else {
-                                        vxge_hw_device_set_intr_type(
-                                                vdev->devh,
-                                                VXGE_HW_INTR_MODE_IRQLINE);
-                                                vdev->config.intr_type = INTA;
-                                        vxge_debug_init(VXGE_ERR,
-                                                "%s: Defaulting to INTA"
-                                                , vdev->ndev->name);
-                                        vxge_close_vpaths(vdev, 1);
-                                        vdev->no_of_vpath = 1;
-                                        vdev->stats.vpaths_open = 1;
+                                vdev->config.intr_type = INTA;
+                                vxge_debug_init(VXGE_ERR,
+                                        "%s: Defaulting to INTA"
+                                        , vdev->ndev->name);
                                         goto INTA_MODE;
-                                }
                         }
 
                         if (irq_req) {
@@ -2535,9 +2509,9 @@ static int vxge_add_isr(struct vxgedev *vdev)
                         }
 
                         /* Point to next vpath handler */
-                        if (((intr_idx + 1) % VXGE_HW_VPATH_MSIX_ACTIVE == 0)
-                                && (vp_idx < (vdev->no_of_vpath - 1)))
-                                        vp_idx++;
+                        if (((intr_idx + 1) % VXGE_HW_VPATH_MSIX_ACTIVE == 0) &&
+                            (vp_idx < (vdev->no_of_vpath - 1)))
+                                vp_idx++;
                 }
 
                 intr_cnt = vdev->max_vpath_supported * 2;
@@ -2555,23 +2529,11 @@ static int vxge_add_isr(struct vxgedev *vdev)
                                 "%s: MSIX - %d Registration failed",
                                 vdev->ndev->name, intr_cnt);
                         vxge_rem_msix_isr(vdev);
-                        if ((function_mode ==
-                                VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION) &&
-                                test_and_set_bit(__VXGE_STATE_CARD_UP,
-                                                &driver_config->inta_dev_open))
-                                return VXGE_HW_FAIL;
-                        else {
-                                vxge_hw_device_set_intr_type(vdev->devh,
-                                                VXGE_HW_INTR_MODE_IRQLINE);
-                                vdev->config.intr_type = INTA;
-                                vxge_debug_init(VXGE_ERR,
-                                        "%s: Defaulting to INTA",
-                                        vdev->ndev->name);
-                                vxge_close_vpaths(vdev, 1);
-                                vdev->no_of_vpath = 1;
-                                vdev->stats.vpaths_open = 1;
+                        vdev->config.intr_type = INTA;
+                        vxge_debug_init(VXGE_ERR,
+                                "%s: Defaulting to INTA",
+                                vdev->ndev->name);
                                 goto INTA_MODE;
-                        }
                 }
 
                 vxge_hw_vpath_msix_unmask(vdev->vpaths[vp_idx].handle,
@@ -2584,6 +2546,10 @@ INTA_MODE:
         snprintf(vdev->desc[0], VXGE_INTR_STRLEN, "%s:vxge", vdev->ndev->name);
 
         if (vdev->config.intr_type == INTA) {
+                vxge_hw_device_set_intr_type(vdev->devh,
+                        VXGE_HW_INTR_MODE_IRQLINE);
+                vxge_hw_vpath_tti_ci_set(vdev->devh,
+                        vdev->vpaths[0].device_id);
                 ret = request_irq((int) vdev->pdev->irq,
                         vxge_isr_napi,
                         IRQF_SHARED, vdev->desc[0], vdev);
@@ -2688,13 +2654,6 @@ vxge_open(struct net_device *dev)
          * initialized */
         netif_carrier_off(dev);
 
-        /* Check for another device already opn with INTA */
-        if ((function_mode == VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION) &&
-                test_bit(__VXGE_STATE_CARD_UP, &driver_config->inta_dev_open)) {
-                ret = -EPERM;
-                goto out0;
-        }
-
         /* Open VPATHs */
         status = vxge_open_vpaths(vdev);
         if (status != VXGE_HW_OK) {
@@ -2983,7 +2942,6 @@ int do_vxge_close(struct net_device *dev, int do_io)
         vxge_debug_entryexit(VXGE_TRACE,
                 "%s: %s:%d  Exiting...", dev->name, __func__, __LINE__);
 
-        clear_bit(__VXGE_STATE_CARD_UP, &driver_config->inta_dev_open);
         clear_bit(__VXGE_STATE_RESET_CARD, &vdev->state);
 
         return 0;
@@ -3653,11 +3611,12 @@ static int __devinit vxge_config_vpaths(
                 device_config->vp_config[i].fifo.enable =
                                                 VXGE_HW_FIFO_ENABLE;
                 device_config->vp_config[i].fifo.max_frags =
-                                MAX_SKB_FRAGS;
+                                MAX_SKB_FRAGS + 1;
                 device_config->vp_config[i].fifo.memblock_size =
                         VXGE_HW_MIN_FIFO_MEMBLOCK_SIZE;
 
-                txdl_size = MAX_SKB_FRAGS * sizeof(struct vxge_hw_fifo_txd);
+                txdl_size = device_config->vp_config[i].fifo.max_frags *
+                                sizeof(struct vxge_hw_fifo_txd);
                 txdl_per_memblock = VXGE_HW_MIN_FIFO_MEMBLOCK_SIZE / txdl_size;
 
                 device_config->vp_config[i].fifo.fifo_blocks =
@@ -4088,9 +4047,10 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                 driver_config->config_dev_cnt = 0;
                 driver_config->total_dev_cnt = 0;
                 driver_config->g_no_cpus = 0;
-                driver_config->vpath_per_dev = max_config_vpath;
         }
 
+        driver_config->vpath_per_dev = max_config_vpath;
+
         driver_config->total_dev_cnt++;
         if (++driver_config->config_dev_cnt > max_config_dev) {
                 ret = 0;
@@ -4126,21 +4086,21 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                 goto _exit0;
         }
 
-        if (!pci_set_dma_mask(pdev, 0xffffffffffffffffULL)) {
+        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                 vxge_debug_ll_config(VXGE_TRACE,
                         "%s : using 64bit DMA", __func__);
 
                 high_dma = 1;
 
                 if (pci_set_consistent_dma_mask(pdev,
-                                                0xffffffffffffffffULL)) {
+                                                DMA_BIT_MASK(64))) {
                         vxge_debug_init(VXGE_ERR,
                                 "%s : unable to obtain 64bit DMA for "
                                 "consistent allocations", __func__);
                         ret = -ENOMEM;
                         goto _exit1;
                 }
-        } else if (!pci_set_dma_mask(pdev, 0xffffffffUL)) {
+        } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                 vxge_debug_ll_config(VXGE_TRACE,
                         "%s : using 32bit DMA", __func__);
         } else {
@@ -4243,6 +4203,15 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                         goto _exit3;
         }
 
+        /* if FCS stripping is not disabled in MAC fail driver load */
+        if (vxge_hw_vpath_strip_fcs_check(hldev, vpath_mask) != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR,
+                        "%s: FCS stripping is not disabled in MAC"
+                        " failing driver load", VXGE_DRIVER_NAME);
+                ret = -EINVAL;
+                goto _exit4;
+        }
+
         vxge_hw_device_debug_set(hldev, VXGE_ERR, VXGE_COMPONENT_LL);
 
         /* set private device info */
@@ -4327,10 +4296,8 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
         vxge_debug_init(VXGE_TRACE, "%s: Neterion %s Server Adapter",
                 vdev->ndev->name, ll_config.device_hw_info.product_desc);
 
-        vxge_debug_init(VXGE_TRACE,
-                "%s: MAC ADDR: %02X:%02X:%02X:%02X:%02X:%02X",
-                vdev->ndev->name, macaddr[0], macaddr[1], macaddr[2],
-                macaddr[3], macaddr[4], macaddr[5]);
+        vxge_debug_init(VXGE_TRACE, "%s: MAC ADDR: %pM",
+                vdev->ndev->name, macaddr);
 
         vxge_debug_init(VXGE_TRACE, "%s: Link Width x%d",
                 vdev->ndev->name, vxge_hw_device_link_width_get(hldev));
@@ -4387,6 +4354,27 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
         }
 
         kfree(device_config);
+
+        /*
+         * INTA is shared in multi-function mode. This is unlike the INTA
+         * implementation in MR mode, where each VH has its own INTA message.
+         * - INTA is masked (disabled) as long as at least one function sets
+         * its TITAN_MASK_ALL_INT.ALARM bit.
+         * - INTA is unmasked (enabled) when all enabled functions have cleared
+         * their own TITAN_MASK_ALL_INT.ALARM bit.
+         * The TITAN_MASK_ALL_INT ALARM & TRAFFIC bits are cleared on power up.
+         * Though this driver leaves the top level interrupts unmasked while
+         * leaving the required module interrupt bits masked on exit, there
+         * could be a rougue driver around that does not follow this procedure
+         * resulting in a failure to generate interrupts. The following code is
+         * present to prevent such a failure.
+         */
+
+        if (ll_config.device_hw_info.function_mode ==
+                VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION)
+                if (vdev->config.intr_type == INTA)
+                        vxge_hw_device_unmask_all(hldev);
+
         vxge_debug_entryexit(VXGE_TRACE, "%s: %s:%d  Exiting...",
                 vdev->ndev->name, __func__, __LINE__);