From: Alfredo Cardigliano Date: Sun, 19 Jan 2020 15:53:47 +0000 (+0100) Subject: net/ionic: support notify queue X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=27b942c89afbd61ff3d026acf69d6198b7d05c86;p=dpdk.git 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 Reviewed-by: Shannon Nelson --- diff --git a/drivers/net/ionic/ionic.h b/drivers/net/ionic/ionic.h index e4592ede39..0243ee4cae 100644 --- 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 f58d2d3a66..5719501db6 100644 --- 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 78a8c93a8f..c831519b72 100644 --- 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 96522c544a..78cf92db86 100644 --- 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_ */