Merge tag 'omap-for-v3.16/l3-noc-signed' of git://git.kernel.org/pub/scm/linux/kernel...

[firefly-linux-kernel-4.4.55.git] / drivers / ntb / ntb_hw.c

diff --git a/drivers/ntb/ntb_hw.c b/drivers/ntb/ntb_hw.c
index eba1ed58471d3cba0fe1b3c4ea2a1c514ff0a3ec..372e08c4ffefb76852e4d640e6936f3529e8c215 100644 (file)
--- a/drivers/ntb/ntb_hw.c
+++ b/drivers/ntb/ntb_hw.c
@@ -1080,111 +1080,131 @@ static irqreturn_t ntb_interrupt(int irq, void *dev)
        return IRQ_HANDLED;
 }
 
-static int ntb_setup_msix(struct ntb_device *ndev)
+static int ntb_setup_snb_msix(struct ntb_device *ndev, int msix_entries)
 {
        struct pci_dev *pdev = ndev->pdev;
        struct msix_entry *msix;
-       int msix_entries;
        int rc, i;
-       u16 val;
 
-       if (!pdev->msix_cap) {
-               rc = -EIO;
-               goto err;
-       }
+       if (msix_entries < ndev->limits.msix_cnt)
+               return -ENOSPC;
 
-       rc = pci_read_config_word(pdev, pdev->msix_cap + PCI_MSIX_FLAGS, &val);
-       if (rc)
-               goto err;
+       rc = pci_enable_msix_exact(pdev, ndev->msix_entries, msix_entries);
+       if (rc < 0)
+               return rc;
 
-       msix_entries = msix_table_size(val);
-       if (msix_entries > ndev->limits.msix_cnt) {
-               rc = -EINVAL;
-               goto err;
+       for (i = 0; i < msix_entries; i++) {
+               msix = &ndev->msix_entries[i];
+               WARN_ON(!msix->vector);
+
+               if (i == msix_entries - 1) {
+                       rc = request_irq(msix->vector,
+                                        xeon_event_msix_irq, 0,
+                                        "ntb-event-msix", ndev);
+                       if (rc)
+                               goto err;
+               } else {
+                       rc = request_irq(msix->vector,
+                                        xeon_callback_msix_irq, 0,
+                                        "ntb-callback-msix",
+                                        &ndev->db_cb[i]);
+                       if (rc)
+                               goto err;
+               }
        }
 
-       ndev->msix_entries = kmalloc(sizeof(struct msix_entry) * msix_entries,
-                                    GFP_KERNEL);
-       if (!ndev->msix_entries) {
-               rc = -ENOMEM;
-               goto err;
+       ndev->num_msix = msix_entries;
+       ndev->max_cbs = msix_entries - 1;
+
+       return 0;
+
+err:
+       while (--i >= 0) {
+               /* Code never reaches here for entry nr 'ndev->num_msix - 1' */
+               msix = &ndev->msix_entries[i];
+               free_irq(msix->vector, &ndev->db_cb[i]);
        }
 
-       for (i = 0; i < msix_entries; i++)
-               ndev->msix_entries[i].entry = i;
+       pci_disable_msix(pdev);
+       ndev->num_msix = 0;
 
-       rc = pci_enable_msix(pdev, ndev->msix_entries, msix_entries);
-       if (rc < 0)
-               goto err1;
-       if (rc > 0) {
-               /* On SNB, the link interrupt is always tied to 4th vector.  If
-                * we can't get all 4, then we can't use MSI-X.
-                */
-               if (ndev->hw_type != BWD_HW) {
-                       rc = -EIO;
-                       goto err1;
-               }
+       return rc;
+}
 
-               dev_warn(&pdev->dev,
-                        "Only %d MSI-X vectors.  Limiting the number of queues to that number.\n",
-                        rc);
-               msix_entries = rc;
+static int ntb_setup_bwd_msix(struct ntb_device *ndev, int msix_entries)
+{
+       struct pci_dev *pdev = ndev->pdev;
+       struct msix_entry *msix;
+       int rc, i;
 
-               rc = pci_enable_msix(pdev, ndev->msix_entries, msix_entries);
-               if (rc)
-                       goto err1;
-       }
+       msix_entries = pci_enable_msix_range(pdev, ndev->msix_entries,
+                                            1, msix_entries);
+       if (msix_entries < 0)
+               return msix_entries;
 
        for (i = 0; i < msix_entries; i++) {
                msix = &ndev->msix_entries[i];
                WARN_ON(!msix->vector);
 
-               /* Use the last MSI-X vector for Link status */
-               if (ndev->hw_type == BWD_HW) {
-                       rc = request_irq(msix->vector, bwd_callback_msix_irq, 0,
-                                        "ntb-callback-msix", &ndev->db_cb[i]);
-                       if (rc)
-                               goto err2;
-               } else {
-                       if (i == msix_entries - 1) {
-                               rc = request_irq(msix->vector,
-                                                xeon_event_msix_irq, 0,
-                                                "ntb-event-msix", ndev);
-                               if (rc)
-                                       goto err2;
-                       } else {
-                               rc = request_irq(msix->vector,
-                                                xeon_callback_msix_irq, 0,
-                                                "ntb-callback-msix",
-                                                &ndev->db_cb[i]);
-                               if (rc)
-                                       goto err2;
-                       }
-               }
+               rc = request_irq(msix->vector, bwd_callback_msix_irq, 0,
+                                "ntb-callback-msix", &ndev->db_cb[i]);
+               if (rc)
+                       goto err;
        }
 
        ndev->num_msix = msix_entries;
+       ndev->max_cbs = msix_entries;
+
+       return 0;
+
+err:
+       while (--i >= 0)
+               free_irq(msix->vector, &ndev->db_cb[i]);
+
+       pci_disable_msix(pdev);
+       ndev->num_msix = 0;
+
+       return rc;
+}
+
+static int ntb_setup_msix(struct ntb_device *ndev)
+{
+       struct pci_dev *pdev = ndev->pdev;
+       int msix_entries;
+       int rc, i;
+
+       msix_entries = pci_msix_vec_count(pdev);
+       if (msix_entries < 0) {
+               rc = msix_entries;
+               goto err;
+       } else if (msix_entries > ndev->limits.msix_cnt) {
+               rc = -EINVAL;
+               goto err;
+       }
+
+       ndev->msix_entries = kmalloc(sizeof(struct msix_entry) * msix_entries,
+                                    GFP_KERNEL);
+       if (!ndev->msix_entries) {
+               rc = -ENOMEM;
+               goto err;
+       }
+
+       for (i = 0; i < msix_entries; i++)
+               ndev->msix_entries[i].entry = i;
+
        if (ndev->hw_type == BWD_HW)
-               ndev->max_cbs = msix_entries;
+               rc = ntb_setup_bwd_msix(ndev, msix_entries);
        else
-               ndev->max_cbs = msix_entries - 1;
+               rc = ntb_setup_snb_msix(ndev, msix_entries);
+       if (rc)
+               goto err1;
 
        return 0;
 
-err2:
-       while (--i >= 0) {
-               msix = &ndev->msix_entries[i];
-               if (ndev->hw_type != BWD_HW && i == ndev->num_msix - 1)
-                       free_irq(msix->vector, ndev);
-               else
-                       free_irq(msix->vector, &ndev->db_cb[i]);
-       }
-       pci_disable_msix(pdev);
 err1:
        kfree(ndev->msix_entries);
-       dev_err(&pdev->dev, "Error allocating MSI-X interrupt\n");
 err:
-       ndev->num_msix = 0;
+       dev_err(&pdev->dev, "Error allocating MSI-X interrupt\n");
        return rc;
 }