X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fsfc%2Fsfc_rx.c;h=a9217ada9d9b6b1ab96fe2bf5b2955eef9dadfe0;hb=0cb551b690c1c52de3e35ea67c502ddf4477a62b;hp=3b4b65f6e6c6f8a03a9bc65f28baa24a07a58c7f;hpb=e295f175bf503b011b2634023dd0f20f47763ed8;p=dpdk.git diff --git a/drivers/net/sfc/sfc_rx.c b/drivers/net/sfc/sfc_rx.c index 3b4b65f6e6..a9217ada9d 100644 --- a/drivers/net/sfc/sfc_rx.c +++ b/drivers/net/sfc/sfc_rx.c @@ -1,7 +1,7 @@ /* SPDX-License-Identifier: BSD-3-Clause * - * Copyright (c) 2016-2018 Solarflare Communications Inc. - * All rights reserved. + * Copyright(c) 2019-2020 Xilinx, Inc. + * Copyright(c) 2016-2019 Solarflare Communications Inc. * * This software was jointly developed between OKTET Labs (under contract * for Solarflare) and Solarflare Communications, Inc. @@ -52,6 +52,19 @@ sfc_rx_qflush_failed(struct sfc_rxq_info *rxq_info) rxq_info->state &= ~SFC_RXQ_FLUSHING; } +static int +sfc_efx_rx_qprime(struct sfc_efx_rxq *rxq) +{ + int rc = 0; + + if (rxq->evq->read_ptr_primed != rxq->evq->read_ptr) { + rc = efx_ev_qprime(rxq->evq->common, rxq->evq->read_ptr); + if (rc == 0) + rxq->evq->read_ptr_primed = rxq->evq->read_ptr; + } + return rc; +} + static void sfc_efx_rx_qrefill(struct sfc_efx_rxq *rxq) { @@ -306,6 +319,9 @@ discard: sfc_efx_rx_qrefill(rxq); + if (rxq->flags & SFC_EFX_RXQ_FLAG_INTR_EN) + sfc_efx_rx_qprime(rxq); + return done_pkts; } @@ -360,6 +376,28 @@ sfc_efx_rx_qdesc_status(struct sfc_dp_rxq *dp_rxq, uint16_t offset) return RTE_ETH_RX_DESC_UNAVAIL; } +boolean_t +sfc_rx_check_scatter(size_t pdu, size_t rx_buf_size, uint32_t rx_prefix_size, + boolean_t rx_scatter_enabled, uint32_t rx_scatter_max, + const char **error) +{ + uint32_t effective_rx_scatter_max; + uint32_t rx_scatter_bufs; + + effective_rx_scatter_max = rx_scatter_enabled ? rx_scatter_max : 1; + rx_scatter_bufs = EFX_DIV_ROUND_UP(pdu + rx_prefix_size, rx_buf_size); + + if (rx_scatter_bufs > effective_rx_scatter_max) { + if (rx_scatter_enabled) + *error = "Possible number of Rx scatter buffers exceeds maximum number"; + else + *error = "Rx scatter is disabled and RxQ mbuf pool object size is too small"; + return B_FALSE; + } + + return B_TRUE; +} + /** Get Rx datapath ops by the datapath RxQ handle */ const struct sfc_dp_rx * sfc_dp_rx_by_dp_rxq(const struct sfc_dp_rxq *dp_rxq) @@ -402,7 +440,7 @@ sfc_rxq_by_dp_rxq(const struct sfc_dp_rxq *dp_rxq) 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; + sa = sfc_adapter_by_eth_dev(eth_dev); SFC_ASSERT(dpq->queue_id < sfc_sa2shared(sa)->rxq_count); return &sa->rxq_ctrl[dpq->queue_id]; @@ -411,6 +449,7 @@ sfc_rxq_by_dp_rxq(const struct sfc_dp_rxq *dp_rxq) 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, @@ -480,6 +519,12 @@ sfc_efx_rx_qdestroy(struct sfc_dp_rxq *dp_rxq) rte_free(rxq); } + +/* Use qstop and qstart functions in the case of qstart failure */ +static sfc_dp_rx_qstop_t sfc_efx_rx_qstop; +static sfc_dp_rx_qpurge_t sfc_efx_rx_qpurge; + + static sfc_dp_rx_qstart_t sfc_efx_rx_qstart; static int sfc_efx_rx_qstart(struct sfc_dp_rxq *dp_rxq, @@ -488,6 +533,7 @@ sfc_efx_rx_qstart(struct sfc_dp_rxq *dp_rxq, /* libefx-based datapath is specific to libefx-based PMD */ struct sfc_efx_rxq *rxq = sfc_efx_rxq_by_dp_rxq(dp_rxq); struct sfc_rxq *crxq = sfc_rxq_by_dp_rxq(dp_rxq); + int rc; rxq->common = crxq->common; @@ -497,10 +543,20 @@ sfc_efx_rx_qstart(struct sfc_dp_rxq *dp_rxq, rxq->flags |= (SFC_EFX_RXQ_FLAG_STARTED | SFC_EFX_RXQ_FLAG_RUNNING); + if (rxq->flags & SFC_EFX_RXQ_FLAG_INTR_EN) { + rc = sfc_efx_rx_qprime(rxq); + if (rc != 0) + goto fail_rx_qprime; + } + return 0; + +fail_rx_qprime: + sfc_efx_rx_qstop(dp_rxq, NULL); + sfc_efx_rx_qpurge(dp_rxq); + return rc; } -static sfc_dp_rx_qstop_t sfc_efx_rx_qstop; static void sfc_efx_rx_qstop(struct sfc_dp_rxq *dp_rxq, __rte_unused unsigned int *evq_read_ptr) @@ -515,7 +571,6 @@ sfc_efx_rx_qstop(struct sfc_dp_rxq *dp_rxq, */ } -static sfc_dp_rx_qpurge_t sfc_efx_rx_qpurge; static void sfc_efx_rx_qpurge(struct sfc_dp_rxq *dp_rxq) { @@ -538,14 +593,43 @@ sfc_efx_rx_qpurge(struct sfc_dp_rxq *dp_rxq) rxq->flags &= ~SFC_EFX_RXQ_FLAG_STARTED; } +static sfc_dp_rx_intr_enable_t sfc_efx_rx_intr_enable; +static int +sfc_efx_rx_intr_enable(struct sfc_dp_rxq *dp_rxq) +{ + struct sfc_efx_rxq *rxq = sfc_efx_rxq_by_dp_rxq(dp_rxq); + int rc = 0; + + rxq->flags |= SFC_EFX_RXQ_FLAG_INTR_EN; + if (rxq->flags & SFC_EFX_RXQ_FLAG_STARTED) { + rc = sfc_efx_rx_qprime(rxq); + if (rc != 0) + rxq->flags &= ~SFC_EFX_RXQ_FLAG_INTR_EN; + } + return rc; +} + +static sfc_dp_rx_intr_disable_t sfc_efx_rx_intr_disable; +static int +sfc_efx_rx_intr_disable(struct sfc_dp_rxq *dp_rxq) +{ + struct sfc_efx_rxq *rxq = sfc_efx_rxq_by_dp_rxq(dp_rxq); + + /* Cannot disarm, just disable rearm */ + rxq->flags &= ~SFC_EFX_RXQ_FLAG_INTR_EN; + return 0; +} + struct sfc_dp_rx sfc_efx_rx = { .dp = { .name = SFC_KVARG_DATAPATH_EFX, .type = SFC_DP_RX, - .hw_fw_caps = 0, + .hw_fw_caps = SFC_DP_HW_FW_CAP_RX_EFX, }, - .features = SFC_DP_RX_FEAT_SCATTER | - SFC_DP_RX_FEAT_CHECKSUM, + .features = SFC_DP_RX_FEAT_INTR, + .dev_offload_capa = DEV_RX_OFFLOAD_CHECKSUM | + DEV_RX_OFFLOAD_RSS_HASH, + .queue_offload_capa = DEV_RX_OFFLOAD_SCATTER, .qsize_up_rings = sfc_efx_rx_qsize_up_rings, .qcreate = sfc_efx_rx_qcreate, .qdestroy = sfc_efx_rx_qdestroy, @@ -555,6 +639,8 @@ struct sfc_dp_rx sfc_efx_rx = { .supported_ptypes_get = sfc_efx_supported_ptypes_get, .qdesc_npending = sfc_efx_rx_qdesc_npending, .qdesc_status = sfc_efx_rx_qdesc_status, + .intr_enable = sfc_efx_rx_intr_enable, + .intr_disable = sfc_efx_rx_intr_disable, .pkt_burst = sfc_efx_recv_pkts, }; @@ -643,7 +729,8 @@ retry: sfc_warn(sa, "promiscuous mode will be disabled"); port->promisc = B_FALSE; - rc = sfc_set_rx_mode(sa); + sa->eth_dev->data->promiscuous = 0; + rc = sfc_set_rx_mode_unchecked(sa); if (rc != 0) return rc; @@ -656,7 +743,8 @@ retry: sfc_warn(sa, "all-multicast mode will be disabled"); port->allmulti = B_FALSE; - rc = sfc_set_rx_mode(sa); + sa->eth_dev->data->all_multicast = 0; + rc = sfc_set_rx_mode_unchecked(sa); if (rc != 0) return rc; @@ -669,7 +757,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; @@ -692,6 +779,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; @@ -731,7 +819,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; @@ -744,10 +832,12 @@ sfc_rx_qstart(struct sfc_adapter *sa, unsigned int sw_index) return 0; fail_mac_filter_default_rxq_set: + sfc_rx_qflush(sa, sw_index); sa->priv.dp_rx->qstop(rxq_info->dp, &rxq->evq->read_ptr); + rxq_info->state = SFC_RXQ_INITIALIZED; fail_dp_qstart: - sfc_rx_qflush(sa, sw_index); + efx_rx_qdestroy(rxq->common); fail_rx_qcreate: fail_bad_contig_block_size: @@ -793,36 +883,32 @@ sfc_rx_qstop(struct sfc_adapter *sa, unsigned int sw_index) sfc_ev_qstop(rxq->evq); } -uint64_t -sfc_rx_get_dev_offload_caps(struct sfc_adapter *sa) +static uint64_t +sfc_rx_get_offload_mask(struct sfc_adapter *sa) { const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic); - uint64_t caps = 0; + uint64_t no_caps = 0; - caps |= DEV_RX_OFFLOAD_JUMBO_FRAME; + if (encp->enc_tunnel_encapsulations_supported == 0) + no_caps |= DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM; - if (sa->priv.dp_rx->features & SFC_DP_RX_FEAT_CHECKSUM) { - caps |= DEV_RX_OFFLOAD_IPV4_CKSUM; - caps |= DEV_RX_OFFLOAD_UDP_CKSUM; - caps |= DEV_RX_OFFLOAD_TCP_CKSUM; - } + return ~no_caps; +} - if (encp->enc_tunnel_encapsulations_supported && - (sa->priv.dp_rx->features & SFC_DP_RX_FEAT_TUNNELS)) - caps |= DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM; +uint64_t +sfc_rx_get_dev_offload_caps(struct sfc_adapter *sa) +{ + uint64_t caps = sa->priv.dp_rx->dev_offload_capa; - return caps; + caps |= DEV_RX_OFFLOAD_JUMBO_FRAME; + + return caps & sfc_rx_get_offload_mask(sa); } uint64_t sfc_rx_get_queue_offload_caps(struct sfc_adapter *sa) { - uint64_t caps = 0; - - if (sa->priv.dp_rx->features & SFC_DP_RX_FEAT_SCATTER) - caps |= DEV_RX_OFFLOAD_SCATTER; - - return caps; + return sa->priv.dp_rx->queue_offload_capa & sfc_rx_get_offload_mask(sa); } static int @@ -948,7 +1034,7 @@ sfc_rx_mb_pool_buf_size(struct sfc_adapter *sa, struct rte_mempool *mb_pool) * Start is aligned the same or better than end, * just align length. */ - buf_size = P2ALIGN(buf_size, nic_align_end); + buf_size = EFX_P2ALIGN(uint32_t, buf_size, nic_align_end); } return buf_size; @@ -972,13 +1058,23 @@ 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; - - rc = sa->priv.dp_rx->qsize_up_rings(nb_rx_desc, mb_pool, &rxq_entries, - &evq_entries, &rxq_max_fill_level); + struct sfc_dp_rx_hw_limits hw_limits; + uint16_t rx_free_thresh; + const char *error; + + 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 | @@ -995,10 +1091,12 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, goto fail_bad_conf; } - if ((buf_size < sa->port.pdu + encp->enc_rx_prefix_size) && - (~offloads & DEV_RX_OFFLOAD_SCATTER)) { - sfc_err(sa, "Rx scatter is disabled and RxQ %u mbuf pool " - "object size is too small", sw_index); + if (!sfc_rx_check_scatter(sa->port.pdu, buf_size, + encp->enc_rx_prefix_size, + (offloads & DEV_RX_OFFLOAD_SCATTER), + encp->enc_rx_scatter_max, + &error)) { + sfc_err(sa, "RxQ %u MTU check failed: %s", sw_index, error); sfc_err(sa, "RxQ %u calculated Rx buffer size is %u vs " "PDU size %u plus Rx prefix %u bytes", sw_index, buf_size, (unsigned int)sa->port.pdu, @@ -1023,7 +1121,8 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, EFX_RXQ_FLAG_SCATTER : EFX_RXQ_FLAG_NONE; if ((encp->enc_tunnel_encapsulations_supported != 0) && - (sa->priv.dp_rx->features & SFC_DP_RX_FEAT_TUNNELS)) + (sfc_dp_rx_offload_capa(sa->priv.dp_rx) & + DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM) != 0) rxq_info->type_flags |= EFX_RXQ_FLAG_INNER_CLASSES; rc = sfc_ev_qinit(sa, SFC_EVQ_TYPE_RX, sw_index, @@ -1034,12 +1133,34 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, rxq = &sa->rxq_ctrl[sw_index]; rxq->evq = evq; rxq->hw_index = sw_index; + /* + * If Rx refill threshold is specified (its value is non zero) in + * Rx configuration, use specified value. Otherwise use 1/8 of + * the Rx descriptors number as the default. It allows to keep + * Rx ring full-enough and does not refill too aggressive if + * packet rate is high. + * + * Since PMD refills in bulks waiting for full bulk may be + * refilled (basically round down), it is better to round up + * here to mitigate it a bit. + */ + rx_free_thresh = (rx_conf->rx_free_thresh != 0) ? + rx_conf->rx_free_thresh : EFX_DIV_ROUND_UP(nb_rx_desc, 8); + /* Rx refill threshold cannot be smaller than refill bulk */ rxq_info->refill_threshold = - RTE_MAX(rx_conf->rx_free_thresh, SFC_RX_REFILL_BULK); + RTE_MAX(rx_free_thresh, SFC_RX_REFILL_BULK); rxq_info->refill_mb_pool = mb_pool; + + if (rss->hash_support == EFX_RX_HASH_AVAILABLE && rss->channels > 0 && + (offloads & DEV_RX_OFFLOAD_RSS_HASH)) + rxq_info->rxq_flags = SFC_RXQ_FLAG_RSS_HASH; + else + rxq_info->rxq_flags = 0; + 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; @@ -1051,12 +1172,10 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index, info.buf_size = buf_size; info.batch_max = encp->enc_rx_batch_max; info.prefix_size = encp->enc_rx_prefix_size; - - if (rss->hash_support == EFX_RX_HASH_AVAILABLE && rss->channels > 0) - info.flags |= SFC_RXQ_FLAG_RSS_HASH; - + info.flags = rxq_info->rxq_flags; info.rxq_entries = rxq_info->entries; info.rxq_hw_ring = rxq->mem.esm_base; + info.evq_hw_index = sfc_evq_index_by_rxq_sw_index(sa, sw_index); info.evq_entries = evq_entries; info.evq_hw_ring = evq->mem.esm_base; info.hw_index = rxq->hw_index; @@ -1303,7 +1422,7 @@ sfc_rx_process_adv_conf_rss(struct sfc_adapter *sa, if (conf->rss_key != NULL) { if (conf->rss_key_len != sizeof(rss->key)) { - sfc_err(sa, "RSS key size is wrong (should be %lu)", + sfc_err(sa, "RSS key size is wrong (should be %zu)", sizeof(rss->key)); return EINVAL; } @@ -1404,9 +1523,10 @@ sfc_rx_qinit_info(struct sfc_adapter *sa, unsigned int 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;