X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fsfc%2Fsfc_rx.c;h=4b1d01e66d145820d7a9c516c9da55453a0c3fdb;hb=de90612f4061a1bd538ad894f1ed18bcf11d335b;hp=3c1e779747ab2fe879bb05ae0196b2decad4bdfd;hpb=b76e1b2c918376d871314be44ff090685b39a1e5;p=dpdk.git diff --git a/drivers/net/sfc/sfc_rx.c b/drivers/net/sfc/sfc_rx.c index 3c1e779747..4b1d01e66d 100644 --- a/drivers/net/sfc/sfc_rx.c +++ b/drivers/net/sfc/sfc_rx.c @@ -381,31 +381,37 @@ sfc_rxq_info_by_dp_rxq(const struct sfc_dp_rxq *dp_rxq) { const struct sfc_dp_queue *dpq = &dp_rxq->dpq; struct rte_eth_dev *eth_dev; - struct sfc_adapter *sa; + struct sfc_adapter_shared *sas; SFC_ASSERT(rte_eth_dev_is_valid_port(dpq->port_id)); eth_dev = &rte_eth_devices[dpq->port_id]; - sa = eth_dev->data->dev_private; + sas = sfc_adapter_shared_by_eth_dev(eth_dev); - SFC_ASSERT(dpq->queue_id < sa->rxq_count); - return &sa->rxq_info[dpq->queue_id]; + SFC_ASSERT(dpq->queue_id < sas->rxq_count); + return &sas->rxq_info[dpq->queue_id]; } struct sfc_rxq * sfc_rxq_by_dp_rxq(const struct sfc_dp_rxq *dp_rxq) { - struct sfc_rxq_info *rxq_info; + const struct sfc_dp_queue *dpq = &dp_rxq->dpq; + struct rte_eth_dev *eth_dev; + struct sfc_adapter *sa; + + SFC_ASSERT(rte_eth_dev_is_valid_port(dpq->port_id)); + eth_dev = &rte_eth_devices[dpq->port_id]; - rxq_info = sfc_rxq_info_by_dp_rxq(dp_rxq); + sa = sfc_adapter_by_eth_dev(eth_dev); - SFC_ASSERT(rxq_info->rxq != NULL); - return rxq_info->rxq; + SFC_ASSERT(dpq->queue_id < sfc_sa2shared(sa)->rxq_count); + return &sa->rxq_ctrl[dpq->queue_id]; } static sfc_dp_rx_qsize_up_rings_t sfc_efx_rx_qsize_up_rings; static int sfc_efx_rx_qsize_up_rings(uint16_t nb_rx_desc, + __rte_unused struct sfc_dp_rx_hw_limits *limits, __rte_unused struct rte_mempool *mb_pool, unsigned int *rxq_entries, unsigned int *evq_entries, @@ -562,10 +568,11 @@ sfc_rx_qflush(struct sfc_adapter *sa, unsigned int sw_index) unsigned int wait_count; int rc; - rxq_info = &sa->rxq_info[sw_index]; - rxq = rxq_info->rxq; + rxq_info = &sfc_sa2shared(sa)->rxq_info[sw_index]; SFC_ASSERT(rxq_info->state & SFC_RXQ_STARTED); + rxq = &sa->rxq_ctrl[sw_index]; + /* * Retry Rx queue flushing in the case of flush failed or * timeout. In the worst case it can delay for 6 seconds. @@ -612,7 +619,7 @@ sfc_rx_qflush(struct sfc_adapter *sa, unsigned int sw_index) static int sfc_rx_default_rxq_set_filter(struct sfc_adapter *sa, struct sfc_rxq *rxq) { - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sfc_sa2shared(sa)->rss; boolean_t need_rss = (rss->channels > 0) ? B_TRUE : B_FALSE; struct sfc_port *port = &sa->port; int rc; @@ -663,7 +670,6 @@ retry: int sfc_rx_qstart(struct sfc_adapter *sa, unsigned int sw_index) { - struct sfc_port *port = &sa->port; struct sfc_rxq_info *rxq_info; struct sfc_rxq *rxq; struct sfc_evq *evq; @@ -671,13 +677,12 @@ sfc_rx_qstart(struct sfc_adapter *sa, unsigned int sw_index) sfc_log_init(sa, "sw_index=%u", sw_index); - SFC_ASSERT(sw_index < sa->rxq_count); + SFC_ASSERT(sw_index < sfc_sa2shared(sa)->rxq_count); - rxq_info = &sa->rxq_info[sw_index]; - rxq = rxq_info->rxq; - SFC_ASSERT(rxq != NULL); + rxq_info = &sfc_sa2shared(sa)->rxq_info[sw_index]; SFC_ASSERT(rxq_info->state == SFC_RXQ_INITIALIZED); + rxq = &sa->rxq_ctrl[sw_index]; evq = rxq->evq; rc = sfc_ev_qstart(evq, sfc_evq_index_by_rxq_sw_index(sa, sw_index)); @@ -687,6 +692,7 @@ sfc_rx_qstart(struct sfc_adapter *sa, unsigned int sw_index) switch (rxq_info->type) { case EFX_RXQ_TYPE_DEFAULT: rc = efx_rx_qcreate(sa->nic, rxq->hw_index, 0, rxq_info->type, + rxq->buf_size, &rxq->mem, rxq_info->entries, 0 /* not used on EF10 */, rxq_info->type_flags, evq->common, &rxq->common); break; @@ -726,7 +732,7 @@ sfc_rx_qstart(struct sfc_adapter *sa, unsigned int sw_index) rxq_info->state |= SFC_RXQ_STARTED; - if ((sw_index == 0) && !port->isolated) { + if (sw_index == 0 && !sfc_sa2shared(sa)->isolated) { rc = sfc_rx_default_rxq_set_filter(sa, rxq); if (rc != 0) goto fail_mac_filter_default_rxq_set; @@ -761,12 +767,11 @@ sfc_rx_qstop(struct sfc_adapter *sa, unsigned int sw_index) sfc_log_init(sa, "sw_index=%u", sw_index); - SFC_ASSERT(sw_index < sa->rxq_count); + SFC_ASSERT(sw_index < sfc_sa2shared(sa)->rxq_count); - rxq_info = &sa->rxq_info[sw_index]; - rxq = rxq_info->rxq; + rxq_info = &sfc_sa2shared(sa)->rxq_info[sw_index]; - if (rxq == NULL || rxq_info->state == SFC_RXQ_INITIALIZED) + if (rxq_info->state == SFC_RXQ_INITIALIZED) return; SFC_ASSERT(rxq_info->state & SFC_RXQ_STARTED); @@ -774,6 +779,7 @@ sfc_rx_qstop(struct sfc_adapter *sa, unsigned int sw_index) sa->eth_dev->data->rx_queue_state[sw_index] = RTE_ETH_QUEUE_STATE_STOPPED; + rxq = &sa->rxq_ctrl[sw_index]; sa->priv.dp_rx->qstop(rxq_info->dp, &rxq->evq->read_ptr); if (sw_index == 0) @@ -956,7 +962,7 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, struct rte_mempool *mb_pool) { const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic); - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sfc_sa2shared(sa)->rss; int rc; unsigned int rxq_entries; unsigned int evq_entries; @@ -967,13 +973,21 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, struct sfc_evq *evq; struct sfc_rxq *rxq; struct sfc_dp_rx_qcreate_info info; + struct sfc_dp_rx_hw_limits hw_limits; - rc = sa->priv.dp_rx->qsize_up_rings(nb_rx_desc, mb_pool, &rxq_entries, - &evq_entries, &rxq_max_fill_level); + memset(&hw_limits, 0, sizeof(hw_limits)); + hw_limits.rxq_max_entries = sa->rxq_max_entries; + hw_limits.rxq_min_entries = sa->rxq_min_entries; + hw_limits.evq_max_entries = sa->evq_max_entries; + hw_limits.evq_min_entries = sa->evq_min_entries; + + rc = sa->priv.dp_rx->qsize_up_rings(nb_rx_desc, &hw_limits, mb_pool, + &rxq_entries, &evq_entries, + &rxq_max_fill_level); if (rc != 0) goto fail_size_up_rings; - SFC_ASSERT(rxq_entries >= EFX_RXQ_MINNDESCS); - SFC_ASSERT(rxq_entries <= EFX_RXQ_MAXNDESCS); + SFC_ASSERT(rxq_entries >= sa->rxq_min_entries); + SFC_ASSERT(rxq_entries <= sa->rxq_max_entries); SFC_ASSERT(rxq_max_fill_level <= nb_rx_desc); offloads = rx_conf->offloads | @@ -1002,8 +1016,8 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, goto fail_bad_conf; } - SFC_ASSERT(sw_index < sa->rxq_count); - rxq_info = &sa->rxq_info[sw_index]; + SFC_ASSERT(sw_index < sfc_sa2shared(sa)->rxq_count); + rxq_info = &sfc_sa2shared(sa)->rxq_info[sw_index]; SFC_ASSERT(rxq_entries <= rxq_info->max_entries); rxq_info->entries = rxq_entries; @@ -1026,14 +1040,7 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, if (rc != 0) goto fail_ev_qinit; - rc = ENOMEM; - rxq = rte_zmalloc_socket("sfc-rxq", sizeof(*rxq), RTE_CACHE_LINE_SIZE, - socket_id); - if (rxq == NULL) - goto fail_rxq_alloc; - - rxq_info->rxq = rxq; - + rxq = &sa->rxq_ctrl[sw_index]; rxq->evq = evq; rxq->hw_index = sw_index; rxq_info->refill_threshold = @@ -1041,7 +1048,8 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, rxq_info->refill_mb_pool = mb_pool; rxq->buf_size = buf_size; - rc = sfc_dma_alloc(sa, "rxq", sw_index, EFX_RXQ_SIZE(rxq_info->entries), + rc = sfc_dma_alloc(sa, "rxq", sw_index, + efx_rxq_size(sa->nic, rxq_info->entries), socket_id, &rxq->mem); if (rc != 0) goto fail_dma_alloc; @@ -1083,10 +1091,6 @@ fail_dp_rx_qcreate: sfc_dma_free(sa, &rxq->mem); fail_dma_alloc: - rxq_info->rxq = NULL; - rte_free(rxq); - -fail_rxq_alloc: sfc_ev_qfini(evq); fail_ev_qinit: @@ -1104,26 +1108,25 @@ sfc_rx_qfini(struct sfc_adapter *sa, unsigned int sw_index) struct sfc_rxq_info *rxq_info; struct sfc_rxq *rxq; - SFC_ASSERT(sw_index < sa->rxq_count); + SFC_ASSERT(sw_index < sfc_sa2shared(sa)->rxq_count); sa->eth_dev->data->rx_queues[sw_index] = NULL; - rxq_info = &sa->rxq_info[sw_index]; + rxq_info = &sfc_sa2shared(sa)->rxq_info[sw_index]; - rxq = rxq_info->rxq; SFC_ASSERT(rxq_info->state == SFC_RXQ_INITIALIZED); sa->priv.dp_rx->qdestroy(rxq_info->dp); rxq_info->dp = NULL; - rxq_info->rxq = NULL; + rxq_info->state &= ~SFC_RXQ_INITIALIZED; rxq_info->entries = 0; + rxq = &sa->rxq_ctrl[sw_index]; + sfc_dma_free(sa, &rxq->mem); sfc_ev_qfini(rxq->evq); rxq->evq = NULL; - - rte_free(rxq); } /* @@ -1183,7 +1186,7 @@ sfc_rx_hash_types_mask_supp(efx_rx_hash_type_t hash_type, int sfc_rx_hash_init(struct sfc_adapter *sa) { - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sfc_sa2shared(sa)->rss; const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic); uint32_t alg_mask = encp->enc_rx_scale_hash_alg_mask; efx_rx_hash_alg_t alg; @@ -1239,7 +1242,7 @@ sfc_rx_hash_init(struct sfc_adapter *sa) void sfc_rx_hash_fini(struct sfc_adapter *sa) { - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sfc_sa2shared(sa)->rss; rte_free(rss->hf_map); } @@ -1248,7 +1251,7 @@ int sfc_rx_hf_rte_to_efx(struct sfc_adapter *sa, uint64_t rte, efx_rx_hash_type_t *efx) { - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sfc_sa2shared(sa)->rss; efx_rx_hash_type_t hash_types = 0; unsigned int i; @@ -1272,9 +1275,8 @@ sfc_rx_hf_rte_to_efx(struct sfc_adapter *sa, uint64_t rte, } uint64_t -sfc_rx_hf_efx_to_rte(struct sfc_adapter *sa, efx_rx_hash_type_t efx) +sfc_rx_hf_efx_to_rte(struct sfc_rss *rss, efx_rx_hash_type_t efx) { - struct sfc_rss *rss = &sa->rss; uint64_t rte = 0; unsigned int i; @@ -1292,9 +1294,9 @@ static int sfc_rx_process_adv_conf_rss(struct sfc_adapter *sa, struct rte_eth_rss_conf *conf) { - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sfc_sa2shared(sa)->rss; efx_rx_hash_type_t efx_hash_types = rss->hash_types; - uint64_t rss_hf = sfc_rx_hf_efx_to_rte(sa, efx_hash_types); + uint64_t rss_hf = sfc_rx_hf_efx_to_rte(rss, efx_hash_types); int rc; if (rss->context_type != EFX_RX_SCALE_EXCLUSIVE) { @@ -1326,7 +1328,7 @@ sfc_rx_process_adv_conf_rss(struct sfc_adapter *sa, static int sfc_rx_rss_config(struct sfc_adapter *sa) { - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sfc_sa2shared(sa)->rss; int rc = 0; if (rss->channels > 0) { @@ -1352,10 +1354,11 @@ finish: int sfc_rx_start(struct sfc_adapter *sa) { + struct sfc_adapter_shared * const sas = sfc_sa2shared(sa); unsigned int sw_index; int rc; - sfc_log_init(sa, "rxq_count=%u", sa->rxq_count); + sfc_log_init(sa, "rxq_count=%u", sas->rxq_count); rc = efx_rx_init(sa->nic); if (rc != 0) @@ -1365,10 +1368,10 @@ sfc_rx_start(struct sfc_adapter *sa) if (rc != 0) goto fail_rss_config; - for (sw_index = 0; sw_index < sa->rxq_count; ++sw_index) { - if (sa->rxq_info[sw_index].rxq != NULL && - (!sa->rxq_info[sw_index].deferred_start || - sa->rxq_info[sw_index].deferred_started)) { + for (sw_index = 0; sw_index < sas->rxq_count; ++sw_index) { + if (sas->rxq_info[sw_index].state == SFC_RXQ_INITIALIZED && + (!sas->rxq_info[sw_index].deferred_start || + sas->rxq_info[sw_index].deferred_started)) { rc = sfc_rx_qstart(sa, sw_index); if (rc != 0) goto fail_rx_qstart; @@ -1392,13 +1395,14 @@ fail_rx_init: void sfc_rx_stop(struct sfc_adapter *sa) { + struct sfc_adapter_shared * const sas = sfc_sa2shared(sa); unsigned int sw_index; - sfc_log_init(sa, "rxq_count=%u", sa->rxq_count); + sfc_log_init(sa, "rxq_count=%u", sas->rxq_count); - sw_index = sa->rxq_count; + sw_index = sas->rxq_count; while (sw_index-- > 0) { - if (sa->rxq_info[sw_index].rxq != NULL) + if (sas->rxq_info[sw_index].state & SFC_RXQ_STARTED) sfc_rx_qstop(sa, sw_index); } @@ -1408,10 +1412,12 @@ sfc_rx_stop(struct sfc_adapter *sa) static int sfc_rx_qinit_info(struct sfc_adapter *sa, unsigned int sw_index) { - struct sfc_rxq_info *rxq_info = &sa->rxq_info[sw_index]; + struct sfc_adapter_shared * const sas = sfc_sa2shared(sa); + struct sfc_rxq_info *rxq_info = &sas->rxq_info[sw_index]; + const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic); unsigned int max_entries; - max_entries = EFX_RXQ_MAXNDESCS; + max_entries = encp->enc_rxq_max_ndescs; SFC_ASSERT(rte_is_power_of_2(max_entries)); rxq_info->max_entries = max_entries; @@ -1422,9 +1428,10 @@ sfc_rx_qinit_info(struct sfc_adapter *sa, unsigned int sw_index) static int sfc_rx_check_mode(struct sfc_adapter *sa, struct rte_eth_rxmode *rxmode) { + struct sfc_adapter_shared * const sas = sfc_sa2shared(sa); uint64_t offloads_supported = sfc_rx_get_dev_offload_caps(sa) | sfc_rx_get_queue_offload_caps(sa); - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sas->rss; int rc = 0; switch (rxmode->mq_mode) { @@ -1470,17 +1477,18 @@ sfc_rx_check_mode(struct sfc_adapter *sa, struct rte_eth_rxmode *rxmode) static void sfc_rx_fini_queues(struct sfc_adapter *sa, unsigned int nb_rx_queues) { + struct sfc_adapter_shared * const sas = sfc_sa2shared(sa); int sw_index; - SFC_ASSERT(nb_rx_queues <= sa->rxq_count); + SFC_ASSERT(nb_rx_queues <= sas->rxq_count); - sw_index = sa->rxq_count; + sw_index = sas->rxq_count; while (--sw_index >= (int)nb_rx_queues) { - if (sa->rxq_info[sw_index].rxq != NULL) + if (sas->rxq_info[sw_index].state & SFC_RXQ_INITIALIZED) sfc_rx_qfini(sa, sw_index); } - sa->rxq_count = nb_rx_queues; + sas->rxq_count = nb_rx_queues; } /** @@ -1494,59 +1502,81 @@ sfc_rx_fini_queues(struct sfc_adapter *sa, unsigned int nb_rx_queues) int sfc_rx_configure(struct sfc_adapter *sa) { - struct sfc_rss *rss = &sa->rss; + struct sfc_adapter_shared * const sas = sfc_sa2shared(sa); + struct sfc_rss *rss = &sas->rss; struct rte_eth_conf *dev_conf = &sa->eth_dev->data->dev_conf; const unsigned int nb_rx_queues = sa->eth_dev->data->nb_rx_queues; int rc; sfc_log_init(sa, "nb_rx_queues=%u (old %u)", - nb_rx_queues, sa->rxq_count); + nb_rx_queues, sas->rxq_count); rc = sfc_rx_check_mode(sa, &dev_conf->rxmode); if (rc != 0) goto fail_check_mode; - if (nb_rx_queues == sa->rxq_count) + if (nb_rx_queues == sas->rxq_count) goto configure_rss; - if (sa->rxq_info == NULL) { + if (sas->rxq_info == NULL) { rc = ENOMEM; - sa->rxq_info = rte_calloc_socket("sfc-rxqs", nb_rx_queues, - sizeof(sa->rxq_info[0]), 0, - sa->socket_id); - if (sa->rxq_info == NULL) + sas->rxq_info = rte_calloc_socket("sfc-rxqs", nb_rx_queues, + sizeof(sas->rxq_info[0]), 0, + sa->socket_id); + if (sas->rxq_info == NULL) goto fail_rxqs_alloc; + + /* + * Allocate primary process only RxQ control from heap + * since it should not be shared. + */ + rc = ENOMEM; + sa->rxq_ctrl = calloc(nb_rx_queues, sizeof(sa->rxq_ctrl[0])); + if (sa->rxq_ctrl == NULL) + goto fail_rxqs_ctrl_alloc; } else { struct sfc_rxq_info *new_rxq_info; + struct sfc_rxq *new_rxq_ctrl; - if (nb_rx_queues < sa->rxq_count) + if (nb_rx_queues < sas->rxq_count) sfc_rx_fini_queues(sa, nb_rx_queues); rc = ENOMEM; new_rxq_info = - rte_realloc(sa->rxq_info, - nb_rx_queues * sizeof(sa->rxq_info[0]), 0); + rte_realloc(sas->rxq_info, + nb_rx_queues * sizeof(sas->rxq_info[0]), 0); if (new_rxq_info == NULL && nb_rx_queues > 0) goto fail_rxqs_realloc; - sa->rxq_info = new_rxq_info; - if (nb_rx_queues > sa->rxq_count) - memset(&sa->rxq_info[sa->rxq_count], 0, - (nb_rx_queues - sa->rxq_count) * - sizeof(sa->rxq_info[0])); + rc = ENOMEM; + new_rxq_ctrl = realloc(sa->rxq_ctrl, + nb_rx_queues * sizeof(sa->rxq_ctrl[0])); + if (new_rxq_ctrl == NULL && nb_rx_queues > 0) + goto fail_rxqs_ctrl_realloc; + + sas->rxq_info = new_rxq_info; + sa->rxq_ctrl = new_rxq_ctrl; + if (nb_rx_queues > sas->rxq_count) { + memset(&sas->rxq_info[sas->rxq_count], 0, + (nb_rx_queues - sas->rxq_count) * + sizeof(sas->rxq_info[0])); + memset(&sa->rxq_ctrl[sas->rxq_count], 0, + (nb_rx_queues - sas->rxq_count) * + sizeof(sa->rxq_ctrl[0])); + } } - while (sa->rxq_count < nb_rx_queues) { - rc = sfc_rx_qinit_info(sa, sa->rxq_count); + while (sas->rxq_count < nb_rx_queues) { + rc = sfc_rx_qinit_info(sa, sas->rxq_count); if (rc != 0) goto fail_rx_qinit_info; - sa->rxq_count++; + sas->rxq_count++; } configure_rss: rss->channels = (dev_conf->rxmode.mq_mode == ETH_MQ_RX_RSS) ? - MIN(sa->rxq_count, EFX_MAXRSS) : 0; + MIN(sas->rxq_count, EFX_MAXRSS) : 0; if (rss->channels > 0) { struct rte_eth_rss_conf *adv_conf_rss; @@ -1565,7 +1595,9 @@ configure_rss: fail_rx_process_adv_conf_rss: fail_rx_qinit_info: +fail_rxqs_ctrl_realloc: fail_rxqs_realloc: +fail_rxqs_ctrl_alloc: fail_rxqs_alloc: sfc_rx_close(sa); @@ -1582,12 +1614,15 @@ fail_check_mode: void sfc_rx_close(struct sfc_adapter *sa) { - struct sfc_rss *rss = &sa->rss; + struct sfc_rss *rss = &sfc_sa2shared(sa)->rss; sfc_rx_fini_queues(sa, 0); rss->channels = 0; - rte_free(sa->rxq_info); - sa->rxq_info = NULL; + free(sa->rxq_ctrl); + sa->rxq_ctrl = NULL; + + rte_free(sfc_sa2shared(sa)->rxq_info); + sfc_sa2shared(sa)->rxq_info = NULL; }