1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2014-2021 Broadcom 3 * All rights reserved. 4 */ 5 6 #include <rte_log.h> 7 #include <rte_malloc.h> 8 #include "bnxt.h" 9 #include "ulp_template_db_enum.h" 10 #include "ulp_template_struct.h" 11 #include "bnxt_tf_common.h" 12 #include "ulp_utils.h" 13 #include "bnxt_ulp.h" 14 #include "tfp.h" 15 #include "tf_ext_flow_handle.h" 16 #include "ulp_mark_mgr.h" 17 #include "ulp_mapper.h" 18 #include "ulp_flow_db.h" 19 #include "tf_util.h" 20 #include "ulp_template_db_tbl.h" 21 #include "ulp_port_db.h" 22 #include "ulp_ha_mgr.h" 23 #include "bnxt_tf_pmd_shim.h" 24 25 static uint8_t mapper_fld_zeros[16] = { 0 }; 26 27 static uint8_t mapper_fld_ones[16] = { 28 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 29 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF 30 }; 31 32 static uint8_t mapper_fld_one[16] = { 33 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 34 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 35 }; 36 37 static const char * 38 ulp_mapper_tmpl_name_str(enum bnxt_ulp_template_type tmpl_type) 39 { 40 switch (tmpl_type) { 41 case BNXT_ULP_TEMPLATE_TYPE_CLASS: 42 return "class"; 43 case BNXT_ULP_TEMPLATE_TYPE_ACTION: 44 return "action"; 45 default: 46 return "invalid template type"; 47 } 48 } 49 50 static struct bnxt_ulp_glb_resource_info * 51 ulp_mapper_glb_resource_info_list_get(uint32_t *num_entries) 52 { 53 if (!num_entries) 54 return NULL; 55 *num_entries = BNXT_ULP_GLB_RESOURCE_TBL_MAX_SZ; 56 return ulp_glb_resource_tbl; 57 } 58 59 /* 60 * Read the global resource from the mapper global resource list 61 * 62 * The regval is always returned in big-endian. 63 * 64 * returns 0 on success 65 */ 66 static int32_t 67 ulp_mapper_glb_resource_read(struct bnxt_ulp_mapper_data *mapper_data, 68 enum tf_dir dir, 69 uint16_t idx, 70 uint64_t *regval, 71 bool *shared) 72 { 73 if (!mapper_data || !regval || !shared || 74 dir >= TF_DIR_MAX || idx >= BNXT_ULP_GLB_RF_IDX_LAST) 75 return -EINVAL; 76 77 *regval = mapper_data->glb_res_tbl[dir][idx].resource_hndl; 78 *shared = mapper_data->glb_res_tbl[dir][idx].shared; 79 return 0; 80 } 81 82 /* 83 * Write a global resource to the mapper global resource list 84 * 85 * The regval value must be in big-endian. 86 * 87 * return 0 on success. 88 */ 89 static int32_t 90 ulp_mapper_glb_resource_write(struct bnxt_ulp_mapper_data *data, 91 struct bnxt_ulp_glb_resource_info *res, 92 uint64_t regval, bool shared) 93 { 94 struct bnxt_ulp_mapper_glb_resource_entry *ent; 95 96 /* validate the arguments */ 97 if (!data || res->direction >= TF_DIR_MAX || 98 res->glb_regfile_index >= BNXT_ULP_GLB_RF_IDX_LAST) 99 return -EINVAL; 100 101 /* write to the mapper data */ 102 ent = &data->glb_res_tbl[res->direction][res->glb_regfile_index]; 103 ent->resource_func = res->resource_func; 104 ent->resource_type = res->resource_type; 105 ent->resource_hndl = regval; 106 ent->shared = shared; 107 return 0; 108 } 109 110 /* 111 * Internal function to allocate identity resource and store it in mapper data. 112 * 113 * returns 0 on success 114 */ 115 static int32_t 116 ulp_mapper_resource_ident_allocate(struct bnxt_ulp_context *ulp_ctx, 117 struct bnxt_ulp_mapper_data *mapper_data, 118 struct bnxt_ulp_glb_resource_info *glb_res) 119 { 120 struct tf_alloc_identifier_parms iparms = { 0 }; 121 struct tf_free_identifier_parms fparms; 122 uint64_t regval; 123 struct tf *tfp; 124 int32_t rc = 0; 125 126 tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO); 127 if (!tfp) 128 return -EINVAL; 129 130 iparms.ident_type = glb_res->resource_type; 131 iparms.dir = glb_res->direction; 132 133 /* Allocate the Identifier using tf api */ 134 rc = tf_alloc_identifier(tfp, &iparms); 135 if (rc) { 136 BNXT_TF_DBG(ERR, "Failed to alloc identifier [%s][%d]\n", 137 tf_dir_2_str(iparms.dir), 138 iparms.ident_type); 139 return rc; 140 } 141 142 /* entries are stored as big-endian format */ 143 regval = tfp_cpu_to_be_64((uint64_t)iparms.id); 144 /* 145 * write to the mapper global resource 146 * Shared resources are never allocated through this method, so the 147 * shared flag is always false. 148 */ 149 rc = ulp_mapper_glb_resource_write(mapper_data, glb_res, regval, false); 150 if (rc) { 151 BNXT_TF_DBG(ERR, "Failed to write to global resource id\n"); 152 /* Free the identifier when update failed */ 153 fparms.dir = iparms.dir; 154 fparms.ident_type = iparms.ident_type; 155 fparms.id = iparms.id; 156 tf_free_identifier(tfp, &fparms); 157 return rc; 158 } 159 return rc; 160 } 161 162 /* 163 * Internal function to allocate index tbl resource and store it in mapper data. 164 * 165 * returns 0 on success 166 */ 167 static int32_t 168 ulp_mapper_resource_index_tbl_alloc(struct bnxt_ulp_context *ulp_ctx, 169 struct bnxt_ulp_mapper_data *mapper_data, 170 struct bnxt_ulp_glb_resource_info *glb_res) 171 { 172 struct tf_alloc_tbl_entry_parms aparms = { 0 }; 173 struct tf_free_tbl_entry_parms free_parms = { 0 }; 174 uint64_t regval; 175 struct tf *tfp; 176 uint32_t tbl_scope_id; 177 int32_t rc = 0; 178 179 tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO); 180 if (!tfp) 181 return -EINVAL; 182 183 /* Get the scope id */ 184 rc = bnxt_ulp_cntxt_tbl_scope_id_get(ulp_ctx, &tbl_scope_id); 185 if (rc) { 186 BNXT_TF_DBG(ERR, "Failed to get table scope rc=%d\n", rc); 187 return rc; 188 } 189 190 aparms.type = glb_res->resource_type; 191 aparms.dir = glb_res->direction; 192 aparms.tbl_scope_id = tbl_scope_id; 193 194 /* Allocate the index tbl using tf api */ 195 rc = tf_alloc_tbl_entry(tfp, &aparms); 196 if (rc) { 197 BNXT_TF_DBG(ERR, "Failed to alloc index table [%s][%d]\n", 198 tf_dir_2_str(aparms.dir), aparms.type); 199 return rc; 200 } 201 202 /* entries are stored as big-endian format */ 203 regval = tfp_cpu_to_be_64((uint64_t)aparms.idx); 204 /* 205 * write to the mapper global resource 206 * Shared resources are never allocated through this method, so the 207 * shared flag is always false. 208 */ 209 rc = ulp_mapper_glb_resource_write(mapper_data, glb_res, regval, false); 210 if (rc) { 211 BNXT_TF_DBG(ERR, "Failed to write to global resource id\n"); 212 /* Free the identifier when update failed */ 213 free_parms.dir = aparms.dir; 214 free_parms.type = aparms.type; 215 free_parms.idx = aparms.idx; 216 tf_free_tbl_entry(tfp, &free_parms); 217 return rc; 218 } 219 return rc; 220 } 221 222 static int32_t 223 ulp_mapper_glb_field_tbl_get(struct bnxt_ulp_mapper_parms *parms, 224 uint32_t operand, 225 uint8_t *val) 226 { 227 uint32_t t_idx; 228 229 t_idx = parms->app_id << (BNXT_ULP_APP_ID_SHIFT + 230 BNXT_ULP_HDR_SIG_ID_SHIFT + 231 BNXT_ULP_GLB_FIELD_TBL_SHIFT); 232 t_idx += parms->class_tid << (BNXT_ULP_HDR_SIG_ID_SHIFT + 233 BNXT_ULP_GLB_FIELD_TBL_SHIFT); 234 t_idx += ULP_COMP_FLD_IDX_RD(parms, BNXT_ULP_CF_IDX_HDR_SIG_ID) << 235 BNXT_ULP_GLB_FIELD_TBL_SHIFT; 236 t_idx += operand; 237 238 if (t_idx >= BNXT_ULP_GLB_FIELD_TBL_SIZE) { 239 BNXT_TF_DBG(ERR, "Invalid hdr field index %x:%x:%x\n", 240 parms->class_tid, t_idx, operand); 241 *val = 0; 242 return -EINVAL; /* error */ 243 } 244 *val = ulp_glb_field_tbl[t_idx]; 245 return 0; 246 } 247 248 /* 249 * Get the size of the action property for a given index. 250 * 251 * idx [in] The index for the action property 252 * 253 * returns the size of the action property. 254 */ 255 static uint32_t 256 ulp_mapper_act_prop_size_get(uint32_t idx) 257 { 258 if (idx >= BNXT_ULP_ACT_PROP_IDX_LAST) 259 return 0; 260 return ulp_act_prop_map_table[idx]; 261 } 262 263 static struct bnxt_ulp_mapper_cond_info * 264 ulp_mapper_tmpl_reject_list_get(struct bnxt_ulp_mapper_parms *mparms, 265 uint32_t tid, 266 uint32_t *num_tbls, 267 enum bnxt_ulp_cond_list_opc *opc) 268 { 269 uint32_t idx; 270 const struct bnxt_ulp_template_device_tbls *dev_tbls; 271 272 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type]; 273 *num_tbls = dev_tbls->tmpl_list[tid].reject_info.cond_nums; 274 *opc = dev_tbls->tmpl_list[tid].reject_info.cond_list_opcode; 275 idx = dev_tbls->tmpl_list[tid].reject_info.cond_start_idx; 276 277 return &dev_tbls->cond_list[idx]; 278 } 279 280 static struct bnxt_ulp_mapper_cond_info * 281 ulp_mapper_tbl_execute_list_get(struct bnxt_ulp_mapper_parms *mparms, 282 struct bnxt_ulp_mapper_tbl_info *tbl, 283 uint32_t *num_tbls, 284 enum bnxt_ulp_cond_list_opc *opc) 285 { 286 uint32_t idx; 287 const struct bnxt_ulp_template_device_tbls *dev_tbls; 288 289 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type]; 290 *num_tbls = tbl->execute_info.cond_nums; 291 *opc = tbl->execute_info.cond_list_opcode; 292 idx = tbl->execute_info.cond_start_idx; 293 294 return &dev_tbls->cond_list[idx]; 295 } 296 297 /* 298 * Get a list of classifier tables that implement the flow 299 * Gets a device dependent list of tables that implement the class template id 300 * 301 * mparms [in] The mappers parms with data related to the flow. 302 * 303 * tid [in] The template id that matches the flow 304 * 305 * num_tbls [out] The number of classifier tables in the returned array 306 * 307 * returns An array of classifier tables to implement the flow, or NULL on 308 * error 309 */ 310 static struct bnxt_ulp_mapper_tbl_info * 311 ulp_mapper_tbl_list_get(struct bnxt_ulp_mapper_parms *mparms, 312 uint32_t tid, 313 uint32_t *num_tbls) 314 { 315 uint32_t idx; 316 const struct bnxt_ulp_template_device_tbls *dev_tbls; 317 318 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type]; 319 320 idx = dev_tbls->tmpl_list[tid].start_tbl_idx; 321 *num_tbls = dev_tbls->tmpl_list[tid].num_tbls; 322 323 return &dev_tbls->tbl_list[idx]; 324 } 325 326 /* 327 * Get the list of key fields that implement the flow. 328 * 329 * mparms [in] The mapper parms with information about the flow 330 * 331 * tbl [in] A single table instance to get the key fields from 332 * 333 * num_flds [out] The number of key fields in the returned array 334 * 335 * Returns array of Key fields, or NULL on error. 336 */ 337 static struct bnxt_ulp_mapper_key_info * 338 ulp_mapper_key_fields_get(struct bnxt_ulp_mapper_parms *mparms, 339 struct bnxt_ulp_mapper_tbl_info *tbl, 340 uint32_t *num_flds) 341 { 342 uint32_t idx; 343 const struct bnxt_ulp_template_device_tbls *dev_tbls; 344 345 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type]; 346 if (!dev_tbls->key_info_list) { 347 *num_flds = 0; 348 return NULL; 349 } 350 351 idx = tbl->key_start_idx; 352 *num_flds = tbl->key_num_fields; 353 354 return &dev_tbls->key_info_list[idx]; 355 } 356 357 /* 358 * Get the list of data fields that implement the flow. 359 * 360 * mparms [in] The mapper parms with information about the flow 361 * 362 * tbl [in] A single table instance to get the data fields from 363 * 364 * num_flds [out] The number of data fields in the returned array. 365 * 366 * num_encap_flds [out] The number of encap fields in the returned array. 367 * 368 * Returns array of data fields, or NULL on error. 369 */ 370 static struct bnxt_ulp_mapper_field_info * 371 ulp_mapper_result_fields_get(struct bnxt_ulp_mapper_parms *mparms, 372 struct bnxt_ulp_mapper_tbl_info *tbl, 373 uint32_t *num_flds, 374 uint32_t *num_encap_flds) 375 { 376 uint32_t idx; 377 const struct bnxt_ulp_template_device_tbls *dev_tbls; 378 379 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type]; 380 if (!dev_tbls->result_field_list) { 381 *num_flds = 0; 382 *num_encap_flds = 0; 383 return NULL; 384 } 385 386 idx = tbl->result_start_idx; 387 *num_flds = tbl->result_num_fields; 388 *num_encap_flds = tbl->encap_num_fields; 389 390 return &dev_tbls->result_field_list[idx]; 391 } 392 393 /* 394 * Get the list of ident fields that implement the flow 395 * 396 * tbl [in] A single table instance to get the ident fields from 397 * 398 * num_flds [out] The number of ident fields in the returned array 399 * 400 * returns array of ident fields, or NULL on error 401 */ 402 static struct bnxt_ulp_mapper_ident_info * 403 ulp_mapper_ident_fields_get(struct bnxt_ulp_mapper_parms *mparms, 404 struct bnxt_ulp_mapper_tbl_info *tbl, 405 uint32_t *num_flds) 406 { 407 uint32_t idx; 408 const struct bnxt_ulp_template_device_tbls *dev_tbls; 409 410 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type]; 411 if (!dev_tbls->ident_list) { 412 *num_flds = 0; 413 return NULL; 414 } 415 416 idx = tbl->ident_start_idx; 417 *num_flds = tbl->ident_nums; 418 419 return &dev_tbls->ident_list[idx]; 420 } 421 422 static enum tf_tbl_type 423 ulp_mapper_dyn_tbl_type_get(struct bnxt_ulp_mapper_parms *mparms, 424 struct bnxt_ulp_mapper_tbl_info *tbl, 425 struct ulp_blob *bdata, 426 uint16_t *out_len) 427 { 428 struct bnxt_ulp_device_params *d_params = mparms->device_params; 429 uint16_t blob_len = ulp_blob_data_len_get(bdata); 430 struct bnxt_ulp_dyn_size_map *size_map; 431 uint32_t i; 432 433 if (d_params->dynamic_sram_en) { 434 switch (tbl->resource_type) { 435 case TF_TBL_TYPE_ACT_ENCAP_8B: 436 case TF_TBL_TYPE_ACT_ENCAP_16B: 437 case TF_TBL_TYPE_ACT_ENCAP_32B: 438 case TF_TBL_TYPE_ACT_ENCAP_64B: 439 size_map = d_params->dyn_encap_sizes; 440 for (i = 0; i < d_params->dyn_encap_list_size; i++) { 441 if (blob_len <= size_map[i].slab_size) { 442 *out_len = size_map[i].slab_size; 443 return size_map[i].tbl_type; 444 } 445 } 446 break; 447 case TF_TBL_TYPE_ACT_MODIFY_8B: 448 case TF_TBL_TYPE_ACT_MODIFY_16B: 449 case TF_TBL_TYPE_ACT_MODIFY_32B: 450 case TF_TBL_TYPE_ACT_MODIFY_64B: 451 size_map = d_params->dyn_modify_sizes; 452 for (i = 0; i < d_params->dyn_modify_list_size; i++) { 453 if (blob_len <= size_map[i].slab_size) { 454 *out_len = size_map[i].slab_size; 455 return size_map[i].tbl_type; 456 } 457 } 458 break; 459 default: 460 break; 461 } 462 } 463 return tbl->resource_type; 464 } 465 466 static uint16_t 467 ulp_mapper_dyn_blob_size_get(struct bnxt_ulp_mapper_parms *mparms, 468 struct bnxt_ulp_mapper_tbl_info *tbl) 469 { 470 struct bnxt_ulp_device_params *d_params = mparms->device_params; 471 472 if (d_params->dynamic_sram_en) { 473 switch (tbl->resource_type) { 474 case TF_TBL_TYPE_ACT_ENCAP_8B: 475 case TF_TBL_TYPE_ACT_ENCAP_16B: 476 case TF_TBL_TYPE_ACT_ENCAP_32B: 477 case TF_TBL_TYPE_ACT_ENCAP_64B: 478 case TF_TBL_TYPE_ACT_MODIFY_8B: 479 case TF_TBL_TYPE_ACT_MODIFY_16B: 480 case TF_TBL_TYPE_ACT_MODIFY_32B: 481 case TF_TBL_TYPE_ACT_MODIFY_64B: 482 /* return max size */ 483 return BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS; 484 default: 485 break; 486 } 487 } else if (tbl->encap_num_fields) { 488 return BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS; 489 } 490 return tbl->result_bit_size; 491 } 492 493 static inline int32_t 494 ulp_mapper_tcam_entry_free(struct bnxt_ulp_context *ulp, 495 struct tf *tfp, 496 struct ulp_flow_db_res_params *res) 497 { 498 struct tf_free_tcam_entry_parms fparms = { 499 .dir = res->direction, 500 .tcam_tbl_type = res->resource_type, 501 .idx = (uint16_t)res->resource_hndl 502 }; 503 504 /* If HA is enabled, we may have to remap the TF Type */ 505 if (bnxt_ulp_cntxt_ha_enabled(ulp)) { 506 enum ulp_ha_mgr_region region; 507 int32_t rc; 508 509 switch (res->resource_type) { 510 case TF_TCAM_TBL_TYPE_WC_TCAM_HIGH: 511 case TF_TCAM_TBL_TYPE_WC_TCAM_LOW: 512 rc = ulp_ha_mgr_region_get(ulp, ®ion); 513 if (rc) 514 /* Log this, but assume region is correct */ 515 BNXT_TF_DBG(ERR, 516 "Unable to get HA region (%d)\n", 517 rc); 518 else 519 fparms.tcam_tbl_type = 520 (region == ULP_HA_REGION_LOW) ? 521 TF_TCAM_TBL_TYPE_WC_TCAM_LOW : 522 TF_TCAM_TBL_TYPE_WC_TCAM_HIGH; 523 break; 524 default: 525 break; 526 } 527 } 528 return tf_free_tcam_entry(tfp, &fparms); 529 } 530 531 static inline int32_t 532 ulp_mapper_index_entry_free(struct bnxt_ulp_context *ulp, 533 struct tf *tfp, 534 struct ulp_flow_db_res_params *res) 535 { 536 struct tf_free_tbl_entry_parms fparms = { 537 .dir = res->direction, 538 .type = res->resource_type, 539 .idx = (uint32_t)res->resource_hndl 540 }; 541 542 /* 543 * Just get the table scope, it will be ignored if not necessary 544 * by the tf_free_tbl_entry 545 */ 546 (void)bnxt_ulp_cntxt_tbl_scope_id_get(ulp, &fparms.tbl_scope_id); 547 548 return tf_free_tbl_entry(tfp, &fparms); 549 } 550 551 static inline int32_t 552 ulp_mapper_em_entry_free(struct bnxt_ulp_context *ulp, 553 struct tf *tfp, 554 struct ulp_flow_db_res_params *res) 555 { 556 struct tf_delete_em_entry_parms fparms = { 0 }; 557 int32_t rc; 558 559 fparms.dir = res->direction; 560 fparms.flow_handle = res->resource_hndl; 561 562 rc = bnxt_ulp_cntxt_tbl_scope_id_get(ulp, &fparms.tbl_scope_id); 563 if (rc) { 564 BNXT_TF_DBG(ERR, "Failed to get table scope\n"); 565 return -EINVAL; 566 } 567 568 return tf_delete_em_entry(tfp, &fparms); 569 } 570 571 static inline int32_t 572 ulp_mapper_ident_free(struct bnxt_ulp_context *ulp __rte_unused, 573 struct tf *tfp, 574 struct ulp_flow_db_res_params *res) 575 { 576 struct tf_free_identifier_parms fparms = { 577 .dir = res->direction, 578 .ident_type = res->resource_type, 579 .id = (uint16_t)res->resource_hndl 580 }; 581 582 return tf_free_identifier(tfp, &fparms); 583 } 584 585 static inline int32_t 586 ulp_mapper_mark_free(struct bnxt_ulp_context *ulp, 587 struct ulp_flow_db_res_params *res) 588 { 589 return ulp_mark_db_mark_del(ulp, 590 res->resource_type, 591 res->resource_hndl); 592 } 593 594 static inline int32_t 595 ulp_mapper_parent_flow_free(struct bnxt_ulp_context *ulp, 596 uint32_t parent_fid, 597 struct ulp_flow_db_res_params *res) 598 { 599 uint32_t pc_idx; 600 601 pc_idx = (uint32_t)res->resource_hndl; 602 603 /* reset the child flow bitset*/ 604 if (ulp_flow_db_pc_db_parent_flow_set(ulp, pc_idx, parent_fid, 0)) { 605 BNXT_TF_DBG(ERR, "error in reset parent flow bitset %x:%x\n", 606 pc_idx, parent_fid); 607 return -EINVAL; 608 } 609 return 0; 610 } 611 612 static inline int32_t 613 ulp_mapper_child_flow_free(struct bnxt_ulp_context *ulp, 614 uint32_t child_fid, 615 struct ulp_flow_db_res_params *res) 616 { 617 uint32_t pc_idx; 618 619 pc_idx = (uint32_t)res->resource_hndl; 620 621 /* reset the child flow bitset*/ 622 if (ulp_flow_db_pc_db_child_flow_set(ulp, pc_idx, child_fid, 0)) { 623 BNXT_TF_DBG(ERR, "error in resetting child flow bitset %x:%x\n", 624 pc_idx, child_fid); 625 return -EINVAL; 626 } 627 return 0; 628 } 629 630 /* 631 * Process the flow database opcode alloc action. 632 * returns 0 on success 633 */ 634 static int32_t 635 ulp_mapper_fdb_opc_alloc_rid(struct bnxt_ulp_mapper_parms *parms, 636 struct bnxt_ulp_mapper_tbl_info *tbl) 637 { 638 uint32_t rid = 0; 639 uint64_t val64; 640 int32_t rc = 0; 641 642 /* allocate a new fid */ 643 rc = ulp_flow_db_fid_alloc(parms->ulp_ctx, 644 BNXT_ULP_FDB_TYPE_RID, 645 0, &rid); 646 if (rc) { 647 BNXT_TF_DBG(ERR, 648 "Unable to allocate flow table entry\n"); 649 return -EINVAL; 650 } 651 /* Store the allocated fid in regfile*/ 652 val64 = rid; 653 rc = ulp_regfile_write(parms->regfile, tbl->fdb_operand, 654 tfp_cpu_to_be_64(val64)); 655 if (rc) { 656 BNXT_TF_DBG(ERR, "Write regfile[%d] failed\n", 657 tbl->fdb_operand); 658 ulp_flow_db_fid_free(parms->ulp_ctx, 659 BNXT_ULP_FDB_TYPE_RID, rid); 660 return -EINVAL; 661 } 662 return 0; 663 } 664 665 /* 666 * Process the flow database opcode action. 667 * returns 0 on success. 668 */ 669 static int32_t 670 ulp_mapper_fdb_opc_process(struct bnxt_ulp_mapper_parms *parms, 671 struct bnxt_ulp_mapper_tbl_info *tbl, 672 struct ulp_flow_db_res_params *fid_parms) 673 { 674 uint32_t push_fid; 675 uint64_t val64; 676 enum bnxt_ulp_fdb_type flow_type; 677 int32_t rc = 0; 678 679 switch (tbl->fdb_opcode) { 680 case BNXT_ULP_FDB_OPC_PUSH_FID: 681 push_fid = parms->fid; 682 flow_type = parms->flow_type; 683 break; 684 case BNXT_ULP_FDB_OPC_PUSH_RID_REGFILE: 685 /* get the fid from the regfile */ 686 rc = ulp_regfile_read(parms->regfile, tbl->fdb_operand, 687 &val64); 688 if (!rc) { 689 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", 690 tbl->fdb_operand); 691 return -EINVAL; 692 } 693 /* Use the extracted fid to update the flow resource */ 694 push_fid = (uint32_t)tfp_be_to_cpu_64(val64); 695 flow_type = BNXT_ULP_FDB_TYPE_RID; 696 break; 697 default: 698 return rc; /* Nothing to be done */ 699 } 700 701 /* Add the resource to the flow database */ 702 rc = ulp_flow_db_resource_add(parms->ulp_ctx, flow_type, 703 push_fid, fid_parms); 704 if (rc) 705 BNXT_TF_DBG(ERR, "Failed to add res to flow %x rc = %d\n", 706 push_fid, rc); 707 return rc; 708 } 709 710 /* 711 * Process the flow database opcode action. 712 * returns 0 on success. 713 */ 714 static int32_t 715 ulp_mapper_priority_opc_process(struct bnxt_ulp_mapper_parms *parms, 716 struct bnxt_ulp_mapper_tbl_info *tbl, 717 uint32_t *priority) 718 { 719 int32_t rc = 0; 720 721 switch (tbl->pri_opcode) { 722 case BNXT_ULP_PRI_OPC_NOT_USED: 723 *priority = 0; 724 break; 725 case BNXT_ULP_PRI_OPC_CONST: 726 *priority = tbl->pri_operand; 727 break; 728 case BNXT_ULP_PRI_OPC_APP_PRI: 729 *priority = parms->app_priority; 730 break; 731 default: 732 BNXT_TF_DBG(ERR, "Priority opcode not supported %d\n", 733 tbl->pri_opcode); 734 rc = -EINVAL; 735 break; 736 } 737 return rc; 738 } 739 740 /* 741 * Process the identifier list in the given table. 742 * Extract the ident from the table entry and 743 * write it to the reg file. 744 * returns 0 on success. 745 */ 746 static int32_t 747 ulp_mapper_tbl_ident_scan_ext(struct bnxt_ulp_mapper_parms *parms, 748 struct bnxt_ulp_mapper_tbl_info *tbl, 749 uint8_t *byte_data, 750 uint32_t byte_data_size, 751 enum bnxt_ulp_byte_order byte_order) 752 { 753 struct bnxt_ulp_mapper_ident_info *idents; 754 uint32_t i, num_idents = 0; 755 uint64_t val64; 756 757 /* validate the null arguments */ 758 if (!byte_data) { 759 BNXT_TF_DBG(ERR, "invalid argument\n"); 760 return -EINVAL; 761 } 762 763 /* Get the ident list and process each one */ 764 idents = ulp_mapper_ident_fields_get(parms, tbl, &num_idents); 765 766 for (i = 0; i < num_idents; i++) { 767 /* check the size of the buffer for validation */ 768 if ((idents[i].ident_bit_pos + idents[i].ident_bit_size) > 769 ULP_BYTE_2_BITS(byte_data_size) || 770 idents[i].ident_bit_size > ULP_BYTE_2_BITS(sizeof(val64))) { 771 BNXT_TF_DBG(ERR, "invalid offset or length %x:%x:%x\n", 772 idents[i].ident_bit_pos, 773 idents[i].ident_bit_size, 774 byte_data_size); 775 return -EINVAL; 776 } 777 val64 = 0; 778 if (byte_order == BNXT_ULP_BYTE_ORDER_LE) 779 ulp_bs_pull_lsb(byte_data, (uint8_t *)&val64, 780 sizeof(val64), 781 idents[i].ident_bit_pos, 782 idents[i].ident_bit_size); 783 else 784 ulp_bs_pull_msb(byte_data, (uint8_t *)&val64, 785 idents[i].ident_bit_pos, 786 idents[i].ident_bit_size); 787 788 /* Write it to the regfile, val64 is already in big-endian*/ 789 if (ulp_regfile_write(parms->regfile, 790 idents[i].regfile_idx, val64)) { 791 BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n", 792 idents[i].regfile_idx); 793 return -EINVAL; 794 } 795 } 796 return 0; 797 } 798 799 /* 800 * Process the identifier instruction and either store it in the flow database 801 * or return it in the val (if not NULL) on success. If val is NULL, the 802 * identifier is to be stored in the flow database. 803 */ 804 static int32_t 805 ulp_mapper_ident_process(struct bnxt_ulp_mapper_parms *parms, 806 struct bnxt_ulp_mapper_tbl_info *tbl, 807 struct bnxt_ulp_mapper_ident_info *ident, 808 uint16_t *val) 809 { 810 struct ulp_flow_db_res_params fid_parms; 811 uint64_t id = 0; 812 int32_t idx; 813 struct tf_alloc_identifier_parms iparms = { 0 }; 814 struct tf_free_identifier_parms free_parms = { 0 }; 815 struct tf *tfp; 816 int rc; 817 818 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); 819 if (!tfp) { 820 BNXT_TF_DBG(ERR, "Failed to get tf pointer\n"); 821 return -EINVAL; 822 } 823 824 idx = ident->regfile_idx; 825 826 iparms.ident_type = ident->ident_type; 827 iparms.dir = tbl->direction; 828 829 rc = tf_alloc_identifier(tfp, &iparms); 830 if (rc) { 831 BNXT_TF_DBG(ERR, "Alloc ident %s:%s failed.\n", 832 tf_dir_2_str(iparms.dir), 833 tf_ident_2_str(iparms.ident_type)); 834 return rc; 835 } 836 BNXT_TF_INF("Alloc ident %s:%s.success.\n", 837 tf_dir_2_str(iparms.dir), 838 tf_ident_2_str(iparms.ident_type)); 839 840 id = (uint64_t)tfp_cpu_to_be_64(iparms.id); 841 if (ulp_regfile_write(parms->regfile, idx, id)) { 842 BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n", idx); 843 rc = -EINVAL; 844 /* Need to free the identifier, so goto error */ 845 goto error; 846 } 847 848 /* Link the resource to the flow in the flow db */ 849 if (!val) { 850 memset(&fid_parms, 0, sizeof(fid_parms)); 851 fid_parms.direction = tbl->direction; 852 fid_parms.resource_func = ident->resource_func; 853 fid_parms.resource_type = ident->ident_type; 854 fid_parms.resource_hndl = iparms.id; 855 fid_parms.critical_resource = tbl->critical_resource; 856 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); 857 858 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 859 if (rc) { 860 BNXT_TF_DBG(ERR, "Failed to link res to flow rc = %d\n", 861 rc); 862 /* Need to free the identifier, so goto error */ 863 goto error; 864 } 865 } else { 866 *val = iparms.id; 867 } 868 return 0; 869 870 error: 871 /* Need to free the identifier */ 872 free_parms.dir = tbl->direction; 873 free_parms.ident_type = ident->ident_type; 874 free_parms.id = iparms.id; 875 876 (void)tf_free_identifier(tfp, &free_parms); 877 878 BNXT_TF_DBG(ERR, "Ident process failed for %s:%s\n", 879 ident->description, 880 tf_dir_2_str(tbl->direction)); 881 return rc; 882 } 883 884 /* 885 * Process the identifier instruction and extract it from result blob. 886 * Increment the identifier reference count and store it in the flow database. 887 */ 888 static int32_t 889 ulp_mapper_ident_extract(struct bnxt_ulp_mapper_parms *parms, 890 struct bnxt_ulp_mapper_tbl_info *tbl, 891 struct bnxt_ulp_mapper_ident_info *ident, 892 struct ulp_blob *res_blob) 893 { 894 struct ulp_flow_db_res_params fid_parms; 895 uint64_t id = 0; 896 uint32_t idx = 0; 897 struct tf_search_identifier_parms sparms = { 0 }; 898 struct tf_free_identifier_parms free_parms = { 0 }; 899 struct tf *tfp; 900 int rc; 901 902 /* Get the tfp from ulp context */ 903 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); 904 if (!tfp) { 905 BNXT_TF_DBG(ERR, "Failed to get tf pointer\n"); 906 return -EINVAL; 907 } 908 909 /* Extract the index from the result blob */ 910 rc = ulp_blob_pull(res_blob, (uint8_t *)&idx, sizeof(idx), 911 ident->ident_bit_pos, ident->ident_bit_size); 912 if (rc) { 913 BNXT_TF_DBG(ERR, "Failed to extract identifier from blob\n"); 914 return -EIO; 915 } 916 917 /* populate the search params and search identifier shadow table */ 918 sparms.ident_type = ident->ident_type; 919 sparms.dir = tbl->direction; 920 /* convert the idx into cpu format */ 921 sparms.search_id = tfp_be_to_cpu_32(idx); 922 923 /* Search identifier also increase the reference count */ 924 rc = tf_search_identifier(tfp, &sparms); 925 if (rc) { 926 BNXT_TF_DBG(ERR, "Search ident %s:%s:%x failed.\n", 927 tf_dir_2_str(sparms.dir), 928 tf_ident_2_str(sparms.ident_type), 929 sparms.search_id); 930 return rc; 931 } 932 BNXT_TF_INF("Search ident %s:%s:%x.success.\n", 933 tf_dir_2_str(sparms.dir), 934 tf_tbl_type_2_str(sparms.ident_type), 935 sparms.search_id); 936 937 /* Write it to the regfile */ 938 id = (uint64_t)tfp_cpu_to_be_64(sparms.search_id); 939 if (ulp_regfile_write(parms->regfile, ident->regfile_idx, id)) { 940 BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n", idx); 941 rc = -EINVAL; 942 /* Need to free the identifier, so goto error */ 943 goto error; 944 } 945 946 /* Link the resource to the flow in the flow db */ 947 memset(&fid_parms, 0, sizeof(fid_parms)); 948 fid_parms.direction = tbl->direction; 949 fid_parms.resource_func = ident->resource_func; 950 fid_parms.resource_type = ident->ident_type; 951 fid_parms.resource_hndl = sparms.search_id; 952 fid_parms.critical_resource = tbl->critical_resource; 953 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); 954 955 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 956 if (rc) { 957 BNXT_TF_DBG(ERR, "Failed to link res to flow rc = %d\n", 958 rc); 959 /* Need to free the identifier, so goto error */ 960 goto error; 961 } 962 963 return 0; 964 965 error: 966 /* Need to free the identifier */ 967 free_parms.dir = tbl->direction; 968 free_parms.ident_type = ident->ident_type; 969 free_parms.id = sparms.search_id; 970 (void)tf_free_identifier(tfp, &free_parms); 971 BNXT_TF_DBG(ERR, "Ident extract failed for %s:%s:%x\n", 972 ident->description, 973 tf_dir_2_str(tbl->direction), sparms.search_id); 974 return rc; 975 } 976 977 static int32_t 978 ulp_mapper_field_port_db_process(struct bnxt_ulp_mapper_parms *parms, 979 uint32_t port_id, 980 uint16_t val16, 981 uint8_t **val) 982 { 983 enum bnxt_ulp_port_table port_data = val16; 984 985 switch (port_data) { 986 case BNXT_ULP_PORT_TABLE_DRV_FUNC_PARENT_MAC: 987 if (ulp_port_db_parent_mac_addr_get(parms->ulp_ctx, port_id, 988 val)) { 989 BNXT_TF_DBG(ERR, "Invalid port id %u\n", port_id); 990 return -EINVAL; 991 } 992 break; 993 case BNXT_ULP_PORT_TABLE_DRV_FUNC_MAC: 994 if (ulp_port_db_drv_mac_addr_get(parms->ulp_ctx, port_id, 995 val)) { 996 BNXT_TF_DBG(ERR, "Invalid port id %u\n", port_id); 997 return -EINVAL; 998 } 999 break; 1000 case BNXT_ULP_PORT_TABLE_DRV_FUNC_PARENT_VNIC: 1001 if (ulp_port_db_parent_vnic_get(parms->ulp_ctx, port_id, 1002 val)) { 1003 BNXT_TF_DBG(ERR, "Invalid port id %u\n", port_id); 1004 return -EINVAL; 1005 } 1006 break; 1007 default: 1008 BNXT_TF_DBG(ERR, "Invalid port_data %d\n", port_data); 1009 return -EINVAL; 1010 } 1011 return 0; 1012 } 1013 1014 static int32_t 1015 ulp_mapper_field_src_process(struct bnxt_ulp_mapper_parms *parms, 1016 enum bnxt_ulp_field_src field_src, 1017 uint8_t *field_opr, 1018 enum tf_dir dir, 1019 uint8_t is_key, 1020 uint32_t bitlen, 1021 uint8_t **val, 1022 uint32_t *val_len, 1023 uint64_t *value) 1024 { 1025 struct bnxt_ulp_mapper_data *m; 1026 uint8_t bit; 1027 uint32_t port_id, val_size, field_size; 1028 uint16_t idx, size_idx, offset; 1029 uint32_t bytelen = ULP_BITS_2_BYTE(bitlen); 1030 uint8_t *buffer; 1031 uint64_t lregval; 1032 bool shared; 1033 1034 *val_len = bitlen; 1035 *value = 0; 1036 /* Perform the action */ 1037 switch (field_src) { 1038 case BNXT_ULP_FIELD_SRC_ZERO: 1039 *val = mapper_fld_zeros; 1040 break; 1041 case BNXT_ULP_FIELD_SRC_CONST: 1042 *val = field_opr; 1043 break; 1044 case BNXT_ULP_FIELD_SRC_ONES: 1045 *val = mapper_fld_ones; 1046 *value = 1; 1047 break; 1048 case BNXT_ULP_FIELD_SRC_CF: 1049 if (!ulp_operand_read(field_opr, 1050 (uint8_t *)&idx, sizeof(uint16_t))) { 1051 BNXT_TF_DBG(ERR, "CF operand read failed\n"); 1052 return -EINVAL; 1053 } 1054 idx = tfp_be_to_cpu_16(idx); 1055 if (idx >= BNXT_ULP_CF_IDX_LAST || bytelen > sizeof(uint64_t)) { 1056 BNXT_TF_DBG(ERR, "comp field [%d] read oob %d\n", idx, 1057 bytelen); 1058 return -EINVAL; 1059 } 1060 buffer = (uint8_t *)&parms->comp_fld[idx]; 1061 *val = &buffer[sizeof(uint64_t) - bytelen]; 1062 *value = ULP_COMP_FLD_IDX_RD(parms, idx); 1063 break; 1064 case BNXT_ULP_FIELD_SRC_RF: 1065 if (!ulp_operand_read(field_opr, 1066 (uint8_t *)&idx, sizeof(uint16_t))) { 1067 BNXT_TF_DBG(ERR, "RF operand read failed\n"); 1068 return -EINVAL; 1069 } 1070 1071 idx = tfp_be_to_cpu_16(idx); 1072 /* Uninitialized regfile entries return 0 */ 1073 if (!ulp_regfile_read(parms->regfile, idx, &lregval) || 1074 sizeof(uint64_t) < bytelen) { 1075 BNXT_TF_DBG(ERR, "regfile[%d] read oob %u\n", idx, 1076 bytelen); 1077 return -EINVAL; 1078 } 1079 buffer = (uint8_t *)&parms->regfile->entry[idx].data; 1080 *val = &buffer[sizeof(uint64_t) - bytelen]; 1081 *value = tfp_be_to_cpu_64(lregval); 1082 break; 1083 case BNXT_ULP_FIELD_SRC_ACT_PROP: 1084 if (!ulp_operand_read(field_opr, 1085 (uint8_t *)&idx, sizeof(uint16_t))) { 1086 BNXT_TF_DBG(ERR, "Action operand read failed\n"); 1087 return -EINVAL; 1088 } 1089 idx = tfp_be_to_cpu_16(idx); 1090 if (idx >= BNXT_ULP_ACT_PROP_IDX_LAST) { 1091 BNXT_TF_DBG(ERR, "act_prop[%d] oob\n", idx); 1092 return -EINVAL; 1093 } 1094 buffer = &parms->act_prop->act_details[idx]; 1095 field_size = ulp_mapper_act_prop_size_get(idx); 1096 if (bytelen > field_size) { 1097 BNXT_TF_DBG(ERR, "act_prop[%d] field size small %u\n", 1098 idx, field_size); 1099 return -EINVAL; 1100 } 1101 *val = &buffer[field_size - bytelen]; 1102 break; 1103 case BNXT_ULP_FIELD_SRC_ACT_PROP_SZ: 1104 if (!ulp_operand_read(field_opr, 1105 (uint8_t *)&idx, sizeof(uint16_t))) { 1106 BNXT_TF_DBG(ERR, "Action sz operand read failed\n"); 1107 return -EINVAL; 1108 } 1109 idx = tfp_be_to_cpu_16(idx); 1110 1111 if (idx >= BNXT_ULP_ACT_PROP_IDX_LAST) { 1112 BNXT_TF_DBG(ERR, "act_prop_sz[%d] oob\n", idx); 1113 return -EINVAL; 1114 } 1115 *val = &parms->act_prop->act_details[idx]; 1116 1117 /* get the size index next */ 1118 if (!ulp_operand_read(&field_opr[sizeof(uint16_t)], 1119 (uint8_t *)&size_idx, sizeof(uint16_t))) { 1120 BNXT_TF_DBG(ERR, "Action sz operand read failed\n"); 1121 return -EINVAL; 1122 } 1123 size_idx = tfp_be_to_cpu_16(size_idx); 1124 if (size_idx >= BNXT_ULP_ACT_PROP_IDX_LAST) { 1125 BNXT_TF_DBG(ERR, "act_prop[%d] oob\n", size_idx); 1126 return -EINVAL; 1127 } 1128 memcpy(&val_size, &parms->act_prop->act_details[size_idx], 1129 sizeof(uint32_t)); 1130 val_size = tfp_be_to_cpu_32(val_size); 1131 *val_len = ULP_BYTE_2_BITS(val_size); 1132 break; 1133 case BNXT_ULP_FIELD_SRC_GLB_RF: 1134 if (!ulp_operand_read(field_opr, 1135 (uint8_t *)&idx, sizeof(uint16_t))) { 1136 BNXT_TF_DBG(ERR, "Global regfile read failed\n"); 1137 return -EINVAL; 1138 } 1139 idx = tfp_be_to_cpu_16(idx); 1140 if (ulp_mapper_glb_resource_read(parms->mapper_data, 1141 dir, idx, &lregval, &shared) || 1142 sizeof(uint64_t) < bytelen) { 1143 BNXT_TF_DBG(ERR, "Global regfile[%d] read failed %u\n", 1144 idx, bytelen); 1145 return -EINVAL; 1146 } 1147 m = parms->mapper_data; 1148 buffer = (uint8_t *)&m->glb_res_tbl[dir][idx].resource_hndl; 1149 *val = &buffer[sizeof(uint64_t) - bytelen]; 1150 *value = tfp_be_to_cpu_64(lregval); 1151 break; 1152 case BNXT_ULP_FIELD_SRC_HF: 1153 case BNXT_ULP_FIELD_SRC_SUB_HF: 1154 if (!ulp_operand_read(field_opr, 1155 (uint8_t *)&idx, sizeof(uint16_t))) { 1156 BNXT_TF_DBG(ERR, "Header field read failed\n"); 1157 return -EINVAL; 1158 } 1159 idx = tfp_be_to_cpu_16(idx); 1160 /* get the index from the global field list */ 1161 if (ulp_mapper_glb_field_tbl_get(parms, idx, &bit)) { 1162 BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n", 1163 idx); 1164 return -EINVAL; 1165 } 1166 if (is_key) 1167 buffer = parms->hdr_field[bit].spec; 1168 else 1169 buffer = parms->hdr_field[bit].mask; 1170 1171 field_size = parms->hdr_field[bit].size; 1172 if (bytelen > field_size) { 1173 BNXT_TF_DBG(ERR, "Hdr field[%d] size small %u\n", 1174 bit, field_size); 1175 return -EINVAL; 1176 } 1177 if (field_src == BNXT_ULP_FIELD_SRC_HF) { 1178 *val = &buffer[field_size - bytelen]; 1179 } else { 1180 /* get the offset next */ 1181 if (!ulp_operand_read(&field_opr[sizeof(uint16_t)], 1182 (uint8_t *)&offset, 1183 sizeof(uint16_t))) { 1184 BNXT_TF_DBG(ERR, "Hdr fld size read failed\n"); 1185 return -EINVAL; 1186 } 1187 offset = tfp_be_to_cpu_16(offset); 1188 offset = ULP_BITS_2_BYTE_NR(offset); 1189 if ((offset + bytelen) > field_size) { 1190 BNXT_TF_DBG(ERR, "Hdr field[%d] oob\n", bit); 1191 return -EINVAL; 1192 } 1193 *val = &buffer[offset]; 1194 } 1195 break; 1196 case BNXT_ULP_FIELD_SRC_HDR_BIT: 1197 if (!ulp_operand_read(field_opr, 1198 (uint8_t *)&lregval, sizeof(uint64_t))) { 1199 BNXT_TF_DBG(ERR, "Header bit read failed\n"); 1200 return -EINVAL; 1201 } 1202 lregval = tfp_be_to_cpu_64(lregval); 1203 if (ULP_BITMAP_ISSET(parms->hdr_bitmap->bits, lregval)) { 1204 *val = mapper_fld_one; 1205 *value = 1; 1206 } else { 1207 *val = mapper_fld_zeros; 1208 } 1209 break; 1210 case BNXT_ULP_FIELD_SRC_ACT_BIT: 1211 if (!ulp_operand_read(field_opr, 1212 (uint8_t *)&lregval, sizeof(uint64_t))) { 1213 BNXT_TF_DBG(ERR, "Action bit read failed\n"); 1214 return -EINVAL; 1215 } 1216 lregval = tfp_be_to_cpu_64(lregval); 1217 if (ULP_BITMAP_ISSET(parms->act_bitmap->bits, lregval)) { 1218 *val = mapper_fld_one; 1219 *value = 1; 1220 } else { 1221 *val = mapper_fld_zeros; 1222 } 1223 break; 1224 case BNXT_ULP_FIELD_SRC_FIELD_BIT: 1225 if (!ulp_operand_read(field_opr, 1226 (uint8_t *)&idx, sizeof(uint16_t))) { 1227 BNXT_TF_DBG(ERR, "Field bit read failed\n"); 1228 return -EINVAL; 1229 } 1230 idx = tfp_be_to_cpu_16(idx); 1231 /* get the index from the global field list */ 1232 if (ulp_mapper_glb_field_tbl_get(parms, idx, &bit)) { 1233 BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n", 1234 idx); 1235 return -EINVAL; 1236 } 1237 if (ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit)) { 1238 *val = mapper_fld_one; 1239 *value = 1; 1240 } else { 1241 *val = mapper_fld_zeros; 1242 } 1243 break; 1244 case BNXT_ULP_FIELD_SRC_PORT_TABLE: 1245 /* The port id is present in the comp field list */ 1246 port_id = ULP_COMP_FLD_IDX_RD(parms, 1247 BNXT_ULP_CF_IDX_DEV_PORT_ID); 1248 /* get the port table enum */ 1249 if (!ulp_operand_read(field_opr, 1250 (uint8_t *)&idx, sizeof(uint16_t))) { 1251 BNXT_TF_DBG(ERR, "Port table enum read failed\n"); 1252 return -EINVAL; 1253 } 1254 idx = tfp_be_to_cpu_16(idx); 1255 if (ulp_mapper_field_port_db_process(parms, port_id, idx, 1256 val)) { 1257 BNXT_TF_DBG(ERR, "field port table failed\n"); 1258 return -EINVAL; 1259 } 1260 break; 1261 case BNXT_ULP_FIELD_SRC_ENC_HDR_BIT: 1262 if (!ulp_operand_read(field_opr, 1263 (uint8_t *)&lregval, sizeof(uint64_t))) { 1264 BNXT_TF_DBG(ERR, "Header bit read failed\n"); 1265 return -EINVAL; 1266 } 1267 lregval = tfp_be_to_cpu_64(lregval); 1268 if (ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits, lregval)) { 1269 *val = mapper_fld_one; 1270 *value = 1; 1271 } else { 1272 *val = mapper_fld_zeros; 1273 } 1274 break; 1275 case BNXT_ULP_FIELD_SRC_ENC_FIELD: 1276 if (!ulp_operand_read(field_opr, 1277 (uint8_t *)&idx, sizeof(uint16_t))) { 1278 BNXT_TF_DBG(ERR, "Header field read failed\n"); 1279 return -EINVAL; 1280 } 1281 idx = tfp_be_to_cpu_16(idx); 1282 /* get the index from the global field list */ 1283 if (idx >= BNXT_ULP_ENC_FIELD_LAST) { 1284 BNXT_TF_DBG(ERR, "invalid encap field tbl idx %d\n", 1285 idx); 1286 return -EINVAL; 1287 } 1288 buffer = parms->enc_field[idx].spec; 1289 field_size = parms->enc_field[idx].size; 1290 if (bytelen > field_size) { 1291 BNXT_TF_DBG(ERR, "Encap field[%d] size small %u\n", 1292 idx, field_size); 1293 return -EINVAL; 1294 } 1295 *val = &buffer[field_size - bytelen]; 1296 break; 1297 case BNXT_ULP_FIELD_SRC_SKIP: 1298 /* do nothing */ 1299 *val = mapper_fld_zeros; 1300 *val_len = 0; 1301 break; 1302 case BNXT_ULP_FIELD_SRC_REJECT: 1303 return -EINVAL; 1304 default: 1305 BNXT_TF_DBG(ERR, "invalid field opcode 0x%x\n", field_src); 1306 return -EINVAL; 1307 } 1308 return 0; 1309 } 1310 1311 static int32_t ulp_mapper_field_buffer_eval(uint8_t *buffer, uint32_t bitlen, 1312 uint64_t *output) 1313 { 1314 uint16_t val_16; 1315 uint32_t val_32; 1316 uint64_t val_64; 1317 uint32_t bytelen; 1318 1319 bytelen = ULP_BITS_2_BYTE(bitlen); 1320 if (bytelen == sizeof(uint8_t)) { 1321 *output = *((uint8_t *)buffer); 1322 } else if (bytelen == sizeof(uint16_t)) { 1323 val_16 = *((uint16_t *)buffer); 1324 *output = tfp_be_to_cpu_16(val_16); 1325 } else if (bytelen == sizeof(uint32_t)) { 1326 val_32 = *((uint32_t *)buffer); 1327 *output = tfp_be_to_cpu_32(val_32); 1328 } else if (bytelen == sizeof(val_64)) { 1329 val_64 = *((uint64_t *)buffer); 1330 *output = tfp_be_to_cpu_64(val_64); 1331 } else { 1332 *output = 0; 1333 return -EINVAL; 1334 } 1335 return 0; 1336 } 1337 1338 static int32_t ulp_mapper_field_blob_write(enum bnxt_ulp_field_src fld_src, 1339 struct ulp_blob *blob, 1340 uint8_t *val, 1341 uint32_t val_len, 1342 uint8_t **out_val) 1343 { 1344 if (fld_src == BNXT_ULP_FIELD_SRC_ZERO) { 1345 if (ulp_blob_pad_push(blob, val_len) < 0) { 1346 BNXT_TF_DBG(ERR, "too large for blob\n"); 1347 return -EINVAL; 1348 } 1349 } else if (fld_src == BNXT_ULP_FIELD_SRC_ACT_PROP_SZ) { 1350 if (ulp_blob_push_encap(blob, val, val_len) < 0) { 1351 BNXT_TF_DBG(ERR, "encap blob push failed\n"); 1352 return -EINVAL; 1353 } 1354 } else if (fld_src == BNXT_ULP_FIELD_SRC_SKIP) { 1355 /* do nothing */ 1356 } else { 1357 if (!ulp_blob_push(blob, val, val_len)) { 1358 BNXT_TF_DBG(ERR, "push of val1 failed\n"); 1359 return -EINVAL; 1360 } 1361 } 1362 *out_val = val; 1363 return 0; 1364 } 1365 1366 static int32_t 1367 ulp_mapper_field_opc_process(struct bnxt_ulp_mapper_parms *parms, 1368 enum tf_dir dir, 1369 struct bnxt_ulp_mapper_field_info *fld, 1370 struct ulp_blob *blob, 1371 uint8_t is_key, 1372 const char *name) 1373 { 1374 uint16_t write_idx = blob->write_idx; 1375 uint8_t *val = NULL, *val1, *val2, *val3; 1376 uint32_t val_len = 0, val1_len = 0, val2_len = 0, val3_len = 0; 1377 uint8_t process_src1 = 0, process_src2 = 0, process_src3 = 0; 1378 uint8_t eval_src1 = 0, eval_src2 = 0, eval_src3 = 0; 1379 uint64_t val_int = 0, val1_int = 0, val2_int = 0, val3_int = 0; 1380 uint64_t value1 = 0, value2 = 0, value3 = 0; 1381 int32_t rc = 0; 1382 1383 /* prepare the field source and values */ 1384 switch (fld->field_opc) { 1385 case BNXT_ULP_FIELD_OPC_SRC1: 1386 process_src1 = 1; 1387 break; 1388 case BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3: 1389 process_src1 = 1; 1390 break; 1391 case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2_OR_SRC3: 1392 case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2_OR_SRC3: 1393 process_src3 = 1; 1394 eval_src3 = 1; 1395 process_src1 = 1; 1396 process_src2 = 1; 1397 eval_src1 = 1; 1398 eval_src2 = 1; 1399 break; 1400 case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2: 1401 case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2: 1402 case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2_POST: 1403 case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2_POST: 1404 case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2: 1405 case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2: 1406 process_src1 = 1; 1407 process_src2 = 1; 1408 eval_src1 = 1; 1409 eval_src2 = 1; 1410 break; 1411 default: 1412 break; 1413 } 1414 1415 /* process the src1 opcode */ 1416 if (process_src1) { 1417 if (ulp_mapper_field_src_process(parms, fld->field_src1, 1418 fld->field_opr1, dir, is_key, 1419 fld->field_bit_size, &val1, 1420 &val1_len, &value1)) { 1421 BNXT_TF_DBG(ERR, "fld src1 process failed\n"); 1422 goto error; 1423 } 1424 if (eval_src1) { 1425 if (ulp_mapper_field_buffer_eval(val1, val1_len, 1426 &val1_int)) { 1427 BNXT_TF_DBG(ERR, "fld src1 eval failed\n"); 1428 goto error; 1429 } 1430 } 1431 } 1432 1433 /* for "if then clause" set the correct process */ 1434 if (fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3) { 1435 if (value1) 1436 process_src2 = 1; 1437 else 1438 process_src3 = 1; 1439 } 1440 1441 /* process src2 opcode */ 1442 if (process_src2) { 1443 if (ulp_mapper_field_src_process(parms, fld->field_src2, 1444 fld->field_opr2, dir, is_key, 1445 fld->field_bit_size, &val2, 1446 &val2_len, &value2)) { 1447 BNXT_TF_DBG(ERR, "fld src2 process failed\n"); 1448 goto error; 1449 } 1450 if (eval_src2) { 1451 if (ulp_mapper_field_buffer_eval(val2, val2_len, 1452 &val2_int)) { 1453 BNXT_TF_DBG(ERR, "fld src2 eval failed\n"); 1454 goto error; 1455 } 1456 } 1457 } 1458 1459 /* process src3 opcode */ 1460 if (process_src3) { 1461 if (ulp_mapper_field_src_process(parms, fld->field_src3, 1462 fld->field_opr3, dir, is_key, 1463 fld->field_bit_size, &val3, 1464 &val3_len, &value3)) { 1465 BNXT_TF_DBG(ERR, "fld src3 process failed\n"); 1466 goto error; 1467 } 1468 if (eval_src3) { 1469 if (ulp_mapper_field_buffer_eval(val3, val3_len, 1470 &val3_int)) { 1471 BNXT_TF_DBG(ERR, "fld src3 eval failed\n"); 1472 goto error; 1473 } 1474 } 1475 } 1476 1477 val_len = fld->field_bit_size; 1478 /* process the field opcodes */ 1479 switch (fld->field_opc) { 1480 case BNXT_ULP_FIELD_OPC_SRC1: 1481 rc = ulp_mapper_field_blob_write(fld->field_src1, 1482 blob, val1, val1_len, &val); 1483 val_len = val1_len; 1484 break; 1485 case BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3: 1486 if (value1) { 1487 rc = ulp_mapper_field_blob_write(fld->field_src2, blob, 1488 val2, val2_len, &val); 1489 val_len = val2_len; 1490 } else { 1491 rc = ulp_mapper_field_blob_write(fld->field_src3, blob, 1492 val3, val3_len, &val); 1493 val_len = val3_len; 1494 } 1495 break; 1496 case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2: 1497 case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2_POST: 1498 val_int = val1_int + val2_int; 1499 val_int = tfp_cpu_to_be_64(val_int); 1500 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); 1501 if (!val) 1502 rc = -EINVAL; 1503 break; 1504 case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2: 1505 case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2_POST: 1506 val_int = val1_int - val2_int; 1507 val_int = tfp_cpu_to_be_64(val_int); 1508 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); 1509 if (!val) 1510 rc = -EINVAL; 1511 break; 1512 case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2: 1513 val_int = val1_int | val2_int; 1514 val_int = tfp_cpu_to_be_64(val_int); 1515 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); 1516 if (!val) 1517 rc = -EINVAL; 1518 break; 1519 case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2_OR_SRC3: 1520 val_int = val1_int | val2_int | val3_int; 1521 val_int = tfp_cpu_to_be_64(val_int); 1522 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); 1523 if (!val) 1524 rc = -EINVAL; 1525 break; 1526 case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2: 1527 val_int = val1_int & val2_int; 1528 val_int = tfp_cpu_to_be_64(val_int); 1529 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); 1530 if (!val) 1531 rc = -EINVAL; 1532 break; 1533 case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2_OR_SRC3: 1534 val_int = val1_int & (val2_int | val3_int); 1535 val_int = tfp_cpu_to_be_64(val_int); 1536 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size); 1537 if (!val) 1538 rc = -EINVAL; 1539 break; 1540 case BNXT_ULP_FIELD_OPC_SKIP: 1541 break; 1542 default: 1543 BNXT_TF_DBG(ERR, "Invalid fld opcode %u\n", fld->field_opc); 1544 rc = -EINVAL; 1545 break; 1546 } 1547 1548 if (!rc) { 1549 return rc; 1550 } 1551 error: 1552 BNXT_TF_DBG(ERR, "Error in %s:%s process %u:%u\n", name, 1553 fld->description, (val) ? write_idx : 0, val_len); 1554 return -EINVAL; 1555 } 1556 1557 /* 1558 * Result table process and fill the result blob. 1559 * data [out] - the result blob data 1560 */ 1561 static int32_t 1562 ulp_mapper_tbl_result_build(struct bnxt_ulp_mapper_parms *parms, 1563 struct bnxt_ulp_mapper_tbl_info *tbl, 1564 struct ulp_blob *data, 1565 const char *name) 1566 { 1567 struct bnxt_ulp_mapper_field_info *dflds; 1568 uint32_t i = 0, num_flds = 0, encap_flds = 0; 1569 struct ulp_blob encap_blob; 1570 int32_t rc = 0; 1571 1572 /* Get the result field list */ 1573 dflds = ulp_mapper_result_fields_get(parms, tbl, &num_flds, 1574 &encap_flds); 1575 1576 /* validate the result field list counts */ 1577 if ((tbl->resource_func == BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE && 1578 (!num_flds && !encap_flds)) || !dflds || 1579 (tbl->resource_func != BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE && 1580 (!num_flds || encap_flds))) { 1581 BNXT_TF_DBG(ERR, "Failed to get data fields %x:%x\n", 1582 num_flds, encap_flds); 1583 return -EINVAL; 1584 } 1585 1586 /* process the result fields */ 1587 for (i = 0; i < num_flds; i++) { 1588 rc = ulp_mapper_field_opc_process(parms, tbl->direction, 1589 &dflds[i], data, 0, name); 1590 if (rc) { 1591 BNXT_TF_DBG(ERR, "result field processing failed\n"); 1592 return rc; 1593 } 1594 } 1595 1596 /* process encap fields if any */ 1597 if (encap_flds) { 1598 uint32_t pad = 0; 1599 /* Initialize the encap blob */ 1600 if (!tbl->record_size && 1601 !parms->device_params->dynamic_sram_en) { 1602 BNXT_TF_DBG(ERR, "Encap tbl record size incorrect\n"); 1603 return -EINVAL; 1604 } 1605 if (!ulp_blob_init(&encap_blob, 1606 ULP_BYTE_2_BITS(tbl->record_size), 1607 parms->device_params->encap_byte_order)) { 1608 BNXT_TF_DBG(ERR, "blob inits failed.\n"); 1609 return -EINVAL; 1610 } 1611 for (; i < encap_flds; i++) { 1612 rc = ulp_mapper_field_opc_process(parms, tbl->direction, 1613 &dflds[i], 1614 &encap_blob, 0, name); 1615 if (rc) { 1616 BNXT_TF_DBG(ERR, 1617 "encap field processing failed\n"); 1618 return rc; 1619 } 1620 } 1621 /* add the dynamic pad push */ 1622 if (parms->device_params->dynamic_sram_en) { 1623 uint16_t rec_s = ULP_BYTE_2_BITS(tbl->record_size); 1624 1625 (void)ulp_mapper_dyn_tbl_type_get(parms, tbl, 1626 &encap_blob, &rec_s); 1627 pad = rec_s - ulp_blob_data_len_get(&encap_blob); 1628 } else { 1629 pad = ULP_BYTE_2_BITS(tbl->record_size) - 1630 ulp_blob_data_len_get(&encap_blob); 1631 } 1632 if (ulp_blob_pad_push(&encap_blob, pad) < 0) { 1633 BNXT_TF_DBG(ERR, "encap buffer padding failed\n"); 1634 return -EINVAL; 1635 } 1636 1637 1638 /* perform the 64 bit byte swap */ 1639 ulp_blob_perform_64B_byte_swap(&encap_blob); 1640 /* Append encap blob to the result blob */ 1641 rc = ulp_blob_buffer_copy(data, &encap_blob); 1642 if (rc) { 1643 BNXT_TF_DBG(ERR, "encap buffer copy failed\n"); 1644 return rc; 1645 } 1646 } 1647 return rc; 1648 } 1649 1650 static int32_t 1651 ulp_mapper_mark_gfid_process(struct bnxt_ulp_mapper_parms *parms, 1652 struct bnxt_ulp_mapper_tbl_info *tbl, 1653 uint64_t flow_id) 1654 { 1655 struct ulp_flow_db_res_params fid_parms; 1656 uint32_t mark, gfid, mark_flag; 1657 enum bnxt_ulp_mark_db_opc mark_op = tbl->mark_db_opcode; 1658 int32_t rc = 0; 1659 1660 if (mark_op == BNXT_ULP_MARK_DB_OPC_NOP || 1661 !(mark_op == BNXT_ULP_MARK_DB_OPC_PUSH_IF_MARK_ACTION && 1662 ULP_BITMAP_ISSET(parms->act_bitmap->bits, 1663 BNXT_ULP_ACT_BIT_MARK))) 1664 return rc; /* no need to perform gfid process */ 1665 1666 /* Get the mark id details from action property */ 1667 memcpy(&mark, &parms->act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_MARK], 1668 sizeof(mark)); 1669 mark = tfp_be_to_cpu_32(mark); 1670 1671 TF_GET_GFID_FROM_FLOW_ID(flow_id, gfid); 1672 mark_flag = BNXT_ULP_MARK_GLOBAL_HW_FID; 1673 1674 rc = ulp_mark_db_mark_add(parms->ulp_ctx, mark_flag, 1675 gfid, mark); 1676 if (rc) { 1677 BNXT_TF_DBG(ERR, "Failed to add mark to flow\n"); 1678 return rc; 1679 } 1680 fid_parms.direction = tbl->direction; 1681 fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_HW_FID; 1682 fid_parms.critical_resource = tbl->critical_resource; 1683 fid_parms.resource_type = mark_flag; 1684 fid_parms.resource_hndl = gfid; 1685 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); 1686 1687 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 1688 if (rc) 1689 BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc); 1690 return rc; 1691 } 1692 1693 static int32_t 1694 ulp_mapper_mark_act_ptr_process(struct bnxt_ulp_mapper_parms *parms, 1695 struct bnxt_ulp_mapper_tbl_info *tbl) 1696 { 1697 struct ulp_flow_db_res_params fid_parms; 1698 uint32_t act_idx, mark, mark_flag; 1699 uint64_t val64; 1700 enum bnxt_ulp_mark_db_opc mark_op = tbl->mark_db_opcode; 1701 int32_t rc = 0; 1702 1703 if (mark_op == BNXT_ULP_MARK_DB_OPC_NOP || 1704 !(mark_op == BNXT_ULP_MARK_DB_OPC_PUSH_IF_MARK_ACTION && 1705 ULP_BITMAP_ISSET(parms->act_bitmap->bits, 1706 BNXT_ULP_ACT_BIT_MARK))) 1707 return rc; /* no need to perform mark action process */ 1708 1709 /* Get the mark id details from action property */ 1710 memcpy(&mark, &parms->act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_MARK], 1711 sizeof(mark)); 1712 mark = tfp_be_to_cpu_32(mark); 1713 1714 if (!ulp_regfile_read(parms->regfile, 1715 BNXT_ULP_RF_IDX_MAIN_ACTION_PTR, 1716 &val64)) { 1717 BNXT_TF_DBG(ERR, "read action ptr main failed\n"); 1718 return -EINVAL; 1719 } 1720 act_idx = tfp_be_to_cpu_64(val64); 1721 mark_flag = BNXT_ULP_MARK_LOCAL_HW_FID; 1722 rc = ulp_mark_db_mark_add(parms->ulp_ctx, mark_flag, 1723 act_idx, mark); 1724 if (rc) { 1725 BNXT_TF_DBG(ERR, "Failed to add mark to flow\n"); 1726 return rc; 1727 } 1728 fid_parms.direction = tbl->direction; 1729 fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_HW_FID; 1730 fid_parms.critical_resource = tbl->critical_resource; 1731 fid_parms.resource_type = mark_flag; 1732 fid_parms.resource_hndl = act_idx; 1733 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); 1734 1735 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 1736 if (rc) 1737 BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc); 1738 return rc; 1739 } 1740 1741 static int32_t 1742 ulp_mapper_mark_vfr_idx_process(struct bnxt_ulp_mapper_parms *parms, 1743 struct bnxt_ulp_mapper_tbl_info *tbl) 1744 { 1745 struct ulp_flow_db_res_params fid_parms; 1746 uint32_t act_idx, mark, mark_flag; 1747 uint64_t val64; 1748 enum bnxt_ulp_mark_db_opc mark_op = tbl->mark_db_opcode; 1749 int32_t rc = 0; 1750 1751 if (mark_op == BNXT_ULP_MARK_DB_OPC_NOP || 1752 mark_op == BNXT_ULP_MARK_DB_OPC_PUSH_IF_MARK_ACTION) 1753 return rc; /* no need to perform mark action process */ 1754 1755 /* Get the mark id details from the computed field of dev port id */ 1756 mark = ULP_COMP_FLD_IDX_RD(parms, BNXT_ULP_CF_IDX_DEV_PORT_ID); 1757 1758 /* Get the main action pointer */ 1759 if (!ulp_regfile_read(parms->regfile, 1760 BNXT_ULP_RF_IDX_MAIN_ACTION_PTR, 1761 &val64)) { 1762 BNXT_TF_DBG(ERR, "read action ptr main failed\n"); 1763 return -EINVAL; 1764 } 1765 act_idx = tfp_be_to_cpu_64(val64); 1766 1767 /* Set the mark flag to local fid and vfr flag */ 1768 mark_flag = BNXT_ULP_MARK_LOCAL_HW_FID | BNXT_ULP_MARK_VFR_ID; 1769 1770 rc = ulp_mark_db_mark_add(parms->ulp_ctx, mark_flag, 1771 act_idx, mark); 1772 if (rc) { 1773 BNXT_TF_DBG(ERR, "Failed to add mark to flow\n"); 1774 return rc; 1775 } 1776 fid_parms.direction = tbl->direction; 1777 fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_HW_FID; 1778 fid_parms.critical_resource = tbl->critical_resource; 1779 fid_parms.resource_type = mark_flag; 1780 fid_parms.resource_hndl = act_idx; 1781 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); 1782 1783 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 1784 if (rc) 1785 BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc); 1786 return rc; 1787 } 1788 1789 /* Tcam table scan the identifier list and allocate each identifier */ 1790 static int32_t 1791 ulp_mapper_tcam_tbl_scan_ident_alloc(struct bnxt_ulp_mapper_parms *parms, 1792 struct bnxt_ulp_mapper_tbl_info *tbl) 1793 { 1794 struct bnxt_ulp_mapper_ident_info *idents; 1795 uint32_t num_idents; 1796 uint32_t i; 1797 1798 idents = ulp_mapper_ident_fields_get(parms, tbl, &num_idents); 1799 for (i = 0; i < num_idents; i++) { 1800 if (ulp_mapper_ident_process(parms, tbl, 1801 &idents[i], NULL)) 1802 return -EINVAL; 1803 } 1804 return 0; 1805 } 1806 1807 /* 1808 * Tcam table scan the identifier list and extract the identifier from 1809 * the result blob. 1810 */ 1811 static int32_t 1812 ulp_mapper_tcam_tbl_scan_ident_extract(struct bnxt_ulp_mapper_parms *parms, 1813 struct bnxt_ulp_mapper_tbl_info *tbl, 1814 struct ulp_blob *data) 1815 { 1816 struct bnxt_ulp_mapper_ident_info *idents; 1817 uint32_t num_idents = 0, i; 1818 int32_t rc = 0; 1819 1820 /* 1821 * Extract the listed identifiers from the result field, 1822 * no need to allocate them. 1823 */ 1824 idents = ulp_mapper_ident_fields_get(parms, tbl, &num_idents); 1825 for (i = 0; i < num_idents; i++) { 1826 rc = ulp_mapper_ident_extract(parms, tbl, &idents[i], data); 1827 if (rc) { 1828 BNXT_TF_DBG(ERR, "Error in identifier extraction\n"); 1829 return rc; 1830 } 1831 } 1832 return rc; 1833 } 1834 1835 /* Internal function to write the tcam entry */ 1836 static int32_t 1837 ulp_mapper_tcam_tbl_entry_write(struct bnxt_ulp_mapper_parms *parms, 1838 struct bnxt_ulp_mapper_tbl_info *tbl, 1839 struct ulp_blob *key, 1840 struct ulp_blob *mask, 1841 struct ulp_blob *data, 1842 uint16_t idx) 1843 { 1844 struct tf_set_tcam_entry_parms sparms = { 0 }; 1845 struct tf *tfp; 1846 uint16_t tmplen; 1847 int32_t rc; 1848 1849 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); 1850 if (!tfp) { 1851 BNXT_TF_DBG(ERR, "Failed to get truflow pointer\n"); 1852 return -EINVAL; 1853 } 1854 1855 sparms.dir = tbl->direction; 1856 sparms.tcam_tbl_type = tbl->resource_type; 1857 sparms.idx = idx; 1858 sparms.key = ulp_blob_data_get(key, &tmplen); 1859 sparms.key_sz_in_bits = tmplen; 1860 sparms.mask = ulp_blob_data_get(mask, &tmplen); 1861 sparms.result = ulp_blob_data_get(data, &tmplen); 1862 sparms.result_sz_in_bits = tmplen; 1863 if (tf_set_tcam_entry(tfp, &sparms)) { 1864 BNXT_TF_DBG(ERR, "tcam[%s][%s][%x] write failed.\n", 1865 tf_tcam_tbl_2_str(sparms.tcam_tbl_type), 1866 tf_dir_2_str(sparms.dir), sparms.idx); 1867 return -EIO; 1868 } 1869 BNXT_TF_INF("tcam[%s][%s][%x] write success.\n", 1870 tf_tcam_tbl_2_str(sparms.tcam_tbl_type), 1871 tf_dir_2_str(sparms.dir), sparms.idx); 1872 1873 /* Mark action */ 1874 rc = ulp_mapper_mark_act_ptr_process(parms, tbl); 1875 if (rc) { 1876 BNXT_TF_DBG(ERR, "failed mark action processing\n"); 1877 return rc; 1878 } 1879 1880 return rc; 1881 } 1882 1883 /* 1884 * internal function to post process key/mask blobs for dynamic pad WC tcam tbl 1885 * 1886 * parms [in] The mappers parms with data related to the flow. 1887 * 1888 * key [in] The original key to be transformed 1889 * 1890 * mask [in] The original mask to be transformed 1891 * 1892 * tkey [in/out] The transformed key 1893 * 1894 * tmask [in/out] The transformed mask 1895 * 1896 * returns zero on success, non-zero on failure 1897 */ 1898 static uint32_t 1899 ulp_mapper_wc_tcam_tbl_dyn_post_process(struct bnxt_ulp_device_params *dparms, 1900 struct ulp_blob *key, 1901 struct ulp_blob *mask, 1902 struct ulp_blob *tkey, 1903 struct ulp_blob *tmask) 1904 { 1905 uint16_t tlen, blen, clen, slice_width, num_slices, max_slices, offset; 1906 uint32_t cword, i, rc; 1907 int32_t pad; 1908 uint8_t *val; 1909 1910 slice_width = dparms->wc_slice_width; 1911 clen = dparms->wc_ctl_size_bits; 1912 max_slices = dparms->wc_max_slices; 1913 blen = ulp_blob_data_len_get(key); 1914 1915 /* Get the length of the key based on number of slices and width */ 1916 num_slices = 1; 1917 tlen = slice_width; 1918 while (tlen < blen && 1919 num_slices <= max_slices) { 1920 num_slices = num_slices << 1; 1921 tlen = tlen << 1; 1922 } 1923 1924 if (num_slices > max_slices) { 1925 BNXT_TF_DBG(ERR, "Key size (%d) too large for WC\n", blen); 1926 return -EINVAL; 1927 } 1928 1929 /* The key/mask may not be on a natural slice boundary, pad it */ 1930 pad = tlen - blen; 1931 if (ulp_blob_pad_push(key, pad) < 0 || 1932 ulp_blob_pad_push(mask, pad) < 0) { 1933 BNXT_TF_DBG(ERR, "Unable to pad key/mask\n"); 1934 return -EINVAL; 1935 } 1936 1937 /* The new length accounts for the ctrl word length and num slices */ 1938 tlen = tlen + clen * num_slices; 1939 if (!ulp_blob_init(tkey, tlen, key->byte_order) || 1940 !ulp_blob_init(tmask, tlen, mask->byte_order)) { 1941 BNXT_TF_DBG(ERR, "Unable to post process wc tcam entry\n"); 1942 return -EINVAL; 1943 } 1944 1945 /* Build the transformed key/mask */ 1946 cword = dparms->wc_mode_list[num_slices - 1]; 1947 cword = tfp_cpu_to_be_32(cword); 1948 offset = 0; 1949 for (i = 0; i < num_slices; i++) { 1950 val = ulp_blob_push_32(tkey, &cword, clen); 1951 if (!val) { 1952 BNXT_TF_DBG(ERR, "Key ctrl word push failed\n"); 1953 return -EINVAL; 1954 } 1955 val = ulp_blob_push_32(tmask, &cword, clen); 1956 if (!val) { 1957 BNXT_TF_DBG(ERR, "Mask ctrl word push failed\n"); 1958 return -EINVAL; 1959 } 1960 rc = ulp_blob_append(tkey, key, offset, slice_width); 1961 if (rc) { 1962 BNXT_TF_DBG(ERR, "Key blob append failed\n"); 1963 return rc; 1964 } 1965 rc = ulp_blob_append(tmask, mask, offset, slice_width); 1966 if (rc) { 1967 BNXT_TF_DBG(ERR, "Mask blob append failed\n"); 1968 return rc; 1969 } 1970 offset += slice_width; 1971 } 1972 1973 /* The key/mask are byte reversed on every 4 byte chunk */ 1974 ulp_blob_perform_byte_reverse(tkey, 4); 1975 ulp_blob_perform_byte_reverse(tmask, 4); 1976 1977 return 0; 1978 } 1979 1980 /* internal function to post process the key/mask blobs for wildcard tcam tbl */ 1981 static void ulp_mapper_wc_tcam_tbl_post_process(struct ulp_blob *blob) 1982 { 1983 ulp_blob_perform_64B_word_swap(blob); 1984 ulp_blob_perform_64B_byte_swap(blob); 1985 } 1986 1987 static int32_t ulp_mapper_tcam_is_wc_tcam(struct bnxt_ulp_mapper_tbl_info *tbl) 1988 { 1989 if (tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM || 1990 tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM_HIGH || 1991 tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM_LOW) 1992 return 1; 1993 return 0; 1994 } 1995 1996 static int32_t 1997 ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms, 1998 struct bnxt_ulp_mapper_tbl_info *tbl) 1999 { 2000 struct bnxt_ulp_mapper_key_info *kflds; 2001 struct ulp_blob okey, omask, data, update_data; 2002 struct ulp_blob tkey, tmask; /* transform key and mask */ 2003 struct ulp_blob *key, *mask; 2004 uint32_t i, num_kflds; 2005 struct tf *tfp; 2006 int32_t rc, trc; 2007 struct bnxt_ulp_device_params *dparms = parms->device_params; 2008 struct tf_alloc_tcam_entry_parms aparms = { 0 }; 2009 struct tf_search_tcam_entry_parms searchparms = { 0 }; 2010 struct ulp_flow_db_res_params fid_parms = { 0 }; 2011 struct tf_free_tcam_entry_parms free_parms = { 0 }; 2012 uint32_t hit = 0; 2013 uint16_t tmplen = 0; 2014 uint16_t idx; 2015 enum bnxt_ulp_byte_order key_byte_order; 2016 2017 /* Set the key and mask to the original key and mask. */ 2018 key = &okey; 2019 mask = &omask; 2020 2021 /* Skip this if table opcode is NOP */ 2022 if (tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_NOT_USED || 2023 tbl->tbl_opcode >= BNXT_ULP_TCAM_TBL_OPC_LAST) { 2024 BNXT_TF_DBG(ERR, "Invalid tcam table opcode %d\n", 2025 tbl->tbl_opcode); 2026 return 0; 2027 } 2028 2029 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); 2030 if (!tfp) { 2031 BNXT_TF_DBG(ERR, "Failed to get truflow pointer\n"); 2032 return -EINVAL; 2033 } 2034 2035 /* If only allocation of identifier then perform and exit */ 2036 if (tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_ALLOC_IDENT) { 2037 rc = ulp_mapper_tcam_tbl_scan_ident_alloc(parms, tbl); 2038 return rc; 2039 } 2040 2041 kflds = ulp_mapper_key_fields_get(parms, tbl, &num_kflds); 2042 if (!kflds || !num_kflds) { 2043 BNXT_TF_DBG(ERR, "Failed to get key fields\n"); 2044 return -EINVAL; 2045 } 2046 2047 if (ulp_mapper_tcam_is_wc_tcam(tbl)) 2048 key_byte_order = dparms->wc_key_byte_order; 2049 else 2050 key_byte_order = dparms->key_byte_order; 2051 2052 if (!ulp_blob_init(key, tbl->blob_key_bit_size, key_byte_order) || 2053 !ulp_blob_init(mask, tbl->blob_key_bit_size, key_byte_order) || 2054 !ulp_blob_init(&data, tbl->result_bit_size, 2055 dparms->result_byte_order) || 2056 !ulp_blob_init(&update_data, tbl->result_bit_size, 2057 dparms->result_byte_order)) { 2058 BNXT_TF_DBG(ERR, "blob inits failed.\n"); 2059 return -EINVAL; 2060 } 2061 2062 /* create the key/mask */ 2063 /* 2064 * NOTE: The WC table will require some kind of flag to handle the 2065 * mode bits within the key/mask 2066 */ 2067 for (i = 0; i < num_kflds; i++) { 2068 /* Setup the key */ 2069 rc = ulp_mapper_field_opc_process(parms, tbl->direction, 2070 &kflds[i].field_info_spec, 2071 key, 1, "TCAM Key"); 2072 if (rc) { 2073 BNXT_TF_DBG(ERR, "Key field set failed %s\n", 2074 kflds[i].field_info_spec.description); 2075 return rc; 2076 } 2077 2078 /* Setup the mask */ 2079 rc = ulp_mapper_field_opc_process(parms, tbl->direction, 2080 &kflds[i].field_info_mask, 2081 mask, 0, "TCAM Mask"); 2082 if (rc) { 2083 BNXT_TF_DBG(ERR, "Mask field set failed %s\n", 2084 kflds[i].field_info_mask.description); 2085 return rc; 2086 } 2087 } 2088 2089 /* For wild card tcam perform the post process to swap the blob */ 2090 if (ulp_mapper_tcam_is_wc_tcam(tbl)) { 2091 if (dparms->dynamic_pad_en) { 2092 /* Sets up the slices for writing to the WC TCAM */ 2093 rc = ulp_mapper_wc_tcam_tbl_dyn_post_process(dparms, 2094 key, mask, 2095 &tkey, 2096 &tmask); 2097 if (rc) { 2098 BNXT_TF_DBG(ERR, 2099 "Failed to post proc WC entry.\n"); 2100 return rc; 2101 } 2102 /* Now need to use the transform Key/Mask */ 2103 key = &tkey; 2104 mask = &tmask; 2105 } else { 2106 ulp_mapper_wc_tcam_tbl_post_process(key); 2107 ulp_mapper_wc_tcam_tbl_post_process(mask); 2108 } 2109 2110 } 2111 2112 if (tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_ALLOC_WR_REGFILE) { 2113 /* allocate the tcam index */ 2114 aparms.dir = tbl->direction; 2115 aparms.tcam_tbl_type = tbl->resource_type; 2116 aparms.key = ulp_blob_data_get(key, &tmplen); 2117 aparms.key_sz_in_bits = tmplen; 2118 aparms.mask = ulp_blob_data_get(mask, &tmplen); 2119 2120 /* calculate the entry priority */ 2121 rc = ulp_mapper_priority_opc_process(parms, tbl, 2122 &aparms.priority); 2123 if (rc) { 2124 BNXT_TF_DBG(ERR, "entry priority process failed\n"); 2125 return rc; 2126 } 2127 2128 rc = tf_alloc_tcam_entry(tfp, &aparms); 2129 if (rc) { 2130 BNXT_TF_DBG(ERR, "tcam alloc failed rc=%d.\n", rc); 2131 return rc; 2132 } 2133 idx = aparms.idx; 2134 hit = aparms.hit; 2135 } else { 2136 /* 2137 * Searching before allocation to see if we already have an 2138 * entry. This allows re-use of a constrained resource. 2139 */ 2140 searchparms.dir = tbl->direction; 2141 searchparms.tcam_tbl_type = tbl->resource_type; 2142 searchparms.key = ulp_blob_data_get(key, &tmplen); 2143 searchparms.key_sz_in_bits = tbl->key_bit_size; 2144 searchparms.mask = ulp_blob_data_get(mask, &tmplen); 2145 searchparms.alloc = 1; 2146 searchparms.result = ulp_blob_data_get(&data, &tmplen); 2147 searchparms.result_sz_in_bits = tbl->result_bit_size; 2148 2149 /* calculate the entry priority */ 2150 rc = ulp_mapper_priority_opc_process(parms, tbl, 2151 &searchparms.priority); 2152 if (rc) { 2153 BNXT_TF_DBG(ERR, "entry priority process failed\n"); 2154 return rc; 2155 } 2156 2157 rc = tf_search_tcam_entry(tfp, &searchparms); 2158 if (rc) { 2159 BNXT_TF_DBG(ERR, "tcam search failed rc=%d\n", rc); 2160 return rc; 2161 } 2162 2163 /* Successful search, check the result */ 2164 if (searchparms.search_status == REJECT) { 2165 BNXT_TF_DBG(ERR, "tcam alloc rejected\n"); 2166 return -ENOMEM; 2167 } 2168 idx = searchparms.idx; 2169 hit = searchparms.hit; 2170 } 2171 2172 /* Write the tcam index into the regfile*/ 2173 if (ulp_regfile_write(parms->regfile, tbl->tbl_operand, 2174 (uint64_t)tfp_cpu_to_be_64(idx))) { 2175 BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n", 2176 tbl->tbl_operand); 2177 rc = -EINVAL; 2178 /* Need to free the tcam idx, so goto error */ 2179 goto error; 2180 } 2181 2182 /* if it is miss then it is same as no search before alloc */ 2183 if (!hit || tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_ALLOC_WR_REGFILE) { 2184 /*Scan identifier list, allocate identifier and update regfile*/ 2185 rc = ulp_mapper_tcam_tbl_scan_ident_alloc(parms, tbl); 2186 /* Create the result blob */ 2187 if (!rc) 2188 rc = ulp_mapper_tbl_result_build(parms, tbl, &data, 2189 "TCAM Result"); 2190 /* write the tcam entry */ 2191 if (!rc) 2192 rc = ulp_mapper_tcam_tbl_entry_write(parms, tbl, key, 2193 mask, &data, idx); 2194 } else { 2195 /*Scan identifier list, extract identifier and update regfile*/ 2196 rc = ulp_mapper_tcam_tbl_scan_ident_extract(parms, tbl, &data); 2197 } 2198 if (rc) 2199 goto error; 2200 2201 /* Add the tcam index to the flow database */ 2202 fid_parms.direction = tbl->direction; 2203 fid_parms.resource_func = tbl->resource_func; 2204 fid_parms.resource_type = tbl->resource_type; 2205 fid_parms.critical_resource = tbl->critical_resource; 2206 fid_parms.resource_hndl = idx; 2207 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); 2208 2209 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 2210 if (rc) { 2211 BNXT_TF_DBG(ERR, "Failed to link resource to flow rc = %d\n", 2212 rc); 2213 /* Need to free the identifier, so goto error */ 2214 goto error; 2215 } 2216 2217 return 0; 2218 error: 2219 free_parms.dir = tbl->direction; 2220 free_parms.tcam_tbl_type = tbl->resource_type; 2221 free_parms.idx = idx; 2222 trc = tf_free_tcam_entry(tfp, &free_parms); 2223 if (trc) 2224 BNXT_TF_DBG(ERR, "Failed to free tcam[%d][%d][%d] on failure\n", 2225 tbl->resource_type, tbl->direction, idx); 2226 return rc; 2227 } 2228 2229 static int32_t 2230 ulp_mapper_em_tbl_process(struct bnxt_ulp_mapper_parms *parms, 2231 struct bnxt_ulp_mapper_tbl_info *tbl) 2232 { 2233 struct bnxt_ulp_mapper_key_info *kflds; 2234 struct ulp_blob key, data; 2235 uint32_t i, num_kflds; 2236 uint16_t tmplen; 2237 struct tf *tfp; 2238 struct ulp_flow_db_res_params fid_parms = { 0 }; 2239 struct tf_insert_em_entry_parms iparms = { 0 }; 2240 struct tf_delete_em_entry_parms free_parms = { 0 }; 2241 enum bnxt_ulp_flow_mem_type mtype; 2242 struct bnxt_ulp_device_params *dparms = parms->device_params; 2243 int32_t trc; 2244 int32_t rc = 0; 2245 int32_t pad = 0; 2246 enum bnxt_ulp_byte_order key_order, res_order; 2247 2248 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); 2249 rc = bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype); 2250 if (rc) { 2251 BNXT_TF_DBG(ERR, "Failed to get the mem type for EM\n"); 2252 return -EINVAL; 2253 } 2254 2255 kflds = ulp_mapper_key_fields_get(parms, tbl, &num_kflds); 2256 if (!kflds || !num_kflds) { 2257 BNXT_TF_DBG(ERR, "Failed to get key fields\n"); 2258 return -EINVAL; 2259 } 2260 2261 key_order = dparms->em_byte_order; 2262 res_order = dparms->em_byte_order; 2263 2264 /* Initialize the key/result blobs */ 2265 if (!ulp_blob_init(&key, tbl->blob_key_bit_size, key_order) || 2266 !ulp_blob_init(&data, tbl->result_bit_size, res_order)) { 2267 BNXT_TF_DBG(ERR, "blob inits failed.\n"); 2268 return -EINVAL; 2269 } 2270 2271 /* create the key */ 2272 for (i = 0; i < num_kflds; i++) { 2273 /* Setup the key */ 2274 rc = ulp_mapper_field_opc_process(parms, tbl->direction, 2275 &kflds[i].field_info_spec, 2276 &key, 1, "EM Key"); 2277 if (rc) { 2278 BNXT_TF_DBG(ERR, "Key field set failed.\n"); 2279 return rc; 2280 } 2281 } 2282 2283 /* if dynamic padding is enabled then add padding to result data */ 2284 if (dparms->dynamic_pad_en) { 2285 /* add padding to make sure key is at byte boundary */ 2286 ulp_blob_pad_align(&key, ULP_BUFFER_ALIGN_8_BITS); 2287 2288 /* add the pad */ 2289 pad = dparms->em_blk_align_bits - dparms->em_blk_size_bits; 2290 if (pad < 0) { 2291 BNXT_TF_DBG(ERR, "Invalid em blk size and align\n"); 2292 return -EINVAL; 2293 } 2294 ulp_blob_pad_push(&data, (uint32_t)pad); 2295 } 2296 2297 /* Create the result data blob */ 2298 rc = ulp_mapper_tbl_result_build(parms, tbl, &data, "EM Result"); 2299 if (rc) { 2300 BNXT_TF_DBG(ERR, "Failed to build the result blob\n"); 2301 return rc; 2302 } 2303 if (dparms->dynamic_pad_en) { 2304 uint32_t abits = dparms->em_blk_align_bits; 2305 2306 /* when dynamic padding is enabled merge result + key */ 2307 rc = ulp_blob_block_merge(&data, &key, abits, pad); 2308 if (rc) { 2309 BNXT_TF_DBG(ERR, "Failed to merge the result blob\n"); 2310 return rc; 2311 } 2312 2313 /* add padding to make sure merged result is at slice boundary*/ 2314 ulp_blob_pad_align(&data, abits); 2315 2316 ulp_blob_perform_byte_reverse(&data, ULP_BITS_2_BYTE(abits)); 2317 } 2318 2319 /* do the transpose for the internal EM keys */ 2320 if (tbl->resource_type == TF_MEM_INTERNAL) { 2321 if (dparms->em_key_align_bytes) { 2322 int32_t b = ULP_BYTE_2_BITS(dparms->em_key_align_bytes); 2323 2324 tmplen = ulp_blob_data_len_get(&key); 2325 ulp_blob_pad_push(&key, b - tmplen); 2326 } 2327 tmplen = ulp_blob_data_len_get(&key); 2328 ulp_blob_perform_byte_reverse(&key, ULP_BITS_2_BYTE(tmplen)); 2329 } 2330 2331 rc = bnxt_ulp_cntxt_tbl_scope_id_get(parms->ulp_ctx, 2332 &iparms.tbl_scope_id); 2333 if (rc) { 2334 BNXT_TF_DBG(ERR, "Failed to get table scope rc=%d\n", rc); 2335 return rc; 2336 } 2337 2338 /* 2339 * NOTE: the actual blob size will differ from the size in the tbl 2340 * entry due to the padding. 2341 */ 2342 iparms.dup_check = 0; 2343 iparms.dir = tbl->direction; 2344 iparms.mem = tbl->resource_type; 2345 iparms.key = ulp_blob_data_get(&key, &tmplen); 2346 iparms.key_sz_in_bits = tbl->key_bit_size; 2347 iparms.em_record = ulp_blob_data_get(&data, &tmplen); 2348 if (tbl->result_bit_size) 2349 iparms.em_record_sz_in_bits = tbl->result_bit_size; 2350 else 2351 iparms.em_record_sz_in_bits = tmplen; 2352 2353 rc = tf_insert_em_entry(tfp, &iparms); 2354 if (rc) { 2355 BNXT_TF_DBG(ERR, "Failed to insert em entry rc=%d.\n", rc); 2356 return rc; 2357 } 2358 2359 /* Mark action process */ 2360 if (mtype == BNXT_ULP_FLOW_MEM_TYPE_EXT && 2361 tbl->resource_type == TF_MEM_EXTERNAL) 2362 rc = ulp_mapper_mark_gfid_process(parms, tbl, iparms.flow_id); 2363 else if (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT && 2364 tbl->resource_type == TF_MEM_INTERNAL) 2365 rc = ulp_mapper_mark_act_ptr_process(parms, tbl); 2366 if (rc) { 2367 BNXT_TF_DBG(ERR, "Failed to add mark to flow\n"); 2368 goto error; 2369 } 2370 2371 /* Link the EM resource to the flow in the flow db */ 2372 memset(&fid_parms, 0, sizeof(fid_parms)); 2373 fid_parms.direction = tbl->direction; 2374 fid_parms.resource_func = tbl->resource_func; 2375 fid_parms.resource_type = tbl->resource_type; 2376 fid_parms.critical_resource = tbl->critical_resource; 2377 fid_parms.resource_hndl = iparms.flow_handle; 2378 2379 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 2380 if (rc) { 2381 BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", 2382 rc); 2383 /* Need to free the identifier, so goto error */ 2384 goto error; 2385 } 2386 2387 return 0; 2388 error: 2389 free_parms.dir = iparms.dir; 2390 free_parms.mem = iparms.mem; 2391 free_parms.tbl_scope_id = iparms.tbl_scope_id; 2392 free_parms.flow_handle = iparms.flow_handle; 2393 2394 trc = tf_delete_em_entry(tfp, &free_parms); 2395 if (trc) 2396 BNXT_TF_DBG(ERR, "Failed to delete EM entry on failed add\n"); 2397 2398 return rc; 2399 } 2400 2401 static int32_t 2402 ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms, 2403 struct bnxt_ulp_mapper_tbl_info *tbl) 2404 { 2405 struct ulp_flow_db_res_params fid_parms; 2406 struct ulp_blob data; 2407 uint64_t regval = 0; 2408 uint16_t tmplen; 2409 uint32_t index; 2410 int32_t rc = 0, trc = 0; 2411 struct tf_alloc_tbl_entry_parms aparms = { 0 }; 2412 struct tf_set_tbl_entry_parms sparms = { 0 }; 2413 struct tf_get_tbl_entry_parms gparms = { 0 }; 2414 struct tf_free_tbl_entry_parms free_parms = { 0 }; 2415 uint32_t tbl_scope_id; 2416 struct tf *tfp; 2417 struct bnxt_ulp_glb_resource_info glb_res = { 0 }; 2418 uint16_t bit_size; 2419 bool alloc = false; 2420 bool write = false; 2421 bool global = false; 2422 uint64_t act_rec_size; 2423 bool shared = false; 2424 enum tf_tbl_type tbl_type = tbl->resource_type; 2425 2426 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); 2427 /* compute the blob size */ 2428 bit_size = ulp_mapper_dyn_blob_size_get(parms, tbl); 2429 2430 /* Initialize the blob data */ 2431 if (!ulp_blob_init(&data, bit_size, 2432 parms->device_params->result_byte_order)) { 2433 BNXT_TF_DBG(ERR, "Failed to initialize index table blob\n"); 2434 return -EINVAL; 2435 } 2436 2437 /* Get the scope id first */ 2438 rc = bnxt_ulp_cntxt_tbl_scope_id_get(parms->ulp_ctx, &tbl_scope_id); 2439 if (rc) { 2440 BNXT_TF_DBG(ERR, "Failed to get table scope rc=%d\n", rc); 2441 return rc; 2442 } 2443 2444 switch (tbl->tbl_opcode) { 2445 case BNXT_ULP_INDEX_TBL_OPC_ALLOC_REGFILE: 2446 alloc = true; 2447 break; 2448 case BNXT_ULP_INDEX_TBL_OPC_ALLOC_WR_REGFILE: 2449 /* 2450 * Build the entry, alloc an index, write the table, and store 2451 * the data in the regfile. 2452 */ 2453 alloc = true; 2454 write = true; 2455 break; 2456 case BNXT_ULP_INDEX_TBL_OPC_WR_REGFILE: 2457 /* 2458 * get the index to write to from the regfile and then write 2459 * the table entry. 2460 */ 2461 if (!ulp_regfile_read(parms->regfile, 2462 tbl->tbl_operand, 2463 ®val)) { 2464 BNXT_TF_DBG(ERR, 2465 "Failed to get tbl idx from regfile[%d].\n", 2466 tbl->tbl_operand); 2467 return -EINVAL; 2468 } 2469 index = tfp_be_to_cpu_64(regval); 2470 /* For external, we need to reverse shift */ 2471 if (tbl->resource_type == TF_TBL_TYPE_EXT) 2472 index = TF_ACT_REC_PTR_2_OFFSET(index); 2473 2474 write = true; 2475 break; 2476 case BNXT_ULP_INDEX_TBL_OPC_ALLOC_WR_GLB_REGFILE: 2477 /* 2478 * Build the entry, alloc an index, write the table, and store 2479 * the data in the global regfile. 2480 */ 2481 alloc = true; 2482 global = true; 2483 write = true; 2484 glb_res.direction = tbl->direction; 2485 glb_res.resource_func = tbl->resource_func; 2486 glb_res.resource_type = tbl->resource_type; 2487 glb_res.glb_regfile_index = tbl->tbl_operand; 2488 break; 2489 case BNXT_ULP_INDEX_TBL_OPC_WR_GLB_REGFILE: 2490 if (tbl->fdb_opcode != BNXT_ULP_FDB_OPC_NOP) { 2491 BNXT_TF_DBG(ERR, "Template error, wrong fdb opcode\n"); 2492 return -EINVAL; 2493 } 2494 /* 2495 * get the index to write to from the global regfile and then 2496 * write the table. 2497 */ 2498 if (ulp_mapper_glb_resource_read(parms->mapper_data, 2499 tbl->direction, 2500 tbl->tbl_operand, 2501 ®val, &shared)) { 2502 BNXT_TF_DBG(ERR, 2503 "Failed to get tbl idx from Glb RF[%d].\n", 2504 tbl->tbl_operand); 2505 return -EINVAL; 2506 } 2507 index = tfp_be_to_cpu_64(regval); 2508 /* For external, we need to reverse shift */ 2509 if (tbl->resource_type == TF_TBL_TYPE_EXT) 2510 index = TF_ACT_REC_PTR_2_OFFSET(index); 2511 write = true; 2512 break; 2513 case BNXT_ULP_INDEX_TBL_OPC_RD_REGFILE: 2514 /* 2515 * The read is different from the rest and can be handled here 2516 * instead of trying to use common code. Simply read the table 2517 * with the index from the regfile, scan and store the 2518 * identifiers, and return. 2519 */ 2520 if (tbl->resource_type == TF_TBL_TYPE_EXT) { 2521 /* Not currently supporting with EXT */ 2522 BNXT_TF_DBG(ERR, 2523 "Ext Table Read Opcode not supported.\n"); 2524 return -EINVAL; 2525 } 2526 if (!ulp_regfile_read(parms->regfile, 2527 tbl->tbl_operand, ®val)) { 2528 BNXT_TF_DBG(ERR, 2529 "Failed to get tbl idx from regfile[%d]\n", 2530 tbl->tbl_operand); 2531 return -EINVAL; 2532 } 2533 index = tfp_be_to_cpu_64(regval); 2534 gparms.dir = tbl->direction; 2535 gparms.type = tbl->resource_type; 2536 gparms.data = ulp_blob_data_get(&data, &tmplen); 2537 gparms.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen); 2538 gparms.idx = index; 2539 rc = tf_get_tbl_entry(tfp, &gparms); 2540 if (rc) { 2541 BNXT_TF_DBG(ERR, "Failed to read the tbl entry %d:%d\n", 2542 tbl->resource_type, index); 2543 return rc; 2544 } 2545 /* 2546 * Scan the fields in the entry and push them into the regfile. 2547 */ 2548 rc = ulp_mapper_tbl_ident_scan_ext(parms, tbl, 2549 gparms.data, 2550 gparms.data_sz_in_bytes, 2551 data.byte_order); 2552 if (rc) { 2553 BNXT_TF_DBG(ERR, 2554 "Failed to get flds on tbl read rc=%d\n", 2555 rc); 2556 return rc; 2557 } 2558 return 0; 2559 default: 2560 BNXT_TF_DBG(ERR, "Invalid index table opcode %d\n", 2561 tbl->tbl_opcode); 2562 return -EINVAL; 2563 } 2564 2565 if (write) { 2566 /* Get the result fields list */ 2567 rc = ulp_mapper_tbl_result_build(parms, 2568 tbl, 2569 &data, 2570 "Indexed Result"); 2571 if (rc) { 2572 BNXT_TF_DBG(ERR, "Failed to build the result blob\n"); 2573 return rc; 2574 } 2575 } 2576 2577 if (alloc) { 2578 aparms.dir = tbl->direction; 2579 tbl_type = ulp_mapper_dyn_tbl_type_get(parms, tbl, 2580 &data, &tmplen); 2581 aparms.type = tbl_type; 2582 aparms.tbl_scope_id = tbl_scope_id; 2583 2584 /* All failures after the alloc succeeds require a free */ 2585 rc = tf_alloc_tbl_entry(tfp, &aparms); 2586 if (rc) { 2587 BNXT_TF_DBG(ERR, "Alloc table[%s][%s] failed rc=%d\n", 2588 tf_tbl_type_2_str(aparms.type), 2589 tf_dir_2_str(tbl->direction), rc); 2590 return rc; 2591 } 2592 index = aparms.idx; 2593 2594 /* 2595 * Store the index in the regfile since we either allocated it 2596 * or it was a hit. 2597 * 2598 * Calculate the idx for the result record, for external EM the 2599 * offset needs to be shifted accordingly. 2600 * If external non-inline table types are used then need to 2601 * revisit this logic. 2602 */ 2603 if (tbl->resource_type == TF_TBL_TYPE_EXT) 2604 regval = TF_ACT_REC_OFFSET_2_PTR(index); 2605 else 2606 regval = index; 2607 regval = tfp_cpu_to_be_64(regval); 2608 2609 if (global) { 2610 /* 2611 * Shared resources are never allocated through this 2612 * method, so the shared flag is always false. 2613 */ 2614 rc = ulp_mapper_glb_resource_write(parms->mapper_data, 2615 &glb_res, regval, 2616 false); 2617 } else { 2618 rc = ulp_regfile_write(parms->regfile, 2619 tbl->tbl_operand, regval); 2620 } 2621 if (rc) { 2622 BNXT_TF_DBG(ERR, 2623 "Failed to write %s regfile[%d] rc=%d\n", 2624 (global) ? "global" : "reg", 2625 tbl->tbl_operand, rc); 2626 goto error; 2627 } 2628 } 2629 2630 if (write) { 2631 sparms.dir = tbl->direction; 2632 sparms.data = ulp_blob_data_get(&data, &tmplen); 2633 tbl_type = ulp_mapper_dyn_tbl_type_get(parms, tbl, &data, 2634 &tmplen); 2635 sparms.type = tbl_type; 2636 sparms.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen); 2637 sparms.idx = index; 2638 sparms.tbl_scope_id = tbl_scope_id; 2639 if (shared) 2640 tfp = bnxt_ulp_cntxt_shared_tfp_get(parms->ulp_ctx); 2641 rc = tf_set_tbl_entry(tfp, &sparms); 2642 if (rc) { 2643 BNXT_TF_DBG(ERR, 2644 "Index table[%s][%s][%x] write fail rc=%d\n", 2645 tf_tbl_type_2_str(sparms.type), 2646 tf_dir_2_str(sparms.dir), 2647 sparms.idx, rc); 2648 goto error; 2649 } 2650 BNXT_TF_INF("Index table[%s][%s][%x] write successful.\n", 2651 tf_tbl_type_2_str(sparms.type), 2652 tf_dir_2_str(sparms.dir), sparms.idx); 2653 2654 /* Calculate action record size */ 2655 if (tbl->resource_type == TF_TBL_TYPE_EXT) { 2656 act_rec_size = (ULP_BITS_2_BYTE_NR(tmplen) + 15) / 16; 2657 act_rec_size--; 2658 if (ulp_regfile_write(parms->regfile, 2659 BNXT_ULP_RF_IDX_ACTION_REC_SIZE, 2660 tfp_cpu_to_be_64(act_rec_size))) 2661 BNXT_TF_DBG(ERR, 2662 "Failed write the act rec size\n"); 2663 } 2664 } 2665 2666 /* Link the resource to the flow in the flow db */ 2667 memset(&fid_parms, 0, sizeof(fid_parms)); 2668 fid_parms.direction = tbl->direction; 2669 fid_parms.resource_func = tbl->resource_func; 2670 fid_parms.resource_type = tbl_type; 2671 fid_parms.resource_sub_type = tbl->resource_sub_type; 2672 fid_parms.resource_hndl = index; 2673 fid_parms.critical_resource = tbl->critical_resource; 2674 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); 2675 2676 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 2677 if (rc) { 2678 BNXT_TF_DBG(ERR, "Failed to link resource to flow rc = %d\n", 2679 rc); 2680 goto error; 2681 } 2682 2683 /* Perform the VF rep action */ 2684 rc = ulp_mapper_mark_vfr_idx_process(parms, tbl); 2685 if (rc) { 2686 BNXT_TF_DBG(ERR, "Failed to add vfr mark rc = %d\n", rc); 2687 goto error; 2688 } 2689 return rc; 2690 error: 2691 /* Shared resources are not freed */ 2692 if (shared) 2693 return rc; 2694 /* 2695 * Free the allocated resource since we failed to either 2696 * write to the entry or link the flow 2697 */ 2698 free_parms.dir = tbl->direction; 2699 free_parms.type = tbl_type; 2700 free_parms.idx = index; 2701 free_parms.tbl_scope_id = tbl_scope_id; 2702 2703 trc = tf_free_tbl_entry(tfp, &free_parms); 2704 if (trc) 2705 BNXT_TF_DBG(ERR, "Failed to free tbl entry on failure\n"); 2706 2707 return rc; 2708 } 2709 2710 static int32_t 2711 ulp_mapper_if_tbl_process(struct bnxt_ulp_mapper_parms *parms, 2712 struct bnxt_ulp_mapper_tbl_info *tbl) 2713 { 2714 struct ulp_blob data, res_blob; 2715 uint64_t idx; 2716 uint16_t tmplen; 2717 int32_t rc = 0; 2718 struct tf_set_if_tbl_entry_parms iftbl_params = { 0 }; 2719 struct tf_get_if_tbl_entry_parms get_parms = { 0 }; 2720 struct tf *tfp; 2721 enum bnxt_ulp_if_tbl_opc if_opc = tbl->tbl_opcode; 2722 uint32_t res_size; 2723 2724 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session); 2725 /* Initialize the blob data */ 2726 if (!ulp_blob_init(&data, tbl->result_bit_size, 2727 parms->device_params->result_byte_order)) { 2728 BNXT_TF_DBG(ERR, "Failed initial index table blob\n"); 2729 return -EINVAL; 2730 } 2731 2732 /* create the result blob */ 2733 rc = ulp_mapper_tbl_result_build(parms, tbl, &data, "IFtable Result"); 2734 if (rc) { 2735 BNXT_TF_DBG(ERR, "Failed to build the result blob\n"); 2736 return rc; 2737 } 2738 2739 /* Get the index details */ 2740 switch (if_opc) { 2741 case BNXT_ULP_IF_TBL_OPC_WR_COMP_FIELD: 2742 idx = ULP_COMP_FLD_IDX_RD(parms, tbl->tbl_operand); 2743 break; 2744 case BNXT_ULP_IF_TBL_OPC_WR_REGFILE: 2745 if (!ulp_regfile_read(parms->regfile, tbl->tbl_operand, &idx)) { 2746 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", 2747 tbl->tbl_operand); 2748 return -EINVAL; 2749 } 2750 idx = tfp_be_to_cpu_64(idx); 2751 break; 2752 case BNXT_ULP_IF_TBL_OPC_WR_CONST: 2753 idx = tbl->tbl_operand; 2754 break; 2755 case BNXT_ULP_IF_TBL_OPC_RD_COMP_FIELD: 2756 /* Initialize the result blob */ 2757 if (!ulp_blob_init(&res_blob, tbl->result_bit_size, 2758 parms->device_params->result_byte_order)) { 2759 BNXT_TF_DBG(ERR, "Failed initial result blob\n"); 2760 return -EINVAL; 2761 } 2762 2763 /* read the interface table */ 2764 idx = ULP_COMP_FLD_IDX_RD(parms, tbl->tbl_operand); 2765 res_size = ULP_BITS_2_BYTE(tbl->result_bit_size); 2766 get_parms.dir = tbl->direction; 2767 get_parms.type = tbl->resource_type; 2768 get_parms.idx = idx; 2769 get_parms.data = ulp_blob_data_get(&res_blob, &tmplen); 2770 get_parms.data_sz_in_bytes = res_size; 2771 2772 rc = tf_get_if_tbl_entry(tfp, &get_parms); 2773 if (rc) { 2774 BNXT_TF_DBG(ERR, "Get table[%d][%s][%x] failed rc=%d\n", 2775 get_parms.type, 2776 tf_dir_2_str(get_parms.dir), 2777 get_parms.idx, rc); 2778 return rc; 2779 } 2780 rc = ulp_mapper_tbl_ident_scan_ext(parms, tbl, 2781 res_blob.data, 2782 res_size, 2783 res_blob.byte_order); 2784 if (rc) 2785 BNXT_TF_DBG(ERR, "Scan and extract failed rc=%d\n", rc); 2786 return rc; 2787 case BNXT_ULP_IF_TBL_OPC_NOT_USED: 2788 return rc; /* skip it */ 2789 default: 2790 BNXT_TF_DBG(ERR, "Invalid tbl index opcode\n"); 2791 return -EINVAL; 2792 } 2793 2794 /* Perform the tf table set by filling the set params */ 2795 iftbl_params.dir = tbl->direction; 2796 iftbl_params.type = tbl->resource_type; 2797 iftbl_params.data = ulp_blob_data_get(&data, &tmplen); 2798 iftbl_params.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen); 2799 iftbl_params.idx = idx; 2800 2801 rc = tf_set_if_tbl_entry(tfp, &iftbl_params); 2802 if (rc) { 2803 BNXT_TF_DBG(ERR, "Set table[%d][%s][%x] failed rc=%d\n", 2804 iftbl_params.type,/* TBD: add tf_if_tbl_2_str */ 2805 tf_dir_2_str(iftbl_params.dir), 2806 iftbl_params.idx, rc); 2807 return rc; 2808 } 2809 BNXT_TF_INF("Set table[%s][%s][%x] success.\n", 2810 tf_if_tbl_2_str(iftbl_params.type), 2811 tf_dir_2_str(iftbl_params.dir), 2812 iftbl_params.idx); 2813 2814 /* 2815 * TBD: Need to look at the need to store idx in flow db for restore 2816 * the table to its original state on deletion of this entry. 2817 */ 2818 return rc; 2819 } 2820 2821 static int32_t 2822 ulp_mapper_gen_tbl_process(struct bnxt_ulp_mapper_parms *parms, 2823 struct bnxt_ulp_mapper_tbl_info *tbl) 2824 { 2825 struct ulp_mapper_gen_tbl_list *gen_tbl_list; 2826 struct bnxt_ulp_mapper_key_info *kflds; 2827 struct ulp_flow_db_res_params fid_parms; 2828 struct ulp_mapper_gen_tbl_entry gen_tbl_ent, *g; 2829 struct ulp_gen_hash_entry_params hash_entry; 2830 uint16_t tmplen = 0; 2831 struct ulp_blob key, data; 2832 uint8_t *cache_key; 2833 int32_t tbl_idx; 2834 uint32_t i, num_kflds = 0, key_index = 0; 2835 uint32_t gen_tbl_miss = 1, fdb_write = 0; 2836 uint8_t *byte_data; 2837 int32_t rc = 0; 2838 2839 /* Get the key fields list and build the key. */ 2840 kflds = ulp_mapper_key_fields_get(parms, tbl, &num_kflds); 2841 if (!kflds || !num_kflds) { 2842 BNXT_TF_DBG(ERR, "Failed to get key fields\n"); 2843 return -EINVAL; 2844 } 2845 2846 if (!ulp_blob_init(&key, tbl->key_bit_size, 2847 parms->device_params->key_byte_order)) { 2848 BNXT_TF_DBG(ERR, "Failed to alloc blob\n"); 2849 return -EINVAL; 2850 } 2851 for (i = 0; i < num_kflds; i++) { 2852 /* Setup the key */ 2853 rc = ulp_mapper_field_opc_process(parms, tbl->direction, 2854 &kflds[i].field_info_spec, 2855 &key, 1, "Gen Tbl Key"); 2856 if (rc) { 2857 BNXT_TF_DBG(ERR, 2858 "Failed to create key for Gen tbl rc=%d\n", 2859 rc); 2860 return -EINVAL; 2861 } 2862 } 2863 2864 /* Calculate the table index for the generic table*/ 2865 tbl_idx = ulp_mapper_gen_tbl_idx_calculate(tbl->resource_sub_type, 2866 tbl->direction); 2867 if (tbl_idx < 0) { 2868 BNXT_TF_DBG(ERR, "Invalid table index %x:%x\n", 2869 tbl->resource_sub_type, tbl->direction); 2870 return -EINVAL; 2871 } 2872 2873 /* The_key is a byte array convert it to a search index */ 2874 cache_key = ulp_blob_data_get(&key, &tmplen); 2875 /* get the generic table */ 2876 gen_tbl_list = &parms->mapper_data->gen_tbl_list[tbl_idx]; 2877 2878 /* Check if generic hash table */ 2879 if (gen_tbl_list->hash_tbl) { 2880 if (tbl->gen_tbl_lkup_type != 2881 BNXT_ULP_GENERIC_TBL_LKUP_TYPE_HASH) { 2882 BNXT_TF_DBG(ERR, "%s: Invalid template lkup type\n", 2883 gen_tbl_list->gen_tbl_name); 2884 return -EINVAL; 2885 } 2886 hash_entry.key_data = cache_key; 2887 hash_entry.key_length = ULP_BITS_2_BYTE(tmplen); 2888 rc = ulp_gen_hash_tbl_list_key_search(gen_tbl_list->hash_tbl, 2889 &hash_entry); 2890 if (rc) { 2891 BNXT_TF_DBG(ERR, "%s: hash tbl search failed\n", 2892 gen_tbl_list->gen_tbl_name); 2893 return rc; 2894 } 2895 if (hash_entry.search_flag == ULP_GEN_HASH_SEARCH_FOUND) { 2896 key_index = hash_entry.key_idx; 2897 /* Get the generic table entry */ 2898 if (ulp_mapper_gen_tbl_entry_get(gen_tbl_list, 2899 key_index, 2900 &gen_tbl_ent)) 2901 return -EINVAL; 2902 /* store the hash index in the fdb */ 2903 key_index = hash_entry.hash_index; 2904 } 2905 } else { 2906 /* convert key to index directly */ 2907 if (ULP_BITS_2_BYTE(tmplen) > (int32_t)sizeof(key_index)) { 2908 BNXT_TF_DBG(ERR, "%s: keysize is bigger then 4 bytes\n", 2909 gen_tbl_list->gen_tbl_name); 2910 return -EINVAL; 2911 } 2912 memcpy(&key_index, cache_key, ULP_BITS_2_BYTE(tmplen)); 2913 /* Get the generic table entry */ 2914 if (ulp_mapper_gen_tbl_entry_get(gen_tbl_list, key_index, 2915 &gen_tbl_ent)) 2916 return -EINVAL; 2917 } 2918 switch (tbl->tbl_opcode) { 2919 case BNXT_ULP_GENERIC_TBL_OPC_READ: 2920 if (gen_tbl_list->hash_tbl) { 2921 if (hash_entry.search_flag != ULP_GEN_HASH_SEARCH_FOUND) 2922 break; /* nothing to be done , no entry */ 2923 } 2924 2925 /* check the reference count */ 2926 if (ULP_GEN_TBL_REF_CNT(&gen_tbl_ent)) { 2927 g = &gen_tbl_ent; 2928 /* Scan ident list and create the result blob*/ 2929 rc = ulp_mapper_tbl_ident_scan_ext(parms, tbl, 2930 g->byte_data, 2931 g->byte_data_size, 2932 g->byte_order); 2933 if (rc) { 2934 BNXT_TF_DBG(ERR, 2935 "Failed to scan ident list\n"); 2936 return -EINVAL; 2937 } 2938 if (tbl->fdb_opcode != BNXT_ULP_FDB_OPC_NOP) { 2939 /* increment the reference count */ 2940 ULP_GEN_TBL_REF_CNT_INC(&gen_tbl_ent); 2941 } 2942 2943 /* it is a hit */ 2944 gen_tbl_miss = 0; 2945 fdb_write = 1; 2946 } 2947 break; 2948 case BNXT_ULP_GENERIC_TBL_OPC_WRITE: 2949 if (gen_tbl_list->hash_tbl) { 2950 rc = ulp_mapper_gen_tbl_hash_entry_add(gen_tbl_list, 2951 &hash_entry, 2952 &gen_tbl_ent); 2953 if (rc) 2954 return rc; 2955 /* store the hash index in the fdb */ 2956 key_index = hash_entry.hash_index; 2957 } 2958 /* check the reference count */ 2959 if (ULP_GEN_TBL_REF_CNT(&gen_tbl_ent)) { 2960 /* a hit then error */ 2961 BNXT_TF_DBG(ERR, "generic entry already present\n"); 2962 return -EINVAL; /* success */ 2963 } 2964 2965 /* Initialize the blob data */ 2966 if (!ulp_blob_init(&data, tbl->result_bit_size, 2967 gen_tbl_ent.byte_order)) { 2968 BNXT_TF_DBG(ERR, "Failed initial index table blob\n"); 2969 return -EINVAL; 2970 } 2971 2972 /* Get the result fields list */ 2973 rc = ulp_mapper_tbl_result_build(parms, tbl, &data, 2974 "Gen tbl Result"); 2975 if (rc) { 2976 BNXT_TF_DBG(ERR, "Failed to build the result blob\n"); 2977 return rc; 2978 } 2979 byte_data = ulp_blob_data_get(&data, &tmplen); 2980 rc = ulp_mapper_gen_tbl_entry_data_set(&gen_tbl_ent, 2981 tmplen, byte_data, 2982 ULP_BITS_2_BYTE(tmplen)); 2983 if (rc) { 2984 BNXT_TF_DBG(ERR, "Failed to write generic table\n"); 2985 return -EINVAL; 2986 } 2987 2988 /* increment the reference count */ 2989 ULP_GEN_TBL_REF_CNT_INC(&gen_tbl_ent); 2990 fdb_write = 1; 2991 parms->shared_hndl = (uint64_t)tbl_idx << 32 | key_index; 2992 break; 2993 default: 2994 BNXT_TF_DBG(ERR, "Invalid table opcode %x\n", tbl->tbl_opcode); 2995 return -EINVAL; 2996 } 2997 2998 /* Set the generic entry hit */ 2999 rc = ulp_regfile_write(parms->regfile, 3000 BNXT_ULP_RF_IDX_GENERIC_TBL_MISS, 3001 tfp_cpu_to_be_64(gen_tbl_miss)); 3002 if (rc) { 3003 BNXT_TF_DBG(ERR, "Write regfile[%d] failed\n", 3004 BNXT_ULP_RF_IDX_GENERIC_TBL_MISS); 3005 return -EIO; 3006 } 3007 3008 /* add the entry to the flow database */ 3009 if (fdb_write) { 3010 memset(&fid_parms, 0, sizeof(fid_parms)); 3011 fid_parms.direction = tbl->direction; 3012 fid_parms.resource_func = tbl->resource_func; 3013 fid_parms.resource_sub_type = tbl->resource_sub_type; 3014 fid_parms.resource_hndl = key_index; 3015 fid_parms.critical_resource = tbl->critical_resource; 3016 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session); 3017 3018 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms); 3019 if (rc) 3020 BNXT_TF_DBG(ERR, "Fail to add gen ent flowdb %d\n", rc); 3021 } 3022 return rc; 3023 } 3024 3025 static int32_t 3026 ulp_mapper_ctrl_tbl_process(struct bnxt_ulp_mapper_parms *parms, 3027 struct bnxt_ulp_mapper_tbl_info *tbl) 3028 { 3029 int32_t rc = 0; 3030 3031 /* process the fdb opcode for alloc push */ 3032 if (tbl->fdb_opcode == BNXT_ULP_FDB_OPC_ALLOC_RID_REGFILE) { 3033 rc = ulp_mapper_fdb_opc_alloc_rid(parms, tbl); 3034 if (rc) { 3035 BNXT_TF_DBG(ERR, "Failed to do fdb alloc\n"); 3036 return rc; 3037 } 3038 } 3039 return rc; 3040 } 3041 3042 static int32_t 3043 ulp_mapper_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, 3044 struct bnxt_ulp_mapper_data *mapper_data) 3045 { 3046 struct bnxt_ulp_glb_resource_info *glb_res; 3047 uint32_t num_glb_res_ids, idx, dev_id; 3048 uint8_t app_id; 3049 int32_t rc = 0; 3050 3051 glb_res = ulp_mapper_glb_resource_info_list_get(&num_glb_res_ids); 3052 if (!glb_res || !num_glb_res_ids) { 3053 BNXT_TF_DBG(ERR, "Invalid Arguments\n"); 3054 return -EINVAL; 3055 } 3056 3057 rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id); 3058 if (rc) { 3059 BNXT_TF_DBG(ERR, "Failed to get device id for glb init (%d)\n", 3060 rc); 3061 return rc; 3062 } 3063 3064 rc = bnxt_ulp_cntxt_app_id_get(ulp_ctx, &app_id); 3065 if (rc) { 3066 BNXT_TF_DBG(ERR, "Failed to get app id for glb init (%d)\n", 3067 rc); 3068 return rc; 3069 } 3070 3071 /* Iterate the global resources and process each one */ 3072 for (idx = 0; idx < num_glb_res_ids; idx++) { 3073 if (dev_id != glb_res[idx].device_id || 3074 glb_res[idx].app_id != app_id) 3075 continue; 3076 switch (glb_res[idx].resource_func) { 3077 case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER: 3078 rc = ulp_mapper_resource_ident_allocate(ulp_ctx, 3079 mapper_data, 3080 &glb_res[idx]); 3081 break; 3082 case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE: 3083 rc = ulp_mapper_resource_index_tbl_alloc(ulp_ctx, 3084 mapper_data, 3085 &glb_res[idx]); 3086 break; 3087 default: 3088 BNXT_TF_DBG(ERR, "Global resource %x not supported\n", 3089 glb_res[idx].resource_func); 3090 rc = -EINVAL; 3091 break; 3092 } 3093 if (rc) 3094 return rc; 3095 } 3096 return rc; 3097 } 3098 3099 /* 3100 * Iterate over the shared resources assigned during tf_open_session and store 3101 * them in the global regfile with the shared flag. 3102 */ 3103 static int32_t 3104 ulp_mapper_app_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx, 3105 struct bnxt_ulp_mapper_data *mapper_data) 3106 { 3107 struct tf_get_shared_tbl_increment_parms iparms; 3108 struct bnxt_ulp_glb_resource_info *glb_res; 3109 struct tf_get_session_info_parms sparms; 3110 uint32_t num_entries, i, dev_id, res; 3111 struct tf_resource_info *res_info; 3112 uint32_t addend; 3113 uint64_t regval; 3114 enum tf_dir dir; 3115 int32_t rc = 0; 3116 struct tf *tfp; 3117 uint8_t app_id; 3118 3119 memset(&sparms, 0, sizeof(sparms)); 3120 glb_res = bnxt_ulp_app_glb_resource_info_list_get(&num_entries); 3121 if (!glb_res || !num_entries) { 3122 BNXT_TF_DBG(ERR, "Invalid Arguments\n"); 3123 return -EINVAL; 3124 } 3125 tfp = bnxt_ulp_cntxt_shared_tfp_get(ulp_ctx); 3126 if (!tfp) { 3127 BNXT_TF_DBG(ERR, "Failed to get tfp for app global init"); 3128 return -EINVAL; 3129 } 3130 /* 3131 * Retrieve the resources that were assigned during the shared session 3132 * creation. 3133 */ 3134 rc = tf_get_session_info(tfp, &sparms); 3135 if (rc) { 3136 BNXT_TF_DBG(ERR, "Failed to get session info (%d)\n", rc); 3137 return rc; 3138 } 3139 3140 rc = bnxt_ulp_cntxt_app_id_get(ulp_ctx, &app_id); 3141 if (rc) { 3142 BNXT_TF_DBG(ERR, "Failed to get the app id in glb init (%d).\n", 3143 rc); 3144 return rc; 3145 } 3146 3147 rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id); 3148 if (rc) { 3149 BNXT_TF_DBG(ERR, "Failed to get dev id for app glb init (%d)\n", 3150 rc); 3151 return rc; 3152 } 3153 3154 /* Store all the app global resources */ 3155 for (i = 0; i < num_entries; i++) { 3156 if (dev_id != glb_res[i].device_id || 3157 app_id != glb_res[i].app_id) 3158 continue; 3159 dir = glb_res[i].direction; 3160 res = glb_res[i].resource_type; 3161 addend = 1; 3162 3163 switch (glb_res[i].resource_func) { 3164 case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER: 3165 res_info = &sparms.session_info.ident[dir].info[res]; 3166 break; 3167 case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE: 3168 /* 3169 * Tables may have various strides for the allocations. 3170 * Need to account. 3171 */ 3172 memset(&iparms, 0, sizeof(iparms)); 3173 iparms.dir = dir; 3174 iparms.type = res; 3175 rc = tf_get_shared_tbl_increment(tfp, &iparms); 3176 if (rc) { 3177 BNXT_TF_DBG(ERR, 3178 "Failed to get addend for %s[%s] rc=(%d)\n", 3179 tf_tbl_type_2_str(res), 3180 tf_dir_2_str(dir), rc); 3181 return rc; 3182 } 3183 addend = iparms.increment_cnt; 3184 res_info = &sparms.session_info.tbl[dir].info[res]; 3185 break; 3186 case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE: 3187 res_info = &sparms.session_info.tcam[dir].info[res]; 3188 break; 3189 case BNXT_ULP_RESOURCE_FUNC_EM_TABLE: 3190 res_info = &sparms.session_info.em[dir].info[res]; 3191 break; 3192 default: 3193 BNXT_TF_DBG(ERR, "Unknown resource func (0x%x)\n", 3194 glb_res[i].resource_func); 3195 continue; 3196 } 3197 regval = tfp_cpu_to_be_64((uint64_t)res_info->start); 3198 res_info->start += addend; 3199 /* 3200 * All resources written to the global regfile are shared for 3201 * this function. 3202 */ 3203 rc = ulp_mapper_glb_resource_write(mapper_data, &glb_res[i], 3204 regval, true); 3205 if (rc) 3206 return rc; 3207 } 3208 3209 return rc; 3210 } 3211 3212 /* 3213 * Common conditional opcode process routine that is used for both the template 3214 * rejection and table conditional execution. 3215 */ 3216 static int32_t 3217 ulp_mapper_cond_opc_process(struct bnxt_ulp_mapper_parms *parms, 3218 enum bnxt_ulp_cond_opc opc, 3219 uint32_t operand, 3220 int32_t *res) 3221 { 3222 enum bnxt_ulp_flow_mem_type mtype = BNXT_ULP_FLOW_MEM_TYPE_INT; 3223 int32_t rc = 0; 3224 uint8_t bit; 3225 uint64_t regval; 3226 3227 switch (opc) { 3228 case BNXT_ULP_COND_OPC_CF_IS_SET: 3229 if (operand < BNXT_ULP_CF_IDX_LAST) { 3230 *res = ULP_COMP_FLD_IDX_RD(parms, operand); 3231 } else { 3232 BNXT_TF_DBG(ERR, "comp field out of bounds %d\n", 3233 operand); 3234 rc = -EINVAL; 3235 } 3236 break; 3237 case BNXT_ULP_COND_OPC_CF_NOT_SET: 3238 if (operand < BNXT_ULP_CF_IDX_LAST) { 3239 *res = !ULP_COMP_FLD_IDX_RD(parms, operand); 3240 } else { 3241 BNXT_TF_DBG(ERR, "comp field out of bounds %d\n", 3242 operand); 3243 rc = -EINVAL; 3244 } 3245 break; 3246 case BNXT_ULP_COND_OPC_ACT_BIT_IS_SET: 3247 if (operand < BNXT_ULP_ACT_BIT_LAST) { 3248 *res = ULP_BITMAP_ISSET(parms->act_bitmap->bits, 3249 operand); 3250 } else { 3251 BNXT_TF_DBG(ERR, "action bit out of bounds %d\n", 3252 operand); 3253 rc = -EINVAL; 3254 } 3255 break; 3256 case BNXT_ULP_COND_OPC_ACT_BIT_NOT_SET: 3257 if (operand < BNXT_ULP_ACT_BIT_LAST) { 3258 *res = !ULP_BITMAP_ISSET(parms->act_bitmap->bits, 3259 operand); 3260 } else { 3261 BNXT_TF_DBG(ERR, "action bit out of bounds %d\n", 3262 operand); 3263 rc = -EINVAL; 3264 } 3265 break; 3266 case BNXT_ULP_COND_OPC_HDR_BIT_IS_SET: 3267 if (operand < BNXT_ULP_HDR_BIT_LAST) { 3268 *res = ULP_BITMAP_ISSET(parms->hdr_bitmap->bits, 3269 operand); 3270 } else { 3271 BNXT_TF_DBG(ERR, "header bit out of bounds %d\n", 3272 operand); 3273 rc = -EINVAL; 3274 } 3275 break; 3276 case BNXT_ULP_COND_OPC_HDR_BIT_NOT_SET: 3277 if (operand < BNXT_ULP_HDR_BIT_LAST) { 3278 *res = !ULP_BITMAP_ISSET(parms->hdr_bitmap->bits, 3279 operand); 3280 } else { 3281 BNXT_TF_DBG(ERR, "header bit out of bounds %d\n", 3282 operand); 3283 rc = -EINVAL; 3284 } 3285 break; 3286 case BNXT_ULP_COND_OPC_FIELD_BIT_IS_SET: 3287 rc = ulp_mapper_glb_field_tbl_get(parms, operand, &bit); 3288 if (rc) { 3289 BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n", 3290 operand); 3291 return -EINVAL; 3292 } 3293 *res = ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit); 3294 break; 3295 case BNXT_ULP_COND_OPC_FIELD_BIT_NOT_SET: 3296 rc = ulp_mapper_glb_field_tbl_get(parms, operand, &bit); 3297 if (rc) { 3298 BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n", 3299 operand); 3300 return -EINVAL; 3301 } 3302 *res = !ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit); 3303 break; 3304 case BNXT_ULP_COND_OPC_RF_IS_SET: 3305 if (!ulp_regfile_read(parms->regfile, operand, ®val)) { 3306 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", operand); 3307 return -EINVAL; 3308 } 3309 *res = regval != 0; 3310 break; 3311 case BNXT_ULP_COND_OPC_RF_NOT_SET: 3312 if (!ulp_regfile_read(parms->regfile, operand, ®val)) { 3313 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", operand); 3314 return -EINVAL; 3315 } 3316 *res = regval == 0; 3317 break; 3318 case BNXT_ULP_COND_OPC_FLOW_PAT_MATCH: 3319 *res = parms->flow_pattern_id == operand; 3320 break; 3321 case BNXT_ULP_COND_OPC_ACT_PAT_MATCH: 3322 *res = parms->act_pattern_id == operand; 3323 break; 3324 case BNXT_ULP_COND_OPC_EXT_MEM_IS_SET: 3325 if (bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype)) { 3326 BNXT_TF_DBG(ERR, "Failed to get the mem type\n"); 3327 return -EINVAL; 3328 } 3329 *res = (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT) ? 0 : 1; 3330 break; 3331 case BNXT_ULP_COND_OPC_EXT_MEM_NOT_SET: 3332 if (bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype)) { 3333 BNXT_TF_DBG(ERR, "Failed to get the mem type\n"); 3334 return -EINVAL; 3335 } 3336 *res = (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT) ? 1 : 0; 3337 break; 3338 case BNXT_ULP_COND_OPC_ENC_HDR_BIT_IS_SET: 3339 if (operand < BNXT_ULP_HDR_BIT_LAST) { 3340 *res = ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits, 3341 operand); 3342 } else { 3343 BNXT_TF_DBG(ERR, "header bit out of bounds %d\n", 3344 operand); 3345 rc = -EINVAL; 3346 } 3347 break; 3348 case BNXT_ULP_COND_OPC_ENC_HDR_BIT_NOT_SET: 3349 if (operand < BNXT_ULP_HDR_BIT_LAST) { 3350 *res = !ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits, 3351 operand); 3352 } else { 3353 BNXT_TF_DBG(ERR, "header bit out of bounds %d\n", 3354 operand); 3355 rc = -EINVAL; 3356 } 3357 break; 3358 default: 3359 BNXT_TF_DBG(ERR, "Invalid conditional opcode %d\n", opc); 3360 rc = -EINVAL; 3361 break; 3362 } 3363 return (rc); 3364 } 3365 3366 static int32_t 3367 ulp_mapper_func_opr_compute(struct bnxt_ulp_mapper_parms *parms, 3368 enum tf_dir dir, 3369 enum bnxt_ulp_func_src func_src, 3370 uint16_t func_opr, 3371 uint64_t *result) 3372 { 3373 uint64_t regval; 3374 bool shared; 3375 3376 *result = false; 3377 switch (func_src) { 3378 case BNXT_ULP_FUNC_SRC_COMP_FIELD: 3379 if (func_opr >= BNXT_ULP_CF_IDX_LAST) { 3380 BNXT_TF_DBG(ERR, "invalid index %u\n", func_opr); 3381 return -EINVAL; 3382 } 3383 *result = ULP_COMP_FLD_IDX_RD(parms, func_opr); 3384 break; 3385 case BNXT_ULP_FUNC_SRC_REGFILE: 3386 if (!ulp_regfile_read(parms->regfile, func_opr, ®val)) { 3387 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", func_opr); 3388 return -EINVAL; 3389 } 3390 *result = tfp_be_to_cpu_64(regval); 3391 break; 3392 case BNXT_ULP_FUNC_SRC_GLB_REGFILE: 3393 if (ulp_mapper_glb_resource_read(parms->mapper_data, dir, 3394 func_opr, ®val, &shared)) { 3395 BNXT_TF_DBG(ERR, "global regfile[%d] read failed.\n", 3396 func_opr); 3397 return -EINVAL; 3398 } 3399 *result = tfp_be_to_cpu_64(regval); 3400 break; 3401 case BNXT_ULP_FUNC_SRC_CONST: 3402 *result = func_opr; 3403 break; 3404 default: 3405 BNXT_TF_DBG(ERR, "invalid src code %u\n", func_src); 3406 return -EINVAL; 3407 } 3408 return 0; 3409 } 3410 3411 static int32_t 3412 ulp_mapper_func_info_process(struct bnxt_ulp_mapper_parms *parms, 3413 struct bnxt_ulp_mapper_tbl_info *tbl) 3414 { 3415 struct bnxt_ulp_mapper_func_info *func_info = &tbl->func_info; 3416 uint64_t res = 0, res1 = 0, res2 = 0; 3417 int32_t rc = 0; 3418 uint32_t process_src1 = 0, process_src2 = 0; 3419 3420 /* determine which functional operands to compute */ 3421 switch (func_info->func_opc) { 3422 case BNXT_ULP_FUNC_OPC_NOP: 3423 return rc; 3424 case BNXT_ULP_FUNC_OPC_EQ: 3425 case BNXT_ULP_FUNC_OPC_NE: 3426 case BNXT_ULP_FUNC_OPC_GE: 3427 case BNXT_ULP_FUNC_OPC_GT: 3428 case BNXT_ULP_FUNC_OPC_LE: 3429 case BNXT_ULP_FUNC_OPC_LT: 3430 process_src1 = 1; 3431 process_src2 = 1; 3432 break; 3433 case BNXT_ULP_FUNC_OPC_COPY_SRC1_TO_RF: 3434 process_src1 = 1; 3435 break; 3436 default: 3437 break; 3438 } 3439 3440 if (process_src1) { 3441 rc = ulp_mapper_func_opr_compute(parms, tbl->direction, 3442 func_info->func_src1, 3443 func_info->func_opr1, &res1); 3444 if (rc) 3445 return rc; 3446 } 3447 3448 if (process_src2) { 3449 rc = ulp_mapper_func_opr_compute(parms, tbl->direction, 3450 func_info->func_src2, 3451 func_info->func_opr2, &res2); 3452 if (rc) 3453 return rc; 3454 } 3455 3456 /* perform the functional opcode operations */ 3457 switch (func_info->func_opc) { 3458 case BNXT_ULP_FUNC_OPC_EQ: 3459 if (res1 == res2) 3460 res = 1; 3461 break; 3462 case BNXT_ULP_FUNC_OPC_NE: 3463 if (res1 != res2) 3464 res = 1; 3465 break; 3466 case BNXT_ULP_FUNC_OPC_GE: 3467 if (res1 >= res2) 3468 res = 1; 3469 break; 3470 case BNXT_ULP_FUNC_OPC_GT: 3471 if (res1 > res2) 3472 res = 1; 3473 break; 3474 case BNXT_ULP_FUNC_OPC_LE: 3475 if (res1 <= res2) 3476 res = 1; 3477 break; 3478 case BNXT_ULP_FUNC_OPC_LT: 3479 if (res1 < res2) 3480 res = 1; 3481 break; 3482 case BNXT_ULP_FUNC_OPC_COPY_SRC1_TO_RF: 3483 res = res1; 3484 break; 3485 case BNXT_ULP_FUNC_OPC_RSS_CONFIG: 3486 /* apply the rss config using pmd method */ 3487 return bnxt_rss_config_action_apply(parms); 3488 case BNXT_ULP_FUNC_OPC_GET_PARENT_MAC_ADDR: 3489 rc = bnxt_pmd_get_parent_mac_addr(parms, (uint8_t *)&res); 3490 if (rc) 3491 return -EINVAL; 3492 res = tfp_be_to_cpu_64(res); 3493 break; 3494 default: 3495 BNXT_TF_DBG(ERR, "invalid func code %u\n", func_info->func_opc); 3496 return -EINVAL; 3497 } 3498 if (ulp_regfile_write(parms->regfile, func_info->func_dst_opr, 3499 tfp_cpu_to_be_64(res))) { 3500 BNXT_TF_DBG(ERR, "Failed write the func_opc %u\n", 3501 func_info->func_dst_opr); 3502 return -EINVAL; 3503 } 3504 3505 return rc; 3506 } 3507 3508 /* 3509 * Processes a list of conditions and returns both a status and result of the 3510 * list. The status must be checked prior to verifying the result. 3511 * 3512 * returns 0 for success, negative on failure 3513 * returns res = 1 for true, res = 0 for false. 3514 */ 3515 static int32_t 3516 ulp_mapper_cond_opc_list_process(struct bnxt_ulp_mapper_parms *parms, 3517 enum bnxt_ulp_cond_list_opc list_opc, 3518 struct bnxt_ulp_mapper_cond_info *list, 3519 uint32_t num, 3520 int32_t *res) 3521 { 3522 uint32_t i; 3523 int32_t rc = 0, trc = 0; 3524 3525 switch (list_opc) { 3526 case BNXT_ULP_COND_LIST_OPC_AND: 3527 /* AND Defaults to true. */ 3528 *res = 1; 3529 break; 3530 case BNXT_ULP_COND_LIST_OPC_OR: 3531 /* OR Defaults to false. */ 3532 *res = 0; 3533 break; 3534 case BNXT_ULP_COND_LIST_OPC_TRUE: 3535 *res = 1; 3536 return rc; 3537 case BNXT_ULP_COND_LIST_OPC_FALSE: 3538 *res = 0; 3539 return rc; 3540 default: 3541 BNXT_TF_DBG(ERR, "Invalid conditional list opcode %d\n", 3542 list_opc); 3543 *res = 0; 3544 return -EINVAL; 3545 } 3546 3547 for (i = 0; i < num; i++) { 3548 rc = ulp_mapper_cond_opc_process(parms, 3549 list[i].cond_opcode, 3550 list[i].cond_operand, 3551 &trc); 3552 if (rc) 3553 return rc; 3554 3555 if (list_opc == BNXT_ULP_COND_LIST_OPC_AND) { 3556 /* early return if result is ever zero */ 3557 if (!trc) { 3558 *res = trc; 3559 return rc; 3560 } 3561 } else { 3562 /* early return if result is ever non-zero */ 3563 if (trc) { 3564 *res = trc; 3565 return rc; 3566 } 3567 } 3568 } 3569 3570 return rc; 3571 } 3572 3573 /* 3574 * Processes conflict resolution and returns both a status and result. 3575 * The status must be checked prior to verifying the result. 3576 * 3577 * returns 0 for success, negative on failure 3578 * returns res = 1 for true, res = 0 for false. 3579 */ 3580 static int32_t 3581 ulp_mapper_conflict_resolution_process(struct bnxt_ulp_mapper_parms *parms, 3582 struct bnxt_ulp_mapper_tbl_info *tbl, 3583 int32_t *res) 3584 { 3585 int32_t rc = 0; 3586 uint64_t regval; 3587 uint64_t comp_sig; 3588 3589 *res = 0; 3590 switch (tbl->accept_opcode) { 3591 case BNXT_ULP_ACCEPT_OPC_ALWAYS: 3592 *res = 1; 3593 break; 3594 case BNXT_ULP_ACCEPT_OPC_FLOW_SIG_ID_MATCH: 3595 /* perform the signature validation*/ 3596 if (tbl->resource_func == 3597 BNXT_ULP_RESOURCE_FUNC_GENERIC_TABLE) { 3598 /* Perform the check that generic table is hit or not */ 3599 if (!ulp_regfile_read(parms->regfile, 3600 BNXT_ULP_RF_IDX_GENERIC_TBL_MISS, 3601 ®val)) { 3602 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", 3603 BNXT_ULP_RF_IDX_GENERIC_TBL_MISS); 3604 return -EINVAL; 3605 } 3606 if (regval) { 3607 /* not a hit so no need to check flow sign*/ 3608 *res = 1; 3609 return rc; 3610 } 3611 } 3612 /* compare the new flow signature against stored one */ 3613 if (!ulp_regfile_read(parms->regfile, 3614 BNXT_ULP_RF_IDX_FLOW_SIG_ID, 3615 ®val)) { 3616 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", 3617 BNXT_ULP_RF_IDX_FLOW_SIG_ID); 3618 return -EINVAL; 3619 } 3620 comp_sig = ULP_COMP_FLD_IDX_RD(parms, 3621 BNXT_ULP_CF_IDX_FLOW_SIG_ID); 3622 regval = tfp_be_to_cpu_64(regval); 3623 if (comp_sig == regval) 3624 *res = 1; 3625 else 3626 BNXT_TF_DBG(ERR, "failed signature match 0x%016" 3627 PRIX64 ":%x\n", comp_sig, (uint32_t)regval); 3628 break; 3629 default: 3630 BNXT_TF_DBG(ERR, "Invalid accept opcode %d\n", 3631 tbl->accept_opcode); 3632 return -EINVAL; 3633 } 3634 return rc; 3635 } 3636 3637 static int32_t 3638 ulp_mapper_tbls_process(struct bnxt_ulp_mapper_parms *parms, uint32_t tid) 3639 { 3640 struct bnxt_ulp_mapper_cond_info *cond_tbls = NULL; 3641 enum bnxt_ulp_cond_list_opc cond_opc; 3642 struct bnxt_ulp_mapper_tbl_info *tbls; 3643 struct bnxt_ulp_mapper_tbl_info *tbl; 3644 uint32_t num_tbls, tbl_idx, num_cond_tbls; 3645 int32_t rc = -EINVAL, cond_rc = 0; 3646 int32_t cond_goto = 1; 3647 3648 cond_tbls = ulp_mapper_tmpl_reject_list_get(parms, tid, 3649 &num_cond_tbls, 3650 &cond_opc); 3651 /* 3652 * Process the reject list if exists, otherwise assume that the 3653 * template is allowed. 3654 */ 3655 if (cond_tbls && num_cond_tbls) { 3656 rc = ulp_mapper_cond_opc_list_process(parms, 3657 cond_opc, 3658 cond_tbls, 3659 num_cond_tbls, 3660 &cond_rc); 3661 if (rc) 3662 return rc; 3663 3664 /* Reject the template if True */ 3665 if (cond_rc) { 3666 BNXT_TF_DBG(ERR, "%s Template %d rejected.\n", 3667 ulp_mapper_tmpl_name_str(parms->tmpl_type), 3668 tid); 3669 return -EINVAL; 3670 } 3671 } 3672 3673 tbls = ulp_mapper_tbl_list_get(parms, tid, &num_tbls); 3674 if (!tbls || !num_tbls) { 3675 BNXT_TF_DBG(ERR, "No %s tables for %d:%d\n", 3676 ulp_mapper_tmpl_name_str(parms->tmpl_type), 3677 parms->dev_id, tid); 3678 return -EINVAL; 3679 } 3680 3681 for (tbl_idx = 0; tbl_idx < num_tbls && cond_goto;) { 3682 tbl = &tbls[tbl_idx]; 3683 cond_goto = tbl->execute_info.cond_true_goto; 3684 /* Process the conditional func code opcodes */ 3685 if (ulp_mapper_func_info_process(parms, tbl)) { 3686 BNXT_TF_DBG(ERR, "Failed to process cond update\n"); 3687 rc = -EINVAL; 3688 goto error; 3689 } 3690 3691 cond_tbls = ulp_mapper_tbl_execute_list_get(parms, tbl, 3692 &num_cond_tbls, 3693 &cond_opc); 3694 rc = ulp_mapper_cond_opc_list_process(parms, cond_opc, 3695 cond_tbls, num_cond_tbls, 3696 &cond_rc); 3697 if (rc) { 3698 BNXT_TF_DBG(ERR, "Failed to proc cond opc list (%d)\n", 3699 rc); 3700 goto error; 3701 } 3702 /* Skip the table if False */ 3703 if (!cond_rc) { 3704 cond_goto = tbl->execute_info.cond_false_goto; 3705 goto next_iteration; 3706 } 3707 3708 switch (tbl->resource_func) { 3709 case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE: 3710 rc = ulp_mapper_tcam_tbl_process(parms, tbl); 3711 break; 3712 case BNXT_ULP_RESOURCE_FUNC_EM_TABLE: 3713 rc = ulp_mapper_em_tbl_process(parms, tbl); 3714 break; 3715 case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE: 3716 rc = ulp_mapper_index_tbl_process(parms, tbl); 3717 break; 3718 case BNXT_ULP_RESOURCE_FUNC_IF_TABLE: 3719 rc = ulp_mapper_if_tbl_process(parms, tbl); 3720 break; 3721 case BNXT_ULP_RESOURCE_FUNC_GENERIC_TABLE: 3722 rc = ulp_mapper_gen_tbl_process(parms, tbl); 3723 break; 3724 case BNXT_ULP_RESOURCE_FUNC_CTRL_TABLE: 3725 rc = ulp_mapper_ctrl_tbl_process(parms, tbl); 3726 break; 3727 case BNXT_ULP_RESOURCE_FUNC_INVALID: 3728 rc = 0; 3729 break; 3730 default: 3731 BNXT_TF_DBG(ERR, "Unexpected mapper resource %d\n", 3732 tbl->resource_func); 3733 rc = -EINVAL; 3734 goto error; 3735 } 3736 3737 if (rc) { 3738 BNXT_TF_DBG(ERR, "Resource type %d failed\n", 3739 tbl->resource_func); 3740 goto error; 3741 } 3742 3743 /* perform the post table process */ 3744 rc = ulp_mapper_conflict_resolution_process(parms, tbl, 3745 &cond_rc); 3746 if (rc || !cond_rc) { 3747 BNXT_TF_DBG(ERR, "Failed due to conflict resolution\n"); 3748 rc = -EINVAL; 3749 goto error; 3750 } 3751 next_iteration: 3752 if (cond_goto == BNXT_ULP_COND_GOTO_REJECT) { 3753 BNXT_TF_DBG(ERR, "reject the flow\n"); 3754 rc = -EINVAL; 3755 goto error; 3756 } else if (cond_goto & BNXT_ULP_COND_GOTO_RF) { 3757 uint32_t rf_idx; 3758 uint64_t regval; 3759 3760 /* least significant 16 bits from reg_file index */ 3761 rf_idx = (uint32_t)(cond_goto & 0xFFFF); 3762 if (!ulp_regfile_read(parms->regfile, rf_idx, 3763 ®val)) { 3764 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", 3765 rf_idx); 3766 rc = -EINVAL; 3767 goto error; 3768 } 3769 cond_goto = (int32_t)regval; 3770 } 3771 3772 if (cond_goto < 0 && ((int32_t)tbl_idx + cond_goto) < 0) { 3773 BNXT_TF_DBG(ERR, "invalid conditional goto %d\n", 3774 cond_goto); 3775 goto error; 3776 } 3777 tbl_idx += cond_goto; 3778 } 3779 3780 return rc; 3781 error: 3782 BNXT_TF_DBG(ERR, "%s tables failed creation for %d:%d\n", 3783 ulp_mapper_tmpl_name_str(parms->tmpl_type), 3784 parms->dev_id, tid); 3785 return rc; 3786 } 3787 3788 static int32_t 3789 ulp_mapper_resource_free(struct bnxt_ulp_context *ulp, 3790 uint32_t fid, 3791 struct ulp_flow_db_res_params *res) 3792 { 3793 struct tf *tfp; 3794 int32_t rc = 0; 3795 3796 if (!res || !ulp) { 3797 BNXT_TF_DBG(ERR, "Unable to free resource\n "); 3798 return -EINVAL; 3799 } 3800 if (res->fdb_flags & ULP_FDB_FLAG_SHARED_SESSION) 3801 tfp = bnxt_ulp_cntxt_tfp_get(ulp, BNXT_ULP_SHARED_SESSION_YES); 3802 else 3803 tfp = bnxt_ulp_cntxt_tfp_get(ulp, BNXT_ULP_SHARED_SESSION_NO); 3804 if (!tfp) { 3805 BNXT_TF_DBG(ERR, "Unable to free resource failed to get tfp\n"); 3806 return -EINVAL; 3807 } 3808 3809 switch (res->resource_func) { 3810 case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE: 3811 rc = ulp_mapper_tcam_entry_free(ulp, tfp, res); 3812 break; 3813 case BNXT_ULP_RESOURCE_FUNC_EM_TABLE: 3814 rc = ulp_mapper_em_entry_free(ulp, tfp, res); 3815 break; 3816 case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE: 3817 rc = ulp_mapper_index_entry_free(ulp, tfp, res); 3818 break; 3819 case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER: 3820 rc = ulp_mapper_ident_free(ulp, tfp, res); 3821 break; 3822 case BNXT_ULP_RESOURCE_FUNC_HW_FID: 3823 rc = ulp_mapper_mark_free(ulp, res); 3824 break; 3825 case BNXT_ULP_RESOURCE_FUNC_PARENT_FLOW: 3826 rc = ulp_mapper_parent_flow_free(ulp, fid, res); 3827 break; 3828 case BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW: 3829 rc = ulp_mapper_child_flow_free(ulp, fid, res); 3830 break; 3831 case BNXT_ULP_RESOURCE_FUNC_GENERIC_TABLE: 3832 rc = ulp_mapper_gen_tbl_res_free(ulp, res); 3833 break; 3834 default: 3835 break; 3836 } 3837 3838 return rc; 3839 } 3840 3841 int32_t 3842 ulp_mapper_resources_free(struct bnxt_ulp_context *ulp_ctx, 3843 enum bnxt_ulp_fdb_type flow_type, 3844 uint32_t fid) 3845 { 3846 struct ulp_flow_db_res_params res_parms = { 0 }; 3847 int32_t rc, trc; 3848 3849 if (!ulp_ctx) { 3850 BNXT_TF_DBG(ERR, "Invalid parms, unable to free flow\n"); 3851 return -EINVAL; 3852 } 3853 3854 /* 3855 * Set the critical resource on the first resource del, then iterate 3856 * while status is good 3857 */ 3858 res_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_YES; 3859 3860 rc = ulp_flow_db_resource_del(ulp_ctx, flow_type, fid, &res_parms); 3861 3862 if (rc) { 3863 /* 3864 * This is unexpected on the first call to resource del. 3865 * It likely means that the flow did not exist in the flow db. 3866 */ 3867 BNXT_TF_DBG(ERR, "Flow[%d][0x%08x] failed to free (rc=%d)\n", 3868 flow_type, fid, rc); 3869 return rc; 3870 } 3871 3872 while (!rc) { 3873 trc = ulp_mapper_resource_free(ulp_ctx, fid, &res_parms); 3874 if (trc) 3875 /* 3876 * On fail, we still need to attempt to free the 3877 * remaining resources. Don't return 3878 */ 3879 BNXT_TF_DBG(ERR, 3880 "Flow[%d][0x%x] Res[%d][0x%016" PRIX64 3881 "] failed rc=%d.\n", 3882 flow_type, fid, res_parms.resource_func, 3883 res_parms.resource_hndl, trc); 3884 3885 /* All subsequent call require the non-critical_resource */ 3886 res_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO; 3887 3888 rc = ulp_flow_db_resource_del(ulp_ctx, 3889 flow_type, 3890 fid, 3891 &res_parms); 3892 } 3893 3894 /* Free the Flow ID since we've removed all resources */ 3895 rc = ulp_flow_db_fid_free(ulp_ctx, flow_type, fid); 3896 3897 return rc; 3898 } 3899 3900 static void 3901 ulp_mapper_glb_resource_info_deinit(struct bnxt_ulp_context *ulp_ctx, 3902 struct bnxt_ulp_mapper_data *mapper_data) 3903 { 3904 struct bnxt_ulp_mapper_glb_resource_entry *ent; 3905 struct ulp_flow_db_res_params res; 3906 uint32_t dir, idx; 3907 3908 /* Iterate the global resources and process each one */ 3909 for (dir = TF_DIR_RX; dir < TF_DIR_MAX; dir++) { 3910 for (idx = 0; idx < BNXT_ULP_GLB_RF_IDX_LAST; idx++) { 3911 ent = &mapper_data->glb_res_tbl[dir][idx]; 3912 if (ent->resource_func == 3913 BNXT_ULP_RESOURCE_FUNC_INVALID || 3914 ent->shared) 3915 continue; 3916 memset(&res, 0, sizeof(struct ulp_flow_db_res_params)); 3917 res.resource_func = ent->resource_func; 3918 res.direction = dir; 3919 res.resource_type = ent->resource_type; 3920 /*convert it from BE to cpu */ 3921 res.resource_hndl = 3922 tfp_be_to_cpu_64(ent->resource_hndl); 3923 ulp_mapper_resource_free(ulp_ctx, 0, &res); 3924 } 3925 } 3926 } 3927 3928 int32_t 3929 ulp_mapper_flow_destroy(struct bnxt_ulp_context *ulp_ctx, 3930 enum bnxt_ulp_fdb_type flow_type, 3931 uint32_t fid) 3932 { 3933 int32_t rc; 3934 3935 if (!ulp_ctx) { 3936 BNXT_TF_DBG(ERR, "Invalid parms, unable to free flow\n"); 3937 return -EINVAL; 3938 } 3939 3940 rc = ulp_mapper_resources_free(ulp_ctx, flow_type, fid); 3941 return rc; 3942 } 3943 3944 /* Function to handle the mapping of the Flow to be compatible 3945 * with the underlying hardware. 3946 */ 3947 int32_t 3948 ulp_mapper_flow_create(struct bnxt_ulp_context *ulp_ctx, 3949 struct bnxt_ulp_mapper_create_parms *cparms) 3950 { 3951 struct bnxt_ulp_mapper_parms parms; 3952 struct ulp_regfile regfile; 3953 int32_t rc = 0, trc; 3954 3955 if (!ulp_ctx || !cparms) 3956 return -EINVAL; 3957 3958 /* Initialize the parms structure */ 3959 memset(&parms, 0, sizeof(parms)); 3960 parms.act_prop = cparms->act_prop; 3961 parms.act_bitmap = cparms->act; 3962 parms.hdr_bitmap = cparms->hdr_bitmap; 3963 parms.enc_hdr_bitmap = cparms->enc_hdr_bitmap; 3964 parms.regfile = ®file; 3965 parms.hdr_field = cparms->hdr_field; 3966 parms.enc_field = cparms->enc_field; 3967 parms.fld_bitmap = cparms->fld_bitmap; 3968 parms.comp_fld = cparms->comp_fld; 3969 parms.ulp_ctx = ulp_ctx; 3970 parms.act_tid = cparms->act_tid; 3971 parms.class_tid = cparms->class_tid; 3972 parms.flow_type = cparms->flow_type; 3973 parms.parent_flow = cparms->parent_flow; 3974 parms.child_flow = cparms->child_flow; 3975 parms.fid = cparms->flow_id; 3976 parms.tun_idx = cparms->tun_idx; 3977 parms.app_priority = cparms->app_priority; 3978 parms.flow_pattern_id = cparms->flow_pattern_id; 3979 parms.act_pattern_id = cparms->act_pattern_id; 3980 parms.app_id = cparms->app_id; 3981 parms.port_id = cparms->port_id; 3982 3983 /* Get the device id from the ulp context */ 3984 if (bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &parms.dev_id)) { 3985 BNXT_TF_DBG(ERR, "Invalid ulp context\n"); 3986 return -EINVAL; 3987 } 3988 3989 /* Get the device params, it will be used in later processing */ 3990 parms.device_params = bnxt_ulp_device_params_get(parms.dev_id); 3991 if (!parms.device_params) { 3992 BNXT_TF_DBG(ERR, "No device parms for device id %d\n", 3993 parms.dev_id); 3994 return -EINVAL; 3995 } 3996 3997 /* 3998 * Get the mapper data for dynamic mapper data such as default 3999 * ids. 4000 */ 4001 parms.mapper_data = (struct bnxt_ulp_mapper_data *) 4002 bnxt_ulp_cntxt_ptr2_mapper_data_get(ulp_ctx); 4003 if (!parms.mapper_data) { 4004 BNXT_TF_DBG(ERR, "Failed to get the ulp mapper data\n"); 4005 return -EINVAL; 4006 } 4007 4008 /* initialize the registry file for further processing */ 4009 if (!ulp_regfile_init(parms.regfile)) { 4010 BNXT_TF_DBG(ERR, "regfile initialization failed.\n"); 4011 return -EINVAL; 4012 } 4013 4014 /* Process the action template list from the selected action table*/ 4015 if (parms.act_tid) { 4016 parms.tmpl_type = BNXT_ULP_TEMPLATE_TYPE_ACTION; 4017 /* Process the action template tables */ 4018 rc = ulp_mapper_tbls_process(&parms, parms.act_tid); 4019 if (rc) 4020 goto flow_error; 4021 cparms->shared_hndl = parms.shared_hndl; 4022 } 4023 4024 if (parms.class_tid) { 4025 parms.tmpl_type = BNXT_ULP_TEMPLATE_TYPE_CLASS; 4026 4027 /* Process the class template tables.*/ 4028 rc = ulp_mapper_tbls_process(&parms, parms.class_tid); 4029 if (rc) 4030 goto flow_error; 4031 } 4032 4033 /* setup the parent-child details */ 4034 if (parms.parent_flow) { 4035 /* create a parent flow details */ 4036 rc = ulp_flow_db_parent_flow_create(&parms); 4037 if (rc) 4038 goto flow_error; 4039 } else if (parms.child_flow) { 4040 /* create a child flow details */ 4041 rc = ulp_flow_db_child_flow_create(&parms); 4042 if (rc) 4043 goto flow_error; 4044 } 4045 4046 return rc; 4047 4048 flow_error: 4049 /* Free all resources that were allocated during flow creation */ 4050 trc = ulp_mapper_flow_destroy(ulp_ctx, parms.flow_type, 4051 parms.fid); 4052 if (trc) 4053 BNXT_TF_DBG(ERR, "Failed to free all resources rc=%d\n", trc); 4054 4055 return rc; 4056 } 4057 4058 int32_t 4059 ulp_mapper_init(struct bnxt_ulp_context *ulp_ctx) 4060 { 4061 struct bnxt_ulp_mapper_data *data; 4062 struct tf *tfp; 4063 int32_t rc; 4064 4065 if (!ulp_ctx) 4066 return -EINVAL; 4067 4068 tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO); 4069 if (!tfp) 4070 return -EINVAL; 4071 4072 data = rte_zmalloc("ulp_mapper_data", 4073 sizeof(struct bnxt_ulp_mapper_data), 0); 4074 if (!data) { 4075 BNXT_TF_DBG(ERR, "Failed to allocate the mapper data\n"); 4076 return -ENOMEM; 4077 } 4078 4079 if (bnxt_ulp_cntxt_ptr2_mapper_data_set(ulp_ctx, data)) { 4080 BNXT_TF_DBG(ERR, "Failed to set mapper data in context\n"); 4081 /* Don't call deinit since the prof_func wasn't allocated. */ 4082 rte_free(data); 4083 return -ENOMEM; 4084 } 4085 4086 /* Allocate the global resource ids */ 4087 rc = ulp_mapper_glb_resource_info_init(ulp_ctx, data); 4088 if (rc) { 4089 BNXT_TF_DBG(ERR, "Failed to initialize global resource ids\n"); 4090 goto error; 4091 } 4092 4093 /* 4094 * Only initialize the app global resources if a shared session was 4095 * created. 4096 */ 4097 if (bnxt_ulp_cntxt_shared_session_enabled(ulp_ctx)) { 4098 rc = ulp_mapper_app_glb_resource_info_init(ulp_ctx, data); 4099 if (rc) { 4100 BNXT_TF_DBG(ERR, "Failed to init app glb resources\n"); 4101 goto error; 4102 } 4103 } 4104 4105 /* Allocate the generic table list */ 4106 rc = ulp_mapper_generic_tbl_list_init(data); 4107 if (rc) { 4108 BNXT_TF_DBG(ERR, "Failed to initialize generic tbl list\n"); 4109 goto error; 4110 } 4111 4112 return 0; 4113 error: 4114 /* Ignore the return code in favor of returning the original error. */ 4115 ulp_mapper_deinit(ulp_ctx); 4116 return rc; 4117 } 4118 4119 void 4120 ulp_mapper_deinit(struct bnxt_ulp_context *ulp_ctx) 4121 { 4122 struct bnxt_ulp_mapper_data *data; 4123 struct tf *tfp; 4124 4125 if (!ulp_ctx) { 4126 BNXT_TF_DBG(ERR, 4127 "Failed to acquire ulp context, so data may not be released.\n"); 4128 return; 4129 } 4130 4131 data = (struct bnxt_ulp_mapper_data *) 4132 bnxt_ulp_cntxt_ptr2_mapper_data_get(ulp_ctx); 4133 if (!data) { 4134 /* Go ahead and return since there is no allocated data. */ 4135 BNXT_TF_DBG(ERR, "No data appears to have been allocated.\n"); 4136 return; 4137 } 4138 4139 tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO); 4140 if (!tfp) { 4141 BNXT_TF_DBG(ERR, "Failed to acquire tfp.\n"); 4142 /* Free the mapper data regardless of errors. */ 4143 goto free_mapper_data; 4144 } 4145 4146 /* Free the global resource info table entries */ 4147 ulp_mapper_glb_resource_info_deinit(ulp_ctx, data); 4148 4149 free_mapper_data: 4150 /* Free the generic table */ 4151 (void)ulp_mapper_generic_tbl_list_deinit(data); 4152 4153 rte_free(data); 4154 /* Reset the data pointer within the ulp_ctx. */ 4155 bnxt_ulp_cntxt_ptr2_mapper_data_set(ulp_ctx, NULL); 4156 } 4157