net/ionic: support notify queue

Add support for the notify queue, which is used for events
published by the NIC.

Signed-off-by: Alfredo Cardigliano <cardigliano@ntop.org>
Reviewed-by: Shannon Nelson <snelson@pensando.io>

diff --git a/drivers/net/ionic/ionic.h b/drivers/net/ionic/ionic.h
index e4592ed..0243ee4 100644 (file)
--- a/drivers/net/ionic/ionic.h
+++ b/drivers/net/ionic/ionic.h
@@ -55,9 +55,11 @@ struct ionic_adapter {
        uint32_t nlifs;
        uint32_t max_ntxqs_per_lif;
        uint32_t max_nrxqs_per_lif;
+       uint32_t link_speed;
        uint32_t nintrs;
        bool intrs[IONIC_INTR_CTRL_REGS_MAX];
        bool is_mgmt_nic;
+       bool link_up;
        struct rte_pci_device *pci_dev;
        LIST_ENTRY(ionic_adapter) pci_adapters;
 };

diff --git a/drivers/net/ionic/ionic_ethdev.c b/drivers/net/ionic/ionic_ethdev.c
index f58d2d3..5719501 100644 (file)
--- a/drivers/net/ionic/ionic_ethdev.c
+++ b/drivers/net/ionic/ionic_ethdev.c
@@ -31,6 +31,30 @@ static const struct rte_pci_id pci_id_ionic_map[] = {
 static const struct eth_dev_ops ionic_eth_dev_ops = {
 };
 
+/**
+ * Interrupt handler triggered by NIC for handling
+ * specific interrupt.
+ *
+ * @param param
+ *  The address of parameter registered before.
+ *
+ * @return
+ *  void
+ */
+static void
+ionic_dev_interrupt_handler(void *param)
+{
+       struct ionic_adapter *adapter = (struct ionic_adapter *)param;
+       uint32_t i;
+
+       IONIC_PRINT(DEBUG, "->");
+
+       for (i = 0; i < adapter->nlifs; i++) {
+               if (adapter->lifs[i])
+                       ionic_notifyq_handler(adapter->lifs[i], -1);
+       }
+}
+
 static int
 eth_ionic_dev_init(struct rte_eth_dev *eth_dev, void *init_params)
 {
@@ -98,6 +122,70 @@ eth_ionic_dev_uninit(struct rte_eth_dev *eth_dev)
        return 0;
 }
 
+static int
+ionic_configure_intr(struct ionic_adapter *adapter)
+{
+       struct rte_pci_device *pci_dev = adapter->pci_dev;
+       struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
+       int err;
+
+       IONIC_PRINT(DEBUG, "Configuring %u intrs", adapter->nintrs);
+
+       if (rte_intr_efd_enable(intr_handle, adapter->nintrs)) {
+               IONIC_PRINT(ERR, "Fail to create eventfd");
+               return -1;
+       }
+
+       if (rte_intr_dp_is_en(intr_handle))
+               IONIC_PRINT(DEBUG,
+                       "Packet I/O interrupt on datapath is enabled");
+
+       if (!intr_handle->intr_vec) {
+               intr_handle->intr_vec = rte_zmalloc("intr_vec",
+                       adapter->nintrs * sizeof(int), 0);
+
+               if (!intr_handle->intr_vec) {
+                       IONIC_PRINT(ERR, "Failed to allocate %u vectors",
+                               adapter->nintrs);
+                       return -ENOMEM;
+               }
+       }
+
+       err = rte_intr_callback_register(intr_handle,
+               ionic_dev_interrupt_handler,
+               adapter);
+
+       if (err) {
+               IONIC_PRINT(ERR,
+                       "Failure registering interrupts handler (%d)",
+                       err);
+               return err;
+       }
+
+       /* enable intr mapping */
+       err = rte_intr_enable(intr_handle);
+
+       if (err) {
+               IONIC_PRINT(ERR, "Failure enabling interrupts (%d)", err);
+               return err;
+       }
+
+       return 0;
+}
+
+static void
+ionic_unconfigure_intr(struct ionic_adapter *adapter)
+{
+       struct rte_pci_device *pci_dev = adapter->pci_dev;
+       struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
+
+       rte_intr_disable(intr_handle);
+
+       rte_intr_callback_unregister(intr_handle,
+               ionic_dev_interrupt_handler,
+               adapter);
+}
+
 static int
 eth_ionic_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
                struct rte_pci_device *pci_dev)
