Merge tag 'ntb-3.15' of git://github.com/jonmason/ntb

Pull PCIe non-transparent bridge fixes and features from Jon Mason:
 "NTB driver bug fixes to address issues in list traversal, skb leak in
  ntb_netdev, a typo, and a leak of msix entries in the error path.
  Clean ups of the event handling logic, as well as a overall style
  cleanup.  Finally, the driver was converted to use the new
  pci_enable_msix_range logic (and the refactoring to go along with it)"

* tag 'ntb-3.15' of git://github.com/jonmason/ntb:
  ntb: Use pci_enable_msix_range() instead of pci_enable_msix()
  ntb: Split ntb_setup_msix() into separate BWD/SNB routines
  ntb: Use pci_msix_vec_count() to obtain number of MSI-Xs
  NTB: Code Style Clean-up
  NTB: client event cleanup
  ntb: Fix leakage of ntb_device::msix_entries[] array
  NTB: Fix typo in setting one translation register
  ntb_netdev: Fix skb free issue in open
  ntb_netdev: Fix list_for_each_entry exit issue

5 files changed, 150 insertions, 116 deletions

diff --git a/drivers/net/ntb_netdev.c b/drivers/net/ntb_netdev.c
index f3cdf64997d6..63aa9d9e34c5 100644
--- a/drivers/net/ntb_netdev.c
+++ b/drivers/net/ntb_netdev.c
@@ -78,11 +78,19 @@ static void ntb_netdev_event_handler(void *data, int status)
         netdev_dbg(ndev, "Event %x, Link %x\n", status,
                    ntb_transport_link_query(dev->qp));
 
-        /* Currently, only link status event is supported */
-        if (status)
-                netif_carrier_on(ndev);
-        else
+        switch (status) {
+        case NTB_LINK_DOWN:
                 netif_carrier_off(ndev);
+                break;
+        case NTB_LINK_UP:
+                if (!ntb_transport_link_query(dev->qp))
+                        return;
+
+                netif_carrier_on(ndev);
+                break;
+        default:
+                netdev_warn(ndev, "Unsupported event type %d\n", status);
+        }
 }
 
 static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data,
@@ -182,8 +190,10 @@ static int ntb_netdev_open(struct net_device *ndev)
 
                 rc = ntb_transport_rx_enqueue(dev->qp, skb, skb->data,
                                               ndev->mtu + ETH_HLEN);
-                if (rc == -EINVAL)
+                if (rc == -EINVAL) {
+                        dev_kfree_skb(skb);
                         goto err;
+                }
         }
 
         netif_carrier_off(ndev);
@@ -367,12 +377,15 @@ static void ntb_netdev_remove(struct pci_dev *pdev)
 {
         struct net_device *ndev;
         struct ntb_netdev *dev;
+        bool found = false;
 
         list_for_each_entry(dev, &dev_list, list) {
-                if (dev->pdev == pdev)
+                if (dev->pdev == pdev) {
+                        found = true;
                         break;
+                }
         }
-        if (dev == NULL)
+        if (!found)
                 return;
 
         list_del(&dev->list);
diff --git a/drivers/ntb/ntb_hw.c b/drivers/ntb/ntb_hw.c
index 170e8e60cdb7..372e08c4ffef 100644
--- a/drivers/ntb/ntb_hw.c
+++ b/drivers/ntb/ntb_hw.c
@@ -91,7 +91,7 @@ static struct dentry *debugfs_dir;
 /* Translate memory window 0,1 to BAR 2,4 */
 #define MW_TO_BAR(mw)   (mw * NTB_MAX_NUM_MW + 2)
 
-static DEFINE_PCI_DEVICE_TABLE(ntb_pci_tbl) = {
+static const struct pci_device_id ntb_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_NTB_B2B_BWD)},
         {PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_NTB_B2B_JSF)},
         {PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_NTB_B2B_SNB)},
