Merge tag 'pci-v4.11-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaa...

[mirror_ubuntu-artful-kernel.git] / drivers / net / ethernet / amd / xgbe / xgbe-pci.c

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-pci.c b/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
index c2730f15bd8b62d2e0487e4eef11f6518a476c39..38392a5207258e707c7aac9f638fb592ad2bd890 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
@@ -122,104 +122,40 @@
 #include "xgbe.h"
 #include "xgbe-common.h"
 
-static int xgbe_config_msi(struct xgbe_prv_data *pdata)
+static int xgbe_config_multi_msi(struct xgbe_prv_data *pdata)
 {
-       unsigned int msi_count;
+       unsigned int vector_count;
        unsigned int i, j;
        int ret;
 
-       msi_count = XGBE_MSIX_BASE_COUNT;
-       msi_count += max(pdata->rx_ring_count,
-                        pdata->tx_ring_count);
-       msi_count = roundup_pow_of_two(msi_count);
+       vector_count = XGBE_MSI_BASE_COUNT;
+       vector_count += max(pdata->rx_ring_count,
+                           pdata->tx_ring_count);
 
-       ret = pci_enable_msi_exact(pdata->pcidev, msi_count);
+       ret = pci_alloc_irq_vectors(pdata->pcidev, XGBE_MSI_MIN_COUNT,
+                                   vector_count, PCI_IRQ_MSI | PCI_IRQ_MSIX);
        if (ret < 0) {
-               dev_info(pdata->dev, "MSI request for %u interrupts failed\n",
-                        msi_count);
-
-               ret = pci_enable_msi(pdata->pcidev);
-               if (ret < 0) {
-                       dev_info(pdata->dev, "MSI enablement failed\n");
-                       return ret;
-               }
-
-               msi_count = 1;
-       }
-
-       pdata->irq_count = msi_count;
-
-       pdata->dev_irq = pdata->pcidev->irq;
-
-       if (msi_count > 1) {
-               pdata->ecc_irq = pdata->pcidev->irq + 1;
-               pdata->i2c_irq = pdata->pcidev->irq + 2;
-               pdata->an_irq = pdata->pcidev->irq + 3;
-
-               for (i = XGBE_MSIX_BASE_COUNT, j = 0;
-                    (i < msi_count) && (j < XGBE_MAX_DMA_CHANNELS);
-                    i++, j++)
-                       pdata->channel_irq[j] = pdata->pcidev->irq + i;
-               pdata->channel_irq_count = j;
-
-               pdata->per_channel_irq = 1;
-               pdata->channel_irq_mode = XGBE_IRQ_MODE_LEVEL;
-       } else {
-               pdata->ecc_irq = pdata->pcidev->irq;
-               pdata->i2c_irq = pdata->pcidev->irq;
-               pdata->an_irq = pdata->pcidev->irq;
-       }
-
-       if (netif_msg_probe(pdata))
-               dev_dbg(pdata->dev, "MSI interrupts enabled\n");
-
-       return 0;
-}
-
-static int xgbe_config_msix(struct xgbe_prv_data *pdata)
-{
-       unsigned int msix_count;
-       unsigned int i, j;
-       int ret;
-
-       msix_count = XGBE_MSIX_BASE_COUNT;
-       msix_count += max(pdata->rx_ring_count,
-                         pdata->tx_ring_count);
-
-       pdata->msix_entries = devm_kcalloc(pdata->dev, msix_count,
-                                          sizeof(struct msix_entry),
-                                          GFP_KERNEL);
-       if (!pdata->msix_entries)
-               return -ENOMEM;
-
-       for (i = 0; i < msix_count; i++)
-               pdata->msix_entries[i].entry = i;
-
-       ret = pci_enable_msix_range(pdata->pcidev, pdata->msix_entries,
-                                   XGBE_MSIX_MIN_COUNT, msix_count);
-       if (ret < 0) {
-               dev_info(pdata->dev, "MSI-X enablement failed\n");
-               devm_kfree(pdata->dev, pdata->msix_entries);
-               pdata->msix_entries = NULL;
+               dev_info(pdata->dev, "multi MSI/MSI-X enablement failed\n");
                return ret;
        }
 
        pdata->irq_count = ret;
 
-       pdata->dev_irq = pdata->msix_entries[0].vector;
-       pdata->ecc_irq = pdata->msix_entries[1].vector;
-       pdata->i2c_irq = pdata->msix_entries[2].vector;
-       pdata->an_irq = pdata->msix_entries[3].vector;
+       pdata->dev_irq = pci_irq_vector(pdata->pcidev, 0);
+       pdata->ecc_irq = pci_irq_vector(pdata->pcidev, 1);
+       pdata->i2c_irq = pci_irq_vector(pdata->pcidev, 2);
+       pdata->an_irq = pci_irq_vector(pdata->pcidev, 3);
 
-       for (i = XGBE_MSIX_BASE_COUNT, j = 0; i < ret; i++, j++)
-               pdata->channel_irq[j] = pdata->msix_entries[i].vector;
+       for (i = XGBE_MSI_BASE_COUNT, j = 0; i < ret; i++, j++)
+               pdata->channel_irq[j] = pci_irq_vector(pdata->pcidev, i);
        pdata->channel_irq_count = j;
 
        pdata->per_channel_irq = 1;
        pdata->channel_irq_mode = XGBE_IRQ_MODE_LEVEL;
 
        if (netif_msg_probe(pdata))
-               dev_dbg(pdata->dev, "MSI-X interrupts enabled\n");
+               dev_dbg(pdata->dev, "multi %s interrupts enabled\n",
+                       pdata->pcidev->msix_enabled ? "MSI-X" : "MSI");
 
        return 0;
 }
