Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C), 2025, Wuxi Stars Micro System Technologies Co., Ltd.
3 : : */
4 : :
5 : : #include "sxe2_rss.h"
6 : : #include "sxe2_common_log.h"
7 : : #include "sxe2_ethdev.h"
8 : : #include "sxe2_cmd_chnl.h"
9 : :
10 : 0 : void sxe2_sw_rss_ctx_hw_cap_set(struct sxe2_adapter *adapter,
11 : : struct sxe2_drv_rss_hash_caps *rss_caps)
12 : : {
13 : 0 : adapter->rss_ctxt.rss_key_size = rss_caps->hash_key_size;
14 : 0 : adapter->rss_ctxt.rss_lut_size = rss_caps->lut_key_size;
15 : 0 : }
16 : :
17 : 0 : int32_t sxe2_rss_hash_key_init(struct rte_eth_dev *dev)
18 : : {
19 : 0 : struct rte_eth_rss_conf *rss_conf = &dev->data->dev_conf.rx_adv_conf.rss_conf;
20 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
21 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
22 : 0 : int32_t ret = 0;
23 : 0 : uint16_t i = 0;
24 : :
25 [ # # ]: 0 : if (rss_ctxt->rss_key == NULL) {
26 : 0 : rss_ctxt->rss_key = (uint8_t *)rte_zmalloc("rss_key", rss_ctxt->rss_key_size, 0);
27 [ # # ]: 0 : if (rss_ctxt->rss_key == NULL) {
28 : 0 : PMD_LOG_ERR(INIT, "Failed to allocate rss key");
29 : 0 : ret = -ENOMEM;
30 : 0 : goto l_end;
31 : : }
32 : : }
33 : :
34 [ # # ]: 0 : if (!rss_conf->rss_key) {
35 [ # # ]: 0 : for (i = 0; i < rss_ctxt->rss_key_size; i++)
36 : 0 : rss_ctxt->rss_key[i] = (uint8_t)rte_rand();
37 : : } else {
38 [ # # ]: 0 : rte_memcpy(rss_ctxt->rss_key, rss_conf->rss_key,
39 [ # # ]: 0 : RTE_MIN(rss_conf->rss_key_len, rss_ctxt->rss_key_size));
40 : : }
41 : :
42 : 0 : ret = sxe2_drv_rss_key_set(adapter, rss_ctxt->rss_key,
43 : 0 : rss_ctxt->rss_key_size);
44 [ # # ]: 0 : if (ret) {
45 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to set rss key, ret:%d", ret);
46 : 0 : rte_free(rss_ctxt->rss_key);
47 : 0 : rss_ctxt->rss_key = NULL;
48 : 0 : goto l_end;
49 : : }
50 : :
51 : 0 : l_end:
52 : 0 : return ret;
53 : : }
54 : :
55 : 0 : void sxe2_rss_hash_key_uninit(struct rte_eth_dev *dev)
56 : : {
57 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
58 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
59 : :
60 [ # # ]: 0 : if (rss_ctxt->rss_key) {
61 : 0 : rte_free(rss_ctxt->rss_key);
62 : 0 : rss_ctxt->rss_key = NULL;
63 : : }
64 : 0 : }
65 : :
66 : 0 : int32_t sxe2_rss_lut_init(struct rte_eth_dev *dev)
67 : : {
68 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
69 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
70 : 0 : int32_t ret = 0;
71 : 0 : uint16_t i;
72 : :
73 [ # # ]: 0 : if (rss_ctxt->rss_lut == NULL) {
74 : 0 : rss_ctxt->rss_lut = (uint8_t *)rte_zmalloc("rss_lut", rss_ctxt->rss_lut_size, 0);
75 [ # # ]: 0 : if (rss_ctxt->rss_lut == NULL) {
76 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to allocate rss lut");
77 : 0 : ret = -ENOMEM;
78 : 0 : goto l_end;
79 : : }
80 : : }
81 : :
82 [ # # ]: 0 : for (i = 0; i < rss_ctxt->rss_lut_size; i++)
83 : 0 : rss_ctxt->rss_lut[i] = (uint8_t)(i % dev->data->nb_rx_queues);
84 : :
85 : 0 : ret = sxe2_drv_rss_lut_set(adapter, rss_ctxt->rss_lut, rss_ctxt->rss_lut_size);
86 [ # # ]: 0 : if (ret) {
87 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to set rss lut, ret:%d", ret);
88 : 0 : rte_free(rss_ctxt->rss_lut);
89 : 0 : rss_ctxt->rss_lut = NULL;
90 : 0 : goto l_end;
91 : : }
92 : :
93 : 0 : l_end:
94 : 0 : return ret;
95 : : }
96 : :
97 : 0 : void sxe2_rss_lut_uninit(struct rte_eth_dev *dev)
98 : : {
99 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
100 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
101 : :
102 [ # # ]: 0 : if (rss_ctxt->rss_lut) {
103 : 0 : rte_free(rss_ctxt->rss_lut);
104 : 0 : rss_ctxt->rss_lut = NULL;
105 : : }
106 : 0 : }
107 : :
108 : : static struct sxe2_rss_hf_config sxe2_rss_default_hf_config[] = {
109 : : {
110 : : .rss_hf = RTE_ETH_RSS_L2_PAYLOAD,
111 : : .hdrs = {SXE2_FLOW_HDR_ETH,
112 : : SXE2_FLOW_END},
113 : : .flds = {SXE2_FLOW_FLD_ID_ETH_TYPE,
114 : : SXE2_FLOW_END},
115 : : },
116 : : {
117 : : .rss_hf = RTE_ETH_RSS_IPV4,
118 : : .hdrs = {SXE2_FLOW_HDR_IPV4,
119 : : SXE2_FLOW_END},
120 : : .flds = {SXE2_FLOW_FLD_ID_IPV4_SA,
121 : : SXE2_FLOW_FLD_ID_IPV4_DA,
122 : : SXE2_FLOW_END},
123 : : },
124 : : {
125 : : .rss_hf = RTE_ETH_RSS_IPV6,
126 : : .hdrs = {SXE2_FLOW_HDR_IPV6,
127 : : SXE2_FLOW_END},
128 : : .flds = {SXE2_FLOW_FLD_ID_IPV6_SA,
129 : : SXE2_FLOW_FLD_ID_IPV6_DA,
130 : : SXE2_FLOW_END},
131 : : },
132 : : {
133 : : .rss_hf = RTE_ETH_RSS_FRAG_IPV4,
134 : : .hdrs = {SXE2_FLOW_HDR_IPV4,
135 : : SXE2_FLOW_HDR_IPV_FRAG,
136 : : SXE2_FLOW_END},
137 : : .flds = {SXE2_FLOW_FLD_ID_IPV4_SA,
138 : : SXE2_FLOW_FLD_ID_IPV4_DA,
139 : : SXE2_FLOW_END},
140 : : },
141 : : {
142 : : .rss_hf = RTE_ETH_RSS_FRAG_IPV6,
143 : : .hdrs = {SXE2_FLOW_HDR_IPV6,
144 : : SXE2_FLOW_HDR_IPV_FRAG,
145 : : SXE2_FLOW_END},
146 : : .flds = {SXE2_FLOW_FLD_ID_IPV6_SA,
147 : : SXE2_FLOW_FLD_ID_IPV6_DA,
148 : : SXE2_FLOW_END},
149 : : },
150 : : {
151 : : .rss_hf = RTE_ETH_RSS_NONFRAG_IPV4_OTHER,
152 : : .hdrs = {SXE2_FLOW_HDR_IPV4,
153 : : SXE2_FLOW_HDR_IPV_OTHER,
154 : : SXE2_FLOW_END},
155 : : .flds = {SXE2_FLOW_FLD_ID_IPV4_SA,
156 : : SXE2_FLOW_FLD_ID_IPV4_DA,
157 : : SXE2_FLOW_END},
158 : : },
159 : : {
160 : : .rss_hf = RTE_ETH_RSS_NONFRAG_IPV6_OTHER,
161 : : .hdrs = {SXE2_FLOW_HDR_IPV6,
162 : : SXE2_FLOW_HDR_IPV_OTHER,
163 : : SXE2_FLOW_END},
164 : : .flds = {SXE2_FLOW_FLD_ID_IPV6_SA,
165 : : SXE2_FLOW_FLD_ID_IPV6_DA,
166 : : SXE2_FLOW_END},
167 : : },
168 : : {
169 : : .rss_hf = RTE_ETH_RSS_NONFRAG_IPV4_UDP,
170 : : .hdrs = {SXE2_FLOW_HDR_IPV4,
171 : : SXE2_FLOW_HDR_UDP,
172 : : SXE2_FLOW_END},
173 : : .flds = {SXE2_FLOW_FLD_ID_IPV4_SA,
174 : : SXE2_FLOW_FLD_ID_IPV4_DA,
175 : : SXE2_FLOW_FLD_ID_UDP_SRC_PORT,
176 : : SXE2_FLOW_FLD_ID_UDP_DST_PORT,
177 : : SXE2_FLOW_END},
178 : : },
179 : : {
180 : : .rss_hf = RTE_ETH_RSS_NONFRAG_IPV6_UDP,
181 : : .hdrs = {SXE2_FLOW_HDR_IPV6,
182 : : SXE2_FLOW_HDR_UDP,
183 : : SXE2_FLOW_END},
184 : : .flds = {SXE2_FLOW_FLD_ID_IPV6_SA,
185 : : SXE2_FLOW_FLD_ID_IPV6_DA,
186 : : SXE2_FLOW_FLD_ID_UDP_SRC_PORT,
187 : : SXE2_FLOW_FLD_ID_UDP_DST_PORT,
188 : : SXE2_FLOW_END},
189 : : },
190 : : {
191 : : .rss_hf = RTE_ETH_RSS_NONFRAG_IPV4_TCP,
192 : : .hdrs = {SXE2_FLOW_HDR_IPV4,
193 : : SXE2_FLOW_HDR_TCP,
194 : : SXE2_FLOW_END},
195 : : .flds = {SXE2_FLOW_FLD_ID_IPV4_SA,
196 : : SXE2_FLOW_FLD_ID_IPV4_DA,
197 : : SXE2_FLOW_FLD_ID_TCP_SRC_PORT,
198 : : SXE2_FLOW_FLD_ID_TCP_DST_PORT,
199 : : SXE2_FLOW_END},
200 : : },
201 : : {
202 : : .rss_hf = RTE_ETH_RSS_NONFRAG_IPV6_TCP,
203 : : .hdrs = {SXE2_FLOW_HDR_IPV6,
204 : : SXE2_FLOW_HDR_TCP,
205 : : SXE2_FLOW_END},
206 : : .flds = {SXE2_FLOW_FLD_ID_IPV6_SA,
207 : : SXE2_FLOW_FLD_ID_IPV6_DA,
208 : : SXE2_FLOW_FLD_ID_TCP_SRC_PORT,
209 : : SXE2_FLOW_FLD_ID_TCP_DST_PORT,
210 : : SXE2_FLOW_END},
211 : : },
212 : : {
213 : : .rss_hf = RTE_ETH_RSS_NONFRAG_IPV4_SCTP,
214 : : .hdrs = {SXE2_FLOW_HDR_IPV4,
215 : : SXE2_FLOW_HDR_SCTP,
216 : : SXE2_FLOW_END},
217 : : .flds = {SXE2_FLOW_FLD_ID_IPV4_SA,
218 : : SXE2_FLOW_FLD_ID_IPV4_DA,
219 : : SXE2_FLOW_FLD_ID_SCTP_SRC_PORT,
220 : : SXE2_FLOW_FLD_ID_SCTP_DST_PORT,
221 : : SXE2_FLOW_END},
222 : : },
223 : : {
224 : : .rss_hf = RTE_ETH_RSS_NONFRAG_IPV6_SCTP,
225 : : .hdrs = {SXE2_FLOW_HDR_IPV6,
226 : : SXE2_FLOW_HDR_SCTP,
227 : : SXE2_FLOW_END},
228 : : .flds = {SXE2_FLOW_FLD_ID_IPV6_SA,
229 : : SXE2_FLOW_FLD_ID_IPV6_DA,
230 : : SXE2_FLOW_FLD_ID_SCTP_SRC_PORT,
231 : : SXE2_FLOW_FLD_ID_SCTP_DST_PORT,
232 : : SXE2_FLOW_END},
233 : : },
234 : : };
235 : :
236 : 0 : int32_t sxe2_rss_hf_type_set(struct rte_eth_dev *dev, uint64_t rss_hf)
237 : : {
238 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
239 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
240 : 0 : int32_t ret = 0;
241 : 0 : uint32_t i;
242 : 0 : uint8_t symm = 0;
243 : :
244 [ # # # # ]: 0 : if (0 == (rss_hf & SXE2_RSS_HF_SUPPORT_ALL) && rss_hf != 0) {
245 : 0 : PMD_DEV_LOG_ERR(adapter, DRV,
246 : : "Failed to set unsupported rss_hf:0x%016" PRIx64,
247 : : rss_hf);
248 : 0 : ret = -EINVAL;
249 : 0 : goto l_end;
250 : : }
251 : :
252 [ # # ]: 0 : for (i = 0; i < RTE_DIM(sxe2_rss_default_hf_config); i++) {
253 [ # # ]: 0 : if (rss_ctxt->rss_hf & sxe2_rss_default_hf_config[i].rss_hf) {
254 : 0 : sxe2_rss_default_hf_config[i].symm = rss_ctxt->symm;
255 : 0 : ret = sxe2_drv_rss_hf_del(adapter, &sxe2_rss_default_hf_config[i]);
256 [ # # ]: 0 : if (ret) {
257 : 0 : PMD_DEV_LOG_ERR(adapter, INIT,
258 : : "Failed to del rss hf cfg[%d], ret:%d", i, ret);
259 : 0 : goto l_end;
260 : : }
261 : : }
262 : : }
263 : :
264 [ # # ]: 0 : if (rss_ctxt->hash_func == RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ)
265 : 0 : symm = 1;
266 : :
267 [ # # ]: 0 : for (i = 0; i < RTE_DIM(sxe2_rss_default_hf_config); i++) {
268 [ # # ]: 0 : if (rss_hf & sxe2_rss_default_hf_config[i].rss_hf) {
269 : 0 : sxe2_rss_default_hf_config[i].symm = symm;
270 : 0 : ret = sxe2_drv_rss_hf_add(adapter, &sxe2_rss_default_hf_config[i]);
271 [ # # ]: 0 : if (ret) {
272 : 0 : PMD_DEV_LOG_ERR(adapter, INIT,
273 : : "Failed to add rss hf cfg[%d], ret:%d", i, ret);
274 : 0 : goto l_end;
275 : : }
276 : : }
277 : : }
278 : :
279 : 0 : rss_ctxt->rss_hf = rss_hf & SXE2_RSS_HF_SUPPORT_ALL;
280 : 0 : rss_ctxt->symm = symm;
281 : 0 : l_end:
282 : 0 : return ret;
283 : : }
284 : :
285 : 0 : int32_t sxe2_rss_hash_function_set(struct rte_eth_dev *dev, enum rte_eth_hash_function func)
286 : : {
287 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
288 : 0 : enum sxe2_rss_hash_key_func hash_func = SXE2_RSS_HASH_FUNC_SYM_TOEPLITZ;
289 : 0 : int32_t ret = 0;
290 : :
291 [ # # # ]: 0 : switch (func) {
292 : : case RTE_ETH_HASH_FUNCTION_DEFAULT:
293 : : case RTE_ETH_HASH_FUNCTION_TOEPLITZ:
294 : : case RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ:
295 : : hash_func = SXE2_RSS_HASH_FUNC_SYM_TOEPLITZ;
296 : : break;
297 : 0 : case RTE_ETH_HASH_FUNCTION_SIMPLE_XOR:
298 : 0 : hash_func = SXE2_RSS_HASH_FUNC_XOR;
299 : 0 : break;
300 : 0 : default:
301 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "RSS hash function[%d] not support.", func);
302 : 0 : ret = -EINVAL;
303 : 0 : goto l_end;
304 : : }
305 : :
306 : 0 : ret = sxe2_drv_rss_hash_ctrl_func(adapter, hash_func);
307 [ # # ]: 0 : if (ret) {
308 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to set rss hash function, ret=[%d]", ret);
309 : 0 : goto l_end;
310 : : }
311 : :
312 : 0 : l_end:
313 : 0 : return ret;
314 : : }
315 : :
316 : 0 : int32_t sxe2_rss_init(struct rte_eth_dev *dev)
317 : : {
318 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
319 : 0 : struct rte_eth_rss_conf *rss_conf = &dev->data->dev_conf.rx_adv_conf.rss_conf;
320 : 0 : enum rte_eth_hash_function rss_func = RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
321 : 0 : int32_t ret = 0;
322 : :
323 : 0 : adapter->rss_ctxt.inited = false;
324 : :
325 [ # # ]: 0 : if (dev->data->nb_rx_queues <= 1) {
326 : 0 : PMD_DEV_LOG_DEBUG(adapter, INIT, "No need to init rss, rx queues %d.",
327 : : dev->data->nb_rx_queues);
328 : 0 : goto l_end;
329 : : }
330 : :
331 [ # # ]: 0 : if ((adapter->cap_flags & SXE2_DEV_CAPS_OFFLOAD_RSS) == 0) {
332 : 0 : PMD_DEV_LOG_WARN(adapter, INIT, "RSS not supported");
333 : 0 : goto l_end;
334 : : }
335 : :
336 : 0 : ret = sxe2_rss_hash_key_init(dev);
337 [ # # ]: 0 : if (ret) {
338 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to init rss key");
339 : 0 : goto l_end;
340 : : }
341 : :
342 : 0 : ret = sxe2_rss_lut_init(dev);
343 [ # # ]: 0 : if (ret) {
344 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to init rss lut");
345 : 0 : goto l_err_key;
346 : : }
347 : :
348 : 0 : rss_func = rss_conf->algorithm;
349 : 0 : ret = sxe2_rss_hash_function_set(dev, rss_func);
350 [ # # ]: 0 : if (ret) {
351 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to init rss hash function");
352 : 0 : goto l_err_lut;
353 : : }
354 : 0 : ret = sxe2_rss_hf_type_set(dev, rss_conf->rss_hf);
355 [ # # ]: 0 : if (ret) {
356 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to set rss hf type");
357 : 0 : goto l_err_lut;
358 : : }
359 : 0 : adapter->rss_ctxt.inited = true;
360 : 0 : goto l_end;
361 : :
362 : 0 : l_err_lut:
363 : 0 : sxe2_rss_lut_uninit(dev);
364 : 0 : l_err_key:
365 : 0 : sxe2_rss_hash_key_uninit(dev);
366 : 0 : l_end:
367 : 0 : return ret;
368 : : }
369 : :
370 : 0 : int32_t sxe2_rss_disable(struct rte_eth_dev *dev)
371 : : {
372 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
373 : 0 : int32_t ret = 0;
374 : :
375 : 0 : PMD_INIT_FUNC_TRACE();
376 : :
377 [ # # ]: 0 : if ((adapter->cap_flags & SXE2_DEV_CAPS_OFFLOAD_RSS) == 0)
378 : 0 : goto l_end;
379 : :
380 : 0 : ret = sxe2_drv_rss_hf_clear(adapter);
381 [ # # ]: 0 : if (ret)
382 : 0 : PMD_LOG_ERR(INIT, "Failed to clear rss hf");
383 : :
384 : 0 : sxe2_rss_hash_key_uninit(dev);
385 : :
386 : 0 : sxe2_rss_lut_uninit(dev);
387 : :
388 : 0 : l_end:
389 : 0 : return ret;
390 : : }
391 : :
392 : 0 : int32_t sxe2_dev_rss_reta_update(struct rte_eth_dev *dev,
393 : : struct rte_eth_rss_reta_entry64 *reta_conf,
394 : : uint16_t reta_size)
395 : : {
396 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
397 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
398 : 0 : uint8_t *lut_tmp = NULL;
399 : 0 : int32_t ret = 0;
400 : 0 : uint16_t i;
401 : 0 : uint16_t shift;
402 : 0 : uint16_t idx;
403 : :
404 [ # # ]: 0 : if (!adapter->rss_ctxt.inited) {
405 : 0 : PMD_DEV_LOG_INFO(adapter, DRV, "RSS not inited.");
406 : 0 : ret = -ENOTSUP;
407 : 0 : goto l_end;
408 : : }
409 : :
410 [ # # ]: 0 : if (reta_size != rss_ctxt->rss_lut_size) {
411 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "The size of hash lookup table configured "
412 : : "(%d) doesn't match the number of hardware can "
413 : : "support (%d)", reta_size, rss_ctxt->rss_lut_size);
414 : 0 : ret = -EINVAL;
415 : 0 : goto l_end;
416 : : }
417 : :
418 : 0 : lut_tmp = rte_zmalloc("rss_lut_temp", reta_size, 0);
419 [ # # ]: 0 : if (!lut_tmp) {
420 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "No memory can be allocated");
421 : 0 : ret = -ENOMEM;
422 : 0 : goto l_end;
423 : : }
424 [ # # ]: 0 : rte_memcpy(lut_tmp, rss_ctxt->rss_lut, reta_size);
425 : :
426 [ # # ]: 0 : for (i = 0; i < reta_size; i++) {
427 : 0 : idx = i / RTE_ETH_RETA_GROUP_SIZE;
428 : 0 : shift = i % RTE_ETH_RETA_GROUP_SIZE;
429 [ # # ]: 0 : if (reta_conf[idx].mask & (1ULL << shift))
430 : 0 : lut_tmp[i] = reta_conf[idx].reta[shift];
431 : : }
432 : :
433 : 0 : ret = sxe2_drv_rss_lut_set(adapter, lut_tmp, reta_size);
434 [ # # ]: 0 : if (ret) {
435 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "Failed to set rss lut");
436 : 0 : goto l_end;
437 : : }
438 : :
439 [ # # ]: 0 : rte_memcpy(rss_ctxt->rss_lut, lut_tmp, reta_size);
440 : :
441 [ # # ]: 0 : l_end:
442 [ # # ]: 0 : if (lut_tmp)
443 : 0 : rte_free(lut_tmp);
444 : 0 : return ret;
445 : : }
446 : :
447 : 0 : int32_t sxe2_dev_rss_reta_query(struct rte_eth_dev *dev,
448 : : struct rte_eth_rss_reta_entry64 *reta_conf,
449 : : uint16_t reta_size)
450 : : {
451 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
452 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
453 : 0 : int32_t ret = 0;
454 : 0 : uint16_t i;
455 : 0 : uint16_t shift;
456 : 0 : uint16_t idx;
457 : :
458 [ # # ]: 0 : if (!adapter->rss_ctxt.inited) {
459 : 0 : PMD_DEV_LOG_INFO(adapter, DRV, "RSS not inited.");
460 : 0 : ret = -ENOTSUP;
461 : 0 : goto l_end;
462 : : }
463 : :
464 [ # # ]: 0 : if (reta_size != rss_ctxt->rss_lut_size) {
465 : 0 : PMD_LOG_ERR(INIT, "The size of hash lookup table configured "
466 : : "(%d) doesn't match the number of hardware can "
467 : : "support (%d)", reta_size, rss_ctxt->rss_lut_size);
468 : 0 : ret = -EINVAL;
469 : 0 : goto l_end;
470 : : }
471 : :
472 [ # # ]: 0 : for (i = 0; i < reta_size; i++) {
473 : 0 : idx = i / RTE_ETH_RETA_GROUP_SIZE;
474 : 0 : shift = i % RTE_ETH_RETA_GROUP_SIZE;
475 [ # # ]: 0 : if (reta_conf[idx].mask & (1ULL << shift))
476 : 0 : reta_conf[idx].reta[shift] = rss_ctxt->rss_lut[i];
477 : : }
478 : :
479 : 0 : l_end:
480 : 0 : return ret;
481 : : }
482 : :
483 : 0 : static int32_t sxe2_rss_hash_key_update(struct rte_eth_dev *dev,
484 : : struct rte_eth_rss_conf *rss_conf)
485 : : {
486 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
487 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
488 : 0 : int32_t ret = 0;
489 : 0 : uint16_t i;
490 : :
491 [ # # # # ]: 0 : if (rss_conf->rss_key_len == 0 || rss_conf->rss_key == NULL)
492 : 0 : goto l_end;
493 : :
494 [ # # ]: 0 : if (rss_conf->rss_key_len != rss_ctxt->rss_key_size) {
495 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "The size of hash key configured "
496 : : "(%d) doesn't match the size of hardware can "
497 : : "support (%d)", rss_conf->rss_key_len,
498 : : rss_ctxt->rss_key_size);
499 : 0 : ret = -EINVAL;
500 : 0 : goto l_end;
501 : : }
502 : :
503 [ # # ]: 0 : for (i = 0; i < rss_conf->rss_key_len; i++) {
504 [ # # ]: 0 : if (rss_conf->rss_key[i] != rss_ctxt->rss_key[i])
505 : : break;
506 : : }
507 [ # # ]: 0 : if (i == rss_conf->rss_key_len)
508 : 0 : goto l_end;
509 : :
510 : 0 : ret = sxe2_drv_rss_key_set(adapter, rss_conf->rss_key,
511 : : rss_conf->rss_key_len);
512 [ # # ]: 0 : if (ret) {
513 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "Failed to set rss key");
514 : 0 : goto l_end;
515 : : }
516 : :
517 [ # # ]: 0 : rte_memcpy(rss_ctxt->rss_key, rss_conf->rss_key, rss_conf->rss_key_len);
518 : 0 : l_end:
519 : 0 : return ret;
520 : : }
521 : :
522 : 0 : int32_t sxe2_dev_rss_hash_update(struct rte_eth_dev *dev,
523 : : struct rte_eth_rss_conf *rss_conf)
524 : : {
525 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
526 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
527 : 0 : int32_t ret = -1;
528 : :
529 [ # # ]: 0 : if (!adapter->rss_ctxt.inited) {
530 : 0 : PMD_DEV_LOG_INFO(adapter, DRV, "RSS not inited.");
531 : 0 : ret = -ENOTSUP;
532 : 0 : goto l_end;
533 : : }
534 : :
535 : 0 : ret = sxe2_rss_hash_key_update(dev, rss_conf);
536 [ # # ]: 0 : if (ret) {
537 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "Failed to set rss hash key");
538 : 0 : goto l_end;
539 : : }
540 : :
541 [ # # ]: 0 : if (rss_conf->algorithm != rss_ctxt->hash_func) {
542 : 0 : ret = sxe2_rss_hash_function_set(dev, rss_conf->algorithm);
543 [ # # ]: 0 : if (ret) {
544 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "Failed to set rss hash function");
545 : 0 : goto l_end;
546 : : }
547 : 0 : rss_ctxt->hash_func = rss_conf->algorithm;
548 : : }
549 : :
550 : 0 : if ((rss_conf->rss_hf & SXE2_RSS_HF_SUPPORT_ALL)
551 [ # # ]: 0 : != rss_ctxt->rss_hf) {
552 : 0 : ret = sxe2_rss_hf_type_set(dev, rss_conf->rss_hf);
553 [ # # ]: 0 : if (ret) {
554 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "Failed to set rss hf type");
555 : 0 : goto l_end;
556 : : }
557 : : }
558 : : ret = 0;
559 : 0 : l_end:
560 : 0 : return ret;
561 : : }
562 : :
563 : 0 : int32_t sxe2_dev_rss_hash_conf_get(struct rte_eth_dev *dev,
564 : : struct rte_eth_rss_conf *rss_conf)
565 : : {
566 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
567 : 0 : struct sxe2_rss_context *rss_ctxt = &adapter->rss_ctxt;
568 : 0 : int32_t ret = 0;
569 : :
570 [ # # ]: 0 : if (adapter->rss_ctxt.inited == 0) {
571 : 0 : PMD_DEV_LOG_INFO(adapter, DRV, "RSS not inited.");
572 : 0 : ret = -ENOTSUP;
573 : 0 : goto l_end;
574 : : }
575 : :
576 [ # # ]: 0 : if (rss_conf->rss_key) {
577 : 0 : rss_conf->rss_key_len = rss_ctxt->rss_key_size;
578 [ # # ]: 0 : rte_memcpy(rss_conf->rss_key, rss_ctxt->rss_key, rss_ctxt->rss_key_size);
579 : : }
580 : 0 : rss_conf->rss_hf = rss_ctxt->rss_hf;
581 : 0 : rss_conf->algorithm = rss_ctxt->hash_func;
582 : 0 : l_end:
583 : 0 : return ret;
584 : : }
|
