X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fsfc%2Fsfc_ethdev.c;h=0297e791ca3b18cc47e3f43cd472d78ff9f59d54;hb=96a46ead5b9c3f544703237eb69ba6e2df603f5a;hp=4aa4382c82fd7ad1449552aaacc5210e7277d4b0;hpb=472fa1b17c270ce44a2640dad0da27f4867b5088;p=dpdk.git diff --git a/drivers/net/sfc/sfc_ethdev.c b/drivers/net/sfc/sfc_ethdev.c index 4aa4382c82..0297e791ca 100644 --- a/drivers/net/sfc/sfc_ethdev.c +++ b/drivers/net/sfc/sfc_ethdev.c @@ -30,6 +30,7 @@ #include "sfc_dp_rx.h" #include "sfc_repr.h" #include "sfc_sw_stats.h" +#include "sfc_switch.h" #define SFC_XSTAT_ID_INVALID_VAL UINT64_MAX #define SFC_XSTAT_ID_INVALID_NAME '\0' @@ -1918,6 +1919,177 @@ sfc_rx_queue_intr_disable(struct rte_eth_dev *dev, uint16_t ethdev_qid) return sap->dp_rx->intr_disable(rxq_info->dp); } +struct sfc_mport_journal_ctx { + struct sfc_adapter *sa; + uint16_t switch_domain_id; + uint32_t mcdi_handle; + bool controllers_assigned; + efx_pcie_interface_t *controllers; + size_t nb_controllers; +}; + +static int +sfc_journal_ctx_add_controller(struct sfc_mport_journal_ctx *ctx, + efx_pcie_interface_t intf) +{ + efx_pcie_interface_t *new_controllers; + size_t i, target; + size_t new_size; + + if (ctx->controllers == NULL) { + ctx->controllers = rte_malloc("sfc_controller_mapping", + sizeof(ctx->controllers[0]), 0); + if (ctx->controllers == NULL) + return ENOMEM; + + ctx->controllers[0] = intf; + ctx->nb_controllers = 1; + + return 0; + } + + for (i = 0; i < ctx->nb_controllers; i++) { + if (ctx->controllers[i] == intf) + return 0; + if (ctx->controllers[i] > intf) + break; + } + target = i; + + ctx->nb_controllers += 1; + new_size = ctx->nb_controllers * sizeof(ctx->controllers[0]); + + new_controllers = rte_realloc(ctx->controllers, new_size, 0); + if (new_controllers == NULL) { + rte_free(ctx->controllers); + return ENOMEM; + } + ctx->controllers = new_controllers; + + for (i = target + 1; i < ctx->nb_controllers; i++) + ctx->controllers[i] = ctx->controllers[i - 1]; + + ctx->controllers[target] = intf; + + return 0; +} + +static efx_rc_t +sfc_process_mport_journal_entry(struct sfc_mport_journal_ctx *ctx, + efx_mport_desc_t *mport) +{ + efx_mport_sel_t ethdev_mport; + int rc; + + sfc_dbg(ctx->sa, + "processing mport id %u (controller %u pf %u vf %u)", + mport->emd_id.id, mport->emd_vnic.ev_intf, + mport->emd_vnic.ev_pf, mport->emd_vnic.ev_vf); + efx_mae_mport_invalid(ðdev_mport); + + if (!ctx->controllers_assigned) { + rc = sfc_journal_ctx_add_controller(ctx, + mport->emd_vnic.ev_intf); + if (rc != 0) + return rc; + } + + return 0; +} + +static efx_rc_t +sfc_process_mport_journal_cb(void *data, efx_mport_desc_t *mport, + size_t mport_len) +{ + struct sfc_mport_journal_ctx *ctx = data; + + if (ctx == NULL || ctx->sa == NULL) { + sfc_err(ctx->sa, "received NULL context or SFC adapter"); + return EINVAL; + } + + if (mport_len != sizeof(*mport)) { + sfc_err(ctx->sa, "actual and expected mport buffer sizes differ"); + return EINVAL; + } + + SFC_ASSERT(sfc_adapter_is_locked(ctx->sa)); + + /* + * If a zombie flag is set, it means the mport has been marked for + * deletion and cannot be used for any new operations. The mport will + * be destroyed completely once all references to it are released. + */ + if (mport->emd_zombie) { + sfc_dbg(ctx->sa, "mport is a zombie, skipping"); + return 0; + } + if (mport->emd_type != EFX_MPORT_TYPE_VNIC) { + sfc_dbg(ctx->sa, "mport is not a VNIC, skipping"); + return 0; + } + if (mport->emd_vnic.ev_client_type != EFX_MPORT_VNIC_CLIENT_FUNCTION) { + sfc_dbg(ctx->sa, "mport is not a function, skipping"); + return 0; + } + if (mport->emd_vnic.ev_handle == ctx->mcdi_handle) { + sfc_dbg(ctx->sa, "mport is this driver instance, skipping"); + return 0; + } + + return sfc_process_mport_journal_entry(ctx, mport); +} + +static int +sfc_process_mport_journal(struct sfc_adapter *sa) +{ + struct sfc_mport_journal_ctx ctx; + const efx_pcie_interface_t *controllers; + size_t nb_controllers; + efx_rc_t efx_rc; + int rc; + + memset(&ctx, 0, sizeof(ctx)); + ctx.sa = sa; + ctx.switch_domain_id = sa->mae.switch_domain_id; + + efx_rc = efx_mcdi_get_own_client_handle(sa->nic, &ctx.mcdi_handle); + if (efx_rc != 0) { + sfc_err(sa, "failed to get own MCDI handle"); + SFC_ASSERT(efx_rc > 0); + return efx_rc; + } + + rc = sfc_mae_switch_domain_controllers(ctx.switch_domain_id, + &controllers, &nb_controllers); + if (rc != 0) { + sfc_err(sa, "failed to get controller mapping"); + return rc; + } + + ctx.controllers_assigned = controllers != NULL; + ctx.controllers = NULL; + ctx.nb_controllers = 0; + + efx_rc = efx_mae_read_mport_journal(sa->nic, + sfc_process_mport_journal_cb, &ctx); + if (efx_rc != 0) { + sfc_err(sa, "failed to process MAE mport journal"); + SFC_ASSERT(efx_rc > 0); + return efx_rc; + } + + if (controllers == NULL) { + rc = sfc_mae_switch_domain_map_controllers(ctx.switch_domain_id, + ctx.controllers, + ctx.nb_controllers); + if (rc != 0) + return rc; + } + + return 0; +} + static const struct eth_dev_ops sfc_eth_dev_ops = { .dev_configure = sfc_dev_configure, .dev_start = sfc_dev_start, @@ -2531,18 +2703,143 @@ sfc_eth_dev_find_or_create(struct rte_pci_device *pci_dev, return 0; } +static int +sfc_eth_dev_create_repr(struct sfc_adapter *sa, + efx_pcie_interface_t controller, + uint16_t port, + uint16_t repr_port, + enum rte_eth_representor_type type) +{ + struct sfc_repr_entity_info entity; + efx_mport_sel_t mport_sel; + int rc; + + switch (type) { + case RTE_ETH_REPRESENTOR_NONE: + return 0; + case RTE_ETH_REPRESENTOR_VF: + case RTE_ETH_REPRESENTOR_PF: + break; + case RTE_ETH_REPRESENTOR_SF: + sfc_err(sa, "SF representors are not supported"); + return ENOTSUP; + default: + sfc_err(sa, "unknown representor type: %d", type); + return ENOTSUP; + } + + rc = efx_mae_mport_by_pcie_mh_function(controller, + port, + repr_port, + &mport_sel); + if (rc != 0) { + sfc_err(sa, + "failed to get m-port selector for controller %u port %u repr_port %u: %s", + controller, port, repr_port, rte_strerror(-rc)); + return rc; + } + + memset(&entity, 0, sizeof(entity)); + entity.type = type; + entity.intf = controller; + entity.pf = port; + entity.vf = repr_port; + + rc = sfc_repr_create(sa->eth_dev, &entity, sa->mae.switch_domain_id, + &mport_sel); + if (rc != 0) { + sfc_err(sa, + "failed to create representor for controller %u port %u repr_port %u: %s", + controller, port, repr_port, rte_strerror(-rc)); + return rc; + } + + return 0; +} + +static int +sfc_eth_dev_create_repr_port(struct sfc_adapter *sa, + const struct rte_eth_devargs *eth_da, + efx_pcie_interface_t controller, + uint16_t port) +{ + int first_error = 0; + uint16_t i; + int rc; + + if (eth_da->type == RTE_ETH_REPRESENTOR_PF) { + return sfc_eth_dev_create_repr(sa, controller, port, + EFX_PCI_VF_INVALID, + eth_da->type); + } + + for (i = 0; i < eth_da->nb_representor_ports; i++) { + rc = sfc_eth_dev_create_repr(sa, controller, port, + eth_da->representor_ports[i], + eth_da->type); + if (rc != 0 && first_error == 0) + first_error = rc; + } + + return first_error; +} + +static int +sfc_eth_dev_create_repr_controller(struct sfc_adapter *sa, + const struct rte_eth_devargs *eth_da, + efx_pcie_interface_t controller) +{ + const efx_nic_cfg_t *encp; + int first_error = 0; + uint16_t default_port; + uint16_t i; + int rc; + + if (eth_da->nb_ports == 0) { + encp = efx_nic_cfg_get(sa->nic); + default_port = encp->enc_intf == controller ? encp->enc_pf : 0; + return sfc_eth_dev_create_repr_port(sa, eth_da, controller, + default_port); + } + + for (i = 0; i < eth_da->nb_ports; i++) { + rc = sfc_eth_dev_create_repr_port(sa, eth_da, controller, + eth_da->ports[i]); + if (rc != 0 && first_error == 0) + first_error = rc; + } + + return first_error; +} + static int sfc_eth_dev_create_representors(struct rte_eth_dev *dev, const struct rte_eth_devargs *eth_da) { + efx_pcie_interface_t intf; + const efx_nic_cfg_t *encp; struct sfc_adapter *sa; - unsigned int i; + uint16_t switch_domain_id; + uint16_t i; int rc; - if (eth_da->nb_representor_ports == 0) - return 0; - sa = sfc_adapter_by_eth_dev(dev); + switch_domain_id = sa->mae.switch_domain_id; + + switch (eth_da->type) { + case RTE_ETH_REPRESENTOR_NONE: + return 0; + case RTE_ETH_REPRESENTOR_PF: + case RTE_ETH_REPRESENTOR_VF: + break; + case RTE_ETH_REPRESENTOR_SF: + sfc_err(sa, "SF representors are not supported"); + return -ENOTSUP; + default: + sfc_err(sa, "unknown representor type: %d", + eth_da->type); + return -ENOTSUP; + } if (!sa->switchdev) { sfc_err(sa, "cannot create representors in non-switchdev mode"); @@ -2555,27 +2852,32 @@ sfc_eth_dev_create_representors(struct rte_eth_dev *dev, return -ENOTSUP; } - for (i = 0; i < eth_da->nb_representor_ports; ++i) { - const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic); - efx_mport_sel_t mport_sel; - - rc = efx_mae_mport_by_pcie_function(encp->enc_pf, - eth_da->representor_ports[i], &mport_sel); - if (rc != 0) { - sfc_err(sa, - "failed to get representor %u m-port: %s - ignore", - eth_da->representor_ports[i], - rte_strerror(-rc)); - continue; - } + /* + * This is needed to construct the DPDK controller -> EFX interface + * mapping. + */ + sfc_adapter_lock(sa); + rc = sfc_process_mport_journal(sa); + sfc_adapter_unlock(sa); + if (rc != 0) { + SFC_ASSERT(rc > 0); + return -rc; + } - rc = sfc_repr_create(dev, eth_da->representor_ports[i], - sa->mae.switch_domain_id, &mport_sel); - if (rc != 0) { - sfc_err(sa, "cannot create representor %u: %s - ignore", - eth_da->representor_ports[i], - rte_strerror(-rc)); + if (eth_da->nb_mh_controllers > 0) { + for (i = 0; i < eth_da->nb_mh_controllers; i++) { + rc = sfc_mae_switch_domain_get_intf(switch_domain_id, + eth_da->mh_controllers[i], + &intf); + if (rc != 0) { + sfc_err(sa, "failed to get representor"); + continue; + } + sfc_eth_dev_create_repr_controller(sa, eth_da, intf); } + } else { + encp = efx_nic_cfg_get(sa->nic); + sfc_eth_dev_create_repr_controller(sa, eth_da, encp->enc_intf); } return 0; @@ -2599,9 +2901,13 @@ static int sfc_eth_dev_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, memset(ð_da, 0, sizeof(eth_da)); } - init_data.nb_representors = eth_da.nb_representor_ports; + /* If no VF representors specified, check for PF ones */ + if (eth_da.nb_representor_ports > 0) + init_data.nb_representors = eth_da.nb_representor_ports; + else + init_data.nb_representors = eth_da.nb_ports; - if (eth_da.nb_representor_ports > 0 && + if (init_data.nb_representors > 0 && rte_eal_process_type() != RTE_PROC_PRIMARY) { SFC_GENERIC_LOG(ERR, "Create representors from secondary process not supported, dev '%s'",