1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2019-2020 Broadcom 3 * All rights reserved. 4 */ 5 6 /* Truflow Table APIs and supporting code */ 7 8 #include <rte_common.h> 9 10 #include "tf_tbl.h" 11 #include "tf_common.h" 12 #include "tf_rm.h" 13 #include "tf_util.h" 14 #include "tf_msg.h" 15 #include "tfp.h" 16 #include "tf_shadow_tbl.h" 17 #include "tf_session.h" 18 #include "tf_device.h" 19 20 21 struct tf; 22 23 /** 24 * Table DBs. 25 */ 26 static void *tbl_db[TF_DIR_MAX]; 27 28 /** 29 * Table Shadow DBs 30 */ 31 static void *shadow_tbl_db[TF_DIR_MAX]; 32 33 /** 34 * Init flag, set on bind and cleared on unbind 35 */ 36 static uint8_t init; 37 38 /** 39 * Shadow init flag, set on bind and cleared on unbind 40 */ 41 static uint8_t shadow_init; 42 43 int 44 tf_tbl_bind(struct tf *tfp, 45 struct tf_tbl_cfg_parms *parms) 46 { 47 int rc, d, i; 48 struct tf_rm_alloc_info info; 49 struct tf_rm_free_db_parms fparms; 50 struct tf_shadow_tbl_free_db_parms fshadow; 51 struct tf_rm_get_alloc_info_parms ainfo; 52 struct tf_shadow_tbl_cfg_parms shadow_cfg; 53 struct tf_shadow_tbl_create_db_parms shadow_cdb; 54 struct tf_rm_create_db_parms db_cfg = { 0 }; 55 56 TF_CHECK_PARMS2(tfp, parms); 57 58 if (init) { 59 TFP_DRV_LOG(ERR, 60 "Table DB already initialized\n"); 61 return -EINVAL; 62 } 63 64 db_cfg.num_elements = parms->num_elements; 65 db_cfg.type = TF_DEVICE_MODULE_TYPE_TABLE; 66 db_cfg.num_elements = parms->num_elements; 67 db_cfg.cfg = parms->cfg; 68 69 for (d = 0; d < TF_DIR_MAX; d++) { 70 db_cfg.dir = d; 71 db_cfg.alloc_cnt = parms->resources->tbl_cnt[d].cnt; 72 db_cfg.rm_db = &tbl_db[d]; 73 rc = tf_rm_create_db(tfp, &db_cfg); 74 if (rc) { 75 TFP_DRV_LOG(ERR, 76 "%s: Table DB creation failed\n", 77 tf_dir_2_str(d)); 78 79 return rc; 80 } 81 } 82 83 /* Initialize the Shadow Table. */ 84 if (parms->shadow_copy) { 85 for (d = 0; d < TF_DIR_MAX; d++) { 86 memset(&shadow_cfg, 0, sizeof(shadow_cfg)); 87 memset(&shadow_cdb, 0, sizeof(shadow_cdb)); 88 /* Get the base addresses of the tables */ 89 for (i = 0; i < TF_TBL_TYPE_MAX; i++) { 90 memset(&info, 0, sizeof(info)); 91 92 if (!parms->resources->tbl_cnt[d].cnt[i]) 93 continue; 94 ainfo.rm_db = tbl_db[d]; 95 ainfo.db_index = i; 96 ainfo.info = &info; 97 rc = tf_rm_get_info(&ainfo); 98 if (rc) 99 goto error; 100 101 shadow_cfg.base_addr[i] = info.entry.start; 102 } 103 104 /* Create the shadow db */ 105 shadow_cfg.alloc_cnt = 106 parms->resources->tbl_cnt[d].cnt; 107 shadow_cfg.num_entries = parms->num_elements; 108 109 shadow_cdb.shadow_db = &shadow_tbl_db[d]; 110 shadow_cdb.cfg = &shadow_cfg; 111 rc = tf_shadow_tbl_create_db(&shadow_cdb); 112 if (rc) { 113 TFP_DRV_LOG(ERR, 114 "Shadow TBL DB creation failed " 115 "rc=%d\n", rc); 116 goto error; 117 } 118 } 119 shadow_init = 1; 120 } 121 122 init = 1; 123 124 TFP_DRV_LOG(INFO, 125 "Table Type - initialized\n"); 126 127 return 0; 128 error: 129 for (d = 0; d < TF_DIR_MAX; d++) { 130 memset(&fparms, 0, sizeof(fparms)); 131 fparms.dir = d; 132 fparms.rm_db = tbl_db[d]; 133 /* Ignoring return here since we are in the error case */ 134 (void)tf_rm_free_db(tfp, &fparms); 135 136 if (parms->shadow_copy) { 137 fshadow.shadow_db = shadow_tbl_db[d]; 138 tf_shadow_tbl_free_db(&fshadow); 139 shadow_tbl_db[d] = NULL; 140 } 141 142 tbl_db[d] = NULL; 143 } 144 145 shadow_init = 0; 146 init = 0; 147 148 return rc; 149 } 150 151 int 152 tf_tbl_unbind(struct tf *tfp) 153 { 154 int rc; 155 int i; 156 struct tf_rm_free_db_parms fparms = { 0 }; 157 struct tf_shadow_tbl_free_db_parms fshadow; 158 159 TF_CHECK_PARMS1(tfp); 160 161 /* Bail if nothing has been initialized */ 162 if (!init) { 163 TFP_DRV_LOG(INFO, 164 "No Table DBs created\n"); 165 return 0; 166 } 167 168 for (i = 0; i < TF_DIR_MAX; i++) { 169 fparms.dir = i; 170 fparms.rm_db = tbl_db[i]; 171 rc = tf_rm_free_db(tfp, &fparms); 172 if (rc) 173 return rc; 174 175 tbl_db[i] = NULL; 176 177 if (shadow_init) { 178 memset(&fshadow, 0, sizeof(fshadow)); 179 fshadow.shadow_db = shadow_tbl_db[i]; 180 tf_shadow_tbl_free_db(&fshadow); 181 shadow_tbl_db[i] = NULL; 182 } 183 } 184 185 init = 0; 186 shadow_init = 0; 187 188 return 0; 189 } 190 191 int 192 tf_tbl_alloc(struct tf *tfp __rte_unused, 193 struct tf_tbl_alloc_parms *parms) 194 { 195 int rc; 196 uint32_t idx; 197 struct tf_rm_allocate_parms aparms = { 0 }; 198 199 TF_CHECK_PARMS2(tfp, parms); 200 201 if (!init) { 202 TFP_DRV_LOG(ERR, 203 "%s: No Table DBs created\n", 204 tf_dir_2_str(parms->dir)); 205 return -EINVAL; 206 } 207 208 /* Allocate requested element */ 209 aparms.rm_db = tbl_db[parms->dir]; 210 aparms.db_index = parms->type; 211 aparms.index = &idx; 212 rc = tf_rm_allocate(&aparms); 213 if (rc) { 214 TFP_DRV_LOG(ERR, 215 "%s: Failed allocate, type:%d\n", 216 tf_dir_2_str(parms->dir), 217 parms->type); 218 return rc; 219 } 220 221 *parms->idx = idx; 222 223 return 0; 224 } 225 226 int 227 tf_tbl_free(struct tf *tfp __rte_unused, 228 struct tf_tbl_free_parms *parms) 229 { 230 int rc; 231 struct tf_rm_is_allocated_parms aparms = { 0 }; 232 struct tf_rm_free_parms fparms = { 0 }; 233 struct tf_shadow_tbl_remove_parms shparms; 234 int allocated = 0; 235 236 TF_CHECK_PARMS2(tfp, parms); 237 238 if (!init) { 239 TFP_DRV_LOG(ERR, 240 "%s: No Table DBs created\n", 241 tf_dir_2_str(parms->dir)); 242 return -EINVAL; 243 } 244 245 /* Check if element is in use */ 246 aparms.rm_db = tbl_db[parms->dir]; 247 aparms.db_index = parms->type; 248 aparms.index = parms->idx; 249 aparms.allocated = &allocated; 250 rc = tf_rm_is_allocated(&aparms); 251 if (rc) 252 return rc; 253 254 if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) { 255 TFP_DRV_LOG(ERR, 256 "%s: Entry already free, type:%d, index:%d\n", 257 tf_dir_2_str(parms->dir), 258 parms->type, 259 parms->idx); 260 return -EINVAL; 261 } 262 263 /* 264 * The Shadow mgmt, if enabled, determines if the entry needs 265 * to be deleted. 266 */ 267 if (shadow_init) { 268 memset(&shparms, 0, sizeof(shparms)); 269 shparms.shadow_db = shadow_tbl_db[parms->dir]; 270 shparms.fparms = parms; 271 rc = tf_shadow_tbl_remove(&shparms); 272 if (rc) { 273 /* 274 * Should not get here, log it and let the entry be 275 * deleted. 276 */ 277 TFP_DRV_LOG(ERR, "%s: Shadow free fail, " 278 "type:%d index:%d deleting the entry.\n", 279 tf_dir_2_str(parms->dir), 280 parms->type, 281 parms->idx); 282 } else { 283 /* 284 * If the entry still has references, just return the 285 * ref count to the caller. No need to remove entry 286 * from rm. 287 */ 288 if (parms->ref_cnt >= 1) 289 return rc; 290 } 291 } 292 293 /* Free requested element */ 294 fparms.rm_db = tbl_db[parms->dir]; 295 fparms.db_index = parms->type; 296 fparms.index = parms->idx; 297 rc = tf_rm_free(&fparms); 298 if (rc) { 299 TFP_DRV_LOG(ERR, 300 "%s: Free failed, type:%d, index:%d\n", 301 tf_dir_2_str(parms->dir), 302 parms->type, 303 parms->idx); 304 return rc; 305 } 306 307 return 0; 308 } 309 310 int 311 tf_tbl_alloc_search(struct tf *tfp, 312 struct tf_tbl_alloc_search_parms *parms) 313 { 314 int rc, frc; 315 uint32_t idx; 316 struct tf_session *tfs; 317 struct tf_dev_info *dev; 318 struct tf_tbl_alloc_parms aparms; 319 struct tf_shadow_tbl_search_parms sparms; 320 struct tf_shadow_tbl_bind_index_parms bparms; 321 struct tf_tbl_free_parms fparms; 322 323 TF_CHECK_PARMS2(tfp, parms); 324 325 if (!shadow_init || !shadow_tbl_db[parms->dir]) { 326 TFP_DRV_LOG(ERR, "%s: Shadow TBL not initialized.\n", 327 tf_dir_2_str(parms->dir)); 328 return -EINVAL; 329 } 330 331 memset(&sparms, 0, sizeof(sparms)); 332 sparms.sparms = parms; 333 sparms.shadow_db = shadow_tbl_db[parms->dir]; 334 rc = tf_shadow_tbl_search(&sparms); 335 if (rc) 336 return rc; 337 338 /* 339 * The app didn't request us to alloc the entry, so return now. 340 * The hit should have been updated in the original search parm. 341 */ 342 if (!parms->alloc || parms->search_status != MISS) 343 return rc; 344 345 /* Retrieve the session information */ 346 rc = tf_session_get_session(tfp, &tfs); 347 if (rc) { 348 TFP_DRV_LOG(ERR, 349 "%s: Failed to lookup session, rc:%s\n", 350 tf_dir_2_str(parms->dir), 351 strerror(-rc)); 352 return rc; 353 } 354 355 /* Retrieve the device information */ 356 rc = tf_session_get_device(tfs, &dev); 357 if (rc) { 358 TFP_DRV_LOG(ERR, 359 "%s: Failed to lookup device, rc:%s\n", 360 tf_dir_2_str(parms->dir), 361 strerror(-rc)); 362 return rc; 363 } 364 365 /* Allocate the index */ 366 if (dev->ops->tf_dev_alloc_tbl == NULL) { 367 rc = -EOPNOTSUPP; 368 TFP_DRV_LOG(ERR, 369 "%s: Operation not supported, rc:%s\n", 370 tf_dir_2_str(parms->dir), 371 strerror(-rc)); 372 return -EOPNOTSUPP; 373 } 374 375 memset(&aparms, 0, sizeof(aparms)); 376 aparms.dir = parms->dir; 377 aparms.type = parms->type; 378 aparms.tbl_scope_id = parms->tbl_scope_id; 379 aparms.idx = &idx; 380 rc = dev->ops->tf_dev_alloc_tbl(tfp, &aparms); 381 if (rc) { 382 TFP_DRV_LOG(ERR, 383 "%s: Table allocation failed, rc:%s\n", 384 tf_dir_2_str(parms->dir), 385 strerror(-rc)); 386 return rc; 387 } 388 389 /* Bind the allocated index to the data */ 390 memset(&bparms, 0, sizeof(bparms)); 391 bparms.shadow_db = shadow_tbl_db[parms->dir]; 392 bparms.dir = parms->dir; 393 bparms.type = parms->type; 394 bparms.idx = idx; 395 bparms.data = parms->result; 396 bparms.data_sz_in_bytes = parms->result_sz_in_bytes; 397 bparms.hb_handle = sparms.hb_handle; 398 rc = tf_shadow_tbl_bind_index(&bparms); 399 if (rc) { 400 /* Error binding entry, need to free the allocated idx */ 401 if (dev->ops->tf_dev_free_tbl == NULL) { 402 rc = -EOPNOTSUPP; 403 TFP_DRV_LOG(ERR, 404 "%s: Operation not supported, rc:%s\n", 405 tf_dir_2_str(parms->dir), 406 strerror(-rc)); 407 return rc; 408 } 409 410 memset(&fparms, 0, sizeof(fparms)); 411 fparms.dir = parms->dir; 412 fparms.type = parms->type; 413 fparms.idx = idx; 414 frc = dev->ops->tf_dev_free_tbl(tfp, &fparms); 415 if (frc) { 416 TFP_DRV_LOG(ERR, 417 "%s: Failed free index allocated during " 418 "search. rc=%s\n", 419 tf_dir_2_str(parms->dir), 420 strerror(-frc)); 421 /* return the original failure. */ 422 return rc; 423 } 424 } 425 426 parms->idx = idx; 427 428 return rc; 429 } 430 431 int 432 tf_tbl_set(struct tf *tfp, 433 struct tf_tbl_set_parms *parms) 434 { 435 int rc; 436 int allocated = 0; 437 uint16_t hcapi_type; 438 struct tf_rm_is_allocated_parms aparms = { 0 }; 439 struct tf_rm_get_hcapi_parms hparms = { 0 }; 440 441 TF_CHECK_PARMS3(tfp, parms, parms->data); 442 443 if (!init) { 444 TFP_DRV_LOG(ERR, 445 "%s: No Table DBs created\n", 446 tf_dir_2_str(parms->dir)); 447 return -EINVAL; 448 } 449 450 /* Verify that the entry has been previously allocated */ 451 aparms.rm_db = tbl_db[parms->dir]; 452 aparms.db_index = parms->type; 453 aparms.index = parms->idx; 454 aparms.allocated = &allocated; 455 rc = tf_rm_is_allocated(&aparms); 456 if (rc) 457 return rc; 458 459 if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) { 460 TFP_DRV_LOG(ERR, 461 "%s, Invalid or not allocated index, type:%d, idx:%d\n", 462 tf_dir_2_str(parms->dir), 463 parms->type, 464 parms->idx); 465 return -EINVAL; 466 } 467 468 /* Set the entry */ 469 hparms.rm_db = tbl_db[parms->dir]; 470 hparms.db_index = parms->type; 471 hparms.hcapi_type = &hcapi_type; 472 rc = tf_rm_get_hcapi_type(&hparms); 473 if (rc) { 474 TFP_DRV_LOG(ERR, 475 "%s, Failed type lookup, type:%d, rc:%s\n", 476 tf_dir_2_str(parms->dir), 477 parms->type, 478 strerror(-rc)); 479 return rc; 480 } 481 482 rc = tf_msg_set_tbl_entry(tfp, 483 parms->dir, 484 hcapi_type, 485 parms->data_sz_in_bytes, 486 parms->data, 487 parms->idx); 488 if (rc) { 489 TFP_DRV_LOG(ERR, 490 "%s, Set failed, type:%d, rc:%s\n", 491 tf_dir_2_str(parms->dir), 492 parms->type, 493 strerror(-rc)); 494 return rc; 495 } 496 497 return 0; 498 } 499 500 int 501 tf_tbl_get(struct tf *tfp, 502 struct tf_tbl_get_parms *parms) 503 { 504 int rc; 505 uint16_t hcapi_type; 506 int allocated = 0; 507 struct tf_rm_is_allocated_parms aparms = { 0 }; 508 struct tf_rm_get_hcapi_parms hparms = { 0 }; 509 510 TF_CHECK_PARMS3(tfp, parms, parms->data); 511 512 if (!init) { 513 TFP_DRV_LOG(ERR, 514 "%s: No Table DBs created\n", 515 tf_dir_2_str(parms->dir)); 516 return -EINVAL; 517 } 518 519 /* Verify that the entry has been previously allocated */ 520 aparms.rm_db = tbl_db[parms->dir]; 521 aparms.db_index = parms->type; 522 aparms.index = parms->idx; 523 aparms.allocated = &allocated; 524 rc = tf_rm_is_allocated(&aparms); 525 if (rc) 526 return rc; 527 528 if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) { 529 TFP_DRV_LOG(ERR, 530 "%s, Invalid or not allocated index, type:%d, idx:%d\n", 531 tf_dir_2_str(parms->dir), 532 parms->type, 533 parms->idx); 534 return -EINVAL; 535 } 536 537 /* Set the entry */ 538 hparms.rm_db = tbl_db[parms->dir]; 539 hparms.db_index = parms->type; 540 hparms.hcapi_type = &hcapi_type; 541 rc = tf_rm_get_hcapi_type(&hparms); 542 if (rc) { 543 TFP_DRV_LOG(ERR, 544 "%s, Failed type lookup, type:%d, rc:%s\n", 545 tf_dir_2_str(parms->dir), 546 parms->type, 547 strerror(-rc)); 548 return rc; 549 } 550 551 /* Get the entry */ 552 rc = tf_msg_get_tbl_entry(tfp, 553 parms->dir, 554 hcapi_type, 555 parms->data_sz_in_bytes, 556 parms->data, 557 parms->idx); 558 if (rc) { 559 TFP_DRV_LOG(ERR, 560 "%s, Get failed, type:%d, rc:%s\n", 561 tf_dir_2_str(parms->dir), 562 parms->type, 563 strerror(-rc)); 564 return rc; 565 } 566 567 return 0; 568 } 569 570 int 571 tf_tbl_bulk_get(struct tf *tfp, 572 struct tf_tbl_get_bulk_parms *parms) 573 { 574 int rc; 575 uint16_t hcapi_type; 576 struct tf_rm_get_hcapi_parms hparms = { 0 }; 577 struct tf_rm_check_indexes_in_range_parms cparms = { 0 }; 578 579 TF_CHECK_PARMS2(tfp, parms); 580 581 if (!init) { 582 TFP_DRV_LOG(ERR, 583 "%s: No Table DBs created\n", 584 tf_dir_2_str(parms->dir)); 585 586 return -EINVAL; 587 } 588 589 /* Verify that the entries are in the range of reserved resources. */ 590 cparms.rm_db = tbl_db[parms->dir]; 591 cparms.db_index = parms->type; 592 cparms.starting_index = parms->starting_idx; 593 cparms.num_entries = parms->num_entries; 594 595 rc = tf_rm_check_indexes_in_range(&cparms); 596 if (rc) { 597 TFP_DRV_LOG(ERR, 598 "%s, Invalid or %d index starting from %d" 599 " not in range, type:%d", 600 tf_dir_2_str(parms->dir), 601 parms->starting_idx, 602 parms->num_entries, 603 parms->type); 604 return rc; 605 } 606 607 hparms.rm_db = tbl_db[parms->dir]; 608 hparms.db_index = parms->type; 609 hparms.hcapi_type = &hcapi_type; 610 rc = tf_rm_get_hcapi_type(&hparms); 611 if (rc) { 612 TFP_DRV_LOG(ERR, 613 "%s, Failed type lookup, type:%d, rc:%s\n", 614 tf_dir_2_str(parms->dir), 615 parms->type, 616 strerror(-rc)); 617 return rc; 618 } 619 620 /* Get the entries */ 621 rc = tf_msg_bulk_get_tbl_entry(tfp, 622 parms->dir, 623 hcapi_type, 624 parms->starting_idx, 625 parms->num_entries, 626 parms->entry_sz_in_bytes, 627 parms->physical_mem_addr); 628 if (rc) { 629 TFP_DRV_LOG(ERR, 630 "%s, Bulk get failed, type:%d, rc:%s\n", 631 tf_dir_2_str(parms->dir), 632 parms->type, 633 strerror(-rc)); 634 } 635 636 return rc; 637 } 638