@@ -120,7 +120,8 @@ MODULE_DEVICE_TABLE(pci, ntb_pci_tbl);
  * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
  */
 int ntb_register_event_callback(struct ntb_device *ndev,
-                            void (*func)(void *handle, enum ntb_hw_event event))
+                                void (*func)(void *handle,
+                                             enum ntb_hw_event event))
 {
         if (ndev->event_cb)
                 return -EINVAL;
@@ -715,9 +716,9 @@ static int ntb_xeon_setup(struct ntb_device *ndev)
                                SNB_PBAR4LMT_OFFSET);
                         /* HW errata on the Limit registers.  They can only be
                          * written when the base register is 4GB aligned and
-                         * < 32bit.  This should already be the case based on the
-                         * driver defaults, but write the Limit registers first
-                         * just in case.
+                         * < 32bit.  This should already be the case based on
+                         * the driver defaults, but write the Limit registers
+                         * first just in case.
                          */
                 } else {
                         ndev->limits.max_mw = SNB_MAX_MW;
@@ -739,9 +740,9 @@ static int ntb_xeon_setup(struct ntb_device *ndev)
                         writeq(0, ndev->reg_base + SNB_PBAR4LMT_OFFSET);
                         /* HW errata on the Limit registers.  They can only be
                          * written when the base register is 4GB aligned and
-                         * < 32bit.  This should already be the case based on the
-                         * driver defaults, but write the Limit registers first
-                         * just in case.
+                         * < 32bit.  This should already be the case based on
+                         * the driver defaults, but write the Limit registers
+                         * first just in case.
                          */
                 }
 
@@ -785,7 +786,7 @@ static int ntb_xeon_setup(struct ntb_device *ndev)
                                 /* B2B_XLAT_OFFSET is a 64bit register, but can
                                  * only take 32bit writes
                                  */
-                                writel(SNB_MBAR01_DSD_ADDR & 0xffffffff,
+                                writel(SNB_MBAR01_USD_ADDR & 0xffffffff,
                                        ndev->reg_base + SNB_B2B_XLAT_OFFSETL);
                                 writel(SNB_MBAR01_USD_ADDR >> 32,
                                        ndev->reg_base + SNB_B2B_XLAT_OFFSETU);
@@ -803,7 +804,7 @@ static int ntb_xeon_setup(struct ntb_device *ndev)
                 ndev->conn_type = NTB_CONN_RP;
 
                 if (xeon_errata_workaround) {
-                        dev_err(&ndev->pdev->dev, 
+                        dev_err(&ndev->pdev->dev,
                                 "NTB-RP disabled due to hardware errata.  To disregard this warning and potentially lock-up the system, add the parameter 'xeon_errata_workaround=0'.\n");
                         return -EINVAL;
                 }
@@ -1079,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;
 }
 
@@ -1281,6 +1302,7 @@ static void ntb_free_interrupts(struct ntb_device *ndev)
                                 free_irq(msix->vector, &ndev->db_cb[i]);
                 }
                 pci_disable_msix(pdev);