@@ -228,21 +164,28 @@ static int xgbe_config_irqs(struct xgbe_prv_data *pdata)
 {
        int ret;
 
-       ret = xgbe_config_msix(pdata);
+       ret = xgbe_config_multi_msi(pdata);
        if (!ret)
                goto out;
 
-       ret = xgbe_config_msi(pdata);
-       if (!ret)
-               goto out;
+       ret = pci_alloc_irq_vectors(pdata->pcidev, 1, 1,
+                                   PCI_IRQ_LEGACY | PCI_IRQ_MSI);
+       if (ret < 0) {
+               dev_info(pdata->dev, "single IRQ enablement failed\n");
+               return ret;
+       }
 
        pdata->irq_count = 1;
-       pdata->irq_shared = 1;
+       pdata->channel_irq_count = 1;
+
+       pdata->dev_irq = pci_irq_vector(pdata->pcidev, 0);
+       pdata->ecc_irq = pci_irq_vector(pdata->pcidev, 0);
+       pdata->i2c_irq = pci_irq_vector(pdata->pcidev, 0);
+       pdata->an_irq = pci_irq_vector(pdata->pcidev, 0);
 
-       pdata->dev_irq = pdata->pcidev->irq;
-       pdata->ecc_irq = pdata->pcidev->irq;
-       pdata->i2c_irq = pdata->pcidev->irq;
-       pdata->an_irq = pdata->pcidev->irq;
+       if (netif_msg_probe(pdata))
+               dev_dbg(pdata->dev, "single %s interrupt enabled\n",
+                       pdata->pcidev->msi_enabled ?  "MSI" : "legacy");
 
 out:
        if (netif_msg_probe(pdata)) {
@@ -425,12 +368,15 @@ static int xgbe_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
        /* Configure the netdev resource */
        ret = xgbe_config_netdev(pdata);
        if (ret)
-               goto err_pci_enable;
+               goto err_irq_vectors;
 
        netdev_notice(pdata->netdev, "net device enabled\n");
 
        return 0;
 
+err_irq_vectors:
+       pci_free_irq_vectors(pdata->pcidev);
+
 err_pci_enable:
        xgbe_free_pdata(pdata);
 
@@ -446,6 +392,8 @@ static void xgbe_pci_remove(struct pci_dev *pdev)
 
        xgbe_deconfig_netdev(pdata);
 
+       pci_free_irq_vectors(pdata->pcidev);
+
        xgbe_free_pdata(pdata);
 }