@@ -221,6 +309,13 @@ eth_ionic_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
                adapter->nlifs++;
        }
 
+       err = ionic_configure_intr(adapter);
+
+       if (err) {
+               IONIC_PRINT(ERR, "Failed to configure interrupts");
+               goto err_free_adapter;
+       }
+
        return 0;
 
 err_free_adapter:
@@ -249,6 +344,8 @@ eth_ionic_pci_remove(struct rte_pci_device *pci_dev __rte_unused)
        }
 
        if (adapter) {
+               ionic_unconfigure_intr(adapter);
+
                for (i = 0; i < adapter->nlifs; i++) {
                        lif = adapter->lifs[i];
                        rte_eth_dev_destroy(lif->eth_dev, eth_ionic_dev_uninit);

diff --git a/drivers/net/ionic/ionic_lif.c b/drivers/net/ionic/ionic_lif.c
index 78a8c93..c831519 100644 (file)
--- a/drivers/net/ionic/ionic_lif.c
+++ b/drivers/net/ionic/ionic_lif.c
@@ -253,7 +253,27 @@ ionic_admin_qcq_alloc(struct ionic_lif *lif)
                sizeof(struct ionic_admin_comp),
                0,
                lif->kern_pid, &lif->adminqcq);
+       if (err)
+               return err;
 
+       return 0;
+}
+
+static int
+ionic_notify_qcq_alloc(struct ionic_lif *lif)
+{
+       uint32_t flags;
+       int err = -ENOMEM;
+
+       flags = IONIC_QCQ_F_NOTIFYQ | IONIC_QCQ_F_INTR;
+
+       err = ionic_qcq_alloc(lif, IONIC_QTYPE_NOTIFYQ, 0, "notify",
+               flags,
+               IONIC_NOTIFYQ_LENGTH,
+               sizeof(struct ionic_notifyq_cmd),
+               sizeof(union ionic_notifyq_comp),
+               0,
+               lif->kern_pid, &lif->notifyqcq);
        if (err)
                return err;
 
@@ -296,6 +316,17 @@ ionic_lif_alloc(struct ionic_lif *lif)
                return -ENOMEM;
        }
 
+       IONIC_PRINT(DEBUG, "Allocating Notify Queue");
+
+       err = ionic_notify_qcq_alloc(lif);
+
+       if (err) {
+               IONIC_PRINT(ERR, "Cannot allocate notify queue");
+               return err;
+       }
+
+       IONIC_PRINT(DEBUG, "Allocating Admin Queue");
+
        IONIC_PRINT(DEBUG, "Allocating Admin Queue");
 
        err = ionic_admin_qcq_alloc(lif);