+                kfree(ndev->msix_entries);
         } else {
                 free_irq(pdev->irq, ndev);
 
diff --git a/drivers/ntb/ntb_hw.h b/drivers/ntb/ntb_hw.h
index bbdb7edca10c..465517b7393e 100644
--- a/drivers/ntb/ntb_hw.h
+++ b/drivers/ntb/ntb_hw.h
@@ -45,6 +45,7 @@
  * Contact Information:
  * Jon Mason <jon.mason@intel.com>
  */
+#include <linux/ntb.h>
 
 #define PCI_DEVICE_ID_INTEL_NTB_B2B_JSF         0x3725
 #define PCI_DEVICE_ID_INTEL_NTB_PS_JSF          0x3726
@@ -60,8 +61,6 @@
 #define PCI_DEVICE_ID_INTEL_NTB_SS_HSX          0x2F0F
 #define PCI_DEVICE_ID_INTEL_NTB_B2B_BWD         0x0C4E
 
-#define msix_table_size(control)        ((control & PCI_MSIX_FLAGS_QSIZE)+1)
-
 #ifndef readq
 static inline u64 readq(void __iomem *addr)
 {
@@ -83,9 +82,6 @@ static inline void writeq(u64 val, void __iomem *addr)
 #define NTB_BAR_MASK            ((1 << NTB_BAR_MMIO) | (1 << NTB_BAR_23) |\
                                  (1 << NTB_BAR_45))
 
-#define NTB_LINK_DOWN           0
-#define NTB_LINK_UP             1
-
 #define NTB_HB_TIMEOUT          msecs_to_jiffies(1000)
 
 #define NTB_MAX_NUM_MW          2
@@ -233,7 +229,7 @@ int ntb_register_db_callback(struct ntb_device *ndev, unsigned int idx,
                                                            int db_num));
 void ntb_unregister_db_callback(struct ntb_device *ndev, unsigned int idx);
 int ntb_register_event_callback(struct ntb_device *ndev,
-                                void (*event_cb_func) (void *handle,
+                                void (*event_cb_func)(void *handle,
                                                       enum ntb_hw_event event));
 void ntb_unregister_event_callback(struct ntb_device *ndev);
 int ntb_get_max_spads(struct ntb_device *ndev);
diff --git a/drivers/ntb/ntb_transport.c b/drivers/ntb/ntb_transport.c
index 3217f394d45b..9dd63b822025 100644
--- a/drivers/ntb/ntb_transport.c
+++ b/drivers/ntb/ntb_transport.c
@@ -56,7 +56,6 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/types.h>
-#include <linux/ntb.h>
 #include "ntb_hw.h"
 
 #define NTB_TRANSPORT_VERSION   3
@@ -107,8 +106,8 @@ struct ntb_transport_qp {
         struct ntb_rx_info __iomem *rx_info;
         struct ntb_rx_info *remote_rx_info;
 
-        void (*tx_handler) (struct ntb_transport_qp *qp, void *qp_data,
-                            void *data, int len);
+        void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
+                           void *data, int len);
         struct list_head tx_free_q;
         spinlock_t ntb_tx_free_q_lock;
         void __iomem *tx_mw;
@@ -117,8 +116,8 @@ struct ntb_transport_qp {
         unsigned int tx_max_entry;
         unsigned int tx_max_frame;
 
-        void (*rx_handler) (struct ntb_transport_qp *qp, void *qp_data,
-                            void *data, int len);
+        void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
+                           void *data, int len);
         struct list_head rx_pend_q;
         struct list_head rx_free_q;
         spinlock_t ntb_rx_pend_q_lock;
@@ -129,7 +128,7 @@ struct ntb_transport_qp {
         unsigned int rx_max_frame;
         dma_cookie_t last_cookie;
 
-        void (*event_handler) (void *data, int status);
+        void (*event_handler)(void *data, int status);
         struct delayed_work link_work;
         struct work_struct link_cleanup;
 
@@ -480,7 +479,7 @@ static void ntb_list_add(spinlock_t *lock, struct list_head *entry,
 }
 
 static struct ntb_queue_entry *ntb_list_rm(spinlock_t *lock,
-                                                struct list_head *list)
+                                           struct list_head *list)
 {
         struct ntb_queue_entry *entry;
         unsigned long flags;
@@ -839,7 +838,7 @@ static void ntb_qp_link_work(struct work_struct *work)
 }
 
 static int ntb_transport_init_queue(struct ntb_transport *nt,
-                                     unsigned int qp_num)
+                                    unsigned int qp_num)
 {
         struct ntb_transport_qp *qp;
         unsigned int num_qps_mw, tx_size;
@@ -1055,7 +1054,7 @@ static void ntb_async_rx(struct ntb_queue_entry *entry, void *offset,
         if (!chan)
                 goto err;
 
-        if (len < copy_bytes) 
+        if (len < copy_bytes)
                 goto err_wait;
 
         device = chan->device;
@@ -1190,8 +1189,7 @@ out:
         return 0;
 
 err:
-        ntb_list_add(&qp->ntb_rx_pend_q_lock, &entry->entry,
-                     &qp->rx_pend_q);
+        ntb_list_add(&qp->ntb_rx_pend_q_lock, &entry->entry, &qp->rx_pend_q);
         /* Ensure that the data is fully copied out before clearing the flag */
         wmb();
         hdr->flags = 0;
diff --git a/include/linux/ntb.h b/include/linux/ntb.h
index f6a15205853b..9ac1a62fc6f5 100644
--- a/include/linux/ntb.h
+++ b/include/linux/ntb.h
@@ -50,8 +50,13 @@ struct ntb_transport_qp;
 
 struct ntb_client {
         struct device_driver driver;
-        int (*probe) (struct pci_dev *pdev);
-        void (*remove) (struct pci_dev *pdev);
+        int (*probe)(struct pci_dev *pdev);
+        void (*remove)(struct pci_dev *pdev);
+};
+
+enum {
+        NTB_LINK_DOWN = 0,
+        NTB_LINK_UP,
 };
 
 int ntb_register_client(struct ntb_client *drvr);
@@ -60,11 +65,11 @@ int ntb_register_client_dev(char *device_name);
 void ntb_unregister_client_dev(char *device_name);
 
 struct ntb_queue_handlers {
-        void (*rx_handler) (struct ntb_transport_qp *qp, void *qp_data,
-                            void *data, int len);
-        void (*tx_handler) (struct ntb_transport_qp *qp, void *qp_data,
-                            void *data, int len);
-        void (*event_handler) (void *data, int status);
+        void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
+                           void *data, int len);
+        void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
+                           void *data, int len);
+        void (*event_handler)(void *data, int status);
 };
 
 unsigned char ntb_transport_qp_num(struct ntb_transport_qp *qp);