diff --git a/0013-maintainers-update-for-DMA-device-performance-tool.patch b/0013-maintainers-update-for-DMA-device-performance-tool.patch new file mode 100644 index 0000000..4753d18 --- /dev/null +++ b/0013-maintainers-update-for-DMA-device-performance-tool.patch @@ -0,0 +1,30 @@ +From e222cf205386ecfdb4b429e5de3a7545bf0a43b6 Mon Sep 17 00:00:00 2001 +From: Chengwen Feng +Date: Fri, 15 Dec 2023 00:35:11 +0000 +Subject: [PATCH 13/30] maintainers: update for DMA device performance tool + +[ upstream commit 4ca7aa1af6c6ff32c2c5ad958e527e17d11f6d18 ] + +Add myself as a new maintainer to DMA device performance tool. + +Signed-off-by: Chengwen Feng +Acked-by: Thomas Monjalon +--- + MAINTAINERS | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/MAINTAINERS b/MAINTAINERS +index 0d1c812..78d4695 100644 +--- a/MAINTAINERS ++++ b/MAINTAINERS +@@ -1789,6 +1789,7 @@ F: doc/guides/testpmd_app_ug/ + + DMA device performance tool + M: Cheng Jiang ++M: Chengwen Feng + F: app/test-dma-perf/ + F: doc/guides/tools/dmaperf.rst + +-- +2.33.0 + diff --git a/0014-dmadev-add-telemetry-capability-for-m2d-auto-free.patch b/0014-dmadev-add-telemetry-capability-for-m2d-auto-free.patch new file mode 100644 index 0000000..9f20a63 --- /dev/null +++ b/0014-dmadev-add-telemetry-capability-for-m2d-auto-free.patch @@ -0,0 +1,40 @@ +From b894c53c587b901f0a03bcd2506dfc3c468f7fd4 Mon Sep 17 00:00:00 2001 +From: Chengwen Feng +Date: Tue, 28 Nov 2023 02:16:55 +0000 +Subject: [PATCH 14/30] dmadev: add telemetry capability for m2d auto free + +[ upstream commit ec932cb907b72291af28406d1621d6837771e10c ] + +The m2d auto free capability was introduced in [1], +but it lacks the support in telemetry. + +[1] 877cb3e3742 dmadev: add buffer auto free offload + +Signed-off-by: Chengwen Feng +--- + lib/dmadev/rte_dmadev.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/lib/dmadev/rte_dmadev.c b/lib/dmadev/rte_dmadev.c +index 4e5e420..7729519 100644 +--- a/lib/dmadev/rte_dmadev.c ++++ b/lib/dmadev/rte_dmadev.c +@@ -749,6 +749,7 @@ dma_capability_name(uint64_t capability) + { RTE_DMA_CAPA_SVA, "sva" }, + { RTE_DMA_CAPA_SILENT, "silent" }, + { RTE_DMA_CAPA_HANDLES_ERRORS, "handles_errors" }, ++ { RTE_DMA_CAPA_M2D_AUTO_FREE, "m2d_auto_free" }, + { RTE_DMA_CAPA_OPS_COPY, "copy" }, + { RTE_DMA_CAPA_OPS_COPY_SG, "copy_sg" }, + { RTE_DMA_CAPA_OPS_FILL, "fill" }, +@@ -953,6 +954,7 @@ dmadev_handle_dev_info(const char *cmd __rte_unused, + ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_SVA); + ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_SILENT); + ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_HANDLES_ERRORS); ++ ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_M2D_AUTO_FREE); + ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_COPY); + ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_COPY_SG); + ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_FILL); +-- +2.33.0 + diff --git a/0015-dmadev-add-tracepoints-in-data-path-API.patch b/0015-dmadev-add-tracepoints-in-data-path-API.patch new file mode 100644 index 0000000..0cc6120 --- /dev/null +++ b/0015-dmadev-add-tracepoints-in-data-path-API.patch @@ -0,0 +1,426 @@ +From f8e2db6965abc49f6f9c80df2b8277969cec2988 Mon Sep 17 00:00:00 2001 +From: Chengwen Feng +Date: Fri, 12 Jan 2024 10:26:59 +0000 +Subject: [PATCH 15/30] dmadev: add tracepoints in data path API +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 112327c220befef14129e4852e8df46e60410128 ] + +Add tracepoints at data path APIs for tracing support. + +Signed-off-by: Chengwen Feng +Acked-by: Morten Brørup +--- + lib/dmadev/meson.build | 2 +- + lib/dmadev/rte_dmadev.h | 56 +++++++--- + lib/dmadev/rte_dmadev_trace_fp.h | 150 +++++++++++++++++++++++++++ + lib/dmadev/rte_dmadev_trace_points.c | 27 +++++ + lib/dmadev/version.map | 15 +++ + 5 files changed, 236 insertions(+), 14 deletions(-) + create mode 100644 lib/dmadev/rte_dmadev_trace_fp.h + +diff --git a/lib/dmadev/meson.build b/lib/dmadev/meson.build +index e0d90ae..62b0650 100644 +--- a/lib/dmadev/meson.build ++++ b/lib/dmadev/meson.build +@@ -3,7 +3,7 @@ + + sources = files('rte_dmadev.c', 'rte_dmadev_trace_points.c') + headers = files('rte_dmadev.h') +-indirect_headers += files('rte_dmadev_core.h') ++indirect_headers += files('rte_dmadev_core.h', 'rte_dmadev_trace_fp.h') + driver_sdk_headers += files('rte_dmadev_pmd.h') + + deps += ['telemetry'] +diff --git a/lib/dmadev/rte_dmadev.h b/lib/dmadev/rte_dmadev.h +index 450b81c..5474a52 100644 +--- a/lib/dmadev/rte_dmadev.h ++++ b/lib/dmadev/rte_dmadev.h +@@ -773,6 +773,7 @@ struct rte_dma_sge { + }; + + #include "rte_dmadev_core.h" ++#include "rte_dmadev_trace_fp.h" + + /**@{@name DMA operation flag + * @see rte_dma_copy() +@@ -836,6 +837,7 @@ rte_dma_copy(int16_t dev_id, uint16_t vchan, rte_iova_t src, rte_iova_t dst, + uint32_t length, uint64_t flags) + { + struct rte_dma_fp_object *obj = &rte_dma_fp_objs[dev_id]; ++ int ret; + + #ifdef RTE_DMADEV_DEBUG + if (!rte_dma_is_valid(dev_id) || length == 0) +@@ -844,7 +846,10 @@ rte_dma_copy(int16_t dev_id, uint16_t vchan, rte_iova_t src, rte_iova_t dst, + return -ENOTSUP; + #endif + +- return (*obj->copy)(obj->dev_private, vchan, src, dst, length, flags); ++ ret = (*obj->copy)(obj->dev_private, vchan, src, dst, length, flags); ++ rte_dma_trace_copy(dev_id, vchan, src, dst, length, flags, ret); ++ ++ return ret; + } + + /** +@@ -883,6 +888,7 @@ rte_dma_copy_sg(int16_t dev_id, uint16_t vchan, struct rte_dma_sge *src, + uint64_t flags) + { + struct rte_dma_fp_object *obj = &rte_dma_fp_objs[dev_id]; ++ int ret; + + #ifdef RTE_DMADEV_DEBUG + if (!rte_dma_is_valid(dev_id) || src == NULL || dst == NULL || +@@ -892,8 +898,12 @@ rte_dma_copy_sg(int16_t dev_id, uint16_t vchan, struct rte_dma_sge *src, + return -ENOTSUP; + #endif + +- return (*obj->copy_sg)(obj->dev_private, vchan, src, dst, nb_src, +- nb_dst, flags); ++ ret = (*obj->copy_sg)(obj->dev_private, vchan, src, dst, nb_src, ++ nb_dst, flags); ++ rte_dma_trace_copy_sg(dev_id, vchan, src, dst, nb_src, nb_dst, flags, ++ ret); ++ ++ return ret; + } + + /** +@@ -927,6 +937,7 @@ rte_dma_fill(int16_t dev_id, uint16_t vchan, uint64_t pattern, + rte_iova_t dst, uint32_t length, uint64_t flags) + { + struct rte_dma_fp_object *obj = &rte_dma_fp_objs[dev_id]; ++ int ret; + + #ifdef RTE_DMADEV_DEBUG + if (!rte_dma_is_valid(dev_id) || length == 0) +@@ -935,8 +946,11 @@ rte_dma_fill(int16_t dev_id, uint16_t vchan, uint64_t pattern, + return -ENOTSUP; + #endif + +- return (*obj->fill)(obj->dev_private, vchan, pattern, dst, length, +- flags); ++ ret = (*obj->fill)(obj->dev_private, vchan, pattern, dst, length, ++ flags); ++ rte_dma_trace_fill(dev_id, vchan, pattern, dst, length, flags, ret); ++ ++ return ret; + } + + /** +@@ -957,6 +971,7 @@ static inline int + rte_dma_submit(int16_t dev_id, uint16_t vchan) + { + struct rte_dma_fp_object *obj = &rte_dma_fp_objs[dev_id]; ++ int ret; + + #ifdef RTE_DMADEV_DEBUG + if (!rte_dma_is_valid(dev_id)) +@@ -965,7 +980,10 @@ rte_dma_submit(int16_t dev_id, uint16_t vchan) + return -ENOTSUP; + #endif + +- return (*obj->submit)(obj->dev_private, vchan); ++ ret = (*obj->submit)(obj->dev_private, vchan); ++ rte_dma_trace_submit(dev_id, vchan, ret); ++ ++ return ret; + } + + /** +@@ -995,7 +1013,7 @@ rte_dma_completed(int16_t dev_id, uint16_t vchan, const uint16_t nb_cpls, + uint16_t *last_idx, bool *has_error) + { + struct rte_dma_fp_object *obj = &rte_dma_fp_objs[dev_id]; +- uint16_t idx; ++ uint16_t idx, ret; + bool err; + + #ifdef RTE_DMADEV_DEBUG +@@ -1019,8 +1037,12 @@ rte_dma_completed(int16_t dev_id, uint16_t vchan, const uint16_t nb_cpls, + has_error = &err; + + *has_error = false; +- return (*obj->completed)(obj->dev_private, vchan, nb_cpls, last_idx, +- has_error); ++ ret = (*obj->completed)(obj->dev_private, vchan, nb_cpls, last_idx, ++ has_error); ++ rte_dma_trace_completed(dev_id, vchan, nb_cpls, last_idx, has_error, ++ ret); ++ ++ return ret; + } + + /** +@@ -1055,7 +1077,7 @@ rte_dma_completed_status(int16_t dev_id, uint16_t vchan, + enum rte_dma_status_code *status) + { + struct rte_dma_fp_object *obj = &rte_dma_fp_objs[dev_id]; +- uint16_t idx; ++ uint16_t idx, ret; + + #ifdef RTE_DMADEV_DEBUG + if (!rte_dma_is_valid(dev_id) || nb_cpls == 0 || status == NULL) +@@ -1067,8 +1089,12 @@ rte_dma_completed_status(int16_t dev_id, uint16_t vchan, + if (last_idx == NULL) + last_idx = &idx; + +- return (*obj->completed_status)(obj->dev_private, vchan, nb_cpls, +- last_idx, status); ++ ret = (*obj->completed_status)(obj->dev_private, vchan, nb_cpls, ++ last_idx, status); ++ rte_dma_trace_completed_status(dev_id, vchan, nb_cpls, last_idx, status, ++ ret); ++ ++ return ret; + } + + /** +@@ -1087,6 +1113,7 @@ static inline uint16_t + rte_dma_burst_capacity(int16_t dev_id, uint16_t vchan) + { + struct rte_dma_fp_object *obj = &rte_dma_fp_objs[dev_id]; ++ uint16_t ret; + + #ifdef RTE_DMADEV_DEBUG + if (!rte_dma_is_valid(dev_id)) +@@ -1094,7 +1121,10 @@ rte_dma_burst_capacity(int16_t dev_id, uint16_t vchan) + if (*obj->burst_capacity == NULL) + return 0; + #endif +- return (*obj->burst_capacity)(obj->dev_private, vchan); ++ ret = (*obj->burst_capacity)(obj->dev_private, vchan); ++ rte_dma_trace_burst_capacity(dev_id, vchan, ret); ++ ++ return ret; + } + + #ifdef __cplusplus +diff --git a/lib/dmadev/rte_dmadev_trace_fp.h b/lib/dmadev/rte_dmadev_trace_fp.h +new file mode 100644 +index 0000000..f5b9683 +--- /dev/null ++++ b/lib/dmadev/rte_dmadev_trace_fp.h +@@ -0,0 +1,150 @@ ++/* SPDX-License-Identifier: BSD-3-Clause ++ * Copyright(c) 2024 HiSilicon Limited ++ */ ++ ++#ifndef RTE_DMADEV_TRACE_FP_H ++#define RTE_DMADEV_TRACE_FP_H ++ ++/** ++ * @file ++ * ++ * API for dmadev fastpath trace support ++ */ ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_stats_get, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, ++ struct rte_dma_stats *stats, int ret), ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_u64(stats->submitted); ++ rte_trace_point_emit_u64(stats->completed); ++ rte_trace_point_emit_u64(stats->errors); ++ rte_trace_point_emit_int(ret); ++) ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_vchan_status, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, ++ enum rte_dma_vchan_status *status, int ret), ++#ifdef _RTE_TRACE_POINT_REGISTER_H_ ++ enum rte_dma_vchan_status __status = 0; ++ status = &__status; ++#endif /* _RTE_TRACE_POINT_REGISTER_H_ */ ++ int vchan_status = *status; ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_int(vchan_status); ++ rte_trace_point_emit_int(ret); ++) ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_copy, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, rte_iova_t src, ++ rte_iova_t dst, uint32_t length, uint64_t flags, ++ int ret), ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_u64(src); ++ rte_trace_point_emit_u64(dst); ++ rte_trace_point_emit_u32(length); ++ rte_trace_point_emit_u64(flags); ++ rte_trace_point_emit_int(ret); ++) ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_copy_sg, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, ++ struct rte_dma_sge *src, struct rte_dma_sge *dst, ++ uint16_t nb_src, uint16_t nb_dst, uint64_t flags, ++ int ret), ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_ptr(src); ++ rte_trace_point_emit_ptr(dst); ++ rte_trace_point_emit_u16(nb_src); ++ rte_trace_point_emit_u16(nb_dst); ++ rte_trace_point_emit_u64(flags); ++ rte_trace_point_emit_int(ret); ++) ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_fill, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, uint64_t pattern, ++ rte_iova_t dst, uint32_t length, uint64_t flags, ++ int ret), ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_u64(pattern); ++ rte_trace_point_emit_u64(dst); ++ rte_trace_point_emit_u32(length); ++ rte_trace_point_emit_u64(flags); ++ rte_trace_point_emit_int(ret); ++) ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_submit, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, int ret), ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_int(ret); ++) ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_completed, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, ++ const uint16_t nb_cpls, uint16_t *last_idx, ++ bool *has_error, uint16_t ret), ++#ifdef _RTE_TRACE_POINT_REGISTER_H_ ++ uint16_t __last_idx = 0; ++ bool __has_error = false; ++ last_idx = &__last_idx; ++ has_error = &__has_error; ++#endif /* _RTE_TRACE_POINT_REGISTER_H_ */ ++ int has_error_val = *has_error; ++ int last_idx_val = *last_idx; ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_u16(nb_cpls); ++ rte_trace_point_emit_int(last_idx_val); ++ rte_trace_point_emit_int(has_error_val); ++ rte_trace_point_emit_u16(ret); ++) ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_completed_status, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, ++ const uint16_t nb_cpls, uint16_t *last_idx, ++ enum rte_dma_status_code *status, uint16_t ret), ++#ifdef _RTE_TRACE_POINT_REGISTER_H_ ++ uint16_t __last_idx = 0; ++ last_idx = &__last_idx; ++#endif /* _RTE_TRACE_POINT_REGISTER_H_ */ ++ int last_idx_val = *last_idx; ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_u16(nb_cpls); ++ rte_trace_point_emit_int(last_idx_val); ++ rte_trace_point_emit_ptr(status); ++ rte_trace_point_emit_u16(ret); ++) ++ ++RTE_TRACE_POINT_FP( ++ rte_dma_trace_burst_capacity, ++ RTE_TRACE_POINT_ARGS(int16_t dev_id, uint16_t vchan, uint16_t ret), ++ rte_trace_point_emit_i16(dev_id); ++ rte_trace_point_emit_u16(vchan); ++ rte_trace_point_emit_u16(ret); ++) ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* RTE_DMADEV_TRACE_FP_H */ +diff --git a/lib/dmadev/rte_dmadev_trace_points.c b/lib/dmadev/rte_dmadev_trace_points.c +index 2a83b90..4c74356 100644 +--- a/lib/dmadev/rte_dmadev_trace_points.c ++++ b/lib/dmadev/rte_dmadev_trace_points.c +@@ -24,8 +24,35 @@ RTE_TRACE_POINT_REGISTER(rte_dma_trace_close, + RTE_TRACE_POINT_REGISTER(rte_dma_trace_vchan_setup, + lib.dmadev.vchan_setup) + ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_stats_get, ++ lib.dmadev.stats_get) ++ + RTE_TRACE_POINT_REGISTER(rte_dma_trace_stats_reset, + lib.dmadev.stats_reset) + ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_vchan_status, ++ lib.dmadev.vchan_status) ++ + RTE_TRACE_POINT_REGISTER(rte_dma_trace_dump, + lib.dmadev.dump) ++ ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_copy, ++ lib.dmadev.copy) ++ ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_copy_sg, ++ lib.dmadev.copy_sg) ++ ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_fill, ++ lib.dmadev.fill) ++ ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_submit, ++ lib.dmadev.submit) ++ ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_completed, ++ lib.dmadev.completed) ++ ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_completed_status, ++ lib.dmadev.completed_status) ++ ++RTE_TRACE_POINT_REGISTER(rte_dma_trace_burst_capacity, ++ lib.dmadev.burst_capacity) +diff --git a/lib/dmadev/version.map b/lib/dmadev/version.map +index 2a37365..14e0927 100644 +--- a/lib/dmadev/version.map ++++ b/lib/dmadev/version.map +@@ -20,6 +20,21 @@ DPDK_24 { + local: *; + }; + ++EXPERIMENTAL { ++ global: ++ ++ # added in 24.03 ++ __rte_dma_trace_burst_capacity; ++ __rte_dma_trace_completed; ++ __rte_dma_trace_completed_status; ++ __rte_dma_trace_copy; ++ __rte_dma_trace_copy_sg; ++ __rte_dma_trace_fill; ++ __rte_dma_trace_submit; ++ ++ local: *; ++}; ++ + INTERNAL { + global: + +-- +2.33.0 + diff --git a/0016-eal-introduce-more-macros-for-bit-definition.patch b/0016-eal-introduce-more-macros-for-bit-definition.patch new file mode 100644 index 0000000..66d8d22 --- /dev/null +++ b/0016-eal-introduce-more-macros-for-bit-definition.patch @@ -0,0 +1,102 @@ +From 8ff07d4203a07fadbae3b9cac3e0f6301d85b022 Mon Sep 17 00:00:00 2001 +From: Chengwen Feng +Date: Fri, 26 Jan 2024 06:10:06 +0000 +Subject: [PATCH 16/30] eal: introduce more macros for bit definition + +[ upstream commit 1d8f2285ed3ffc3dfbf0857a960915c0e8ef6a8d ] + +Introduce macros: +1. RTE_SHIFT_VAL64: get the uint64_t value which shifted by nr. +2. RTE_SHIFT_VAL32: get the uint32_t value which shifted by nr. +3. RTE_GENMASK64: generate a contiguous 64bit bitmask starting at bit + position low and ending at position high. +4. RTE_GENMASK32: generate a contiguous 32bit bitmask starting at bit + position low and ending at position high. +5. RTE_FIELD_GET64: extract a 64bit field element. +6. RTE_FIELD_GET32: extract a 32bit field element. + +Signed-off-by: Chengwen Feng +--- + lib/eal/include/rte_bitops.h | 66 ++++++++++++++++++++++++++++++++++++ + 1 file changed, 66 insertions(+) + +diff --git a/lib/eal/include/rte_bitops.h b/lib/eal/include/rte_bitops.h +index 6bd8bae..449565e 100644 +--- a/lib/eal/include/rte_bitops.h ++++ b/lib/eal/include/rte_bitops.h +@@ -39,6 +39,72 @@ extern "C" { + */ + #define RTE_BIT32(nr) (UINT32_C(1) << (nr)) + ++/** ++ * Get the uint32_t shifted value. ++ * ++ * @param val ++ * The value to be shifted. ++ * @param nr ++ * The shift number in range of 0 to (32 - width of val). ++ */ ++#define RTE_SHIFT_VAL32(val, nr) (UINT32_C(val) << (nr)) ++ ++/** ++ * Get the uint64_t shifted value. ++ * ++ * @param val ++ * The value to be shifted. ++ * @param nr ++ * The shift number in range of 0 to (64 - width of val). ++ */ ++#define RTE_SHIFT_VAL64(val, nr) (UINT64_C(val) << (nr)) ++ ++/** ++ * Generate a contiguous 32-bit mask ++ * starting at bit position low and ending at position high. ++ * ++ * @param high ++ * High bit position. ++ * @param low ++ * Low bit position. ++ */ ++#define RTE_GENMASK32(high, low) \ ++ (((~UINT32_C(0)) << (low)) & (~UINT32_C(0) >> (31u - (high)))) ++ ++/** ++ * Generate a contiguous 64-bit mask ++ * starting at bit position low and ending at position high. ++ * ++ * @param high ++ * High bit position. ++ * @param low ++ * Low bit position. ++ */ ++#define RTE_GENMASK64(high, low) \ ++ (((~UINT64_C(0)) << (low)) & (~UINT64_C(0) >> (63u - (high)))) ++ ++/** ++ * Extract a 32-bit field element. ++ * ++ * @param mask ++ * Shifted mask. ++ * @param reg ++ * Value of entire bitfield. ++ */ ++#define RTE_FIELD_GET32(mask, reg) \ ++ ((typeof(mask))(((reg) & (mask)) >> rte_ctz32(mask))) ++ ++/** ++ * Extract a 64-bit field element. ++ * ++ * @param mask ++ * Shifted mask. ++ * @param reg ++ * Value of entire bitfield. ++ */ ++#define RTE_FIELD_GET64(mask, reg) \ ++ ((typeof(mask))(((reg) & (mask)) >> rte_ctz64(mask))) ++ + /*------------------------ 32-bit relaxed operations ------------------------*/ + + /** +-- +2.33.0 + diff --git a/0017-ring-add-telemetry-command-to-list-rings.patch b/0017-ring-add-telemetry-command-to-list-rings.patch new file mode 100644 index 0000000..bf43241 --- /dev/null +++ b/0017-ring-add-telemetry-command-to-list-rings.patch @@ -0,0 +1,99 @@ +From 5d3158e366fe1293ee5a7293a9050bf93a460f53 Mon Sep 17 00:00:00 2001 +From: Jie Hai +Date: Mon, 19 Feb 2024 16:32:52 +0800 +Subject: [PATCH 17/30] ring: add telemetry command to list rings +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 36e5c1b91607cc41e73e1108bdc5843c68e3ebc6 ] + +Add a telemetry command to list the rings used in the system. +An example using this command is shown below: + +--> /ring/list +{ + "/ring/list": [ + "HT_0000:7d:00.2", + "MP_mb_pool_0" + ] +} + +Signed-off-by: Jie Hai +Acked-by: Konstantin Ananyev +Reviewed-by: Honnappa Nagarahalli +Acked-by: Huisong Li +Acked-by: Chengwen Feng +Acked-by: Morten Brørup +--- + lib/ring/meson.build | 1 + + lib/ring/rte_ring.c | 40 ++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 41 insertions(+) + +diff --git a/lib/ring/meson.build b/lib/ring/meson.build +index c20685c..7fca958 100644 +--- a/lib/ring/meson.build ++++ b/lib/ring/meson.build +@@ -18,3 +18,4 @@ indirect_headers += files ( + 'rte_ring_rts.h', + 'rte_ring_rts_elem_pvt.h', + ) ++deps += ['telemetry'] +diff --git a/lib/ring/rte_ring.c b/lib/ring/rte_ring.c +index 057d25f..6a10280 100644 +--- a/lib/ring/rte_ring.c ++++ b/lib/ring/rte_ring.c +@@ -22,6 +22,7 @@ + #include + #include + #include ++#include + + #include "rte_ring.h" + #include "rte_ring_elem.h" +@@ -418,3 +419,42 @@ rte_ring_lookup(const char *name) + + return r; + } ++ ++static void ++ring_walk(void (*func)(struct rte_ring *, void *), void *arg) ++{ ++ struct rte_ring_list *ring_list; ++ struct rte_tailq_entry *tailq_entry; ++ ++ ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list); ++ rte_mcfg_tailq_read_lock(); ++ ++ TAILQ_FOREACH(tailq_entry, ring_list, next) { ++ (*func)((struct rte_ring *) tailq_entry->data, arg); ++ } ++ ++ rte_mcfg_tailq_read_unlock(); ++} ++ ++static void ++ring_list_cb(struct rte_ring *r, void *arg) ++{ ++ struct rte_tel_data *d = (struct rte_tel_data *)arg; ++ ++ rte_tel_data_add_array_string(d, r->name); ++} ++ ++static int ++ring_handle_list(const char *cmd __rte_unused, ++ const char *params __rte_unused, struct rte_tel_data *d) ++{ ++ rte_tel_data_start_array(d, RTE_TEL_STRING_VAL); ++ ring_walk(ring_list_cb, d); ++ return 0; ++} ++ ++RTE_INIT(ring_init_telemetry) ++{ ++ rte_telemetry_register_cmd("/ring/list", ring_handle_list, ++ "Returns list of available rings. Takes no parameters"); ++} +-- +2.33.0 + diff --git a/0018-ring-add-telemetry-command-for-ring-info.patch b/0018-ring-add-telemetry-command-for-ring-info.patch new file mode 100644 index 0000000..871da70 --- /dev/null +++ b/0018-ring-add-telemetry-command-for-ring-info.patch @@ -0,0 +1,154 @@ +From b57a22942d27636291889298a3e186fde0f5225e Mon Sep 17 00:00:00 2001 +From: Jie Hai +Date: Mon, 19 Feb 2024 16:32:53 +0800 +Subject: [PATCH 18/30] ring: add telemetry command for ring info +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 2e99bd65ca788f7f540b2c155208dae2b0128b36 ] + +This patch supports dump of ring information by its name. +An example using this command is shown below: + +--> /ring/info,MP_mb_pool_0 +{ + "/ring/info": { + "name": "MP_mb_pool_0", + "socket": 0, + "flags": 0, + "producer_type": "MP", + "consumer_type": "MC", + "size": 262144, + "mask": "0x3ffff", + "capacity": 262143, + "used_count": 153197, + "mz_name": "RG_MP_mb_pool_0", + "mz_len": 2097536, + "mz_hugepage_sz": 1073741824, + "mz_socket_id": 0, + "mz_flags": "0x0" + } +} + +Signed-off-by: Jie Hai +Reviewed-by: Honnappa Nagarahalli +Acked-by: Konstantin Ananyev +Acked-by: Huisong Li +Acked-by: Chengwen Feng +Acked-by: Morten Brørup +--- + lib/ring/rte_ring.c | 95 +++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 95 insertions(+) + +diff --git a/lib/ring/rte_ring.c b/lib/ring/rte_ring.c +index 6a10280..ec56b38 100644 +--- a/lib/ring/rte_ring.c ++++ b/lib/ring/rte_ring.c +@@ -453,8 +453,103 @@ ring_handle_list(const char *cmd __rte_unused, + return 0; + } + ++static const char * ++ring_prod_sync_type_to_name(struct rte_ring *r) ++{ ++ switch (r->prod.sync_type) { ++ case RTE_RING_SYNC_MT: ++ return "MP"; ++ case RTE_RING_SYNC_ST: ++ return "SP"; ++ case RTE_RING_SYNC_MT_RTS: ++ return "MP_RTS"; ++ case RTE_RING_SYNC_MT_HTS: ++ return "MP_HTS"; ++ default: ++ return "Unknown"; ++ } ++} ++ ++static const char * ++ring_cons_sync_type_to_name(struct rte_ring *r) ++{ ++ switch (r->cons.sync_type) { ++ case RTE_RING_SYNC_MT: ++ return "MC"; ++ case RTE_RING_SYNC_ST: ++ return "SC"; ++ case RTE_RING_SYNC_MT_RTS: ++ return "MC_RTS"; ++ case RTE_RING_SYNC_MT_HTS: ++ return "MC_HTS"; ++ default: ++ return "Unknown"; ++ } ++} ++ ++struct ring_info_cb_arg { ++ char *ring_name; ++ struct rte_tel_data *d; ++}; ++ ++static void ++ring_info_cb(struct rte_ring *r, void *arg) ++{ ++ struct ring_info_cb_arg *ring_arg = (struct ring_info_cb_arg *)arg; ++ struct rte_tel_data *d = ring_arg->d; ++ const struct rte_memzone *mz; ++ ++ if (strncmp(r->name, ring_arg->ring_name, RTE_RING_NAMESIZE)) ++ return; ++ ++ rte_tel_data_add_dict_string(d, "name", r->name); ++ rte_tel_data_add_dict_int(d, "socket", r->memzone->socket_id); ++ rte_tel_data_add_dict_int(d, "flags", r->flags); ++ rte_tel_data_add_dict_string(d, "producer_type", ++ ring_prod_sync_type_to_name(r)); ++ rte_tel_data_add_dict_string(d, "consumer_type", ++ ring_cons_sync_type_to_name(r)); ++ rte_tel_data_add_dict_uint(d, "size", r->size); ++ rte_tel_data_add_dict_uint_hex(d, "mask", r->mask, 0); ++ rte_tel_data_add_dict_uint(d, "capacity", r->capacity); ++ rte_tel_data_add_dict_uint(d, "used_count", rte_ring_count(r)); ++ ++ mz = r->memzone; ++ if (mz == NULL) ++ return; ++ rte_tel_data_add_dict_string(d, "mz_name", mz->name); ++ rte_tel_data_add_dict_uint(d, "mz_len", mz->len); ++ rte_tel_data_add_dict_uint(d, "mz_hugepage_sz", mz->hugepage_sz); ++ rte_tel_data_add_dict_int(d, "mz_socket_id", mz->socket_id); ++ rte_tel_data_add_dict_uint_hex(d, "mz_flags", mz->flags, 0); ++} ++ ++static int ++ring_handle_info(const char *cmd __rte_unused, const char *params, ++ struct rte_tel_data *d) ++{ ++ char name[RTE_RING_NAMESIZE] = {0}; ++ struct ring_info_cb_arg ring_arg; ++ ++ if (params == NULL || strlen(params) == 0 || ++ strlen(params) >= RTE_RING_NAMESIZE) ++ return -EINVAL; ++ ++ rte_strlcpy(name, params, RTE_RING_NAMESIZE); ++ ++ ring_arg.ring_name = name; ++ ring_arg.d = d; ++ ++ rte_tel_data_start_dict(d); ++ ring_walk(ring_info_cb, &ring_arg); ++ ++ return 0; ++} ++ + RTE_INIT(ring_init_telemetry) + { + rte_telemetry_register_cmd("/ring/list", ring_handle_list, + "Returns list of available rings. Takes no parameters"); ++ rte_telemetry_register_cmd("/ring/info", ring_handle_info, ++ "Returns ring info. Parameters: ring_name."); + } +-- +2.33.0 + diff --git a/0019-ethdev-get-RSS-hash-algorithm-by-name.patch b/0019-ethdev-get-RSS-hash-algorithm-by-name.patch new file mode 100644 index 0000000..0794305 --- /dev/null +++ b/0019-ethdev-get-RSS-hash-algorithm-by-name.patch @@ -0,0 +1,93 @@ +From 6b7a19a619a47d85cb21edce610d9b7a2313b19d Mon Sep 17 00:00:00 2001 +From: Jie Hai +Date: Fri, 1 Dec 2023 16:52:53 +0800 +Subject: [PATCH 19/30] ethdev: get RSS hash algorithm by name + +[ upstream commit c9884dfb4a35ec00c1aaa2ece2033da679233003 ] + +This patch supports conversion from names to hash algorithm +(see RTE_ETH_HASH_FUNCTION_XXX). + +Signed-off-by: Jie Hai +Reviewed-by: Huisong Li +Reviewed-by: Ferruh Yigit +--- + lib/ethdev/rte_ethdev.c | 15 +++++++++++++++ + lib/ethdev/rte_ethdev.h | 20 ++++++++++++++++++++ + lib/ethdev/version.map | 3 +++ + 3 files changed, 38 insertions(+) + +diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c +index 3858983..c0398d9 100644 +--- a/lib/ethdev/rte_ethdev.c ++++ b/lib/ethdev/rte_ethdev.c +@@ -4826,6 +4826,21 @@ rte_eth_dev_rss_algo_name(enum rte_eth_hash_function rss_algo) + return name; + } + ++int ++rte_eth_find_rss_algo(const char *name, uint32_t *algo) ++{ ++ unsigned int i; ++ ++ for (i = 0; i < RTE_DIM(rte_eth_dev_rss_algo_names); i++) { ++ if (strcmp(name, rte_eth_dev_rss_algo_names[i].name) == 0) { ++ *algo = rte_eth_dev_rss_algo_names[i].algo; ++ return 0; ++ } ++ } ++ ++ return -EINVAL; ++} ++ + int + rte_eth_dev_udp_tunnel_port_add(uint16_t port_id, + struct rte_eth_udp_tunnel *udp_tunnel) +diff --git a/lib/ethdev/rte_ethdev.h b/lib/ethdev/rte_ethdev.h +index 77331ce..57a9a55 100644 +--- a/lib/ethdev/rte_ethdev.h ++++ b/lib/ethdev/rte_ethdev.h +@@ -4667,6 +4667,26 @@ __rte_experimental + const char * + rte_eth_dev_rss_algo_name(enum rte_eth_hash_function rss_algo); + ++/** ++ * @warning ++ * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. ++ * ++ * Get RSS hash algorithm by its name. ++ * ++ * @param name ++ * RSS hash algorithm. ++ * ++ * @param algo ++ * Return the RSS hash algorithm found, @see rte_eth_hash_function. ++ * ++ * @return ++ * - (0) if successful. ++ * - (-EINVAL) if not found. ++ */ ++__rte_experimental ++int ++rte_eth_find_rss_algo(const char *name, uint32_t *algo); ++ + /** + * Add UDP tunneling port for a type of tunnel. + * +diff --git a/lib/ethdev/version.map b/lib/ethdev/version.map +index 5c4917c..a050baa 100644 +--- a/lib/ethdev/version.map ++++ b/lib/ethdev/version.map +@@ -316,6 +316,9 @@ EXPERIMENTAL { + rte_eth_recycle_rx_queue_info_get; + rte_flow_group_set_miss_actions; + rte_flow_calc_table_hash; ++ ++ # added in 24.03 ++ rte_eth_find_rss_algo; + }; + + INTERNAL { +-- +2.33.0 + diff --git a/0020-app-testpmd-set-RSS-hash-algorithm.patch b/0020-app-testpmd-set-RSS-hash-algorithm.patch new file mode 100644 index 0000000..3243e47 --- /dev/null +++ b/0020-app-testpmd-set-RSS-hash-algorithm.patch @@ -0,0 +1,150 @@ +From 787e715f8e77722658d56209c1a73ba5626d19fa Mon Sep 17 00:00:00 2001 +From: Jie Hai +Date: Fri, 1 Dec 2023 16:52:54 +0800 +Subject: [PATCH 20/30] app/testpmd: set RSS hash algorithm + +[ upstream commit 3da59f30a23f2e795d2315f3d949e1b3e0ce0c3d ] + +Since API rte_eth_dev_rss_hash_update() supports setting RSS hash +algorithm, add new command to support it: + +testpmd> port config 0 rss-hash-algo symmetric_toeplitz + +Signed-off-by: Jie Hai +Reviewed-by: Huisong Li +Reviewed-by: Ferruh Yigit +--- + app/test-pmd/cmdline.c | 81 +++++++++++++++++++++ + doc/guides/testpmd_app_ug/testpmd_funcs.rst | 10 +++ + 2 files changed, 91 insertions(+) + +diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c +index 9369d3b..f704319 100644 +--- a/app/test-pmd/cmdline.c ++++ b/app/test-pmd/cmdline.c +@@ -726,6 +726,10 @@ static void cmd_help_long_parsed(void *parsed_result, + "port config port-id rss reta (hash,queue)[,(hash,queue)]\n" + " Set the RSS redirection table.\n\n" + ++ "port config (port_id) rss-hash-algo (default|simple_xor|toeplitz|" ++ "symmetric_toeplitz|symmetric_toeplitz_sort)\n" ++ " Set the RSS hash algorithm.\n\n" ++ + "port config (port_id) dcb vt (on|off) (traffic_class)" + " pfc (on|off)\n" + " Set the DCB mode.\n\n" +@@ -2275,6 +2279,82 @@ static cmdline_parse_inst_t cmd_config_rss_hash_key = { + }, + }; + ++/* *** configure rss hash algorithm *** */ ++struct cmd_config_rss_hash_algo { ++ cmdline_fixed_string_t port; ++ cmdline_fixed_string_t config; ++ portid_t port_id; ++ cmdline_fixed_string_t rss_hash_algo; ++ cmdline_fixed_string_t algo; ++}; ++ ++static void ++cmd_config_rss_hash_algo_parsed(void *parsed_result, ++ __rte_unused struct cmdline *cl, ++ __rte_unused void *data) ++{ ++ struct cmd_config_rss_hash_algo *res = parsed_result; ++ uint8_t rss_key[RSS_HASH_KEY_LENGTH]; ++ struct rte_eth_rss_conf rss_conf; ++ uint32_t algorithm; ++ int ret; ++ ++ rss_conf.rss_key_len = RSS_HASH_KEY_LENGTH; ++ rss_conf.rss_key = rss_key; ++ ret = rte_eth_dev_rss_hash_conf_get(res->port_id, &rss_conf); ++ if (ret != 0) { ++ fprintf(stderr, "failed to get port %u RSS configuration\n", ++ res->port_id); ++ return; ++ } ++ ++ algorithm = (uint32_t)rss_conf.algorithm; ++ ret = rte_eth_find_rss_algo(res->algo, &algorithm); ++ if (ret != 0) { ++ fprintf(stderr, "port %u configured invalid RSS hash algorithm: %s\n", ++ res->port_id, res->algo); ++ return; ++ } ++ ++ ret = rte_eth_dev_rss_hash_update(res->port_id, &rss_conf); ++ if (ret != 0) { ++ fprintf(stderr, "failed to set port %u RSS hash algorithm\n", ++ res->port_id); ++ return; ++ } ++} ++ ++static cmdline_parse_token_string_t cmd_config_rss_hash_algo_port = ++ TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_algo, port, "port"); ++static cmdline_parse_token_string_t cmd_config_rss_hash_algo_config = ++ TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_algo, config, ++ "config"); ++static cmdline_parse_token_num_t cmd_config_rss_hash_algo_port_id = ++ TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_algo, port_id, ++ RTE_UINT16); ++static cmdline_parse_token_string_t cmd_config_rss_hash_algo_rss_hash_algo = ++ TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_algo, ++ rss_hash_algo, "rss-hash-algo"); ++static cmdline_parse_token_string_t cmd_config_rss_hash_algo_algo = ++ TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_algo, algo, ++ "default#simple_xor#toeplitz#" ++ "symmetric_toeplitz#symmetric_toeplitz_sort"); ++ ++static cmdline_parse_inst_t cmd_config_rss_hash_algo = { ++ .f = cmd_config_rss_hash_algo_parsed, ++ .data = NULL, ++ .help_str = "port config rss-hash-algo " ++ "default|simple_xor|toeplitz|symmetric_toeplitz|symmetric_toeplitz_sort", ++ .tokens = { ++ (void *)&cmd_config_rss_hash_algo_port, ++ (void *)&cmd_config_rss_hash_algo_config, ++ (void *)&cmd_config_rss_hash_algo_port_id, ++ (void *)&cmd_config_rss_hash_algo_rss_hash_algo, ++ (void *)&cmd_config_rss_hash_algo_algo, ++ NULL, ++ }, ++}; ++ + /* *** cleanup txq mbufs *** */ + struct cmd_cleanup_txq_mbufs_result { + cmdline_fixed_string_t port; +@@ -13165,6 +13245,7 @@ static cmdline_parse_ctx_t builtin_ctx[] = { + (cmdline_parse_inst_t *)&cmd_showport_rss_hash_key, + (cmdline_parse_inst_t *)&cmd_showport_rss_hash_algo, + (cmdline_parse_inst_t *)&cmd_config_rss_hash_key, ++ (cmdline_parse_inst_t *)&cmd_config_rss_hash_algo, + (cmdline_parse_inst_t *)&cmd_cleanup_txq_mbufs, + (cmdline_parse_inst_t *)&cmd_dump, + (cmdline_parse_inst_t *)&cmd_dump_one, +diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst b/doc/guides/testpmd_app_ug/testpmd_funcs.rst +index 447e28e..227188f 100644 +--- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst ++++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst +@@ -2263,6 +2263,16 @@ hash of input [IP] packets received on port:: + ipv6-udp-ex ) + ++port config rss hash algorithm ++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ ++To configure the RSS hash algorithm used to compute the RSS ++hash of input packets received on port:: ++ ++ testpmd> port config rss-hash-algo (default|\ ++ simple_xor|toeplitz|symmetric_toeplitz|\ ++ symmetric_toeplitz_sort) ++ + port cleanup txq mbufs + ~~~~~~~~~~~~~~~~~~~~~~ + +-- +2.33.0 + diff --git a/0021-net-hns3-refactor-VF-mailbox-message-struct.patch b/0021-net-hns3-refactor-VF-mailbox-message-struct.patch new file mode 100644 index 0000000..c78829b --- /dev/null +++ b/0021-net-hns3-refactor-VF-mailbox-message-struct.patch @@ -0,0 +1,279 @@ +From 7adff88ea9f41ea3270f52407345571cd35946e6 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Fri, 8 Dec 2023 14:55:05 +0800 +Subject: [PATCH 21/30] net/hns3: refactor VF mailbox message struct + +[ upstream commit 692b35be121b724119da001d7ec4c0fabd51177b ] + +The data region in VF to PF mbx memssage command is +used to communicate with PF driver. And this data +region exists as an array. As a result, some complicated +feature commands, like setting promisc mode, map/unmap +ring vector and setting VLAN id, have to use magic number +to set them. This isn't good for maintenance of driver. +So this patch refactors these messages by extracting an +hns3_vf_to_pf_msg structure. + +In addition, the PF link change event message is reported +by the firmware and is reported in hns3_mbx_vf_to_pf_cmd +format, it also needs to be modified. + +Fixes: 463e748964f5 ("net/hns3: support mailbox") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_ethdev_vf.c | 54 ++++++++++++++--------------- + drivers/net/hns3/hns3_mbx.c | 24 ++++++------- + drivers/net/hns3/hns3_mbx.h | 56 ++++++++++++++++++++++--------- + 3 files changed, 76 insertions(+), 58 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c +index 916cc0f..19e734c 100644 +--- a/drivers/net/hns3/hns3_ethdev_vf.c ++++ b/drivers/net/hns3/hns3_ethdev_vf.c +@@ -254,11 +254,12 @@ hns3vf_set_promisc_mode(struct hns3_hw *hw, bool en_bc_pmc, + * the packets with vlan tag in promiscuous mode. + */ + hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_MBX_VF_TO_PF, false); +- req->msg[0] = HNS3_MBX_SET_PROMISC_MODE; +- req->msg[1] = en_bc_pmc ? 1 : 0; +- req->msg[2] = en_uc_pmc ? 1 : 0; +- req->msg[3] = en_mc_pmc ? 1 : 0; +- req->msg[4] = hw->promisc_mode == HNS3_LIMIT_PROMISC_MODE ? 1 : 0; ++ req->msg.code = HNS3_MBX_SET_PROMISC_MODE; ++ req->msg.en_bc = en_bc_pmc ? 1 : 0; ++ req->msg.en_uc = en_uc_pmc ? 1 : 0; ++ req->msg.en_mc = en_mc_pmc ? 1 : 0; ++ req->msg.en_limit_promisc = ++ hw->promisc_mode == HNS3_LIMIT_PROMISC_MODE ? 1 : 0; + + ret = hns3_cmd_send(hw, &desc, 1); + if (ret) +@@ -347,30 +348,28 @@ hns3vf_bind_ring_with_vector(struct hns3_hw *hw, uint16_t vector_id, + bool mmap, enum hns3_ring_type queue_type, + uint16_t queue_id) + { +- struct hns3_vf_bind_vector_msg bind_msg; ++#define HNS3_RING_VERCTOR_DATA_SIZE 14 ++ struct hns3_vf_to_pf_msg req = {0}; + const char *op_str; +- uint16_t code; + int ret; + +- memset(&bind_msg, 0, sizeof(bind_msg)); +- code = mmap ? HNS3_MBX_MAP_RING_TO_VECTOR : ++ req.code = mmap ? HNS3_MBX_MAP_RING_TO_VECTOR : + HNS3_MBX_UNMAP_RING_TO_VECTOR; +- bind_msg.vector_id = (uint8_t)vector_id; ++ req.vector_id = (uint8_t)vector_id; ++ req.ring_num = 1; + + if (queue_type == HNS3_RING_TYPE_RX) +- bind_msg.param[0].int_gl_index = HNS3_RING_GL_RX; ++ req.ring_param[0].int_gl_index = HNS3_RING_GL_RX; + else +- bind_msg.param[0].int_gl_index = HNS3_RING_GL_TX; +- +- bind_msg.param[0].ring_type = queue_type; +- bind_msg.ring_num = 1; +- bind_msg.param[0].tqp_index = queue_id; ++ req.ring_param[0].int_gl_index = HNS3_RING_GL_TX; ++ req.ring_param[0].ring_type = queue_type; ++ req.ring_param[0].tqp_index = queue_id; + op_str = mmap ? "Map" : "Unmap"; +- ret = hns3_send_mbx_msg(hw, code, 0, (uint8_t *)&bind_msg, +- sizeof(bind_msg), false, NULL, 0); ++ ret = hns3_send_mbx_msg(hw, req.code, 0, (uint8_t *)&req.vector_id, ++ HNS3_RING_VERCTOR_DATA_SIZE, false, NULL, 0); + if (ret) +- hns3_err(hw, "%s TQP %u fail, vector_id is %u, ret is %d.", +- op_str, queue_id, bind_msg.vector_id, ret); ++ hns3_err(hw, "%s TQP %u fail, vector_id is %u, ret = %d.", ++ op_str, queue_id, req.vector_id, ret); + + return ret; + } +@@ -965,19 +964,16 @@ hns3vf_update_link_status(struct hns3_hw *hw, uint8_t link_status, + static int + hns3vf_vlan_filter_configure(struct hns3_adapter *hns, uint16_t vlan_id, int on) + { +-#define HNS3VF_VLAN_MBX_MSG_LEN 5 ++ struct hns3_mbx_vlan_filter vlan_filter = {0}; + struct hns3_hw *hw = &hns->hw; +- uint8_t msg_data[HNS3VF_VLAN_MBX_MSG_LEN]; +- uint16_t proto = htons(RTE_ETHER_TYPE_VLAN); +- uint8_t is_kill = on ? 0 : 1; + +- msg_data[0] = is_kill; +- memcpy(&msg_data[1], &vlan_id, sizeof(vlan_id)); +- memcpy(&msg_data[3], &proto, sizeof(proto)); ++ vlan_filter.is_kill = on ? 0 : 1; ++ vlan_filter.proto = rte_cpu_to_le_16(RTE_ETHER_TYPE_VLAN); ++ vlan_filter.vlan_id = rte_cpu_to_le_16(vlan_id); + + return hns3_send_mbx_msg(hw, HNS3_MBX_SET_VLAN, HNS3_MBX_VLAN_FILTER, +- msg_data, HNS3VF_VLAN_MBX_MSG_LEN, true, NULL, +- 0); ++ (uint8_t *)&vlan_filter, sizeof(vlan_filter), ++ true, NULL, 0); + } + + static int +diff --git a/drivers/net/hns3/hns3_mbx.c b/drivers/net/hns3/hns3_mbx.c +index f1743c1..ad5ec55 100644 +--- a/drivers/net/hns3/hns3_mbx.c ++++ b/drivers/net/hns3/hns3_mbx.c +@@ -11,8 +11,6 @@ + #include "hns3_intr.h" + #include "hns3_rxtx.h" + +-#define HNS3_CMD_CODE_OFFSET 2 +- + static const struct errno_respcode_map err_code_map[] = { + {0, 0}, + {1, -EPERM}, +@@ -127,29 +125,30 @@ hns3_send_mbx_msg(struct hns3_hw *hw, uint16_t code, uint16_t subcode, + struct hns3_mbx_vf_to_pf_cmd *req; + struct hns3_cmd_desc desc; + bool is_ring_vector_msg; +- int offset; + int ret; + + req = (struct hns3_mbx_vf_to_pf_cmd *)desc.data; + + /* first two bytes are reserved for code & subcode */ +- if (msg_len > (HNS3_MBX_MAX_MSG_SIZE - HNS3_CMD_CODE_OFFSET)) { ++ if (msg_len > HNS3_MBX_MSG_MAX_DATA_SIZE) { + hns3_err(hw, + "VF send mbx msg fail, msg len %u exceeds max payload len %d", +- msg_len, HNS3_MBX_MAX_MSG_SIZE - HNS3_CMD_CODE_OFFSET); ++ msg_len, HNS3_MBX_MSG_MAX_DATA_SIZE); + return -EINVAL; + } + + hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_MBX_VF_TO_PF, false); +- req->msg[0] = code; ++ req->msg.code = code; + is_ring_vector_msg = (code == HNS3_MBX_MAP_RING_TO_VECTOR) || + (code == HNS3_MBX_UNMAP_RING_TO_VECTOR) || + (code == HNS3_MBX_GET_RING_VECTOR_MAP); + if (!is_ring_vector_msg) +- req->msg[1] = subcode; ++ req->msg.subcode = subcode; + if (msg_data) { +- offset = is_ring_vector_msg ? 1 : HNS3_CMD_CODE_OFFSET; +- memcpy(&req->msg[offset], msg_data, msg_len); ++ if (is_ring_vector_msg) ++ memcpy(&req->msg.vector_id, msg_data, msg_len); ++ else ++ memcpy(&req->msg.data, msg_data, msg_len); + } + + /* synchronous send */ +@@ -296,11 +295,8 @@ static void + hns3pf_handle_link_change_event(struct hns3_hw *hw, + struct hns3_mbx_vf_to_pf_cmd *req) + { +-#define LINK_STATUS_OFFSET 1 +-#define LINK_FAIL_CODE_OFFSET 2 +- +- if (!req->msg[LINK_STATUS_OFFSET]) +- hns3_link_fail_parse(hw, req->msg[LINK_FAIL_CODE_OFFSET]); ++ if (!req->msg.link_status) ++ hns3_link_fail_parse(hw, req->msg.link_fail_code); + + hns3_update_linkstatus_and_event(hw, true); + } +diff --git a/drivers/net/hns3/hns3_mbx.h b/drivers/net/hns3/hns3_mbx.h +index 4a32880..59fb73a 100644 +--- a/drivers/net/hns3/hns3_mbx.h ++++ b/drivers/net/hns3/hns3_mbx.h +@@ -89,7 +89,6 @@ enum hns3_mbx_link_fail_subcode { + HNS3_MBX_LF_XSFP_ABSENT, + }; + +-#define HNS3_MBX_MAX_MSG_SIZE 16 + #define HNS3_MBX_MAX_RESP_DATA_SIZE 8 + #define HNS3_MBX_DEF_TIME_LIMIT_MS 500 + +@@ -107,6 +106,46 @@ struct hns3_mbx_resp_status { + uint8_t additional_info[HNS3_MBX_MAX_RESP_DATA_SIZE]; + }; + ++struct hns3_ring_chain_param { ++ uint8_t ring_type; ++ uint8_t tqp_index; ++ uint8_t int_gl_index; ++}; ++ ++struct hns3_mbx_vlan_filter { ++ uint8_t is_kill; ++ uint16_t vlan_id; ++ uint16_t proto; ++} __rte_packed; ++ ++#define HNS3_MBX_MSG_MAX_DATA_SIZE 14 ++#define HNS3_MBX_MAX_RING_CHAIN_PARAM_NUM 4 ++struct hns3_vf_to_pf_msg { ++ uint8_t code; ++ union { ++ struct { ++ uint8_t subcode; ++ uint8_t data[HNS3_MBX_MSG_MAX_DATA_SIZE]; ++ }; ++ struct { ++ uint8_t en_bc; ++ uint8_t en_uc; ++ uint8_t en_mc; ++ uint8_t en_limit_promisc; ++ }; ++ struct { ++ uint8_t vector_id; ++ uint8_t ring_num; ++ struct hns3_ring_chain_param ++ ring_param[HNS3_MBX_MAX_RING_CHAIN_PARAM_NUM]; ++ }; ++ struct { ++ uint8_t link_status; ++ uint8_t link_fail_code; ++ }; ++ }; ++}; ++ + struct errno_respcode_map { + uint16_t resp_code; + int err_no; +@@ -122,7 +161,7 @@ struct hns3_mbx_vf_to_pf_cmd { + uint8_t msg_len; + uint8_t rsv2; + uint16_t match_id; +- uint8_t msg[HNS3_MBX_MAX_MSG_SIZE]; ++ struct hns3_vf_to_pf_msg msg; + }; + + struct hns3_mbx_pf_to_vf_cmd { +@@ -134,19 +173,6 @@ struct hns3_mbx_pf_to_vf_cmd { + uint16_t msg[8]; + }; + +-struct hns3_ring_chain_param { +- uint8_t ring_type; +- uint8_t tqp_index; +- uint8_t int_gl_index; +-}; +- +-#define HNS3_MBX_MAX_RING_CHAIN_PARAM_NUM 4 +-struct hns3_vf_bind_vector_msg { +- uint8_t vector_id; +- uint8_t ring_num; +- struct hns3_ring_chain_param param[HNS3_MBX_MAX_RING_CHAIN_PARAM_NUM]; +-}; +- + struct hns3_pf_rst_done_cmd { + uint8_t pf_rst_done; + uint8_t rsv[23]; +-- +2.33.0 + diff --git a/0022-net-hns3-refactor-PF-mailbox-message-struct.patch b/0022-net-hns3-refactor-PF-mailbox-message-struct.patch new file mode 100644 index 0000000..1b28c06 --- /dev/null +++ b/0022-net-hns3-refactor-PF-mailbox-message-struct.patch @@ -0,0 +1,195 @@ +From 11e1f6c8b4ec6d246b65448a65533aad7129a5d2 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Fri, 8 Dec 2023 14:55:06 +0800 +Subject: [PATCH 22/30] net/hns3: refactor PF mailbox message struct + +[ upstream commit 4d534598d922130d12c244d3237652fbfdad0f4b ] + +The data region in PF to VF mbx memssage command is used +to communicate with VF driver. And this data region exists +as an array. As a result, some complicated feature commands, +like mailbox response, link change event, close promisc mode, +reset request and update pvid state, have to use magic number +to set them. This isn't good for maintenance of driver. So +this patch refactors these messages by extracting an +hns3_pf_to_vf_msg structure. + +Fixes: 463e748964f5 ("net/hns3: support mailbox") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_mbx.c | 38 ++++++++++++++++++------------------- + drivers/net/hns3/hns3_mbx.h | 25 +++++++++++++++++++++++- + 2 files changed, 43 insertions(+), 20 deletions(-) + +diff --git a/drivers/net/hns3/hns3_mbx.c b/drivers/net/hns3/hns3_mbx.c +index ad5ec55..c90f5d5 100644 +--- a/drivers/net/hns3/hns3_mbx.c ++++ b/drivers/net/hns3/hns3_mbx.c +@@ -192,17 +192,17 @@ static void + hns3vf_handle_link_change_event(struct hns3_hw *hw, + struct hns3_mbx_pf_to_vf_cmd *req) + { ++ struct hns3_mbx_link_status *link_info = ++ (struct hns3_mbx_link_status *)req->msg.msg_data; + uint8_t link_status, link_duplex; +- uint16_t *msg_q = req->msg; + uint8_t support_push_lsc; + uint32_t link_speed; + +- memcpy(&link_speed, &msg_q[2], sizeof(link_speed)); +- link_status = rte_le_to_cpu_16(msg_q[1]); +- link_duplex = (uint8_t)rte_le_to_cpu_16(msg_q[4]); +- hns3vf_update_link_status(hw, link_status, link_speed, +- link_duplex); +- support_push_lsc = (*(uint8_t *)&msg_q[5]) & 1u; ++ link_status = (uint8_t)rte_le_to_cpu_16(link_info->link_status); ++ link_speed = rte_le_to_cpu_32(link_info->speed); ++ link_duplex = (uint8_t)rte_le_to_cpu_16(link_info->duplex); ++ hns3vf_update_link_status(hw, link_status, link_speed, link_duplex); ++ support_push_lsc = (link_info->flag) & 1u; + hns3vf_update_push_lsc_cap(hw, support_push_lsc); + } + +@@ -211,7 +211,6 @@ hns3_handle_asserting_reset(struct hns3_hw *hw, + struct hns3_mbx_pf_to_vf_cmd *req) + { + enum hns3_reset_level reset_level; +- uint16_t *msg_q = req->msg; + + /* + * PF has asserted reset hence VF should go in pending +@@ -219,7 +218,7 @@ hns3_handle_asserting_reset(struct hns3_hw *hw, + * has been completely reset. After this stack should + * eventually be re-initialized. + */ +- reset_level = rte_le_to_cpu_16(msg_q[1]); ++ reset_level = rte_le_to_cpu_16(req->msg.reset_level); + hns3_atomic_set_bit(reset_level, &hw->reset.pending); + + hns3_warn(hw, "PF inform reset level %d", reset_level); +@@ -241,8 +240,9 @@ hns3_handle_mbx_response(struct hns3_hw *hw, struct hns3_mbx_pf_to_vf_cmd *req) + * to match the request. + */ + if (req->match_id == resp->match_id) { +- resp->resp_status = hns3_resp_to_errno(req->msg[3]); +- memcpy(resp->additional_info, &req->msg[4], ++ resp->resp_status = ++ hns3_resp_to_errno(req->msg.resp_status); ++ memcpy(resp->additional_info, &req->msg.resp_data, + HNS3_MBX_MAX_RESP_DATA_SIZE); + rte_io_wmb(); + resp->received_match_resp = true; +@@ -255,7 +255,8 @@ hns3_handle_mbx_response(struct hns3_hw *hw, struct hns3_mbx_pf_to_vf_cmd *req) + * support copy request's match_id to its response. So VF follows the + * original scheme to process. + */ +- msg_data = (uint32_t)req->msg[1] << HNS3_MBX_RESP_CODE_OFFSET | req->msg[2]; ++ msg_data = (uint32_t)req->msg.vf_mbx_msg_code << ++ HNS3_MBX_RESP_CODE_OFFSET | req->msg.vf_mbx_msg_subcode; + if (resp->req_msg_data != msg_data) { + hns3_warn(hw, + "received response tag (%u) is mismatched with requested tag (%u)", +@@ -263,8 +264,8 @@ hns3_handle_mbx_response(struct hns3_hw *hw, struct hns3_mbx_pf_to_vf_cmd *req) + return; + } + +- resp->resp_status = hns3_resp_to_errno(req->msg[3]); +- memcpy(resp->additional_info, &req->msg[4], ++ resp->resp_status = hns3_resp_to_errno(req->msg.resp_status); ++ memcpy(resp->additional_info, &req->msg.resp_data, + HNS3_MBX_MAX_RESP_DATA_SIZE); + rte_io_wmb(); + resp->received_match_resp = true; +@@ -305,8 +306,7 @@ static void + hns3_update_port_base_vlan_info(struct hns3_hw *hw, + struct hns3_mbx_pf_to_vf_cmd *req) + { +-#define PVID_STATE_OFFSET 1 +- uint16_t new_pvid_state = req->msg[PVID_STATE_OFFSET] ? ++ uint16_t new_pvid_state = req->msg.pvid_state ? + HNS3_PORT_BASE_VLAN_ENABLE : HNS3_PORT_BASE_VLAN_DISABLE; + /* + * Currently, hardware doesn't support more than two layers VLAN offload +@@ -355,7 +355,7 @@ hns3_handle_mbx_msg_out_intr(struct hns3_hw *hw) + while (next_to_use != tail) { + desc = &crq->desc[next_to_use]; + req = (struct hns3_mbx_pf_to_vf_cmd *)desc->data; +- opcode = req->msg[0] & 0xff; ++ opcode = req->msg.code & 0xff; + + flag = rte_le_to_cpu_16(crq->desc[next_to_use].flag); + if (!hns3_get_bit(flag, HNS3_CMDQ_RX_OUTVLD_B)) +@@ -428,7 +428,7 @@ hns3_dev_handle_mbx_msg(struct hns3_hw *hw) + + desc = &crq->desc[crq->next_to_use]; + req = (struct hns3_mbx_pf_to_vf_cmd *)desc->data; +- opcode = req->msg[0] & 0xff; ++ opcode = req->msg.code & 0xff; + + flag = rte_le_to_cpu_16(crq->desc[crq->next_to_use].flag); + if (unlikely(!hns3_get_bit(flag, HNS3_CMDQ_RX_OUTVLD_B))) { +@@ -484,7 +484,7 @@ hns3_dev_handle_mbx_msg(struct hns3_hw *hw) + * hns3 PF kernel driver, VF driver will receive this + * mailbox message from PF driver. + */ +- hns3_handle_promisc_info(hw, req->msg[1]); ++ hns3_handle_promisc_info(hw, req->msg.promisc_en); + break; + default: + hns3_err(hw, "received unsupported(%u) mbx msg", +diff --git a/drivers/net/hns3/hns3_mbx.h b/drivers/net/hns3/hns3_mbx.h +index 59fb73a..09780fc 100644 +--- a/drivers/net/hns3/hns3_mbx.h ++++ b/drivers/net/hns3/hns3_mbx.h +@@ -118,6 +118,13 @@ struct hns3_mbx_vlan_filter { + uint16_t proto; + } __rte_packed; + ++struct hns3_mbx_link_status { ++ uint16_t link_status; ++ uint32_t speed; ++ uint16_t duplex; ++ uint8_t flag; ++} __rte_packed; ++ + #define HNS3_MBX_MSG_MAX_DATA_SIZE 14 + #define HNS3_MBX_MAX_RING_CHAIN_PARAM_NUM 4 + struct hns3_vf_to_pf_msg { +@@ -146,6 +153,22 @@ struct hns3_vf_to_pf_msg { + }; + }; + ++struct hns3_pf_to_vf_msg { ++ uint16_t code; ++ union { ++ struct { ++ uint16_t vf_mbx_msg_code; ++ uint16_t vf_mbx_msg_subcode; ++ uint16_t resp_status; ++ uint8_t resp_data[HNS3_MBX_MAX_RESP_DATA_SIZE]; ++ }; ++ uint16_t promisc_en; ++ uint16_t reset_level; ++ uint16_t pvid_state; ++ uint8_t msg_data[HNS3_MBX_MSG_MAX_DATA_SIZE]; ++ }; ++}; ++ + struct errno_respcode_map { + uint16_t resp_code; + int err_no; +@@ -170,7 +193,7 @@ struct hns3_mbx_pf_to_vf_cmd { + uint8_t msg_len; + uint8_t rsv1; + uint16_t match_id; +- uint16_t msg[8]; ++ struct hns3_pf_to_vf_msg msg; + }; + + struct hns3_pf_rst_done_cmd { +-- +2.33.0 + diff --git a/0023-net-hns3-refactor-send-mailbox-function.patch b/0023-net-hns3-refactor-send-mailbox-function.patch new file mode 100644 index 0000000..667f871 --- /dev/null +++ b/0023-net-hns3-refactor-send-mailbox-function.patch @@ -0,0 +1,526 @@ +From a7731d0a954c84aaf347aef67a773ae1561e7cd5 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Fri, 8 Dec 2023 14:55:07 +0800 +Subject: [PATCH 23/30] net/hns3: refactor send mailbox function + +[ upstream commit c9bd98d84587dbc0dddb8964ad3d7d54818aca01 ] + +The 'hns3_send_mbx_msg' function has following problem: +1. the name is vague, missing caller indication +2. too many input parameters because the filling messages + are placed in commands the send command. + +Therefore, a common interface is encapsulated to fill in +the mailbox message before sending it. + +Fixes: 463e748964f5 ("net/hns3: support mailbox") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_ethdev_vf.c | 141 ++++++++++++++++++------------ + drivers/net/hns3/hns3_mbx.c | 50 ++++------- + drivers/net/hns3/hns3_mbx.h | 8 +- + drivers/net/hns3/hns3_rxtx.c | 18 ++-- + 4 files changed, 116 insertions(+), 101 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c +index 19e734c..b0d0c29 100644 +--- a/drivers/net/hns3/hns3_ethdev_vf.c ++++ b/drivers/net/hns3/hns3_ethdev_vf.c +@@ -91,11 +91,13 @@ hns3vf_add_uc_mac_addr(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + { + /* mac address was checked by upper level interface */ + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; ++ struct hns3_vf_to_pf_msg req; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_UNICAST, +- HNS3_MBX_MAC_VLAN_UC_ADD, mac_addr->addr_bytes, +- RTE_ETHER_ADDR_LEN, false, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_UNICAST, ++ HNS3_MBX_MAC_VLAN_UC_ADD); ++ memcpy(req.data, mac_addr->addr_bytes, RTE_ETHER_ADDR_LEN); ++ ret = hns3vf_mbx_send(hw, &req, false, NULL, 0); + if (ret) { + hns3_ether_format_addr(mac_str, RTE_ETHER_ADDR_FMT_SIZE, + mac_addr); +@@ -110,12 +112,13 @@ hns3vf_remove_uc_mac_addr(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + { + /* mac address was checked by upper level interface */ + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; ++ struct hns3_vf_to_pf_msg req; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_UNICAST, +- HNS3_MBX_MAC_VLAN_UC_REMOVE, +- mac_addr->addr_bytes, RTE_ETHER_ADDR_LEN, +- false, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_UNICAST, ++ HNS3_MBX_MAC_VLAN_UC_REMOVE); ++ memcpy(req.data, mac_addr->addr_bytes, RTE_ETHER_ADDR_LEN); ++ ret = hns3vf_mbx_send(hw, &req, false, NULL, 0); + if (ret) { + hns3_ether_format_addr(mac_str, RTE_ETHER_ADDR_FMT_SIZE, + mac_addr); +@@ -134,6 +137,7 @@ hns3vf_set_default_mac_addr(struct rte_eth_dev *dev, + struct rte_ether_addr *old_addr; + uint8_t addr_bytes[HNS3_TWO_ETHER_ADDR_LEN]; /* for 2 MAC addresses */ + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; ++ struct hns3_vf_to_pf_msg req; + int ret; + + /* +@@ -146,9 +150,10 @@ hns3vf_set_default_mac_addr(struct rte_eth_dev *dev, + memcpy(&addr_bytes[RTE_ETHER_ADDR_LEN], old_addr->addr_bytes, + RTE_ETHER_ADDR_LEN); + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_UNICAST, +- HNS3_MBX_MAC_VLAN_UC_MODIFY, addr_bytes, +- HNS3_TWO_ETHER_ADDR_LEN, true, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_UNICAST, ++ HNS3_MBX_MAC_VLAN_UC_MODIFY); ++ memcpy(req.data, addr_bytes, HNS3_TWO_ETHER_ADDR_LEN); ++ ret = hns3vf_mbx_send(hw, &req, true, NULL, 0); + if (ret) { + /* + * The hns3 VF PMD depends on the hns3 PF kernel ethdev +@@ -185,12 +190,13 @@ hns3vf_add_mc_mac_addr(struct hns3_hw *hw, + struct rte_ether_addr *mac_addr) + { + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; ++ struct hns3_vf_to_pf_msg req; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_MULTICAST, +- HNS3_MBX_MAC_VLAN_MC_ADD, +- mac_addr->addr_bytes, RTE_ETHER_ADDR_LEN, false, +- NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_MULTICAST, ++ HNS3_MBX_MAC_VLAN_MC_ADD); ++ memcpy(req.data, mac_addr->addr_bytes, RTE_ETHER_ADDR_LEN); ++ ret = hns3vf_mbx_send(hw, &req, false, NULL, 0); + if (ret) { + hns3_ether_format_addr(mac_str, RTE_ETHER_ADDR_FMT_SIZE, + mac_addr); +@@ -206,12 +212,13 @@ hns3vf_remove_mc_mac_addr(struct hns3_hw *hw, + struct rte_ether_addr *mac_addr) + { + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; ++ struct hns3_vf_to_pf_msg req; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_MULTICAST, +- HNS3_MBX_MAC_VLAN_MC_REMOVE, +- mac_addr->addr_bytes, RTE_ETHER_ADDR_LEN, false, +- NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_MULTICAST, ++ HNS3_MBX_MAC_VLAN_MC_REMOVE); ++ memcpy(req.data, mac_addr->addr_bytes, RTE_ETHER_ADDR_LEN); ++ ret = hns3vf_mbx_send(hw, &req, false, NULL, 0); + if (ret) { + hns3_ether_format_addr(mac_str, RTE_ETHER_ADDR_FMT_SIZE, + mac_addr); +@@ -348,7 +355,6 @@ hns3vf_bind_ring_with_vector(struct hns3_hw *hw, uint16_t vector_id, + bool mmap, enum hns3_ring_type queue_type, + uint16_t queue_id) + { +-#define HNS3_RING_VERCTOR_DATA_SIZE 14 + struct hns3_vf_to_pf_msg req = {0}; + const char *op_str; + int ret; +@@ -365,8 +371,7 @@ hns3vf_bind_ring_with_vector(struct hns3_hw *hw, uint16_t vector_id, + req.ring_param[0].ring_type = queue_type; + req.ring_param[0].tqp_index = queue_id; + op_str = mmap ? "Map" : "Unmap"; +- ret = hns3_send_mbx_msg(hw, req.code, 0, (uint8_t *)&req.vector_id, +- HNS3_RING_VERCTOR_DATA_SIZE, false, NULL, 0); ++ ret = hns3vf_mbx_send(hw, &req, false, NULL, 0); + if (ret) + hns3_err(hw, "%s TQP %u fail, vector_id is %u, ret = %d.", + op_str, queue_id, req.vector_id, ret); +@@ -452,10 +457,12 @@ hns3vf_dev_configure(struct rte_eth_dev *dev) + static int + hns3vf_config_mtu(struct hns3_hw *hw, uint16_t mtu) + { ++ struct hns3_vf_to_pf_msg req; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_MTU, 0, (const uint8_t *)&mtu, +- sizeof(mtu), true, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_MTU, 0); ++ memcpy(req.data, &mtu, sizeof(mtu)); ++ ret = hns3vf_mbx_send(hw, &req, true, NULL, 0); + if (ret) + hns3_err(hw, "Failed to set mtu (%u) for vf: %d", mtu, ret); + +@@ -646,12 +653,13 @@ hns3vf_get_push_lsc_cap(struct hns3_hw *hw) + uint16_t val = HNS3_PF_PUSH_LSC_CAP_NOT_SUPPORTED; + uint16_t exp = HNS3_PF_PUSH_LSC_CAP_UNKNOWN; + struct hns3_vf *vf = HNS3_DEV_HW_TO_VF(hw); ++ struct hns3_vf_to_pf_msg req; + + __atomic_store_n(&vf->pf_push_lsc_cap, HNS3_PF_PUSH_LSC_CAP_UNKNOWN, + __ATOMIC_RELEASE); + +- (void)hns3_send_mbx_msg(hw, HNS3_MBX_GET_LINK_STATUS, 0, NULL, 0, false, +- NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_GET_LINK_STATUS, 0); ++ (void)hns3vf_mbx_send(hw, &req, false, NULL, 0); + + while (remain_ms > 0) { + rte_delay_ms(HNS3_POLL_RESPONE_MS); +@@ -746,12 +754,13 @@ hns3vf_check_tqp_info(struct hns3_hw *hw) + static int + hns3vf_get_port_base_vlan_filter_state(struct hns3_hw *hw) + { ++ struct hns3_vf_to_pf_msg req; + uint8_t resp_msg; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_VLAN, +- HNS3_MBX_GET_PORT_BASE_VLAN_STATE, NULL, 0, +- true, &resp_msg, sizeof(resp_msg)); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_VLAN, ++ HNS3_MBX_GET_PORT_BASE_VLAN_STATE); ++ ret = hns3vf_mbx_send(hw, &req, true, &resp_msg, sizeof(resp_msg)); + if (ret) { + if (ret == -ETIME) { + /* +@@ -792,10 +801,12 @@ hns3vf_get_queue_info(struct hns3_hw *hw) + { + #define HNS3VF_TQPS_RSS_INFO_LEN 6 + uint8_t resp_msg[HNS3VF_TQPS_RSS_INFO_LEN]; ++ struct hns3_vf_to_pf_msg req; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_GET_QINFO, 0, NULL, 0, true, +- resp_msg, HNS3VF_TQPS_RSS_INFO_LEN); ++ hns3vf_mbx_setup(&req, HNS3_MBX_GET_QINFO, 0); ++ ret = hns3vf_mbx_send(hw, &req, true, ++ resp_msg, HNS3VF_TQPS_RSS_INFO_LEN); + if (ret) { + PMD_INIT_LOG(ERR, "Failed to get tqp info from PF: %d", ret); + return ret; +@@ -833,10 +844,11 @@ hns3vf_get_basic_info(struct hns3_hw *hw) + { + uint8_t resp_msg[HNS3_MBX_MAX_RESP_DATA_SIZE]; + struct hns3_basic_info *basic_info; ++ struct hns3_vf_to_pf_msg req; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_GET_BASIC_INFO, 0, NULL, 0, +- true, resp_msg, sizeof(resp_msg)); ++ hns3vf_mbx_setup(&req, HNS3_MBX_GET_BASIC_INFO, 0); ++ ret = hns3vf_mbx_send(hw, &req, true, resp_msg, sizeof(resp_msg)); + if (ret) { + hns3_err(hw, "failed to get basic info from PF, ret = %d.", + ret); +@@ -856,10 +868,11 @@ static int + hns3vf_get_host_mac_addr(struct hns3_hw *hw) + { + uint8_t host_mac[RTE_ETHER_ADDR_LEN]; ++ struct hns3_vf_to_pf_msg req; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_GET_MAC_ADDR, 0, NULL, 0, +- true, host_mac, RTE_ETHER_ADDR_LEN); ++ hns3vf_mbx_setup(&req, HNS3_MBX_GET_MAC_ADDR, 0); ++ ret = hns3vf_mbx_send(hw, &req, true, host_mac, RTE_ETHER_ADDR_LEN); + if (ret) { + hns3_err(hw, "Failed to get mac addr from PF: %d", ret); + return ret; +@@ -908,6 +921,7 @@ static void + hns3vf_request_link_info(struct hns3_hw *hw) + { + struct hns3_vf *vf = HNS3_DEV_HW_TO_VF(hw); ++ struct hns3_vf_to_pf_msg req; + bool send_req; + int ret; + +@@ -919,8 +933,8 @@ hns3vf_request_link_info(struct hns3_hw *hw) + if (!send_req) + return; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_GET_LINK_STATUS, 0, NULL, 0, false, +- NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_GET_LINK_STATUS, 0); ++ ret = hns3vf_mbx_send(hw, &req, false, NULL, 0); + if (ret) { + hns3_err(hw, "failed to fetch link status, ret = %d", ret); + return; +@@ -964,16 +978,18 @@ hns3vf_update_link_status(struct hns3_hw *hw, uint8_t link_status, + static int + hns3vf_vlan_filter_configure(struct hns3_adapter *hns, uint16_t vlan_id, int on) + { +- struct hns3_mbx_vlan_filter vlan_filter = {0}; ++ struct hns3_mbx_vlan_filter *vlan_filter; ++ struct hns3_vf_to_pf_msg req = {0}; + struct hns3_hw *hw = &hns->hw; + +- vlan_filter.is_kill = on ? 0 : 1; +- vlan_filter.proto = rte_cpu_to_le_16(RTE_ETHER_TYPE_VLAN); +- vlan_filter.vlan_id = rte_cpu_to_le_16(vlan_id); ++ req.code = HNS3_MBX_SET_VLAN; ++ req.subcode = HNS3_MBX_VLAN_FILTER; ++ vlan_filter = (struct hns3_mbx_vlan_filter *)req.data; ++ vlan_filter->is_kill = on ? 0 : 1; ++ vlan_filter->proto = rte_cpu_to_le_16(RTE_ETHER_TYPE_VLAN); ++ vlan_filter->vlan_id = rte_cpu_to_le_16(vlan_id); + +- return hns3_send_mbx_msg(hw, HNS3_MBX_SET_VLAN, HNS3_MBX_VLAN_FILTER, +- (uint8_t *)&vlan_filter, sizeof(vlan_filter), +- true, NULL, 0); ++ return hns3vf_mbx_send(hw, &req, true, NULL, 0); + } + + static int +@@ -1002,6 +1018,7 @@ hns3vf_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on) + static int + hns3vf_en_vlan_filter(struct hns3_hw *hw, bool enable) + { ++ struct hns3_vf_to_pf_msg req; + uint8_t msg_data; + int ret; + +@@ -1009,9 +1026,10 @@ hns3vf_en_vlan_filter(struct hns3_hw *hw, bool enable) + return 0; + + msg_data = enable ? 1 : 0; +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_VLAN, +- HNS3_MBX_ENABLE_VLAN_FILTER, &msg_data, +- sizeof(msg_data), true, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_VLAN, ++ HNS3_MBX_ENABLE_VLAN_FILTER); ++ memcpy(req.data, &msg_data, sizeof(msg_data)); ++ ret = hns3vf_mbx_send(hw, &req, true, NULL, 0); + if (ret) + hns3_err(hw, "%s vlan filter failed, ret = %d.", + enable ? "enable" : "disable", ret); +@@ -1022,12 +1040,15 @@ hns3vf_en_vlan_filter(struct hns3_hw *hw, bool enable) + static int + hns3vf_en_hw_strip_rxvtag(struct hns3_hw *hw, bool enable) + { ++ struct hns3_vf_to_pf_msg req; + uint8_t msg_data; + int ret; + + msg_data = enable ? 1 : 0; +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_SET_VLAN, HNS3_MBX_VLAN_RX_OFF_CFG, +- &msg_data, sizeof(msg_data), false, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_VLAN, ++ HNS3_MBX_VLAN_RX_OFF_CFG); ++ memcpy(req.data, &msg_data, sizeof(msg_data)); ++ ret = hns3vf_mbx_send(hw, &req, false, NULL, 0); + if (ret) + hns3_err(hw, "vf %s strip failed, ret = %d.", + enable ? "enable" : "disable", ret); +@@ -1171,11 +1192,13 @@ hns3vf_dev_configure_vlan(struct rte_eth_dev *dev) + static int + hns3vf_set_alive(struct hns3_hw *hw, bool alive) + { ++ struct hns3_vf_to_pf_msg req; + uint8_t msg_data; + + msg_data = alive ? 1 : 0; +- return hns3_send_mbx_msg(hw, HNS3_MBX_SET_ALIVE, 0, &msg_data, +- sizeof(msg_data), false, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_SET_ALIVE, 0); ++ memcpy(req.data, &msg_data, sizeof(msg_data)); ++ return hns3vf_mbx_send(hw, &req, false, NULL, 0); + } + + static void +@@ -1183,11 +1206,12 @@ hns3vf_keep_alive_handler(void *param) + { + struct rte_eth_dev *eth_dev = (struct rte_eth_dev *)param; + struct hns3_adapter *hns = eth_dev->data->dev_private; ++ struct hns3_vf_to_pf_msg req; + struct hns3_hw *hw = &hns->hw; + int ret; + +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_KEEP_ALIVE, 0, NULL, 0, +- false, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_KEEP_ALIVE, 0); ++ ret = hns3vf_mbx_send(hw, &req, false, NULL, 0); + if (ret) + hns3_err(hw, "VF sends keeping alive cmd failed(=%d)", + ret); +@@ -1326,9 +1350,11 @@ hns3vf_init_hardware(struct hns3_adapter *hns) + static int + hns3vf_clear_vport_list(struct hns3_hw *hw) + { +- return hns3_send_mbx_msg(hw, HNS3_MBX_HANDLE_VF_TBL, +- HNS3_MBX_VPORT_LIST_CLEAR, NULL, 0, false, +- NULL, 0); ++ struct hns3_vf_to_pf_msg req; ++ ++ hns3vf_mbx_setup(&req, HNS3_MBX_HANDLE_VF_TBL, ++ HNS3_MBX_VPORT_LIST_CLEAR); ++ return hns3vf_mbx_send(hw, &req, false, NULL, 0); + } + + static int +@@ -1797,12 +1823,13 @@ hns3vf_wait_hardware_ready(struct hns3_adapter *hns) + static int + hns3vf_prepare_reset(struct hns3_adapter *hns) + { ++ struct hns3_vf_to_pf_msg req; + struct hns3_hw *hw = &hns->hw; + int ret; + + if (hw->reset.level == HNS3_VF_FUNC_RESET) { +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_RESET, 0, NULL, +- 0, true, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_RESET, 0); ++ ret = hns3vf_mbx_send(hw, &req, true, NULL, 0); + if (ret) + return ret; + } +diff --git a/drivers/net/hns3/hns3_mbx.c b/drivers/net/hns3/hns3_mbx.c +index c90f5d5..43195ff 100644 +--- a/drivers/net/hns3/hns3_mbx.c ++++ b/drivers/net/hns3/hns3_mbx.c +@@ -24,6 +24,14 @@ static const struct errno_respcode_map err_code_map[] = { + {95, -EOPNOTSUPP}, + }; + ++void ++hns3vf_mbx_setup(struct hns3_vf_to_pf_msg *req, uint8_t code, uint8_t subcode) ++{ ++ memset(req, 0, sizeof(struct hns3_vf_to_pf_msg)); ++ req->code = code; ++ req->subcode = subcode; ++} ++ + static int + hns3_resp_to_errno(uint16_t resp_code) + { +@@ -118,45 +126,24 @@ hns3_mbx_prepare_resp(struct hns3_hw *hw, uint16_t code, uint16_t subcode) + } + + int +-hns3_send_mbx_msg(struct hns3_hw *hw, uint16_t code, uint16_t subcode, +- const uint8_t *msg_data, uint8_t msg_len, bool need_resp, +- uint8_t *resp_data, uint16_t resp_len) ++hns3vf_mbx_send(struct hns3_hw *hw, ++ struct hns3_vf_to_pf_msg *req, bool need_resp, ++ uint8_t *resp_data, uint16_t resp_len) + { +- struct hns3_mbx_vf_to_pf_cmd *req; ++ struct hns3_mbx_vf_to_pf_cmd *cmd; + struct hns3_cmd_desc desc; +- bool is_ring_vector_msg; + int ret; + +- req = (struct hns3_mbx_vf_to_pf_cmd *)desc.data; +- +- /* first two bytes are reserved for code & subcode */ +- if (msg_len > HNS3_MBX_MSG_MAX_DATA_SIZE) { +- hns3_err(hw, +- "VF send mbx msg fail, msg len %u exceeds max payload len %d", +- msg_len, HNS3_MBX_MSG_MAX_DATA_SIZE); +- return -EINVAL; +- } +- + hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_MBX_VF_TO_PF, false); +- req->msg.code = code; +- is_ring_vector_msg = (code == HNS3_MBX_MAP_RING_TO_VECTOR) || +- (code == HNS3_MBX_UNMAP_RING_TO_VECTOR) || +- (code == HNS3_MBX_GET_RING_VECTOR_MAP); +- if (!is_ring_vector_msg) +- req->msg.subcode = subcode; +- if (msg_data) { +- if (is_ring_vector_msg) +- memcpy(&req->msg.vector_id, msg_data, msg_len); +- else +- memcpy(&req->msg.data, msg_data, msg_len); +- } ++ cmd = (struct hns3_mbx_vf_to_pf_cmd *)desc.data; ++ cmd->msg = *req; + + /* synchronous send */ + if (need_resp) { +- req->mbx_need_resp |= HNS3_MBX_NEED_RESP_BIT; ++ cmd->mbx_need_resp |= HNS3_MBX_NEED_RESP_BIT; + rte_spinlock_lock(&hw->mbx_resp.lock); +- hns3_mbx_prepare_resp(hw, code, subcode); +- req->match_id = hw->mbx_resp.match_id; ++ hns3_mbx_prepare_resp(hw, req->code, req->subcode); ++ cmd->match_id = hw->mbx_resp.match_id; + ret = hns3_cmd_send(hw, &desc, 1); + if (ret) { + rte_spinlock_unlock(&hw->mbx_resp.lock); +@@ -165,7 +152,8 @@ hns3_send_mbx_msg(struct hns3_hw *hw, uint16_t code, uint16_t subcode, + return ret; + } + +- ret = hns3_get_mbx_resp(hw, code, subcode, resp_data, resp_len); ++ ret = hns3_get_mbx_resp(hw, req->code, req->subcode, ++ resp_data, resp_len); + rte_spinlock_unlock(&hw->mbx_resp.lock); + } else { + /* asynchronous send */ +diff --git a/drivers/net/hns3/hns3_mbx.h b/drivers/net/hns3/hns3_mbx.h +index 09780fc..2952b96 100644 +--- a/drivers/net/hns3/hns3_mbx.h ++++ b/drivers/net/hns3/hns3_mbx.h +@@ -208,7 +208,9 @@ struct hns3_pf_rst_done_cmd { + + struct hns3_hw; + void hns3_dev_handle_mbx_msg(struct hns3_hw *hw); +-int hns3_send_mbx_msg(struct hns3_hw *hw, uint16_t code, uint16_t subcode, +- const uint8_t *msg_data, uint8_t msg_len, bool need_resp, +- uint8_t *resp_data, uint16_t resp_len); ++void hns3vf_mbx_setup(struct hns3_vf_to_pf_msg *req, ++ uint8_t code, uint8_t subcode); ++int hns3vf_mbx_send(struct hns3_hw *hw, ++ struct hns3_vf_to_pf_msg *req_msg, bool need_resp, ++ uint8_t *resp_data, uint16_t resp_len); + #endif /* HNS3_MBX_H */ +diff --git a/drivers/net/hns3/hns3_rxtx.c b/drivers/net/hns3/hns3_rxtx.c +index 09b7e90..9087bcf 100644 +--- a/drivers/net/hns3/hns3_rxtx.c ++++ b/drivers/net/hns3/hns3_rxtx.c +@@ -686,13 +686,12 @@ hns3pf_reset_tqp(struct hns3_hw *hw, uint16_t queue_id) + static int + hns3vf_reset_tqp(struct hns3_hw *hw, uint16_t queue_id) + { +- uint8_t msg_data[2]; ++ struct hns3_vf_to_pf_msg req; + int ret; + +- memcpy(msg_data, &queue_id, sizeof(uint16_t)); +- +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_QUEUE_RESET, 0, msg_data, +- sizeof(msg_data), true, NULL, 0); ++ hns3vf_mbx_setup(&req, HNS3_MBX_QUEUE_RESET, 0); ++ memcpy(req.data, &queue_id, sizeof(uint16_t)); ++ ret = hns3vf_mbx_send(hw, &req, true, NULL, 0); + if (ret) + hns3_err(hw, "fail to reset tqp, queue_id = %u, ret = %d.", + queue_id, ret); +@@ -769,15 +768,14 @@ static int + hns3vf_reset_all_tqps(struct hns3_hw *hw) + { + #define HNS3VF_RESET_ALL_TQP_DONE 1U ++ struct hns3_vf_to_pf_msg req; + uint8_t reset_status; +- uint8_t msg_data[2]; + int ret; + uint16_t i; + +- memset(msg_data, 0, sizeof(msg_data)); +- ret = hns3_send_mbx_msg(hw, HNS3_MBX_QUEUE_RESET, 0, msg_data, +- sizeof(msg_data), true, &reset_status, +- sizeof(reset_status)); ++ hns3vf_mbx_setup(&req, HNS3_MBX_QUEUE_RESET, 0); ++ ret = hns3vf_mbx_send(hw, &req, true, ++ &reset_status, sizeof(reset_status)); + if (ret) { + hns3_err(hw, "fail to send rcb reset mbx, ret = %d.", ret); + return ret; +-- +2.33.0 + diff --git a/0024-net-hns3-refactor-handle-mailbox-function.patch b/0024-net-hns3-refactor-handle-mailbox-function.patch new file mode 100644 index 0000000..06d98d6 --- /dev/null +++ b/0024-net-hns3-refactor-handle-mailbox-function.patch @@ -0,0 +1,188 @@ +From f6f87e815c8bc4e287e8f37abfd969464658ea29 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Fri, 8 Dec 2023 14:55:08 +0800 +Subject: [PATCH 24/30] net/hns3: refactor handle mailbox function + +[ upstream commit 277d522ae39f6c9daa38c5ad5d3b94f632f9cf49 ] + +The mailbox messages of the PF and VF are processed in +the same function. The PF and VF call the same function +to process the messages. This code is excessive coupling +and isn't good for maintenance. Therefore, this patch +separates the interfaces that handle PF mailbox message +and handle VF mailbox message. + +Fixes: 463e748964f5 ("net/hns3: support mailbox") +Fixes: 109e4dd1bd7a ("net/hns3: get link state change through mailbox") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_ethdev.c | 2 +- + drivers/net/hns3/hns3_ethdev_vf.c | 4 +- + drivers/net/hns3/hns3_mbx.c | 69 ++++++++++++++++++++++++------- + drivers/net/hns3/hns3_mbx.h | 3 +- + 4 files changed, 58 insertions(+), 20 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index ae81368..bccd9db 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -380,7 +380,7 @@ hns3_interrupt_handler(void *param) + hns3_warn(hw, "received reset interrupt"); + hns3_schedule_reset(hns); + } else if (event_cause == HNS3_VECTOR0_EVENT_MBX) { +- hns3_dev_handle_mbx_msg(hw); ++ hns3pf_handle_mbx_msg(hw); + } else if (event_cause != HNS3_VECTOR0_EVENT_PTP) { + hns3_warn(hw, "received unknown event: vector0_int_stat:0x%x " + "ras_int_stat:0x%x cmdq_int_stat:0x%x", +diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c +index b0d0c29..f5a7a2b 100644 +--- a/drivers/net/hns3/hns3_ethdev_vf.c ++++ b/drivers/net/hns3/hns3_ethdev_vf.c +@@ -618,7 +618,7 @@ hns3vf_interrupt_handler(void *param) + hns3_schedule_reset(hns); + break; + case HNS3VF_VECTOR0_EVENT_MBX: +- hns3_dev_handle_mbx_msg(hw); ++ hns3vf_handle_mbx_msg(hw); + break; + default: + break; +@@ -670,7 +670,7 @@ hns3vf_get_push_lsc_cap(struct hns3_hw *hw) + * driver has to actively handle the HNS3_MBX_LINK_STAT_CHANGE + * mailbox from PF driver to get this capability. + */ +- hns3_dev_handle_mbx_msg(hw); ++ hns3vf_handle_mbx_msg(hw); + if (__atomic_load_n(&vf->pf_push_lsc_cap, __ATOMIC_ACQUIRE) != + HNS3_PF_PUSH_LSC_CAP_UNKNOWN) + break; +diff --git a/drivers/net/hns3/hns3_mbx.c b/drivers/net/hns3/hns3_mbx.c +index 43195ff..9cdbc16 100644 +--- a/drivers/net/hns3/hns3_mbx.c ++++ b/drivers/net/hns3/hns3_mbx.c +@@ -78,7 +78,7 @@ hns3_get_mbx_resp(struct hns3_hw *hw, uint16_t code, uint16_t subcode, + return -EIO; + } + +- hns3_dev_handle_mbx_msg(hw); ++ hns3vf_handle_mbx_msg(hw); + rte_delay_us(HNS3_WAIT_RESP_US); + + if (hw->mbx_resp.received_match_resp) +@@ -372,9 +372,57 @@ hns3_handle_mbx_msg_out_intr(struct hns3_hw *hw) + } + + void +-hns3_dev_handle_mbx_msg(struct hns3_hw *hw) ++hns3pf_handle_mbx_msg(struct hns3_hw *hw) ++{ ++ struct hns3_cmq_ring *crq = &hw->cmq.crq; ++ struct hns3_mbx_vf_to_pf_cmd *req; ++ struct hns3_cmd_desc *desc; ++ uint16_t flag; ++ ++ rte_spinlock_lock(&hw->cmq.crq.lock); ++ ++ while (!hns3_cmd_crq_empty(hw)) { ++ if (__atomic_load_n(&hw->reset.disable_cmd, __ATOMIC_RELAXED)) { ++ rte_spinlock_unlock(&hw->cmq.crq.lock); ++ return; ++ } ++ desc = &crq->desc[crq->next_to_use]; ++ req = (struct hns3_mbx_vf_to_pf_cmd *)desc->data; ++ ++ flag = rte_le_to_cpu_16(crq->desc[crq->next_to_use].flag); ++ if (unlikely(!hns3_get_bit(flag, HNS3_CMDQ_RX_OUTVLD_B))) { ++ hns3_warn(hw, ++ "dropped invalid mailbox message, code = %u", ++ req->msg.code); ++ ++ /* dropping/not processing this invalid message */ ++ crq->desc[crq->next_to_use].flag = 0; ++ hns3_mbx_ring_ptr_move_crq(crq); ++ continue; ++ } ++ ++ switch (req->msg.code) { ++ case HNS3_MBX_PUSH_LINK_STATUS: ++ hns3pf_handle_link_change_event(hw, req); ++ break; ++ default: ++ hns3_err(hw, "received unsupported(%u) mbx msg", ++ req->msg.code); ++ break; ++ } ++ crq->desc[crq->next_to_use].flag = 0; ++ hns3_mbx_ring_ptr_move_crq(crq); ++ } ++ ++ /* Write back CMDQ_RQ header pointer, IMP need this pointer */ ++ hns3_write_dev(hw, HNS3_CMDQ_RX_HEAD_REG, crq->next_to_use); ++ ++ rte_spinlock_unlock(&hw->cmq.crq.lock); ++} ++ ++void ++hns3vf_handle_mbx_msg(struct hns3_hw *hw) + { +- struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw); + struct hns3_cmq_ring *crq = &hw->cmq.crq; + struct hns3_mbx_pf_to_vf_cmd *req; + struct hns3_cmd_desc *desc; +@@ -385,7 +433,7 @@ hns3_dev_handle_mbx_msg(struct hns3_hw *hw) + rte_spinlock_lock(&hw->cmq.crq.lock); + + handle_out = (rte_eal_process_type() != RTE_PROC_PRIMARY || +- !rte_thread_is_intr()) && hns->is_vf; ++ !rte_thread_is_intr()); + if (handle_out) { + /* + * Currently, any threads in the primary and secondary processes +@@ -430,8 +478,7 @@ hns3_dev_handle_mbx_msg(struct hns3_hw *hw) + continue; + } + +- handle_out = hns->is_vf && desc->opcode == 0; +- if (handle_out) { ++ if (desc->opcode == 0) { + /* Message already processed by other thread */ + crq->desc[crq->next_to_use].flag = 0; + hns3_mbx_ring_ptr_move_crq(crq); +@@ -448,16 +495,6 @@ hns3_dev_handle_mbx_msg(struct hns3_hw *hw) + case HNS3_MBX_ASSERTING_RESET: + hns3_handle_asserting_reset(hw, req); + break; +- case HNS3_MBX_PUSH_LINK_STATUS: +- /* +- * This message is reported by the firmware and is +- * reported in 'struct hns3_mbx_vf_to_pf_cmd' format. +- * Therefore, we should cast the req variable to +- * 'struct hns3_mbx_vf_to_pf_cmd' and then process it. +- */ +- hns3pf_handle_link_change_event(hw, +- (struct hns3_mbx_vf_to_pf_cmd *)req); +- break; + case HNS3_MBX_PUSH_VLAN_INFO: + /* + * When the PVID configuration status of VF device is +diff --git a/drivers/net/hns3/hns3_mbx.h b/drivers/net/hns3/hns3_mbx.h +index 2952b96..2b6cb8f 100644 +--- a/drivers/net/hns3/hns3_mbx.h ++++ b/drivers/net/hns3/hns3_mbx.h +@@ -207,7 +207,8 @@ struct hns3_pf_rst_done_cmd { + ((crq)->next_to_use = ((crq)->next_to_use + 1) % (crq)->desc_num) + + struct hns3_hw; +-void hns3_dev_handle_mbx_msg(struct hns3_hw *hw); ++void hns3pf_handle_mbx_msg(struct hns3_hw *hw); ++void hns3vf_handle_mbx_msg(struct hns3_hw *hw); + void hns3vf_mbx_setup(struct hns3_vf_to_pf_msg *req, + uint8_t code, uint8_t subcode); + int hns3vf_mbx_send(struct hns3_hw *hw, +-- +2.33.0 + diff --git a/0025-net-hns3-fix-VF-multiple-count-on-one-reset.patch b/0025-net-hns3-fix-VF-multiple-count-on-one-reset.patch new file mode 100644 index 0000000..d656123 --- /dev/null +++ b/0025-net-hns3-fix-VF-multiple-count-on-one-reset.patch @@ -0,0 +1,114 @@ +From a9364470e9198353e6ed8e28b0b86e6b2b7ce5b3 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Fri, 8 Dec 2023 15:44:14 +0800 +Subject: [PATCH 25/30] net/hns3: fix VF multiple count on one reset + +[ upstream commit 072a07a9dcbd604b1983bf2cb266d3dd4dc89824 ] + +There are two ways for the hns3 VF driver to know reset event, namely, +interrupt task and periodic detection task. For the latter, the real +reset process will delay several microseconds to execute. Both tasks +cause the count to increase by 1. + +However, the periodic detection task also detects a reset event A +after interrupt task receive a reset event A. As a result, the reset +count will be double. + +So this patch adds the comparison of reset level for VF in case of the +multiple reset count. + +Fixes: a5475d61fa34 ("net/hns3: support VF") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_ethdev_vf.c | 44 ++++++++++++++++++++----------- + 1 file changed, 29 insertions(+), 15 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c +index f5a7a2b..83d3d66 100644 +--- a/drivers/net/hns3/hns3_ethdev_vf.c ++++ b/drivers/net/hns3/hns3_ethdev_vf.c +@@ -569,13 +569,8 @@ hns3vf_check_event_cause(struct hns3_adapter *hns, uint32_t *clearval) + val = hns3_read_dev(hw, HNS3_VF_RST_ING); + hns3_write_dev(hw, HNS3_VF_RST_ING, val | HNS3_VF_RST_ING_BIT); + val = cmdq_stat_reg & ~BIT(HNS3_VECTOR0_RST_INT_B); +- if (clearval) { +- hw->reset.stats.global_cnt++; +- hns3_warn(hw, "Global reset detected, clear reset status"); +- } else { +- hns3_schedule_delayed_reset(hns); +- hns3_warn(hw, "Global reset detected, don't clear reset status"); +- } ++ hw->reset.stats.global_cnt++; ++ hns3_warn(hw, "Global reset detected, clear reset status"); + + ret = HNS3VF_VECTOR0_EVENT_RST; + goto out; +@@ -590,9 +585,9 @@ hns3vf_check_event_cause(struct hns3_adapter *hns, uint32_t *clearval) + + val = 0; + ret = HNS3VF_VECTOR0_EVENT_OTHER; ++ + out: +- if (clearval) +- *clearval = val; ++ *clearval = val; + return ret; + } + +@@ -1731,11 +1726,25 @@ is_vf_reset_done(struct hns3_hw *hw) + return true; + } + ++static enum hns3_reset_level ++hns3vf_detect_reset_event(struct hns3_hw *hw) ++{ ++ enum hns3_reset_level reset = HNS3_NONE_RESET; ++ uint32_t cmdq_stat_reg; ++ ++ cmdq_stat_reg = hns3_read_dev(hw, HNS3_VECTOR0_CMDQ_STAT_REG); ++ if (BIT(HNS3_VECTOR0_RST_INT_B) & cmdq_stat_reg) ++ reset = HNS3_VF_RESET; ++ ++ return reset; ++} ++ + bool + hns3vf_is_reset_pending(struct hns3_adapter *hns) + { ++ enum hns3_reset_level last_req; + struct hns3_hw *hw = &hns->hw; +- enum hns3_reset_level reset; ++ enum hns3_reset_level new_req; + + /* + * According to the protocol of PCIe, FLR to a PF device resets the PF +@@ -1758,13 +1767,18 @@ hns3vf_is_reset_pending(struct hns3_adapter *hns) + if (rte_eal_process_type() != RTE_PROC_PRIMARY) + return false; + +- hns3vf_check_event_cause(hns, NULL); +- reset = hns3vf_get_reset_level(hw, &hw->reset.pending); +- if (hw->reset.level != HNS3_NONE_RESET && reset != HNS3_NONE_RESET && +- hw->reset.level < reset) { +- hns3_warn(hw, "High level reset %d is pending", reset); ++ new_req = hns3vf_detect_reset_event(hw); ++ if (new_req == HNS3_NONE_RESET) ++ return false; ++ ++ last_req = hns3vf_get_reset_level(hw, &hw->reset.pending); ++ if (last_req == HNS3_NONE_RESET || last_req < new_req) { ++ __atomic_store_n(&hw->reset.disable_cmd, 1, __ATOMIC_RELAXED); ++ hns3_schedule_delayed_reset(hns); ++ hns3_warn(hw, "High level reset detected, delay do reset"); + return true; + } ++ + return false; + } + +-- +2.33.0 + diff --git a/0026-net-hns3-fix-disable-command-with-firmware.patch b/0026-net-hns3-fix-disable-command-with-firmware.patch new file mode 100644 index 0000000..059daa1 --- /dev/null +++ b/0026-net-hns3-fix-disable-command-with-firmware.patch @@ -0,0 +1,48 @@ +From b58308dd555c3e8491c8fd7839c1af030b6ad6e1 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Fri, 8 Dec 2023 15:44:15 +0800 +Subject: [PATCH 26/30] net/hns3: fix disable command with firmware + +[ upstream commit 66048270a49088f79c2a020bd28ee0a93c4a73ed ] + +Disable command only when need to delay handle reset. +This patch fixes it. + +Fixes: 5be38fc6c0fc ("net/hns3: fix multiple reset detected log") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_ethdev.c | 8 +++----- + 1 file changed, 3 insertions(+), 5 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index bccd9db..d626bdd 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -5552,18 +5552,16 @@ hns3_detect_reset_event(struct hns3_hw *hw) + + last_req = hns3_get_reset_level(hns, &hw->reset.pending); + vector0_intr_state = hns3_read_dev(hw, HNS3_VECTOR0_OTHER_INT_STS_REG); +- if (BIT(HNS3_VECTOR0_IMPRESET_INT_B) & vector0_intr_state) { +- __atomic_store_n(&hw->reset.disable_cmd, 1, __ATOMIC_RELAXED); ++ if (BIT(HNS3_VECTOR0_IMPRESET_INT_B) & vector0_intr_state) + new_req = HNS3_IMP_RESET; +- } else if (BIT(HNS3_VECTOR0_GLOBALRESET_INT_B) & vector0_intr_state) { +- __atomic_store_n(&hw->reset.disable_cmd, 1, __ATOMIC_RELAXED); ++ else if (BIT(HNS3_VECTOR0_GLOBALRESET_INT_B) & vector0_intr_state) + new_req = HNS3_GLOBAL_RESET; +- } + + if (new_req == HNS3_NONE_RESET) + return HNS3_NONE_RESET; + + if (last_req == HNS3_NONE_RESET || last_req < new_req) { ++ __atomic_store_n(&hw->reset.disable_cmd, 1, __ATOMIC_RELAXED); + hns3_schedule_delayed_reset(hns); + hns3_warn(hw, "High level reset detected, delay do reset"); + } +-- +2.33.0 + diff --git a/0027-net-hns3-fix-reset-level-comparison.patch b/0027-net-hns3-fix-reset-level-comparison.patch new file mode 100644 index 0000000..acd5908 --- /dev/null +++ b/0027-net-hns3-fix-reset-level-comparison.patch @@ -0,0 +1,78 @@ +From 5fe966c13b5c37e1dbaed7afa7d0125de26068e4 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Fri, 8 Dec 2023 15:44:16 +0800 +Subject: [PATCH 27/30] net/hns3: fix reset level comparison + +[ upstream commit 1ceb5ad2dfdcc3e6658119d25253bced5be3cc32 ] + +Currently, there are two problems in hns3vf_is_reset_pending(): +1. The new detect reset level is not HNS3_NONE_RESET, but the + last reset level is HNS3_NONE_RESET, this function returns false. +2. Comparison between last_req and new_req is opposite. + +In addition, the reset level comparison in hns3_detect_reset_event() +is similar to the hns3vf_is_reset_pending(). So this patch fixes +above the problems and merges the logic of reset level comparison. + +Fixes: 5be38fc6c0fc ("net/hns3: fix multiple reset detected log") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_ethdev.c | 22 +++++++--------------- + 1 file changed, 7 insertions(+), 15 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index d626bdd..eafcf2c 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -5545,27 +5545,15 @@ is_pf_reset_done(struct hns3_hw *hw) + static enum hns3_reset_level + hns3_detect_reset_event(struct hns3_hw *hw) + { +- struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw); + enum hns3_reset_level new_req = HNS3_NONE_RESET; +- enum hns3_reset_level last_req; + uint32_t vector0_intr_state; + +- last_req = hns3_get_reset_level(hns, &hw->reset.pending); + vector0_intr_state = hns3_read_dev(hw, HNS3_VECTOR0_OTHER_INT_STS_REG); + if (BIT(HNS3_VECTOR0_IMPRESET_INT_B) & vector0_intr_state) + new_req = HNS3_IMP_RESET; + else if (BIT(HNS3_VECTOR0_GLOBALRESET_INT_B) & vector0_intr_state) + new_req = HNS3_GLOBAL_RESET; + +- if (new_req == HNS3_NONE_RESET) +- return HNS3_NONE_RESET; +- +- if (last_req == HNS3_NONE_RESET || last_req < new_req) { +- __atomic_store_n(&hw->reset.disable_cmd, 1, __ATOMIC_RELAXED); +- hns3_schedule_delayed_reset(hns); +- hns3_warn(hw, "High level reset detected, delay do reset"); +- } +- + return new_req; + } + +@@ -5584,10 +5572,14 @@ hns3_is_reset_pending(struct hns3_adapter *hns) + return false; + + new_req = hns3_detect_reset_event(hw); ++ if (new_req == HNS3_NONE_RESET) ++ return false; ++ + last_req = hns3_get_reset_level(hns, &hw->reset.pending); +- if (last_req != HNS3_NONE_RESET && new_req != HNS3_NONE_RESET && +- new_req < last_req) { +- hns3_warn(hw, "High level reset %d is pending", last_req); ++ if (last_req == HNS3_NONE_RESET || last_req < new_req) { ++ __atomic_store_n(&hw->reset.disable_cmd, 1, __ATOMIC_RELAXED); ++ hns3_schedule_delayed_reset(hns); ++ hns3_warn(hw, "High level reset detected, delay do reset"); + return true; + } + last_req = hns3_get_reset_level(hns, &hw->reset.request); +-- +2.33.0 + diff --git a/0028-net-hns3-remove-QinQ-insert-support-for-VF.patch b/0028-net-hns3-remove-QinQ-insert-support-for-VF.patch new file mode 100644 index 0000000..065326f --- /dev/null +++ b/0028-net-hns3-remove-QinQ-insert-support-for-VF.patch @@ -0,0 +1,48 @@ +From 28db014a776d5f3ca2d2e162c1cbab3ab874379c Mon Sep 17 00:00:00 2001 +From: Chengwen Feng +Date: Thu, 28 Dec 2023 20:14:28 +0800 +Subject: [PATCH 28/30] net/hns3: remove QinQ insert support for VF + +[ upstream commit f6e79b8d3968150736499bc225762b62fbf1b768 ] + +In the HIP08 platform, the PF driver will notify VF driver to update +the PVID state [1], and VF will declare support QinQ insert when PVID +is disabled. + +In the later platform (e.g. HIP09), the hardware has been improved, +so the PF driver will NOT notify VF driver to update the PVID state. + +However, the later platform still have constraint: PVID and QinQ insert +cannot be enabled at the same time, otherwise, the hardware discards +packets and reports an error interrupt. + +Plus, as far as we known, VF driver's users don't use the QinQ insert. + +Therefore, we declare that the VF driver don't support QinQ insert. + +[1] commit b4e4d7ac9f09 ("net/hns3: support setting VF PVID by PF driver") + +Cc: stable@dpdk.org + +Signed-off-by: Chengwen Feng +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_common.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/net/hns3/hns3_common.c b/drivers/net/hns3/hns3_common.c +index 8f224aa..28c26b0 100644 +--- a/drivers/net/hns3/hns3_common.c ++++ b/drivers/net/hns3/hns3_common.c +@@ -85,7 +85,7 @@ hns3_dev_infos_get(struct rte_eth_dev *eth_dev, struct rte_eth_dev_info *info) + RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE | + RTE_ETH_TX_OFFLOAD_VLAN_INSERT); + +- if (!hw->port_base_vlan_cfg.state) ++ if (!hns->is_vf && !hw->port_base_vlan_cfg.state) + info->tx_offload_capa |= RTE_ETH_TX_OFFLOAD_QINQ_INSERT; + + if (hns3_dev_get_support(hw, OUTER_UDP_CKSUM)) +-- +2.33.0 + diff --git a/0029-net-hns3-support-power-monitor.patch b/0029-net-hns3-support-power-monitor.patch new file mode 100644 index 0000000..cb7e973 --- /dev/null +++ b/0029-net-hns3-support-power-monitor.patch @@ -0,0 +1,90 @@ +From ec982e4420625a346de01d46343a63f044dfb0e6 Mon Sep 17 00:00:00 2001 +From: Chengwen Feng +Date: Mon, 5 Feb 2024 16:35:21 +0800 +Subject: [PATCH 29/30] net/hns3: support power monitor + +[ upstream commit 9e1e7dded323ce424aebf992f6ddfa9656655631 ] + +This commit supports power monitor on the Rx queue descriptor of the +next poll. + +Note: Although rte_power_monitor() on the ARM platform does not support +callback, this commit still implements the callback so that it does not +need to be adjusted after the ARM platform supports callback. + +Signed-off-by: Chengwen Feng +Signed-off-by: Jie Hai +--- + drivers/net/hns3/hns3_ethdev.c | 1 + + drivers/net/hns3/hns3_ethdev_vf.c | 1 + + drivers/net/hns3/hns3_rxtx.c | 21 +++++++++++++++++++++ + drivers/net/hns3/hns3_rxtx.h | 1 + + 4 files changed, 24 insertions(+) + +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index eafcf2c..b10d121 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -6501,6 +6501,7 @@ static const struct eth_dev_ops hns3_eth_dev_ops = { + .eth_dev_priv_dump = hns3_eth_dev_priv_dump, + .eth_rx_descriptor_dump = hns3_rx_descriptor_dump, + .eth_tx_descriptor_dump = hns3_tx_descriptor_dump, ++ .get_monitor_addr = hns3_get_monitor_addr, + }; + + static const struct hns3_reset_ops hns3_reset_ops = { +diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c +index 83d3d66..4eeb46a 100644 +--- a/drivers/net/hns3/hns3_ethdev_vf.c ++++ b/drivers/net/hns3/hns3_ethdev_vf.c +@@ -2209,6 +2209,7 @@ static const struct eth_dev_ops hns3vf_eth_dev_ops = { + .eth_dev_priv_dump = hns3_eth_dev_priv_dump, + .eth_rx_descriptor_dump = hns3_rx_descriptor_dump, + .eth_tx_descriptor_dump = hns3_tx_descriptor_dump, ++ .get_monitor_addr = hns3_get_monitor_addr, + }; + + static const struct hns3_reset_ops hns3vf_reset_ops = { +diff --git a/drivers/net/hns3/hns3_rxtx.c b/drivers/net/hns3/hns3_rxtx.c +index 9087bcf..04ae8dc 100644 +--- a/drivers/net/hns3/hns3_rxtx.c ++++ b/drivers/net/hns3/hns3_rxtx.c +@@ -4883,3 +4883,24 @@ hns3_start_rxtx_datapath(struct rte_eth_dev *dev) + + hns3_mp_req_start_rxtx(dev); + } ++ ++static int ++hns3_monitor_callback(const uint64_t value, ++ const uint64_t arg[RTE_POWER_MONITOR_OPAQUE_SZ] __rte_unused) ++{ ++ const uint64_t vld = rte_le_to_cpu_32(BIT(HNS3_RXD_VLD_B)); ++ return (value & vld) == vld ? -1 : 0; ++} ++ ++int ++hns3_get_monitor_addr(void *rx_queue, struct rte_power_monitor_cond *pmc) ++{ ++ struct hns3_rx_queue *rxq = rx_queue; ++ struct hns3_desc *rxdp = &rxq->rx_ring[rxq->next_to_use]; ++ ++ pmc->addr = &rxdp->rx.bd_base_info; ++ pmc->fn = hns3_monitor_callback; ++ pmc->size = sizeof(uint32_t); ++ ++ return 0; ++} +diff --git a/drivers/net/hns3/hns3_rxtx.h b/drivers/net/hns3/hns3_rxtx.h +index b6a6513..18dcc75 100644 +--- a/drivers/net/hns3/hns3_rxtx.h ++++ b/drivers/net/hns3/hns3_rxtx.h +@@ -814,5 +814,6 @@ void hns3_stop_tx_datapath(struct rte_eth_dev *dev); + void hns3_start_tx_datapath(struct rte_eth_dev *dev); + void hns3_stop_rxtx_datapath(struct rte_eth_dev *dev); + void hns3_start_rxtx_datapath(struct rte_eth_dev *dev); ++int hns3_get_monitor_addr(void *rx_queue, struct rte_power_monitor_cond *pmc); + + #endif /* HNS3_RXTX_H */ +-- +2.33.0 + diff --git a/0030-app-testpmd-fix-crash-in-multi-process-forwarding.patch b/0030-app-testpmd-fix-crash-in-multi-process-forwarding.patch new file mode 100644 index 0000000..e2d5070 --- /dev/null +++ b/0030-app-testpmd-fix-crash-in-multi-process-forwarding.patch @@ -0,0 +1,84 @@ +From 432000eaee7f2e5188e9517c408ab4bd348a3553 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Tue, 30 Jan 2024 09:32:49 +0800 +Subject: [PATCH 30/30] app/testpmd: fix crash in multi-process forwarding + +[ upstream commit b3a33138f317d1c651cd86f423cc703176eb7b07 ] + +On multi-process scenario, each process creates flows based on the +number of queues. When nbcore is greater than 1, multiple cores may +use the same queue to forward packet, like: +dpdk-testpmd -a BDF --proc-type=auto -- -i --rxq=4 --txq=4 +--nb-cores=2 --num-procs=2 --proc-id=0 +testpmd> start +mac packet forwarding - ports=1 - cores=2 - streams=4 - NUMA support +enabled, MP allocation mode: native +Logical Core 2 (socket 0) forwards packets on 2 streams: + RX P=0/Q=0 (socket 0) -> TX P=0/Q=0 (socket 0) peer=02:00:00:00:00:00 + RX P=0/Q=1 (socket 0) -> TX P=0/Q=1 (socket 0) peer=02:00:00:00:00:00 +Logical Core 3 (socket 0) forwards packets on 2 streams: + RX P=0/Q=0 (socket 0) -> TX P=0/Q=0 (socket 0) peer=02:00:00:00:00:00 + RX P=0/Q=1 (socket 0) -> TX P=0/Q=1 (socket 0) peer=02:00:00:00:00:00 + +After this commit, the result will be: +dpdk-testpmd -a BDF --proc-type=auto -- -i --rxq=4 --txq=4 +--nb-cores=2 --num-procs=2 --proc-id=0 +testpmd> start +io packet forwarding - ports=1 - cores=2 - streams=2 - NUMA support +enabled, MP allocation mode: native +Logical Core 2 (socket 0) forwards packets on 1 streams: + RX P=0/Q=0 (socket 2) -> TX P=0/Q=0 (socket 2) peer=02:00:00:00:00:00 +Logical Core 3 (socket 0) forwards packets on 1 streams: + RX P=0/Q=1 (socket 2) -> TX P=0/Q=1 (socket 2) peer=02:00:00:00:00:00 + +Fixes: a550baf24af9 ("app/testpmd: support multi-process") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +Acked-by: Chengwen Feng +Acked-by: Ferruh Yigit +--- + app/test-pmd/config.c | 6 +----- + 1 file changed, 1 insertion(+), 5 deletions(-) + +diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c +index cad7537..2c4dedd 100644 +--- a/app/test-pmd/config.c ++++ b/app/test-pmd/config.c +@@ -4794,7 +4794,6 @@ rss_fwd_config_setup(void) + queueid_t nb_q; + streamid_t sm_id; + int start; +- int end; + + nb_q = nb_rxq; + if (nb_q > nb_txq) +@@ -4802,7 +4801,7 @@ rss_fwd_config_setup(void) + cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores; + cur_fwd_config.nb_fwd_ports = nb_fwd_ports; + cur_fwd_config.nb_fwd_streams = +- (streamid_t) (nb_q * cur_fwd_config.nb_fwd_ports); ++ (streamid_t) (nb_q / num_procs * cur_fwd_config.nb_fwd_ports); + + if (cur_fwd_config.nb_fwd_streams < cur_fwd_config.nb_fwd_lcores) + cur_fwd_config.nb_fwd_lcores = +@@ -4824,7 +4823,6 @@ rss_fwd_config_setup(void) + * the 2~3 queue for secondary process. + */ + start = proc_id * nb_q / num_procs; +- end = start + nb_q / num_procs; + rxp = 0; + rxq = start; + for (sm_id = 0; sm_id < cur_fwd_config.nb_fwd_streams; sm_id++) { +@@ -4843,8 +4841,6 @@ rss_fwd_config_setup(void) + continue; + rxp = 0; + rxq++; +- if (rxq >= end) +- rxq = start; + } + } + +-- +2.33.0 + diff --git a/dpdk.spec b/dpdk.spec index 2eecb4e..c9a5c55 100644 --- a/dpdk.spec +++ b/dpdk.spec @@ -10,12 +10,13 @@ Name: dpdk Version: 23.11 -Release: 5 +Release: 6 URL: http://dpdk.org Source: https://fast.dpdk.org/rel/dpdk-%{version}.tar.xz -# upstream patch number start from 6000 -# self developed patch number start from 9000 +# upstream patch number is 6xxx +# self developed patch number is 9xxx +# And the name number of two types patch are numbered together Patch9001: 0001-add-igb_uio.patch Patch9002: 0002-dpdk-add-secure-compile-option-and-fPIC-option.patch Patch9003: 0003-dpdk-bugfix-the-deadlock-in-rte_eal_init.patch @@ -29,6 +30,25 @@ Patch9010: 0010-example-l3fwd-masking-wrong-warning-array-subscript-.patch Patch9011: 0011-dpdk-add-support-for-gazellle.patch Patch9012: 0012-lstack-need-skip-rte_bus_probe-when-use-ltran-mode.patch +Patch6013: 0013-maintainers-update-for-DMA-device-performance-tool.patch +Patch6014: 0014-dmadev-add-telemetry-capability-for-m2d-auto-free.patch +Patch6015: 0015-dmadev-add-tracepoints-in-data-path-API.patch +Patch6016: 0016-eal-introduce-more-macros-for-bit-definition.patch +Patch6017: 0017-ring-add-telemetry-command-to-list-rings.patch +Patch6018: 0018-ring-add-telemetry-command-for-ring-info.patch +Patch6019: 0019-ethdev-get-RSS-hash-algorithm-by-name.patch +Patch6020: 0020-app-testpmd-set-RSS-hash-algorithm.patch +Patch6021: 0021-net-hns3-refactor-VF-mailbox-message-struct.patch +Patch6022: 0022-net-hns3-refactor-PF-mailbox-message-struct.patch +Patch6023: 0023-net-hns3-refactor-send-mailbox-function.patch +Patch6024: 0024-net-hns3-refactor-handle-mailbox-function.patch +Patch6025: 0025-net-hns3-fix-VF-multiple-count-on-one-reset.patch +Patch6026: 0026-net-hns3-fix-disable-command-with-firmware.patch +Patch6027: 0027-net-hns3-fix-reset-level-comparison.patch +Patch6028: 0028-net-hns3-remove-QinQ-insert-support-for-VF.patch +Patch6029: 0029-net-hns3-support-power-monitor.patch +Patch6030: 0030-app-testpmd-fix-crash-in-multi-process-forwarding.patch + BuildRequires: meson BuildRequires: python3-pyelftools BuildRequires: diffutils @@ -195,6 +215,28 @@ strip -g $RPM_BUILD_ROOT/lib/modules/%{kern_devel_ver}/extra/dpdk/igb_uio.ko %endif %changelog +* Tue Mar 5 2024 huangdengdui - 23.11-6 + Sync some patches for hns3 about refactor mailbox, add new API for RSS, + support power monitor and some bugfix, modifies are as follow: + - app/testpmd: fix crash in multi -process forwarding + - net/hns3: support power monitor + - net/hns3: remove QinQ insert support for VF + - net/hns3: fix reset level comparison + - net/hns3: fix disable command with firmware + - net/hns3: fix VF multiple count on one reset + - net/hns3: refactor handle mailbox function + - net/hns3: refactor send mailbox function + - net/hns3: refactor PF mailbox message struct + - net/hns3: refactor VF mailbox message struct + - app/testpmd: set RSS hash algorithm + - ethdev: get RSS hash algorithm by name + - ring: add telemetry command for ring info + - ring: add telemetry command to list rings + - eal: introduce more macros for bit definition + - dmadev: add tracepoints in data path API + - dmadev: add telemetry capability for m2d auto free + - maintainers: update for DMA device performance tool + * Thu Jan 25 2024 shafeipaozi - 23.11-5 Add support to riscv64