@@ -325,6 +356,11 @@ ionic_lif_alloc(struct ionic_lif *lif)
 void
 ionic_lif_free(struct ionic_lif *lif)
 {
+       if (lif->notifyqcq) {
+               ionic_qcq_free(lif->notifyqcq);
+               lif->notifyqcq = NULL;
+       }
+
        if (lif->adminqcq) {
                ionic_qcq_free(lif->adminqcq);
                lif->adminqcq = NULL;
@@ -379,6 +415,99 @@ ionic_qcq_service(struct ionic_qcq *qcq, int budget, ionic_cq_cb cb,
        return work_done;
 }
 
+static void
+ionic_link_status_check(struct ionic_lif *lif)
+{
+       struct ionic_adapter *adapter = lif->adapter;
+       bool link_up;
+
+       lif->state &= ~IONIC_LIF_F_LINK_CHECK_NEEDED;
+
+       if (!lif->info)
+               return;
+
+       link_up = (lif->info->status.link_status == IONIC_PORT_OPER_STATUS_UP);
+
+       if ((link_up  && adapter->link_up) ||
+           (!link_up && !adapter->link_up))
+               return;
+
+       if (link_up) {
+               IONIC_PRINT(DEBUG, "Link up - %d Gbps",
+                       lif->info->status.link_speed);
+               adapter->link_speed = lif->info->status.link_speed;
+       } else {
+               IONIC_PRINT(DEBUG, "Link down");
+       }
+
+       adapter->link_up = link_up;
+}
+
+static bool
+ionic_notifyq_cb(struct ionic_cq *cq, uint32_t cq_desc_index, void *cb_arg)
+{
+       union ionic_notifyq_comp *cq_desc_base = cq->base;
+       union ionic_notifyq_comp *cq_desc = &cq_desc_base[cq_desc_index];
+       struct ionic_lif *lif = cb_arg;
+
+       IONIC_PRINT(DEBUG, "Notifyq callback eid = %jd ecode = %d",
+               cq_desc->event.eid, cq_desc->event.ecode);
+
+       /* Have we run out of new completions to process? */
+       if (!(cq_desc->event.eid > lif->last_eid))
+               return false;
+
+       lif->last_eid = cq_desc->event.eid;
+
+       switch (cq_desc->event.ecode) {
+       case IONIC_EVENT_LINK_CHANGE:
+               IONIC_PRINT(DEBUG,
+                       "Notifyq IONIC_EVENT_LINK_CHANGE eid=%jd link_status=%d link_speed=%d",
+                       cq_desc->event.eid,
+                       cq_desc->link_change.link_status,
+                       cq_desc->link_change.link_speed);
+
+               lif->state |= IONIC_LIF_F_LINK_CHECK_NEEDED;
+
+               break;
+       default:
+               IONIC_PRINT(WARNING, "Notifyq bad event ecode=%d eid=%jd",
+                       cq_desc->event.ecode, cq_desc->event.eid);
+               break;
+       }
+
+       return true;
+}
+
+int
+ionic_notifyq_handler(struct ionic_lif *lif, int budget)
+{
+       struct ionic_dev *idev = &lif->adapter->idev;
+       struct ionic_qcq *qcq = lif->notifyqcq;
+       uint32_t work_done;
+
+       if (!(qcq->flags & IONIC_QCQ_F_INITED)) {
+               IONIC_PRINT(DEBUG, "Notifyq not yet initialized");
+               return -1;
+       }
+
+       ionic_intr_mask(idev->intr_ctrl, qcq->intr.index,
+               IONIC_INTR_MASK_SET);
+
+       work_done = ionic_qcq_service(qcq, budget, ionic_notifyq_cb, lif);
+
+       if (lif->state & IONIC_LIF_F_LINK_CHECK_NEEDED)
+               ionic_link_status_check(lif);
+
+       ionic_intr_credits(idev->intr_ctrl, qcq->intr.index,
+               work_done, IONIC_INTR_CRED_RESET_COALESCE);
+
+       ionic_intr_mask(idev->intr_ctrl, qcq->intr.index,
+               IONIC_INTR_MASK_CLEAR);
+
+       return 0;
+}
+
 static int
 ionic_lif_adminq_init(struct ionic_lif *lif)
 {
@@ -412,6 +541,58 @@ ionic_lif_adminq_init(struct ionic_lif *lif)
        return 0;
 }
 
+static int
+ionic_lif_notifyq_init(struct ionic_lif *lif)
+{
+       struct ionic_dev *idev = &lif->adapter->idev;
+       struct ionic_qcq *qcq = lif->notifyqcq;
+       struct ionic_queue *q = &qcq->q;
+       int err;
+
+       struct ionic_admin_ctx ctx = {
+               .pending_work = true,
+               .cmd.q_init = {
+                       .opcode = IONIC_CMD_Q_INIT,
+                       .lif_index = lif->index,
+                       .type = q->type,
+                       .index = q->index,
+                       .flags = (IONIC_QINIT_F_IRQ | IONIC_QINIT_F_ENA),
+                       .intr_index = qcq->intr.index,
+                       .pid = q->pid,
+                       .ring_size = rte_log2_u32(q->num_descs),
+                       .ring_base = q->base_pa,
+               }
+       };
+
+       IONIC_PRINT(DEBUG, "notifyq_init.pid %d", ctx.cmd.q_init.pid);
+       IONIC_PRINT(DEBUG, "notifyq_init.index %d",
+               ctx.cmd.q_init.index);
+       IONIC_PRINT(DEBUG, "notifyq_init.ring_base 0x%" PRIx64 "",
+               ctx.cmd.q_init.ring_base);
+       IONIC_PRINT(DEBUG, "notifyq_init.ring_size %d",
+               ctx.cmd.q_init.ring_size);
+
+       err = ionic_adminq_post_wait(lif, &ctx);
+       if (err)
+               return err;
+
+       q->hw_type = ctx.comp.q_init.hw_type;
+       q->hw_index = ctx.comp.q_init.hw_index;
+       q->db = NULL;
+
+       IONIC_PRINT(DEBUG, "notifyq->hw_type %d", q->hw_type);
+       IONIC_PRINT(DEBUG, "notifyq->hw_index %d", q->hw_index);
+       IONIC_PRINT(DEBUG, "notifyq->db %p", q->db);
+
+       if (qcq->flags & IONIC_QCQ_F_INTR)
+               ionic_intr_mask(idev->intr_ctrl, qcq->intr.index,
+                       IONIC_INTR_MASK_CLEAR);
+
+       qcq->flags |= IONIC_QCQ_F_INITED;
+
+       return 0;
+}
+
 int
 ionic_lif_init(struct ionic_lif *lif)
 {
@@ -431,9 +612,18 @@ ionic_lif_init(struct ionic_lif *lif)
        if (err)
                return err;
 
+       err = ionic_lif_notifyq_init(lif);
+       if (err)
+               goto err_out_adminq_deinit;
+
        lif->state |= IONIC_LIF_F_INITED;
 
        return 0;
+
+err_out_adminq_deinit:
+       ionic_lif_qcq_deinit(lif, lif->adminqcq);
+
+       return err;
 }
 
 void
@@ -442,6 +632,7 @@ ionic_lif_deinit(struct ionic_lif *lif)
        if (!(lif->state & IONIC_LIF_F_INITED))
                return;
 
+       ionic_lif_qcq_deinit(lif, lif->notifyqcq);
        ionic_lif_qcq_deinit(lif, lif->adminqcq);
 
        lif->state &= ~IONIC_LIF_F_INITED;

diff --git a/drivers/net/ionic/ionic_lif.h b/drivers/net/ionic/ionic_lif.h
index 96522c5..78cf92d 100644 (file)
--- a/drivers/net/ionic/ionic_lif.h
+++ b/drivers/net/ionic/ionic_lif.h
@@ -14,10 +14,12 @@
 #include "ionic_dev.h"
 
 #define IONIC_ADMINQ_LENGTH    16      /* must be a power of two */
+#define IONIC_NOTIFYQ_LENGTH   64      /* must be a power of two */
 
 #define IONIC_QCQ_F_INITED     BIT(0)
 #define IONIC_QCQ_F_SG         BIT(1)
 #define IONIC_QCQ_F_INTR       BIT(2)
+#define IONIC_QCQ_F_NOTIFYQ    BIT(3)
 
 /* Queue / Completion Queue */
 struct ionic_qcq {
@@ -34,6 +36,7 @@ struct ionic_qcq {
 };
 
 #define IONIC_LIF_F_INITED             BIT(0)
+#define IONIC_LIF_F_LINK_CHECK_NEEDED  BIT(1)
 
 #define IONIC_LIF_NAME_MAX_SZ          (32)
 
@@ -48,7 +51,9 @@ struct ionic_lif {
        rte_spinlock_t adminq_lock;
        rte_spinlock_t adminq_service_lock;
        struct ionic_qcq *adminqcq;
+       struct ionic_qcq *notifyqcq;
        struct ionic_doorbell __iomem *kern_dbpage;
+       uint64_t last_eid;
        char name[IONIC_LIF_NAME_MAX_SZ];
        uint32_t info_sz;
        struct ionic_lif_info *info;
@@ -83,4 +88,6 @@ void ionic_qcq_free(struct ionic_qcq *qcq);
 int ionic_qcq_enable(struct ionic_qcq *qcq);
 int ionic_qcq_disable(struct ionic_qcq *qcq);
 
+int ionic_notifyq_handler(struct ionic_lif *lif, int budget);
+
 #endif /* _IONIC_LIF_H_ */