net/i40e: fix interrupt conflict with multi-driver

There's interrupt conflict when using DPDK and Linux i40e
on different ports of the same Ethernet controller, this
patch fixes it by switching from IntN to Int0 if multiple
drivers are used.

Fixes: be6c228d4da3 ("i40e: support Rx interrupt")
Cc: stable@dpdk.org
Signed-off-by: Beilei Xing <beilei.xing@intel.com>
Acked-by: Jingjing Wu <jingjing.wu@intel.com>

diff --git a/drivers/net/i40e/i40e_ethdev.c b/drivers/net/i40e/i40e_ethdev.c
index 0c141c4..a60fd60 100644 (file)
--- a/drivers/net/i40e/i40e_ethdev.c
+++ b/drivers/net/i40e/i40e_ethdev.c
@@ -692,6 +692,23 @@ static inline void i40e_GLQF_reg_init(struct i40e_hw *hw)
        i40e_global_cfg_warning(I40E_WARNING_QINQ_PARSER);
 }
 
+static inline void i40e_config_automask(struct i40e_pf *pf)
+{
+       struct i40e_hw *hw = I40E_PF_TO_HW(pf);
+       uint32_t val;
+
+       /* INTENA flag is not auto-cleared for interrupt */
+       val = I40E_READ_REG(hw, I40E_GLINT_CTL);
+       val |= I40E_GLINT_CTL_DIS_AUTOMASK_PF0_MASK |
+               I40E_GLINT_CTL_DIS_AUTOMASK_VF0_MASK;
+
+       /* If support multi-driver, PF will use INT0. */
+       if (!pf->support_multi_driver)
+               val |= I40E_GLINT_CTL_DIS_AUTOMASK_N_MASK;
+
+       I40E_WRITE_REG(hw, I40E_GLINT_CTL, val);
+}
+
 #define I40E_FLOW_CONTROL_ETHERTYPE  0x8808
 
 /*
@@ -1173,6 +1190,8 @@ eth_i40e_dev_init(struct rte_eth_dev *dev)
                return ret;
        }
 
+       i40e_config_automask(pf);
+
        i40e_set_default_pctype_table(dev);
 
        /*
@@ -1705,6 +1724,7 @@ __vsi_queues_bind_intr(struct i40e_vsi *vsi, uint16_t msix_vect,
        int i;
        uint32_t val;
        struct i40e_hw *hw = I40E_VSI_TO_HW(vsi);
+       struct i40e_pf *pf = I40E_VSI_TO_PF(vsi);
 
        /* Bind all RX queues to allocated MSIX interrupt */
        for (i = 0; i < nb_queue; i++) {
@@ -1723,7 +1743,8 @@ __vsi_queues_bind_intr(struct i40e_vsi *vsi, uint16_t msix_vect,
        /* Write first RX queue to Link list register as the head element */
        if (vsi->type != I40E_VSI_SRIOV) {
                uint16_t interval =
-                       i40e_calc_itr_interval(RTE_LIBRTE_I40E_ITR_INTERVAL, 1);
+                       i40e_calc_itr_interval(RTE_LIBRTE_I40E_ITR_INTERVAL, 1,
+                                              pf->support_multi_driver);
 
                if (msix_vect == I40E_MISC_VEC_ID) {
                        I40E_WRITE_REG(hw, I40E_PFINT_LNKLST0,
@@ -1782,7 +1803,6 @@ i40e_vsi_queues_bind_intr(struct i40e_vsi *vsi, uint16_t itr_idx)
        uint16_t nb_msix = RTE_MIN(vsi->nb_msix, intr_handle->nb_efd);
        uint16_t queue_idx = 0;
        int record = 0;
-       uint32_t val;
        int i;
 
        for (i = 0; i < vsi->nb_qps; i++) {
@@ -1790,13 +1810,6 @@ i40e_vsi_queues_bind_intr(struct i40e_vsi *vsi, uint16_t itr_idx)
                I40E_WRITE_REG(hw, I40E_QINT_RQCTL(vsi->base_queue + i), 0);
        }
 
-       /* INTENA flag is not auto-cleared for interrupt */
-       val = I40E_READ_REG(hw, I40E_GLINT_CTL);
-       val |= I40E_GLINT_CTL_DIS_AUTOMASK_PF0_MASK |
-               I40E_GLINT_CTL_DIS_AUTOMASK_N_MASK |
-               I40E_GLINT_CTL_DIS_AUTOMASK_VF0_MASK;
-       I40E_WRITE_REG(hw, I40E_GLINT_CTL, val);
-
        /* VF bind interrupt */
        if (vsi->type == I40E_VSI_SRIOV) {
                __vsi_queues_bind_intr(vsi, msix_vect,
@@ -1853,27 +1866,22 @@ i40e_vsi_enable_queues_intr(struct i40e_vsi *vsi)
        struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
        struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
        struct i40e_hw *hw = I40E_VSI_TO_HW(vsi);
-       uint16_t interval = i40e_calc_itr_interval(\
-               RTE_LIBRTE_I40E_ITR_INTERVAL, 1);
+       struct i40e_pf *pf = I40E_VSI_TO_PF(vsi);
        uint16_t msix_intr, i;
 
-       if (rte_intr_allow_others(intr_handle))
+       if (rte_intr_allow_others(intr_handle) || !pf->support_multi_driver)
                for (i = 0; i < vsi->nb_msix; i++) {
                        msix_intr = vsi->msix_intr + i;
                        I40E_WRITE_REG(hw, I40E_PFINT_DYN_CTLN(msix_intr - 1),
                                I40E_PFINT_DYN_CTLN_INTENA_MASK |
                                I40E_PFINT_DYN_CTLN_CLEARPBA_MASK |
-                               (0 << I40E_PFINT_DYN_CTLN_ITR_INDX_SHIFT) |
-                               (interval <<
-                                I40E_PFINT_DYN_CTLN_INTERVAL_SHIFT));
+                               I40E_PFINT_DYN_CTLN_ITR_INDX_MASK);
                }
        else
                I40E_WRITE_REG(hw, I40E_PFINT_DYN_CTL0,
                               I40E_PFINT_DYN_CTL0_INTENA_MASK |
                               I40E_PFINT_DYN_CTL0_CLEARPBA_MASK |
-                              (0 << I40E_PFINT_DYN_CTL0_ITR_INDX_SHIFT) |
-                              (interval <<
-                               I40E_PFINT_DYN_CTL0_INTERVAL_SHIFT));
+                              I40E_PFINT_DYN_CTL0_ITR_INDX_MASK);
 
        I40E_WRITE_FLUSH(hw);
 }
@@ -1885,16 +1893,18 @@ i40e_vsi_disable_queues_intr(struct i40e_vsi *vsi)
        struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
        struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
        struct i40e_hw *hw = I40E_VSI_TO_HW(vsi);
+       struct i40e_pf *pf = I40E_VSI_TO_PF(vsi);
        uint16_t msix_intr, i;
 
-       if (rte_intr_allow_others(intr_handle))
+       if (rte_intr_allow_others(intr_handle) || !pf->support_multi_driver)
                for (i = 0; i < vsi->nb_msix; i++) {
                        msix_intr = vsi->msix_intr + i;
                        I40E_WRITE_REG(hw, I40E_PFINT_DYN_CTLN(msix_intr - 1),
-                                      0);
+                                      I40E_PFINT_DYN_CTLN_ITR_INDX_MASK);
                }
        else
-               I40E_WRITE_REG(hw, I40E_PFINT_DYN_CTL0, 0);
+               I40E_WRITE_REG(hw, I40E_PFINT_DYN_CTL0,
+                              I40E_PFINT_DYN_CTL0_ITR_INDX_MASK);
 
        I40E_WRITE_FLUSH(hw);
 }
@@ -5177,16 +5187,28 @@ i40e_vsi_setup(struct i40e_pf *pf,
 
        /* VF has MSIX interrupt in VF range, don't allocate here */
        if (type == I40E_VSI_MAIN) {
-               ret = i40e_res_pool_alloc(&pf->msix_pool,
-                                         RTE_MIN(vsi->nb_qps,
-                                                 RTE_MAX_RXTX_INTR_VEC_ID));
-               if (ret < 0) {
-                       PMD_DRV_LOG(ERR, "VSI MAIN %d get heap failed %d",
-                                   vsi->seid, ret);
-                       goto fail_queue_alloc;
+               if (pf->support_multi_driver) {
+                       /* If support multi-driver, need to use INT0 instead of
+                        * allocating from msix pool. The Msix pool is init from
+                        * INT1, so it's OK just set msix_intr to 0 and nb_msix
+                        * to 1 without calling i40e_res_pool_alloc.
+                        */
+                       vsi->msix_intr = 0;
+                       vsi->nb_msix = 1;
+               } else {
+                       ret = i40e_res_pool_alloc(&pf->msix_pool,
+                                                 RTE_MIN(vsi->nb_qps,
+                                                    RTE_MAX_RXTX_INTR_VEC_ID));
+                       if (ret < 0) {
+                               PMD_DRV_LOG(ERR,
+                                           "VSI MAIN %d get heap failed %d",
+                                           vsi->seid, ret);
+                               goto fail_queue_alloc;
+                       }
+                       vsi->msix_intr = ret;
+                       vsi->nb_msix = RTE_MIN(vsi->nb_qps,
+                                              RTE_MAX_RXTX_INTR_VEC_ID);
                }
-               vsi->msix_intr = ret;
-               vsi->nb_msix = RTE_MIN(vsi->nb_qps, RTE_MAX_RXTX_INTR_VEC_ID);
        } else if (type != I40E_VSI_SRIOV) {
                ret = i40e_res_pool_alloc(&pf->msix_pool, 1);
                if (ret < 0) {
@@ -6103,7 +6125,8 @@ void
 i40e_pf_disable_irq0(struct i40e_hw *hw)
 {
        /* Disable all interrupt types */
-       I40E_WRITE_REG(hw, I40E_PFINT_DYN_CTL0, 0);
+       I40E_WRITE_REG(hw, I40E_PFINT_DYN_CTL0,
+                      I40E_PFINT_DYN_CTL0_ITR_INDX_MASK);
        I40E_WRITE_FLUSH(hw);
 }
 
@@ -11091,11 +11114,13 @@ i40e_dev_get_dcb_info(struct rte_eth_dev *dev,
 static int
 i40e_dev_rx_queue_intr_enable(struct rte_eth_dev *dev, uint16_t queue_id)
 {
+       struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
        struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
        struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
        struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
        uint16_t interval =
-               i40e_calc_itr_interval(RTE_LIBRTE_I40E_ITR_INTERVAL, 1);
+               i40e_calc_itr_interval(RTE_LIBRTE_I40E_ITR_INTERVAL, 1,
+                                      pf->support_multi_driver);
        uint16_t msix_intr;
 
        msix_intr = intr_handle->intr_vec[queue_id];

diff --git a/drivers/net/i40e/i40e_ethdev.h b/drivers/net/i40e/i40e_ethdev.h
index deefb11..99efb67 100644 (file)
--- a/drivers/net/i40e/i40e_ethdev.h
+++ b/drivers/net/i40e/i40e_ethdev.h
@@ -1292,13 +1292,17 @@ i40e_align_floor(int n)
 }
 
 static inline uint16_t
-i40e_calc_itr_interval(int16_t interval, bool is_pf)
+i40e_calc_itr_interval(int16_t interval, bool is_pf, bool is_multi_drv)
 {
        if (interval < 0 || interval > I40E_QUEUE_ITR_INTERVAL_MAX) {
-               if (is_pf)
-                       interval = I40E_QUEUE_ITR_INTERVAL_DEFAULT;
-               else
-                       interval = I40E_VF_QUEUE_ITR_INTERVAL_DEFAULT;
+               if (is_multi_drv) {
+                       interval = I40E_QUEUE_ITR_INTERVAL_MAX;
+               } else {
+                       if (is_pf)
+                               interval = I40E_QUEUE_ITR_INTERVAL_DEFAULT;
+                       else
+                               interval = I40E_VF_QUEUE_ITR_INTERVAL_DEFAULT;
+               }
        }
 
        /* Convert to hardware count, as writing each 1 represents 2 us */

diff --git a/drivers/net/i40e/i40e_ethdev_vf.c b/drivers/net/i40e/i40e_ethdev_vf.c
index 708756e..fd003fe 100644 (file)
--- a/drivers/net/i40e/i40e_ethdev_vf.c
+++ b/drivers/net/i40e/i40e_ethdev_vf.c
@@ -1138,7 +1138,7 @@ i40evf_init_vf(struct rte_eth_dev *dev)
        struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
        struct i40e_vf *vf = I40EVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
        uint16_t interval =
-               i40e_calc_itr_interval(RTE_LIBRTE_I40E_ITR_INTERVAL, 0);
+               i40e_calc_itr_interval(RTE_LIBRTE_I40E_ITR_INTERVAL, 0, 0);
 
        vf->adapter = I40E_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
        vf->dev_data = dev->data;
@@ -1841,7 +1841,7 @@ i40evf_dev_rx_queue_intr_enable(struct rte_eth_dev *dev, uint16_t queue_id)
        struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
        struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
        uint16_t interval =
-               i40e_calc_itr_interval(RTE_LIBRTE_I40E_ITR_INTERVAL, 0);
+               i40e_calc_itr_interval(RTE_LIBRTE_I40E_ITR_INTERVAL, 0, 0);
        uint16_t msix_intr;
 
        msix_intr = intr_handle->intr_vec[queue_id];