1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2019-2021 Broadcom
3 * All rights reserved.
4 */
5
6 #include "bnxt_tf_common.h"
7 #include "ulp_template_struct.h"
8 #include "ulp_template_db_enum.h"
9 #include "ulp_template_db_field.h"
10 #include "ulp_utils.h"
11 #include "ulp_port_db.h"
12 #include "ulp_flow_db.h"
13 #include "ulp_mapper.h"
14
15 struct bnxt_ulp_def_param_handler {
16 int32_t (*vfr_func)(struct bnxt_ulp_context *ulp_ctx,
17 struct ulp_tlv_param *param,
18 struct bnxt_ulp_mapper_create_parms *mapper_params);
19 };
20
21 static int32_t
ulp_set_svif_in_comp_fld(struct bnxt_ulp_context * ulp_ctx,uint32_t ifindex,uint8_t svif_type,struct bnxt_ulp_mapper_create_parms * mapper_params)22 ulp_set_svif_in_comp_fld(struct bnxt_ulp_context *ulp_ctx,
23 uint32_t ifindex, uint8_t svif_type,
24 struct bnxt_ulp_mapper_create_parms *mapper_params)
25 {
26 uint16_t svif;
27 uint8_t idx;
28 int rc;
29
30 rc = ulp_port_db_svif_get(ulp_ctx, ifindex, svif_type, &svif);
31 if (rc)
32 return rc;
33
34 if (svif_type == BNXT_ULP_PHY_PORT_SVIF)
35 idx = BNXT_ULP_CF_IDX_PHY_PORT_SVIF;
36 else if (svif_type == BNXT_ULP_DRV_FUNC_SVIF)
37 idx = BNXT_ULP_CF_IDX_DRV_FUNC_SVIF;
38 else
39 idx = BNXT_ULP_CF_IDX_VF_FUNC_SVIF;
40
41 ULP_COMP_FLD_IDX_WR(mapper_params, idx, svif);
42
43 return 0;
44 }
45
46 static int32_t
ulp_set_spif_in_comp_fld(struct bnxt_ulp_context * ulp_ctx,uint32_t ifindex,uint8_t spif_type,struct bnxt_ulp_mapper_create_parms * mapper_params)47 ulp_set_spif_in_comp_fld(struct bnxt_ulp_context *ulp_ctx,
48 uint32_t ifindex, uint8_t spif_type,
49 struct bnxt_ulp_mapper_create_parms *mapper_params)
50 {
51 uint16_t spif;
52 uint8_t idx;
53 int rc;
54
55 rc = ulp_port_db_spif_get(ulp_ctx, ifindex, spif_type, &spif);
56 if (rc)
57 return rc;
58
59 if (spif_type == BNXT_ULP_PHY_PORT_SPIF)
60 idx = BNXT_ULP_CF_IDX_PHY_PORT_SPIF;
61 else if (spif_type == BNXT_ULP_DRV_FUNC_SPIF)
62 idx = BNXT_ULP_CF_IDX_DRV_FUNC_SPIF;
63 else
64 idx = BNXT_ULP_CF_IDX_VF_FUNC_SPIF;
65
66 ULP_COMP_FLD_IDX_WR(mapper_params, idx, spif);
67
68 return 0;
69 }
70
71 static int32_t
ulp_set_parif_in_comp_fld(struct bnxt_ulp_context * ulp_ctx,uint32_t ifindex,uint8_t parif_type,struct bnxt_ulp_mapper_create_parms * mapper_params)72 ulp_set_parif_in_comp_fld(struct bnxt_ulp_context *ulp_ctx,
73 uint32_t ifindex, uint8_t parif_type,
74 struct bnxt_ulp_mapper_create_parms *mapper_params)
75 {
76 uint16_t parif;
77 uint8_t idx;
78 int rc;
79
80 rc = ulp_port_db_parif_get(ulp_ctx, ifindex, parif_type, &parif);
81 if (rc)
82 return rc;
83
84 if (parif_type == BNXT_ULP_PHY_PORT_PARIF)
85 idx = BNXT_ULP_CF_IDX_PHY_PORT_PARIF;
86 else if (parif_type == BNXT_ULP_DRV_FUNC_PARIF)
87 idx = BNXT_ULP_CF_IDX_DRV_FUNC_PARIF;
88 else
89 idx = BNXT_ULP_CF_IDX_VF_FUNC_PARIF;
90
91 ULP_COMP_FLD_IDX_WR(mapper_params, idx, parif);
92
93 return 0;
94 }
95
96 static int32_t
ulp_set_vport_in_comp_fld(struct bnxt_ulp_context * ulp_ctx,uint32_t ifindex,struct bnxt_ulp_mapper_create_parms * mapper_params)97 ulp_set_vport_in_comp_fld(struct bnxt_ulp_context *ulp_ctx, uint32_t ifindex,
98 struct bnxt_ulp_mapper_create_parms *mapper_params)
99 {
100 uint16_t vport;
101 int rc;
102
103 rc = ulp_port_db_vport_get(ulp_ctx, ifindex, &vport);
104 if (rc)
105 return rc;
106
107 ULP_COMP_FLD_IDX_WR(mapper_params, BNXT_ULP_CF_IDX_PHY_PORT_VPORT,
108 vport);
109 return 0;
110 }
111
112 static int32_t
ulp_set_vnic_in_comp_fld(struct bnxt_ulp_context * ulp_ctx,uint32_t ifindex,uint8_t vnic_type,struct bnxt_ulp_mapper_create_parms * mapper_params)113 ulp_set_vnic_in_comp_fld(struct bnxt_ulp_context *ulp_ctx,
114 uint32_t ifindex, uint8_t vnic_type,
115 struct bnxt_ulp_mapper_create_parms *mapper_params)
116 {
117 uint16_t vnic;
118 uint8_t idx;
119 int rc;
120
121 rc = ulp_port_db_default_vnic_get(ulp_ctx, ifindex, vnic_type, &vnic);
122 if (rc)
123 return rc;
124
125 if (vnic_type == BNXT_ULP_DRV_FUNC_VNIC)
126 idx = BNXT_ULP_CF_IDX_DRV_FUNC_VNIC;
127 else
128 idx = BNXT_ULP_CF_IDX_VF_FUNC_VNIC;
129
130 ULP_COMP_FLD_IDX_WR(mapper_params, idx, vnic);
131
132 return 0;
133 }
134
135 static int32_t
ulp_set_vlan_in_act_prop(uint16_t port_id,struct bnxt_ulp_mapper_create_parms * mapper_params)136 ulp_set_vlan_in_act_prop(uint16_t port_id,
137 struct bnxt_ulp_mapper_create_parms *mapper_params)
138 {
139 struct ulp_rte_act_prop *act_prop = mapper_params->act_prop;
140
141 if (ULP_BITMAP_ISSET(mapper_params->act->bits,
142 BNXT_ULP_ACT_BIT_SET_VLAN_VID)) {
143 BNXT_TF_DBG(ERR,
144 "VLAN already set, multiple VLANs unsupported\n");
145 return BNXT_TF_RC_ERROR;
146 }
147
148 port_id = rte_cpu_to_be_16(port_id);
149
150 ULP_BITMAP_SET(mapper_params->act->bits,
151 BNXT_ULP_ACT_BIT_SET_VLAN_VID);
152
153 memcpy(&act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_ENCAP_VTAG],
154 &port_id, sizeof(port_id));
155
156 return 0;
157 }
158
159 static int32_t
ulp_set_mark_in_act_prop(uint16_t port_id,struct bnxt_ulp_mapper_create_parms * mapper_params)160 ulp_set_mark_in_act_prop(uint16_t port_id,
161 struct bnxt_ulp_mapper_create_parms *mapper_params)
162 {
163 if (ULP_BITMAP_ISSET(mapper_params->act->bits,
164 BNXT_ULP_ACT_BIT_MARK)) {
165 BNXT_TF_DBG(ERR,
166 "MARK already set, multiple MARKs unsupported\n");
167 return BNXT_TF_RC_ERROR;
168 }
169
170 ULP_COMP_FLD_IDX_WR(mapper_params, BNXT_ULP_CF_IDX_DEV_PORT_ID,
171 port_id);
172
173 return 0;
174 }
175
176 static int32_t
ulp_df_dev_port_handler(struct bnxt_ulp_context * ulp_ctx,struct ulp_tlv_param * param,struct bnxt_ulp_mapper_create_parms * mapper_params)177 ulp_df_dev_port_handler(struct bnxt_ulp_context *ulp_ctx,
178 struct ulp_tlv_param *param,
179 struct bnxt_ulp_mapper_create_parms *mapper_params)
180 {
181 uint16_t port_id;
182 uint32_t ifindex;
183 int rc;
184
185 port_id = param->value[0] | param->value[1];
186
187 rc = ulp_port_db_dev_port_to_ulp_index(ulp_ctx, port_id, &ifindex);
188 if (rc) {
189 BNXT_TF_DBG(ERR,
190 "Invalid port id\n");
191 return BNXT_TF_RC_ERROR;
192 }
193
194 /* Set port SVIF */
195 rc = ulp_set_svif_in_comp_fld(ulp_ctx, ifindex, BNXT_ULP_PHY_PORT_SVIF,
196 mapper_params);
197 if (rc)
198 return rc;
199
200 /* Set DRV Func SVIF */
201 rc = ulp_set_svif_in_comp_fld(ulp_ctx, ifindex, BNXT_ULP_DRV_FUNC_SVIF,
202 mapper_params);
203 if (rc)
204 return rc;
205
206 /* Set VF Func SVIF */
207 rc = ulp_set_svif_in_comp_fld(ulp_ctx, ifindex, BNXT_ULP_VF_FUNC_SVIF,
208 mapper_params);
209 if (rc)
210 return rc;
211
212 /* Set port SPIF */
213 rc = ulp_set_spif_in_comp_fld(ulp_ctx, ifindex, BNXT_ULP_PHY_PORT_SPIF,
214 mapper_params);
215 if (rc)
216 return rc;
217
218 /* Set DRV Func SPIF */
219 rc = ulp_set_spif_in_comp_fld(ulp_ctx, ifindex, BNXT_ULP_DRV_FUNC_SPIF,
220 mapper_params);
221 if (rc)
222 return rc;
223
224 /* Set VF Func SPIF */
225 rc = ulp_set_spif_in_comp_fld(ulp_ctx, ifindex, BNXT_ULP_DRV_FUNC_SPIF,
226 mapper_params);
227 if (rc)
228 return rc;
229
230 /* Set port PARIF */
231 rc = ulp_set_parif_in_comp_fld(ulp_ctx, ifindex,
232 BNXT_ULP_PHY_PORT_PARIF, mapper_params);
233 if (rc)
234 return rc;
235
236 /* Set DRV Func PARIF */
237 rc = ulp_set_parif_in_comp_fld(ulp_ctx, ifindex,
238 BNXT_ULP_DRV_FUNC_PARIF, mapper_params);
239 if (rc)
240 return rc;
241
242 /* Set VF Func PARIF */
243 rc = ulp_set_parif_in_comp_fld(ulp_ctx, ifindex, BNXT_ULP_VF_FUNC_PARIF,
244 mapper_params);
245 if (rc)
246 return rc;
247
248 /* Set uplink VNIC */
249 rc = ulp_set_vnic_in_comp_fld(ulp_ctx, ifindex, true, mapper_params);
250 if (rc)
251 return rc;
252
253 /* Set VF VNIC */
254 rc = ulp_set_vnic_in_comp_fld(ulp_ctx, ifindex, false, mapper_params);
255 if (rc)
256 return rc;
257
258 /* Set VPORT */
259 rc = ulp_set_vport_in_comp_fld(ulp_ctx, ifindex, mapper_params);
260 if (rc)
261 return rc;
262
263 /* Set VLAN */
264 rc = ulp_set_vlan_in_act_prop(port_id, mapper_params);
265 if (rc)
266 return rc;
267
268 /* Set MARK */
269 rc = ulp_set_mark_in_act_prop(port_id, mapper_params);
270 if (rc)
271 return rc;
272
273 return 0;
274 }
275
276 struct bnxt_ulp_def_param_handler ulp_def_handler_tbl[] = {
277 [BNXT_ULP_DF_PARAM_TYPE_DEV_PORT_ID] = {
278 .vfr_func = ulp_df_dev_port_handler }
279 };
280
281 /*
282 * Function to create default rules for the following paths
283 * 1) Device PORT to DPDK App
284 * 2) DPDK App to Device PORT
285 * 3) VF Representor to VF
286 * 4) VF to VF Representor
287 *
288 * eth_dev [in] Ptr to rte eth device.
289 * param_list [in] Ptr to a list of parameters (Currently, only DPDK port_id).
290 * ulp_class_tid [in] Class template ID number.
291 * flow_id [out] Ptr to flow identifier.
292 *
293 * Returns 0 on success or negative number on failure.
294 */
295 int32_t
ulp_default_flow_create(struct rte_eth_dev * eth_dev,struct ulp_tlv_param * param_list,uint32_t ulp_class_tid,uint32_t * flow_id)296 ulp_default_flow_create(struct rte_eth_dev *eth_dev,
297 struct ulp_tlv_param *param_list,
298 uint32_t ulp_class_tid,
299 uint32_t *flow_id)
300 {
301 struct ulp_rte_hdr_field hdr_field[BNXT_ULP_PROTO_HDR_MAX];
302 uint64_t comp_fld[BNXT_ULP_CF_IDX_LAST];
303 struct bnxt_ulp_mapper_create_parms mapper_params = { 0 };
304 struct ulp_rte_act_prop act_prop;
305 struct ulp_rte_act_bitmap act = { 0 };
306 struct bnxt_ulp_context *ulp_ctx;
307 uint32_t type, ulp_flags = 0, fid;
308 int rc = 0;
309
310 memset(&mapper_params, 0, sizeof(mapper_params));
311 memset(hdr_field, 0, sizeof(hdr_field));
312 memset(comp_fld, 0, sizeof(comp_fld));
313 memset(&act_prop, 0, sizeof(act_prop));
314
315 mapper_params.hdr_field = hdr_field;
316 mapper_params.act = &act;
317 mapper_params.act_prop = &act_prop;
318 mapper_params.comp_fld = comp_fld;
319 mapper_params.class_tid = ulp_class_tid;
320 mapper_params.flow_type = BNXT_ULP_FDB_TYPE_DEFAULT;
321 mapper_params.port_id = eth_dev->data->port_id;
322
323 ulp_ctx = bnxt_ulp_eth_dev_ptr2_cntxt_get(eth_dev);
324 if (!ulp_ctx) {
325 BNXT_TF_DBG(ERR,
326 "ULP is not init'ed. Fail to create dflt flow.\n");
327 return -EINVAL;
328 }
329
330 /* update the vf rep flag */
331 if (bnxt_ulp_cntxt_ptr2_ulp_flags_get(ulp_ctx, &ulp_flags)) {
332 BNXT_TF_DBG(ERR, "Error in getting ULP context flags\n");
333 return -EINVAL;
334 }
335 if (ULP_VF_REP_IS_ENABLED(ulp_flags))
336 ULP_COMP_FLD_IDX_WR(&mapper_params,
337 BNXT_ULP_CF_IDX_VFR_MODE, 1);
338
339 type = param_list->type;
340 while (type != BNXT_ULP_DF_PARAM_TYPE_LAST) {
341 if (ulp_def_handler_tbl[type].vfr_func) {
342 rc = ulp_def_handler_tbl[type].vfr_func(ulp_ctx,
343 param_list,
344 &mapper_params);
345 if (rc) {
346 BNXT_TF_DBG(ERR,
347 "Failed to create default flow.\n");
348 return rc;
349 }
350 }
351
352 param_list++;
353 type = param_list->type;
354 }
355
356 /* Get the function id */
357 if (ulp_port_db_port_func_id_get(ulp_ctx,
358 eth_dev->data->port_id,
359 &mapper_params.func_id)) {
360 BNXT_TF_DBG(ERR, "conversion of port to func id failed\n");
361 goto err1;
362 }
363
364 BNXT_TF_DBG(DEBUG, "Creating default flow with template id: %u\n",
365 ulp_class_tid);
366
367 /* Protect flow creation */
368 if (bnxt_ulp_cntxt_acquire_fdb_lock(ulp_ctx)) {
369 BNXT_TF_DBG(ERR, "Flow db lock acquire failed\n");
370 goto err1;
371 }
372
373 rc = ulp_flow_db_fid_alloc(ulp_ctx, mapper_params.flow_type,
374 mapper_params.func_id, &fid);
375 if (rc) {
376 BNXT_TF_DBG(ERR, "Unable to allocate flow table entry\n");
377 goto err2;
378 }
379
380 mapper_params.flow_id = fid;
381 rc = ulp_mapper_flow_create(ulp_ctx, &mapper_params);
382 if (rc)
383 goto err3;
384
385 bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
386 *flow_id = fid;
387 return 0;
388
389 err3:
390 ulp_flow_db_fid_free(ulp_ctx, mapper_params.flow_type, fid);
391 err2:
392 bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
393 err1:
394 BNXT_TF_DBG(ERR, "Failed to create default flow.\n");
395 return rc;
396 }
397
398 /*
399 * Function to destroy default rules for the following paths
400 * 1) Device PORT to DPDK App
401 * 2) DPDK App to Device PORT
402 * 3) VF Representor to VF
403 * 4) VF to VF Representor
404 *
405 * eth_dev [in] Ptr to rte eth device.
406 * flow_id [in] Flow identifier.
407 *
408 * Returns 0 on success or negative number on failure.
409 */
410 int32_t
ulp_default_flow_destroy(struct rte_eth_dev * eth_dev,uint32_t flow_id)411 ulp_default_flow_destroy(struct rte_eth_dev *eth_dev, uint32_t flow_id)
412 {
413 struct bnxt_ulp_context *ulp_ctx;
414 int rc = 0;
415
416 ulp_ctx = bnxt_ulp_eth_dev_ptr2_cntxt_get(eth_dev);
417 if (!ulp_ctx) {
418 BNXT_TF_DBG(ERR, "ULP context is not initialized\n");
419 return -EINVAL;
420 }
421
422 if (!flow_id) {
423 BNXT_TF_DBG(DEBUG, "invalid flow id zero\n");
424 return rc;
425 }
426
427 if (bnxt_ulp_cntxt_acquire_fdb_lock(ulp_ctx)) {
428 BNXT_TF_DBG(ERR, "Flow db lock acquire failed\n");
429 return -EINVAL;
430 }
431 rc = ulp_mapper_flow_destroy(ulp_ctx, BNXT_ULP_FDB_TYPE_DEFAULT,
432 flow_id);
433 if (rc)
434 BNXT_TF_DBG(ERR, "Failed to destroy flow.\n");
435 bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
436
437 return rc;
438 }
439
440 void
bnxt_ulp_destroy_df_rules(struct bnxt * bp,bool global)441 bnxt_ulp_destroy_df_rules(struct bnxt *bp, bool global)
442 {
443 struct bnxt_ulp_df_rule_info *info;
444 uint16_t port_id;
445
446 if (!BNXT_TRUFLOW_EN(bp) ||
447 BNXT_ETH_DEV_IS_REPRESENTOR(bp->eth_dev))
448 return;
449
450 if (!bp->ulp_ctx || !bp->ulp_ctx->cfg_data)
451 return;
452
453 /* Delete default rules per port */
454 if (!global) {
455 port_id = bp->eth_dev->data->port_id;
456 info = &bp->ulp_ctx->cfg_data->df_rule_info[port_id];
457 if (!info->valid)
458 return;
459
460 ulp_default_flow_destroy(bp->eth_dev,
461 info->def_port_flow_id);
462 memset(info, 0, sizeof(struct bnxt_ulp_df_rule_info));
463 return;
464 }
465
466 /* Delete default rules for all ports */
467 for (port_id = 0; port_id < RTE_MAX_ETHPORTS; port_id++) {
468 info = &bp->ulp_ctx->cfg_data->df_rule_info[port_id];
469 if (!info->valid)
470 continue;
471
472 ulp_default_flow_destroy(bp->eth_dev,
473 info->def_port_flow_id);
474 memset(info, 0, sizeof(struct bnxt_ulp_df_rule_info));
475 }
476 }
477
478 static int32_t
bnxt_create_port_app_df_rule(struct bnxt * bp,uint8_t flow_type,uint32_t * flow_id)479 bnxt_create_port_app_df_rule(struct bnxt *bp, uint8_t flow_type,
480 uint32_t *flow_id)
481 {
482 uint16_t port_id = bp->eth_dev->data->port_id;
483 struct ulp_tlv_param param_list[] = {
484 {
485 .type = BNXT_ULP_DF_PARAM_TYPE_DEV_PORT_ID,
486 .length = 2,
487 .value = {(port_id >> 8) & 0xff, port_id & 0xff}
488 },
489 {
490 .type = BNXT_ULP_DF_PARAM_TYPE_LAST,
491 .length = 0,
492 .value = {0}
493 }
494 };
495
496 if (!flow_type) {
497 *flow_id = 0;
498 return 0;
499 }
500 return ulp_default_flow_create(bp->eth_dev, param_list, flow_type,
501 flow_id);
502 }
503
504 int32_t
bnxt_ulp_create_df_rules(struct bnxt * bp)505 bnxt_ulp_create_df_rules(struct bnxt *bp)
506 {
507 struct bnxt_ulp_df_rule_info *info;
508 uint16_t port_id;
509 int rc = 0;
510
511 if (!BNXT_TRUFLOW_EN(bp) ||
512 BNXT_ETH_DEV_IS_REPRESENTOR(bp->eth_dev) || !bp->ulp_ctx)
513 return 0;
514
515 port_id = bp->eth_dev->data->port_id;
516 info = &bp->ulp_ctx->cfg_data->df_rule_info[port_id];
517 rc = bnxt_create_port_app_df_rule(bp,
518 BNXT_ULP_DF_TPL_DEFAULT_UPLINK_PORT,
519 &info->def_port_flow_id);
520 if (rc) {
521 BNXT_TF_DBG(ERR,
522 "Failed to create port to app default rule\n");
523 return rc;
524 }
525
526 rc = ulp_default_flow_db_cfa_action_get(bp->ulp_ctx,
527 info->def_port_flow_id,
528 &bp->tx_cfa_action);
529 if (rc)
530 bp->tx_cfa_action = 0;
531 info->valid = true;
532 return 0;
533 }
534
535 static int32_t
bnxt_create_port_vfr_default_rule(struct bnxt * bp,uint8_t flow_type,uint16_t vfr_port_id,uint32_t * flow_id)536 bnxt_create_port_vfr_default_rule(struct bnxt *bp,
537 uint8_t flow_type,
538 uint16_t vfr_port_id,
539 uint32_t *flow_id)
540 {
541 struct ulp_tlv_param param_list[] = {
542 {
543 .type = BNXT_ULP_DF_PARAM_TYPE_DEV_PORT_ID,
544 .length = 2,
545 .value = {(vfr_port_id >> 8) & 0xff, vfr_port_id & 0xff}
546 },
547 {
548 .type = BNXT_ULP_DF_PARAM_TYPE_LAST,
549 .length = 0,
550 .value = {0}
551 }
552 };
553 return ulp_default_flow_create(bp->eth_dev, param_list, flow_type,
554 flow_id);
555 }
556
557 int32_t
bnxt_ulp_create_vfr_default_rules(struct rte_eth_dev * vfr_ethdev)558 bnxt_ulp_create_vfr_default_rules(struct rte_eth_dev *vfr_ethdev)
559 {
560 struct bnxt_ulp_vfr_rule_info *info;
561 struct bnxt_representor *vfr = vfr_ethdev->data->dev_private;
562 struct rte_eth_dev *parent_dev = vfr->parent_dev;
563 struct bnxt *bp = parent_dev->data->dev_private;
564 uint16_t vfr_port_id = vfr_ethdev->data->port_id;
565 uint16_t port_id;
566 int rc;
567
568 if (!bp || !BNXT_TRUFLOW_EN(bp))
569 return 0;
570
571 port_id = vfr_ethdev->data->port_id;
572 info = bnxt_ulp_cntxt_ptr2_ulp_vfr_info_get(bp->ulp_ctx, port_id);
573
574 if (!info) {
575 BNXT_TF_DBG(ERR, "Failed to get vfr ulp context\n");
576 return -EINVAL;
577 }
578
579 if (info->valid) {
580 BNXT_TF_DBG(ERR, "VFR already allocated\n");
581 return -EINVAL;
582 }
583
584 memset(info, 0, sizeof(struct bnxt_ulp_vfr_rule_info));
585 rc = bnxt_create_port_vfr_default_rule(bp, BNXT_ULP_DF_TPL_DEFAULT_VFR,
586 vfr_port_id,
587 &info->vfr_flow_id);
588 if (rc) {
589 BNXT_TF_DBG(ERR, "Failed to create VFR default rule\n");
590 goto error;
591 }
592 rc = ulp_default_flow_db_cfa_action_get(bp->ulp_ctx,
593 info->vfr_flow_id,
594 &vfr->vfr_tx_cfa_action);
595 if (rc) {
596 BNXT_TF_DBG(ERR, "Failed to get the tx cfa action\n");
597 goto error;
598 }
599
600 /* Update the other details */
601 info->valid = true;
602 info->parent_port_id = bp->eth_dev->data->port_id;
603 return 0;
604
605 error:
606 if (info->vfr_flow_id)
607 ulp_default_flow_destroy(bp->eth_dev, info->vfr_flow_id);
608 return rc;
609 }
610
611 int32_t
bnxt_ulp_delete_vfr_default_rules(struct bnxt_representor * vfr)612 bnxt_ulp_delete_vfr_default_rules(struct bnxt_representor *vfr)
613 {
614 struct bnxt_ulp_vfr_rule_info *info;
615 struct rte_eth_dev *parent_dev = vfr->parent_dev;
616 struct bnxt *bp = parent_dev->data->dev_private;
617
618 if (!bp || !BNXT_TRUFLOW_EN(bp))
619 return 0;
620 info = bnxt_ulp_cntxt_ptr2_ulp_vfr_info_get(bp->ulp_ctx,
621 vfr->dpdk_port_id);
622 if (!info) {
623 BNXT_TF_DBG(ERR, "Failed to get vfr ulp context\n");
624 return -EINVAL;
625 }
626
627 if (!info->valid) {
628 BNXT_TF_DBG(ERR, "VFR already freed\n");
629 return -EINVAL;
630 }
631 ulp_default_flow_destroy(bp->eth_dev, info->vfr_flow_id);
632 vfr->vfr_tx_cfa_action = 0;
633 memset(info, 0, sizeof(struct bnxt_ulp_vfr_rule_info));
634 return 0;
635 }
636